arch/all-pc/acpica/source/compiler/asltree.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asltree - parse tree management
   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 "acapps.h"
  48 #include <time.h>
  49
  50 #define _COMPONENT          ACPI_COMPILER
  51         ACPI_MODULE_NAME    ("asltree")
  52
  53 /* Local prototypes */
  54
  55 static ACPI_PARSE_OBJECT *
  56 TrGetNextNode (
  57     void);
  58
  59 static char *
  60 TrGetNodeFlagName (
  61     UINT32                  Flags);
  62
  63
  64 /*******************************************************************************
  65  *
  66  * FUNCTION:    TrGetNextNode
  67  *
  68  * PARAMETERS:  None
  69  *
  70  * RETURN:      New parse node. Aborts on allocation failure
  71  *
  72  * DESCRIPTION: Allocate a new parse node for the parse tree. Bypass the local
  73  *              dynamic memory manager for performance reasons (This has a
  74  *              major impact on the speed of the compiler.)
  75  *
  76  ******************************************************************************/
  77
  78 static ACPI_PARSE_OBJECT *
  79 TrGetNextNode (
  80     void)
  81 {
  82
  83     if (Gbl_NodeCacheNext >= Gbl_NodeCacheLast)
  84     {
  85         Gbl_NodeCacheNext = UtLocalCalloc (sizeof (ACPI_PARSE_OBJECT) *
  86                                 ASL_NODE_CACHE_SIZE);
  87         Gbl_NodeCacheLast = Gbl_NodeCacheNext + ASL_NODE_CACHE_SIZE;
  88     }
  89
  90     return (Gbl_NodeCacheNext++);
  91 }
  92
  93
  94 /*******************************************************************************
  95  *
  96  * FUNCTION:    TrAllocateNode
  97  *
  98  * PARAMETERS:  ParseOpcode         - Opcode to be assigned to the node
  99  *
 100  * RETURN:      New parse node. Aborts on allocation failure
 101  *
 102  * DESCRIPTION: Allocate and initialize a new parse node for the parse tree
 103  *
 104  ******************************************************************************/
 105
 106 ACPI_PARSE_OBJECT *
 107 TrAllocateNode (
 108     UINT32                  ParseOpcode)
 109 {
 110     ACPI_PARSE_OBJECT       *Op;
 111
 112
 113     Op = TrGetNextNode ();
 114
 115     Op->Asl.ParseOpcode       = (UINT16) ParseOpcode;
 116     Op->Asl.Filename          = Gbl_Files[ASL_FILE_INPUT].Filename;
 117     Op->Asl.LineNumber        = Gbl_CurrentLineNumber;
 118     Op->Asl.LogicalLineNumber = Gbl_LogicalLineNumber;
 119     Op->Asl.LogicalByteOffset = Gbl_CurrentLineOffset;
 120     Op->Asl.Column            = Gbl_CurrentColumn;
 121
 122     UtSetParseOpName (Op);
 123     return (Op);
 124 }
 125
 126
 127 /*******************************************************************************
 128  *
 129  * FUNCTION:    TrReleaseNode
 130  *
 131  * PARAMETERS:  Op            - Op to be released
 132  *
 133  * RETURN:      None
 134  *
 135  * DESCRIPTION: "release" a node. In truth, nothing is done since the node
 136  *              is part of a larger buffer
 137  *
 138  ******************************************************************************/
 139
 140 void
 141 TrReleaseNode (
 142     ACPI_PARSE_OBJECT       *Op)
 143 {
 144
 145     return;
 146 }
 147
 148
 149 /*******************************************************************************
 150  *
 151  * FUNCTION:    TrUpdateNode
 152  *
 153  * PARAMETERS:  ParseOpcode         - New opcode to be assigned to the node
 154  *              Op                - An existing parse node
 155  *
 156  * RETURN:      The updated node
 157  *
 158  * DESCRIPTION: Change the parse opcode assigned to a node. Usually used to
 159  *              change an opcode to DEFAULT_ARG so that the node is ignored
 160  *              during the code generation. Also used to set generic integers
 161  *              to a specific size (8, 16, 32, or 64 bits)
 162  *
 163  ******************************************************************************/
 164
 165 ACPI_PARSE_OBJECT *
 166 TrUpdateNode (
 167     UINT32                  ParseOpcode,
 168     ACPI_PARSE_OBJECT       *Op)
 169 {
 170
 171     if (!Op)
 172     {
 173         return (NULL);
 174     }
 175
 176     DbgPrint (ASL_PARSE_OUTPUT,
 177         "\nUpdateNode: Old - %s, New - %s\n\n",
 178         UtGetOpName (Op->Asl.ParseOpcode),
 179         UtGetOpName (ParseOpcode));
 180
 181     /* Assign new opcode and name */
 182
 183     if (Op->Asl.ParseOpcode == PARSEOP_ONES)
 184     {
 185         switch (ParseOpcode)
 186         {
 187         case PARSEOP_BYTECONST:
 188
 189             Op->Asl.Value.Integer = ACPI_UINT8_MAX;
 190             break;
 191
 192         case PARSEOP_WORDCONST:
 193
 194             Op->Asl.Value.Integer = ACPI_UINT16_MAX;
 195             break;
 196
 197         case PARSEOP_DWORDCONST:
 198
 199             Op->Asl.Value.Integer = ACPI_UINT32_MAX;
 200             break;
 201
 202         /* Don't need to do the QWORD case */
 203
 204         default:
 205
 206             /* Don't care about others */
 207             break;
 208         }
 209     }
 210
 211     Op->Asl.ParseOpcode = (UINT16) ParseOpcode;
 212     UtSetParseOpName (Op);
 213
 214     /*
 215      * For the BYTE, WORD, and DWORD constants, make sure that the integer
 216      * that was passed in will actually fit into the data type
 217      */
 218     switch (ParseOpcode)
 219     {
 220     case PARSEOP_BYTECONST:
 221
 222         UtCheckIntegerRange (Op, 0x00, ACPI_UINT8_MAX);
 223         Op->Asl.Value.Integer &= ACPI_UINT8_MAX;
 224         break;
 225
 226     case PARSEOP_WORDCONST:
 227
 228         UtCheckIntegerRange (Op, 0x00, ACPI_UINT16_MAX);
 229         Op->Asl.Value.Integer &= ACPI_UINT16_MAX;
 230         break;
 231
 232     case PARSEOP_DWORDCONST:
 233
 234         UtCheckIntegerRange (Op, 0x00, ACPI_UINT32_MAX);
 235         Op->Asl.Value.Integer &= ACPI_UINT32_MAX;
 236         break;
 237
 238     default:
 239
 240         /* Don't care about others, don't need to check QWORD */
 241
 242         break;
 243     }
 244
 245     return (Op);
 246 }
 247
 248
 249 /*******************************************************************************
 250  *
 251  * FUNCTION:    TrGetNodeFlagName
 252  *
 253  * PARAMETERS:  Flags               - Flags word to be decoded
 254  *
 255  * RETURN:      Name string. Always returns a valid string pointer.
 256  *
 257  * DESCRIPTION: Decode a flags word
 258  *
 259  ******************************************************************************/
 260
 261 static char *
 262 TrGetNodeFlagName (
 263     UINT32                  Flags)
 264 {
 265
 266     switch (Flags)
 267     {
 268     case NODE_VISITED:
 269
 270         return ("NODE_VISITED");
 271
 272     case NODE_AML_PACKAGE:
 273
 274         return ("NODE_AML_PACKAGE");
 275
 276     case NODE_IS_TARGET:
 277
 278         return ("NODE_IS_TARGET");
 279
 280     case NODE_IS_RESOURCE_DESC:
 281
 282         return ("NODE_IS_RESOURCE_DESC");
 283
 284     case NODE_IS_RESOURCE_FIELD:
 285
 286         return ("NODE_IS_RESOURCE_FIELD");
 287
 288     case NODE_HAS_NO_EXIT:
 289
 290         return ("NODE_HAS_NO_EXIT");
 291
 292     case NODE_IF_HAS_NO_EXIT:
 293
 294         return ("NODE_IF_HAS_NO_EXIT");
 295
 296     case NODE_NAME_INTERNALIZED:
 297
 298         return ("NODE_NAME_INTERNALIZED");
 299
 300     case NODE_METHOD_NO_RETVAL:
 301
 302         return ("NODE_METHOD_NO_RETVAL");
 303
 304     case NODE_METHOD_SOME_NO_RETVAL:
 305
 306         return ("NODE_METHOD_SOME_NO_RETVAL");
 307
 308     case NODE_RESULT_NOT_USED:
 309
 310         return ("NODE_RESULT_NOT_USED");
 311
 312     case NODE_METHOD_TYPED:
 313
 314         return ("NODE_METHOD_TYPED");
 315
 316     case NODE_COMPILE_TIME_CONST:
 317
 318         return ("NODE_COMPILE_TIME_CONST");
 319
 320     case NODE_IS_TERM_ARG:
 321
 322         return ("NODE_IS_TERM_ARG");
 323
 324     case NODE_WAS_ONES_OP:
 325
 326         return ("NODE_WAS_ONES_OP");
 327
 328     case NODE_IS_NAME_DECLARATION:
 329
 330         return ("NODE_IS_NAME_DECLARATION");
 331
 332     default:
 333
 334         return ("Multiple Flags (or unknown flag) set");
 335     }
 336 }
 337
 338
 339 /*******************************************************************************
 340  *
 341  * FUNCTION:    TrSetNodeFlags
 342  *
 343  * PARAMETERS:  Op                  - An existing parse node
 344  *              Flags               - New flags word
 345  *
 346  * RETURN:      The updated parser op
 347  *
 348  * DESCRIPTION: Set bits in the node flags word. Will not clear bits, only set
 349  *
 350  ******************************************************************************/
 351
 352 ACPI_PARSE_OBJECT *
 353 TrSetNodeFlags (
 354     ACPI_PARSE_OBJECT       *Op,
 355     UINT32                  Flags)
 356 {
 357
 358     DbgPrint (ASL_PARSE_OUTPUT,
 359         "\nSetNodeFlags: Op %p, %8.8X %s\n\n", Op, Flags,
 360         TrGetNodeFlagName (Flags));
 361
 362     if (!Op)
 363     {
 364         return (NULL);
 365     }
 366
 367     Op->Asl.CompileFlags |= Flags;
 368     return (Op);
 369 }
 370
 371
 372 /*******************************************************************************
 373  *
 374  * FUNCTION:    TrSetNodeAmlLength
 375  *
 376  * PARAMETERS:  Op                  - An existing parse node
 377  *              Length              - AML Length
 378  *
 379  * RETURN:      The updated parser op
 380  *
 381  * DESCRIPTION: Set the AML Length in a node. Used by the parser to indicate
 382  *              the presence of a node that must be reduced to a fixed length
 383  *              constant.
 384  *
 385  ******************************************************************************/
 386
 387 ACPI_PARSE_OBJECT *
 388 TrSetNodeAmlLength (
 389     ACPI_PARSE_OBJECT       *Op,
 390     UINT32                  Length)
 391 {
 392
 393     DbgPrint (ASL_PARSE_OUTPUT,
 394         "\nSetNodeAmlLength: Op %p, %8.8X\n", Op, Length);
 395
 396     if (!Op)
 397     {
 398         return (NULL);
 399     }
 400
 401     Op->Asl.AmlLength = Length;
 402     return (Op);
 403 }
 404
 405
 406 /*******************************************************************************
 407  *
 408  * FUNCTION:    TrSetEndLineNumber
 409  *
 410  * PARAMETERS:  Op                - An existing parse node
 411  *
 412  * RETURN:      None.
 413  *
 414  * DESCRIPTION: Set the ending line numbers (file line and logical line) of a
 415  *              parse node to the current line numbers.
 416  *
 417  ******************************************************************************/
 418
 419 void
 420 TrSetEndLineNumber (
 421     ACPI_PARSE_OBJECT       *Op)
 422 {
 423
 424     /* If the end line # is already set, just return */
 425
 426     if (Op->Asl.EndLine)
 427     {
 428         return;
 429     }
 430
 431     Op->Asl.EndLine        = Gbl_CurrentLineNumber;
 432     Op->Asl.EndLogicalLine = Gbl_LogicalLineNumber;
 433 }
 434
 435
 436 /*******************************************************************************
 437  *
 438  * FUNCTION:    TrCreateLeafNode
 439  *
 440  * PARAMETERS:  ParseOpcode         - New opcode to be assigned to the node
 441  *
 442  * RETURN:      Pointer to the new node. Aborts on allocation failure
 443  *
 444  * DESCRIPTION: Create a simple leaf node (no children or peers, and no value
 445  *              assigned to the node)
 446  *
 447  ******************************************************************************/
 448
 449 ACPI_PARSE_OBJECT *
 450 TrCreateLeafNode (
 451     UINT32                  ParseOpcode)
 452 {
 453     ACPI_PARSE_OBJECT       *Op;
 454
 455
 456     Op = TrAllocateNode (ParseOpcode);
 457
 458     DbgPrint (ASL_PARSE_OUTPUT,
 459         "\nCreateLeafNode  Ln/Col %u/%u NewNode %p  Op %s\n\n",
 460         Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName(ParseOpcode));
 461
 462     return (Op);
 463 }
 464
 465
 466 /*******************************************************************************
 467  *
 468  * FUNCTION:    TrCreateConstantLeafNode
 469  *
 470  * PARAMETERS:  ParseOpcode         - The constant opcode
 471  *
 472  * RETURN:      Pointer to the new node. Aborts on allocation failure
 473  *
 474  * DESCRIPTION: Create a leaf node (no children or peers) for one of the
 475  *              special constants - __LINE__, __FILE__, and __DATE__.
 476  *
 477  * Note: An implemenation of __FUNC__ cannot happen here because we don't
 478  * have a full parse tree at this time and cannot find the parent control
 479  * method. If it is ever needed, __FUNC__ must be implemented later, after
 480  * the parse tree has been fully constructed.
 481  *
 482  ******************************************************************************/
 483
 484 ACPI_PARSE_OBJECT *
 485 TrCreateConstantLeafNode (
 486     UINT32                  ParseOpcode)
 487 {
 488     ACPI_PARSE_OBJECT       *Op = NULL;
 489     time_t                  CurrentTime;
 490     char                    *StaticTimeString;
 491     char                    *TimeString;
 492     char                    *Path;
 493     char                    *Filename;
 494
 495
 496     switch (ParseOpcode)
 497     {
 498     case PARSEOP___LINE__:
 499
 500         Op = TrAllocateNode (PARSEOP_INTEGER);
 501         Op->Asl.Value.Integer = Op->Asl.LineNumber;
 502         break;
 503
 504     case PARSEOP___PATH__:
 505
 506         Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
 507
 508         /* Op.Asl.Filename contains the full pathname to the file */
 509
 510         Op->Asl.Value.String = Op->Asl.Filename;
 511         break;
 512
 513     case PARSEOP___FILE__:
 514
 515         Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
 516
 517         /* Get the simple filename from the full path */
 518
 519         FlSplitInputPathname (Op->Asl.Filename, &Path, &Filename);
 520         ACPI_FREE (Path);
 521         Op->Asl.Value.String = Filename;
 522         break;
 523
 524     case PARSEOP___DATE__:
 525
 526         Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
 527
 528         /* Get a copy of the current time */
 529
 530         CurrentTime = time (NULL);
 531         StaticTimeString = ctime (&CurrentTime);
 532         TimeString = UtLocalCalloc (strlen (StaticTimeString) + 1);
 533         strcpy (TimeString, StaticTimeString);
 534
 535         TimeString[strlen(TimeString) -1] = 0;  /* Remove trailing newline */
 536         Op->Asl.Value.String = TimeString;
 537         break;
 538
 539     default: /* This would be an internal error */
 540
 541         return (NULL);
 542     }
 543
 544     DbgPrint (ASL_PARSE_OUTPUT,
 545         "\nCreateConstantLeafNode  Ln/Col %u/%u NewNode %p  Op %s  Value %8.8X%8.8X  ",
 546         Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName (ParseOpcode),
 547         ACPI_FORMAT_UINT64 (Op->Asl.Value.Integer));
 548     return (Op);
 549 }
 550
 551
 552 /*******************************************************************************
 553  *
 554  * FUNCTION:    TrCreateValuedLeafNode
 555  *
 556  * PARAMETERS:  ParseOpcode         - New opcode to be assigned to the node
 557  *              Value               - Value to be assigned to the node
 558  *
 559  * RETURN:      Pointer to the new node. Aborts on allocation failure
 560  *
 561  * DESCRIPTION: Create a leaf node (no children or peers) with a value
 562  *              assigned to it
 563  *
 564  ******************************************************************************/
 565
 566 ACPI_PARSE_OBJECT *
 567 TrCreateValuedLeafNode (
 568     UINT32                  ParseOpcode,
 569     UINT64                  Value)
 570 {
 571     ACPI_PARSE_OBJECT       *Op;
 572
 573
 574     Op = TrAllocateNode (ParseOpcode);
 575
 576     DbgPrint (ASL_PARSE_OUTPUT,
 577         "\nCreateValuedLeafNode  Ln/Col %u/%u NewNode %p  Op %s  Value %8.8X%8.8X  ",
 578         Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName(ParseOpcode),
 579         ACPI_FORMAT_UINT64 (Value));
 580     Op->Asl.Value.Integer = Value;
 581
 582     switch (ParseOpcode)
 583     {
 584     case PARSEOP_STRING_LITERAL:
 585
 586         DbgPrint (ASL_PARSE_OUTPUT, "STRING->%s", Value);
 587         break;
 588
 589     case PARSEOP_NAMESEG:
 590
 591         DbgPrint (ASL_PARSE_OUTPUT, "NAMESEG->%s", Value);
 592         break;
 593
 594     case PARSEOP_NAMESTRING:
 595
 596         DbgPrint (ASL_PARSE_OUTPUT, "NAMESTRING->%s", Value);
 597         break;
 598
 599     case PARSEOP_EISAID:
 600
 601         DbgPrint (ASL_PARSE_OUTPUT, "EISAID->%s", Value);
 602         break;
 603
 604     case PARSEOP_METHOD:
 605
 606         DbgPrint (ASL_PARSE_OUTPUT, "METHOD");
 607         break;
 608
 609     case PARSEOP_INTEGER:
 610
 611         DbgPrint (ASL_PARSE_OUTPUT, "INTEGER");
 612         break;
 613
 614     default:
 615
 616         break;
 617     }
 618
 619     DbgPrint (ASL_PARSE_OUTPUT, "\n\n");
 620     return (Op);
 621 }
 622
 623
 624 /*******************************************************************************
 625  *
 626  * FUNCTION:    TrCreateNode
 627  *
 628  * PARAMETERS:  ParseOpcode         - Opcode to be assigned to the node
 629  *              NumChildren         - Number of children to follow
 630  *              ...                 - A list of child nodes to link to the new
 631  *                                    node. NumChildren long.
 632  *
 633  * RETURN:      Pointer to the new node. Aborts on allocation failure
 634  *
 635  * DESCRIPTION: Create a new parse node and link together a list of child
 636  *              nodes underneath the new node.
 637  *
 638  ******************************************************************************/
 639
 640 ACPI_PARSE_OBJECT *
 641 TrCreateNode (
 642     UINT32                  ParseOpcode,
 643     UINT32                  NumChildren,
 644     ...)
 645 {
 646     ACPI_PARSE_OBJECT       *Op;
 647     ACPI_PARSE_OBJECT       *Child;
 648     ACPI_PARSE_OBJECT       *PrevChild;
 649     va_list                 ap;
 650     UINT32                  i;
 651     BOOLEAN                 FirstChild;
 652
 653
 654     va_start (ap, NumChildren);
 655
 656     /* Allocate one new node */
 657
 658     Op = TrAllocateNode (ParseOpcode);
 659
 660     DbgPrint (ASL_PARSE_OUTPUT,
 661         "\nCreateNode  Ln/Col %u/%u NewParent %p Child %u Op %s  ",
 662         Op->Asl.LineNumber, Op->Asl.Column, Op, NumChildren, UtGetOpName(ParseOpcode));
 663
 664     /* Some extra debug output based on the parse opcode */
 665
 666     switch (ParseOpcode)
 667     {
 668     case PARSEOP_DEFINITIONBLOCK:
 669
 670         RootNode = Op;
 671         DbgPrint (ASL_PARSE_OUTPUT, "DEFINITION_BLOCK (Tree Completed)->");
 672         break;
 673
 674     case PARSEOP_OPERATIONREGION:
 675
 676         DbgPrint (ASL_PARSE_OUTPUT, "OPREGION->");
 677         break;
 678
 679     case PARSEOP_OR:
 680
 681         DbgPrint (ASL_PARSE_OUTPUT, "OR->");
 682         break;
 683
 684     default:
 685
 686         /* Nothing to do for other opcodes */
 687
 688         break;
 689     }
 690
 691     /* Link the new node to its children */
 692
 693     PrevChild = NULL;
 694     FirstChild = TRUE;
 695     for (i = 0; i < NumChildren; i++)
 696     {
 697         /* Get the next child */
 698
 699         Child = va_arg (ap, ACPI_PARSE_OBJECT *);
 700         DbgPrint (ASL_PARSE_OUTPUT, "%p, ", Child);
 701
 702         /*
 703          * If child is NULL, this means that an optional argument
 704          * was omitted. We must create a placeholder with a special
 705          * opcode (DEFAULT_ARG) so that the code generator will know
 706          * that it must emit the correct default for this argument
 707          */
 708         if (!Child)
 709         {
 710             Child = TrAllocateNode (PARSEOP_DEFAULT_ARG);
 711         }
 712
 713         /* Link first child to parent */
 714
 715         if (FirstChild)
 716         {
 717             FirstChild = FALSE;
 718             Op->Asl.Child = Child;
 719         }
 720
 721         /* Point all children to parent */
 722
 723         Child->Asl.Parent = Op;
 724
 725         /* Link children in a peer list */
 726
 727         if (PrevChild)
 728         {
 729             PrevChild->Asl.Next = Child;
 730         };
 731
 732         /*
 733          * This child might be a list, point all nodes in the list
 734          * to the same parent
 735          */
 736         while (Child->Asl.Next)
 737         {
 738             Child = Child->Asl.Next;
 739             Child->Asl.Parent = Op;
 740         }
 741
 742         PrevChild = Child;
 743     }
 744     va_end(ap);
 745
 746     DbgPrint (ASL_PARSE_OUTPUT, "\n\n");
 747     return (Op);
 748 }
 749
 750
 751 /*******************************************************************************
 752  *
 753  * FUNCTION:    TrLinkChildren
 754  *
 755  * PARAMETERS:  Op                - An existing parse node
 756  *              NumChildren         - Number of children to follow
 757  *              ...                 - A list of child nodes to link to the new
 758  *                                    node. NumChildren long.
 759  *
 760  * RETURN:      The updated (linked) node
 761  *
 762  * DESCRIPTION: Link a group of nodes to an existing parse node
 763  *
 764  ******************************************************************************/
 765
 766 ACPI_PARSE_OBJECT *
 767 TrLinkChildren (
 768     ACPI_PARSE_OBJECT       *Op,
 769     UINT32                  NumChildren,
 770     ...)
 771 {
 772     ACPI_PARSE_OBJECT       *Child;
 773     ACPI_PARSE_OBJECT       *PrevChild;
 774     va_list                 ap;
 775     UINT32                  i;
 776     BOOLEAN                 FirstChild;
 777
 778
 779     va_start (ap, NumChildren);
 780
 781
 782     TrSetEndLineNumber (Op);
 783
 784     DbgPrint (ASL_PARSE_OUTPUT,
 785         "\nLinkChildren  Line [%u to %u] NewParent %p Child %u Op %s  ",
 786         Op->Asl.LineNumber, Op->Asl.EndLine,
 787         Op, NumChildren, UtGetOpName(Op->Asl.ParseOpcode));
 788
 789     switch (Op->Asl.ParseOpcode)
 790     {
 791     case PARSEOP_DEFINITIONBLOCK:
 792
 793         RootNode = Op;
 794         DbgPrint (ASL_PARSE_OUTPUT, "DEFINITION_BLOCK (Tree Completed)->");
 795         break;
 796
 797     case PARSEOP_OPERATIONREGION:
 798
 799         DbgPrint (ASL_PARSE_OUTPUT, "OPREGION->");
 800         break;
 801
 802     case PARSEOP_OR:
 803
 804         DbgPrint (ASL_PARSE_OUTPUT, "OR->");
 805         break;
 806
 807     default:
 808
 809         /* Nothing to do for other opcodes */
 810
 811         break;
 812     }
 813
 814     /* Link the new node to it's children */
 815
 816     PrevChild = NULL;
 817     FirstChild = TRUE;
 818     for (i = 0; i < NumChildren; i++)
 819     {
 820         Child = va_arg (ap, ACPI_PARSE_OBJECT *);
 821
 822         if ((Child == PrevChild) && (Child != NULL))
 823         {
 824             AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Child,
 825                 "Child node list invalid");
 826             va_end(ap);
 827             return (Op);
 828         }
 829
 830         DbgPrint (ASL_PARSE_OUTPUT, "%p, ", Child);
 831
 832         /*
 833          * If child is NULL, this means that an optional argument
 834          * was omitted. We must create a placeholder with a special
 835          * opcode (DEFAULT_ARG) so that the code generator will know
 836          * that it must emit the correct default for this argument
 837          */
 838         if (!Child)
 839         {
 840             Child = TrAllocateNode (PARSEOP_DEFAULT_ARG);
 841         }
 842
 843         /* Link first child to parent */
 844
 845         if (FirstChild)
 846         {
 847             FirstChild = FALSE;
 848             Op->Asl.Child = Child;
 849         }
 850
 851         /* Point all children to parent */
 852
 853         Child->Asl.Parent = Op;
 854
 855         /* Link children in a peer list */
 856
 857         if (PrevChild)
 858         {
 859             PrevChild->Asl.Next = Child;
 860         };
 861
 862         /*
 863          * This child might be a list, point all nodes in the list
 864          * to the same parent
 865          */
 866         while (Child->Asl.Next)
 867         {
 868             Child = Child->Asl.Next;
 869             Child->Asl.Parent = Op;
 870         }
 871         PrevChild = Child;
 872     }
 873
 874     va_end(ap);
 875     DbgPrint (ASL_PARSE_OUTPUT, "\n\n");
 876     return (Op);
 877 }
 878
 879
 880 /*******************************************************************************
 881  *
 882  * FUNCTION:    TrLinkPeerNode
 883  *
 884  * PARAMETERS:  Op1           - First peer
 885  *              Op2           - Second peer
 886  *
 887  * RETURN:      Op1 or the non-null node.
 888  *
 889  * DESCRIPTION: Link two nodes as peers. Handles cases where one peer is null.
 890  *
 891  ******************************************************************************/
 892
 893 ACPI_PARSE_OBJECT *
 894 TrLinkPeerNode (
 895     ACPI_PARSE_OBJECT       *Op1,
 896     ACPI_PARSE_OBJECT       *Op2)
 897 {
 898     ACPI_PARSE_OBJECT       *Next;
 899
 900
 901     DbgPrint (ASL_PARSE_OUTPUT,
 902         "\nLinkPeerNode: 1=%p (%s), 2=%p (%s)\n\n",
 903         Op1, Op1 ? UtGetOpName(Op1->Asl.ParseOpcode) : NULL,
 904         Op2, Op2 ? UtGetOpName(Op2->Asl.ParseOpcode) : NULL);
 905
 906
 907     if ((!Op1) && (!Op2))
 908     {
 909         DbgPrint (ASL_PARSE_OUTPUT, "\nTwo Null nodes!\n");
 910         return (Op1);
 911     }
 912
 913     /* If one of the nodes is null, just return the non-null node */
 914
 915     if (!Op2)
 916     {
 917         return (Op1);
 918     }
 919
 920     if (!Op1)
 921     {
 922         return (Op2);
 923     }
 924
 925     if (Op1 == Op2)
 926     {
 927         DbgPrint (ASL_DEBUG_OUTPUT,
 928             "\n\n************* Internal error, linking node to itself %p\n\n\n",
 929             Op1);
 930         AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Op1,
 931             "Linking node to itself");
 932         return (Op1);
 933     }
 934
 935     Op1->Asl.Parent = Op2->Asl.Parent;
 936
 937     /*
 938      * Op 1 may already have a peer list (such as an IF/ELSE pair),
 939      * so we must walk to the end of the list and attach the new
 940      * peer at the end
 941      */
 942     Next = Op1;
 943     while (Next->Asl.Next)
 944     {
 945         Next = Next->Asl.Next;
 946     }
 947
 948     Next->Asl.Next = Op2;
 949     return (Op1);
 950 }
 951
 952
 953 /*******************************************************************************
 954  *
 955  * FUNCTION:    TrLinkPeerNodes
 956  *
 957  * PARAMETERS:  NumPeers            - The number of nodes in the list to follow
 958  *              ...                 - A list of nodes to link together as peers
 959  *
 960  * RETURN:      The first node in the list (head of the peer list)
 961  *
 962  * DESCRIPTION: Link together an arbitrary number of peer nodes.
 963  *
 964  ******************************************************************************/
 965
 966 ACPI_PARSE_OBJECT *
 967 TrLinkPeerNodes (
 968     UINT32                  NumPeers,
 969     ...)
 970 {
 971     ACPI_PARSE_OBJECT       *This;
 972     ACPI_PARSE_OBJECT       *Next;
 973     va_list                 ap;
 974     UINT32                  i;
 975     ACPI_PARSE_OBJECT       *Start;
 976
 977
 978     DbgPrint (ASL_PARSE_OUTPUT,
 979         "\nLinkPeerNodes: (%u) ", NumPeers);
 980
 981     va_start (ap, NumPeers);
 982     This = va_arg (ap, ACPI_PARSE_OBJECT *);
 983     Start = This;
 984
 985     /*
 986      * Link all peers
 987      */
 988     for (i = 0; i < (NumPeers -1); i++)
 989     {
 990         DbgPrint (ASL_PARSE_OUTPUT, "%u=%p ", (i+1), This);
 991
 992         while (This->Asl.Next)
 993         {
 994             This = This->Asl.Next;
 995         }
 996
 997         /* Get another peer node */
 998
 999         Next = va_arg (ap, ACPI_PARSE_OBJECT *);
1000         if (!Next)
1001         {
1002             Next = TrAllocateNode (PARSEOP_DEFAULT_ARG);
1003         }
1004
1005         /* link new node to the current node */
1006
1007         This->Asl.Next = Next;
1008         This = Next;
1009     }
1010     va_end (ap);
1011
1012     DbgPrint (ASL_PARSE_OUTPUT,"\n\n");
1013     return (Start);
1014 }
1015
1016
1017 /*******************************************************************************
1018  *
1019  * FUNCTION:    TrLinkChildNode
1020  *
1021  * PARAMETERS:  Op1           - Parent node
1022  *              Op2           - Op to become a child
1023  *
1024  * RETURN:      The parent node
1025  *
1026  * DESCRIPTION: Link two nodes together as a parent and child
1027  *
1028  ******************************************************************************/
1029
1030 ACPI_PARSE_OBJECT *
1031 TrLinkChildNode (
1032     ACPI_PARSE_OBJECT       *Op1,
1033     ACPI_PARSE_OBJECT       *Op2)
1034 {
1035     ACPI_PARSE_OBJECT       *Next;
1036
1037
1038     DbgPrint (ASL_PARSE_OUTPUT,
1039         "\nLinkChildNode: Parent=%p (%s), Child=%p (%s)\n\n",
1040         Op1, Op1 ? UtGetOpName(Op1->Asl.ParseOpcode): NULL,
1041         Op2, Op2 ? UtGetOpName(Op2->Asl.ParseOpcode): NULL);
1042
1043     if (!Op1 || !Op2)
1044     {
1045         return (Op1);
1046     }
1047
1048     Op1->Asl.Child = Op2;
1049
1050     /* Set the child and all peers of the child to point to the parent */
1051
1052     Next = Op2;
1053     while (Next)
1054     {
1055         Next->Asl.Parent = Op1;
1056         Next = Next->Asl.Next;
1057     }
1058
1059     return (Op1);
1060 }
1061
1062
1063 /*******************************************************************************
1064  *
1065  * FUNCTION:    TrWalkParseTree
1066  *
1067  * PARAMETERS:  Visitation              - Type of walk
1068  *              DescendingCallback      - Called during tree descent
1069  *              AscendingCallback       - Called during tree ascent
1070  *              Context                 - To be passed to the callbacks
1071  *
1072  * RETURN:      Status from callback(s)
1073  *
1074  * DESCRIPTION: Walk the entire parse tree.
1075  *
1076  ******************************************************************************/
1077
1078 ACPI_STATUS
1079 TrWalkParseTree (
1080     ACPI_PARSE_OBJECT       *Op,
1081     UINT32                  Visitation,
1082     ASL_WALK_CALLBACK       DescendingCallback,
1083     ASL_WALK_CALLBACK       AscendingCallback,
1084     void                    *Context)
1085 {
1086     UINT32                  Level;
1087     BOOLEAN                 NodePreviouslyVisited;
1088     ACPI_PARSE_OBJECT       *StartOp = Op;
1089     ACPI_STATUS             Status;
1090
1091
1092     if (!RootNode)
1093     {
1094         return (AE_OK);
1095     }
1096
1097     Level = 0;
1098     NodePreviouslyVisited = FALSE;
1099
1100     switch (Visitation)
1101     {
1102     case ASL_WALK_VISIT_DOWNWARD:
1103
1104         while (Op)
1105         {
1106             if (!NodePreviouslyVisited)
1107             {
1108                 /* Let the callback process the node. */
1109
1110                 Status = DescendingCallback (Op, Level, Context);
1111                 if (ACPI_SUCCESS (Status))
1112                 {
1113                     /* Visit children first, once */
1114
1115                     if (Op->Asl.Child)
1116                     {
1117                         Level++;
1118                         Op = Op->Asl.Child;
1119                         continue;
1120                     }
1121                 }
1122                 else if (Status != AE_CTRL_DEPTH)
1123                 {
1124                     /* Exit immediately on any error */
1125
1126                     return (Status);
1127                 }
1128             }
1129
1130             /* Terminate walk at start op */
1131
1132             if (Op == StartOp)
1133             {
1134                 break;
1135             }
1136
1137             /* No more children, visit peers */
1138
1139             if (Op->Asl.Next)
1140             {
1141                 Op = Op->Asl.Next;
1142                 NodePreviouslyVisited = FALSE;
1143             }
1144             else
1145             {
1146                 /* No children or peers, re-visit parent */
1147
1148                 if (Level != 0 )
1149                 {
1150                     Level--;
1151                 }
1152                 Op = Op->Asl.Parent;
1153                 NodePreviouslyVisited = TRUE;
1154             }
1155         }
1156         break;
1157
1158     case ASL_WALK_VISIT_UPWARD:
1159
1160         while (Op)
1161         {
1162             /* Visit leaf node (no children) or parent node on return trip */
1163
1164             if ((!Op->Asl.Child) ||
1165                 (NodePreviouslyVisited))
1166             {
1167                 /* Let the callback process the node. */
1168
1169                 Status = AscendingCallback (Op, Level, Context);
1170                 if (ACPI_FAILURE (Status))
1171                 {
1172                     return (Status);
1173                 }
1174             }
1175             else
1176             {
1177                 /* Visit children first, once */
1178
1179                 Level++;
1180                 Op = Op->Asl.Child;
1181                 continue;
1182             }
1183
1184             /* Terminate walk at start op */
1185
1186             if (Op == StartOp)
1187             {
1188                 break;
1189             }
1190
1191             /* No more children, visit peers */
1192
1193             if (Op->Asl.Next)
1194             {
1195                 Op = Op->Asl.Next;
1196                 NodePreviouslyVisited = FALSE;
1197             }
1198             else
1199             {
1200                 /* No children or peers, re-visit parent */
1201
1202                 if (Level != 0 )
1203                 {
1204                     Level--;
1205                 }
1206                 Op = Op->Asl.Parent;
1207                 NodePreviouslyVisited = TRUE;
1208             }
1209         }
1210         break;
1211
1212      case ASL_WALK_VISIT_TWICE:
1213
1214         while (Op)
1215         {
1216             if (NodePreviouslyVisited)
1217             {
1218                 Status = AscendingCallback (Op, Level, Context);
1219                 if (ACPI_FAILURE (Status))
1220                 {
1221                     return (Status);
1222                 }
1223             }
1224             else
1225             {
1226                 /* Let the callback process the node. */
1227
1228                 Status = DescendingCallback (Op, Level, Context);
1229                 if (ACPI_SUCCESS (Status))
1230                 {
1231                     /* Visit children first, once */
1232
1233                     if (Op->Asl.Child)
1234                     {
1235                         Level++;
1236                         Op = Op->Asl.Child;
1237                         continue;
1238                     }
1239                 }
1240                 else if (Status != AE_CTRL_DEPTH)
1241                 {
1242                     /* Exit immediately on any error */
1243
1244                     return (Status);
1245                 }
1246             }
1247
1248             /* Terminate walk at start op */
1249
1250             if (Op == StartOp)
1251             {
1252                 break;
1253             }
1254
1255             /* No more children, visit peers */
1256
1257             if (Op->Asl.Next)
1258             {
1259                 Op = Op->Asl.Next;
1260                 NodePreviouslyVisited = FALSE;
1261             }
1262             else
1263             {
1264                 /* No children or peers, re-visit parent */
1265
1266                 if (Level != 0 )
1267                 {
1268                     Level--;
1269                 }
1270                 Op = Op->Asl.Parent;
1271                 NodePreviouslyVisited = TRUE;
1272             }
1273         }
1274         break;
1275
1276     default:
1277         /* No other types supported */
1278         break;
1279     }
1280
1281     /* If we get here, the walk completed with no errors */
1282
1283     return (AE_OK);
1284 }