1 /******************************************************************************
2 *
3 * Module Name: aslbtypes - Support for bitfield types
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2022, 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 MERCHANTABILITY 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
AnMapArgTypeToBtype(UINT32 ArgType)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
AnMapEtypeToBtype(UINT32 Etype)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
AnFormatBtype(char * Buffer,UINT32 Btype)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 strcat (Buffer, "Resource");
370 }
371 }
372
373
374 /*******************************************************************************
375 *
376 * FUNCTION: AnGetBtype
377 *
378 * PARAMETERS: Op - Parse node whose type will be returned.
379 *
380 * RETURN: The Btype associated with the Op.
381 *
382 * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node.
383 * Handles the case where the node is a name or method call and
384 * the actual type must be obtained from the namespace node.
385 *
386 ******************************************************************************/
387
388 UINT32
AnGetBtype(ACPI_PARSE_OBJECT * Op)389 AnGetBtype (
390 ACPI_PARSE_OBJECT *Op)
391 {
392 ACPI_NAMESPACE_NODE *Node;
393 ACPI_PARSE_OBJECT *ReferencedNode;
394 UINT32 ThisNodeBtype = 0;
395
396
397 if (!Op)
398 {
399 AcpiOsPrintf ("Null Op in AnGetBtype\n");
400 return (ACPI_UINT32_MAX);
401 }
402
403 if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
404 (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) ||
405 (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
406 {
407 Node = Op->Asl.Node;
408 if (!Node)
409 {
410 /* These are not expected to have a node at this time */
411
412 if ((Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEWORDFIELD) ||
413 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEDWORDFIELD) ||
414 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEQWORDFIELD) ||
415 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEBYTEFIELD) ||
416 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEBITFIELD) ||
417 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CREATEFIELD) ||
418 (Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CONDREFOF))
419 {
420 return (ACPI_UINT32_MAX - 1);
421 }
422
423 DbgPrint (ASL_DEBUG_OUTPUT,
424 "No attached Nsnode: [%s] at line %u name [%s], "
425 "ignoring typecheck. Parent [%s]\n",
426 Op->Asl.ParseOpName, Op->Asl.LineNumber,
427 Op->Asl.ExternalName, Op->Asl.Parent->Asl.ParseOpName);
428 return (ACPI_UINT32_MAX - 1);
429 }
430
431 ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
432 if (!ThisNodeBtype)
433 {
434 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
435 "could not map type");
436 }
437
438 if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
439 {
440 ReferencedNode = Node->Op;
441 if (!ReferencedNode)
442 {
443 /* Check for an internal method */
444
445 if (AnIsInternalMethod (Op))
446 {
447 return (AnGetInternalMethodReturnType (Op));
448 }
449
450 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
451 "null Op pointer");
452 return (ACPI_UINT32_MAX);
453 }
454
455 if (ReferencedNode->Asl.CompileFlags & OP_METHOD_TYPED)
456 {
457 ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
458 }
459 else
460 {
461 return (ACPI_UINT32_MAX -1);
462 }
463 }
464 }
465 else
466 {
467 ThisNodeBtype = Op->Asl.AcpiBtype;
468 }
469
470 return (ThisNodeBtype);
471 }
472
473
474 /*******************************************************************************
475 *
476 * FUNCTION: AnMapObjTypeToBtype
477 *
478 * PARAMETERS: Op - A parse node
479 *
480 * RETURN: A Btype
481 *
482 * DESCRIPTION: Map object to the associated "Btype"
483 *
484 ******************************************************************************/
485
486 UINT32
AnMapObjTypeToBtype(ACPI_PARSE_OBJECT * Op)487 AnMapObjTypeToBtype (
488 ACPI_PARSE_OBJECT *Op)
489 {
490
491 switch (Op->Asl.ParseOpcode)
492 {
493 case PARSEOP_OBJECTTYPE_BFF: /* "BuffFieldObj" */
494
495 return (ACPI_BTYPE_BUFFER_FIELD);
496
497 case PARSEOP_OBJECTTYPE_BUF: /* "BuffObj" */
498
499 return (ACPI_BTYPE_BUFFER);
500
501 case PARSEOP_OBJECTTYPE_DDB: /* "DDBHandleObj" */
502
503 return (ACPI_BTYPE_DDB_HANDLE);
504
505 case PARSEOP_OBJECTTYPE_DEV: /* "DeviceObj" */
506
507 return (ACPI_BTYPE_DEVICE);
508
509 case PARSEOP_OBJECTTYPE_EVT: /* "EventObj" */
510
511 return (ACPI_BTYPE_EVENT);
512
513 case PARSEOP_OBJECTTYPE_FLD: /* "FieldUnitObj" */
514
515 return (ACPI_BTYPE_FIELD_UNIT);
516
517 case PARSEOP_OBJECTTYPE_INT: /* "IntObj" */
518
519 return (ACPI_BTYPE_INTEGER);
520
521 case PARSEOP_OBJECTTYPE_MTH: /* "MethodObj" */
522
523 return (ACPI_BTYPE_METHOD);
524
525 case PARSEOP_OBJECTTYPE_MTX: /* "MutexObj" */
526
527 return (ACPI_BTYPE_MUTEX);
528
529 case PARSEOP_OBJECTTYPE_OPR: /* "OpRegionObj" */
530
531 return (ACPI_BTYPE_REGION);
532
533 case PARSEOP_OBJECTTYPE_PKG: /* "PkgObj" */
534
535 return (ACPI_BTYPE_PACKAGE);
536
537 case PARSEOP_OBJECTTYPE_POW: /* "PowerResObj" */
538
539 return (ACPI_BTYPE_POWER);
540
541 case PARSEOP_OBJECTTYPE_STR: /* "StrObj" */
542
543 return (ACPI_BTYPE_STRING);
544
545 case PARSEOP_OBJECTTYPE_THZ: /* "ThermalZoneObj" */
546
547 return (ACPI_BTYPE_THERMAL);
548
549 case PARSEOP_OBJECTTYPE_UNK: /* "UnknownObj" */
550
551 return (ACPI_BTYPE_OBJECTS_AND_REFS);
552
553 default:
554
555 return (0);
556 }
557 }
558
559
560 #ifdef ACPI_OBSOLETE_FUNCTIONS
561 /*******************************************************************************
562 *
563 * FUNCTION: AnMapBtypeToEtype
564 *
565 * PARAMETERS: Btype - Bitfield of ACPI types
566 *
567 * RETURN: The Etype corresponding the Btype
568 *
569 * DESCRIPTION: Convert a bitfield type to an encoded type
570 *
571 ******************************************************************************/
572
573 UINT32
AnMapBtypeToEtype(UINT32 Btype)574 AnMapBtypeToEtype (
575 UINT32 Btype)
576 {
577 UINT32 i;
578 UINT32 Etype;
579
580
581 if (Btype == 0)
582 {
583 return (0);
584 }
585
586 Etype = 1;
587 for (i = 1; i < Btype; i *= 2)
588 {
589 Etype++;
590 }
591
592 return (Etype);
593 }
594 #endif
595