sys/contrib/dev/acpica/source/compiler/asltransform.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asltransform - Parse tree transforms
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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
  48 #define _COMPONENT          ACPI_COMPILER
  49         ACPI_MODULE_NAME    ("asltransform")
  50
  51 /* Local prototypes */
  52
  53 static void
  54 TrTransformSubtree (
  55     ACPI_PARSE_OBJECT       *Op);
  56
  57 static char *
  58 TrAmlGetNextTempName (
  59     ACPI_PARSE_OBJECT       *Op,
  60     UINT8                   *TempCount);
  61
  62 static void
  63 TrAmlInitLineNumbers (
  64     ACPI_PARSE_OBJECT       *Op,
  65     ACPI_PARSE_OBJECT       *Neighbor);
  66
  67 static void
  68 TrAmlInitNode (
  69     ACPI_PARSE_OBJECT       *Op,
  70     UINT16                  ParseOpcode);
  71
  72 static void
  73 TrAmlSetSubtreeParent (
  74     ACPI_PARSE_OBJECT       *Op,
  75     ACPI_PARSE_OBJECT       *Parent);
  76
  77 static void
  78 TrAmlInsertPeer (
  79     ACPI_PARSE_OBJECT       *Op,
  80     ACPI_PARSE_OBJECT       *NewPeer);
  81
  82 static void
  83 TrDoDefinitionBlock (
  84     ACPI_PARSE_OBJECT       *Op);
  85
  86 static void
  87 TrDoSwitch (
  88     ACPI_PARSE_OBJECT       *StartNode);
  89
  90
  91 /*******************************************************************************
  92  *
  93  * FUNCTION:    TrAmlGetNextTempName
  94  *
  95  * PARAMETERS:  Op              - Current parse op
  96  *              TempCount       - Current temporary counter. Was originally
  97  *                                per-module; Currently per method, could be
  98  *                                expanded to per-scope.
  99  *
 100  * RETURN:      A pointer to name (allocated here).
 101  *
 102  * DESCRIPTION: Generate an ACPI name of the form _T_x. These names are
 103  *              reserved for use by the ASL compiler. (_T_0 through _T_Z)
 104  *
 105  ******************************************************************************/
 106
 107 static char *
 108 TrAmlGetNextTempName (
 109     ACPI_PARSE_OBJECT       *Op,
 110     UINT8                   *TempCount)
 111 {
 112     char                    *TempName;
 113
 114
 115     if (*TempCount >= (10+26))  /* 0-35 valid: 0-9 and A-Z for TempName[3] */
 116     {
 117         /* Too many temps */
 118
 119         AslError (ASL_ERROR, ASL_MSG_TOO_MANY_TEMPS, Op, NULL);
 120         return (NULL);
 121     }
 122
 123     TempName = UtLocalCalloc (5);
 124
 125     if (*TempCount < 10)    /* 0-9 */
 126     {
 127         TempName[3] = (char) (*TempCount + '0');
 128     }
 129     else                    /* 10-35: A-Z */
 130     {
 131         TempName[3] = (char) (*TempCount + ('A' - 10));
 132     }
 133     (*TempCount)++;
 134
 135     /* First three characters are always "_T_" */
 136
 137     TempName[0] = '_';
 138     TempName[1] = 'T';
 139     TempName[2] = '_';
 140
 141     return (TempName);
 142 }
 143
 144
 145 /*******************************************************************************
 146  *
 147  * FUNCTION:    TrAmlInitLineNumbers
 148  *
 149  * PARAMETERS:  Op              - Op to be initialized
 150  *              Neighbor        - Op used for initialization values
 151  *
 152  * RETURN:      None
 153  *
 154  * DESCRIPTION: Initialized the various line numbers for a parse node.
 155  *
 156  ******************************************************************************/
 157
 158 static void
 159 TrAmlInitLineNumbers (
 160     ACPI_PARSE_OBJECT       *Op,
 161     ACPI_PARSE_OBJECT       *Neighbor)
 162 {
 163
 164     Op->Asl.EndLine           = Neighbor->Asl.EndLine;
 165     Op->Asl.EndLogicalLine    = Neighbor->Asl.EndLogicalLine;
 166     Op->Asl.LineNumber        = Neighbor->Asl.LineNumber;
 167     Op->Asl.LogicalByteOffset = Neighbor->Asl.LogicalByteOffset;
 168     Op->Asl.LogicalLineNumber = Neighbor->Asl.LogicalLineNumber;
 169 }
 170
 171
 172 /*******************************************************************************
 173  *
 174  * FUNCTION:    TrAmlInitNode
 175  *
 176  * PARAMETERS:  Op              - Op to be initialized
 177  *              ParseOpcode     - Opcode for this node
 178  *
 179  * RETURN:      None
 180  *
 181  * DESCRIPTION: Initialize a node with the parse opcode and opcode name.
 182  *
 183  ******************************************************************************/
 184
 185 static void
 186 TrAmlInitNode (
 187     ACPI_PARSE_OBJECT       *Op,
 188     UINT16                  ParseOpcode)
 189 {
 190
 191     Op->Asl.ParseOpcode = ParseOpcode;
 192     UtSetParseOpName (Op);
 193 }
 194
 195
 196 /*******************************************************************************
 197  *
 198  * FUNCTION:    TrAmlSetSubtreeParent
 199  *
 200  * PARAMETERS:  Op              - First node in a list of peer nodes
 201  *              Parent          - Parent of the subtree
 202  *
 203  * RETURN:      None
 204  *
 205  * DESCRIPTION: Set the parent for all peer nodes in a subtree
 206  *
 207  ******************************************************************************/
 208
 209 static void
 210 TrAmlSetSubtreeParent (
 211     ACPI_PARSE_OBJECT       *Op,
 212     ACPI_PARSE_OBJECT       *Parent)
 213 {
 214     ACPI_PARSE_OBJECT       *Next;
 215
 216
 217     Next = Op;
 218     while (Next)
 219     {
 220         Next->Asl.Parent = Parent;
 221         Next             = Next->Asl.Next;
 222     }
 223 }
 224
 225
 226 /*******************************************************************************
 227  *
 228  * FUNCTION:    TrAmlInsertPeer
 229  *
 230  * PARAMETERS:  Op              - First node in a list of peer nodes
 231  *              NewPeer         - Peer node to insert
 232  *
 233  * RETURN:      None
 234  *
 235  * DESCRIPTION: Insert a new peer node into a list of peers.
 236  *
 237  ******************************************************************************/
 238
 239 static void
 240 TrAmlInsertPeer (
 241     ACPI_PARSE_OBJECT       *Op,
 242     ACPI_PARSE_OBJECT       *NewPeer)
 243 {
 244
 245     NewPeer->Asl.Next = Op->Asl.Next;
 246     Op->Asl.Next      = NewPeer;
 247 }
 248
 249
 250 /*******************************************************************************
 251  *
 252  * FUNCTION:    TrAmlTransformWalk
 253  *
 254  * PARAMETERS:  ASL_WALK_CALLBACK
 255  *
 256  * RETURN:      None
 257  *
 258  * DESCRIPTION: Parse tree walk to generate both the AML opcodes and the AML
 259  *              operands.
 260  *
 261  ******************************************************************************/
 262
 263 ACPI_STATUS
 264 TrAmlTransformWalk (
 265     ACPI_PARSE_OBJECT       *Op,
 266     UINT32                  Level,
 267     void                    *Context)
 268 {
 269
 270     TrTransformSubtree (Op);
 271     return (AE_OK);
 272 }
 273
 274
 275 /*******************************************************************************
 276  *
 277  * FUNCTION:    TrTransformSubtree
 278  *
 279  * PARAMETERS:  Op        - The parent parse node
 280  *
 281  * RETURN:      None
 282  *
 283  * DESCRIPTION: Prepare nodes to be output as AML data and operands. The more
 284  *              complex AML opcodes require processing of the child nodes
 285  *              (arguments/operands).
 286  *
 287  ******************************************************************************/
 288
 289 static void
 290 TrTransformSubtree (
 291     ACPI_PARSE_OBJECT           *Op)
 292 {
 293
 294     if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
 295     {
 296         return;
 297     }
 298
 299     switch (Op->Asl.ParseOpcode)
 300     {
 301     case PARSEOP_DEFINITIONBLOCK:
 302
 303         TrDoDefinitionBlock (Op);
 304         break;
 305
 306     case PARSEOP_SWITCH:
 307
 308         TrDoSwitch (Op);
 309         break;
 310
 311     case PARSEOP_METHOD:
 312         /*
 313          * TBD: Zero the tempname (_T_x) count. Probably shouldn't be a global,
 314          * however
 315          */
 316         Gbl_TempCount = 0;
 317         break;
 318
 319     default:
 320
 321         /* Nothing to do here for other opcodes */
 322
 323         break;
 324     }
 325 }
 326
 327
 328 /*******************************************************************************
 329  *
 330  * FUNCTION:    TrDoDefinitionBlock
 331  *
 332  * PARAMETERS:  Op        - Parse node
 333  *
 334  * RETURN:      None
 335  *
 336  * DESCRIPTION: Find the end of the definition block and set a global to this
 337  *              node. It is used by the compiler to insert compiler-generated
 338  *              names at the root level of the namespace.
 339  *
 340  ******************************************************************************/
 341
 342 static void
 343 TrDoDefinitionBlock (
 344     ACPI_PARSE_OBJECT       *Op)
 345 {
 346     ACPI_PARSE_OBJECT       *Next;
 347     UINT32                  i;
 348
 349
 350     Next = Op->Asl.Child;
 351     for (i = 0; i < 5; i++)
 352     {
 353         Next = Next->Asl.Next;
 354         if (i == 0)
 355         {
 356             /*
 357              * This is the table signature. Only the DSDT can be assumed
 358              * to be at the root of the namespace;  Therefore, namepath
 359              * optimization can only be performed on the DSDT.
 360              */
 361             if (!ACPI_COMPARE_NAME (Next->Asl.Value.String, ACPI_SIG_DSDT))
 362             {
 363                 Gbl_ReferenceOptimizationFlag = FALSE;
 364             }
 365         }
 366     }
 367
 368     Gbl_FirstLevelInsertionNode = Next;
 369 }
 370
 371
 372 /*******************************************************************************
 373  *
 374  * FUNCTION:    TrDoSwitch
 375  *
 376  * PARAMETERS:  StartNode        - Parse node for SWITCH
 377  *
 378  * RETURN:      None
 379  *
 380  *
 381  * DESCRIPTION: Translate ASL SWITCH statement to if/else pairs. There is
 382  *              no actual AML opcode for SWITCH -- it must be simulated.
 383  *
 384  ******************************************************************************/
 385
 386 static void
 387 TrDoSwitch (
 388     ACPI_PARSE_OBJECT       *StartNode)
 389 {
 390     ACPI_PARSE_OBJECT       *Next;
 391     ACPI_PARSE_OBJECT       *CaseOp = NULL;
 392     ACPI_PARSE_OBJECT       *CaseBlock = NULL;
 393     ACPI_PARSE_OBJECT       *DefaultOp = NULL;
 394     ACPI_PARSE_OBJECT       *CurrentParentNode;
 395     ACPI_PARSE_OBJECT       *Conditional = NULL;
 396     ACPI_PARSE_OBJECT       *Predicate;
 397     ACPI_PARSE_OBJECT       *Peer;
 398     ACPI_PARSE_OBJECT       *NewOp;
 399     ACPI_PARSE_OBJECT       *NewOp2;
 400     ACPI_PARSE_OBJECT       *MethodOp;
 401     ACPI_PARSE_OBJECT       *StoreOp;
 402     ACPI_PARSE_OBJECT       *BreakOp;
 403     ACPI_PARSE_OBJECT       *BufferOp;
 404     char                    *PredicateValueName;
 405     UINT16                  Index;
 406     UINT32                  Btype;
 407
 408
 409     /* Start node is the Switch() node */
 410
 411     CurrentParentNode  = StartNode;
 412
 413     /* Create a new temp name of the form _T_x */
 414
 415     PredicateValueName = TrAmlGetNextTempName (StartNode, &Gbl_TempCount);
 416     if (!PredicateValueName)
 417     {
 418         return;
 419     }
 420
 421     /* First child is the Switch() predicate */
 422
 423     Next = StartNode->Asl.Child;
 424
 425     /*
 426      * Examine the return type of the Switch Value -
 427      * must be Integer/Buffer/String
 428      */
 429     Index = (UINT16) (Next->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE);
 430     Btype = AslKeywordMapping[Index].AcpiBtype;
 431     if ((Btype != ACPI_BTYPE_INTEGER) &&
 432         (Btype != ACPI_BTYPE_STRING)  &&
 433         (Btype != ACPI_BTYPE_BUFFER))
 434     {
 435         AslError (ASL_WARNING, ASL_MSG_SWITCH_TYPE, Next, NULL);
 436         Btype = ACPI_BTYPE_INTEGER;
 437     }
 438
 439     /* CASE statements start at next child */
 440
 441     Peer = Next->Asl.Next;
 442     while (Peer)
 443     {
 444         Next = Peer;
 445         Peer = Next->Asl.Next;
 446
 447         if (Next->Asl.ParseOpcode == PARSEOP_CASE)
 448         {
 449             if (CaseOp)
 450             {
 451                 /* Add an ELSE to complete the previous CASE */
 452
 453                 NewOp             = TrCreateLeafNode (PARSEOP_ELSE);
 454                 NewOp->Asl.Parent = Conditional->Asl.Parent;
 455                 TrAmlInitLineNumbers (NewOp, NewOp->Asl.Parent);
 456
 457                 /* Link ELSE node as a peer to the previous IF */
 458
 459                 TrAmlInsertPeer (Conditional, NewOp);
 460                 CurrentParentNode = NewOp;
 461             }
 462
 463             CaseOp      = Next;
 464             Conditional = CaseOp;
 465             CaseBlock   = CaseOp->Asl.Child->Asl.Next;
 466             Conditional->Asl.Child->Asl.Next = NULL;
 467             Predicate = CaseOp->Asl.Child;
 468
 469             if ((Predicate->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
 470                 (Predicate->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
 471             {
 472                 /*
 473                  * Convert the package declaration to this form:
 474                  *
 475                  * If (LNotEqual (Match (Package(<size>){<data>},
 476                  *                       MEQ, _T_x, MTR, Zero, Zero), Ones))
 477                  */
 478                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);
 479                 Predicate->Asl.Next = NewOp2;
 480                 TrAmlInitLineNumbers (NewOp2, Conditional);
 481
 482                 NewOp               = NewOp2;
 483                 NewOp2              = TrCreateValuedLeafNode (PARSEOP_NAMESTRING,
 484                                         (UINT64) ACPI_TO_INTEGER (PredicateValueName));
 485                 NewOp->Asl.Next     = NewOp2;
 486                 TrAmlInitLineNumbers (NewOp2, Predicate);
 487
 488                 NewOp               = NewOp2;
 489                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);
 490                 NewOp->Asl.Next     = NewOp2;
 491                 TrAmlInitLineNumbers (NewOp2, Predicate);
 492
 493                 NewOp               = NewOp2;
 494                 NewOp2              = TrCreateLeafNode (PARSEOP_ZERO);
 495                 NewOp->Asl.Next     = NewOp2;
 496                 TrAmlInitLineNumbers (NewOp2, Predicate);
 497
 498                 NewOp               = NewOp2;
 499                 NewOp2              = TrCreateLeafNode (PARSEOP_ZERO);
 500                 NewOp->Asl.Next     = NewOp2;
 501                 TrAmlInitLineNumbers (NewOp2, Predicate);
 502
 503                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCH);
 504                 NewOp2->Asl.Child   = Predicate;  /* PARSEOP_PACKAGE */
 505                 TrAmlInitLineNumbers (NewOp2, Conditional);
 506                 TrAmlSetSubtreeParent (Predicate, NewOp2);
 507
 508                 NewOp               = NewOp2;
 509                 NewOp2              = TrCreateLeafNode (PARSEOP_ONES);
 510                 NewOp->Asl.Next     = NewOp2;
 511                 TrAmlInitLineNumbers (NewOp2, Conditional);
 512
 513                 NewOp2              = TrCreateLeafNode (PARSEOP_LEQUAL);
 514                 NewOp2->Asl.Child   = NewOp;
 515                 NewOp->Asl.Parent   = NewOp2;
 516                 TrAmlInitLineNumbers (NewOp2, Conditional);
 517                 TrAmlSetSubtreeParent (NewOp, NewOp2);
 518
 519                 NewOp               = NewOp2;
 520                 NewOp2              = TrCreateLeafNode (PARSEOP_LNOT);
 521                 NewOp2->Asl.Child   = NewOp;
 522                 NewOp2->Asl.Parent  = Conditional;
 523                 NewOp->Asl.Parent   = NewOp2;
 524                 TrAmlInitLineNumbers (NewOp2, Conditional);
 525
 526                 Conditional->Asl.Child = NewOp2;
 527                 NewOp2->Asl.Next = CaseBlock;
 528             }
 529             else
 530             {
 531                 /*
 532                  * Integer and Buffer case.
 533                  *
 534                  * Change CaseOp() to:  If (LEqual (SwitchValue, CaseValue)) {...}
 535                  * Note: SwitchValue is first to allow the CaseValue to be implicitly
 536                  * converted to the type of SwitchValue if necessary.
 537                  *
 538                  * CaseOp->Child is the case value
 539                  * CaseOp->Child->Peer is the beginning of the case block
 540                  */
 541                 NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESTRING,
 542                             (UINT64) ACPI_TO_INTEGER (PredicateValueName));
 543                 NewOp->Asl.Next = Predicate;
 544                 TrAmlInitLineNumbers (NewOp, Predicate);
 545
 546                 NewOp2              = TrCreateLeafNode (PARSEOP_LEQUAL);
 547                 NewOp2->Asl.Parent  = Conditional;
 548                 NewOp2->Asl.Child   = NewOp;
 549                 TrAmlInitLineNumbers (NewOp2, Conditional);
 550
 551                 TrAmlSetSubtreeParent (NewOp, NewOp2);
 552
 553                 Predicate           = NewOp2;
 554                 Predicate->Asl.Next = CaseBlock;
 555
 556                 TrAmlSetSubtreeParent (Predicate, Conditional);
 557                 Conditional->Asl.Child = Predicate;
 558             }
 559
 560             /* Reinitialize the CASE node to an IF node */
 561
 562             TrAmlInitNode (Conditional, PARSEOP_IF);
 563
 564             /*
 565              * The first CASE(IF) is not nested under an ELSE.
 566              * All other CASEs are children of a parent ELSE.
 567              */
 568             if (CurrentParentNode == StartNode)
 569             {
 570                 Conditional->Asl.Next = NULL;
 571             }
 572             else
 573             {
 574                 /*
 575                  * The IF is a child of previous IF/ELSE. It
 576                  * is therefore without peer.
 577                  */
 578                 CurrentParentNode->Asl.Child = Conditional;
 579                 Conditional->Asl.Parent      = CurrentParentNode;
 580                 Conditional->Asl.Next        = NULL;
 581             }
 582         }
 583         else if (Next->Asl.ParseOpcode == PARSEOP_DEFAULT)
 584         {
 585             if (DefaultOp)
 586             {
 587                 /*
 588                  * More than one Default
 589                  * (Parser does not catch this, must check here)
 590                  */
 591                 AslError (ASL_ERROR, ASL_MSG_MULTIPLE_DEFAULT, Next, NULL);
 592             }
 593             else
 594             {
 595                 /* Save the DEFAULT node for later, after CASEs */
 596
 597                 DefaultOp = Next;
 598             }
 599         }
 600         else
 601         {
 602             /* Unknown peer opcode */
 603
 604             AcpiOsPrintf ("Unknown parse opcode for switch statement: %s (%u)\n",
 605                         Next->Asl.ParseOpName, Next->Asl.ParseOpcode);
 606         }
 607     }
 608
 609     /* Add the default case at the end of the if/else construct */
 610
 611     if (DefaultOp)
 612     {
 613         /* If no CASE statements, this is an error - see below */
 614
 615         if (CaseOp)
 616         {
 617             /* Convert the DEFAULT node to an ELSE */
 618
 619             TrAmlInitNode (DefaultOp, PARSEOP_ELSE);
 620             DefaultOp->Asl.Parent = Conditional->Asl.Parent;
 621
 622             /* Link ELSE node as a peer to the previous IF */
 623
 624             TrAmlInsertPeer (Conditional, DefaultOp);
 625         }
 626     }
 627
 628     if (!CaseOp)
 629     {
 630         AslError (ASL_ERROR, ASL_MSG_NO_CASES, StartNode, NULL);
 631     }
 632
 633
 634     /*
 635      * Create a Name(_T_x, ...) statement. This statement must appear at the
 636      * method level, in case a loop surrounds the switch statement and could
 637      * cause the name to be created twice (error).
 638      */
 639
 640     /* Create the Name node */
 641
 642     Predicate = StartNode->Asl.Child;
 643     NewOp = TrCreateLeafNode (PARSEOP_NAME);
 644     TrAmlInitLineNumbers (NewOp, StartNode);
 645
 646     /* Find the parent method */
 647
 648     Next = StartNode;
 649     while ((Next->Asl.ParseOpcode != PARSEOP_METHOD) &&
 650            (Next->Asl.ParseOpcode != PARSEOP_DEFINITIONBLOCK))
 651     {
 652         Next = Next->Asl.Parent;
 653     }
 654     MethodOp = Next;
 655
 656     NewOp->Asl.CompileFlags |= NODE_COMPILER_EMITTED;
 657     NewOp->Asl.Parent = Next;
 658
 659     /* Insert name after the method name and arguments */
 660
 661     Next = Next->Asl.Child; /* Name */
 662     Next = Next->Asl.Next;  /* NumArgs */
 663     Next = Next->Asl.Next;  /* SerializeRule */
 664
 665     /*
 666      * If method is not Serialized, we must make is so, because of the way
 667      * that Switch() must be implemented -- we cannot allow multiple threads
 668      * to execute this method concurrently since we need to create local
 669      * temporary name(s).
 670      */
 671     if (Next->Asl.ParseOpcode != PARSEOP_SERIALIZERULE_SERIAL)
 672     {
 673         AslError (ASL_REMARK, ASL_MSG_SERIALIZED, MethodOp, "Due to use of Switch operator");
 674         Next->Asl.ParseOpcode = PARSEOP_SERIALIZERULE_SERIAL;
 675     }
 676
 677     Next = Next->Asl.Next;  /* SyncLevel */
 678     Next = Next->Asl.Next;  /* ReturnType */
 679     Next = Next->Asl.Next;  /* ParameterTypes */
 680
 681     TrAmlInsertPeer (Next, NewOp);
 682     TrAmlInitLineNumbers (NewOp, Next);
 683
 684     /* Create the NameSeg child for the Name node */
 685
 686     NewOp2 = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
 687                 (UINT64) ACPI_TO_INTEGER (PredicateValueName));
 688     TrAmlInitLineNumbers (NewOp2, NewOp);
 689     NewOp2->Asl.CompileFlags |= NODE_IS_NAME_DECLARATION;
 690     NewOp->Asl.Child  = NewOp2;
 691
 692     /* Create the initial value for the Name. Btype was already validated above */
 693
 694     switch (Btype)
 695     {
 696     case ACPI_BTYPE_INTEGER:
 697
 698         NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_ZERO,
 699                                 (UINT64) 0);
 700         TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp);
 701         break;
 702
 703     case ACPI_BTYPE_STRING:
 704
 705         NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL,
 706                                 (UINT64) ACPI_TO_INTEGER (""));
 707         TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp);
 708         break;
 709
 710     case ACPI_BTYPE_BUFFER:
 711
 712         (void) TrLinkPeerNode (NewOp2, TrCreateValuedLeafNode (PARSEOP_BUFFER,
 713                                     (UINT64) 0));
 714         Next = NewOp2->Asl.Next;
 715         TrAmlInitLineNumbers (Next, NewOp2);
 716         (void) TrLinkChildren (Next, 1, TrCreateValuedLeafNode (PARSEOP_ZERO,
 717                                     (UINT64) 1));
 718         TrAmlInitLineNumbers (Next->Asl.Child, Next);
 719
 720         BufferOp = TrCreateValuedLeafNode (PARSEOP_DEFAULT_ARG, (UINT64) 0);
 721         TrAmlInitLineNumbers (BufferOp, Next->Asl.Child);
 722         (void) TrLinkPeerNode (Next->Asl.Child, BufferOp);
 723
 724         TrAmlSetSubtreeParent (Next->Asl.Child, Next);
 725         break;
 726
 727     default:
 728
 729         break;
 730     }
 731
 732     TrAmlSetSubtreeParent (NewOp2, NewOp);
 733
 734     /*
 735      * Transform the Switch() into a While(One)-Break node.
 736      * And create a Store() node which will be used to save the
 737      * Switch() value. The store is of the form: Store (Value, _T_x)
 738      * where _T_x is the temp variable.
 739      */
 740     TrAmlInitNode (StartNode, PARSEOP_WHILE);
 741     NewOp = TrCreateLeafNode (PARSEOP_ONE);
 742     TrAmlInitLineNumbers (NewOp, StartNode);
 743     NewOp->Asl.Next = Predicate->Asl.Next;
 744     NewOp->Asl.Parent = StartNode;
 745     StartNode->Asl.Child = NewOp;
 746
 747     /* Create a Store() node */
 748
 749     StoreOp = TrCreateLeafNode (PARSEOP_STORE);
 750     TrAmlInitLineNumbers (StoreOp, NewOp);
 751     StoreOp->Asl.Parent = StartNode;
 752     TrAmlInsertPeer (NewOp, StoreOp);
 753
 754     /* Complete the Store subtree */
 755
 756     StoreOp->Asl.Child = Predicate;
 757     Predicate->Asl.Parent = StoreOp;
 758
 759     NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
 760                 (UINT64) ACPI_TO_INTEGER (PredicateValueName));
 761     TrAmlInitLineNumbers (NewOp, StoreOp);
 762     NewOp->Asl.Parent    = StoreOp;
 763     Predicate->Asl.Next  = NewOp;
 764
 765     /* Create a Break() node and insert it into the end of While() */
 766
 767     Conditional = StartNode->Asl.Child;
 768     while (Conditional->Asl.Next)
 769     {
 770         Conditional = Conditional->Asl.Next;
 771     }
 772
 773     BreakOp = TrCreateLeafNode (PARSEOP_BREAK);
 774     TrAmlInitLineNumbers (BreakOp, NewOp);
 775     BreakOp->Asl.Parent = StartNode;
 776     TrAmlInsertPeer (Conditional, BreakOp);
 777 }