Sync ACPICA with Intel's version 20150930.
[dragonfly.git] / sys / contrib / dev / acpica / source / compiler / aslbtypes.c
CommitLineData
0d02842f
SW
1/******************************************************************************
2 *
3 * Module Name: aslbtypes - Support for bitfield types
4 *
5 *****************************************************************************/
6
7/*
fe7b5cb4 8 * Copyright (C) 2000 - 2015, Intel Corp.
0d02842f
SW
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
0d02842f
SW
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
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
c6400d37
SW
103 * ACPI_BTYPE_REFERENCE_OBJECT:
104 * Index reference as parameter of Load/Unload
0d02842f 105 */
c6400d37 106 return (ACPI_BTYPE_DDB_HANDLE | ACPI_BTYPE_REFERENCE_OBJECT);
0d02842f
SW
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
c6400d37 137 return (ACPI_BTYPE_NAMED_REFERENCE); /* Name or Namestring */
0d02842f
SW
138
139 case ARGI_TARGETREF:
c6400d37
SW
140
141 /*
142 * Target operand for most math and logic operators.
143 * Package objects not allowed as target.
144 */
145 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DEBUG_OBJECT |
146 ACPI_BTYPE_REFERENCE_OBJECT);
147
148 case ARGI_STORE_TARGET:
149
150 /* Special target for Store(), includes packages */
151
152 return (ACPI_BTYPE_DATA | ACPI_BTYPE_DEBUG_OBJECT |
153 ACPI_BTYPE_REFERENCE_OBJECT);
154
0d02842f
SW
155 case ARGI_FIXED_TARGET:
156 case ARGI_SIMPLE_TARGET:
157
158 return (ACPI_BTYPE_OBJECTS_AND_REFS);
159
160 /* Complex types */
161
162 case ARGI_DATAOBJECT:
163 /*
164 * Buffer, string, package or reference to a Op -
165 * Used only by SizeOf operator
166 */
167 return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
c6400d37 168 ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE_OBJECT);
0d02842f
SW
169
170 case ARGI_COMPLEXOBJ:
171
172 /* Buffer, String, or package */
173
c6400d37
SW
174 return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
175 ACPI_BTYPE_PACKAGE);
0d02842f
SW
176
177 case ARGI_REF_OR_STRING:
178
c6400d37
SW
179 /* Used by DeRefOf operator only */
180
181 return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE_OBJECT);
0d02842f
SW
182
183 case ARGI_REGION_OR_BUFFER:
184
185 /* Used by Load() only. Allow buffers in addition to regions/fields */
186
c6400d37
SW
187 return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER |
188 ACPI_BTYPE_FIELD_UNIT);
0d02842f
SW
189
190 case ARGI_DATAREFOBJ:
191
c6400d37
SW
192 /* Used by Store() only, as the source operand */
193
194 return (ACPI_BTYPE_DATA_REFERENCE | ACPI_BTYPE_REFERENCE_OBJECT);
0d02842f
SW
195
196 default:
197
198 break;
199 }
200
201 return (ACPI_BTYPE_OBJECTS_AND_REFS);
202}
203
204
205/*******************************************************************************
206 *
207 * FUNCTION: AnMapEtypeToBtype
208 *
209 * PARAMETERS: Etype - Encoded ACPI Type
210 *
211 * RETURN: Btype corresponding to the Etype
212 *
213 * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
214 * operand conversion rules. In other words, returns the type(s)
215 * this Etype is implicitly converted to during interpretation.
216 *
217 ******************************************************************************/
218
219static UINT32
220AnMapEtypeToBtype (
221 UINT32 Etype)
222{
223
224
225 if (Etype == ACPI_TYPE_ANY)
226 {
227 return (ACPI_BTYPE_OBJECTS_AND_REFS);
228 }
229
230 /* Try the standard ACPI data types */
231
232 if (Etype <= ACPI_TYPE_EXTERNAL_MAX)
233 {
234 /*
235 * This switch statement implements the allowed operand conversion
236 * rules as per the "ASL Data Types" section of the ACPI
237 * specification.
238 */
239 switch (Etype)
240 {
241 case ACPI_TYPE_INTEGER:
242
243 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE);
244
245 case ACPI_TYPE_STRING:
246 case ACPI_TYPE_BUFFER:
247
248 return (ACPI_BTYPE_COMPUTE_DATA);
249
250 case ACPI_TYPE_PACKAGE:
251
252 return (ACPI_BTYPE_PACKAGE);
253
254 case ACPI_TYPE_FIELD_UNIT:
255
256 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
257
258 case ACPI_TYPE_BUFFER_FIELD:
259
260 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD);
261
262 case ACPI_TYPE_DDB_HANDLE:
263
264 return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE);
265
266 case ACPI_TYPE_DEBUG_OBJECT:
267
268 /* Cannot be used as a source operand */
269
270 return (0);
271
272 default:
273
274 return (1 << (Etype - 1));
275 }
276 }
277
278 /* Try the internal data types */
279
280 switch (Etype)
281 {
282 case ACPI_TYPE_LOCAL_REGION_FIELD:
283 case ACPI_TYPE_LOCAL_BANK_FIELD:
284 case ACPI_TYPE_LOCAL_INDEX_FIELD:
285
286 /* Named fields can be either Integer/Buffer/String */
287
288 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
289
290 case ACPI_TYPE_LOCAL_ALIAS:
291
292 return (ACPI_BTYPE_INTEGER);
293
294
295 case ACPI_TYPE_LOCAL_RESOURCE:
296 case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
297
c6400d37 298 return (ACPI_BTYPE_REFERENCE_OBJECT);
0d02842f
SW
299
300 default:
301
302 printf ("Unhandled encoded type: %X\n", Etype);
303 return (0);
304 }
305}
306
307
308/*******************************************************************************
309 *
310 * FUNCTION: AnFormatBtype
311 *
312 * PARAMETERS: Btype - Bitfield of ACPI types
313 * Buffer - Where to put the ascii string
314 *
315 * RETURN: None.
316 *
317 * DESCRIPTION: Convert a Btype to a string of ACPI types
318 *
319 ******************************************************************************/
320
321void
322AnFormatBtype (
323 char *Buffer,
324 UINT32 Btype)
325{
326 UINT32 Type;
327 BOOLEAN First = TRUE;
328
329
330 *Buffer = 0;
331
332 if (Btype == 0)
333 {
334 strcat (Buffer, "NoReturnValue");
335 return;
336 }
337
338 for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++)
339 {
340 if (Btype & 0x00000001)
341 {
342 if (!First)
343 {
344 strcat (Buffer, "|");
345 }
346 First = FALSE;
347 strcat (Buffer, AcpiUtGetTypeName (Type));
348 }
349 Btype >>= 1;
350 }
351
352 if (Btype & 0x00000001)
353 {
354 if (!First)
355 {
356 strcat (Buffer, "|");
357 }
358 First = FALSE;
359 strcat (Buffer, "Reference");
360 }
361
362 Btype >>= 1;
363 if (Btype & 0x00000001)
364 {
365 if (!First)
366 {
367 strcat (Buffer, "|");
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
2e2672b8
SW
398 if (!Op)
399 {
400 AcpiOsPrintf ("Null Op in AnGetBtype\n");
401 return (ACPI_UINT32_MAX);
402 }
403
0d02842f
SW
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], ignoring typecheck\n",
413 Op->Asl.ParseOpName, Op->Asl.LineNumber,
414 Op->Asl.ExternalName);
415 return (ACPI_UINT32_MAX);
416 }
417
418 ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
419 if (!ThisNodeBtype)
420 {
421 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
422 "could not map type");
423 }
424
0d02842f
SW
425 if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
426 {
427 ReferencedNode = Node->Op;
428 if (!ReferencedNode)
429 {
430 /* Check for an internal method */
431
432 if (AnIsInternalMethod (Op))
433 {
434 return (AnGetInternalMethodReturnType (Op));
435 }
436
437 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
438 "null Op pointer");
439 return (ACPI_UINT32_MAX);
440 }
441
442 if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
443 {
444 ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
445 }
446 else
447 {
448 return (ACPI_UINT32_MAX -1);
449 }
450 }
451 }
452 else
453 {
454 ThisNodeBtype = Op->Asl.AcpiBtype;
455 }
456
457 return (ThisNodeBtype);
458}
459
0d02842f
SW
460/*******************************************************************************
461 *
462 * FUNCTION: AnMapObjTypeToBtype
463 *
464 * PARAMETERS: Op - A parse node
465 *
466 * RETURN: A Btype
467 *
468 * DESCRIPTION: Map object to the associated "Btype"
469 *
470 ******************************************************************************/
471
472UINT32
473AnMapObjTypeToBtype (
474 ACPI_PARSE_OBJECT *Op)
475{
476
477 switch (Op->Asl.ParseOpcode)
478 {
479 case PARSEOP_OBJECTTYPE_BFF: /* "BuffFieldObj" */
480
481 return (ACPI_BTYPE_BUFFER_FIELD);
482
483 case PARSEOP_OBJECTTYPE_BUF: /* "BuffObj" */
484
485 return (ACPI_BTYPE_BUFFER);
486
487 case PARSEOP_OBJECTTYPE_DDB: /* "DDBHandleObj" */
488
489 return (ACPI_BTYPE_DDB_HANDLE);
490
491 case PARSEOP_OBJECTTYPE_DEV: /* "DeviceObj" */
492
493 return (ACPI_BTYPE_DEVICE);
494
495 case PARSEOP_OBJECTTYPE_EVT: /* "EventObj" */
496
497 return (ACPI_BTYPE_EVENT);
498
499 case PARSEOP_OBJECTTYPE_FLD: /* "FieldUnitObj" */
500
501 return (ACPI_BTYPE_FIELD_UNIT);
502
503 case PARSEOP_OBJECTTYPE_INT: /* "IntObj" */
504
505 return (ACPI_BTYPE_INTEGER);
506
507 case PARSEOP_OBJECTTYPE_MTH: /* "MethodObj" */
508
509 return (ACPI_BTYPE_METHOD);
510
511 case PARSEOP_OBJECTTYPE_MTX: /* "MutexObj" */
512
513 return (ACPI_BTYPE_MUTEX);
514
515 case PARSEOP_OBJECTTYPE_OPR: /* "OpRegionObj" */
516
517 return (ACPI_BTYPE_REGION);
518
519 case PARSEOP_OBJECTTYPE_PKG: /* "PkgObj" */
520
521 return (ACPI_BTYPE_PACKAGE);
522
523 case PARSEOP_OBJECTTYPE_POW: /* "PowerResObj" */
524
525 return (ACPI_BTYPE_POWER);
526
527 case PARSEOP_OBJECTTYPE_STR: /* "StrObj" */
528
529 return (ACPI_BTYPE_STRING);
530
531 case PARSEOP_OBJECTTYPE_THZ: /* "ThermalZoneObj" */
532
533 return (ACPI_BTYPE_THERMAL);
534
535 case PARSEOP_OBJECTTYPE_UNK: /* "UnknownObj" */
536
537 return (ACPI_BTYPE_OBJECTS_AND_REFS);
538
539 default:
540
541 return (0);
542 }
543}
544
545
546#ifdef ACPI_OBSOLETE_FUNCTIONS
547/*******************************************************************************
548 *
549 * FUNCTION: AnMapBtypeToEtype
550 *
551 * PARAMETERS: Btype - Bitfield of ACPI types
552 *
553 * RETURN: The Etype corresponding the the Btype
554 *
555 * DESCRIPTION: Convert a bitfield type to an encoded type
556 *
557 ******************************************************************************/
558
559UINT32
560AnMapBtypeToEtype (
561 UINT32 Btype)
562{
563 UINT32 i;
564 UINT32 Etype;
565
566
567 if (Btype == 0)
568 {
569 return (0);
570 }
571
572 Etype = 1;
573 for (i = 1; i < Btype; i *= 2)
574 {
575 Etype++;
576 }
577
578 return (Etype);
579}
580#endif