arch/all-pc/acpica/source/common/adwalk.c

   1 /******************************************************************************
   2  *
   3  * Module Name: adwalk - Application-level disassembler parse tree walk routines
   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 "acpi.h"
  46 #include "accommon.h"
  47 #include "acparser.h"
  48 #include "amlcode.h"
  49 #include "acdisasm.h"
  50 #include "acdispat.h"
  51 #include "acnamesp.h"
  52 #include "acapps.h"
  53
  54
  55 #define _COMPONENT          ACPI_TOOLS
  56         ACPI_MODULE_NAME    ("adwalk")
  57
  58 /*
  59  * aslmap - opcode mappings and reserved method names
  60  */
  61 ACPI_OBJECT_TYPE
  62 AslMapNamedOpcodeToDataType (
  63     UINT16                  Opcode);
  64
  65 /* Local prototypes */
  66
  67 static ACPI_STATUS
  68 AcpiDmFindOrphanDescending (
  69     ACPI_PARSE_OBJECT       *Op,
  70     UINT32                  Level,
  71     void                    *Context);
  72
  73 static ACPI_STATUS
  74 AcpiDmDumpDescending (
  75     ACPI_PARSE_OBJECT       *Op,
  76     UINT32                  Level,
  77     void                    *Context);
  78
  79 static ACPI_STATUS
  80 AcpiDmXrefDescendingOp (
  81     ACPI_PARSE_OBJECT       *Op,
  82     UINT32                  Level,
  83     void                    *Context);
  84
  85 static ACPI_STATUS
  86 AcpiDmCommonAscendingOp (
  87     ACPI_PARSE_OBJECT       *Op,
  88     UINT32                  Level,
  89     void                    *Context);
  90
  91 static ACPI_STATUS
  92 AcpiDmLoadDescendingOp (
  93     ACPI_PARSE_OBJECT       *Op,
  94     UINT32                  Level,
  95     void                    *Context);
  96
  97 static UINT32
  98 AcpiDmInspectPossibleArgs (
  99     UINT32                  CurrentOpArgCount,
 100     UINT32                  TargetCount,
 101     ACPI_PARSE_OBJECT       *Op);
 102
 103 static ACPI_STATUS
 104 AcpiDmResourceDescendingOp (
 105     ACPI_PARSE_OBJECT       *Op,
 106     UINT32                  Level,
 107     void                    *Context);
 108
 109
 110 /*******************************************************************************
 111  *
 112  * FUNCTION:    AcpiDmDumpTree
 113  *
 114  * PARAMETERS:  Origin              - Starting object
 115  *
 116  * RETURN:      None
 117  *
 118  * DESCRIPTION: Parse tree walk to format and output the nodes
 119  *
 120  ******************************************************************************/
 121
 122 void
 123 AcpiDmDumpTree (
 124     ACPI_PARSE_OBJECT       *Origin)
 125 {
 126     ACPI_OP_WALK_INFO       Info;
 127
 128
 129     if (!Origin)
 130     {
 131         return;
 132     }
 133
 134     AcpiOsPrintf ("/*\nAML Parse Tree\n\n");
 135     Info.Flags = 0;
 136     Info.Count = 0;
 137     Info.Level = 0;
 138     Info.WalkState = NULL;
 139     AcpiDmWalkParseTree (Origin, AcpiDmDumpDescending, NULL, &Info);
 140     AcpiOsPrintf ("*/\n\n");
 141 }
 142
 143
 144 /*******************************************************************************
 145  *
 146  * FUNCTION:    AcpiDmFindOrphanMethods
 147  *
 148  * PARAMETERS:  Origin              - Starting object
 149  *
 150  * RETURN:      None
 151  *
 152  * DESCRIPTION: Parse tree walk to find "orphaned" method invocations -- methods
 153  *              that are not resolved in the namespace
 154  *
 155  ******************************************************************************/
 156
 157 void
 158 AcpiDmFindOrphanMethods (
 159     ACPI_PARSE_OBJECT       *Origin)
 160 {
 161     ACPI_OP_WALK_INFO       Info;
 162
 163
 164     if (!Origin)
 165     {
 166         return;
 167     }
 168
 169     Info.Flags = 0;
 170     Info.Level = 0;
 171     Info.WalkState = NULL;
 172     AcpiDmWalkParseTree (Origin, AcpiDmFindOrphanDescending, NULL, &Info);
 173 }
 174
 175
 176 /*******************************************************************************
 177  *
 178  * FUNCTION:    AcpiDmFinishNamespaceLoad
 179  *
 180  * PARAMETERS:  ParseTreeRoot       - Root of the parse tree
 181  *              NamespaceRoot       - Root of the internal namespace
 182  *              OwnerId             - OwnerId of the table to be disassembled
 183  *
 184  * RETURN:      None
 185  *
 186  * DESCRIPTION: Load all namespace items that are created within control
 187  *              methods. Used before namespace cross reference
 188  *
 189  ******************************************************************************/
 190
 191 void
 192 AcpiDmFinishNamespaceLoad (
 193     ACPI_PARSE_OBJECT       *ParseTreeRoot,
 194     ACPI_NAMESPACE_NODE     *NamespaceRoot,
 195     ACPI_OWNER_ID           OwnerId)
 196 {
 197     ACPI_STATUS             Status;
 198     ACPI_OP_WALK_INFO       Info;
 199     ACPI_WALK_STATE         *WalkState;
 200
 201
 202     if (!ParseTreeRoot)
 203     {
 204         return;
 205     }
 206
 207     /* Create and initialize a new walk state */
 208
 209     WalkState = AcpiDsCreateWalkState (OwnerId, ParseTreeRoot, NULL, NULL);
 210     if (!WalkState)
 211     {
 212         return;
 213     }
 214
 215     Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
 216     if (ACPI_FAILURE (Status))
 217     {
 218         return;
 219     }
 220
 221     Info.Flags = 0;
 222     Info.Level = 0;
 223     Info.WalkState = WalkState;
 224     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmLoadDescendingOp,
 225         AcpiDmCommonAscendingOp, &Info);
 226     ACPI_FREE (WalkState);
 227 }
 228
 229
 230 /*******************************************************************************
 231  *
 232  * FUNCTION:    AcpiDmCrossReferenceNamespace
 233  *
 234  * PARAMETERS:  ParseTreeRoot       - Root of the parse tree
 235  *              NamespaceRoot       - Root of the internal namespace
 236  *              OwnerId             - OwnerId of the table to be disassembled
 237  *
 238  * RETURN:      None
 239  *
 240  * DESCRIPTION: Cross reference the namespace to create externals
 241  *
 242  ******************************************************************************/
 243
 244 void
 245 AcpiDmCrossReferenceNamespace (
 246     ACPI_PARSE_OBJECT       *ParseTreeRoot,
 247     ACPI_NAMESPACE_NODE     *NamespaceRoot,
 248     ACPI_OWNER_ID           OwnerId)
 249 {
 250     ACPI_STATUS             Status;
 251     ACPI_OP_WALK_INFO       Info;
 252     ACPI_WALK_STATE         *WalkState;
 253
 254
 255     if (!ParseTreeRoot)
 256     {
 257         return;
 258     }
 259
 260     /* Create and initialize a new walk state */
 261
 262     WalkState = AcpiDsCreateWalkState (OwnerId, ParseTreeRoot, NULL, NULL);
 263     if (!WalkState)
 264     {
 265         return;
 266     }
 267
 268     Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
 269     if (ACPI_FAILURE (Status))
 270     {
 271         return;
 272     }
 273
 274     Info.Flags = 0;
 275     Info.Level = 0;
 276     Info.WalkState = WalkState;
 277     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmXrefDescendingOp,
 278         AcpiDmCommonAscendingOp, &Info);
 279     ACPI_FREE (WalkState);
 280 }
 281
 282
 283 /*******************************************************************************
 284  *
 285  * FUNCTION:    AcpiDmConvertResourceIndexes
 286  *
 287  * PARAMETERS:  ParseTreeRoot       - Root of the parse tree
 288  *              NamespaceRoot       - Root of the internal namespace
 289  *
 290  * RETURN:      None
 291  *
 292  * DESCRIPTION: Convert fixed-offset references to resource descriptors to
 293  *              symbolic references. Should only be called after namespace has
 294  *              been cross referenced.
 295  *
 296  ******************************************************************************/
 297
 298 void
 299 AcpiDmConvertResourceIndexes (
 300     ACPI_PARSE_OBJECT       *ParseTreeRoot,
 301     ACPI_NAMESPACE_NODE     *NamespaceRoot)
 302 {
 303     ACPI_STATUS             Status;
 304     ACPI_OP_WALK_INFO       Info;
 305     ACPI_WALK_STATE         *WalkState;
 306
 307
 308     if (!ParseTreeRoot)
 309     {
 310         return;
 311     }
 312
 313     /* Create and initialize a new walk state */
 314
 315     WalkState = AcpiDsCreateWalkState (0, ParseTreeRoot, NULL, NULL);
 316     if (!WalkState)
 317     {
 318         return;
 319     }
 320
 321     Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
 322     if (ACPI_FAILURE (Status))
 323     {
 324         return;
 325     }
 326
 327     Info.Flags = 0;
 328     Info.Level = 0;
 329     Info.WalkState = WalkState;
 330     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmResourceDescendingOp,
 331         AcpiDmCommonAscendingOp, &Info);
 332     ACPI_FREE (WalkState);
 333     return;
 334 }
 335
 336
 337 /*******************************************************************************
 338  *
 339  * FUNCTION:    AcpiDmDumpDescending
 340  *
 341  * PARAMETERS:  ASL_WALK_CALLBACK
 342  *
 343  * RETURN:      Status
 344  *
 345  * DESCRIPTION: Format and print contents of one parse Op.
 346  *
 347  ******************************************************************************/
 348
 349 static ACPI_STATUS
 350 AcpiDmDumpDescending (
 351     ACPI_PARSE_OBJECT       *Op,
 352     UINT32                  Level,
 353     void                    *Context)
 354 {
 355     ACPI_OP_WALK_INFO       *Info = Context;
 356     char                    *Path;
 357
 358
 359     if (!Op)
 360     {
 361         return (AE_OK);
 362     }
 363
 364     /* Most of the information (count, level, name) here */
 365
 366     Info->Count++;
 367     AcpiOsPrintf ("% 5d [%2.2d] ", Info->Count, Level);
 368     AcpiDmIndent (Level);
 369     AcpiOsPrintf ("%-28s", AcpiPsGetOpcodeName (Op->Common.AmlOpcode));
 370
 371     /* Extra info is helpful */
 372
 373     switch (Op->Common.AmlOpcode)
 374     {
 375     case AML_BYTE_OP:
 376
 377         AcpiOsPrintf ("%2.2X", (UINT32) Op->Common.Value.Integer);
 378         break;
 379
 380     case AML_WORD_OP:
 381
 382         AcpiOsPrintf ("%4.4X", (UINT32) Op->Common.Value.Integer);
 383         break;
 384
 385     case AML_DWORD_OP:
 386
 387         AcpiOsPrintf ("%8.8X", (UINT32) Op->Common.Value.Integer);
 388         break;
 389
 390     case AML_QWORD_OP:
 391
 392         AcpiOsPrintf ("%8.8X%8.8X", ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
 393         break;
 394
 395     case AML_INT_NAMEPATH_OP:
 396
 397         if (Op->Common.Value.String)
 398         {
 399             AcpiNsExternalizeName (ACPI_UINT32_MAX, Op->Common.Value.String,
 400                             NULL, &Path);
 401             AcpiOsPrintf ("%s %p", Path, Op->Common.Node);
 402             ACPI_FREE (Path);
 403         }
 404         else
 405         {
 406             AcpiOsPrintf ("[NULL]");
 407         }
 408         break;
 409
 410     case AML_NAME_OP:
 411     case AML_METHOD_OP:
 412     case AML_DEVICE_OP:
 413     case AML_INT_NAMEDFIELD_OP:
 414
 415         AcpiOsPrintf ("%4.4s", ACPI_CAST_PTR (char, &Op->Named.Name));
 416         break;
 417
 418     default:
 419
 420         break;
 421     }
 422
 423     AcpiOsPrintf ("\n");
 424     return (AE_OK);
 425 }
 426
 427
 428 /*******************************************************************************
 429  *
 430  * FUNCTION:    AcpiDmFindOrphanDescending
 431  *
 432  * PARAMETERS:  ASL_WALK_CALLBACK
 433  *
 434  * RETURN:      Status
 435  *
 436  * DESCRIPTION: Check namepath Ops for orphaned method invocations
 437  *
 438  * Note: Experimental.
 439  *
 440  ******************************************************************************/
 441
 442 static ACPI_STATUS
 443 AcpiDmFindOrphanDescending (
 444     ACPI_PARSE_OBJECT       *Op,
 445     UINT32                  Level,
 446     void                    *Context)
 447 {
 448     const ACPI_OPCODE_INFO  *OpInfo;
 449     ACPI_PARSE_OBJECT       *ChildOp;
 450     ACPI_PARSE_OBJECT       *NextOp;
 451     ACPI_PARSE_OBJECT       *ParentOp;
 452     UINT32                  ArgCount;
 453
 454
 455     if (!Op)
 456     {
 457         return (AE_OK);
 458     }
 459
 460     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 461
 462     switch (Op->Common.AmlOpcode)
 463     {
 464 #ifdef ACPI_UNDER_DEVELOPMENT
 465     case AML_ADD_OP:
 466
 467         ChildOp = Op->Common.Value.Arg;
 468         if ((ChildOp->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
 469             !ChildOp->Common.Node)
 470         {
 471             AcpiNsExternalizeName (ACPI_UINT32_MAX, ChildOp->Common.Value.String,
 472                             NULL, &Path);
 473             AcpiOsPrintf ("/* %-16s A-NAMEPATH: %s  */\n", Op->Common.AmlOpName, Path);
 474             ACPI_FREE (Path);
 475
 476             NextOp = Op->Common.Next;
 477             if (!NextOp)
 478             {
 479                 /* This NamePath has no args, assume it is an integer */
 480
 481                 AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
 482                 return (AE_OK);
 483             }
 484
 485             ArgCount = AcpiDmInspectPossibleArgs (3, 1, NextOp);
 486             AcpiOsPrintf ("/* A-CHILDREN: %u Actual %u */\n", ArgCount, AcpiDmCountChildren (Op));
 487
 488             if (ArgCount < 1)
 489             {
 490                 /* One Arg means this is just a Store(Name,Target) */
 491
 492                 AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
 493                 return (AE_OK);
 494             }
 495
 496             AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
 497         }
 498         break;
 499 #endif
 500
 501     case AML_STORE_OP:
 502
 503         ChildOp = Op->Common.Value.Arg;
 504         if ((ChildOp->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
 505             !ChildOp->Common.Node)
 506         {
 507             NextOp = Op->Common.Next;
 508             if (!NextOp)
 509             {
 510                 /* This NamePath has no args, assume it is an integer */
 511
 512                 AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
 513                 return (AE_OK);
 514             }
 515
 516             ArgCount = AcpiDmInspectPossibleArgs (2, 1, NextOp);
 517             if (ArgCount <= 1)
 518             {
 519                 /* One Arg means this is just a Store(Name,Target) */
 520
 521                 AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
 522                 return (AE_OK);
 523             }
 524
 525             AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
 526         }
 527         break;
 528
 529     case AML_INT_NAMEPATH_OP:
 530
 531         /* Must examine parent to see if this namepath is an argument */
 532
 533         ParentOp = Op->Common.Parent;
 534         OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Common.AmlOpcode);
 535
 536         if ((OpInfo->Class != AML_CLASS_EXECUTE) &&
 537             (OpInfo->Class != AML_CLASS_CREATE) &&
 538             (OpInfo->ObjectType != ACPI_TYPE_LOCAL_ALIAS) &&
 539             (ParentOp->Common.AmlOpcode != AML_INT_METHODCALL_OP) &&
 540             !Op->Common.Node)
 541         {
 542             ArgCount = AcpiDmInspectPossibleArgs (0, 0, Op->Common.Next);
 543
 544             /*
 545              * Check if namepath is a predicate for if/while or lone parameter to
 546              * a return.
 547              */
 548             if (ArgCount == 0)
 549             {
 550                 if (((ParentOp->Common.AmlOpcode == AML_IF_OP) ||
 551                      (ParentOp->Common.AmlOpcode == AML_WHILE_OP) ||
 552                      (ParentOp->Common.AmlOpcode == AML_RETURN_OP)) &&
 553
 554                      /* And namepath is the first argument */
 555                      (ParentOp->Common.Value.Arg == Op))
 556                 {
 557                     AcpiDmAddToExternalList (Op, Op->Common.Value.String, ACPI_TYPE_INTEGER, 0);
 558                     break;
 559                 }
 560             }
 561
 562             /*
 563              * This is a standalone namestring (not a parameter to another
 564              * operator) - it *must* be a method invocation, nothing else is
 565              * grammatically possible.
 566              */
 567             AcpiDmAddToExternalList (Op, Op->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
 568
 569         }
 570         break;
 571
 572     default:
 573
 574         break;
 575     }
 576
 577     return (AE_OK);
 578 }
 579
 580
 581 /*******************************************************************************
 582  *
 583  * FUNCTION:    AcpiDmLoadDescendingOp
 584  *
 585  * PARAMETERS:  ASL_WALK_CALLBACK
 586  *
 587  * RETURN:      Status
 588  *
 589  * DESCRIPTION: Descending handler for namespace control method object load
 590  *
 591  ******************************************************************************/
 592
 593 static ACPI_STATUS
 594 AcpiDmLoadDescendingOp (
 595     ACPI_PARSE_OBJECT       *Op,
 596     UINT32                  Level,
 597     void                    *Context)
 598 {
 599     ACPI_OP_WALK_INFO       *Info = Context;
 600     const ACPI_OPCODE_INFO  *OpInfo;
 601     ACPI_WALK_STATE         *WalkState;
 602     ACPI_OBJECT_TYPE        ObjectType;
 603     ACPI_STATUS             Status;
 604     char                    *Path = NULL;
 605     ACPI_PARSE_OBJECT       *NextOp;
 606     ACPI_NAMESPACE_NODE     *Node;
 607     char                    FieldPath[5];
 608     BOOLEAN                 PreDefined = FALSE;
 609     UINT8                   PreDefineIndex = 0;
 610
 611
 612     WalkState = Info->WalkState;
 613     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 614     ObjectType = OpInfo->ObjectType;
 615     ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
 616
 617     /* Only interested in operators that create new names */
 618
 619     if (!(OpInfo->Flags & AML_NAMED) &&
 620         !(OpInfo->Flags & AML_CREATE))
 621     {
 622         goto Exit;
 623     }
 624
 625     /* Get the NamePath from the appropriate place */
 626
 627     if (OpInfo->Flags & AML_NAMED)
 628     {
 629         /* For all named operators, get the new name */
 630
 631         Path = (char *) Op->Named.Path;
 632
 633         if (!Path && Op->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)
 634         {
 635             *ACPI_CAST_PTR (UINT32, &FieldPath[0]) = Op->Named.Name;
 636             FieldPath[4] = 0;
 637             Path = FieldPath;
 638         }
 639     }
 640     else if (OpInfo->Flags & AML_CREATE)
 641     {
 642         /* New name is the last child */
 643
 644         NextOp = Op->Common.Value.Arg;
 645
 646         while (NextOp->Common.Next)
 647         {
 648             NextOp = NextOp->Common.Next;
 649         }
 650         Path = NextOp->Common.Value.String;
 651     }
 652
 653     if (!Path)
 654     {
 655         goto Exit;
 656     }
 657
 658     /* Insert the name into the namespace */
 659
 660     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 661                 ACPI_IMODE_LOAD_PASS2, ACPI_NS_DONT_OPEN_SCOPE,
 662                 WalkState, &Node);
 663
 664     Op->Common.Node = Node;
 665
 666     if (ACPI_SUCCESS (Status))
 667     {
 668         /* Check if it's a predefined node */
 669
 670         while (AcpiGbl_PreDefinedNames[PreDefineIndex].Name)
 671         {
 672             if (ACPI_COMPARE_NAME (Node->Name.Ascii,
 673                 AcpiGbl_PreDefinedNames[PreDefineIndex].Name))
 674             {
 675                 PreDefined = TRUE;
 676                 break;
 677             }
 678
 679             PreDefineIndex++;
 680         }
 681
 682         /*
 683          * Set node owner id if it satisfies all the following conditions:
 684          * 1) Not a predefined node, _SB_ etc
 685          * 2) Not the root node
 686          * 3) Not a node created by Scope
 687          */
 688
 689         if (!PreDefined && Node != AcpiGbl_RootNode &&
 690             Op->Common.AmlOpcode != AML_SCOPE_OP)
 691         {
 692             Node->OwnerId = WalkState->OwnerId;
 693         }
 694     }
 695
 696
 697 Exit:
 698
 699     if (AcpiNsOpensScope (ObjectType))
 700     {
 701         if (Op->Common.Node)
 702         {
 703             Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
 704             if (ACPI_FAILURE (Status))
 705             {
 706                 return (Status);
 707             }
 708         }
 709     }
 710
 711     return (AE_OK);
 712 }
 713
 714
 715 /*******************************************************************************
 716  *
 717  * FUNCTION:    AcpiDmXrefDescendingOp
 718  *
 719  * PARAMETERS:  ASL_WALK_CALLBACK
 720  *
 721  * RETURN:      Status
 722  *
 723  * DESCRIPTION: Descending handler for namespace cross reference
 724  *
 725  ******************************************************************************/
 726
 727 static ACPI_STATUS
 728 AcpiDmXrefDescendingOp (
 729     ACPI_PARSE_OBJECT       *Op,
 730     UINT32                  Level,
 731     void                    *Context)
 732 {
 733     ACPI_OP_WALK_INFO       *Info = Context;
 734     const ACPI_OPCODE_INFO  *OpInfo;
 735     ACPI_WALK_STATE         *WalkState;
 736     ACPI_OBJECT_TYPE        ObjectType;
 737     ACPI_OBJECT_TYPE        ObjectType2;
 738     ACPI_STATUS             Status;
 739     char                    *Path = NULL;
 740     ACPI_PARSE_OBJECT       *NextOp;
 741     ACPI_NAMESPACE_NODE     *Node;
 742     ACPI_OPERAND_OBJECT     *Object;
 743     UINT32                  ParamCount = 0;
 744
 745
 746     WalkState = Info->WalkState;
 747     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 748     ObjectType = OpInfo->ObjectType;
 749     ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
 750
 751     if ((!(OpInfo->Flags & AML_NAMED)) &&
 752         (!(OpInfo->Flags & AML_CREATE)) &&
 753         (Op->Common.AmlOpcode != AML_INT_NAMEPATH_OP))
 754     {
 755         goto Exit;
 756     }
 757
 758     /* Get the NamePath from the appropriate place */
 759
 760     if (OpInfo->Flags & AML_NAMED)
 761     {
 762         /*
 763          * Only these two operators (Alias, Scope) refer to an existing
 764          * name, it is the first argument
 765          */
 766         if (Op->Common.AmlOpcode == AML_ALIAS_OP)
 767         {
 768             ObjectType = ACPI_TYPE_ANY;
 769
 770             NextOp = Op->Common.Value.Arg;
 771             NextOp = NextOp->Common.Value.Arg;
 772             if (NextOp->Common.AmlOpcode == AML_INT_NAMEPATH_OP)
 773             {
 774                 Path = NextOp->Common.Value.String;
 775             }
 776         }
 777         else if (Op->Common.AmlOpcode == AML_SCOPE_OP)
 778         {
 779             Path = (char *) Op->Named.Path;
 780         }
 781     }
 782     else if (OpInfo->Flags & AML_CREATE)
 783     {
 784         /* Referenced Buffer Name is the first child */
 785
 786         ObjectType = ACPI_TYPE_BUFFER; /* Change from TYPE_BUFFER_FIELD */
 787
 788         NextOp = Op->Common.Value.Arg;
 789         if (NextOp->Common.AmlOpcode == AML_INT_NAMEPATH_OP)
 790         {
 791             Path = NextOp->Common.Value.String;
 792         }
 793     }
 794     else
 795     {
 796         Path = Op->Common.Value.String;
 797     }
 798
 799     if (!Path)
 800     {
 801         goto Exit;
 802     }
 803
 804     /*
 805      * Lookup the name in the namespace. Name must exist at this point, or it
 806      * is an invalid reference.
 807      *
 808      * The namespace is also used as a lookup table for references to resource
 809      * descriptors and the fields within them.
 810      */
 811     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,
 812                 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
 813                 WalkState, &Node);
 814     if (ACPI_SUCCESS (Status) && (Node->Flags & ANOBJ_IS_EXTERNAL))
 815     {
 816         Status = AE_NOT_FOUND;
 817     }
 818
 819     if (ACPI_FAILURE (Status))
 820     {
 821         if (Status == AE_NOT_FOUND)
 822         {
 823             /*
 824              * Add this symbol as an external declaration, except if the
 825              * parent is a CondRefOf operator. For this operator, we do not
 826              * need an external, nor do we want one, since this can cause
 827              * disassembly problems if the symbol is actually a control
 828              * method.
 829              */
 830             if (!(Op->Asl.Parent &&
 831                 (Op->Asl.Parent->Asl.AmlOpcode == AML_COND_REF_OF_OP)))
 832             {
 833                 AcpiDmAddToExternalList (Op, Path, (UINT8) ObjectType, 0);
 834             }
 835         }
 836     }
 837
 838     /*
 839      * Found the node in external table, add it to external list
 840      * Node->OwnerId == 0 indicates built-in ACPI Names, _OS_ etc
 841      */
 842     else if (Node->OwnerId && WalkState->OwnerId != Node->OwnerId)
 843     {
 844         ObjectType2 = ObjectType;
 845
 846         Object = AcpiNsGetAttachedObject (Node);
 847         if (Object)
 848         {
 849             ObjectType2 = Object->Common.Type;
 850             if (ObjectType2 == ACPI_TYPE_METHOD)
 851             {
 852                 ParamCount = Object->Method.ParamCount;
 853             }
 854         }
 855
 856         AcpiDmAddToExternalList (Op, Path, (UINT8) ObjectType2, ParamCount | 0x80);
 857         Op->Common.Node = Node;
 858     }
 859     else
 860     {
 861         Op->Common.Node = Node;
 862     }
 863
 864
 865 Exit:
 866     /* Open new scope if necessary */
 867
 868     if (AcpiNsOpensScope (ObjectType))
 869     {
 870         if (Op->Common.Node)
 871         {
 872             Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
 873             if (ACPI_FAILURE (Status))
 874             {
 875                 return (Status);
 876             }
 877         }
 878     }
 879
 880     return (AE_OK);
 881 }
 882
 883
 884 /*******************************************************************************
 885  *
 886  * FUNCTION:    AcpiDmResourceDescendingOp
 887  *
 888  * PARAMETERS:  ASL_WALK_CALLBACK
 889  *
 890  * RETURN:      None
 891  *
 892  * DESCRIPTION: Process one parse op during symbolic resource index conversion.
 893  *
 894  ******************************************************************************/
 895
 896 static ACPI_STATUS
 897 AcpiDmResourceDescendingOp (
 898     ACPI_PARSE_OBJECT       *Op,
 899     UINT32                  Level,
 900     void                    *Context)
 901 {
 902     ACPI_OP_WALK_INFO       *Info = Context;
 903     const ACPI_OPCODE_INFO  *OpInfo;
 904     ACPI_WALK_STATE         *WalkState;
 905     ACPI_OBJECT_TYPE        ObjectType;
 906     ACPI_STATUS             Status;
 907
 908
 909     WalkState = Info->WalkState;
 910     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 911
 912     /* Open new scope if necessary */
 913
 914     ObjectType = OpInfo->ObjectType;
 915     if (AcpiNsOpensScope (ObjectType))
 916     {
 917         if (Op->Common.Node)
 918         {
 919
 920             Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
 921             if (ACPI_FAILURE (Status))
 922             {
 923                 return (Status);
 924             }
 925         }
 926     }
 927
 928     /*
 929      * Check if this operator contains a reference to a resource descriptor.
 930      * If so, convert the reference into a symbolic reference.
 931      */
 932     AcpiDmCheckResourceReference (Op, WalkState);
 933     return (AE_OK);
 934 }
 935
 936
 937 /*******************************************************************************
 938  *
 939  * FUNCTION:    AcpiDmCommonAscendingOp
 940  *
 941  * PARAMETERS:  ASL_WALK_CALLBACK
 942  *
 943  * RETURN:      None
 944  *
 945  * DESCRIPTION: Ascending handler for combined parse/namespace walks. Closes
 946  *              scope if necessary.
 947  *
 948  ******************************************************************************/
 949
 950 static ACPI_STATUS
 951 AcpiDmCommonAscendingOp (
 952     ACPI_PARSE_OBJECT       *Op,
 953     UINT32                  Level,
 954     void                    *Context)
 955 {
 956     ACPI_OP_WALK_INFO       *Info = Context;
 957     const ACPI_OPCODE_INFO  *OpInfo;
 958     ACPI_OBJECT_TYPE        ObjectType;
 959
 960
 961     /* Close scope if necessary */
 962
 963     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 964     ObjectType = OpInfo->ObjectType;
 965     ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
 966
 967     if (AcpiNsOpensScope (ObjectType))
 968     {
 969         (void) AcpiDsScopeStackPop (Info->WalkState);
 970     }
 971
 972     return (AE_OK);
 973 }
 974
 975
 976 /*******************************************************************************
 977  *
 978  * FUNCTION:    AcpiDmInspectPossibleArgs
 979  *
 980  * PARAMETERS:  CurrentOpArgCount   - Which arg of the current op was the
 981  *                                    possible method invocation found
 982  *              TargetCount         - Number of targets (0,1,2) for this op
 983  *              Op                  - Parse op
 984  *
 985  * RETURN:      Status
 986  *
 987  * DESCRIPTION: Examine following args and next ops for possible arguments
 988  *              for an unrecognized method invocation.
 989  *
 990  ******************************************************************************/
 991
 992 static UINT32
 993 AcpiDmInspectPossibleArgs (
 994     UINT32                  CurrentOpArgCount,
 995     UINT32                  TargetCount,
 996     ACPI_PARSE_OBJECT       *Op)
 997 {
 998     const ACPI_OPCODE_INFO  *OpInfo;
 999     UINT32                  i;
1000     UINT32                  Last = 0;
1001     UINT32                  Lookahead;
1002
1003
1004     Lookahead = (ACPI_METHOD_NUM_ARGS + TargetCount) - CurrentOpArgCount;
1005
1006     /* Lookahead for the maximum number of possible arguments */
1007
1008     for (i = 0; i < Lookahead; i++)
1009     {
1010         if (!Op)
1011         {
1012             break;
1013         }
1014
1015         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
1016
1017         /*
1018          * Any one of these operators is "very probably" not a method arg
1019          */
1020         if ((Op->Common.AmlOpcode == AML_STORE_OP) ||
1021             (Op->Common.AmlOpcode == AML_NOTIFY_OP))
1022         {
1023             break;
1024         }
1025
1026         if ((OpInfo->Class != AML_CLASS_EXECUTE) &&
1027             (OpInfo->Class != AML_CLASS_CONTROL))
1028         {
1029             Last = i+1;
1030         }
1031
1032         Op = Op->Common.Next;
1033     }
1034
1035     return (Last);
1036 }