sys/contrib/dev/acpica/components/parser/psloop.c

   1 /******************************************************************************
   2  *
   3  * Module Name: psloop - Main AML parse loop
   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 /*
  46  * Parse the AML and build an operation tree as most interpreters, (such as
  47  * Perl) do. Parsing is done by hand rather than with a YACC generated parser
  48  * to tightly constrain stack and dynamic memory usage. Parsing is kept
  49  * flexible and the code fairly compact by parsing based on a list of AML
  50  * opcode templates in AmlOpInfo[].
  51  */
  52
  53 #include <contrib/dev/acpica/include/acpi.h>
  54 #include <contrib/dev/acpica/include/accommon.h>
  55 #include <contrib/dev/acpica/include/acparser.h>
  56 #include <contrib/dev/acpica/include/acdispat.h>
  57 #include <contrib/dev/acpica/include/amlcode.h>
  58
  59 #define _COMPONENT          ACPI_PARSER
  60         ACPI_MODULE_NAME    ("psloop")
  61
  62
  63 /* Local prototypes */
  64
  65 static ACPI_STATUS
  66 AcpiPsGetArguments (
  67     ACPI_WALK_STATE         *WalkState,
  68     UINT8                   *AmlOpStart,
  69     ACPI_PARSE_OBJECT       *Op);
  70
  71 static void
  72 AcpiPsLinkModuleCode (
  73     ACPI_PARSE_OBJECT       *ParentOp,
  74     UINT8                   *AmlStart,
  75     UINT32                  AmlLength,
  76     ACPI_OWNER_ID           OwnerId);
  77
  78
  79 /*******************************************************************************
  80  *
  81  * FUNCTION:    AcpiPsGetArguments
  82  *
  83  * PARAMETERS:  WalkState           - Current state
  84  *              AmlOpStart          - Op start in AML
  85  *              Op                  - Current Op
  86  *
  87  * RETURN:      Status
  88  *
  89  * DESCRIPTION: Get arguments for passed Op.
  90  *
  91  ******************************************************************************/
  92
  93 static ACPI_STATUS
  94 AcpiPsGetArguments (
  95     ACPI_WALK_STATE         *WalkState,
  96     UINT8                   *AmlOpStart,
  97     ACPI_PARSE_OBJECT       *Op)
  98 {
  99     ACPI_STATUS             Status = AE_OK;
 100     ACPI_PARSE_OBJECT       *Arg = NULL;
 101     const ACPI_OPCODE_INFO  *OpInfo;
 102
 103
 104     ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
 105
 106
 107     switch (Op->Common.AmlOpcode)
 108     {
 109     case AML_BYTE_OP:       /* AML_BYTEDATA_ARG */
 110     case AML_WORD_OP:       /* AML_WORDDATA_ARG */
 111     case AML_DWORD_OP:      /* AML_DWORDATA_ARG */
 112     case AML_QWORD_OP:      /* AML_QWORDATA_ARG */
 113     case AML_STRING_OP:     /* AML_ASCIICHARLIST_ARG */
 114
 115         /* Fill in constant or string argument directly */
 116
 117         AcpiPsGetNextSimpleArg (&(WalkState->ParserState),
 118             GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), Op);
 119         break;
 120
 121     case AML_INT_NAMEPATH_OP:   /* AML_NAMESTRING_ARG */
 122
 123         Status = AcpiPsGetNextNamepath (WalkState, &(WalkState->ParserState), Op, 1);
 124         if (ACPI_FAILURE (Status))
 125         {
 126             return_ACPI_STATUS (Status);
 127         }
 128
 129         WalkState->ArgTypes = 0;
 130         break;
 131
 132     default:
 133         /*
 134          * Op is not a constant or string, append each argument to the Op
 135          */
 136         while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) && !WalkState->ArgCount)
 137         {
 138             WalkState->AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->ParserState.Aml,
 139                 WalkState->ParserState.AmlStart);
 140
 141             Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
 142                         GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
 143             if (ACPI_FAILURE (Status))
 144             {
 145                 return_ACPI_STATUS (Status);
 146             }
 147
 148             if (Arg)
 149             {
 150                 Arg->Common.AmlOffset = WalkState->AmlOffset;
 151                 AcpiPsAppendArg (Op, Arg);
 152             }
 153
 154             INCREMENT_ARG_LIST (WalkState->ArgTypes);
 155         }
 156
 157
 158         /*
 159          * Handle executable code at "module-level". This refers to
 160          * executable opcodes that appear outside of any control method.
 161          */
 162         if ((WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2) &&
 163             ((WalkState->ParseFlags & ACPI_PARSE_DISASSEMBLE) == 0))
 164         {
 165             /*
 166              * We want to skip If/Else/While constructs during Pass1 because we
 167              * want to actually conditionally execute the code during Pass2.
 168              *
 169              * Except for disassembly, where we always want to walk the
 170              * If/Else/While packages
 171              */
 172             switch (Op->Common.AmlOpcode)
 173             {
 174             case AML_IF_OP:
 175             case AML_ELSE_OP:
 176             case AML_WHILE_OP:
 177                 /*
 178                  * Currently supported module-level opcodes are:
 179                  * IF/ELSE/WHILE. These appear to be the most common,
 180                  * and easiest to support since they open an AML
 181                  * package.
 182                  */
 183                 if (WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1)
 184                 {
 185                     AcpiPsLinkModuleCode (Op->Common.Parent, AmlOpStart,
 186                         (UINT32) (WalkState->ParserState.PkgEnd - AmlOpStart),
 187                         WalkState->OwnerId);
 188                 }
 189
 190                 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 191                     "Pass1: Skipping an If/Else/While body\n"));
 192
 193                 /* Skip body of if/else/while in pass 1 */
 194
 195                 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
 196                 WalkState->ArgCount = 0;
 197                 break;
 198
 199             default:
 200                 /*
 201                  * Check for an unsupported executable opcode at module
 202                  * level. We must be in PASS1, the parent must be a SCOPE,
 203                  * The opcode class must be EXECUTE, and the opcode must
 204                  * not be an argument to another opcode.
 205                  */
 206                 if ((WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1) &&
 207                     (Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
 208                 {
 209                     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 210                     if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
 211                         (!Arg))
 212                     {
 213                         ACPI_WARNING ((AE_INFO,
 214                             "Unsupported module-level executable opcode "
 215                             "0x%.2X at table offset 0x%.4X",
 216                             Op->Common.AmlOpcode,
 217                             (UINT32) (ACPI_PTR_DIFF (AmlOpStart,
 218                                 WalkState->ParserState.AmlStart) +
 219                                 sizeof (ACPI_TABLE_HEADER))));
 220                     }
 221                 }
 222                 break;
 223             }
 224         }
 225
 226         /* Special processing for certain opcodes */
 227
 228         switch (Op->Common.AmlOpcode)
 229         {
 230         case AML_METHOD_OP:
 231             /*
 232              * Skip parsing of control method because we don't have enough
 233              * info in the first pass to parse it correctly.
 234              *
 235              * Save the length and address of the body
 236              */
 237             Op->Named.Data = WalkState->ParserState.Aml;
 238             Op->Named.Length = (UINT32)
 239                 (WalkState->ParserState.PkgEnd - WalkState->ParserState.Aml);
 240
 241             /* Skip body of method */
 242
 243             WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
 244             WalkState->ArgCount = 0;
 245             break;
 246
 247         case AML_BUFFER_OP:
 248         case AML_PACKAGE_OP:
 249         case AML_VAR_PACKAGE_OP:
 250
 251             if ((Op->Common.Parent) &&
 252                 (Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
 253                 (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
 254             {
 255                 /*
 256                  * Skip parsing of Buffers and Packages because we don't have
 257                  * enough info in the first pass to parse them correctly.
 258                  */
 259                 Op->Named.Data = AmlOpStart;
 260                 Op->Named.Length = (UINT32)
 261                     (WalkState->ParserState.PkgEnd - AmlOpStart);
 262
 263                 /* Skip body */
 264
 265                 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
 266                 WalkState->ArgCount = 0;
 267             }
 268             break;
 269
 270         case AML_WHILE_OP:
 271
 272             if (WalkState->ControlState)
 273             {
 274                 WalkState->ControlState->Control.PackageEnd =
 275                     WalkState->ParserState.PkgEnd;
 276             }
 277             break;
 278
 279         default:
 280
 281             /* No action for all other opcodes */
 282
 283             break;
 284         }
 285
 286         break;
 287     }
 288
 289     return_ACPI_STATUS (AE_OK);
 290 }
 291
 292
 293 /*******************************************************************************
 294  *
 295  * FUNCTION:    AcpiPsLinkModuleCode
 296  *
 297  * PARAMETERS:  ParentOp            - Parent parser op
 298  *              AmlStart            - Pointer to the AML
 299  *              AmlLength           - Length of executable AML
 300  *              OwnerId             - OwnerId of module level code
 301  *
 302  * RETURN:      None.
 303  *
 304  * DESCRIPTION: Wrap the module-level code with a method object and link the
 305  *              object to the global list. Note, the mutex field of the method
 306  *              object is used to link multiple module-level code objects.
 307  *
 308  ******************************************************************************/
 309
 310 static void
 311 AcpiPsLinkModuleCode (
 312     ACPI_PARSE_OBJECT       *ParentOp,
 313     UINT8                   *AmlStart,
 314     UINT32                  AmlLength,
 315     ACPI_OWNER_ID           OwnerId)
 316 {
 317     ACPI_OPERAND_OBJECT     *Prev;
 318     ACPI_OPERAND_OBJECT     *Next;
 319     ACPI_OPERAND_OBJECT     *MethodObj;
 320     ACPI_NAMESPACE_NODE     *ParentNode;
 321
 322
 323     /* Get the tail of the list */
 324
 325     Prev = Next = AcpiGbl_ModuleCodeList;
 326     while (Next)
 327     {
 328         Prev = Next;
 329         Next = Next->Method.Mutex;
 330     }
 331
 332     /*
 333      * Insert the module level code into the list. Merge it if it is
 334      * adjacent to the previous element.
 335      */
 336     if (!Prev ||
 337        ((Prev->Method.AmlStart + Prev->Method.AmlLength) != AmlStart))
 338     {
 339         /* Create, initialize, and link a new temporary method object */
 340
 341         MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
 342         if (!MethodObj)
 343         {
 344             return;
 345         }
 346
 347         if (ParentOp->Common.Node)
 348         {
 349             ParentNode = ParentOp->Common.Node;
 350         }
 351         else
 352         {
 353             ParentNode = AcpiGbl_RootNode;
 354         }
 355
 356         MethodObj->Method.AmlStart = AmlStart;
 357         MethodObj->Method.AmlLength = AmlLength;
 358         MethodObj->Method.OwnerId = OwnerId;
 359         MethodObj->Method.InfoFlags |= ACPI_METHOD_MODULE_LEVEL;
 360
 361         /*
 362          * Save the parent node in NextObject. This is cheating, but we
 363          * don't want to expand the method object.
 364          */
 365         MethodObj->Method.NextObject =
 366             ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParentNode);
 367
 368         if (!Prev)
 369         {
 370             AcpiGbl_ModuleCodeList = MethodObj;
 371         }
 372         else
 373         {
 374             Prev->Method.Mutex = MethodObj;
 375         }
 376     }
 377     else
 378     {
 379         Prev->Method.AmlLength += AmlLength;
 380     }
 381 }
 382
 383 /*******************************************************************************
 384  *
 385  * FUNCTION:    AcpiPsParseLoop
 386  *
 387  * PARAMETERS:  WalkState           - Current state
 388  *
 389  * RETURN:      Status
 390  *
 391  * DESCRIPTION: Parse AML (pointed to by the current parser state) and return
 392  *              a tree of ops.
 393  *
 394  ******************************************************************************/
 395
 396 ACPI_STATUS
 397 AcpiPsParseLoop (
 398     ACPI_WALK_STATE         *WalkState)
 399 {
 400     ACPI_STATUS             Status = AE_OK;
 401     ACPI_PARSE_OBJECT       *Op = NULL;     /* current op */
 402     ACPI_PARSE_STATE        *ParserState;
 403     UINT8                   *AmlOpStart = NULL;
 404
 405
 406     ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
 407
 408
 409     if (WalkState->DescendingCallback == NULL)
 410     {
 411         return_ACPI_STATUS (AE_BAD_PARAMETER);
 412     }
 413
 414     ParserState = &WalkState->ParserState;
 415     WalkState->ArgTypes = 0;
 416
 417 #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
 418
 419     if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
 420     {
 421         /* We are restarting a preempted control method */
 422
 423         if (AcpiPsHasCompletedScope (ParserState))
 424         {
 425             /*
 426              * We must check if a predicate to an IF or WHILE statement
 427              * was just completed
 428              */
 429             if ((ParserState->Scope->ParseScope.Op) &&
 430                ((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
 431                 (ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
 432                 (WalkState->ControlState) &&
 433                 (WalkState->ControlState->Common.State ==
 434                     ACPI_CONTROL_PREDICATE_EXECUTING))
 435             {
 436                 /*
 437                  * A predicate was just completed, get the value of the
 438                  * predicate and branch based on that value
 439                  */
 440                 WalkState->Op = NULL;
 441                 Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
 442                 if (ACPI_FAILURE (Status) &&
 443                     ((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
 444                 {
 445                     if (Status == AE_AML_NO_RETURN_VALUE)
 446                     {
 447                         ACPI_EXCEPTION ((AE_INFO, Status,
 448                             "Invoked method did not return a value"));
 449                     }
 450
 451                     ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
 452                     return_ACPI_STATUS (Status);
 453                 }
 454
 455                 Status = AcpiPsNextParseState (WalkState, Op, Status);
 456             }
 457
 458             AcpiPsPopScope (ParserState, &Op,
 459                 &WalkState->ArgTypes, &WalkState->ArgCount);
 460             ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
 461         }
 462         else if (WalkState->PrevOp)
 463         {
 464             /* We were in the middle of an op */
 465
 466             Op = WalkState->PrevOp;
 467             WalkState->ArgTypes = WalkState->PrevArgTypes;
 468         }
 469     }
 470 #endif
 471
 472     /* Iterative parsing loop, while there is more AML to process: */
 473
 474     while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
 475     {
 476         AmlOpStart = ParserState->Aml;
 477         if (!Op)
 478         {
 479             Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
 480             if (ACPI_FAILURE (Status))
 481             {
 482                 if (Status == AE_CTRL_PARSE_CONTINUE)
 483                 {
 484                     continue;
 485                 }
 486
 487                 if (Status == AE_CTRL_PARSE_PENDING)
 488                 {
 489                     Status = AE_OK;
 490                 }
 491
 492                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
 493                 if (ACPI_FAILURE (Status))
 494                 {
 495                     return_ACPI_STATUS (Status);
 496                 }
 497
 498                 continue;
 499             }
 500
 501             Op->Common.AmlOffset = WalkState->AmlOffset;
 502
 503             if (WalkState->OpInfo)
 504             {
 505                 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 506                     "Opcode %4.4X [%s] Op %p Aml %p AmlOffset %5.5X\n",
 507                      (UINT32) Op->Common.AmlOpcode, WalkState->OpInfo->Name,
 508                      Op, ParserState->Aml, Op->Common.AmlOffset));
 509             }
 510         }
 511
 512
 513         /*
 514          * Start ArgCount at zero because we don't know if there are
 515          * any args yet
 516          */
 517         WalkState->ArgCount  = 0;
 518
 519         /* Are there any arguments that must be processed? */
 520
 521         if (WalkState->ArgTypes)
 522         {
 523             /* Get arguments */
 524
 525             Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
 526             if (ACPI_FAILURE (Status))
 527             {
 528                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
 529                 if (ACPI_FAILURE (Status))
 530                 {
 531                     return_ACPI_STATUS (Status);
 532                 }
 533
 534                 continue;
 535             }
 536         }
 537
 538         /* Check for arguments that need to be processed */
 539
 540         if (WalkState->ArgCount)
 541         {
 542             /*
 543              * There are arguments (complex ones), push Op and
 544              * prepare for argument
 545              */
 546             Status = AcpiPsPushScope (ParserState, Op,
 547                         WalkState->ArgTypes, WalkState->ArgCount);
 548             if (ACPI_FAILURE (Status))
 549             {
 550                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
 551                 if (ACPI_FAILURE (Status))
 552                 {
 553                     return_ACPI_STATUS (Status);
 554                 }
 555
 556                 continue;
 557             }
 558
 559             Op = NULL;
 560             continue;
 561         }
 562
 563         /*
 564          * All arguments have been processed -- Op is complete,
 565          * prepare for next
 566          */
 567         WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 568         if (WalkState->OpInfo->Flags & AML_NAMED)
 569         {
 570             if (Op->Common.AmlOpcode == AML_REGION_OP ||
 571                 Op->Common.AmlOpcode == AML_DATA_REGION_OP)
 572             {
 573                 /*
 574                  * Skip parsing of control method or opregion body,
 575                  * because we don't have enough info in the first pass
 576                  * to parse them correctly.
 577                  *
 578                  * Completed parsing an OpRegion declaration, we now
 579                  * know the length.
 580                  */
 581                 Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
 582             }
 583         }
 584
 585         if (WalkState->OpInfo->Flags & AML_CREATE)
 586         {
 587             /*
 588              * Backup to beginning of CreateXXXfield declaration (1 for
 589              * Opcode)
 590              *
 591              * BodyLength is unknown until we parse the body
 592              */
 593             Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
 594         }
 595
 596         if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
 597         {
 598             /*
 599              * Backup to beginning of BankField declaration
 600              *
 601              * BodyLength is unknown until we parse the body
 602              */
 603             Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
 604         }
 605
 606         /* This op complete, notify the dispatcher */
 607
 608         if (WalkState->AscendingCallback != NULL)
 609         {
 610             WalkState->Op = Op;
 611             WalkState->Opcode = Op->Common.AmlOpcode;
 612
 613             Status = WalkState->AscendingCallback (WalkState);
 614             Status = AcpiPsNextParseState (WalkState, Op, Status);
 615             if (Status == AE_CTRL_PENDING)
 616             {
 617                 Status = AE_OK;
 618             }
 619         }
 620
 621         Status = AcpiPsCompleteOp (WalkState, &Op, Status);
 622         if (ACPI_FAILURE (Status))
 623         {
 624             return_ACPI_STATUS (Status);
 625         }
 626
 627     } /* while ParserState->Aml */
 628
 629     Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
 630     return_ACPI_STATUS (Status);
 631 }