aslbtypes.c revision 281075 
1/******************************************************************************
2 *
3 * Module Name: aslbtypes - Support for bitfield types
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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
82    /* Simple types */
83
84    case ARGI_ANYTYPE:
85
86        return (ACPI_BTYPE_OBJECTS_AND_REFS);
87
88    case ARGI_PACKAGE:
89
90        return (ACPI_BTYPE_PACKAGE);
91
92    case ARGI_EVENT:
93
94        return (ACPI_BTYPE_EVENT);
95
96    case ARGI_MUTEX:
97
98        return (ACPI_BTYPE_MUTEX);
99
100    case ARGI_DDBHANDLE:
101        /*
102         * DDBHandleObject := SuperName
103         * ACPI_BTYPE_REFERENCE: Index reference as parameter of Load/Unload
104         */
105        return (ACPI_BTYPE_DDB_HANDLE | ACPI_BTYPE_REFERENCE);
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_REFERENCE);
137
138    case ARGI_TARGETREF:
139    case ARGI_FIXED_TARGET:
140    case ARGI_SIMPLE_TARGET:
141
142        return (ACPI_BTYPE_OBJECTS_AND_REFS);
143
144    /* Complex types */
145
146    case ARGI_DATAOBJECT:
147        /*
148         * Buffer, string, package or reference to a Op -
149         * Used only by SizeOf operator
150         */
151        return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
152            ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE);
153
154    case ARGI_COMPLEXOBJ:
155
156        /* Buffer, String, or package */
157
158        return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | ACPI_BTYPE_PACKAGE);
159
160    case ARGI_REF_OR_STRING:
161
162        return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE);
163
164    case ARGI_REGION_OR_BUFFER:
165
166        /* Used by Load() only. Allow buffers in addition to regions/fields */
167
168        return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER | ACPI_BTYPE_FIELD_UNIT);
169
170    case ARGI_DATAREFOBJ:
171
172        return (ACPI_BTYPE_INTEGER |ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
173            ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE | ACPI_BTYPE_DDB_HANDLE);
174
175    default:
176
177        break;
178    }
179
180    return (ACPI_BTYPE_OBJECTS_AND_REFS);
181}
182
183
184/*******************************************************************************
185 *
186 * FUNCTION:    AnMapEtypeToBtype
187 *
188 * PARAMETERS:  Etype               - Encoded ACPI Type
189 *
190 * RETURN:      Btype corresponding to the Etype
191 *
192 * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
193 *              operand conversion rules. In other words, returns the type(s)
194 *              this Etype is implicitly converted to during interpretation.
195 *
196 ******************************************************************************/
197
198static UINT32
199AnMapEtypeToBtype (
200    UINT32                  Etype)
201{
202
203
204    if (Etype == ACPI_TYPE_ANY)
205    {
206        return (ACPI_BTYPE_OBJECTS_AND_REFS);
207    }
208
209    /* Try the standard ACPI data types */
210
211    if (Etype <= ACPI_TYPE_EXTERNAL_MAX)
212    {
213        /*
214         * This switch statement implements the allowed operand conversion
215         * rules as per the "ASL Data Types" section of the ACPI
216         * specification.
217         */
218        switch (Etype)
219        {
220        case ACPI_TYPE_INTEGER:
221
222            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE);
223
224        case ACPI_TYPE_STRING:
225        case ACPI_TYPE_BUFFER:
226
227            return (ACPI_BTYPE_COMPUTE_DATA);
228
229        case ACPI_TYPE_PACKAGE:
230
231            return (ACPI_BTYPE_PACKAGE);
232
233        case ACPI_TYPE_FIELD_UNIT:
234
235            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
236
237        case ACPI_TYPE_BUFFER_FIELD:
238
239            return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD);
240
241        case ACPI_TYPE_DDB_HANDLE:
242
243            return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE);
244
245        case ACPI_TYPE_DEBUG_OBJECT:
246
247            /* Cannot be used as a source operand */
248
249            return (0);
250
251        default:
252
253            return (1 << (Etype - 1));
254        }
255    }
256
257    /* Try the internal data types */
258
259    switch (Etype)
260    {
261    case ACPI_TYPE_LOCAL_REGION_FIELD:
262    case ACPI_TYPE_LOCAL_BANK_FIELD:
263    case ACPI_TYPE_LOCAL_INDEX_FIELD:
264
265        /* Named fields can be either Integer/Buffer/String */
266
267        return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
268
269    case ACPI_TYPE_LOCAL_ALIAS:
270
271        return (ACPI_BTYPE_INTEGER);
272
273
274    case ACPI_TYPE_LOCAL_RESOURCE:
275    case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
276
277        return (ACPI_BTYPE_REFERENCE);
278
279    default:
280
281        printf ("Unhandled encoded type: %X\n", Etype);
282        return (0);
283    }
284}
285
286
287/*******************************************************************************
288 *
289 * FUNCTION:    AnFormatBtype
290 *
291 * PARAMETERS:  Btype               - Bitfield of ACPI types
292 *              Buffer              - Where to put the ascii string
293 *
294 * RETURN:      None.
295 *
296 * DESCRIPTION: Convert a Btype to a string of ACPI types
297 *
298 ******************************************************************************/
299
300void
301AnFormatBtype (
302    char                    *Buffer,
303    UINT32                  Btype)
304{
305    UINT32                  Type;
306    BOOLEAN                 First = TRUE;
307
308
309    *Buffer = 0;
310
311    if (Btype == 0)
312    {
313        strcat (Buffer, "NoReturnValue");
314        return;
315    }
316
317    for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++)
318    {
319        if (Btype & 0x00000001)
320        {
321            if (!First)
322            {
323                strcat (Buffer, "|");
324            }
325            First = FALSE;
326            strcat (Buffer, AcpiUtGetTypeName (Type));
327        }
328        Btype >>= 1;
329    }
330
331    if (Btype & 0x00000001)
332    {
333        if (!First)
334        {
335            strcat (Buffer, "|");
336        }
337        First = FALSE;
338        strcat (Buffer, "Reference");
339    }
340
341    Btype >>= 1;
342    if (Btype & 0x00000001)
343    {
344        if (!First)
345        {
346            strcat (Buffer, "|");
347        }
348        First = FALSE;
349        strcat (Buffer, "Resource");
350    }
351}
352
353
354/*******************************************************************************
355 *
356 * FUNCTION:    AnGetBtype
357 *
358 * PARAMETERS:  Op                  - Parse node whose type will be returned.
359 *
360 * RETURN:      The Btype associated with the Op.
361 *
362 * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node.
363 *              Handles the case where the node is a name or method call and
364 *              the actual type must be obtained from the namespace node.
365 *
366 ******************************************************************************/
367
368UINT32
369AnGetBtype (
370    ACPI_PARSE_OBJECT       *Op)
371{
372    ACPI_NAMESPACE_NODE     *Node;
373    ACPI_PARSE_OBJECT       *ReferencedNode;
374    UINT32                  ThisNodeBtype = 0;
375
376
377    if (!Op)
378    {
379        AcpiOsPrintf ("Null Op in AnGetBtype\n");
380        return (ACPI_UINT32_MAX);
381    }
382
383    if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG)     ||
384        (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING)  ||
385        (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
386    {
387        Node = Op->Asl.Node;
388        if (!Node)
389        {
390            DbgPrint (ASL_DEBUG_OUTPUT,
391                "No attached Nsnode: [%s] at line %u name [%s], ignoring typecheck\n",
392                Op->Asl.ParseOpName, Op->Asl.LineNumber,
393                Op->Asl.ExternalName);
394            return (ACPI_UINT32_MAX);
395        }
396
397        ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
398        if (!ThisNodeBtype)
399        {
400            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
401                "could not map type");
402        }
403
404        /*
405         * Since it was a named reference, enable the
406         * reference bit also
407         */
408        ThisNodeBtype |= ACPI_BTYPE_REFERENCE;
409
410        if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
411        {
412            ReferencedNode = Node->Op;
413            if (!ReferencedNode)
414            {
415                /* Check for an internal method */
416
417                if (AnIsInternalMethod (Op))
418                {
419                    return (AnGetInternalMethodReturnType (Op));
420                }
421
422                AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
423                    "null Op pointer");
424                return (ACPI_UINT32_MAX);
425            }
426
427            if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
428            {
429                ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
430            }
431            else
432            {
433                return (ACPI_UINT32_MAX -1);
434            }
435        }
436    }
437    else
438    {
439        ThisNodeBtype = Op->Asl.AcpiBtype;
440    }
441
442    return (ThisNodeBtype);
443}
444
445
446/*******************************************************************************
447 *
448 * FUNCTION:    AnMapObjTypeToBtype
449 *
450 * PARAMETERS:  Op                  - A parse node
451 *
452 * RETURN:      A Btype
453 *
454 * DESCRIPTION: Map object to the associated "Btype"
455 *
456 ******************************************************************************/
457
458UINT32
459AnMapObjTypeToBtype (
460    ACPI_PARSE_OBJECT       *Op)
461{
462
463    switch (Op->Asl.ParseOpcode)
464    {
465    case PARSEOP_OBJECTTYPE_BFF:        /* "BuffFieldObj" */
466
467        return (ACPI_BTYPE_BUFFER_FIELD);
468
469    case PARSEOP_OBJECTTYPE_BUF:        /* "BuffObj" */
470
471        return (ACPI_BTYPE_BUFFER);
472
473    case PARSEOP_OBJECTTYPE_DDB:        /* "DDBHandleObj" */
474
475        return (ACPI_BTYPE_DDB_HANDLE);
476
477    case PARSEOP_OBJECTTYPE_DEV:        /* "DeviceObj" */
478
479        return (ACPI_BTYPE_DEVICE);
480
481    case PARSEOP_OBJECTTYPE_EVT:        /* "EventObj" */
482
483        return (ACPI_BTYPE_EVENT);
484
485    case PARSEOP_OBJECTTYPE_FLD:        /* "FieldUnitObj" */
486
487        return (ACPI_BTYPE_FIELD_UNIT);
488
489    case PARSEOP_OBJECTTYPE_INT:        /* "IntObj" */
490
491        return (ACPI_BTYPE_INTEGER);
492
493    case PARSEOP_OBJECTTYPE_MTH:        /* "MethodObj" */
494
495        return (ACPI_BTYPE_METHOD);
496
497    case PARSEOP_OBJECTTYPE_MTX:        /* "MutexObj" */
498
499        return (ACPI_BTYPE_MUTEX);
500
501    case PARSEOP_OBJECTTYPE_OPR:        /* "OpRegionObj" */
502
503        return (ACPI_BTYPE_REGION);
504
505    case PARSEOP_OBJECTTYPE_PKG:        /* "PkgObj" */
506
507        return (ACPI_BTYPE_PACKAGE);
508
509    case PARSEOP_OBJECTTYPE_POW:        /* "PowerResObj" */
510
511        return (ACPI_BTYPE_POWER);
512
513    case PARSEOP_OBJECTTYPE_STR:        /* "StrObj" */
514
515        return (ACPI_BTYPE_STRING);
516
517    case PARSEOP_OBJECTTYPE_THZ:        /* "ThermalZoneObj" */
518
519        return (ACPI_BTYPE_THERMAL);
520
521    case PARSEOP_OBJECTTYPE_UNK:        /* "UnknownObj" */
522
523        return (ACPI_BTYPE_OBJECTS_AND_REFS);
524
525    default:
526
527        return (0);
528    }
529}
530
531
532#ifdef ACPI_OBSOLETE_FUNCTIONS
533/*******************************************************************************
534 *
535 * FUNCTION:    AnMapBtypeToEtype
536 *
537 * PARAMETERS:  Btype               - Bitfield of ACPI types
538 *
539 * RETURN:      The Etype corresponding the the Btype
540 *
541 * DESCRIPTION: Convert a bitfield type to an encoded type
542 *
543 ******************************************************************************/
544
545UINT32
546AnMapBtypeToEtype (
547    UINT32              Btype)
548{
549    UINT32              i;
550    UINT32              Etype;
551
552
553    if (Btype == 0)
554    {
555        return (0);
556    }
557
558    Etype = 1;
559    for (i = 1; i < Btype; i *= 2)
560    {
561        Etype++;
562    }
563
564    return (Etype);
565}
566#endif
567