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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslopt- Compiler optimizations
   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 #include "acparser.h"
  49 #include "amlcode.h"
  50 #include "acnamesp.h"
  51
  52
  53 #define _COMPONENT          ACPI_COMPILER
  54         ACPI_MODULE_NAME    ("aslopt")
  55
  56
  57 static UINT32 OptTotal = 0;
  58
  59 /* Local prototypes */
  60
  61 static ACPI_STATUS
  62 OptSearchToRoot (
  63     ACPI_PARSE_OBJECT       *Op,
  64     ACPI_WALK_STATE         *WalkState,
  65     ACPI_NAMESPACE_NODE     *CurrentNode,
  66     ACPI_NAMESPACE_NODE     *TargetNode,
  67     ACPI_BUFFER             *TargetPath,
  68     char                    **NewPath);
  69
  70 static ACPI_STATUS
  71 OptBuildShortestPath (
  72     ACPI_PARSE_OBJECT       *Op,
  73     ACPI_WALK_STATE         *WalkState,
  74     ACPI_NAMESPACE_NODE     *CurrentNode,
  75     ACPI_NAMESPACE_NODE     *TargetNode,
  76     ACPI_BUFFER             *CurrentPath,
  77     ACPI_BUFFER             *TargetPath,
  78     ACPI_SIZE               AmlNameStringLength,
  79     UINT8                   IsDeclaration,
  80     char                    **ReturnNewPath);
  81
  82 static ACPI_STATUS
  83 OptOptimizeNameDeclaration (
  84     ACPI_PARSE_OBJECT       *Op,
  85     ACPI_WALK_STATE         *WalkState,
  86     ACPI_NAMESPACE_NODE     *CurrentNode,
  87     ACPI_NAMESPACE_NODE     *TargetNode,
  88     char                    *AmlNameString,
  89     char                    **NewPath);
  90
  91
  92 /*******************************************************************************
  93  *
  94  * FUNCTION:    OptSearchToRoot
  95  *
  96  * PARAMETERS:  Op                  - Current parser op
  97  *              WalkState           - Current state
  98  *              CurrentNode         - Where we are in the namespace
  99  *              TargetNode          - Node to which we are referring
 100  *              TargetPath          - External full path to the target node
 101  *              NewPath             - Where the optimized path is returned
 102  *
 103  * RETURN:      Status
 104  *
 105  * DESCRIPTION: Attempt to optimize a reference to a single 4-character ACPI
 106  *              name utilizing the search-to-root name resolution algorithm
 107  *              that is used by AML interpreters.
 108  *
 109  ******************************************************************************/
 110
 111 static ACPI_STATUS
 112 OptSearchToRoot (
 113     ACPI_PARSE_OBJECT       *Op,
 114     ACPI_WALK_STATE         *WalkState,
 115     ACPI_NAMESPACE_NODE     *CurrentNode,
 116     ACPI_NAMESPACE_NODE     *TargetNode,
 117     ACPI_BUFFER             *TargetPath,
 118     char                    **NewPath)
 119 {
 120     ACPI_NAMESPACE_NODE     *Node;
 121     ACPI_GENERIC_STATE      ScopeInfo;
 122     ACPI_STATUS             Status;
 123     char                    *Path;
 124
 125
 126     ACPI_FUNCTION_NAME (OptSearchToRoot);
 127
 128
 129     /*
 130      * Check if search-to-root can be utilized. Use the last NameSeg of
 131      * the NamePath and 1) See if can be found and 2) If found, make
 132      * sure that it is the same node that we want. If there is another
 133      * name in the search path before the one we want, the nodes will
 134      * not match, and we cannot use this optimization.
 135      */
 136     Path = &(((char *) TargetPath->Pointer)[TargetPath->Length -
 137                                             ACPI_NAME_SIZE]),
 138     ScopeInfo.Scope.Node = CurrentNode;
 139
 140     /* Lookup the NameSeg using SEARCH_PARENT (search-to-root) */
 141
 142     Status = AcpiNsLookup (&ScopeInfo, Path, ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 143                     ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
 144                     WalkState, &(Node));
 145     if (ACPI_FAILURE (Status))
 146     {
 147         return (Status);
 148     }
 149
 150     /*
 151      * We found the name, but we must check to make sure that the node
 152      * matches. Otherwise, there is another identical name in the search
 153      * path that precludes the use of this optimization.
 154      */
 155     if (Node != TargetNode)
 156     {
 157         /*
 158          * This means that another object with the same name was found first,
 159          * and we cannot use this optimization.
 160          */
 161         return (AE_NOT_FOUND);
 162     }
 163
 164     /* Found the node, we can use this optimization */
 165
 166     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 167         "NAMESEG:   %-24s", Path));
 168
 169     /* We must allocate a new string for the name (TargetPath gets deleted) */
 170
 171     *NewPath = ACPI_ALLOCATE_ZEROED (ACPI_NAME_SIZE + 1);
 172     ACPI_STRCPY (*NewPath, Path);
 173
 174     if (ACPI_STRNCMP (*NewPath, "_T_", 3))
 175     {
 176         AslError (ASL_OPTIMIZATION, ASL_MSG_SINGLE_NAME_OPTIMIZATION, Op,
 177                 *NewPath);
 178     }
 179
 180     return (AE_OK);
 181 }
 182
 183
 184 /*******************************************************************************
 185  *
 186  * FUNCTION:    OptBuildShortestPath
 187  *
 188  * PARAMETERS:  Op                  - Current parser op
 189  *              WalkState           - Current state
 190  *              CurrentNode         - Where we are in the namespace
 191  *              TargetNode          - Node to which we are referring
 192  *              CurrentPath         - External full path to the current node
 193  *              TargetPath          - External full path to the target node
 194  *              AmlNameStringLength - Length of the original namepath
 195  *              IsDeclaration       - TRUE for declaration, FALSE for reference
 196  *              ReturnNewPath       - Where the optimized path is returned
 197  *
 198  * RETURN:      Status
 199  *
 200  * DESCRIPTION: Build an optimal NamePath using carats
 201  *
 202  ******************************************************************************/
 203
 204 static ACPI_STATUS
 205 OptBuildShortestPath (
 206     ACPI_PARSE_OBJECT       *Op,
 207     ACPI_WALK_STATE         *WalkState,
 208     ACPI_NAMESPACE_NODE     *CurrentNode,
 209     ACPI_NAMESPACE_NODE     *TargetNode,
 210     ACPI_BUFFER             *CurrentPath,
 211     ACPI_BUFFER             *TargetPath,
 212     ACPI_SIZE               AmlNameStringLength,
 213     UINT8                   IsDeclaration,
 214     char                    **ReturnNewPath)
 215 {
 216     UINT32                  NumCommonSegments;
 217     UINT32                  MaxCommonSegments;
 218     UINT32                  Index;
 219     UINT32                  NumCarats;
 220     UINT32                  i;
 221     char                    *NewPath;
 222     char                    *NewPathExternal;
 223     ACPI_NAMESPACE_NODE     *Node;
 224     ACPI_GENERIC_STATE      ScopeInfo;
 225     ACPI_STATUS             Status;
 226     BOOLEAN                 SubPath = FALSE;
 227
 228
 229     ACPI_FUNCTION_NAME (OptBuildShortestPath);
 230
 231
 232     ScopeInfo.Scope.Node = CurrentNode;
 233
 234     /*
 235      * Determine the maximum number of NameSegs that the Target and Current paths
 236      * can possibly have in common. (To optimize, we have to have at least 1)
 237      *
 238      * Note: The external NamePath string lengths are always a multiple of 5
 239      * (ACPI_NAME_SIZE + separator)
 240      */
 241     MaxCommonSegments = TargetPath->Length / ACPI_PATH_SEGMENT_LENGTH;
 242     if (CurrentPath->Length < TargetPath->Length)
 243     {
 244         MaxCommonSegments = CurrentPath->Length / ACPI_PATH_SEGMENT_LENGTH;
 245     }
 246
 247     /*
 248      * Determine how many NameSegs the two paths have in common.
 249      * (Starting from the root)
 250      */
 251     for (NumCommonSegments = 0;
 252          NumCommonSegments < MaxCommonSegments;
 253          NumCommonSegments++)
 254     {
 255         /* Compare two single NameSegs */
 256
 257         if (!ACPI_COMPARE_NAME (
 258             &((char *) TargetPath->Pointer)[
 259                 (NumCommonSegments * ACPI_PATH_SEGMENT_LENGTH) + 1],
 260             &((char *) CurrentPath->Pointer)[
 261                 (NumCommonSegments * ACPI_PATH_SEGMENT_LENGTH) + 1]))
 262         {
 263             /* Mismatch */
 264
 265             break;
 266         }
 267     }
 268
 269     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " COMMON: %u",
 270         NumCommonSegments));
 271
 272     /* There must be at least 1 common NameSeg in order to optimize */
 273
 274     if (NumCommonSegments == 0)
 275     {
 276         return (AE_NOT_FOUND);
 277     }
 278
 279     if (NumCommonSegments == MaxCommonSegments)
 280     {
 281         if (CurrentPath->Length == TargetPath->Length)
 282         {
 283             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " SAME PATH"));
 284             return (AE_NOT_FOUND);
 285         }
 286         else
 287         {
 288             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " SUBPATH"));
 289             SubPath = TRUE;
 290         }
 291     }
 292
 293     /* Determine how many prefix Carats are required */
 294
 295     NumCarats = (CurrentPath->Length / ACPI_PATH_SEGMENT_LENGTH) -
 296                 NumCommonSegments;
 297
 298     /*
 299      * Construct a new target string
 300      */
 301     NewPathExternal = ACPI_ALLOCATE_ZEROED (
 302         TargetPath->Length + NumCarats + 1);
 303
 304     /* Insert the Carats into the Target string */
 305
 306     for (i = 0; i < NumCarats; i++)
 307     {
 308         NewPathExternal[i] = AML_PARENT_PREFIX;
 309     }
 310
 311     /*
 312      * Copy only the necessary (optimal) segments from the original
 313      * target string
 314      */
 315     Index = (NumCommonSegments * ACPI_PATH_SEGMENT_LENGTH) + 1;
 316
 317     /* Special handling for exact subpath in a name declaration */
 318
 319     if (IsDeclaration && SubPath && (CurrentPath->Length > TargetPath->Length))
 320     {
 321         /*
 322          * The current path is longer than the target, and the target is a
 323          * subpath of the current path. We must include one more NameSeg of
 324          * the target path
 325          */
 326         Index -= ACPI_PATH_SEGMENT_LENGTH;
 327
 328         /* Special handling for Scope() operator */
 329
 330         if (Op->Asl.AmlOpcode == AML_SCOPE_OP)
 331         {
 332             NewPathExternal[i] = AML_PARENT_PREFIX;
 333             i++;
 334             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, "(EXTRA ^)"));
 335         }
 336     }
 337
 338     /* Make sure we haven't gone off the end of the target path */
 339
 340     if (Index > TargetPath->Length)
 341     {
 342         Index = TargetPath->Length;
 343     }
 344
 345     ACPI_STRCPY (&NewPathExternal[i], &((char *) TargetPath->Pointer)[Index]);
 346     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " %-24s", NewPathExternal));
 347
 348     /*
 349      * Internalize the new target string and check it against the original
 350      * string to make sure that this is in fact an optimization. If the
 351      * original string is already optimal, there is no point in continuing.
 352      */
 353     Status = AcpiNsInternalizeName (NewPathExternal, &NewPath);
 354     if (ACPI_FAILURE (Status))
 355     {
 356         AslCoreSubsystemError (Op, Status, "Internalizing new NamePath",
 357             ASL_NO_ABORT);
 358         ACPI_FREE (NewPathExternal);
 359         return (Status);
 360     }
 361
 362     if (ACPI_STRLEN (NewPath) >= AmlNameStringLength)
 363     {
 364         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 365             " NOT SHORTER (New %u old %u)",
 366             (UINT32) ACPI_STRLEN (NewPath), (UINT32) AmlNameStringLength));
 367         ACPI_FREE (NewPathExternal);
 368         return (AE_NOT_FOUND);
 369     }
 370
 371     /*
 372      * Check to make sure that the optimization finds the node we are
 373      * looking for. This is simply a sanity check on the new
 374      * path that has been created.
 375      */
 376     Status = AcpiNsLookup (&ScopeInfo,  NewPath,
 377                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 378                     ACPI_NS_DONT_OPEN_SCOPE, WalkState, &(Node));
 379     if (ACPI_SUCCESS (Status))
 380     {
 381         /* Found the namepath, but make sure the node is correct */
 382
 383         if (Node == TargetNode)
 384         {
 385             /* The lookup matched the node, accept this optimization */
 386
 387             AslError (ASL_OPTIMIZATION, ASL_MSG_NAME_OPTIMIZATION,
 388                 Op, NewPathExternal);
 389             *ReturnNewPath = NewPath;
 390         }
 391         else
 392         {
 393             /* Node is not correct, do not use this optimization */
 394
 395             Status = AE_NOT_FOUND;
 396             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " ***** WRONG NODE"));
 397             AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Op,
 398                 "Not using optimized name - found wrong node");
 399         }
 400     }
 401     else
 402     {
 403         /* The lookup failed, we obviously cannot use this optimization */
 404
 405         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " ***** NOT FOUND"));
 406         AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Op,
 407             "Not using optimized name - did not find node");
 408     }
 409
 410     ACPI_FREE (NewPathExternal);
 411     return (Status);
 412 }
 413
 414
 415 /*******************************************************************************
 416  *
 417  * FUNCTION:    OptOptimizeNameDeclaration
 418  *
 419  * PARAMETERS:  Op                  - Current parser op
 420  *              WalkState           - Current state
 421  *              CurrentNode         - Where we are in the namespace
 422  *              AmlNameString       - Unoptimized namepath
 423  *              NewPath             - Where the optimized path is returned
 424  *
 425  * RETURN:      Status. AE_OK If path is optimized
 426  *
 427  * DESCRIPTION: Perform a simple optimization of removing an extraneous
 428  *              backslash prefix if we are already at the root scope.
 429  *
 430  ******************************************************************************/
 431
 432 static ACPI_STATUS
 433 OptOptimizeNameDeclaration (
 434     ACPI_PARSE_OBJECT       *Op,
 435     ACPI_WALK_STATE         *WalkState,
 436     ACPI_NAMESPACE_NODE     *CurrentNode,
 437     ACPI_NAMESPACE_NODE     *TargetNode,
 438     char                    *AmlNameString,
 439     char                    **NewPath)
 440 {
 441     ACPI_STATUS             Status;
 442     char                    *NewPathExternal;
 443     ACPI_NAMESPACE_NODE     *Node;
 444
 445
 446     ACPI_FUNCTION_TRACE (OptOptimizeNameDeclaration);
 447
 448
 449     if (((CurrentNode == AcpiGbl_RootNode) ||
 450         (Op->Common.Parent->Asl.ParseOpcode == PARSEOP_DEFINITIONBLOCK)) &&
 451             (ACPI_IS_ROOT_PREFIX (AmlNameString[0])))
 452     {
 453         /*
 454          * The current scope is the root, and the namepath has a root prefix
 455          * that is therefore extraneous. Remove it.
 456          */
 457         *NewPath = &AmlNameString[1];
 458
 459         /* Debug output */
 460
 461         Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, *NewPath,
 462                     NULL, &NewPathExternal);
 463         if (ACPI_FAILURE (Status))
 464         {
 465             AslCoreSubsystemError (Op, Status, "Externalizing NamePath",
 466                 ASL_NO_ABORT);
 467             return (Status);
 468         }
 469
 470         /*
 471          * Check to make sure that the optimization finds the node we are
 472          * looking for. This is simply a sanity check on the new
 473          * path that has been created.
 474          *
 475          * We know that we are at the root, so NULL is used for the scope.
 476          */
 477         Status = AcpiNsLookup (NULL, *NewPath,
 478                         ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 479                         ACPI_NS_DONT_OPEN_SCOPE, WalkState, &(Node));
 480         if (ACPI_SUCCESS (Status))
 481         {
 482             /* Found the namepath, but make sure the node is correct */
 483
 484             if (Node == TargetNode)
 485             {
 486                 /* The lookup matched the node, accept this optimization */
 487
 488                 AslError (ASL_OPTIMIZATION, ASL_MSG_NAME_OPTIMIZATION,
 489                     Op, NewPathExternal);
 490
 491                 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 492                     "AT ROOT:   %-24s", NewPathExternal));
 493             }
 494             else
 495             {
 496                 /* Node is not correct, do not use this optimization */
 497
 498                 Status = AE_NOT_FOUND;
 499                 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 500                     " ***** WRONG NODE"));
 501                 AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Op,
 502                     "Not using optimized name - found wrong node");
 503             }
 504         }
 505         else
 506         {
 507             /* The lookup failed, we obviously cannot use this optimization */
 508
 509             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 510                 " ***** NOT FOUND"));
 511             AslError (ASL_WARNING, ASL_MSG_COMPILER_INTERNAL, Op,
 512                 "Not using optimized name - did not find node");
 513         }
 514
 515         ACPI_FREE (NewPathExternal);
 516         return (Status);
 517     }
 518
 519     /* Could not optimize */
 520
 521     return (AE_NOT_FOUND);
 522 }
 523
 524
 525 /*******************************************************************************
 526  *
 527  * FUNCTION:    OptOptimizeNamePath
 528  *
 529  * PARAMETERS:  Op                  - Current parser op
 530  *              Flags               - Opcode info flags
 531  *              WalkState           - Current state
 532  *              AmlNameString       - Unoptimized namepath
 533  *              TargetNode          - Node to which AmlNameString refers
 534  *
 535  * RETURN:      None. If path is optimized, the Op is updated with new path
 536  *
 537  * DESCRIPTION: Optimize a Named Declaration or Reference to the minimal length.
 538  *              Must take into account both the current location in the
 539  *              namespace and the actual reference path.
 540  *
 541  ******************************************************************************/
 542
 543 void
 544 OptOptimizeNamePath (
 545     ACPI_PARSE_OBJECT       *Op,
 546     UINT32                  Flags,
 547     ACPI_WALK_STATE         *WalkState,
 548     char                    *AmlNameString,
 549     ACPI_NAMESPACE_NODE     *TargetNode)
 550 {
 551     ACPI_STATUS             Status;
 552     ACPI_BUFFER             TargetPath;
 553     ACPI_BUFFER             CurrentPath;
 554     ACPI_SIZE               AmlNameStringLength;
 555     ACPI_NAMESPACE_NODE     *CurrentNode;
 556     char                    *ExternalNameString;
 557     char                    *NewPath = NULL;
 558     ACPI_SIZE               HowMuchShorter;
 559     ACPI_PARSE_OBJECT       *NextOp;
 560
 561
 562     ACPI_FUNCTION_TRACE (OptOptimizeNamePath);
 563
 564
 565     /* This is an optional optimization */
 566
 567     if (!Gbl_ReferenceOptimizationFlag)
 568     {
 569         return_VOID;
 570     }
 571
 572     /* Various required items */
 573
 574     if (!TargetNode || !WalkState || !AmlNameString || !Op->Common.Parent)
 575     {
 576         return_VOID;
 577     }
 578
 579     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 580         "PATH OPTIMIZE: Line %5d ParentOp [%12.12s] ThisOp [%12.12s] ",
 581         Op->Asl.LogicalLineNumber,
 582         AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode),
 583         AcpiPsGetOpcodeName (Op->Common.AmlOpcode)));
 584
 585     if (!(Flags & (AML_NAMED | AML_CREATE)))
 586     {
 587         if (Op->Asl.CompileFlags & NODE_IS_NAME_DECLARATION)
 588         {
 589             /* We don't want to fuss with actual name declaration nodes here */
 590
 591             ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 592                 "******* NAME DECLARATION\n"));
 593             return_VOID;
 594         }
 595     }
 596
 597     /*
 598      * The original path must be longer than one NameSeg (4 chars) for there
 599      * to be any possibility that it can be optimized to a shorter string
 600      */
 601     AmlNameStringLength = ACPI_STRLEN (AmlNameString);
 602     if (AmlNameStringLength <= ACPI_NAME_SIZE)
 603     {
 604         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 605             "NAMESEG %4.4s\n", AmlNameString));
 606         return_VOID;
 607     }
 608
 609     /*
 610      * We need to obtain the node that represents the current scope -- where
 611      * we are right now in the namespace. We will compare this path
 612      * against the Namepath, looking for commonality.
 613      */
 614     CurrentNode = AcpiGbl_RootNode;
 615     if (WalkState->ScopeInfo)
 616     {
 617         CurrentNode = WalkState->ScopeInfo->Scope.Node;
 618     }
 619
 620     if (Flags & (AML_NAMED | AML_CREATE))
 621     {
 622         /* This is the declaration of a new name */
 623
 624         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, "NAME\n"));
 625
 626         /*
 627          * The node of interest is the parent of this node (the containing
 628          * scope). The actual namespace node may be up more than one level
 629          * of parse op or it may not exist at all (if we traverse back
 630          * up to the root.)
 631          */
 632         NextOp = Op->Asl.Parent;
 633         while (NextOp && (!NextOp->Asl.Node))
 634         {
 635             NextOp = NextOp->Asl.Parent;
 636         }
 637         if (NextOp && NextOp->Asl.Node)
 638         {
 639             CurrentNode = NextOp->Asl.Node;
 640         }
 641         else
 642         {
 643             CurrentNode = AcpiGbl_RootNode;
 644         }
 645     }
 646     else
 647     {
 648         /* This is a reference to an existing named object */
 649
 650         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, "REFERENCE\n"));
 651     }
 652
 653     /*
 654      * Obtain the full paths to the two nodes that we are interested in
 655      * (Target and current namespace location) in external
 656      * format -- something we can easily manipulate
 657      */
 658     TargetPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 659     Status = AcpiNsHandleToPathname (TargetNode, &TargetPath);
 660     if (ACPI_FAILURE (Status))
 661     {
 662         AslCoreSubsystemError (Op, Status, "Getting Target NamePath",
 663             ASL_NO_ABORT);
 664         return_VOID;
 665     }
 666     TargetPath.Length--;    /* Subtract one for null terminator */
 667
 668     /* CurrentPath is the path to this scope (where we are in the namespace) */
 669
 670     CurrentPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 671     Status = AcpiNsHandleToPathname (CurrentNode, &CurrentPath);
 672     if (ACPI_FAILURE (Status))
 673     {
 674         AslCoreSubsystemError (Op, Status, "Getting Current NamePath",
 675             ASL_NO_ABORT);
 676         return_VOID;
 677     }
 678     CurrentPath.Length--;   /* Subtract one for null terminator */
 679
 680     /* Debug output only */
 681
 682     Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, AmlNameString,
 683                 NULL, &ExternalNameString);
 684     if (ACPI_FAILURE (Status))
 685     {
 686         AslCoreSubsystemError (Op, Status, "Externalizing NamePath",
 687             ASL_NO_ABORT);
 688         return_VOID;
 689     }
 690
 691     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 692         "CURRENT SCOPE: (%2u) %-37s FULL PATH TO NAME: (%2u) %-32s ACTUAL AML:%-32s\n",
 693         (UINT32) CurrentPath.Length, (char *) CurrentPath.Pointer,
 694         (UINT32) TargetPath.Length, (char *) TargetPath.Pointer,
 695         ExternalNameString));
 696
 697     ACPI_FREE (ExternalNameString);
 698
 699     /*
 700      * Attempt an optmization depending on the type of namepath
 701      */
 702     if (Flags & (AML_NAMED | AML_CREATE))
 703     {
 704         /*
 705          * This is a named opcode and the namepath is a name declaration, not
 706          * a reference.
 707          */
 708         Status = OptOptimizeNameDeclaration (Op, WalkState, CurrentNode,
 709                     TargetNode, AmlNameString, &NewPath);
 710         if (ACPI_FAILURE (Status))
 711         {
 712             /*
 713              * 2) now attempt to
 714              *    optimize the namestring with carats (up-arrow)
 715              */
 716             Status = OptBuildShortestPath (Op, WalkState, CurrentNode,
 717                             TargetNode, &CurrentPath, &TargetPath,
 718                             AmlNameStringLength, 1, &NewPath);
 719         }
 720     }
 721     else
 722     {
 723         /*
 724          * This is a reference to an existing named object
 725          *
 726          * 1) Check if search-to-root can be utilized using the last
 727          *    NameSeg of the NamePath
 728          */
 729         Status = OptSearchToRoot (Op, WalkState, CurrentNode,
 730                         TargetNode, &TargetPath, &NewPath);
 731         if (ACPI_FAILURE (Status))
 732         {
 733             /*
 734              * 2) Search-to-root could not be used, now attempt to
 735              *    optimize the namestring with carats (up-arrow)
 736              */
 737             Status = OptBuildShortestPath (Op, WalkState, CurrentNode,
 738                             TargetNode, &CurrentPath, &TargetPath,
 739                             AmlNameStringLength, 0, &NewPath);
 740         }
 741     }
 742
 743     /*
 744      * Success from above indicates that the NamePath was successfully
 745      * optimized. We need to update the parse op with the new name
 746      */
 747     if (ACPI_SUCCESS (Status))
 748     {
 749         HowMuchShorter = (AmlNameStringLength - ACPI_STRLEN (NewPath));
 750         OptTotal += HowMuchShorter;
 751
 752         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
 753             " REDUCED BY %2u (TOTAL SAVED %2u)",
 754             (UINT32) HowMuchShorter, OptTotal));
 755
 756         if (Flags & AML_NAMED)
 757         {
 758             if (Op->Asl.AmlOpcode == AML_ALIAS_OP)
 759             {
 760                 /*
 761                  * ALIAS is the only oddball opcode, the name declaration
 762                  * (alias name) is the second operand
 763                  */
 764                 Op->Asl.Child->Asl.Next->Asl.Value.String = NewPath;
 765                 Op->Asl.Child->Asl.Next->Asl.AmlLength = ACPI_STRLEN (NewPath);
 766             }
 767             else
 768             {
 769                 Op->Asl.Child->Asl.Value.String = NewPath;
 770                 Op->Asl.Child->Asl.AmlLength = ACPI_STRLEN (NewPath);
 771             }
 772         }
 773         else if (Flags & AML_CREATE)
 774         {
 775             /* Name must appear as the last parameter */
 776
 777             NextOp = Op->Asl.Child;
 778             while (!(NextOp->Asl.CompileFlags & NODE_IS_NAME_DECLARATION))
 779             {
 780                 NextOp = NextOp->Asl.Next;
 781             }
 782             /* Update the parse node with the new NamePath */
 783
 784             NextOp->Asl.Value.String = NewPath;
 785             NextOp->Asl.AmlLength = ACPI_STRLEN (NewPath);
 786         }
 787         else
 788         {
 789             /* Update the parse node with the new NamePath */
 790
 791             Op->Asl.Value.String = NewPath;
 792             Op->Asl.AmlLength = ACPI_STRLEN (NewPath);
 793         }
 794     }
 795     else
 796     {
 797         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " ALREADY OPTIMAL"));
 798     }
 799
 800     /* Cleanup path buffers */
 801
 802     ACPI_FREE (TargetPath.Pointer);
 803     ACPI_FREE (CurrentPath.Pointer);
 804
 805     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, "\n"));
 806     return_VOID;
 807 }