aslbtypes.c revision 306536 
1/******************************************************************************
2 *
3 * Module Name: aslbtypes - Support for bitfield types
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <contrib/dev/acpica/compiler/aslcompiler.h>
45#include "aslcompiler.y.h"
46#include <contrib/dev/acpica/include/amlcode.h>
47
48
49#define _COMPONENT          ACPI_COMPILER
50        ACPI_MODULE_NAME    ("aslbtypes")
51
52/* Local prototypes */
53
54static UINT32
55AnMapEtypeToBtype (
56    UINT32                  Etype);
57
58
59/*******************************************************************************
60 *
61 * FUNCTION:    AnMapArgTypeToBtype
62 *
63 * PARAMETERS:  ArgType             - The ARGI required type(s) for this
64 *                                    argument, from the opcode info table
65 *
66 * RETURN:      The corresponding Bit-encoded types
67 *
68 * DESCRIPTION: Convert an encoded ARGI required argument type code into a
69 *              bitfield type code. Implements the implicit source conversion
70 *              rules.
71 *
72 ******************************************************************************/
73
74UINT32
75AnMapArgTypeToBtype (
76    UINT32                  ArgType)
77{
78
79    switch (ArgType)
80    {
81    /* Simple types */
82
83    case ARGI_ANYTYPE:
84
85        return (ACPI_BTYPE_OBJECTS_AND_REFS);
86
87    case ARGI_PACKAGE:
88
89        return (ACPI_BTYPE_PACKAGE);
90
91    case ARGI_EVENT:
92
93        return (ACPI_BTYPE_EVENT);
94
95    case ARGI_MUTEX:
96
97        return (ACPI_BTYPE_MUTEX);
98
99    case ARGI_DDBHANDLE:
100        /*
101         * DDBHandleObject := SuperName
102         * ACPI_BTYPE_REFERENCE_OBJECT:
103         *      Index reference as parameter of Load/Unload
104         */
105        return (ACPI_BTYPE_DDB_HANDLE | ACPI_BTYPE_REFERENCE_OBJECT);
106
107    /* Interchangeable types */
108    /*
109     * Source conversion rules:
110     * Integer, String, and Buffer are all interchangeable
111     */
112    case ARGI_INTEGER:
113    case ARGI_STRING:
114    case ARGI_BUFFER:
115    case ARGI_BUFFER_OR_STRING:
116    case ARGI_COMPUTEDATA:
117
118        return (ACPI_BTYPE_COMPUTE_DATA);
119
120    /* References */
121
122    case ARGI_INTEGER_REF:
123
124        return (ACPI_BTYPE_INTEGER);
125
126    case ARGI_OBJECT_REF:
127
128        return (ACPI_BTYPE_ALL_OBJECTS);
129
130    case ARGI_DEVICE_REF:
131
132        return (ACPI_BTYPE_DEVICE_OBJECTS);
133
134    case ARGI_REFERENCE:
135
136        return (ACPI_BTYPE_NAMED_REFERENCE); /* Name or Namestring */
137
138    case ARGI_TARGETREF:
139
140        /*
141         * Target operand for most math and logic operators.
142         * Package objects not allowed as target.
143         */
144        return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DEBUG_OBJECT |
145            ACPI_BTYPE_REFERENCE_OBJECT);
146
147    case ARGI_STORE_TARGET:
148
149        /* Special target for Store(), includes packages */
150
151        return (ACPI_BTYPE_DATA | ACPI_BTYPE_DEBUG_OBJECT |
152            ACPI_BTYPE_REFERENCE_OBJECT);
153
154    case ARGI_FIXED_TARGET:
155    case ARGI_SIMPLE_TARGET:
156
157        return (ACPI_BTYPE_OBJECTS_AND_REFS);
158
159    /* Complex types */
160
161    case ARGI_DATAOBJECT:
162        /*
163         * Buffer, string, package or reference to a Op -
164         * Used only by SizeOf operator
165         */
166        return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
167            ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE_OBJECT);
168
169    case ARGI_COMPLEXOBJ:
170
171        /* Buffer, String, or package */
172
173        return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
174            ACPI_BTYPE_PACKAGE);
175
176    case ARGI_REF_OR_STRING:
177
178        /* Used by DeRefOf operator only */
179
180        return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE_OBJECT);
181
182    case ARGI_REGION_OR_BUFFER:
183
184        /* Used by Load() only. Allow buffers in addition to regions/fields */
185
186        return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER |
187            ACPI_BTYPE_FIELD_UNIT);
188
189    case ARGI_DATAREFOBJ:
190
191        /* Used by Store() only, as the source operand */
192
193        return (ACPI_BTYPE_DATA_REFERENCE | ACPI_BTYPE_REFERENCE_OBJECT);
194
195    default:
196
197        break;
198    }
199
200    return (ACPI_BTYPE_OBJECTS_AND_REFS);
201}
202
203
204/*******************************************************************************
205 *
206 * FUNCTION:    AnMapEtypeToBtype
207 *
208 * PARAMETERS:  Etype               - Encoded ACPI Type
209 *
210 * RETURN:      Btype corresponding to the Etype
211 *
212 * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
213 *              operand conversion rules. In other words, returns the type(s)
214 *              this Etype is implicitly converted to during interpretation.
215 *
216 ******************************************************************************/
217
218static UINT32
219AnMapEtypeToBtype (
220    UINT32                  Etype)
221{
222
223    if (Etype == ACPI_TYPE_ANY)
224    {
225        return (ACPI_BTYPE_OBJECTS_AND_REFS);
226    }
227
228    /* Try the standard ACPI data types */
229
230    if (Etype <= ACPI_TYPE_EXTERNAL_MAX)
231    {
232        /*
233         * This switch statement implements the allowed operand conversion
234         * rules as per the "ASL Data Types" section of the ACPI
235         * specification.
236         */
237        switch (Etype)
238        {
239        case ACPI_TYPE_INTEGER:
240
241            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE);
242
243        case ACPI_TYPE_STRING:
244        case ACPI_TYPE_BUFFER:
245
246            return (ACPI_BTYPE_COMPUTE_DATA);
247
248        case ACPI_TYPE_PACKAGE:
249
250            return (ACPI_BTYPE_PACKAGE);
251
252        case ACPI_TYPE_FIELD_UNIT:
253
254            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
255
256        case ACPI_TYPE_BUFFER_FIELD:
257
258            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD);
259
260        case ACPI_TYPE_DDB_HANDLE:
261
262            return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE);
263
264        case ACPI_TYPE_DEBUG_OBJECT:
265
266            /* Cannot be used as a source operand */
267
268            return (0);
269
270        default:
271
272            return (1 << (Etype - 1));
273        }
274    }
275
276    /* Try the internal data types */
277
278    switch (Etype)
279    {
280    case ACPI_TYPE_LOCAL_REGION_FIELD:
281    case ACPI_TYPE_LOCAL_BANK_FIELD:
282    case ACPI_TYPE_LOCAL_INDEX_FIELD:
283
284        /* Named fields can be either Integer/Buffer/String */
285
286        return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
287
288    case ACPI_TYPE_LOCAL_ALIAS:
289
290        return (ACPI_BTYPE_INTEGER);
291
292
293    case ACPI_TYPE_LOCAL_RESOURCE:
294    case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
295
296        return (ACPI_BTYPE_REFERENCE_OBJECT);
297
298    default:
299
300        printf ("Unhandled encoded type: %X\n", Etype);
301        return (0);
302    }
303}
304
305
306/*******************************************************************************
307 *
308 * FUNCTION:    AnFormatBtype
309 *
310 * PARAMETERS:  Btype               - Bitfield of ACPI types
311 *              Buffer              - Where to put the ascii string
312 *
313 * RETURN:      None.
314 *
315 * DESCRIPTION: Convert a Btype to a string of ACPI types
316 *
317 ******************************************************************************/
318
319void
320AnFormatBtype (
321    char                    *Buffer,
322    UINT32                  Btype)
323{
324    UINT32                  Type;
325    BOOLEAN                 First = TRUE;
326
327
328    *Buffer = 0;
329    if (Btype == 0)
330    {
331        strcat (Buffer, "NoReturnValue");
332        return;
333    }
334
335    for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++)
336    {
337        if (Btype & 0x00000001)
338        {
339            if (!First)
340            {
341                strcat (Buffer, "|");
342            }
343
344            First = FALSE;
345            strcat (Buffer, AcpiUtGetTypeName (Type));
346        }
347        Btype >>= 1;
348    }
349
350    if (Btype & 0x00000001)
351    {
352        if (!First)
353        {
354            strcat (Buffer, "|");
355        }
356
357        First = FALSE;
358        strcat (Buffer, "Reference");
359    }
360
361    Btype >>= 1;
362    if (Btype & 0x00000001)
363    {
364        if (!First)
365        {
366            strcat (Buffer, "|");
367        }
368
369        First = FALSE;
370        strcat (Buffer, "Resource");
371    }
372}
373
374
375/*******************************************************************************
376 *
377 * FUNCTION:    AnGetBtype
378 *
379 * PARAMETERS:  Op                  - Parse node whose type will be returned.
380 *
381 * RETURN:      The Btype associated with the Op.
382 *
383 * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node.
384 *              Handles the case where the node is a name or method call and
385 *              the actual type must be obtained from the namespace node.
386 *
387 ******************************************************************************/
388
389UINT32
390AnGetBtype (
391    ACPI_PARSE_OBJECT       *Op)
392{
393    ACPI_NAMESPACE_NODE     *Node;
394    ACPI_PARSE_OBJECT       *ReferencedNode;
395    UINT32                  ThisNodeBtype = 0;
396
397
398    if (!Op)
399    {
400        AcpiOsPrintf ("Null Op in AnGetBtype\n");
401        return (ACPI_UINT32_MAX);
402    }
403
404    if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG)     ||
405        (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING)  ||
406        (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
407    {
408        Node = Op->Asl.Node;
409        if (!Node)
410        {
411            /* These are not expected to have a node at this time */
412
413            if ((Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEWORDFIELD) ||
414                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEDWORDFIELD) ||
415                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEQWORDFIELD) ||
416                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEBYTEFIELD) ||
417                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEBITFIELD) ||
418                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEFIELD)    ||
419                (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CONDREFOF))
420            {
421                return (ACPI_UINT32_MAX - 1);
422            }
423
424            DbgPrint (ASL_DEBUG_OUTPUT,
425                "No attached Nsnode: [%s] at line %u name [%s], "
426                "ignoring typecheck. Parent [%s]\n",
427                Op->Asl.ParseOpName, Op->Asl.LineNumber,
428                Op->Asl.ExternalName, Op->Asl.Parent->Asl.ParseOpName);
429            return (ACPI_UINT32_MAX - 1);
430        }
431
432        ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
433        if (!ThisNodeBtype)
434        {
435            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
436                "could not map type");
437        }
438
439        if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
440        {
441            ReferencedNode = Node->Op;
442            if (!ReferencedNode)
443            {
444                /* Check for an internal method */
445
446                if (AnIsInternalMethod (Op))
447                {
448                    return (AnGetInternalMethodReturnType (Op));
449                }
450
451                AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
452                    "null Op pointer");
453                return (ACPI_UINT32_MAX);
454            }
455
456            if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
457            {
458                ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
459            }
460            else
461            {
462                return (ACPI_UINT32_MAX -1);
463            }
464        }
465    }
466    else
467    {
468        ThisNodeBtype = Op->Asl.AcpiBtype;
469    }
470
471    return (ThisNodeBtype);
472}
473
474
475/*******************************************************************************
476 *
477 * FUNCTION:    AnMapObjTypeToBtype
478 *
479 * PARAMETERS:  Op                  - A parse node
480 *
481 * RETURN:      A Btype
482 *
483 * DESCRIPTION: Map object to the associated "Btype"
484 *
485 ******************************************************************************/
486
487UINT32
488AnMapObjTypeToBtype (
489    ACPI_PARSE_OBJECT       *Op)
490{
491
492    switch (Op->Asl.ParseOpcode)
493    {
494    case PARSEOP_OBJECTTYPE_BFF:        /* "BuffFieldObj" */
495
496        return (ACPI_BTYPE_BUFFER_FIELD);
497
498    case PARSEOP_OBJECTTYPE_BUF:        /* "BuffObj" */
499
500        return (ACPI_BTYPE_BUFFER);
501
502    case PARSEOP_OBJECTTYPE_DDB:        /* "DDBHandleObj" */
503
504        return (ACPI_BTYPE_DDB_HANDLE);
505
506    case PARSEOP_OBJECTTYPE_DEV:        /* "DeviceObj" */
507
508        return (ACPI_BTYPE_DEVICE);
509
510    case PARSEOP_OBJECTTYPE_EVT:        /* "EventObj" */
511
512        return (ACPI_BTYPE_EVENT);
513
514    case PARSEOP_OBJECTTYPE_FLD:        /* "FieldUnitObj" */
515
516        return (ACPI_BTYPE_FIELD_UNIT);
517
518    case PARSEOP_OBJECTTYPE_INT:        /* "IntObj" */
519
520        return (ACPI_BTYPE_INTEGER);
521
522    case PARSEOP_OBJECTTYPE_MTH:        /* "MethodObj" */
523
524        return (ACPI_BTYPE_METHOD);
525
526    case PARSEOP_OBJECTTYPE_MTX:        /* "MutexObj" */
527
528        return (ACPI_BTYPE_MUTEX);
529
530    case PARSEOP_OBJECTTYPE_OPR:        /* "OpRegionObj" */
531
532        return (ACPI_BTYPE_REGION);
533
534    case PARSEOP_OBJECTTYPE_PKG:        /* "PkgObj" */
535
536        return (ACPI_BTYPE_PACKAGE);
537
538    case PARSEOP_OBJECTTYPE_POW:        /* "PowerResObj" */
539
540        return (ACPI_BTYPE_POWER);
541
542    case PARSEOP_OBJECTTYPE_STR:        /* "StrObj" */
543
544        return (ACPI_BTYPE_STRING);
545
546    case PARSEOP_OBJECTTYPE_THZ:        /* "ThermalZoneObj" */
547
548        return (ACPI_BTYPE_THERMAL);
549
550    case PARSEOP_OBJECTTYPE_UNK:        /* "UnknownObj" */
551
552        return (ACPI_BTYPE_OBJECTS_AND_REFS);
553
554    default:
555
556        return (0);
557    }
558}
559
560
561#ifdef ACPI_OBSOLETE_FUNCTIONS
562/*******************************************************************************
563 *
564 * FUNCTION:    AnMapBtypeToEtype
565 *
566 * PARAMETERS:  Btype               - Bitfield of ACPI types
567 *
568 * RETURN:      The Etype corresponding the the Btype
569 *
570 * DESCRIPTION: Convert a bitfield type to an encoded type
571 *
572 ******************************************************************************/
573
574UINT32
575AnMapBtypeToEtype (
576    UINT32              Btype)
577{
578    UINT32              i;
579    UINT32              Etype;
580
581
582    if (Btype == 0)
583    {
584        return (0);
585    }
586
587    Etype = 1;
588    for (i = 1; i < Btype; i *= 2)
589    {
590        Etype++;
591    }
592
593    return (Etype);
594}
595#endif
596