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_SIMPLE_TARGET: 155 156 return (ACPI_BTYPE_OBJECTS_AND_REFS); 157 158 /* Complex types */ 159 160 case ARGI_DATAOBJECT: 161 /* 162 * Buffer, string, package or reference to a Op - 163 * Used only by SizeOf operator 164 */ 165 return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | 166 ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE_OBJECT); 167 168 case ARGI_COMPLEXOBJ: 169 170 /* Buffer, String, or package */ 171 172 return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | 173 ACPI_BTYPE_PACKAGE); 174 175 case ARGI_REF_OR_STRING: 176 177 /* Used by DeRefOf operator only */ 178 179 return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE_OBJECT); 180 181 case ARGI_REGION_OR_BUFFER: 182 183 /* Used by Load() only. Allow buffers in addition to regions/fields */ 184 185 return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER | 186 ACPI_BTYPE_FIELD_UNIT); 187 188 case ARGI_DATAREFOBJ: 189 190 /* Used by Store() only, as the source operand */ 191 192 return (ACPI_BTYPE_DATA_REFERENCE | ACPI_BTYPE_REFERENCE_OBJECT); 193 194 default: 195 196 break; 197 } 198 199 return (ACPI_BTYPE_OBJECTS_AND_REFS); 200 } 201 202 203 /******************************************************************************* 204 * 205 * FUNCTION: AnMapEtypeToBtype 206 * 207 * PARAMETERS: Etype - Encoded ACPI Type 208 * 209 * RETURN: Btype corresponding to the Etype 210 * 211 * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the 212 * operand conversion rules. In other words, returns the type(s) 213 * this Etype is implicitly converted to during interpretation. 214 * 215 ******************************************************************************/ 216 217 static UINT32 218 AnMapEtypeToBtype ( 219 UINT32 Etype) 220 { 221 222 if (Etype == ACPI_TYPE_ANY) 223 { 224 return (ACPI_BTYPE_OBJECTS_AND_REFS); 225 } 226 227 /* Try the standard ACPI data types */ 228 229 if (Etype <= ACPI_TYPE_EXTERNAL_MAX) 230 { 231 /* 232 * This switch statement implements the allowed operand conversion 233 * rules as per the "ASL Data Types" section of the ACPI 234 * specification. 235 */ 236 switch (Etype) 237 { 238 case ACPI_TYPE_INTEGER: 239 240 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE); 241 242 case ACPI_TYPE_STRING: 243 case ACPI_TYPE_BUFFER: 244 245 return (ACPI_BTYPE_COMPUTE_DATA); 246 247 case ACPI_TYPE_PACKAGE: 248 249 return (ACPI_BTYPE_PACKAGE); 250 251 case ACPI_TYPE_FIELD_UNIT: 252 253 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT); 254 255 case ACPI_TYPE_BUFFER_FIELD: 256 257 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD); 258 259 case ACPI_TYPE_DDB_HANDLE: 260 261 return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE); 262 263 case ACPI_TYPE_DEBUG_OBJECT: 264 265 /* Cannot be used as a source operand */ 266 267 return (0); 268 269 default: 270 271 return (1 << (Etype - 1)); 272 } 273 } 274 275 /* Try the internal data types */ 276 277 switch (Etype) 278 { 279 case ACPI_TYPE_LOCAL_REGION_FIELD: 280 case ACPI_TYPE_LOCAL_BANK_FIELD: 281 case ACPI_TYPE_LOCAL_INDEX_FIELD: 282 283 /* Named fields can be either Integer/Buffer/String */ 284 285 return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT); 286 287 case ACPI_TYPE_LOCAL_ALIAS: 288 289 return (ACPI_BTYPE_INTEGER); 290 291 292 case ACPI_TYPE_LOCAL_RESOURCE: 293 case ACPI_TYPE_LOCAL_RESOURCE_FIELD: 294 295 return (ACPI_BTYPE_REFERENCE_OBJECT); 296 297 default: 298 299 printf ("Unhandled encoded type: %X\n", Etype); 300 return (0); 301 } 302 } 303 304 305 /******************************************************************************* 306 * 307 * FUNCTION: AnFormatBtype 308 * 309 * PARAMETERS: Btype - Bitfield of ACPI types 310 * Buffer - Where to put the ascii string 311 * 312 * RETURN: None. 313 * 314 * DESCRIPTION: Convert a Btype to a string of ACPI types 315 * 316 ******************************************************************************/ 317 318 void 319 AnFormatBtype ( 320 char *Buffer, 321 UINT32 Btype) 322 { 323 UINT32 Type; 324 BOOLEAN First = TRUE; 325 326 327 *Buffer = 0; 328 if (Btype == 0) 329 { 330 strcat (Buffer, "NoReturnValue"); 331 return; 332 } 333 334 for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++) 335 { 336 if (Btype & 0x00000001) 337 { 338 if (!First) 339 { 340 strcat (Buffer, "|"); 341 } 342 343 First = FALSE; 344 strcat (Buffer, AcpiUtGetTypeName (Type)); 345 } 346 Btype >>= 1; 347 } 348 349 if (Btype & 0x00000001) 350 { 351 if (!First) 352 { 353 strcat (Buffer, "|"); 354 } 355 356 First = FALSE; 357 strcat (Buffer, "Reference"); 358 } 359 360 Btype >>= 1; 361 if (Btype & 0x00000001) 362 { 363 if (!First) 364 { 365 strcat (Buffer, "|"); 366 } 367 368 First = FALSE; 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 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 & NODE_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 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 the Btype 568 * 569 * DESCRIPTION: Convert a bitfield type to an encoded type 570 * 571 ******************************************************************************/ 572 573 UINT32 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