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 
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     /* 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 
218 static UINT32
219 AnMapEtypeToBtype (
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 
319 void
320 AnFormatBtype (
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 
389 UINT32
390 AnGetBtype (
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 
487 UINT32
488 AnMapObjTypeToBtype (
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 
574 UINT32
575 AnMapBtypeToEtype (
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