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