/****************************************************************************** * * Module Name: aslanalyze.c - check for semantic errors * $Revision: 1.41 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "aslcompiler.h" #include "aslcompiler.y.h" #include "acparser.h" #include "amlcode.h" #include #define _COMPONENT ACPI_COMPILER MODULE_NAME ("aslanalyze") /******************************************************************************* * * FUNCTION: AnMapArgTypeToBtype * * PARAMETERS: ArgType - The ARGI required type(s) for this argument, * from the opcode info table * * RETURN: The corresponding Bit-encoded types * * DESCRIPTION: Convert an encoded ARGI required argument type code into a * bitfield type code. Implements the implicit source conversion * rules. * ******************************************************************************/ UINT32 AnMapArgTypeToBtype ( UINT32 ArgType) { switch (ArgType) { case ARGI_ANYTYPE: return (ACPI_BTYPE_OBJECTS_AND_REFS); case ARGI_TARGETREF: case ARGI_FIXED_TARGET: case ARGI_SIMPLE_TARGET: return (ACPI_BTYPE_OBJECTS_AND_REFS); case ARGI_REFERENCE: return (ACPI_BTYPE_REFERENCE); case ARGI_INTEGER_REF: return (ACPI_BTYPE_INTEGER); case ARGI_OBJECT_REF: return (ACPI_BTYPE_ALL_OBJECTS); case ARGI_DEVICE_REF: return (ACPI_BTYPE_DEVICE_OBJECTS); case ARGI_IF: return (ACPI_BTYPE_ANY); /* * Source conversion rules: * Integer, String, and Buffer are interchangable */ case ARGI_INTEGER: return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER); case ARGI_STRING: return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER); case ARGI_BUFFER: return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER); case ARGI_PACKAGE: return (ACPI_BTYPE_PACKAGE); case ARGI_COMPUTEDATA: return (ACPI_BTYPE_COMPUTE_DATA); case ARGI_DATAOBJECT: /* Buffer, string, package or reference to a Node - Used only by SizeOf operator*/ return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE); case ARGI_COMPLEXOBJ: /* Buffer, String, or package */ return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | ACPI_BTYPE_PACKAGE); case ARGI_MUTEX: return (ACPI_BTYPE_MUTEX); case ARGI_EVENT: return (ACPI_BTYPE_EVENT); case ARGI_REGION: return (ACPI_BTYPE_REGION); case ARGI_DDBHANDLE: return (ACPI_BTYPE_DDB_HANDLE); } return (ACPI_BTYPE_OBJECTS_AND_REFS); } /******************************************************************************* * * FUNCTION: AnMapEtypeToBtype * * PARAMETERS: Etype - Encoded ACPI Type * * RETURN: Btype * * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the * operand conversion rules. In other words, returns the type(s) * this Etype is implicitly converted to during interpretation. * ******************************************************************************/ UINT32 AnMapEtypeToBtype ( UINT32 Etype) { if (Etype == ACPI_TYPE_ANY) { return ACPI_BTYPE_OBJECTS_AND_REFS; } /* Try the standard ACPI data types */ if (Etype <= ACPI_TYPE_MAX) { /* * This switch statement implements the allowed operand conversion * rules as per the "ASL Data Types" section of the ACPI * specification. */ switch (Etype) { case ACPI_TYPE_INTEGER: return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE); case ACPI_TYPE_STRING: case ACPI_TYPE_BUFFER: return (ACPI_BTYPE_COMPUTE_DATA); case ACPI_TYPE_PACKAGE: return (ACPI_BTYPE_PACKAGE); case ACPI_TYPE_FIELD_UNIT: return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT); case ACPI_TYPE_BUFFER_FIELD: return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD); case ACPI_TYPE_DDB_HANDLE: return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE); case ACPI_BTYPE_DEBUG_OBJECT: return (0); /* Cannot be used as a source operand */ default: return (1 << (Etype - 1)); } } /* Try the internal data types */ switch (Etype) { case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: /* Named fields can be either Integer/Buffer/String */ return (ACPI_BTYPE_COMPUTE_DATA); case INTERNAL_TYPE_ALIAS: return (ACPI_BTYPE_INTEGER); case INTERNAL_TYPE_RESOURCE: case INTERNAL_TYPE_RESOURCE_FIELD: return (ACPI_BTYPE_REFERENCE); default: printf ("Unhandled encoded type: %X\n", Etype); return (0); } return 0; } /******************************************************************************* * * FUNCTION: AnMapBtypeToEtype * * PARAMETERS: Btype - Bitfield of ACPI types * * RETURN: none * * DESCRIPTION: Convert a bitfield type to an encoded type * ******************************************************************************/ UINT32 AnMapBtypeToEtype ( UINT32 Btype) { UINT32 i; UINT32 Etype; if (Btype == 0) { return 0; } Etype = 1; for (i = 1; i < Btype; i *= 2) { Etype++; } return (Etype); } /******************************************************************************* * * FUNCTION: AnFormatBtype * * PARAMETERS: Btype - Bitfield of ACPI types * Buffer - Where to put the ascii string * * RETURN: None. * * DESCRIPTION: Convert a Btype to a string of ACPI types * ******************************************************************************/ void AnFormatBtype ( char *Buffer, UINT32 Btype) { UINT32 Type; BOOLEAN First = TRUE; *Buffer = 0; if (Btype == 0) { strcat (Buffer, "NoReturnValue"); return; } for (Type = 1; Type < ACPI_TYPE_MAX; Type++) { if (Btype & 0x00000001) { if (!First) { strcat (Buffer, "|"); } First = FALSE; strcat (Buffer, AcpiUtGetTypeName (Type)); } Btype >>= 1; } if (Btype & 0x00000001) { if (!First) { strcat (Buffer, "|"); } First = FALSE; strcat (Buffer, "Reference"); } Btype >>= 1; if (Btype & 0x00000001) { if (!First) { strcat (Buffer, "|"); } First = FALSE; strcat (Buffer, "Resource"); } } /******************************************************************************* * * FUNCTION: AnGetBtype * * PARAMETERS: * * RETURN: None. * * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node. * Handles the case where the node is a name or method call and * the actual type must be obtained from the namespace node. * ******************************************************************************/ UINT32 AnGetBtype ( ASL_PARSE_NODE *PsNode) { ACPI_NAMESPACE_NODE *NsNode; ASL_PARSE_NODE *ReferencedNode; UINT32 ThisNodeBtype = 0; if ((PsNode->ParseOpcode == NAMESEG) || (PsNode->ParseOpcode == NAMESTRING) || (PsNode->ParseOpcode == METHODCALL)) { NsNode = PsNode->NsNode; if (!NsNode) { DbgPrint (ASL_DEBUG_OUTPUT, "Null attached Nsnode: [%s] at line %d\n", PsNode->ParseOpName, PsNode->LineNumber); return ACPI_UINT32_MAX; } ThisNodeBtype = AnMapEtypeToBtype (NsNode->Type); /* * Since it was a named reference, enable the * reference bit also */ ThisNodeBtype |= ACPI_BTYPE_REFERENCE; if (PsNode->ParseOpcode == METHODCALL) { ReferencedNode = NsNode->Object; if (!ReferencedNode) { printf ("No back ptr to PsNode: type %X\n", NsNode->Type); return ACPI_UINT32_MAX; } if (ReferencedNode->Flags & NODE_METHOD_TYPED) { ThisNodeBtype = ReferencedNode->AcpiBtype; } else { return (ACPI_UINT32_MAX -1); } } } else { ThisNodeBtype = PsNode->AcpiBtype; } return (ThisNodeBtype); } /******************************************************************************* * * FUNCTION: AnCheckForReservedMethod * * PARAMETERS: Node - A parse node of type "METHOD". * MethodInfo - Saved info about this method * * RETURN: None * * DESCRIPTION: If method is a reserved name, check that the number of arguments * and the return type (returns a value or not) is correct. * ******************************************************************************/ void AnCheckForReservedMethod ( ASL_PARSE_NODE *Node, ASL_METHOD_INFO *MethodInfo) { UINT32 i; /* All reserved names are prefixed with a single underscore */ if (Node->ExternalName[0] != '_') { return; } /* Check for a standard reserved method name */ for (i = 0; ReservedMethods[i].Name; i++) { if (!STRCMP (Node->ExternalName, ReservedMethods[i].Name)) { Gbl_ReservedMethods++; /* Matched a reserved method name */ if (MethodInfo->NumArguments != ReservedMethods[i].NumArguments) { sprintf (MsgBuffer, " %s requires %d", ReservedMethods[i].Name, ReservedMethods[i].NumArguments); if (MethodInfo->NumArguments > ReservedMethods[i].NumArguments) { AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Node, MsgBuffer); } else { AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Node, MsgBuffer); } } if (MethodInfo->NumReturnNoValue && ReservedMethods[i].Flags & ASL_RSVD_RETURN_VALUE) { sprintf (MsgBuffer, "%s", ReservedMethods[i].Name); AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Node, MsgBuffer); } return; } } /* * Now check for the "special" reserved names -- * GPE: _Lxx * GPE: _Exx * EC: _Qxx */ if ((Node->ExternalName[1] == 'L') || (Node->ExternalName[1] == 'E') || (Node->ExternalName[1] == 'Q')) { Gbl_ReservedMethods++; /* The next two characters must be hex digits */ if ((isxdigit (Node->ExternalName[2])) && (isxdigit (Node->ExternalName[3])) && (MethodInfo->NumArguments != 0)) { sprintf (MsgBuffer, " %s requires %d", Node->ExternalName, 0); AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Node, MsgBuffer); } return; } /* Check for the names reserved for the compiler itself: _T_x */ if ((Node->ExternalName[1] == 'T') && (Node->ExternalName[2] == '_')) { AslError (ASL_ERROR, ASL_MSG_RESERVED_WORD, Node, Node->ExternalName); return; } /* * The name didn't match any of the known reserved names. Flag it as a * warning, since the entire namespace starting with an underscore is * reserved by the ACPI spec. */ AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Node, Node->ExternalName); return; } /******************************************************************************* * * FUNCTION: AnMethodAnalysisWalkBegin * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: none * * DESCRIPTION: Descending callback for the analysis walk. Check methods for : * 1) Initialized local variables * 2) Valid arguments * 3) Return types * ******************************************************************************/ ACPI_STATUS AnMethodAnalysisWalkBegin ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { ASL_ANALYSIS_WALK_INFO *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context; ASL_METHOD_INFO *MethodInfo = WalkInfo->MethodStack; ASL_PARSE_NODE *Next; UINT32 RegisterNumber; UINT32 i; char LocalName[] = "Local0"; char ArgName[] = "Arg0"; PROC_NAME ("AnMethodAnalysisWalkBegin"); switch (Node->ParseOpcode) { case METHOD: TotalMethods++; /* * Create and init method info */ MethodInfo = UtLocalCalloc (sizeof (ASL_METHOD_INFO)); MethodInfo->Next = WalkInfo->MethodStack; MethodInfo->Node = Node; WalkInfo->MethodStack = MethodInfo; /* Get the NumArguments node */ Next = Node->Child; Next = Next->Peer; MethodInfo->NumArguments = (UINT8) (Next->Value.Integer8 & 0x07); /* * Actual arguments are initialized at method entry. * All other ArgX "registers" can be used as locals, so we * track their initialization. */ for (i = 0; i < MethodInfo->NumArguments; i++) { MethodInfo->ArgInitialized[i] = TRUE; } break; case METHODCALL: if (MethodInfo && (Node->NsNode == MethodInfo->Node->NsNode)) { AslError (ASL_REMARK, ASL_MSG_RECURSION, Node, Node->ExternalName); } break; case LOCAL0: case LOCAL1: case LOCAL2: case LOCAL3: case LOCAL4: case LOCAL5: case LOCAL6: case LOCAL7: if (!MethodInfo) { /* Probably was an error in the method declaration, no additional error here */ ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%X, No parent method\n", Node)); return (AE_ERROR); } RegisterNumber = (Node->AmlOpcode & 0x000F); /* * If the local is being used as a target, mark the local * initialized */ if (Node->Flags & NODE_IS_TARGET) { MethodInfo->LocalInitialized[RegisterNumber] = TRUE; } /* * Otherwise, this is a reference, check if the local * has been previously initialized. */ else if (!MethodInfo->LocalInitialized[RegisterNumber]) { LocalName[strlen (LocalName) -1] = (UINT8) (RegisterNumber + 0x30); AslError (ASL_ERROR, ASL_MSG_LOCAL_INIT, Node, LocalName); } break; case ARG0: case ARG1: case ARG2: case ARG3: case ARG4: case ARG5: case ARG6: if (!MethodInfo) { /* Probably was an error in the method declaration, no additional error here */ ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%X, No parent method\n", Node)); return (AE_ERROR); } RegisterNumber = (Node->AmlOpcode & 0x000F) - 8; ArgName[strlen (ArgName) -1] = (UINT8) (RegisterNumber + 0x30); /* * If the Arg is being used as a target, mark the local * initialized */ if (Node->Flags & NODE_IS_TARGET) { MethodInfo->ArgInitialized[RegisterNumber] = TRUE; } /* * Otherwise, this is a reference, check if the Arg * has been previously initialized. */ else if (!MethodInfo->ArgInitialized[RegisterNumber]) { AslError (ASL_ERROR, ASL_MSG_ARG_INIT, Node, ArgName); } /* Flag this arg if it is not a "real" argument to the method */ if (RegisterNumber >= MethodInfo->NumArguments) { AslError (ASL_REMARK, ASL_MSG_NOT_PARAMETER, Node, ArgName); } break; case RETURN: if (!MethodInfo) { /* Probably was an error in the method declaration, no additional error here */ ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%X, No parent method\n", Node)); return (AE_ERROR); } /* Child indicates a return value */ if ((Node->Child) && (Node->Child->ParseOpcode != DEFAULT_ARG)) { MethodInfo->NumReturnWithValue++; } else { MethodInfo->NumReturnNoValue++; } break; } return AE_OK; } /******************************************************************************* * * FUNCTION: AnLastStatementIsReturn * * PARAMETERS: Node - A method node * * RETURN: TRUE if last statement is an ASL RETURN. False otherwise * * DESCRIPTION: Walk down the list of top level statements within a method * to find the last one. Check if that last statement is in * fact a RETURN statement. * ******************************************************************************/ BOOLEAN AnLastStatementIsReturn ( ASL_PARSE_NODE *Node) { ASL_PARSE_NODE *Next; /* * Check if last statement is a return */ Next = ASL_GET_CHILD_NODE (Node); while (Next) { if ((!Next->Peer) && (Next->ParseOpcode == RETURN)) { return TRUE; } Next = ASL_GET_PEER_NODE (Next); } return FALSE; } /******************************************************************************* * * FUNCTION: AnMethodAnalysisWalkEnd * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: None. * * DESCRIPTION: Ascending callback for analysis walk. Complete method * return analysis. * ******************************************************************************/ ACPI_STATUS AnMethodAnalysisWalkEnd ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { ASL_ANALYSIS_WALK_INFO *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context; ASL_METHOD_INFO *MethodInfo = WalkInfo->MethodStack; switch (Node->ParseOpcode) { case METHOD: case RETURN: if (!MethodInfo) { printf ("No method info for method! [%s]\n", Node->Namepath); AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Node, "No method info for this method"); CmCleanupAndExit (); } break; } switch (Node->ParseOpcode) { case METHOD: WalkInfo->MethodStack = MethodInfo->Next; /* * Check if there is no return statement at the end of the * method AND we can actually get there -- i.e., the execution * of the method can possibly terminate without a return statement. */ if ((!AnLastStatementIsReturn (Node)) && (!(Node->Flags & NODE_HAS_NO_EXIT))) { /* * No return statement, and execution can possibly exit * via this path. This is equivalent to Return () */ MethodInfo->NumReturnNoValue++; } /* * Check for case where some return statements have a return value * and some do not. Exit without a return statement is a return with * no value */ if (MethodInfo->NumReturnNoValue && MethodInfo->NumReturnWithValue) { AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Node, Node->ExternalName); } /* * If there are any RETURN() statements with no value, or there is a * control path that allows the method to exit without a return value, * we mark the method as a method that does not return a value. This * knowledge can be used to check method invocations that expect a * returned value. */ if (MethodInfo->NumReturnNoValue) { if (MethodInfo->NumReturnWithValue) { Node->Flags |= NODE_METHOD_SOME_NO_RETVAL; } else { Node->Flags |= NODE_METHOD_NO_RETVAL; } } /* * Check predefined method names for correct return behavior * and correct number of arguments */ AnCheckForReservedMethod (Node, MethodInfo); ACPI_MEM_FREE (MethodInfo); break; case RETURN: Node->Parent->Flags |= NODE_HAS_NO_EXIT; Node->ParentMethod = MethodInfo->Node; /* Used in the "typing" pass later */ break; case IF: if ((Node->Flags & NODE_HAS_NO_EXIT) && (Node->Peer) && (Node->Peer->ParseOpcode == ELSE)) { Node->Peer->Flags |= NODE_IF_HAS_NO_EXIT; } break; case ELSE: if ((Node->Flags & NODE_HAS_NO_EXIT) && (Node->Flags & NODE_IF_HAS_NO_EXIT)) { Node->Parent->Flags |= NODE_HAS_NO_EXIT; } break; default: if ((Node->Flags & NODE_HAS_NO_EXIT) && (Node->Parent)) { Node->Parent->Flags |= NODE_HAS_NO_EXIT; } break; } return AE_OK; } /******************************************************************************* * * FUNCTION: AnMethodTypingWalkBegin * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: none * * DESCRIPTION: Descending callback for the typing walk. * ******************************************************************************/ ACPI_STATUS AnMethodTypingWalkBegin ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { return AE_OK; } /******************************************************************************* * * FUNCTION: AnMethodTypingWalkEnd * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: None. * * DESCRIPTION: Ascending callback for typing walk. Complete method * return analysis. Check methods for : * 1) Initialized local variables * 2) Valid arguments * 3) Return types * ******************************************************************************/ ACPI_STATUS AnMethodTypingWalkEnd ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { UINT32 ThisNodeBtype; switch (Node->ParseOpcode) { case METHOD: Node->Flags |= NODE_METHOD_TYPED; break; case RETURN: if ((Node->Child) && (Node->Child->ParseOpcode != DEFAULT_ARG)) { ThisNodeBtype = AnGetBtype (Node->Child); if ((Node->Child->ParseOpcode == METHODCALL) && (ThisNodeBtype == (ACPI_UINT32_MAX -1))) { /* * The method is untyped at this time (typically a forward reference). * We must recursively type the method here */ TrWalkParseTree (Node->Child->NsNode->Object, ASL_WALK_VISIT_TWICE, AnMethodTypingWalkBegin, AnMethodTypingWalkEnd, NULL); ThisNodeBtype = AnGetBtype (Node->Child); } /* Returns a value, get it's type */ Node->ParentMethod->AcpiBtype |= ThisNodeBtype; } break; } return AE_OK; } /******************************************************************************* * * FUNCTION: AnSemanticAnalysisWalkBegin * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: none * * DESCRIPTION: Descending callback for the analysis walk. Check methods for : * 1) Initialized local variables * 2) Valid arguments * 3) Return types * ******************************************************************************/ ACPI_STATUS AnSemanticAnalysisWalkBegin ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { return AE_OK; } /******************************************************************************* * * FUNCTION: AnSemanticAnalysisWalkEnd * * PARAMETERS: ASL_WALK_CALLBACK * * RETURN: None. * * DESCRIPTION: Ascending callback for analysis walk. Complete method * return analysis. * ******************************************************************************/ ACPI_STATUS AnSemanticAnalysisWalkEnd ( ASL_PARSE_NODE *Node, UINT32 Level, void *Context) { ACPI_OPCODE_INFO *OpInfo; UINT32 ParseArgTypes; UINT32 RuntimeArgTypes; UINT32 RuntimeArgTypes2; UINT32 RequiredBtypes; ASL_PARSE_NODE *ArgNode; UINT32 ArgType; UINT32 ThisNodeBtype; UINT32 AcpiEtype; UINT32 OpcodeClass; UINT32 i; UINT32 CommonBtypes; switch (Node->AmlOpcode) { case AML_RAW_DATA_BYTE: case AML_RAW_DATA_WORD: case AML_RAW_DATA_DWORD: case AML_RAW_DATA_QWORD: case AML_RAW_DATA_BUFFER: case AML_RAW_DATA_CHAIN: case AML_PACKAGE_LENGTH: case AML_UNASSIGNED_OPCODE: case AML_DEFAULT_ARG_OP: return (AE_OK); } OpInfo = AcpiPsGetOpcodeInfo (Node->AmlOpcode); if (!OpInfo) { return (AE_OK); } ArgNode = Node->Child; RuntimeArgTypes = OpInfo->RuntimeArgs; ParseArgTypes = OpInfo->ParseArgs; OpcodeClass = ACPI_GET_OP_CLASS (OpInfo); /* Ignore the non-executable opcodes */ if (RuntimeArgTypes == ARGI_INVALID_OPCODE) { return (AE_OK); } switch (OpcodeClass) { case OPTYPE_MONADIC2: case OPTYPE_MONADIC2R: case OPTYPE_DYADIC2: case OPTYPE_DYADIC2R: case OPTYPE_DYADIC2S: case OPTYPE_TRIADIC: case OPTYPE_QUADRADIC: case OPTYPE_HEXADIC: case OPTYPE_CREATE_FIELD: case OPTYPE_RECONFIGURATION: case OPTYPE_CONTROL: case OPTYPE_RETURN: RuntimeArgTypes2 = 0; while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes))) { RuntimeArgTypes2 <<= ARG_TYPE_WIDTH; RuntimeArgTypes2 |= ArgType; INCREMENT_ARG_LIST (RuntimeArgTypes); } i = 1; while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes2))) { RequiredBtypes = AnMapArgTypeToBtype (ArgType); ThisNodeBtype = AnGetBtype (ArgNode); if (ThisNodeBtype == ACPI_UINT32_MAX) { goto NextArgument; } /* Examine the arg based on the required type of the arg */ switch (ArgType) { case ARGI_TARGETREF: if (ArgNode->ParseOpcode == ZERO) { /* ZERO is the placeholder for "don't store result" */ ThisNodeBtype = RequiredBtypes; break; } if (ArgNode->ParseOpcode == INTEGER) { /* * This is the case where an original reference to a resource * descriptor field has been replaced by an (Integer) offset. * These named fields are supported at compile-time only; * the names are not passed to the interpreter (via the AML). */ if ((ArgNode->NsNode->Type == INTERNAL_TYPE_RESOURCE_FIELD) || (ArgNode->NsNode->Type == INTERNAL_TYPE_RESOURCE)) { AslError (ASL_ERROR, ASL_MSG_RESOURCE_FIELD, ArgNode, NULL); } else { AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgNode, NULL); } break; } if ((ArgNode->ParseOpcode == METHODCALL) || (ArgNode->ParseOpcode == DEREFOF)) { break; } ThisNodeBtype = RequiredBtypes; break; case ARGI_REFERENCE: /* References */ case ARGI_INTEGER_REF: case ARGI_OBJECT_REF: case ARGI_DEVICE_REF: switch (ArgNode->ParseOpcode) { case LOCAL0: case LOCAL1: case LOCAL2: case LOCAL3: case LOCAL4: case LOCAL5: case LOCAL6: case LOCAL7: /* TBD: implement analysis of current value (type) of the local */ /* For now, just treat any local as a typematch */ //ThisNodeBtype = RequiredBtypes; break; case ARG0: case ARG1: case ARG2: case ARG3: case ARG4: case ARG5: case ARG6: /* Hard to analyze argument types, sow we won't */ /* For now, just treat any arg as a typematch */ //ThisNodeBtype = RequiredBtypes; break; case DEBUG: break; case REFOF: case INDEX: break; } break; case ARGI_INTEGER: break; } CommonBtypes = ThisNodeBtype & RequiredBtypes; if (ArgNode->ParseOpcode == METHODCALL) { if (!CommonBtypes) { AnFormatBtype (StringBuffer, ThisNodeBtype); AnFormatBtype (StringBuffer2, RequiredBtypes); /* * The case where the method does not return any value at all * was already handled in the namespace cross reference * -- Only issue an error if the method in fact returns a value, * but it is of the wrong type */ if (ThisNodeBtype != 0) { sprintf (MsgBuffer, "Method returns [%s], %s operator requires [%s]", StringBuffer, OpInfo->Name, StringBuffer2); AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgNode, MsgBuffer); } } } /* * Now check if the actual type(s) match at least one * bit to the required type */ else if (!CommonBtypes) { /* TBD: Can an implicit conversion be performed? */ AcpiEtype = AnMapBtypeToEtype (ThisNodeBtype); AnFormatBtype (StringBuffer, ThisNodeBtype); AnFormatBtype (StringBuffer2, RequiredBtypes); sprintf (MsgBuffer, "[%s] found, %s operator requires [%s]", StringBuffer, OpInfo->Name, StringBuffer2); AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgNode, MsgBuffer); } NextArgument: ArgNode = ArgNode->Peer; INCREMENT_ARG_LIST (RuntimeArgTypes2); i++; } } return (AE_OK); }