1 /******************************************************************************
   2  *
   3  * Module Name: asloperands - AML operand processing
   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 #include "aslcompiler.h"
  46 #include "aslcompiler.y.h"
  47 #include "amlcode.h"
  48 
  49 #define _COMPONENT          ACPI_COMPILER
  50         ACPI_MODULE_NAME    ("asloperands")
  51 
  52 /* Local prototypes */
  53 
  54 static void
  55 OpnDoField (
  56     ACPI_PARSE_OBJECT       *Op);
  57 
  58 static void
  59 OpnDoBankField (
  60     ACPI_PARSE_OBJECT       *Op);
  61 
  62 static void
  63 OpnDoBuffer (
  64     ACPI_PARSE_OBJECT       *Op);
  65 
  66 static void
  67 OpnDoDefinitionBlock (
  68     ACPI_PARSE_OBJECT       *Op);
  69 
  70 static void
  71 OpnDoFieldCommon (
  72     ACPI_PARSE_OBJECT       *FieldOp,
  73     ACPI_PARSE_OBJECT       *Op);
  74 
  75 static void
  76 OpnDoIndexField (
  77     ACPI_PARSE_OBJECT       *Op);
  78 
  79 static void
  80 OpnDoLoadTable (
  81     ACPI_PARSE_OBJECT       *Op);
  82 
  83 static void
  84 OpnDoMethod (
  85     ACPI_PARSE_OBJECT       *Op);
  86 
  87 static void
  88 OpnDoMutex (
  89     ACPI_PARSE_OBJECT       *Op);
  90 
  91 static void
  92 OpnDoRegion (
  93     ACPI_PARSE_OBJECT       *Op);
  94 
  95 static void
  96 OpnAttachNameToNode (
  97     ACPI_PARSE_OBJECT       *Op);
  98 
  99 
 100 /*******************************************************************************
 101  *
 102  * FUNCTION:    OpnDoMutex
 103  *
 104  * PARAMETERS:  Op        - The parent parse node
 105  *
 106  * RETURN:      None
 107  *
 108  * DESCRIPTION: Construct the operands for the MUTEX ASL keyword.
 109  *
 110  ******************************************************************************/
 111 
 112 static void
 113 OpnDoMutex (
 114     ACPI_PARSE_OBJECT       *Op)
 115 {
 116     ACPI_PARSE_OBJECT       *Next;
 117 
 118 
 119     Next = Op->Asl.Child;
 120     Next = Next->Asl.Next;
 121 
 122     if (Next->Asl.Value.Integer > 15)
 123     {
 124         AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
 125     }
 126     return;
 127 }
 128 
 129 
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    OpnDoMethod
 133  *
 134  * PARAMETERS:  Op        - The parent parse node
 135  *
 136  * RETURN:      None
 137  *
 138  * DESCRIPTION: Construct the operands for the METHOD ASL keyword.
 139  *
 140  ******************************************************************************/
 141 
 142 static void
 143 OpnDoMethod (
 144     ACPI_PARSE_OBJECT       *Op)
 145 {
 146     ACPI_PARSE_OBJECT       *Next;
 147 
 148     /* Optional arguments for this opcode with defaults */
 149 
 150     UINT8                   NumArgs = 0;
 151     UINT8                   Serialized = 0;
 152     UINT8                   Concurrency = 0;
 153     UINT8                   MethodFlags;
 154 
 155 
 156     /* Opcode and package length first */
 157     /* Method name */
 158 
 159     Next = Op->Asl.Child;
 160 
 161     /* Num args */
 162 
 163     Next = Next->Asl.Next;
 164     if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 165     {
 166         NumArgs = (UINT8) Next->Asl.Value.Integer;
 167         Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 168     }
 169 
 170     /* Serialized Flag */
 171 
 172     Next = Next->Asl.Next;
 173     if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 174     {
 175         Serialized = (UINT8) Next->Asl.Value.Integer;
 176         Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 177     }
 178 
 179     /* Concurrency value (valid values are 0-15) */
 180 
 181     Next = Next->Asl.Next;
 182     if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 183     {
 184         /* This is a ByteConstExpr, so eval the constant now */
 185 
 186         OpcAmlConstantWalk (Next, 0, NULL);
 187 
 188         if (Next->Asl.Value.Integer > 15)
 189         {
 190             AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
 191         }
 192         Concurrency = (UINT8) Next->Asl.Value.Integer;
 193     }
 194 
 195     /* Put the bits in their proper places */
 196 
 197     MethodFlags = (UINT8) ((NumArgs & 0x7) |
 198                           ((Serialized & 0x1) << 3) |
 199                           ((Concurrency & 0xF) << 4));
 200 
 201     /* Use the last node for the combined flags byte */
 202 
 203     Next->Asl.Value.Integer = MethodFlags;
 204     Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
 205     Next->Asl.AmlLength = 1;
 206     Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
 207 
 208     /* Save the arg count in the first node */
 209 
 210     Op->Asl.Extra = NumArgs;
 211 }
 212 
 213 
 214 /*******************************************************************************
 215  *
 216  * FUNCTION:    OpnDoFieldCommon
 217  *
 218  * PARAMETERS:  FieldOp       - Node for an ASL field
 219  *              Op            - The parent parse node
 220  *
 221  * RETURN:      None
 222  *
 223  * DESCRIPTION: Construct the AML operands for the various field keywords,
 224  *              FIELD, BANKFIELD, INDEXFIELD
 225  *
 226  ******************************************************************************/
 227 
 228 static void
 229 OpnDoFieldCommon (
 230     ACPI_PARSE_OBJECT       *FieldOp,
 231     ACPI_PARSE_OBJECT       *Op)
 232 {
 233     ACPI_PARSE_OBJECT       *Next;
 234     ACPI_PARSE_OBJECT       *PkgLengthNode;
 235     UINT32                  CurrentBitOffset;
 236     UINT32                  NewBitOffset;
 237     UINT8                   AccessType;
 238     UINT8                   LockRule;
 239     UINT8                   UpdateRule;
 240     UINT8                   FieldFlags;
 241     UINT32                  MinimumLength;
 242 
 243 
 244     /* AccessType -- not optional, so no need to check for DEFAULT_ARG */
 245 
 246     AccessType = (UINT8) Op->Asl.Value.Integer;
 247     Op->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 248 
 249     /* Set the access type in the parent (field) node for use later */
 250 
 251     FieldOp->Asl.Value.Integer = AccessType;
 252 
 253     /* LockRule -- not optional, so no need to check for DEFAULT_ARG */
 254 
 255     Next = Op->Asl.Next;
 256     LockRule = (UINT8) Next->Asl.Value.Integer;
 257     Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 258 
 259     /* UpdateRule -- not optional, so no need to check for DEFAULT_ARG */
 260 
 261     Next = Next->Asl.Next;
 262     UpdateRule = (UINT8) Next->Asl.Value.Integer;
 263 
 264     /*
 265      * Generate the flags byte. The various fields are already
 266      * in the right bit position via translation from the
 267      * keywords by the parser.
 268      */
 269     FieldFlags = (UINT8) (AccessType | LockRule | UpdateRule);
 270 
 271     /* Use the previous node to be the FieldFlags node */
 272 
 273     /* Set the node to RAW_DATA */
 274 
 275     Next->Asl.Value.Integer = FieldFlags;
 276     Next->Asl.AmlOpcode     = AML_RAW_DATA_BYTE;
 277     Next->Asl.AmlLength     = 1;
 278     Next->Asl.ParseOpcode   = PARSEOP_RAW_DATA;
 279 
 280     /* Process the FieldUnitList */
 281 
 282     Next = Next->Asl.Next;
 283     CurrentBitOffset = 0;
 284 
 285     while (Next)
 286     {
 287         /* Save the offset of this field unit */
 288 
 289         Next->Asl.ExtraValue = CurrentBitOffset;
 290 
 291         switch (Next->Asl.ParseOpcode)
 292         {
 293         case PARSEOP_ACCESSAS:
 294 
 295             PkgLengthNode = Next->Asl.Child;
 296             AccessType = (UINT8) PkgLengthNode->Asl.Value.Integer;
 297 
 298             /* Nothing additional to do */
 299             break;
 300 
 301         case PARSEOP_OFFSET:
 302 
 303             /* New offset into the field */
 304 
 305             PkgLengthNode = Next->Asl.Child;
 306             NewBitOffset = ((UINT32) PkgLengthNode->Asl.Value.Integer) * 8;
 307 
 308             /*
 309              * Examine the specified offset in relation to the
 310              * current offset counter.
 311              */
 312             if (NewBitOffset < CurrentBitOffset)
 313             {
 314                 /*
 315                  * Not allowed to specify a backwards offset!
 316                  * Issue error and ignore this node.
 317                  */
 318                 AslError (ASL_ERROR, ASL_MSG_BACKWARDS_OFFSET, PkgLengthNode,
 319                     NULL);
 320                 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 321                 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 322             }
 323             else if (NewBitOffset == CurrentBitOffset)
 324             {
 325                 /*
 326                  * Offset is redundant; we don't need to output an
 327                  * offset opcode. Just set these nodes to default
 328                  */
 329                 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 330                 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 331             }
 332             else
 333             {
 334                 /*
 335                  * Valid new offset - set the value to be inserted into the AML
 336                  * and update the offset counter.
 337                  */
 338                 PkgLengthNode->Asl.Value.Integer =
 339                     NewBitOffset - CurrentBitOffset;
 340                 CurrentBitOffset = NewBitOffset;
 341             }
 342             break;
 343 
 344         case PARSEOP_NAMESEG:
 345         case PARSEOP_RESERVED_BYTES:
 346 
 347             /* Named or reserved field entry */
 348 
 349             PkgLengthNode     = Next->Asl.Child;
 350             NewBitOffset      = (UINT32) PkgLengthNode->Asl.Value.Integer;
 351             CurrentBitOffset += NewBitOffset;
 352 
 353             /* Save the current AccessAs value for error checking later */
 354 
 355             switch (AccessType)
 356             {
 357                 case AML_FIELD_ACCESS_ANY:
 358                 case AML_FIELD_ACCESS_BYTE:
 359                 case AML_FIELD_ACCESS_BUFFER:
 360                 default:
 361 
 362                     MinimumLength = 8;
 363                     break;
 364 
 365                 case AML_FIELD_ACCESS_WORD:
 366                     MinimumLength = 16;
 367                     break;
 368 
 369                 case AML_FIELD_ACCESS_DWORD:
 370                     MinimumLength = 32;
 371                     break;
 372 
 373                 case AML_FIELD_ACCESS_QWORD:
 374                     MinimumLength = 64;
 375                     break;
 376             }
 377 
 378             PkgLengthNode->Asl.ExtraValue = MinimumLength;
 379             break;
 380 
 381         default:
 382 
 383             /* All supported field opcodes must appear above */
 384 
 385             break;
 386         }
 387 
 388         /* Move on to next entry in the field list */
 389 
 390         Next = Next->Asl.Next;
 391     }
 392 }
 393 
 394 
 395 /*******************************************************************************
 396  *
 397  * FUNCTION:    OpnDoField
 398  *
 399  * PARAMETERS:  Op        - The parent parse node
 400  *
 401  * RETURN:      None
 402  *
 403  * DESCRIPTION: Construct the AML operands for the FIELD ASL keyword
 404  *
 405  ******************************************************************************/
 406 
 407 static void
 408 OpnDoField (
 409     ACPI_PARSE_OBJECT       *Op)
 410 {
 411     ACPI_PARSE_OBJECT       *Next;
 412 
 413 
 414     /* Opcode is parent node */
 415     /* First child is field name */
 416 
 417     Next = Op->Asl.Child;
 418 
 419     /* Second child is the AccessType */
 420 
 421     OpnDoFieldCommon (Op, Next->Asl.Next);
 422 }
 423 
 424 
 425 /*******************************************************************************
 426  *
 427  * FUNCTION:    OpnDoIndexField
 428  *
 429  * PARAMETERS:  Op        - The parent parse node
 430  *
 431  * RETURN:      None
 432  *
 433  * DESCRIPTION: Construct the AML operands for the INDEXFIELD ASL keyword
 434  *
 435  ******************************************************************************/
 436 
 437 static void
 438 OpnDoIndexField (
 439     ACPI_PARSE_OBJECT       *Op)
 440 {
 441     ACPI_PARSE_OBJECT       *Next;
 442 
 443 
 444     /* Opcode is parent node */
 445     /* First child is the index name */
 446 
 447     Next = Op->Asl.Child;
 448 
 449     /* Second child is the data name */
 450 
 451     Next = Next->Asl.Next;
 452 
 453     /* Third child is the AccessType */
 454 
 455     OpnDoFieldCommon (Op, Next->Asl.Next);
 456 }
 457 
 458 
 459 /*******************************************************************************
 460  *
 461  * FUNCTION:    OpnDoBankField
 462  *
 463  * PARAMETERS:  Op        - The parent parse node
 464  *
 465  * RETURN:      None
 466  *
 467  * DESCRIPTION: Construct the AML operands for the BANKFIELD ASL keyword
 468  *
 469  ******************************************************************************/
 470 
 471 static void
 472 OpnDoBankField (
 473     ACPI_PARSE_OBJECT       *Op)
 474 {
 475     ACPI_PARSE_OBJECT       *Next;
 476 
 477 
 478     /* Opcode is parent node */
 479     /* First child is the region name */
 480 
 481     Next = Op->Asl.Child;
 482 
 483     /* Second child is the bank name */
 484 
 485     Next = Next->Asl.Next;
 486 
 487     /* Third child is the bank value */
 488 
 489     Next = Next->Asl.Next;
 490 
 491     /* Fourth child is the AccessType */
 492 
 493     OpnDoFieldCommon (Op, Next->Asl.Next);
 494 }
 495 
 496 
 497 /*******************************************************************************
 498  *
 499  * FUNCTION:    OpnDoRegion
 500  *
 501  * PARAMETERS:  Op        - The parent parse node
 502  *
 503  * RETURN:      None
 504  *
 505  * DESCRIPTION: Tries to get the length of the region. Can only do this at
 506  *              compile time if the length is a constant.
 507  *
 508  ******************************************************************************/
 509 
 510 static void
 511 OpnDoRegion (
 512     ACPI_PARSE_OBJECT       *Op)
 513 {
 514     ACPI_PARSE_OBJECT       *Next;
 515 
 516 
 517     /* Opcode is parent node */
 518     /* First child is the region name */
 519 
 520     Next = Op->Asl.Child;
 521 
 522     /* Second child is the space ID*/
 523 
 524     Next = Next->Asl.Next;
 525 
 526     /* Third child is the region offset */
 527 
 528     Next = Next->Asl.Next;
 529 
 530     /* Fourth child is the region length */
 531 
 532     Next = Next->Asl.Next;
 533     if (Next->Asl.ParseOpcode == PARSEOP_INTEGER)
 534     {
 535         Op->Asl.Value.Integer = Next->Asl.Value.Integer;
 536     }
 537     else
 538     {
 539         Op->Asl.Value.Integer = ACPI_UINT64_MAX;
 540     }
 541 }
 542 
 543 
 544 /*******************************************************************************
 545  *
 546  * FUNCTION:    OpnDoBuffer
 547  *
 548  * PARAMETERS:  Op        - The parent parse node
 549  *
 550  * RETURN:      None
 551  *
 552  * DESCRIPTION: Construct the AML operands for the BUFFER ASL keyword. We
 553  *              build a single raw byte buffer from the initialization nodes,
 554  *              each parse node contains a buffer byte.
 555  *
 556  ******************************************************************************/
 557 
 558 static void
 559 OpnDoBuffer (
 560     ACPI_PARSE_OBJECT       *Op)
 561 {
 562     ACPI_PARSE_OBJECT       *InitializerOp;
 563     ACPI_PARSE_OBJECT       *BufferLengthOp;
 564 
 565     /* Optional arguments for this opcode with defaults */
 566 
 567     UINT32                  BufferLength = 0;
 568 
 569 
 570     /* Opcode and package length first */
 571     /* Buffer Length is next, followed by the initializer list */
 572 
 573     BufferLengthOp = Op->Asl.Child;
 574     InitializerOp = BufferLengthOp->Asl.Next;
 575 
 576     /*
 577      * If the BufferLength is not an INTEGER or was not specified in the ASL
 578      * (DEFAULT_ARG), it is a TermArg that is
 579      * evaluated at run-time, and we are therefore finished.
 580      */
 581     if ((BufferLengthOp->Asl.ParseOpcode != PARSEOP_INTEGER) &&
 582         (BufferLengthOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
 583     {
 584         return;
 585     }
 586 
 587     /*
 588      * We want to count the number of items in the initializer list, because if
 589      * it is larger than the buffer length, we will define the buffer size
 590      * to be the size of the initializer list (as per the ACPI Specification)
 591      */
 592     switch (InitializerOp->Asl.ParseOpcode)
 593     {
 594     case PARSEOP_INTEGER:
 595     case PARSEOP_BYTECONST:
 596     case PARSEOP_WORDCONST:
 597     case PARSEOP_DWORDCONST:
 598 
 599         /* The peer list contains the byte list (if any...) */
 600 
 601         while (InitializerOp)
 602         {
 603             /* For buffers, this is a list of raw bytes */
 604 
 605             InitializerOp->Asl.AmlOpcode      = AML_RAW_DATA_BYTE;
 606             InitializerOp->Asl.AmlLength      = 1;
 607             InitializerOp->Asl.ParseOpcode    = PARSEOP_RAW_DATA;
 608 
 609             BufferLength++;
 610             InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
 611         }
 612         break;
 613 
 614     case PARSEOP_STRING_LITERAL:
 615 
 616         /*
 617          * Only one initializer, the string. Buffer must be big enough to hold
 618          * the string plus the null termination byte
 619          */
 620         BufferLength = strlen (InitializerOp->Asl.Value.String) + 1;
 621 
 622         InitializerOp->Asl.AmlOpcode      = AML_RAW_DATA_BUFFER;
 623         InitializerOp->Asl.AmlLength      = BufferLength;
 624         InitializerOp->Asl.ParseOpcode    = PARSEOP_RAW_DATA;
 625         break;
 626 
 627     case PARSEOP_RAW_DATA:
 628 
 629         /* Buffer nodes are already initialized (e.g. Unicode operator) */
 630         return;
 631 
 632     case PARSEOP_DEFAULT_ARG:
 633         break;
 634 
 635     default:
 636 
 637         AslError (ASL_ERROR, ASL_MSG_INVALID_OPERAND, InitializerOp,
 638             "Unknown buffer initializer opcode");
 639         printf ("Unknown buffer initializer opcode [%s]\n",
 640                         UtGetOpName (InitializerOp->Asl.ParseOpcode));
 641         return;
 642     }
 643 
 644     /* Check if initializer list is longer than the buffer length */
 645 
 646     if (BufferLengthOp->Asl.Value.Integer > BufferLength)
 647     {
 648         BufferLength = (UINT32) BufferLengthOp->Asl.Value.Integer;
 649     }
 650 
 651     if (!BufferLength)
 652     {
 653         /* No length AND no items -- issue notice */
 654 
 655         AslError (ASL_REMARK, ASL_MSG_BUFFER_LENGTH, BufferLengthOp, NULL);
 656 
 657         /* But go ahead and put the buffer length of zero into the AML */
 658     }
 659 
 660     /*
 661      * Just set the buffer size node to be the buffer length, regardless
 662      * of whether it was previously an integer or a default_arg placeholder
 663      */
 664     BufferLengthOp->Asl.ParseOpcode   = PARSEOP_INTEGER;
 665     BufferLengthOp->Asl.AmlOpcode     = AML_DWORD_OP;
 666     BufferLengthOp->Asl.Value.Integer = BufferLength;
 667 
 668     (void) OpcSetOptimalIntegerSize (BufferLengthOp);
 669 
 670     /* Remaining nodes are handled via the tree walk */
 671 }
 672 
 673 
 674 /*******************************************************************************
 675  *
 676  * FUNCTION:    OpnDoPackage
 677  *
 678  * PARAMETERS:  Op        - The parent parse node
 679  *
 680  * RETURN:      None
 681  *
 682  * DESCRIPTION: Construct the AML operands for the PACKAGE ASL keyword. NOTE:
 683  *              can only be called after constants have been folded, to ensure
 684  *              that the PackageLength operand has been fully reduced.
 685  *
 686  ******************************************************************************/
 687 
 688 void
 689 OpnDoPackage (
 690     ACPI_PARSE_OBJECT       *Op)
 691 {
 692     ACPI_PARSE_OBJECT       *InitializerOp;
 693     ACPI_PARSE_OBJECT       *PackageLengthOp;
 694     UINT32                  PackageLength = 0;
 695 
 696 
 697     /* Opcode and package length first, followed by the initializer list */
 698 
 699     PackageLengthOp = Op->Asl.Child;
 700     InitializerOp = PackageLengthOp->Asl.Next;
 701 
 702     /* Count the number of items in the initializer list */
 703 
 704     if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 705     {
 706         /* The peer list contains the byte list (if any...) */
 707 
 708         while (InitializerOp)
 709         {
 710             PackageLength++;
 711             InitializerOp = InitializerOp->Asl.Next;
 712         }
 713     }
 714 
 715     /* If package length is a constant, compare to the initializer list */
 716 
 717     if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER)      ||
 718         (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST))
 719     {
 720         if (PackageLengthOp->Asl.Value.Integer > PackageLength)
 721         {
 722             /*
 723              * Allow package length to be longer than the initializer
 724              * list -- but if the length of initializer list is nonzero,
 725              * issue a message since this is probably a coding error,
 726              * even though technically legal.
 727              */
 728             if (PackageLength > 0)
 729             {
 730                 AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT,
 731                     PackageLengthOp, NULL);
 732             }
 733 
 734             PackageLength = (UINT32) PackageLengthOp->Asl.Value.Integer;
 735         }
 736         else if (PackageLengthOp->Asl.Value.Integer < PackageLength)
 737         {
 738             /*
 739              * The package length is smaller than the length of the
 740              * initializer list. This is an error as per the ACPI spec.
 741              */
 742             AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG,
 743                 PackageLengthOp, NULL);
 744         }
 745     }
 746 
 747     if (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 748     {
 749         /*
 750          * This is the case if the PackageLength was left empty - Package()
 751          * The package length becomes the length of the initializer list
 752          */
 753         Op->Asl.Child->Asl.ParseOpcode = PARSEOP_INTEGER;
 754         Op->Asl.Child->Asl.Value.Integer = PackageLength;
 755 
 756         /* Set the AML opcode */
 757 
 758         (void) OpcSetOptimalIntegerSize (Op->Asl.Child);
 759     }
 760 
 761     /* If not a variable-length package, check for a zero package length */
 762 
 763     if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER)      ||
 764         (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST)   ||
 765         (PackageLengthOp->Asl.ParseOpcode == PARSEOP_ZERO)         ||
 766         (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG))
 767     {
 768         if (!PackageLength)
 769         {
 770             /* No length AND no initializer list -- issue a remark */
 771 
 772             AslError (ASL_REMARK, ASL_MSG_PACKAGE_LENGTH,
 773                 PackageLengthOp, NULL);
 774 
 775             /* But go ahead and put the buffer length of zero into the AML */
 776         }
 777     }
 778 
 779     /*
 780      * If the PackageLength is a constant <= 255, we can change the
 781      * AML opcode from VarPackage to a simple (ACPI 1.0) Package opcode.
 782      */
 783     if (((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
 784             (Op->Asl.Child->Asl.Value.Integer <= 255))  ||
 785         (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONE) ||
 786         (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONES)||
 787         (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ZERO))
 788     {
 789         Op->Asl.AmlOpcode = AML_PACKAGE_OP;
 790         Op->Asl.ParseOpcode = PARSEOP_PACKAGE;
 791 
 792         /*
 793          * Just set the package size node to be the package length, regardless
 794          * of whether it was previously an integer or a default_arg placeholder
 795          */
 796         PackageLengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
 797         PackageLengthOp->Asl.AmlLength = 1;
 798         PackageLengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
 799         PackageLengthOp->Asl.Value.Integer = PackageLength;
 800     }
 801 
 802     /* Remaining nodes are handled via the tree walk */
 803 }
 804 
 805 
 806 /*******************************************************************************
 807  *
 808  * FUNCTION:    OpnDoLoadTable
 809  *
 810  * PARAMETERS:  Op        - The parent parse node
 811  *
 812  * RETURN:      None
 813  *
 814  * DESCRIPTION: Construct the AML operands for the LOADTABLE ASL keyword.
 815  *
 816  ******************************************************************************/
 817 
 818 static void
 819 OpnDoLoadTable (
 820     ACPI_PARSE_OBJECT       *Op)
 821 {
 822     ACPI_PARSE_OBJECT       *Next;
 823 
 824 
 825     /* Opcode is parent node */
 826     /* First child is the table signature */
 827 
 828     Next = Op->Asl.Child;
 829 
 830     /* Second child is the OEM ID*/
 831 
 832     Next = Next->Asl.Next;
 833 
 834     /* Third child is the OEM table ID */
 835 
 836     Next = Next->Asl.Next;
 837 
 838     /* Fourth child is the RootPath string */
 839 
 840     Next = Next->Asl.Next;
 841     if (Next->Asl.ParseOpcode == PARSEOP_ZERO)
 842     {
 843         Next->Asl.ParseOpcode    = PARSEOP_STRING_LITERAL;
 844         Next->Asl.Value.String   = "\\";
 845         Next->Asl.AmlLength      = 2;
 846         OpcGenerateAmlOpcode (Next);
 847     }
 848 
 849 #ifdef ASL_FUTURE_IMPLEMENTATION
 850 
 851     /* TBD: NOT IMPLEMENTED */
 852     /* Fifth child is the [optional] ParameterPathString */
 853     /* Sixth child is the [optional] ParameterData */
 854 
 855     Next = Next->Asl.Next;
 856     if (Next->Asl.ParseOpcode == DEFAULT_ARG)
 857     {
 858         Next->Asl.AmlLength = 1;
 859         Next->Asl.ParseOpcode = ZERO;
 860         OpcGenerateAmlOpcode (Next);
 861     }
 862 
 863 
 864     Next = Next->Asl.Next;
 865     if (Next->Asl.ParseOpcode == DEFAULT_ARG)
 866     {
 867         Next->Asl.AmlLength = 1;
 868         Next->Asl.ParseOpcode = ZERO;
 869         OpcGenerateAmlOpcode (Next);
 870     }
 871 #endif
 872 }
 873 
 874 
 875 /*******************************************************************************
 876  *
 877  * FUNCTION:    OpnDoDefinitionBlock
 878  *
 879  * PARAMETERS:  Op        - The parent parse node
 880  *
 881  * RETURN:      None
 882  *
 883  * DESCRIPTION: Construct the AML operands for the DEFINITIONBLOCK ASL keyword
 884  *
 885  ******************************************************************************/
 886 
 887 static void
 888 OpnDoDefinitionBlock (
 889     ACPI_PARSE_OBJECT       *Op)
 890 {
 891     ACPI_PARSE_OBJECT       *Child;
 892     ACPI_SIZE               Length;
 893     UINT32                  i;
 894     char                    *Filename;
 895 
 896 
 897     /*
 898      * These nodes get stuffed into the table header. They are special
 899      * cased when the table is written to the output file.
 900      *
 901      * Mark all of these nodes as non-usable so they won't get output
 902      * as AML opcodes!
 903      */
 904 
 905     /* Get AML filename. Use it if non-null */
 906 
 907     Child = Op->Asl.Child;
 908     if (Child->Asl.Value.Buffer  &&
 909         *Child->Asl.Value.Buffer &&
 910         (Gbl_UseDefaultAmlFilename))
 911     {
 912         /*
 913          * We will use the AML filename that is embedded in the source file
 914          * for the output filename.
 915          */
 916         Filename = ACPI_ALLOCATE (strlen (Gbl_DirectoryPath) +
 917                     strlen ((char *) Child->Asl.Value.Buffer) + 1);
 918 
 919         /* Prepend the current directory path */
 920 
 921         strcpy (Filename, Gbl_DirectoryPath);
 922         strcat (Filename, (char *) Child->Asl.Value.Buffer);
 923 
 924         Gbl_OutputFilenamePrefix = Filename;
 925         UtConvertBackslashes (Gbl_OutputFilenamePrefix);
 926     }
 927     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 928 
 929     /* Signature */
 930 
 931     Child = Child->Asl.Next;
 932     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 933     if (Child->Asl.Value.String)
 934     {
 935         Gbl_TableSignature = Child->Asl.Value.String;
 936         if (ACPI_STRLEN (Gbl_TableSignature) != 4)
 937         {
 938             AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
 939                 "Length not exactly 4");
 940         }
 941 
 942         for (i = 0; i < 4; i++)
 943         {
 944             if (!isalnum ((int) Gbl_TableSignature[i]))
 945             {
 946                 AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
 947                     "Contains non-alphanumeric characters");
 948             }
 949         }
 950     }
 951 
 952     /* Revision */
 953 
 954     Child = Child->Asl.Next;
 955     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 956     /*
 957      * We used the revision to set the integer width earlier
 958      */
 959 
 960     /* OEMID */
 961 
 962     Child = Child->Asl.Next;
 963     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 964 
 965     /* OEM TableID */
 966 
 967     Child = Child->Asl.Next;
 968     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 969     if (Child->Asl.Value.String)
 970     {
 971         Length = ACPI_STRLEN (Child->Asl.Value.String);
 972         Gbl_TableId = AcpiOsAllocate (Length + 1);
 973         ACPI_STRCPY (Gbl_TableId, Child->Asl.Value.String);
 974 
 975         /*
 976          * Convert anything non-alphanumeric to an underscore. This
 977          * allows us to use the TableID to generate unique C symbols.
 978          */
 979         for (i = 0; i < Length; i++)
 980         {
 981             if (!isalnum ((int) Gbl_TableId[i]))
 982             {
 983                 Gbl_TableId[i] = '_';
 984             }
 985         }
 986     }
 987 
 988     /* OEM Revision */
 989 
 990     Child = Child->Asl.Next;
 991     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 992 }
 993 
 994 
 995 /*******************************************************************************
 996  *
 997  * FUNCTION:    UtGetArg
 998  *
 999  * PARAMETERS:  Op              - Get an argument for this op
1000  *              Argn            - Nth argument to get
1001  *
1002  * RETURN:      The argument (as an Op object). NULL if argument does not exist
1003  *
1004  * DESCRIPTION: Get the specified op's argument (peer)
1005  *
1006  ******************************************************************************/
1007 
1008 ACPI_PARSE_OBJECT *
1009 UtGetArg (
1010     ACPI_PARSE_OBJECT       *Op,
1011     UINT32                  Argn)
1012 {
1013     ACPI_PARSE_OBJECT       *Arg = NULL;
1014 
1015 
1016     /* Get the requested argument object */
1017 
1018     Arg = Op->Asl.Child;
1019     while (Arg && Argn)
1020     {
1021         Argn--;
1022         Arg = Arg->Asl.Next;
1023     }
1024 
1025     return (Arg);
1026 }
1027 
1028 
1029 /*******************************************************************************
1030  *
1031  * FUNCTION:    OpnAttachNameToNode
1032  *
1033  * PARAMETERS:  Op        - The parent parse node
1034  *
1035  * RETURN:      None
1036  *
1037  * DESCRIPTION: For the named ASL/AML operators, get the actual name from the
1038  *              argument list and attach it to the parent node so that we
1039  *              can get to it quickly later.
1040  *
1041  ******************************************************************************/
1042 
1043 static void
1044 OpnAttachNameToNode (
1045     ACPI_PARSE_OBJECT       *Op)
1046 {
1047     ACPI_PARSE_OBJECT       *Child = NULL;
1048 
1049 
1050     if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL)
1051     {
1052         Child = UtGetArg (Op, 0);
1053     }
1054     else switch (Op->Asl.AmlOpcode)
1055     {
1056     case AML_DATA_REGION_OP:
1057     case AML_DEVICE_OP:
1058     case AML_EVENT_OP:
1059     case AML_METHOD_OP:
1060     case AML_MUTEX_OP:
1061     case AML_REGION_OP:
1062     case AML_POWER_RES_OP:
1063     case AML_PROCESSOR_OP:
1064     case AML_THERMAL_ZONE_OP:
1065     case AML_NAME_OP:
1066     case AML_SCOPE_OP:
1067 
1068         Child = UtGetArg (Op, 0);
1069         break;
1070 
1071     case AML_ALIAS_OP:
1072 
1073         Child = UtGetArg (Op, 1);
1074         break;
1075 
1076     case AML_CREATE_BIT_FIELD_OP:
1077     case AML_CREATE_BYTE_FIELD_OP:
1078     case AML_CREATE_WORD_FIELD_OP:
1079     case AML_CREATE_DWORD_FIELD_OP:
1080     case AML_CREATE_QWORD_FIELD_OP:
1081 
1082         Child = UtGetArg (Op, 2);
1083         break;
1084 
1085     case AML_CREATE_FIELD_OP:
1086 
1087         Child = UtGetArg (Op, 3);
1088         break;
1089 
1090     case AML_BANK_FIELD_OP:
1091     case AML_INDEX_FIELD_OP:
1092     case AML_FIELD_OP:
1093 
1094         return;
1095 
1096     default:
1097 
1098         return;
1099     }
1100 
1101     if (Child)
1102     {
1103         UtAttachNamepathToOwner (Op, Child);
1104     }
1105 }
1106 
1107 
1108 /*******************************************************************************
1109  *
1110  * FUNCTION:    OpnGenerateAmlOperands
1111  *
1112  * PARAMETERS:  Op        - The parent parse node
1113  *
1114  * RETURN:      None
1115  *
1116  * DESCRIPTION: Prepare nodes to be output as AML data and operands. The more
1117  *              complex AML opcodes require processing of the child nodes
1118  *              (arguments/operands).
1119  *
1120  ******************************************************************************/
1121 
1122 void
1123 OpnGenerateAmlOperands (
1124     ACPI_PARSE_OBJECT       *Op)
1125 {
1126 
1127 
1128     if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
1129     {
1130         return;
1131     }
1132 
1133     switch (Op->Asl.ParseOpcode)
1134     {
1135     case PARSEOP_DEFINITIONBLOCK:
1136 
1137         OpnDoDefinitionBlock (Op);
1138         break;
1139 
1140     case PARSEOP_METHOD:
1141 
1142         OpnDoMethod (Op);
1143         break;
1144 
1145     case PARSEOP_MUTEX:
1146 
1147         OpnDoMutex (Op);
1148         break;
1149 
1150     case PARSEOP_FIELD:
1151 
1152         OpnDoField (Op);
1153         break;
1154 
1155     case PARSEOP_INDEXFIELD:
1156 
1157         OpnDoIndexField (Op);
1158         break;
1159 
1160     case PARSEOP_BANKFIELD:
1161 
1162         OpnDoBankField (Op);
1163         break;
1164 
1165     case PARSEOP_BUFFER:
1166 
1167         OpnDoBuffer (Op);
1168         break;
1169 
1170     case PARSEOP_LOADTABLE:
1171 
1172         OpnDoLoadTable (Op);
1173         break;
1174 
1175     case PARSEOP_OPERATIONREGION:
1176 
1177         OpnDoRegion (Op);
1178         break;
1179 
1180     case PARSEOP_RESOURCETEMPLATE:
1181 
1182         RsDoResourceTemplate (Op);
1183         break;
1184 
1185     case PARSEOP_NAMESEG:
1186     case PARSEOP_NAMESTRING:
1187     case PARSEOP_METHODCALL:
1188     case PARSEOP_STRING_LITERAL:
1189 
1190         break;
1191 
1192     default:
1193 
1194         break;
1195     }
1196 
1197     /* TBD: move */
1198 
1199     OpnAttachNameToNode (Op);
1200 }