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 "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 
54 static UINT32
55 AnMapEtypeToBtype (
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 
74 UINT32
75 AnMapArgTypeToBtype (
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 
198 static UINT32
199 AnMapEtypeToBtype (
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 
300 void
301 AnFormatBtype (
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 
368 UINT32
369 AnGetBtype (
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 
458 UINT32
459 AnMapObjTypeToBtype (
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 
545 UINT32
546 AnMapBtypeToEtype (
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