1 /****************************************************************************** 2 * 3 * Module Name: psobject - Support for parse objects 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 "acpi.h" 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "amlcode.h" 48 49 #define _COMPONENT ACPI_PARSER 50 ACPI_MODULE_NAME ("psobject") 51 52 53 /* Local prototypes */ 54 55 static ACPI_STATUS 56 AcpiPsGetAmlOpcode ( 57 ACPI_WALK_STATE *WalkState); 58 59 60 /******************************************************************************* 61 * 62 * FUNCTION: AcpiPsGetAmlOpcode 63 * 64 * PARAMETERS: WalkState - Current state 65 * 66 * RETURN: Status 67 * 68 * DESCRIPTION: Extract the next AML opcode from the input stream. 69 * 70 ******************************************************************************/ 71 72 static ACPI_STATUS 73 AcpiPsGetAmlOpcode ( 74 ACPI_WALK_STATE *WalkState) 75 { 76 UINT32 AmlOffset; 77 78 79 ACPI_FUNCTION_TRACE_PTR (PsGetAmlOpcode, WalkState); 80 81 82 WalkState->Aml = WalkState->ParserState.Aml; 83 WalkState->Opcode = AcpiPsPeekOpcode (&(WalkState->ParserState)); 84 85 /* 86 * First cut to determine what we have found: 87 * 1) A valid AML opcode 88 * 2) A name string 89 * 3) An unknown/invalid opcode 90 */ 91 WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode); 92 93 switch (WalkState->OpInfo->Class) 94 { 95 case AML_CLASS_ASCII: 96 case AML_CLASS_PREFIX: 97 /* 98 * Starts with a valid prefix or ASCII char, this is a name 99 * string. Convert the bare name string to a namepath. 100 */ 101 WalkState->Opcode = AML_INT_NAMEPATH_OP; 102 WalkState->ArgTypes = ARGP_NAMESTRING; 103 break; 104 105 case AML_CLASS_UNKNOWN: 106 107 /* The opcode is unrecognized. Complain and skip unknown opcodes */ 108 109 if (WalkState->PassNumber == 2) 110 { 111 AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->Aml, 112 WalkState->ParserState.AmlStart); 113 114 ACPI_ERROR ((AE_INFO, 115 "Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring", 116 WalkState->Opcode, 117 (UINT32) (AmlOffset + sizeof (ACPI_TABLE_HEADER)))); 118 119 ACPI_DUMP_BUFFER ((WalkState->ParserState.Aml - 16), 48); 120 121 #ifdef ACPI_ASL_COMPILER 122 /* 123 * This is executed for the disassembler only. Output goes 124 * to the disassembled ASL output file. 125 */ 126 AcpiOsPrintf ( 127 "/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n", 128 WalkState->Opcode, 129 (UINT32) (AmlOffset + sizeof (ACPI_TABLE_HEADER))); 130 131 /* Dump the context surrounding the invalid opcode */ 132 133 AcpiUtDumpBuffer (((UINT8 *) WalkState->ParserState.Aml - 16), 134 48, DB_BYTE_DISPLAY, 135 (AmlOffset + sizeof (ACPI_TABLE_HEADER) - 16)); 136 AcpiOsPrintf (" */\n"); 137 #endif 138 } 139 140 /* Increment past one-byte or two-byte opcode */ 141 142 WalkState->ParserState.Aml++; 143 if (WalkState->Opcode > 0xFF) /* Can only happen if first byte is 0x5B */ 144 { 145 WalkState->ParserState.Aml++; 146 } 147 148 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE); 149 150 default: 151 152 /* Found opcode info, this is a normal opcode */ 153 154 WalkState->ParserState.Aml += 155 AcpiPsGetOpcodeSize (WalkState->Opcode); 156 WalkState->ArgTypes = WalkState->OpInfo->ParseArgs; 157 break; 158 } 159 160 return_ACPI_STATUS (AE_OK); 161 } 162 163 164 /******************************************************************************* 165 * 166 * FUNCTION: AcpiPsBuildNamedOp 167 * 168 * PARAMETERS: WalkState - Current state 169 * AmlOpStart - Begin of named Op in AML 170 * UnnamedOp - Early Op (not a named Op) 171 * Op - Returned Op 172 * 173 * RETURN: Status 174 * 175 * DESCRIPTION: Parse a named Op 176 * 177 ******************************************************************************/ 178 179 ACPI_STATUS 180 AcpiPsBuildNamedOp ( 181 ACPI_WALK_STATE *WalkState, 182 UINT8 *AmlOpStart, 183 ACPI_PARSE_OBJECT *UnnamedOp, 184 ACPI_PARSE_OBJECT **Op) 185 { 186 ACPI_STATUS Status = AE_OK; 187 ACPI_PARSE_OBJECT *Arg = NULL; 188 189 190 ACPI_FUNCTION_TRACE_PTR (PsBuildNamedOp, WalkState); 191 192 193 UnnamedOp->Common.Value.Arg = NULL; 194 UnnamedOp->Common.ArgListLength = 0; 195 UnnamedOp->Common.AmlOpcode = WalkState->Opcode; 196 197 /* 198 * Get and append arguments until we find the node that contains 199 * the name (the type ARGP_NAME). 200 */ 201 while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) && 202 (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) != ARGP_NAME)) 203 { 204 Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState), 205 GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg); 206 if (ACPI_FAILURE (Status)) 207 { 208 return_ACPI_STATUS (Status); 209 } 210 211 AcpiPsAppendArg (UnnamedOp, Arg); 212 INCREMENT_ARG_LIST (WalkState->ArgTypes); 213 } 214 215 /* 216 * Make sure that we found a NAME and didn't run out of arguments 217 */ 218 if (!GET_CURRENT_ARG_TYPE (WalkState->ArgTypes)) 219 { 220 return_ACPI_STATUS (AE_AML_NO_OPERAND); 221 } 222 223 /* We know that this arg is a name, move to next arg */ 224 225 INCREMENT_ARG_LIST (WalkState->ArgTypes); 226 227 /* 228 * Find the object. This will either insert the object into 229 * the namespace or simply look it up 230 */ 231 WalkState->Op = NULL; 232 233 Status = WalkState->DescendingCallback (WalkState, Op); 234 if (ACPI_FAILURE (Status)) 235 { 236 if (Status != AE_CTRL_TERMINATE) 237 { 238 ACPI_EXCEPTION ((AE_INFO, Status, "During name lookup/catalog")); 239 } 240 return_ACPI_STATUS (Status); 241 } 242 243 if (!*Op) 244 { 245 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE); 246 } 247 248 Status = AcpiPsNextParseState (WalkState, *Op, Status); 249 if (ACPI_FAILURE (Status)) 250 { 251 if (Status == AE_CTRL_PENDING) 252 { 253 Status = AE_CTRL_PARSE_PENDING; 254 } 255 return_ACPI_STATUS (Status); 256 } 257 258 AcpiPsAppendArg (*Op, UnnamedOp->Common.Value.Arg); 259 260 if ((*Op)->Common.AmlOpcode == AML_REGION_OP || 261 (*Op)->Common.AmlOpcode == AML_DATA_REGION_OP) 262 { 263 /* 264 * Defer final parsing of an OperationRegion body, because we don't 265 * have enough info in the first pass to parse it correctly (i.e., 266 * there may be method calls within the TermArg elements of the body.) 267 * 268 * However, we must continue parsing because the opregion is not a 269 * standalone package -- we don't know where the end is at this point. 270 * 271 * (Length is unknown until parse of the body complete) 272 */ 273 (*Op)->Named.Data = AmlOpStart; 274 (*Op)->Named.Length = 0; 275 } 276 277 return_ACPI_STATUS (AE_OK); 278 } 279 280 281 /******************************************************************************* 282 * 283 * FUNCTION: AcpiPsCreateOp 284 * 285 * PARAMETERS: WalkState - Current state 286 * AmlOpStart - Op start in AML 287 * NewOp - Returned Op 288 * 289 * RETURN: Status 290 * 291 * DESCRIPTION: Get Op from AML 292 * 293 ******************************************************************************/ 294 295 ACPI_STATUS 296 AcpiPsCreateOp ( 297 ACPI_WALK_STATE *WalkState, 298 UINT8 *AmlOpStart, 299 ACPI_PARSE_OBJECT **NewOp) 300 { 301 ACPI_STATUS Status = AE_OK; 302 ACPI_PARSE_OBJECT *Op; 303 ACPI_PARSE_OBJECT *NamedOp = NULL; 304 ACPI_PARSE_OBJECT *ParentScope; 305 UINT8 ArgumentCount; 306 const ACPI_OPCODE_INFO *OpInfo; 307 308 309 ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState); 310 311 312 Status = AcpiPsGetAmlOpcode (WalkState); 313 if (Status == AE_CTRL_PARSE_CONTINUE) 314 { 315 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE); 316 } 317 318 /* Create Op structure and append to parent's argument list */ 319 320 WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode); 321 Op = AcpiPsAllocOp (WalkState->Opcode, AmlOpStart); 322 if (!Op) 323 { 324 return_ACPI_STATUS (AE_NO_MEMORY); 325 } 326 327 if (WalkState->OpInfo->Flags & AML_NAMED) 328 { 329 Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp); 330 AcpiPsFreeOp (Op); 331 if (ACPI_FAILURE (Status)) 332 { 333 return_ACPI_STATUS (Status); 334 } 335 336 *NewOp = NamedOp; 337 return_ACPI_STATUS (AE_OK); 338 } 339 340 /* Not a named opcode, just allocate Op and append to parent */ 341 342 if (WalkState->OpInfo->Flags & AML_CREATE) 343 { 344 /* 345 * Backup to beginning of CreateXXXfield declaration 346 * BodyLength is unknown until we parse the body 347 */ 348 Op->Named.Data = AmlOpStart; 349 Op->Named.Length = 0; 350 } 351 352 if (WalkState->Opcode == AML_BANK_FIELD_OP) 353 { 354 /* 355 * Backup to beginning of BankField declaration 356 * BodyLength is unknown until we parse the body 357 */ 358 Op->Named.Data = AmlOpStart; 359 Op->Named.Length = 0; 360 } 361 362 ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState)); 363 AcpiPsAppendArg (ParentScope, Op); 364 365 if (ParentScope) 366 { 367 OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode); 368 if (OpInfo->Flags & AML_HAS_TARGET) 369 { 370 ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type); 371 if (ParentScope->Common.ArgListLength > ArgumentCount) 372 { 373 Op->Common.Flags |= ACPI_PARSEOP_TARGET; 374 } 375 } 376 else if (ParentScope->Common.AmlOpcode == AML_INCREMENT_OP) 377 { 378 Op->Common.Flags |= ACPI_PARSEOP_TARGET; 379 } 380 } 381 382 if (WalkState->DescendingCallback != NULL) 383 { 384 /* 385 * Find the object. This will either insert the object into 386 * the namespace or simply look it up 387 */ 388 WalkState->Op = *NewOp = Op; 389 390 Status = WalkState->DescendingCallback (WalkState, &Op); 391 Status = AcpiPsNextParseState (WalkState, Op, Status); 392 if (Status == AE_CTRL_PENDING) 393 { 394 Status = AE_CTRL_PARSE_PENDING; 395 } 396 } 397 398 return_ACPI_STATUS (Status); 399 } 400 401 402 /******************************************************************************* 403 * 404 * FUNCTION: AcpiPsCompleteOp 405 * 406 * PARAMETERS: WalkState - Current state 407 * Op - Returned Op 408 * Status - Parse status before complete Op 409 * 410 * RETURN: Status 411 * 412 * DESCRIPTION: Complete Op 413 * 414 ******************************************************************************/ 415 416 ACPI_STATUS 417 AcpiPsCompleteOp ( 418 ACPI_WALK_STATE *WalkState, 419 ACPI_PARSE_OBJECT **Op, 420 ACPI_STATUS Status) 421 { 422 ACPI_STATUS Status2; 423 424 425 ACPI_FUNCTION_TRACE_PTR (PsCompleteOp, WalkState); 426 427 428 /* 429 * Finished one argument of the containing scope 430 */ 431 WalkState->ParserState.Scope->ParseScope.ArgCount--; 432 433 /* Close this Op (will result in parse subtree deletion) */ 434 435 Status2 = AcpiPsCompleteThisOp (WalkState, *Op); 436 if (ACPI_FAILURE (Status2)) 437 { 438 return_ACPI_STATUS (Status2); 439 } 440 441 *Op = NULL; 442 443 switch (Status) 444 { 445 case AE_OK: 446 447 break; 448 449 case AE_CTRL_TRANSFER: 450 451 /* We are about to transfer to a called method */ 452 453 WalkState->PrevOp = NULL; 454 WalkState->PrevArgTypes = WalkState->ArgTypes; 455 return_ACPI_STATUS (Status); 456 457 case AE_CTRL_END: 458 459 AcpiPsPopScope (&(WalkState->ParserState), Op, 460 &WalkState->ArgTypes, &WalkState->ArgCount); 461 462 if (*Op) 463 { 464 WalkState->Op = *Op; 465 WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode); 466 WalkState->Opcode = (*Op)->Common.AmlOpcode; 467 468 Status = WalkState->AscendingCallback (WalkState); 469 Status = AcpiPsNextParseState (WalkState, *Op, Status); 470 471 Status2 = AcpiPsCompleteThisOp (WalkState, *Op); 472 if (ACPI_FAILURE (Status2)) 473 { 474 return_ACPI_STATUS (Status2); 475 } 476 } 477 478 Status = AE_OK; 479 break; 480 481 case AE_CTRL_BREAK: 482 case AE_CTRL_CONTINUE: 483 484 /* Pop off scopes until we find the While */ 485 486 while (!(*Op) || ((*Op)->Common.AmlOpcode != AML_WHILE_OP)) 487 { 488 AcpiPsPopScope (&(WalkState->ParserState), Op, 489 &WalkState->ArgTypes, &WalkState->ArgCount); 490 } 491 492 /* Close this iteration of the While loop */ 493 494 WalkState->Op = *Op; 495 WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode); 496 WalkState->Opcode = (*Op)->Common.AmlOpcode; 497 498 Status = WalkState->AscendingCallback (WalkState); 499 Status = AcpiPsNextParseState (WalkState, *Op, Status); 500 501 Status2 = AcpiPsCompleteThisOp (WalkState, *Op); 502 if (ACPI_FAILURE (Status2)) 503 { 504 return_ACPI_STATUS (Status2); 505 } 506 507 Status = AE_OK; 508 break; 509 510 case AE_CTRL_TERMINATE: 511 512 /* Clean up */ 513 do 514 { 515 if (*Op) 516 { 517 Status2 = AcpiPsCompleteThisOp (WalkState, *Op); 518 if (ACPI_FAILURE (Status2)) 519 { 520 return_ACPI_STATUS (Status2); 521 } 522 523 AcpiUtDeleteGenericState ( 524 AcpiUtPopGenericState (&WalkState->ControlState)); 525 } 526 527 AcpiPsPopScope (&(WalkState->ParserState), Op, 528 &WalkState->ArgTypes, &WalkState->ArgCount); 529 530 } while (*Op); 531 532 return_ACPI_STATUS (AE_OK); 533 534 default: /* All other non-AE_OK status */ 535 536 do 537 { 538 if (*Op) 539 { 540 Status2 = AcpiPsCompleteThisOp (WalkState, *Op); 541 if (ACPI_FAILURE (Status2)) 542 { 543 return_ACPI_STATUS (Status2); 544 } 545 } 546 547 AcpiPsPopScope (&(WalkState->ParserState), Op, 548 &WalkState->ArgTypes, &WalkState->ArgCount); 549 550 } while (*Op); 551 552 553 #if 0 554 /* 555 * TBD: Cleanup parse ops on error 556 */ 557 if (*Op == NULL) 558 { 559 AcpiPsPopScope (ParserState, Op, 560 &WalkState->ArgTypes, &WalkState->ArgCount); 561 } 562 #endif 563 WalkState->PrevOp = NULL; 564 WalkState->PrevArgTypes = WalkState->ArgTypes; 565 return_ACPI_STATUS (Status); 566 } 567 568 /* This scope complete? */ 569 570 if (AcpiPsHasCompletedScope (&(WalkState->ParserState))) 571 { 572 AcpiPsPopScope (&(WalkState->ParserState), Op, 573 &WalkState->ArgTypes, &WalkState->ArgCount); 574 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *Op)); 575 } 576 else 577 { 578 *Op = NULL; 579 } 580 581 return_ACPI_STATUS (AE_OK); 582 } 583 584 585 /******************************************************************************* 586 * 587 * FUNCTION: AcpiPsCompleteFinalOp 588 * 589 * PARAMETERS: WalkState - Current state 590 * Op - Current Op 591 * Status - Current parse status before complete last 592 * Op 593 * 594 * RETURN: Status 595 * 596 * DESCRIPTION: Complete last Op. 597 * 598 ******************************************************************************/ 599 600 ACPI_STATUS 601 AcpiPsCompleteFinalOp ( 602 ACPI_WALK_STATE *WalkState, 603 ACPI_PARSE_OBJECT *Op, 604 ACPI_STATUS Status) 605 { 606 ACPI_STATUS Status2; 607 608 609 ACPI_FUNCTION_TRACE_PTR (PsCompleteFinalOp, WalkState); 610 611 612 /* 613 * Complete the last Op (if not completed), and clear the scope stack. 614 * It is easily possible to end an AML "package" with an unbounded number 615 * of open scopes (such as when several ASL blocks are closed with 616 * sequential closing braces). We want to terminate each one cleanly. 617 */ 618 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "AML package complete at Op %p\n", Op)); 619 do 620 { 621 if (Op) 622 { 623 if (WalkState->AscendingCallback != NULL) 624 { 625 WalkState->Op = Op; 626 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 627 WalkState->Opcode = Op->Common.AmlOpcode; 628 629 Status = WalkState->AscendingCallback (WalkState); 630 Status = AcpiPsNextParseState (WalkState, Op, Status); 631 if (Status == AE_CTRL_PENDING) 632 { 633 Status = AcpiPsCompleteOp (WalkState, &Op, AE_OK); 634 if (ACPI_FAILURE (Status)) 635 { 636 return_ACPI_STATUS (Status); 637 } 638 } 639 640 if (Status == AE_CTRL_TERMINATE) 641 { 642 Status = AE_OK; 643 644 /* Clean up */ 645 do 646 { 647 if (Op) 648 { 649 Status2 = AcpiPsCompleteThisOp (WalkState, Op); 650 if (ACPI_FAILURE (Status2)) 651 { 652 return_ACPI_STATUS (Status2); 653 } 654 } 655 656 AcpiPsPopScope (&(WalkState->ParserState), &Op, 657 &WalkState->ArgTypes, &WalkState->ArgCount); 658 659 } while (Op); 660 661 return_ACPI_STATUS (Status); 662 } 663 664 else if (ACPI_FAILURE (Status)) 665 { 666 /* First error is most important */ 667 668 (void) AcpiPsCompleteThisOp (WalkState, Op); 669 return_ACPI_STATUS (Status); 670 } 671 } 672 673 Status2 = AcpiPsCompleteThisOp (WalkState, Op); 674 if (ACPI_FAILURE (Status2)) 675 { 676 return_ACPI_STATUS (Status2); 677 } 678 } 679 680 AcpiPsPopScope (&(WalkState->ParserState), &Op, &WalkState->ArgTypes, 681 &WalkState->ArgCount); 682 683 } while (Op); 684 685 return_ACPI_STATUS (Status); 686 } 687