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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslmethod.c - Control method analysis walk
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************
 115  *
 116  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include "aslcompiler.h"
 153 #include "aslcompiler.y.h"
 154 #include "acparser.h"
 155 #include "amlcode.h"
 156
 157
 158 #define _COMPONENT          ACPI_COMPILER
 159         ACPI_MODULE_NAME    ("aslmethod")
 160
 161
 162 /* Local prototypes */
 163
 164 static void
 165 MtCheckNamedObjectInMethod (
 166     ACPI_PARSE_OBJECT       *Op,
 167     ASL_METHOD_INFO         *MethodInfo);
 168
 169
 170 /*******************************************************************************
 171  *
 172  * FUNCTION:    MtMethodAnalysisWalkBegin
 173  *
 174  * PARAMETERS:  ASL_WALK_CALLBACK
 175  *
 176  * RETURN:      Status
 177  *
 178  * DESCRIPTION: Descending callback for the analysis walk. Check methods for:
 179  *              1) Initialized local variables
 180  *              2) Valid arguments
 181  *              3) Return types
 182  *
 183  ******************************************************************************/
 184
 185 ACPI_STATUS
 186 MtMethodAnalysisWalkBegin (
 187     ACPI_PARSE_OBJECT       *Op,
 188     UINT32                  Level,
 189     void                    *Context)
 190 {
 191     ASL_ANALYSIS_WALK_INFO  *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
 192     ASL_METHOD_INFO         *MethodInfo = WalkInfo->MethodStack;
 193     ACPI_PARSE_OBJECT       *Next;
 194     UINT32                  RegisterNumber;
 195     UINT32                  i;
 196     char                    LocalName[] = "Local0";
 197     char                    ArgName[] = "Arg0";
 198     ACPI_PARSE_OBJECT       *ArgNode;
 199     ACPI_PARSE_OBJECT       *NextType;
 200     ACPI_PARSE_OBJECT       *NextParamType;
 201     UINT8                   ActualArgs = 0;
 202     BOOLEAN                 HidExists;
 203     BOOLEAN                 AdrExists;
 204
 205
 206     /* Build cross-reference output file if requested */
 207
 208     if (AslGbl_CrossReferenceOutput)
 209     {
 210         OtXrefWalkPart1 (Op, Level, MethodInfo);
 211     }
 212
 213     switch (Op->Asl.ParseOpcode)
 214     {
 215     case PARSEOP_METHOD:
 216
 217         AslGbl_TotalMethods++;
 218
 219         /* Create and init method info */
 220
 221         MethodInfo = UtLocalCalloc (sizeof (ASL_METHOD_INFO));
 222         MethodInfo->Next = WalkInfo->MethodStack;
 223         MethodInfo->Op = Op;
 224
 225         WalkInfo->MethodStack = MethodInfo;
 226
 227         /*
 228          * Special handling for _PSx methods. Dependency rules (same scope):
 229          *
 230          * 1) _PS0 - One of these must exist: _PS1, _PS2, _PS3
 231          * 2) _PS1/_PS2/_PS3: A _PS0 must exist
 232          */
 233         if (ACPI_COMPARE_NAMESEG (METHOD_NAME__PS0, Op->Asl.NameSeg))
 234         {
 235             /* For _PS0, one of _PS1/_PS2/_PS3 must exist */
 236
 237             if ((!ApFindNameInScope (METHOD_NAME__PS1, Op)) &&
 238                 (!ApFindNameInScope (METHOD_NAME__PS2, Op)) &&
 239                 (!ApFindNameInScope (METHOD_NAME__PS3, Op)))
 240             {
 241                 AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 242                     "_PS0 requires one of _PS1/_PS2/_PS3 in same scope");
 243             }
 244         }
 245         else if (
 246             ACPI_COMPARE_NAMESEG (METHOD_NAME__PS1, Op->Asl.NameSeg) ||
 247             ACPI_COMPARE_NAMESEG (METHOD_NAME__PS2, Op->Asl.NameSeg) ||
 248             ACPI_COMPARE_NAMESEG (METHOD_NAME__PS3, Op->Asl.NameSeg))
 249         {
 250             /* For _PS1/_PS2/_PS3, a _PS0 must exist */
 251
 252             if (!ApFindNameInScope (METHOD_NAME__PS0, Op))
 253             {
 254                 sprintf (AslGbl_MsgBuffer,
 255                     "%4.4s requires _PS0 in same scope", Op->Asl.NameSeg);
 256
 257                 AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 258                     AslGbl_MsgBuffer);
 259             }
 260         }
 261
 262         /* Get the name node */
 263
 264         Next = Op->Asl.Child;
 265
 266         /* Get the NumArguments node */
 267
 268         Next = Next->Asl.Next;
 269         MethodInfo->NumArguments = (UINT8)
 270             (((UINT8) Next->Asl.Value.Integer) & 0x07);
 271
 272         /* Get the SerializeRule and SyncLevel nodes, ignored here */
 273
 274         Next = Next->Asl.Next;
 275         MethodInfo->ShouldBeSerialized = (UINT8) Next->Asl.Value.Integer;
 276
 277         Next = Next->Asl.Next;
 278         ArgNode = Next;
 279
 280         /* Get the ReturnType node */
 281
 282         Next = Next->Asl.Next;
 283
 284         NextType = Next->Asl.Child;
 285         while (NextType)
 286         {
 287             /* Get and map each of the ReturnTypes */
 288
 289             MethodInfo->ValidReturnTypes |= AnMapObjTypeToBtype (NextType);
 290             NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 291             NextType = NextType->Asl.Next;
 292         }
 293
 294         /* Get the ParameterType node */
 295
 296         Next = Next->Asl.Next;
 297
 298         NextType = Next->Asl.Child;
 299         while (NextType)
 300         {
 301             if (NextType->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 302             {
 303                 NextParamType = NextType->Asl.Child;
 304                 while (NextParamType)
 305                 {
 306                     MethodInfo->ValidArgTypes[ActualArgs] |=
 307                         AnMapObjTypeToBtype (NextParamType);
 308
 309                     NextParamType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 310                     NextParamType = NextParamType->Asl.Next;
 311                 }
 312             }
 313             else
 314             {
 315                 MethodInfo->ValidArgTypes[ActualArgs] =
 316                     AnMapObjTypeToBtype (NextType);
 317
 318                 NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 319                 ActualArgs++;
 320             }
 321
 322             NextType = NextType->Asl.Next;
 323         }
 324
 325         if ((MethodInfo->NumArguments) &&
 326             (MethodInfo->NumArguments != ActualArgs))
 327         {
 328             /* error: Param list did not match number of args */
 329         }
 330
 331         /* Allow numarguments == 0 for Function() */
 332
 333         if ((!MethodInfo->NumArguments) && (ActualArgs))
 334         {
 335             MethodInfo->NumArguments = ActualArgs;
 336             ArgNode->Asl.Value.Integer |= ActualArgs;
 337         }
 338
 339         /*
 340          * Actual arguments are initialized at method entry.
 341          * All other ArgX "registers" can be used as locals, so we
 342          * track their initialization.
 343          */
 344         for (i = 0; i < MethodInfo->NumArguments; i++)
 345         {
 346             MethodInfo->ArgInitialized[i] = TRUE;
 347         }
 348         break;
 349
 350     case PARSEOP_METHODCALL:
 351
 352         /* Check for a recursive method call */
 353
 354         if (MethodInfo &&
 355            (Op->Asl.Node == MethodInfo->Op->Asl.Node))
 356         {
 357             if (MethodInfo->CreatesNamedObjects)
 358             {
 359                 /*
 360                  * This is an error, as it will fail at runtime on all ACPI
 361                  * implementations. Any named object declarations will be
 362                  * executed twice, causing failure the second time. Note,
 363                  * this is independent of whether the method is declared
 364                  * Serialized, because the same thread is attempting to
 365                  * reenter the method, and this will always succeed.
 366                  */
 367                 AslDualParseOpError (ASL_ERROR, ASL_MSG_ILLEGAL_RECURSION, Op,
 368                     Op->Asl.Value.String, ASL_MSG_FOUND_HERE, MethodInfo->Op,
 369                     MethodInfo->Op->Asl.ExternalName);
 370             }
 371             else
 372             {
 373                 /* Method does not create objects, issue a remark */
 374
 375                 AslError (ASL_REMARK, ASL_MSG_RECURSION, Op, Op->Asl.ExternalName);
 376             }
 377         }
 378         break;
 379
 380     case PARSEOP_LOCAL0:
 381     case PARSEOP_LOCAL1:
 382     case PARSEOP_LOCAL2:
 383     case PARSEOP_LOCAL3:
 384     case PARSEOP_LOCAL4:
 385     case PARSEOP_LOCAL5:
 386     case PARSEOP_LOCAL6:
 387     case PARSEOP_LOCAL7:
 388
 389         if (!MethodInfo)
 390         {
 391             /*
 392              * Local was used outside a control method, or there was an error
 393              * in the method declaration.
 394              */
 395             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD,
 396                 Op, Op->Asl.ExternalName);
 397             return (AE_ERROR);
 398         }
 399
 400         RegisterNumber = (Op->Asl.AmlOpcode & 0x0007);
 401
 402         /*
 403          * If the local is being used as a target, mark the local
 404          * initialized
 405          */
 406         if (Op->Asl.CompileFlags & OP_IS_TARGET)
 407         {
 408             MethodInfo->LocalInitialized[RegisterNumber] = TRUE;
 409         }
 410
 411         /*
 412          * Otherwise, this is a reference, check if the local
 413          * has been previously initialized.
 414          *
 415          * The only operator that accepts an uninitialized value is ObjectType()
 416          */
 417         else if ((!MethodInfo->LocalInitialized[RegisterNumber]) &&
 418                  (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
 419         {
 420             LocalName[strlen (LocalName) -1] = (char) (RegisterNumber + 0x30);
 421             AslError (ASL_ERROR, ASL_MSG_LOCAL_INIT, Op, LocalName);
 422         }
 423         break;
 424
 425     case PARSEOP_ARG0:
 426     case PARSEOP_ARG1:
 427     case PARSEOP_ARG2:
 428     case PARSEOP_ARG3:
 429     case PARSEOP_ARG4:
 430     case PARSEOP_ARG5:
 431     case PARSEOP_ARG6:
 432
 433         if (!MethodInfo)
 434         {
 435             /*
 436              * Arg was used outside a control method, or there was an error
 437              * in the method declaration.
 438              */
 439             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD,
 440                 Op, Op->Asl.ExternalName);
 441             return (AE_ERROR);
 442         }
 443
 444         RegisterNumber = (Op->Asl.AmlOpcode & 0x000F) - 8;
 445         ArgName[strlen (ArgName) -1] = (char) (RegisterNumber + 0x30);
 446
 447         /*
 448          * If the Arg is being used as a target, mark the local
 449          * initialized
 450          */
 451         if (Op->Asl.CompileFlags & OP_IS_TARGET)
 452         {
 453             MethodInfo->ArgInitialized[RegisterNumber] = TRUE;
 454         }
 455
 456         /*
 457          * Otherwise, this is a reference, check if the Arg
 458          * has been previously initialized.
 459          *
 460          * The only operator that accepts an uninitialized value is ObjectType()
 461          */
 462         else if ((!MethodInfo->ArgInitialized[RegisterNumber]) &&
 463             (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
 464         {
 465             AslError (ASL_ERROR, ASL_MSG_ARG_INIT, Op, ArgName);
 466         }
 467
 468         /* Flag this arg if it is not a "real" argument to the method */
 469
 470         if (RegisterNumber >= MethodInfo->NumArguments)
 471         {
 472             AslError (ASL_REMARK, ASL_MSG_NOT_PARAMETER, Op, ArgName);
 473         }
 474         break;
 475
 476     case PARSEOP_RETURN:
 477
 478         if (!MethodInfo)
 479         {
 480             /*
 481              * Probably was an error in the method declaration,
 482              * no additional error here
 483              */
 484             ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
 485             return (AE_ERROR);
 486         }
 487
 488         /*
 489          * A child indicates a possible return value. A simple Return or
 490          * Return() is marked with OP_IS_NULL_RETURN by the parser so
 491          * that it is not counted as a "real" return-with-value, although
 492          * the AML code that is actually emitted is Return(0). The AML
 493          * definition of Return has a required parameter, so we are
 494          * forced to convert a null return to Return(0).
 495          */
 496         if ((Op->Asl.Child) &&
 497             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 498             (!(Op->Asl.Child->Asl.CompileFlags & OP_IS_NULL_RETURN)))
 499         {
 500             MethodInfo->NumReturnWithValue++;
 501         }
 502         else
 503         {
 504             MethodInfo->NumReturnNoValue++;
 505         }
 506         break;
 507
 508     case PARSEOP_BREAK:
 509     case PARSEOP_CONTINUE:
 510
 511         Next = Op->Asl.Parent;
 512         while (Next)
 513         {
 514             if (Next->Asl.ParseOpcode == PARSEOP_WHILE)
 515             {
 516                 break;
 517             }
 518             Next = Next->Asl.Parent;
 519         }
 520
 521         if (!Next)
 522         {
 523             AslError (ASL_ERROR, ASL_MSG_NO_WHILE, Op, NULL);
 524         }
 525         break;
 526
 527     case PARSEOP_STALL:
 528
 529         /* We can range check if the argument is an integer */
 530
 531         if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
 532             (Op->Asl.Child->Asl.Value.Integer > ACPI_UINT8_MAX))
 533         {
 534             AslError (ASL_ERROR, ASL_MSG_INVALID_TIME, Op, NULL);
 535         }
 536         break;
 537
 538     case PARSEOP_DEVICE:
 539
 540         /* Check usage of _HID and _ADR objects */
 541
 542         HidExists = ApFindNameInDeviceTree (METHOD_NAME__HID, Op);
 543         AdrExists = ApFindNameInDeviceTree (METHOD_NAME__ADR, Op);
 544
 545         if (!HidExists && !AdrExists)
 546         {
 547             AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 548                 "Device object requires a _HID or _ADR in same scope");
 549         }
 550         else if (HidExists && AdrExists)
 551         {
 552             /*
 553              * According to the ACPI spec, "A device object must contain
 554              * either an _HID object or an _ADR object, but should not contain
 555              * both".
 556              */
 557             AslError (ASL_WARNING, ASL_MSG_MULTIPLE_TYPES, Op,
 558                 "Device object requires either a _HID or _ADR, but not both");
 559         }
 560         break;
 561
 562     case PARSEOP_EVENT:
 563     case PARSEOP_MUTEX:
 564     case PARSEOP_OPERATIONREGION:
 565     case PARSEOP_POWERRESOURCE:
 566     case PARSEOP_PROCESSOR:
 567     case PARSEOP_THERMALZONE:
 568
 569         /*
 570          * The first operand is a name to be created in the namespace.
 571          * Check against the reserved list.
 572          */
 573         i = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
 574         if (i < ACPI_VALID_RESERVED_NAME_MAX)
 575         {
 576             AslError (ASL_ERROR, ASL_MSG_RESERVED_USE,
 577                 Op, Op->Asl.ExternalName);
 578         }
 579         break;
 580
 581     case PARSEOP_NAME:
 582
 583         /* Typecheck any predefined names statically defined with Name() */
 584
 585         ApCheckForPredefinedObject (Op, Op->Asl.NameSeg);
 586
 587         /* Special typechecking for _HID */
 588
 589         if (ACPI_COMPARE_NAMESEG (METHOD_NAME__HID, Op->Asl.NameSeg))
 590         {
 591             Next = Op->Asl.Child->Asl.Next;
 592             AnCheckId (Next, ASL_TYPE_HID);
 593         }
 594
 595         /* Special typechecking for _CID */
 596
 597         else if (ACPI_COMPARE_NAMESEG (METHOD_NAME__CID, Op->Asl.NameSeg))
 598         {
 599             Next = Op->Asl.Child->Asl.Next;
 600
 601             if ((Next->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
 602                 (Next->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
 603             {
 604                 Next = Next->Asl.Child;
 605                 while (Next)
 606                 {
 607                     AnCheckId (Next, ASL_TYPE_CID);
 608                     Next = Next->Asl.Next;
 609                 }
 610             }
 611             else
 612             {
 613                 AnCheckId (Next, ASL_TYPE_CID);
 614             }
 615         }
 616
 617         break;
 618
 619     default:
 620
 621         break;
 622     }
 623
 624     /* Check for named object creation within a non-serialized method */
 625
 626     MtCheckNamedObjectInMethod (Op, MethodInfo);
 627     return (AE_OK);
 628 }
 629
 630
 631 /*******************************************************************************
 632  *
 633  * FUNCTION:    MtCheckNamedObjectInMethod
 634  *
 635  * PARAMETERS:  Op                  - Current parser op
 636  *              MethodInfo          - Info for method being parsed
 637  *
 638  * RETURN:      None
 639  *
 640  * DESCRIPTION: Detect if a non-serialized method is creating a named object,
 641  *              which could possibly cause problems if two threads execute
 642  *              the method concurrently. Emit a remark in this case.
 643  *
 644  ******************************************************************************/
 645
 646 static void
 647 MtCheckNamedObjectInMethod (
 648     ACPI_PARSE_OBJECT       *Op,
 649     ASL_METHOD_INFO         *MethodInfo)
 650 {
 651     const ACPI_OPCODE_INFO  *OpInfo;
 652
 653
 654     /* We don't care about actual method declarations or scopes */
 655
 656     if ((Op->Asl.AmlOpcode == AML_METHOD_OP) ||
 657         (Op->Asl.AmlOpcode == AML_SCOPE_OP))
 658     {
 659         return;
 660     }
 661
 662     /* Determine if we are creating a named object within a method */
 663
 664     if (!MethodInfo)
 665     {
 666         return;
 667     }
 668
 669     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 670     if (OpInfo->Class == AML_CLASS_NAMED_OBJECT)
 671     {
 672         /*
 673          * 1) Mark the method as a method that creates named objects.
 674          *
 675          * 2) If the method is non-serialized, emit a remark that the method
 676          * should be serialized.
 677          *
 678          * Reason: If a thread blocks within the method for any reason, and
 679          * another thread enters the method, the method will fail because
 680          * an attempt will be made to create the same object twice.
 681          */
 682         MethodInfo->CreatesNamedObjects = TRUE;
 683         if (!MethodInfo->ShouldBeSerialized)
 684         {
 685             AslError (ASL_REMARK, ASL_MSG_SERIALIZED_REQUIRED, MethodInfo->Op,
 686                 "due to creation of named objects within");
 687
 688             /* Emit message only ONCE per method */
 689
 690             MethodInfo->ShouldBeSerialized = TRUE;
 691         }
 692     }
 693 }
 694
 695
 696 /*******************************************************************************
 697  *
 698  * FUNCTION:    MtMethodAnalysisWalkEnd
 699  *
 700  * PARAMETERS:  ASL_WALK_CALLBACK
 701  *
 702  * RETURN:      Status
 703  *
 704  * DESCRIPTION: Ascending callback for analysis walk. Complete method
 705  *              return analysis.
 706  *
 707  ******************************************************************************/
 708
 709 ACPI_STATUS
 710 MtMethodAnalysisWalkEnd (
 711     ACPI_PARSE_OBJECT       *Op,
 712     UINT32                  Level,
 713     void                    *Context)
 714 {
 715     ASL_ANALYSIS_WALK_INFO  *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
 716     ASL_METHOD_INFO         *MethodInfo = WalkInfo->MethodStack;
 717
 718
 719     switch (Op->Asl.ParseOpcode)
 720     {
 721     case PARSEOP_METHOD:
 722     case PARSEOP_RETURN:
 723
 724         if (!MethodInfo)
 725         {
 726             printf ("No method info for method! [%s]\n", Op->Asl.Namepath);
 727             AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
 728                 "No method info for this method");
 729
 730             CmCleanupAndExit ();
 731             return (AE_AML_INTERNAL);
 732         }
 733         break;
 734
 735     default:
 736
 737         break;
 738     }
 739
 740     switch (Op->Asl.ParseOpcode)
 741     {
 742     case PARSEOP_METHOD:
 743
 744         WalkInfo->MethodStack = MethodInfo->Next;
 745
 746         /*
 747          * Check if there is no return statement at the end of the
 748          * method AND we can actually get there -- i.e., the execution
 749          * of the method can possibly terminate without a return statement.
 750          */
 751         if ((!AnLastStatementIsReturn (Op)) &&
 752             (!(Op->Asl.CompileFlags & OP_HAS_NO_EXIT)))
 753         {
 754             /*
 755              * No return statement, and execution can possibly exit
 756              * via this path. This is equivalent to Return ()
 757              */
 758             MethodInfo->NumReturnNoValue++;
 759         }
 760
 761         /*
 762          * Check for case where some return statements have a return value
 763          * and some do not. Exit without a return statement is a return with
 764          * no value
 765          */
 766         if (MethodInfo->NumReturnNoValue &&
 767             MethodInfo->NumReturnWithValue)
 768         {
 769             AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Op,
 770                 Op->Asl.ExternalName);
 771         }
 772
 773         /*
 774          * If there are any RETURN() statements with no value, or there is a
 775          * control path that allows the method to exit without a return value,
 776          * we mark the method as a method that does not return a value. This
 777          * knowledge can be used to check method invocations that expect a
 778          * returned value.
 779          */
 780         if (MethodInfo->NumReturnNoValue)
 781         {
 782             if (MethodInfo->NumReturnWithValue)
 783             {
 784                 Op->Asl.CompileFlags |= OP_METHOD_SOME_NO_RETVAL;
 785             }
 786             else
 787             {
 788                 Op->Asl.CompileFlags |= OP_METHOD_NO_RETVAL;
 789             }
 790         }
 791
 792         /*
 793          * Check predefined method names for correct return behavior
 794          * and correct number of arguments. Also, some special checks
 795          * For GPE and _REG methods.
 796          */
 797         if (ApCheckForPredefinedMethod (Op, MethodInfo))
 798         {
 799             /* Special check for two names like _L01 and _E01 in same scope */
 800
 801             ApCheckForGpeNameConflict (Op);
 802
 803             /*
 804              * Special check for _REG: Must have an operation region definition
 805              * within the same scope!
 806              */
 807             ApCheckRegMethod (Op);
 808         }
 809
 810         ACPI_FREE (MethodInfo);
 811         break;
 812
 813     case PARSEOP_NAME:
 814
 815          /* Special check for two names like _L01 and _E01 in same scope */
 816
 817         ApCheckForGpeNameConflict (Op);
 818         break;
 819
 820     case PARSEOP_RETURN:
 821
 822         /*
 823          * If the parent is a predefined method name, attempt to typecheck
 824          * the return value. Only static types can be validated.
 825          */
 826         ApCheckPredefinedReturnValue (Op, MethodInfo);
 827
 828         /*
 829          * The parent block does not "exit" and continue execution -- the
 830          * method is terminated here with the Return() statement.
 831          */
 832         Op->Asl.Parent->Asl.CompileFlags |= OP_HAS_NO_EXIT;
 833
 834         /* Used in the "typing" pass later */
 835
 836         Op->Asl.ParentMethod = MethodInfo->Op;
 837
 838         /*
 839          * If there is a peer node after the return statement, then this
 840          * node is unreachable code -- i.e., it won't be executed because of
 841          * the preceding Return() statement.
 842          */
 843         if (Op->Asl.Next)
 844         {
 845             AslError (ASL_WARNING, ASL_MSG_UNREACHABLE_CODE,
 846                 Op->Asl.Next, NULL);
 847         }
 848         break;
 849
 850     case PARSEOP_IF:
 851
 852         if ((Op->Asl.CompileFlags & OP_HAS_NO_EXIT) &&
 853             (Op->Asl.Next) &&
 854             (Op->Asl.Next->Asl.ParseOpcode == PARSEOP_ELSE))
 855         {
 856             /*
 857              * This IF has a corresponding ELSE. The IF block has no exit,
 858              * (it contains an unconditional Return)
 859              * mark the ELSE block to remember this fact.
 860              */
 861             Op->Asl.Next->Asl.CompileFlags |= OP_IF_HAS_NO_EXIT;
 862         }
 863         break;
 864
 865     case PARSEOP_ELSE:
 866
 867         if ((Op->Asl.CompileFlags & OP_HAS_NO_EXIT) &&
 868             (Op->Asl.CompileFlags & OP_IF_HAS_NO_EXIT))
 869         {
 870             /*
 871              * This ELSE block has no exit and the corresponding IF block
 872              * has no exit either. Therefore, the parent node has no exit.
 873              */
 874             Op->Asl.Parent->Asl.CompileFlags |= OP_HAS_NO_EXIT;
 875         }
 876         break;
 877
 878
 879     default:
 880
 881         if ((Op->Asl.CompileFlags & OP_HAS_NO_EXIT) &&
 882             (Op->Asl.Parent))
 883         {
 884             /* If this node has no exit, then the parent has no exit either */
 885
 886             Op->Asl.Parent->Asl.CompileFlags |= OP_HAS_NO_EXIT;
 887         }
 888         break;
 889     }
 890
 891     return (AE_OK);
 892 }