hier.7: Explain /lib and /libexec. Remove /usr/libexec/sendmail.
[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
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
198static UINT32
199AnMapEtypeToBtype (
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
300void
301AnFormatBtype (
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
368UINT32
369AnGetBtype (
370 ACPI_PARSE_OBJECT *Op)
371{
372 ACPI_NAMESPACE_NODE *Node;
373 ACPI_PARSE_OBJECT *ReferencedNode;
374 UINT32 ThisNodeBtype = 0;
375
376
2e2672b8
SW
377 if (!Op)
378 {
379 AcpiOsPrintf ("Null Op in AnGetBtype\n");
380 return (ACPI_UINT32_MAX);
381 }
382
0d02842f
SW
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
458UINT32
459AnMapObjTypeToBtype (
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
545UINT32
546AnMapBtypeToEtype (
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