Home | History | Annotate | Line # | Download | only in compiler
aslwalks.c revision 1.3.2.1
      1      1.1    jruoho /******************************************************************************
      2      1.1    jruoho  *
      3      1.2  christos  * Module Name: aslwalks.c - Miscellaneous analytical parse tree walks
      4      1.1    jruoho  *
      5      1.1    jruoho  *****************************************************************************/
      6      1.1    jruoho 
      7      1.1    jruoho /*
      8  1.3.2.1     skrll  * Copyright (C) 2000 - 2015, Intel Corp.
      9      1.1    jruoho  * All rights reserved.
     10      1.1    jruoho  *
     11      1.1    jruoho  * Redistribution and use in source and binary forms, with or without
     12      1.1    jruoho  * modification, are permitted provided that the following conditions
     13      1.1    jruoho  * are met:
     14      1.1    jruoho  * 1. Redistributions of source code must retain the above copyright
     15      1.1    jruoho  *    notice, this list of conditions, and the following disclaimer,
     16      1.1    jruoho  *    without modification.
     17      1.1    jruoho  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     18      1.1    jruoho  *    substantially similar to the "NO WARRANTY" disclaimer below
     19      1.1    jruoho  *    ("Disclaimer") and any redistribution must be conditioned upon
     20      1.1    jruoho  *    including a substantially similar Disclaimer requirement for further
     21      1.1    jruoho  *    binary redistribution.
     22      1.1    jruoho  * 3. Neither the names of the above-listed copyright holders nor the names
     23      1.1    jruoho  *    of any contributors may be used to endorse or promote products derived
     24      1.1    jruoho  *    from this software without specific prior written permission.
     25      1.1    jruoho  *
     26      1.1    jruoho  * Alternatively, this software may be distributed under the terms of the
     27      1.1    jruoho  * GNU General Public License ("GPL") version 2 as published by the Free
     28      1.1    jruoho  * Software Foundation.
     29      1.1    jruoho  *
     30      1.1    jruoho  * NO WARRANTY
     31      1.1    jruoho  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     32      1.1    jruoho  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     33      1.1    jruoho  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     34      1.1    jruoho  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     35      1.1    jruoho  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     36      1.1    jruoho  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     37      1.1    jruoho  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     38      1.1    jruoho  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     39      1.1    jruoho  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     40      1.1    jruoho  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     41      1.1    jruoho  * POSSIBILITY OF SUCH DAMAGES.
     42      1.1    jruoho  */
     43      1.1    jruoho 
     44      1.1    jruoho #include "aslcompiler.h"
     45      1.1    jruoho #include "aslcompiler.y.h"
     46      1.1    jruoho #include "acparser.h"
     47      1.1    jruoho #include "amlcode.h"
     48      1.1    jruoho 
     49      1.1    jruoho 
     50      1.1    jruoho #define _COMPONENT          ACPI_COMPILER
     51      1.1    jruoho         ACPI_MODULE_NAME    ("aslwalks")
     52      1.1    jruoho 
     53      1.1    jruoho 
     54      1.1    jruoho /*******************************************************************************
     55      1.1    jruoho  *
     56      1.1    jruoho  * FUNCTION:    AnMethodTypingWalkEnd
     57      1.1    jruoho  *
     58      1.1    jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
     59      1.1    jruoho  *
     60      1.1    jruoho  * RETURN:      Status
     61      1.1    jruoho  *
     62      1.1    jruoho  * DESCRIPTION: Ascending callback for typing walk. Complete the method
     63      1.1    jruoho  *              return analysis. Check methods for:
     64      1.1    jruoho  *              1) Initialized local variables
     65      1.1    jruoho  *              2) Valid arguments
     66      1.1    jruoho  *              3) Return types
     67      1.1    jruoho  *
     68      1.1    jruoho  ******************************************************************************/
     69      1.1    jruoho 
     70      1.1    jruoho ACPI_STATUS
     71      1.1    jruoho AnMethodTypingWalkEnd (
     72      1.1    jruoho     ACPI_PARSE_OBJECT       *Op,
     73      1.1    jruoho     UINT32                  Level,
     74      1.1    jruoho     void                    *Context)
     75      1.1    jruoho {
     76      1.1    jruoho     UINT32                  ThisNodeBtype;
     77      1.1    jruoho 
     78      1.1    jruoho 
     79      1.1    jruoho     switch (Op->Asl.ParseOpcode)
     80      1.1    jruoho     {
     81      1.1    jruoho     case PARSEOP_METHOD:
     82      1.1    jruoho 
     83      1.1    jruoho         Op->Asl.CompileFlags |= NODE_METHOD_TYPED;
     84      1.1    jruoho         break;
     85      1.1    jruoho 
     86      1.1    jruoho     case PARSEOP_RETURN:
     87      1.1    jruoho 
     88      1.1    jruoho         if ((Op->Asl.Child) &&
     89      1.1    jruoho             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
     90      1.1    jruoho         {
     91      1.1    jruoho             ThisNodeBtype = AnGetBtype (Op->Asl.Child);
     92      1.1    jruoho 
     93      1.1    jruoho             if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_METHODCALL) &&
     94      1.1    jruoho                 (ThisNodeBtype == (ACPI_UINT32_MAX -1)))
     95      1.1    jruoho             {
     96      1.1    jruoho                 /*
     97      1.1    jruoho                  * The called method is untyped at this time (typically a
     98      1.1    jruoho                  * forward reference).
     99      1.1    jruoho                  *
    100      1.1    jruoho                  * Check for a recursive method call first.
    101      1.1    jruoho                  */
    102      1.1    jruoho                 if (Op->Asl.ParentMethod != Op->Asl.Child->Asl.Node->Op)
    103      1.1    jruoho                 {
    104      1.1    jruoho                     /* We must type the method here */
    105      1.1    jruoho 
    106      1.1    jruoho                     TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
    107      1.1    jruoho                         ASL_WALK_VISIT_UPWARD, NULL,
    108      1.1    jruoho                         AnMethodTypingWalkEnd, NULL);
    109      1.1    jruoho 
    110      1.1    jruoho                     ThisNodeBtype = AnGetBtype (Op->Asl.Child);
    111      1.1    jruoho                 }
    112      1.1    jruoho             }
    113      1.1    jruoho 
    114      1.1    jruoho             /* Returns a value, save the value type */
    115      1.1    jruoho 
    116      1.1    jruoho             if (Op->Asl.ParentMethod)
    117      1.1    jruoho             {
    118      1.1    jruoho                 Op->Asl.ParentMethod->Asl.AcpiBtype |= ThisNodeBtype;
    119      1.1    jruoho             }
    120      1.1    jruoho         }
    121      1.1    jruoho         break;
    122      1.1    jruoho 
    123      1.1    jruoho     default:
    124      1.2  christos 
    125      1.1    jruoho         break;
    126      1.1    jruoho     }
    127      1.1    jruoho 
    128      1.1    jruoho     return (AE_OK);
    129      1.1    jruoho }
    130      1.1    jruoho 
    131      1.1    jruoho 
    132      1.1    jruoho /*******************************************************************************
    133      1.1    jruoho  *
    134      1.1    jruoho  * FUNCTION:    AnOperandTypecheckWalkEnd
    135      1.1    jruoho  *
    136      1.1    jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
    137      1.1    jruoho  *
    138      1.1    jruoho  * RETURN:      Status
    139      1.1    jruoho  *
    140      1.1    jruoho  * DESCRIPTION: Ascending callback for analysis walk. Complete method
    141      1.1    jruoho  *              return analysis.
    142      1.1    jruoho  *
    143      1.1    jruoho  ******************************************************************************/
    144      1.1    jruoho 
    145      1.1    jruoho ACPI_STATUS
    146      1.1    jruoho AnOperandTypecheckWalkEnd (
    147      1.1    jruoho     ACPI_PARSE_OBJECT       *Op,
    148      1.1    jruoho     UINT32                  Level,
    149      1.1    jruoho     void                    *Context)
    150      1.1    jruoho {
    151      1.1    jruoho     const ACPI_OPCODE_INFO  *OpInfo;
    152      1.1    jruoho     UINT32                  RuntimeArgTypes;
    153      1.1    jruoho     UINT32                  RuntimeArgTypes2;
    154      1.1    jruoho     UINT32                  RequiredBtypes;
    155      1.1    jruoho     UINT32                  ThisNodeBtype;
    156      1.1    jruoho     UINT32                  CommonBtypes;
    157      1.1    jruoho     UINT32                  OpcodeClass;
    158      1.1    jruoho     ACPI_PARSE_OBJECT       *ArgOp;
    159      1.1    jruoho     UINT32                  ArgType;
    160      1.1    jruoho 
    161      1.1    jruoho 
    162      1.1    jruoho     switch (Op->Asl.AmlOpcode)
    163      1.1    jruoho     {
    164      1.1    jruoho     case AML_RAW_DATA_BYTE:
    165      1.1    jruoho     case AML_RAW_DATA_WORD:
    166      1.1    jruoho     case AML_RAW_DATA_DWORD:
    167      1.1    jruoho     case AML_RAW_DATA_QWORD:
    168      1.1    jruoho     case AML_RAW_DATA_BUFFER:
    169      1.1    jruoho     case AML_RAW_DATA_CHAIN:
    170      1.1    jruoho     case AML_PACKAGE_LENGTH:
    171      1.1    jruoho     case AML_UNASSIGNED_OPCODE:
    172      1.1    jruoho     case AML_DEFAULT_ARG_OP:
    173      1.1    jruoho 
    174      1.1    jruoho         /* Ignore the internal (compiler-only) AML opcodes */
    175      1.1    jruoho 
    176      1.1    jruoho         return (AE_OK);
    177      1.1    jruoho 
    178      1.1    jruoho     default:
    179      1.2  christos 
    180      1.1    jruoho         break;
    181      1.1    jruoho     }
    182      1.1    jruoho 
    183      1.1    jruoho     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
    184      1.1    jruoho     if (!OpInfo)
    185      1.1    jruoho     {
    186      1.1    jruoho         return (AE_OK);
    187      1.1    jruoho     }
    188      1.1    jruoho 
    189      1.1    jruoho     ArgOp           = Op->Asl.Child;
    190      1.1    jruoho     RuntimeArgTypes = OpInfo->RuntimeArgs;
    191      1.1    jruoho     OpcodeClass     = OpInfo->Class;
    192      1.1    jruoho 
    193      1.1    jruoho #ifdef ASL_ERROR_NAMED_OBJECT_IN_WHILE
    194      1.1    jruoho     /*
    195      1.1    jruoho      * Update 11/2008: In practice, we can't perform this check. A simple
    196      1.1    jruoho      * analysis is not sufficient. Also, it can cause errors when compiling
    197      1.1    jruoho      * disassembled code because of the way Switch operators are implemented
    198      1.1    jruoho      * (a While(One) loop with a named temp variable created within.)
    199      1.1    jruoho      */
    200      1.1    jruoho 
    201      1.1    jruoho     /*
    202      1.1    jruoho      * If we are creating a named object, check if we are within a while loop
    203      1.1    jruoho      * by checking if the parent is a WHILE op. This is a simple analysis, but
    204      1.1    jruoho      * probably sufficient for many cases.
    205      1.1    jruoho      *
    206      1.1    jruoho      * Allow Scope(), Buffer(), and Package().
    207      1.1    jruoho      */
    208      1.1    jruoho     if (((OpcodeClass == AML_CLASS_NAMED_OBJECT) && (Op->Asl.AmlOpcode != AML_SCOPE_OP)) ||
    209      1.1    jruoho         ((OpcodeClass == AML_CLASS_CREATE) && (OpInfo->Flags & AML_NSNODE)))
    210      1.1    jruoho     {
    211      1.1    jruoho         if (Op->Asl.Parent->Asl.AmlOpcode == AML_WHILE_OP)
    212      1.1    jruoho         {
    213      1.1    jruoho             AslError (ASL_ERROR, ASL_MSG_NAMED_OBJECT_IN_WHILE, Op, NULL);
    214      1.1    jruoho         }
    215      1.1    jruoho     }
    216      1.1    jruoho #endif
    217      1.1    jruoho 
    218      1.1    jruoho     /*
    219      1.1    jruoho      * Special case for control opcodes IF/RETURN/WHILE since they
    220      1.1    jruoho      * have no runtime arg list (at this time)
    221      1.1    jruoho      */
    222      1.1    jruoho     switch (Op->Asl.AmlOpcode)
    223      1.1    jruoho     {
    224      1.1    jruoho     case AML_IF_OP:
    225      1.1    jruoho     case AML_WHILE_OP:
    226      1.1    jruoho     case AML_RETURN_OP:
    227      1.1    jruoho 
    228      1.1    jruoho         if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
    229      1.1    jruoho         {
    230      1.1    jruoho             /* Check for an internal method */
    231      1.1    jruoho 
    232      1.1    jruoho             if (AnIsInternalMethod (ArgOp))
    233      1.1    jruoho             {
    234      1.1    jruoho                 return (AE_OK);
    235      1.1    jruoho             }
    236      1.1    jruoho 
    237      1.1    jruoho             /* The lone arg is a method call, check it */
    238      1.1    jruoho 
    239      1.1    jruoho             RequiredBtypes = AnMapArgTypeToBtype (ARGI_INTEGER);
    240      1.1    jruoho             if (Op->Asl.AmlOpcode == AML_RETURN_OP)
    241      1.1    jruoho             {
    242      1.1    jruoho                 RequiredBtypes = 0xFFFFFFFF;
    243      1.1    jruoho             }
    244      1.1    jruoho 
    245      1.1    jruoho             ThisNodeBtype = AnGetBtype (ArgOp);
    246      1.1    jruoho             if (ThisNodeBtype == ACPI_UINT32_MAX)
    247      1.1    jruoho             {
    248      1.1    jruoho                 return (AE_OK);
    249      1.1    jruoho             }
    250      1.1    jruoho             AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
    251      1.1    jruoho                 RequiredBtypes, ThisNodeBtype);
    252      1.1    jruoho         }
    253      1.1    jruoho         return (AE_OK);
    254      1.1    jruoho 
    255  1.3.2.1     skrll     case AML_EXTERNAL_OP:
    256  1.3.2.1     skrll         /*
    257  1.3.2.1     skrll          * Not really a "runtime" opcode since it used by disassembler only.
    258  1.3.2.1     skrll          * The parser will find any issues with the operands.
    259  1.3.2.1     skrll          */
    260  1.3.2.1     skrll         return (AE_OK);
    261  1.3.2.1     skrll 
    262      1.1    jruoho     default:
    263      1.2  christos 
    264      1.1    jruoho         break;
    265      1.1    jruoho     }
    266      1.1    jruoho 
    267      1.1    jruoho     /* Ignore the non-executable opcodes */
    268      1.1    jruoho 
    269      1.1    jruoho     if (RuntimeArgTypes == ARGI_INVALID_OPCODE)
    270      1.1    jruoho     {
    271      1.1    jruoho         return (AE_OK);
    272      1.1    jruoho     }
    273      1.1    jruoho 
    274      1.1    jruoho     switch (OpcodeClass)
    275      1.1    jruoho     {
    276      1.1    jruoho     case AML_CLASS_EXECUTE:
    277      1.1    jruoho     case AML_CLASS_CREATE:
    278      1.1    jruoho     case AML_CLASS_CONTROL:
    279      1.1    jruoho     case AML_CLASS_RETURN_VALUE:
    280      1.1    jruoho 
    281      1.1    jruoho         /* TBD: Change class or fix typechecking for these */
    282      1.1    jruoho 
    283      1.1    jruoho         if ((Op->Asl.AmlOpcode == AML_BUFFER_OP)        ||
    284      1.1    jruoho             (Op->Asl.AmlOpcode == AML_PACKAGE_OP)       ||
    285      1.1    jruoho             (Op->Asl.AmlOpcode == AML_VAR_PACKAGE_OP))
    286      1.1    jruoho         {
    287      1.1    jruoho             break;
    288      1.1    jruoho         }
    289      1.1    jruoho 
    290      1.1    jruoho         /* Reverse the runtime argument list */
    291      1.1    jruoho 
    292      1.1    jruoho         RuntimeArgTypes2 = 0;
    293      1.1    jruoho         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes)))
    294      1.1    jruoho         {
    295      1.1    jruoho             RuntimeArgTypes2 <<= ARG_TYPE_WIDTH;
    296      1.1    jruoho             RuntimeArgTypes2 |= ArgType;
    297      1.1    jruoho             INCREMENT_ARG_LIST (RuntimeArgTypes);
    298      1.1    jruoho         }
    299      1.1    jruoho 
    300      1.1    jruoho         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes2)))
    301      1.1    jruoho         {
    302      1.1    jruoho             RequiredBtypes = AnMapArgTypeToBtype (ArgType);
    303      1.1    jruoho 
    304  1.3.2.1     skrll             if (!ArgOp)
    305  1.3.2.1     skrll             {
    306  1.3.2.1     skrll                 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
    307  1.3.2.1     skrll                     "Null ArgOp in argument loop");
    308  1.3.2.1     skrll                 AslAbort ();
    309  1.3.2.1     skrll             }
    310  1.3.2.1     skrll 
    311      1.1    jruoho             ThisNodeBtype = AnGetBtype (ArgOp);
    312      1.1    jruoho             if (ThisNodeBtype == ACPI_UINT32_MAX)
    313      1.1    jruoho             {
    314      1.1    jruoho                 goto NextArgument;
    315      1.1    jruoho             }
    316      1.1    jruoho 
    317      1.1    jruoho             /* Examine the arg based on the required type of the arg */
    318      1.1    jruoho 
    319      1.1    jruoho             switch (ArgType)
    320      1.1    jruoho             {
    321      1.1    jruoho             case ARGI_TARGETREF:
    322      1.1    jruoho 
    323      1.1    jruoho                 if (ArgOp->Asl.ParseOpcode == PARSEOP_ZERO)
    324      1.1    jruoho                 {
    325      1.1    jruoho                     /* ZERO is the placeholder for "don't store result" */
    326      1.1    jruoho 
    327      1.1    jruoho                     ThisNodeBtype = RequiredBtypes;
    328      1.1    jruoho                     break;
    329      1.1    jruoho                 }
    330      1.1    jruoho 
    331      1.1    jruoho                 if (ArgOp->Asl.ParseOpcode == PARSEOP_INTEGER)
    332      1.1    jruoho                 {
    333      1.1    jruoho                     /*
    334      1.1    jruoho                      * This is the case where an original reference to a resource
    335      1.1    jruoho                      * descriptor field has been replaced by an (Integer) offset.
    336      1.1    jruoho                      * These named fields are supported at compile-time only;
    337      1.1    jruoho                      * the names are not passed to the interpreter (via the AML).
    338      1.1    jruoho                      */
    339      1.1    jruoho                     if ((ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
    340      1.1    jruoho                         (ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
    341      1.1    jruoho                     {
    342      1.1    jruoho                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_FIELD, ArgOp, NULL);
    343      1.1    jruoho                     }
    344      1.1    jruoho                     else
    345      1.1    jruoho                     {
    346      1.1    jruoho                         AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, NULL);
    347      1.1    jruoho                     }
    348      1.1    jruoho                     break;
    349      1.1    jruoho                 }
    350      1.1    jruoho 
    351      1.1    jruoho                 if ((ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL) ||
    352      1.1    jruoho                     (ArgOp->Asl.ParseOpcode == PARSEOP_DEREFOF))
    353      1.1    jruoho                 {
    354      1.1    jruoho                     break;
    355      1.1    jruoho                 }
    356      1.1    jruoho 
    357      1.1    jruoho                 ThisNodeBtype = RequiredBtypes;
    358      1.1    jruoho                 break;
    359      1.1    jruoho 
    360      1.1    jruoho 
    361      1.1    jruoho             case ARGI_REFERENCE:            /* References */
    362      1.1    jruoho             case ARGI_INTEGER_REF:
    363      1.1    jruoho             case ARGI_OBJECT_REF:
    364      1.1    jruoho             case ARGI_DEVICE_REF:
    365      1.1    jruoho 
    366      1.1    jruoho                 switch (ArgOp->Asl.ParseOpcode)
    367      1.1    jruoho                 {
    368      1.1    jruoho                 case PARSEOP_LOCAL0:
    369      1.1    jruoho                 case PARSEOP_LOCAL1:
    370      1.1    jruoho                 case PARSEOP_LOCAL2:
    371      1.1    jruoho                 case PARSEOP_LOCAL3:
    372      1.1    jruoho                 case PARSEOP_LOCAL4:
    373      1.1    jruoho                 case PARSEOP_LOCAL5:
    374      1.1    jruoho                 case PARSEOP_LOCAL6:
    375      1.1    jruoho                 case PARSEOP_LOCAL7:
    376      1.1    jruoho 
    377      1.1    jruoho                     /* TBD: implement analysis of current value (type) of the local */
    378      1.1    jruoho                     /* For now, just treat any local as a typematch */
    379      1.1    jruoho 
    380      1.1    jruoho                     /*ThisNodeBtype = RequiredBtypes;*/
    381      1.1    jruoho                     break;
    382      1.1    jruoho 
    383      1.1    jruoho                 case PARSEOP_ARG0:
    384      1.1    jruoho                 case PARSEOP_ARG1:
    385      1.1    jruoho                 case PARSEOP_ARG2:
    386      1.1    jruoho                 case PARSEOP_ARG3:
    387      1.1    jruoho                 case PARSEOP_ARG4:
    388      1.1    jruoho                 case PARSEOP_ARG5:
    389      1.1    jruoho                 case PARSEOP_ARG6:
    390      1.1    jruoho 
    391      1.1    jruoho                     /* Hard to analyze argument types, sow we won't */
    392      1.1    jruoho                     /* For now, just treat any arg as a typematch */
    393      1.1    jruoho 
    394      1.1    jruoho                     /* ThisNodeBtype = RequiredBtypes; */
    395      1.1    jruoho                     break;
    396      1.1    jruoho 
    397      1.1    jruoho                 case PARSEOP_DEBUG:
    398      1.1    jruoho                 case PARSEOP_REFOF:
    399      1.1    jruoho                 case PARSEOP_INDEX:
    400      1.1    jruoho                 default:
    401      1.2  christos 
    402      1.1    jruoho                     break;
    403      1.1    jruoho 
    404      1.1    jruoho                 }
    405      1.1    jruoho                 break;
    406      1.1    jruoho 
    407      1.1    jruoho             case ARGI_INTEGER:
    408      1.1    jruoho             default:
    409      1.2  christos 
    410      1.1    jruoho                 break;
    411      1.1    jruoho             }
    412      1.1    jruoho 
    413      1.1    jruoho 
    414      1.1    jruoho             CommonBtypes = ThisNodeBtype & RequiredBtypes;
    415      1.1    jruoho 
    416      1.1    jruoho             if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
    417      1.1    jruoho             {
    418      1.1    jruoho                 if (AnIsInternalMethod (ArgOp))
    419      1.1    jruoho                 {
    420      1.1    jruoho                     return (AE_OK);
    421      1.1    jruoho                 }
    422      1.1    jruoho 
    423      1.1    jruoho                 /* Check a method call for a valid return value */
    424      1.1    jruoho 
    425      1.1    jruoho                 AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
    426      1.1    jruoho                     RequiredBtypes, ThisNodeBtype);
    427      1.1    jruoho             }
    428      1.1    jruoho 
    429      1.1    jruoho             /*
    430      1.1    jruoho              * Now check if the actual type(s) match at least one
    431      1.1    jruoho              * bit to the required type
    432      1.1    jruoho              */
    433      1.1    jruoho             else if (!CommonBtypes)
    434      1.1    jruoho             {
    435      1.1    jruoho                 /* No match -- this is a type mismatch error */
    436      1.1    jruoho 
    437      1.1    jruoho                 AnFormatBtype (StringBuffer, ThisNodeBtype);
    438      1.1    jruoho                 AnFormatBtype (StringBuffer2, RequiredBtypes);
    439      1.1    jruoho 
    440      1.2  christos                 snprintf (MsgBuffer, sizeof(MsgBuffer), "[%s] found, %s operator requires [%s]",
    441      1.1    jruoho                             StringBuffer, OpInfo->Name, StringBuffer2);
    442      1.1    jruoho 
    443      1.1    jruoho                 AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
    444      1.1    jruoho             }
    445      1.1    jruoho 
    446      1.1    jruoho         NextArgument:
    447      1.1    jruoho             ArgOp = ArgOp->Asl.Next;
    448      1.1    jruoho             INCREMENT_ARG_LIST (RuntimeArgTypes2);
    449      1.1    jruoho         }
    450      1.1    jruoho         break;
    451      1.1    jruoho 
    452      1.1    jruoho     default:
    453      1.2  christos 
    454      1.1    jruoho         break;
    455      1.1    jruoho     }
    456      1.1    jruoho 
    457      1.1    jruoho     return (AE_OK);
    458      1.1    jruoho }
    459      1.1    jruoho 
    460      1.1    jruoho 
    461      1.1    jruoho /*******************************************************************************
    462      1.1    jruoho  *
    463      1.1    jruoho  * FUNCTION:    AnOtherSemanticAnalysisWalkBegin
    464      1.1    jruoho  *
    465      1.1    jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
    466      1.1    jruoho  *
    467      1.1    jruoho  * RETURN:      Status
    468      1.1    jruoho  *
    469      1.1    jruoho  * DESCRIPTION: Descending callback for the analysis walk. Checks for
    470      1.1    jruoho  *              miscellaneous issues in the code.
    471      1.1    jruoho  *
    472      1.1    jruoho  ******************************************************************************/
    473      1.1    jruoho 
    474      1.1    jruoho ACPI_STATUS
    475      1.1    jruoho AnOtherSemanticAnalysisWalkBegin (
    476      1.1    jruoho     ACPI_PARSE_OBJECT       *Op,
    477      1.1    jruoho     UINT32                  Level,
    478      1.1    jruoho     void                    *Context)
    479      1.1    jruoho {
    480      1.1    jruoho     ACPI_PARSE_OBJECT       *ArgNode;
    481      1.1    jruoho     ACPI_PARSE_OBJECT       *PrevArgNode = NULL;
    482      1.1    jruoho     const ACPI_OPCODE_INFO  *OpInfo;
    483      1.2  christos     ACPI_NAMESPACE_NODE     *Node;
    484      1.1    jruoho 
    485      1.1    jruoho 
    486      1.1    jruoho     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
    487      1.1    jruoho 
    488      1.1    jruoho     /*
    489      1.1    jruoho      * Determine if an execution class operator actually does something by
    490      1.1    jruoho      * checking if it has a target and/or the function return value is used.
    491      1.1    jruoho      * (Target is optional, so a standalone statement can actually do nothing.)
    492      1.1    jruoho      */
    493      1.1    jruoho     if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
    494      1.1    jruoho         (OpInfo->Flags & AML_HAS_RETVAL) &&
    495      1.1    jruoho         (!AnIsResultUsed (Op)))
    496      1.1    jruoho     {
    497      1.1    jruoho         if (OpInfo->Flags & AML_HAS_TARGET)
    498      1.1    jruoho         {
    499      1.1    jruoho             /*
    500      1.1    jruoho              * Find the target node, it is always the last child. If the traget
    501      1.1    jruoho              * is not specified in the ASL, a default node of type Zero was
    502      1.1    jruoho              * created by the parser.
    503      1.1    jruoho              */
    504      1.1    jruoho             ArgNode = Op->Asl.Child;
    505      1.1    jruoho             while (ArgNode->Asl.Next)
    506      1.1    jruoho             {
    507      1.1    jruoho                 PrevArgNode = ArgNode;
    508      1.1    jruoho                 ArgNode = ArgNode->Asl.Next;
    509      1.1    jruoho             }
    510      1.1    jruoho 
    511      1.1    jruoho             /* Divide() is the only weird case, it has two targets */
    512      1.1    jruoho 
    513      1.1    jruoho             if (Op->Asl.AmlOpcode == AML_DIVIDE_OP)
    514      1.1    jruoho             {
    515      1.1    jruoho                 if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) &&
    516      1.1    jruoho                     (PrevArgNode) &&
    517      1.1    jruoho                     (PrevArgNode->Asl.ParseOpcode == PARSEOP_ZERO))
    518      1.1    jruoho                 {
    519      1.2  christos                     AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
    520      1.1    jruoho                         Op, Op->Asl.ExternalName);
    521      1.1    jruoho                 }
    522      1.1    jruoho             }
    523      1.1    jruoho             else if (ArgNode->Asl.ParseOpcode == PARSEOP_ZERO)
    524      1.1    jruoho             {
    525      1.2  christos                 AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
    526      1.1    jruoho                     Op, Op->Asl.ExternalName);
    527      1.1    jruoho             }
    528      1.1    jruoho         }
    529      1.1    jruoho         else
    530      1.1    jruoho         {
    531      1.1    jruoho             /*
    532      1.1    jruoho              * Has no target and the result is not used. Only a couple opcodes
    533      1.1    jruoho              * can have this combination.
    534      1.1    jruoho              */
    535      1.1    jruoho             switch (Op->Asl.ParseOpcode)
    536      1.1    jruoho             {
    537      1.1    jruoho             case PARSEOP_ACQUIRE:
    538      1.1    jruoho             case PARSEOP_WAIT:
    539      1.1    jruoho             case PARSEOP_LOADTABLE:
    540      1.2  christos 
    541      1.1    jruoho                 break;
    542      1.1    jruoho 
    543      1.1    jruoho             default:
    544      1.2  christos 
    545      1.2  christos                 AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
    546      1.1    jruoho                     Op, Op->Asl.ExternalName);
    547      1.1    jruoho                 break;
    548      1.1    jruoho             }
    549      1.1    jruoho         }
    550      1.1    jruoho     }
    551      1.1    jruoho 
    552      1.1    jruoho 
    553      1.1    jruoho     /*
    554      1.1    jruoho      * Semantic checks for individual ASL operators
    555      1.1    jruoho      */
    556      1.1    jruoho     switch (Op->Asl.ParseOpcode)
    557      1.1    jruoho     {
    558      1.1    jruoho     case PARSEOP_ACQUIRE:
    559      1.1    jruoho     case PARSEOP_WAIT:
    560      1.1    jruoho         /*
    561      1.1    jruoho          * Emit a warning if the timeout parameter for these operators is not
    562      1.1    jruoho          * ACPI_WAIT_FOREVER, and the result value from the operator is not
    563      1.1    jruoho          * checked, meaning that a timeout could happen, but the code
    564      1.1    jruoho          * would not know about it.
    565      1.1    jruoho          */
    566      1.1    jruoho 
    567      1.1    jruoho         /* First child is the namepath, 2nd child is timeout */
    568      1.1    jruoho 
    569      1.1    jruoho         ArgNode = Op->Asl.Child;
    570      1.1    jruoho         ArgNode = ArgNode->Asl.Next;
    571      1.1    jruoho 
    572      1.1    jruoho         /*
    573      1.1    jruoho          * Check for the WAIT_FOREVER case - defined by the ACPI spec to be
    574      1.1    jruoho          * 0xFFFF or greater
    575      1.1    jruoho          */
    576      1.1    jruoho         if (((ArgNode->Asl.ParseOpcode == PARSEOP_WORDCONST) ||
    577      1.1    jruoho              (ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER))  &&
    578      1.1    jruoho              (ArgNode->Asl.Value.Integer >= (UINT64) ACPI_WAIT_FOREVER))
    579      1.1    jruoho         {
    580      1.1    jruoho             break;
    581      1.1    jruoho         }
    582      1.1    jruoho 
    583      1.1    jruoho         /*
    584      1.1    jruoho          * The operation could timeout. If the return value is not used
    585      1.1    jruoho          * (indicates timeout occurred), issue a warning
    586      1.1    jruoho          */
    587      1.1    jruoho         if (!AnIsResultUsed (Op))
    588      1.1    jruoho         {
    589      1.1    jruoho             AslError (ASL_WARNING, ASL_MSG_TIMEOUT, ArgNode,
    590      1.1    jruoho                 Op->Asl.ExternalName);
    591      1.1    jruoho         }
    592      1.1    jruoho         break;
    593      1.1    jruoho 
    594      1.1    jruoho     case PARSEOP_CREATEFIELD:
    595      1.1    jruoho         /*
    596      1.1    jruoho          * Check for a zero Length (NumBits) operand. NumBits is the 3rd operand
    597      1.1    jruoho          */
    598      1.1    jruoho         ArgNode = Op->Asl.Child;
    599      1.1    jruoho         ArgNode = ArgNode->Asl.Next;
    600      1.1    jruoho         ArgNode = ArgNode->Asl.Next;
    601      1.1    jruoho 
    602      1.1    jruoho         if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) ||
    603      1.1    jruoho            ((ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER) &&
    604      1.1    jruoho             (ArgNode->Asl.Value.Integer == 0)))
    605      1.1    jruoho         {
    606      1.1    jruoho             AslError (ASL_ERROR, ASL_MSG_NON_ZERO, ArgNode, NULL);
    607      1.1    jruoho         }
    608      1.1    jruoho         break;
    609      1.1    jruoho 
    610      1.2  christos     case PARSEOP_CONNECTION:
    611      1.2  christos         /*
    612      1.2  christos          * Ensure that the referenced operation region has the correct SPACE_ID.
    613      1.2  christos          * From the grammar/parser, we know the parent is a FIELD definition.
    614      1.2  christos          */
    615      1.2  christos         ArgNode = Op->Asl.Parent;       /* Field definition */
    616      1.2  christos         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
    617      1.2  christos         Node = ArgNode->Asl.Node;       /* OpRegion namespace node */
    618      1.3  christos         if (!Node)
    619      1.3  christos         {
    620      1.3  christos             break;
    621      1.3  christos         }
    622      1.2  christos 
    623      1.2  christos         ArgNode = Node->Op;             /* OpRegion definition */
    624      1.2  christos         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
    625      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* Next peer is the SPACE_ID (what we want) */
    626      1.2  christos 
    627      1.2  christos         /*
    628      1.2  christos          * The Connection() operator is only valid for the following operation
    629      1.2  christos          * region SpaceIds: GeneralPurposeIo and GenericSerialBus.
    630      1.2  christos          */
    631      1.2  christos         if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
    632      1.2  christos             (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
    633      1.2  christos         {
    634      1.2  christos             AslError (ASL_ERROR, ASL_MSG_CONNECTION_INVALID, Op, NULL);
    635      1.2  christos         }
    636      1.2  christos         break;
    637      1.2  christos 
    638      1.2  christos     case PARSEOP_FIELD:
    639      1.2  christos         /*
    640      1.2  christos          * Ensure that fields for GeneralPurposeIo and GenericSerialBus
    641      1.2  christos          * contain at least one Connection() operator
    642      1.2  christos          */
    643      1.2  christos         ArgNode = Op->Asl.Child;        /* 1st child is the OpRegion Name */
    644      1.2  christos         Node = ArgNode->Asl.Node;       /* OpRegion namespace node */
    645      1.2  christos         if (!Node)
    646      1.2  christos         {
    647      1.2  christos             break;
    648      1.2  christos         }
    649      1.2  christos 
    650      1.2  christos         ArgNode = Node->Op;             /* OpRegion definition */
    651      1.2  christos         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
    652      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* Next peer is the SPACE_ID (what we want) */
    653      1.2  christos 
    654      1.2  christos         /* We are only interested in GeneralPurposeIo and GenericSerialBus */
    655      1.2  christos 
    656      1.2  christos         if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
    657      1.2  christos             (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
    658      1.2  christos         {
    659      1.2  christos             break;
    660      1.2  christos         }
    661      1.2  christos 
    662      1.2  christos         ArgNode = Op->Asl.Child;        /* 1st child is the OpRegion Name */
    663      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* AccessType */
    664      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* LockRule */
    665      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* UpdateRule */
    666      1.2  christos         ArgNode = ArgNode->Asl.Next;    /* Start of FieldUnitList */
    667      1.2  christos 
    668      1.2  christos         /* Walk the FieldUnitList */
    669      1.2  christos 
    670      1.2  christos         while (ArgNode)
    671      1.2  christos         {
    672      1.2  christos             if (ArgNode->Asl.ParseOpcode == PARSEOP_CONNECTION)
    673      1.2  christos             {
    674      1.2  christos                 break;
    675      1.2  christos             }
    676      1.2  christos             else if (ArgNode->Asl.ParseOpcode == PARSEOP_NAMESEG)
    677      1.2  christos             {
    678      1.2  christos                 AslError (ASL_ERROR, ASL_MSG_CONNECTION_MISSING, ArgNode, NULL);
    679      1.2  christos                 break;
    680      1.2  christos             }
    681      1.2  christos 
    682      1.2  christos             ArgNode = ArgNode->Asl.Next;
    683      1.2  christos         }
    684      1.2  christos         break;
    685      1.2  christos 
    686      1.1    jruoho     default:
    687      1.2  christos 
    688      1.1    jruoho         break;
    689      1.1    jruoho     }
    690      1.1    jruoho 
    691      1.1    jruoho     return (AE_OK);
    692      1.1    jruoho }
    693