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