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 "aslcompiler.h"
45#include "aslcompiler.y.h"
46#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            DbgPrint (ASL_DEBUG_OUTPUT,
412                "No attached Nsnode: [%s] at line %u name [%s], "
413                "ignoring typecheck\n",
414                Op->Asl.ParseOpName, Op->Asl.LineNumber,
415                Op->Asl.ExternalName);
416            return (ACPI_UINT32_MAX);
417        }
418
419        ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
420        if (!ThisNodeBtype)
421        {
422            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
423                "could not map type");
424        }
425
426        if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
427        {
428            ReferencedNode = Node->Op;
429            if (!ReferencedNode)
430            {
431                /* Check for an internal method */
432
433                if (AnIsInternalMethod (Op))
434                {
435                    return (AnGetInternalMethodReturnType (Op));
436                }
437
438                AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
439                    "null Op pointer");
440                return (ACPI_UINT32_MAX);
441            }
442
443            if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
444            {
445                ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
446            }
447            else
448            {
449                return (ACPI_UINT32_MAX -1);
450            }
451        }
452    }
453    else
454    {
455        ThisNodeBtype = Op->Asl.AcpiBtype;
456    }
457
458    return (ThisNodeBtype);
459}
460
461
462/*******************************************************************************
463 *
464 * FUNCTION:    AnMapObjTypeToBtype
465 *
466 * PARAMETERS:  Op                  - A parse node
467 *
468 * RETURN:      A Btype
469 *
470 * DESCRIPTION: Map object to the associated "Btype"
471 *
472 ******************************************************************************/
473
474UINT32
475AnMapObjTypeToBtype (
476    ACPI_PARSE_OBJECT       *Op)
477{
478
479    switch (Op->Asl.ParseOpcode)
480    {
481    case PARSEOP_OBJECTTYPE_BFF:        /* "BuffFieldObj" */
482
483        return (ACPI_BTYPE_BUFFER_FIELD);
484
485    case PARSEOP_OBJECTTYPE_BUF:        /* "BuffObj" */
486
487        return (ACPI_BTYPE_BUFFER);
488
489    case PARSEOP_OBJECTTYPE_DDB:        /* "DDBHandleObj" */
490
491        return (ACPI_BTYPE_DDB_HANDLE);
492
493    case PARSEOP_OBJECTTYPE_DEV:        /* "DeviceObj" */
494
495        return (ACPI_BTYPE_DEVICE);
496
497    case PARSEOP_OBJECTTYPE_EVT:        /* "EventObj" */
498
499        return (ACPI_BTYPE_EVENT);
500
501    case PARSEOP_OBJECTTYPE_FLD:        /* "FieldUnitObj" */
502
503        return (ACPI_BTYPE_FIELD_UNIT);
504
505    case PARSEOP_OBJECTTYPE_INT:        /* "IntObj" */
506
507        return (ACPI_BTYPE_INTEGER);
508
509    case PARSEOP_OBJECTTYPE_MTH:        /* "MethodObj" */
510
511        return (ACPI_BTYPE_METHOD);
512
513    case PARSEOP_OBJECTTYPE_MTX:        /* "MutexObj" */
514
515        return (ACPI_BTYPE_MUTEX);
516
517    case PARSEOP_OBJECTTYPE_OPR:        /* "OpRegionObj" */
518
519        return (ACPI_BTYPE_REGION);
520
521    case PARSEOP_OBJECTTYPE_PKG:        /* "PkgObj" */
522
523        return (ACPI_BTYPE_PACKAGE);
524
525    case PARSEOP_OBJECTTYPE_POW:        /* "PowerResObj" */
526
527        return (ACPI_BTYPE_POWER);
528
529    case PARSEOP_OBJECTTYPE_STR:        /* "StrObj" */
530
531        return (ACPI_BTYPE_STRING);
532
533    case PARSEOP_OBJECTTYPE_THZ:        /* "ThermalZoneObj" */
534
535        return (ACPI_BTYPE_THERMAL);
536
537    case PARSEOP_OBJECTTYPE_UNK:        /* "UnknownObj" */
538
539        return (ACPI_BTYPE_OBJECTS_AND_REFS);
540
541    default:
542
543        return (0);
544    }
545}
546
547
548#ifdef ACPI_OBSOLETE_FUNCTIONS
549/*******************************************************************************
550 *
551 * FUNCTION:    AnMapBtypeToEtype
552 *
553 * PARAMETERS:  Btype               - Bitfield of ACPI types
554 *
555 * RETURN:      The Etype corresponding the the Btype
556 *
557 * DESCRIPTION: Convert a bitfield type to an encoded type
558 *
559 ******************************************************************************/
560
561UINT32
562AnMapBtypeToEtype (
563    UINT32              Btype)
564{
565    UINT32              i;
566    UINT32              Etype;
567
568
569    if (Btype == 0)
570    {
571        return (0);
572    }
573
574    Etype = 1;
575    for (i = 1; i < Btype; i *= 2)
576    {
577        Etype++;
578    }
579
580    return (Etype);
581}
582#endif
583