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 - 2017, 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
 203
 204     /* Build cross-reference output file if requested */
 205
 206     if (Gbl_CrossReferenceOutput)
 207     {
 208         OtXrefWalkPart1 (Op, Level, MethodInfo);
 209     }
 210
 211     switch (Op->Asl.ParseOpcode)
 212     {
 213     case PARSEOP_METHOD:
 214
 215         TotalMethods++;
 216
 217         /* Create and init method info */
 218
 219         MethodInfo = UtLocalCalloc (sizeof (ASL_METHOD_INFO));
 220         MethodInfo->Next = WalkInfo->MethodStack;
 221         MethodInfo->Op = Op;
 222
 223         WalkInfo->MethodStack = MethodInfo;
 224
 225         /*
 226          * Special handling for _PSx methods. Dependency rules (same scope):
 227          *
 228          * 1) _PS0 - One of these must exist: _PS1, _PS2, _PS3
 229          * 2) _PS1/_PS2/_PS3: A _PS0 must exist
 230          */
 231         if (ACPI_COMPARE_NAME (METHOD_NAME__PS0, Op->Asl.NameSeg))
 232         {
 233             /* For _PS0, one of _PS1/_PS2/_PS3 must exist */
 234
 235             if ((!ApFindNameInScope (METHOD_NAME__PS1, Op)) &&
 236                 (!ApFindNameInScope (METHOD_NAME__PS2, Op)) &&
 237                 (!ApFindNameInScope (METHOD_NAME__PS3, Op)))
 238             {
 239                 AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 240                     "_PS0 requires one of _PS1/_PS2/_PS3 in same scope");
 241             }
 242         }
 243         else if (
 244             ACPI_COMPARE_NAME (METHOD_NAME__PS1, Op->Asl.NameSeg) ||
 245             ACPI_COMPARE_NAME (METHOD_NAME__PS2, Op->Asl.NameSeg) ||
 246             ACPI_COMPARE_NAME (METHOD_NAME__PS3, Op->Asl.NameSeg))
 247         {
 248             /* For _PS1/_PS2/_PS3, a _PS0 must exist */
 249
 250             if (!ApFindNameInScope (METHOD_NAME__PS0, Op))
 251             {
 252                 sprintf (MsgBuffer,
 253                     "%4.4s requires _PS0 in same scope", Op->Asl.NameSeg);
 254
 255                 AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 256                     MsgBuffer);
 257             }
 258         }
 259
 260         /* Get the name node */
 261
 262         Next = Op->Asl.Child;
 263
 264         /* Get the NumArguments node */
 265
 266         Next = Next->Asl.Next;
 267         MethodInfo->NumArguments = (UINT8)
 268             (((UINT8) Next->Asl.Value.Integer) & 0x07);
 269
 270         /* Get the SerializeRule and SyncLevel nodes, ignored here */
 271
 272         Next = Next->Asl.Next;
 273         MethodInfo->ShouldBeSerialized = (UINT8) Next->Asl.Value.Integer;
 274
 275         Next = Next->Asl.Next;
 276         ArgNode = Next;
 277
 278         /* Get the ReturnType node */
 279
 280         Next = Next->Asl.Next;
 281
 282         NextType = Next->Asl.Child;
 283         while (NextType)
 284         {
 285             /* Get and map each of the ReturnTypes */
 286
 287             MethodInfo->ValidReturnTypes |= AnMapObjTypeToBtype (NextType);
 288             NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 289             NextType = NextType->Asl.Next;
 290         }
 291
 292         /* Get the ParameterType node */
 293
 294         Next = Next->Asl.Next;
 295
 296         NextType = Next->Asl.Child;
 297         while (NextType)
 298         {
 299             if (NextType->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 300             {
 301                 NextParamType = NextType->Asl.Child;
 302                 while (NextParamType)
 303                 {
 304                     MethodInfo->ValidArgTypes[ActualArgs] |=
 305                         AnMapObjTypeToBtype (NextParamType);
 306
 307                     NextParamType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 308                     NextParamType = NextParamType->Asl.Next;
 309                 }
 310             }
 311             else
 312             {
 313                 MethodInfo->ValidArgTypes[ActualArgs] =
 314                     AnMapObjTypeToBtype (NextType);
 315
 316                 NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
 317                 ActualArgs++;
 318             }
 319
 320             NextType = NextType->Asl.Next;
 321         }
 322
 323         if ((MethodInfo->NumArguments) &&
 324             (MethodInfo->NumArguments != ActualArgs))
 325         {
 326             /* error: Param list did not match number of args */
 327         }
 328
 329         /* Allow numarguments == 0 for Function() */
 330
 331         if ((!MethodInfo->NumArguments) && (ActualArgs))
 332         {
 333             MethodInfo->NumArguments = ActualArgs;
 334             ArgNode->Asl.Value.Integer |= ActualArgs;
 335         }
 336
 337         /*
 338          * Actual arguments are initialized at method entry.
 339          * All other ArgX "registers" can be used as locals, so we
 340          * track their initialization.
 341          */
 342         for (i = 0; i < MethodInfo->NumArguments; i++)
 343         {
 344             MethodInfo->ArgInitialized[i] = TRUE;
 345         }
 346         break;
 347
 348     case PARSEOP_METHODCALL:
 349
 350         if (MethodInfo &&
 351            (Op->Asl.Node == MethodInfo->Op->Asl.Node))
 352         {
 353             AslError (ASL_REMARK, ASL_MSG_RECURSION, Op, Op->Asl.ExternalName);
 354         }
 355         break;
 356
 357     case PARSEOP_LOCAL0:
 358     case PARSEOP_LOCAL1:
 359     case PARSEOP_LOCAL2:
 360     case PARSEOP_LOCAL3:
 361     case PARSEOP_LOCAL4:
 362     case PARSEOP_LOCAL5:
 363     case PARSEOP_LOCAL6:
 364     case PARSEOP_LOCAL7:
 365
 366         if (!MethodInfo)
 367         {
 368             /*
 369              * Local was used outside a control method, or there was an error
 370              * in the method declaration.
 371              */
 372             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD,
 373                 Op, Op->Asl.ExternalName);
 374             return (AE_ERROR);
 375         }
 376
 377         RegisterNumber = (Op->Asl.AmlOpcode & 0x0007);
 378
 379         /*
 380          * If the local is being used as a target, mark the local
 381          * initialized
 382          */
 383         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
 384         {
 385             MethodInfo->LocalInitialized[RegisterNumber] = TRUE;
 386         }
 387
 388         /*
 389          * Otherwise, this is a reference, check if the local
 390          * has been previously initialized.
 391          *
 392          * The only operator that accepts an uninitialized value is ObjectType()
 393          */
 394         else if ((!MethodInfo->LocalInitialized[RegisterNumber]) &&
 395                  (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
 396         {
 397             LocalName[strlen (LocalName) -1] = (char) (RegisterNumber + 0x30);
 398             AslError (ASL_ERROR, ASL_MSG_LOCAL_INIT, Op, LocalName);
 399         }
 400         break;
 401
 402     case PARSEOP_ARG0:
 403     case PARSEOP_ARG1:
 404     case PARSEOP_ARG2:
 405     case PARSEOP_ARG3:
 406     case PARSEOP_ARG4:
 407     case PARSEOP_ARG5:
 408     case PARSEOP_ARG6:
 409
 410         if (!MethodInfo)
 411         {
 412             /*
 413              * Arg was used outside a control method, or there was an error
 414              * in the method declaration.
 415              */
 416             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD,
 417                 Op, Op->Asl.ExternalName);
 418             return (AE_ERROR);
 419         }
 420
 421         RegisterNumber = (Op->Asl.AmlOpcode & 0x000F) - 8;
 422         ArgName[strlen (ArgName) -1] = (char) (RegisterNumber + 0x30);
 423
 424         /*
 425          * If the Arg is being used as a target, mark the local
 426          * initialized
 427          */
 428         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
 429         {
 430             MethodInfo->ArgInitialized[RegisterNumber] = TRUE;
 431         }
 432
 433         /*
 434          * Otherwise, this is a reference, check if the Arg
 435          * has been previously initialized.
 436          *
 437          * The only operator that accepts an uninitialized value is ObjectType()
 438          */
 439         else if ((!MethodInfo->ArgInitialized[RegisterNumber]) &&
 440             (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
 441         {
 442             AslError (ASL_ERROR, ASL_MSG_ARG_INIT, Op, ArgName);
 443         }
 444
 445         /* Flag this arg if it is not a "real" argument to the method */
 446
 447         if (RegisterNumber >= MethodInfo->NumArguments)
 448         {
 449             AslError (ASL_REMARK, ASL_MSG_NOT_PARAMETER, Op, ArgName);
 450         }
 451         break;
 452
 453     case PARSEOP_RETURN:
 454
 455         if (!MethodInfo)
 456         {
 457             /*
 458              * Probably was an error in the method declaration,
 459              * no additional error here
 460              */
 461             ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
 462             return (AE_ERROR);
 463         }
 464
 465         /*
 466          * A child indicates a possible return value. A simple Return or
 467          * Return() is marked with NODE_IS_NULL_RETURN by the parser so
 468          * that it is not counted as a "real" return-with-value, although
 469          * the AML code that is actually emitted is Return(0). The AML
 470          * definition of Return has a required parameter, so we are
 471          * forced to convert a null return to Return(0).
 472          */
 473         if ((Op->Asl.Child) &&
 474             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 475             (!(Op->Asl.Child->Asl.CompileFlags & NODE_IS_NULL_RETURN)))
 476         {
 477             MethodInfo->NumReturnWithValue++;
 478         }
 479         else
 480         {
 481             MethodInfo->NumReturnNoValue++;
 482         }
 483         break;
 484
 485     case PARSEOP_BREAK:
 486     case PARSEOP_CONTINUE:
 487
 488         Next = Op->Asl.Parent;
 489         while (Next)
 490         {
 491             if (Next->Asl.ParseOpcode == PARSEOP_WHILE)
 492             {
 493                 break;
 494             }
 495             Next = Next->Asl.Parent;
 496         }
 497
 498         if (!Next)
 499         {
 500             AslError (ASL_ERROR, ASL_MSG_NO_WHILE, Op, NULL);
 501         }
 502         break;
 503
 504     case PARSEOP_STALL:
 505
 506         /* We can range check if the argument is an integer */
 507
 508         if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
 509             (Op->Asl.Child->Asl.Value.Integer > ACPI_UINT8_MAX))
 510         {
 511             AslError (ASL_ERROR, ASL_MSG_INVALID_TIME, Op, NULL);
 512         }
 513         break;
 514
 515     case PARSEOP_DEVICE:
 516
 517         if (!ApFindNameInDeviceTree (METHOD_NAME__HID, Op) &&
 518             !ApFindNameInDeviceTree (METHOD_NAME__ADR, Op))
 519         {
 520             AslError (ASL_WARNING, ASL_MSG_MISSING_DEPENDENCY, Op,
 521                 "Device object requires a _HID or _ADR in same scope");
 522         }
 523         break;
 524
 525     case PARSEOP_EVENT:
 526     case PARSEOP_MUTEX:
 527     case PARSEOP_OPERATIONREGION:
 528     case PARSEOP_POWERRESOURCE:
 529     case PARSEOP_PROCESSOR:
 530     case PARSEOP_THERMALZONE:
 531
 532         /*
 533          * The first operand is a name to be created in the namespace.
 534          * Check against the reserved list.
 535          */
 536         i = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
 537         if (i < ACPI_VALID_RESERVED_NAME_MAX)
 538         {
 539             AslError (ASL_ERROR, ASL_MSG_RESERVED_USE,
 540                 Op, Op->Asl.ExternalName);
 541         }
 542         break;
 543
 544     case PARSEOP_NAME:
 545
 546         /* Typecheck any predefined names statically defined with Name() */
 547
 548         ApCheckForPredefinedObject (Op, Op->Asl.NameSeg);
 549
 550         /* Special typechecking for _HID */
 551
 552         if (!strcmp (METHOD_NAME__HID, Op->Asl.NameSeg))
 553         {
 554             Next = Op->Asl.Child->Asl.Next;
 555             AnCheckId (Next, ASL_TYPE_HID);
 556         }
 557
 558         /* Special typechecking for _CID */
 559
 560         else if (!strcmp (METHOD_NAME__CID, Op->Asl.NameSeg))
 561         {
 562             Next = Op->Asl.Child->Asl.Next;
 563
 564             if ((Next->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
 565                 (Next->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
 566             {
 567                 Next = Next->Asl.Child;
 568                 while (Next)
 569                 {
 570                     AnCheckId (Next, ASL_TYPE_CID);
 571                     Next = Next->Asl.Next;
 572                 }
 573             }
 574             else
 575             {
 576                 AnCheckId (Next, ASL_TYPE_CID);
 577             }
 578         }
 579
 580         break;
 581
 582     default:
 583
 584         break;
 585     }
 586
 587     /* Check for named object creation within a non-serialized method */
 588
 589     MtCheckNamedObjectInMethod (Op, MethodInfo);
 590     return (AE_OK);
 591 }
 592
 593
 594 /*******************************************************************************
 595  *
 596  * FUNCTION:    MtCheckNamedObjectInMethod
 597  *
 598  * PARAMETERS:  Op                  - Current parser op
 599  *              MethodInfo          - Info for method being parsed
 600  *
 601  * RETURN:      None
 602  *
 603  * DESCRIPTION: Detect if a non-serialized method is creating a named object,
 604  *              which could possibly cause problems if two threads execute
 605  *              the method concurrently. Emit a remark in this case.
 606  *
 607  ******************************************************************************/
 608
 609 static void
 610 MtCheckNamedObjectInMethod (
 611     ACPI_PARSE_OBJECT       *Op,
 612     ASL_METHOD_INFO         *MethodInfo)
 613 {
 614     const ACPI_OPCODE_INFO  *OpInfo;
 615
 616
 617     /* We don't care about actual method declarations or scopes */
 618
 619     if ((Op->Asl.AmlOpcode == AML_METHOD_OP) ||
 620         (Op->Asl.AmlOpcode == AML_SCOPE_OP))
 621     {
 622         return;
 623     }
 624
 625     /* Determine if we are creating a named object */
 626
 627     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 628     if (OpInfo->Class == AML_CLASS_NAMED_OBJECT)
 629     {
 630         /*
 631          * If we have a named object created within a non-serialized method,
 632          * emit a remark that the method should be serialized.
 633          *
 634          * Reason: If a thread blocks within the method for any reason, and
 635          * another thread enters the method, the method will fail because an
 636          * attempt will be made to create the same object twice.
 637          */
 638         if (MethodInfo && !MethodInfo->ShouldBeSerialized)
 639         {
 640             AslError (ASL_REMARK, ASL_MSG_SERIALIZED_REQUIRED, MethodInfo->Op,
 641                 "due to creation of named objects within");
 642
 643             /* Emit message only ONCE per method */
 644
 645             MethodInfo->ShouldBeSerialized = TRUE;
 646         }
 647     }
 648 }
 649
 650
 651 /*******************************************************************************
 652  *
 653  * FUNCTION:    MtMethodAnalysisWalkEnd
 654  *
 655  * PARAMETERS:  ASL_WALK_CALLBACK
 656  *
 657  * RETURN:      Status
 658  *
 659  * DESCRIPTION: Ascending callback for analysis walk. Complete method
 660  *              return analysis.
 661  *
 662  ******************************************************************************/
 663
 664 ACPI_STATUS
 665 MtMethodAnalysisWalkEnd (
 666     ACPI_PARSE_OBJECT       *Op,
 667     UINT32                  Level,
 668     void                    *Context)
 669 {
 670     ASL_ANALYSIS_WALK_INFO  *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
 671     ASL_METHOD_INFO         *MethodInfo = WalkInfo->MethodStack;
 672
 673
 674     switch (Op->Asl.ParseOpcode)
 675     {
 676     case PARSEOP_METHOD:
 677     case PARSEOP_RETURN:
 678
 679         if (!MethodInfo)
 680         {
 681             printf ("No method info for method! [%s]\n", Op->Asl.Namepath);
 682             AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
 683                 "No method info for this method");
 684
 685             CmCleanupAndExit ();
 686             return (AE_AML_INTERNAL);
 687         }
 688         break;
 689
 690     default:
 691
 692         break;
 693     }
 694
 695     switch (Op->Asl.ParseOpcode)
 696     {
 697     case PARSEOP_METHOD:
 698
 699         WalkInfo->MethodStack = MethodInfo->Next;
 700
 701         /*
 702          * Check if there is no return statement at the end of the
 703          * method AND we can actually get there -- i.e., the execution
 704          * of the method can possibly terminate without a return statement.
 705          */
 706         if ((!AnLastStatementIsReturn (Op)) &&
 707             (!(Op->Asl.CompileFlags & NODE_HAS_NO_EXIT)))
 708         {
 709             /*
 710              * No return statement, and execution can possibly exit
 711              * via this path. This is equivalent to Return ()
 712              */
 713             MethodInfo->NumReturnNoValue++;
 714         }
 715
 716         /*
 717          * Check for case where some return statements have a return value
 718          * and some do not. Exit without a return statement is a return with
 719          * no value
 720          */
 721         if (MethodInfo->NumReturnNoValue &&
 722             MethodInfo->NumReturnWithValue)
 723         {
 724             AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Op,
 725                 Op->Asl.ExternalName);
 726         }
 727
 728         /*
 729          * If there are any RETURN() statements with no value, or there is a
 730          * control path that allows the method to exit without a return value,
 731          * we mark the method as a method that does not return a value. This
 732          * knowledge can be used to check method invocations that expect a
 733          * returned value.
 734          */
 735         if (MethodInfo->NumReturnNoValue)
 736         {
 737             if (MethodInfo->NumReturnWithValue)
 738             {
 739                 Op->Asl.CompileFlags |= NODE_METHOD_SOME_NO_RETVAL;
 740             }
 741             else
 742             {
 743                 Op->Asl.CompileFlags |= NODE_METHOD_NO_RETVAL;
 744             }
 745         }
 746
 747         /*
 748          * Check predefined method names for correct return behavior
 749          * and correct number of arguments. Also, some special checks
 750          * For GPE and _REG methods.
 751          */
 752         if (ApCheckForPredefinedMethod (Op, MethodInfo))
 753         {
 754             /* Special check for two names like _L01 and _E01 in same scope */
 755
 756             ApCheckForGpeNameConflict (Op);
 757
 758             /*
 759              * Special check for _REG: Must have an operation region definition
 760              * within the same scope!
 761              */
 762             ApCheckRegMethod (Op);
 763         }
 764
 765         ACPI_FREE (MethodInfo);
 766         break;
 767
 768     case PARSEOP_NAME:
 769
 770          /* Special check for two names like _L01 and _E01 in same scope */
 771
 772         ApCheckForGpeNameConflict (Op);
 773         break;
 774
 775     case PARSEOP_RETURN:
 776
 777         /*
 778          * If the parent is a predefined method name, attempt to typecheck
 779          * the return value. Only static types can be validated.
 780          */
 781         ApCheckPredefinedReturnValue (Op, MethodInfo);
 782
 783         /*
 784          * The parent block does not "exit" and continue execution -- the
 785          * method is terminated here with the Return() statement.
 786          */
 787         Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
 788
 789         /* Used in the "typing" pass later */
 790
 791         Op->Asl.ParentMethod = MethodInfo->Op;
 792
 793         /*
 794          * If there is a peer node after the return statement, then this
 795          * node is unreachable code -- i.e., it won't be executed because of
 796          * the preceding Return() statement.
 797          */
 798         if (Op->Asl.Next)
 799         {
 800             AslError (ASL_WARNING, ASL_MSG_UNREACHABLE_CODE,
 801                 Op->Asl.Next, NULL);
 802         }
 803         break;
 804
 805     case PARSEOP_IF:
 806
 807         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
 808             (Op->Asl.Next) &&
 809             (Op->Asl.Next->Asl.ParseOpcode == PARSEOP_ELSE))
 810         {
 811             /*
 812              * This IF has a corresponding ELSE. The IF block has no exit,
 813              * (it contains an unconditional Return)
 814              * mark the ELSE block to remember this fact.
 815              */
 816             Op->Asl.Next->Asl.CompileFlags |= NODE_IF_HAS_NO_EXIT;
 817         }
 818         break;
 819
 820     case PARSEOP_ELSE:
 821
 822         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
 823             (Op->Asl.CompileFlags & NODE_IF_HAS_NO_EXIT))
 824         {
 825             /*
 826              * This ELSE block has no exit and the corresponding IF block
 827              * has no exit either. Therefore, the parent node has no exit.
 828              */
 829             Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
 830         }
 831         break;
 832
 833
 834     default:
 835
 836         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
 837             (Op->Asl.Parent))
 838         {
 839             /* If this node has no exit, then the parent has no exit either */
 840
 841             Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
 842         }
 843         break;
 844     }
 845
 846     return (AE_OK);
 847 }