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