Home | History | Annotate | Line # | Download | only in compiler
aslwalks.c revision 1.1.1.1
      1  1.1  jruoho /******************************************************************************
      2  1.1  jruoho  *
      3  1.1  jruoho  * Module Name: aslwalks.c - major analytical parse tree walks
      4  1.1  jruoho  *
      5  1.1  jruoho  *****************************************************************************/
      6  1.1  jruoho 
      7  1.1  jruoho /*
      8  1.1  jruoho  * Copyright (C) 2000 - 2011, 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 
     45  1.1  jruoho #include "aslcompiler.h"
     46  1.1  jruoho #include "aslcompiler.y.h"
     47  1.1  jruoho #include "acparser.h"
     48  1.1  jruoho #include "amlcode.h"
     49  1.1  jruoho 
     50  1.1  jruoho 
     51  1.1  jruoho #define _COMPONENT          ACPI_COMPILER
     52  1.1  jruoho         ACPI_MODULE_NAME    ("aslwalks")
     53  1.1  jruoho 
     54  1.1  jruoho 
     55  1.1  jruoho /*******************************************************************************
     56  1.1  jruoho  *
     57  1.1  jruoho  * FUNCTION:    AnMethodAnalysisWalkBegin
     58  1.1  jruoho  *
     59  1.1  jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
     60  1.1  jruoho  *
     61  1.1  jruoho  * RETURN:      Status
     62  1.1  jruoho  *
     63  1.1  jruoho  * DESCRIPTION: Descending callback for the analysis walk. 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 AnMethodAnalysisWalkBegin (
     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     ASL_ANALYSIS_WALK_INFO  *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
     77  1.1  jruoho     ASL_METHOD_INFO         *MethodInfo = WalkInfo->MethodStack;
     78  1.1  jruoho     ACPI_PARSE_OBJECT       *Next;
     79  1.1  jruoho     UINT32                  RegisterNumber;
     80  1.1  jruoho     UINT32                  i;
     81  1.1  jruoho     char                    LocalName[] = "Local0";
     82  1.1  jruoho     char                    ArgName[] = "Arg0";
     83  1.1  jruoho     ACPI_PARSE_OBJECT       *ArgNode;
     84  1.1  jruoho     ACPI_PARSE_OBJECT       *NextType;
     85  1.1  jruoho     ACPI_PARSE_OBJECT       *NextParamType;
     86  1.1  jruoho     UINT8                   ActualArgs = 0;
     87  1.1  jruoho 
     88  1.1  jruoho 
     89  1.1  jruoho     switch (Op->Asl.ParseOpcode)
     90  1.1  jruoho     {
     91  1.1  jruoho     case PARSEOP_METHOD:
     92  1.1  jruoho 
     93  1.1  jruoho         TotalMethods++;
     94  1.1  jruoho 
     95  1.1  jruoho         /* Create and init method info */
     96  1.1  jruoho 
     97  1.1  jruoho         MethodInfo       = UtLocalCalloc (sizeof (ASL_METHOD_INFO));
     98  1.1  jruoho         MethodInfo->Next = WalkInfo->MethodStack;
     99  1.1  jruoho         MethodInfo->Op = Op;
    100  1.1  jruoho 
    101  1.1  jruoho         WalkInfo->MethodStack = MethodInfo;
    102  1.1  jruoho 
    103  1.1  jruoho         /* Get the name node, ignored here */
    104  1.1  jruoho 
    105  1.1  jruoho         Next = Op->Asl.Child;
    106  1.1  jruoho 
    107  1.1  jruoho         /* Get the NumArguments node */
    108  1.1  jruoho 
    109  1.1  jruoho         Next = Next->Asl.Next;
    110  1.1  jruoho         MethodInfo->NumArguments = (UINT8)
    111  1.1  jruoho             (((UINT8) Next->Asl.Value.Integer) & 0x07);
    112  1.1  jruoho 
    113  1.1  jruoho         /* Get the SerializeRule and SyncLevel nodes, ignored here */
    114  1.1  jruoho 
    115  1.1  jruoho         Next = Next->Asl.Next;
    116  1.1  jruoho         Next = Next->Asl.Next;
    117  1.1  jruoho         ArgNode = Next;
    118  1.1  jruoho 
    119  1.1  jruoho         /* Get the ReturnType node */
    120  1.1  jruoho 
    121  1.1  jruoho         Next = Next->Asl.Next;
    122  1.1  jruoho 
    123  1.1  jruoho         NextType = Next->Asl.Child;
    124  1.1  jruoho         while (NextType)
    125  1.1  jruoho         {
    126  1.1  jruoho             /* Get and map each of the ReturnTypes */
    127  1.1  jruoho 
    128  1.1  jruoho             MethodInfo->ValidReturnTypes |= AnMapObjTypeToBtype (NextType);
    129  1.1  jruoho             NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
    130  1.1  jruoho             NextType = NextType->Asl.Next;
    131  1.1  jruoho         }
    132  1.1  jruoho 
    133  1.1  jruoho         /* Get the ParameterType node */
    134  1.1  jruoho 
    135  1.1  jruoho         Next = Next->Asl.Next;
    136  1.1  jruoho 
    137  1.1  jruoho         NextType = Next->Asl.Child;
    138  1.1  jruoho         while (NextType)
    139  1.1  jruoho         {
    140  1.1  jruoho             if (NextType->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
    141  1.1  jruoho             {
    142  1.1  jruoho                 NextParamType = NextType->Asl.Child;
    143  1.1  jruoho                 while (NextParamType)
    144  1.1  jruoho                 {
    145  1.1  jruoho                     MethodInfo->ValidArgTypes[ActualArgs] |= AnMapObjTypeToBtype (NextParamType);
    146  1.1  jruoho                     NextParamType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
    147  1.1  jruoho                     NextParamType = NextParamType->Asl.Next;
    148  1.1  jruoho                 }
    149  1.1  jruoho             }
    150  1.1  jruoho             else
    151  1.1  jruoho             {
    152  1.1  jruoho                 MethodInfo->ValidArgTypes[ActualArgs] =
    153  1.1  jruoho                     AnMapObjTypeToBtype (NextType);
    154  1.1  jruoho                 NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
    155  1.1  jruoho                 ActualArgs++;
    156  1.1  jruoho             }
    157  1.1  jruoho 
    158  1.1  jruoho             NextType = NextType->Asl.Next;
    159  1.1  jruoho         }
    160  1.1  jruoho 
    161  1.1  jruoho         if ((MethodInfo->NumArguments) &&
    162  1.1  jruoho             (MethodInfo->NumArguments != ActualArgs))
    163  1.1  jruoho         {
    164  1.1  jruoho             /* error: Param list did not match number of args */
    165  1.1  jruoho         }
    166  1.1  jruoho 
    167  1.1  jruoho         /* Allow numarguments == 0 for Function() */
    168  1.1  jruoho 
    169  1.1  jruoho         if ((!MethodInfo->NumArguments) && (ActualArgs))
    170  1.1  jruoho         {
    171  1.1  jruoho             MethodInfo->NumArguments = ActualArgs;
    172  1.1  jruoho             ArgNode->Asl.Value.Integer |= ActualArgs;
    173  1.1  jruoho         }
    174  1.1  jruoho 
    175  1.1  jruoho         /*
    176  1.1  jruoho          * Actual arguments are initialized at method entry.
    177  1.1  jruoho          * All other ArgX "registers" can be used as locals, so we
    178  1.1  jruoho          * track their initialization.
    179  1.1  jruoho          */
    180  1.1  jruoho         for (i = 0; i < MethodInfo->NumArguments; i++)
    181  1.1  jruoho         {
    182  1.1  jruoho             MethodInfo->ArgInitialized[i] = TRUE;
    183  1.1  jruoho         }
    184  1.1  jruoho         break;
    185  1.1  jruoho 
    186  1.1  jruoho 
    187  1.1  jruoho     case PARSEOP_METHODCALL:
    188  1.1  jruoho 
    189  1.1  jruoho         if (MethodInfo &&
    190  1.1  jruoho            (Op->Asl.Node == MethodInfo->Op->Asl.Node))
    191  1.1  jruoho         {
    192  1.1  jruoho             AslError (ASL_REMARK, ASL_MSG_RECURSION, Op, Op->Asl.ExternalName);
    193  1.1  jruoho         }
    194  1.1  jruoho         break;
    195  1.1  jruoho 
    196  1.1  jruoho 
    197  1.1  jruoho     case PARSEOP_LOCAL0:
    198  1.1  jruoho     case PARSEOP_LOCAL1:
    199  1.1  jruoho     case PARSEOP_LOCAL2:
    200  1.1  jruoho     case PARSEOP_LOCAL3:
    201  1.1  jruoho     case PARSEOP_LOCAL4:
    202  1.1  jruoho     case PARSEOP_LOCAL5:
    203  1.1  jruoho     case PARSEOP_LOCAL6:
    204  1.1  jruoho     case PARSEOP_LOCAL7:
    205  1.1  jruoho 
    206  1.1  jruoho         if (!MethodInfo)
    207  1.1  jruoho         {
    208  1.1  jruoho             /*
    209  1.1  jruoho              * Local was used outside a control method, or there was an error
    210  1.1  jruoho              * in the method declaration.
    211  1.1  jruoho              */
    212  1.1  jruoho             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD, Op, Op->Asl.ExternalName);
    213  1.1  jruoho             return (AE_ERROR);
    214  1.1  jruoho         }
    215  1.1  jruoho 
    216  1.1  jruoho         RegisterNumber = (Op->Asl.AmlOpcode & 0x000F);
    217  1.1  jruoho 
    218  1.1  jruoho         /*
    219  1.1  jruoho          * If the local is being used as a target, mark the local
    220  1.1  jruoho          * initialized
    221  1.1  jruoho          */
    222  1.1  jruoho         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
    223  1.1  jruoho         {
    224  1.1  jruoho             MethodInfo->LocalInitialized[RegisterNumber] = TRUE;
    225  1.1  jruoho         }
    226  1.1  jruoho 
    227  1.1  jruoho         /*
    228  1.1  jruoho          * Otherwise, this is a reference, check if the local
    229  1.1  jruoho          * has been previously initialized.
    230  1.1  jruoho          *
    231  1.1  jruoho          * The only operator that accepts an uninitialized value is ObjectType()
    232  1.1  jruoho          */
    233  1.1  jruoho         else if ((!MethodInfo->LocalInitialized[RegisterNumber]) &&
    234  1.1  jruoho                  (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
    235  1.1  jruoho         {
    236  1.1  jruoho             LocalName[strlen (LocalName) -1] = (char) (RegisterNumber + 0x30);
    237  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_LOCAL_INIT, Op, LocalName);
    238  1.1  jruoho         }
    239  1.1  jruoho         break;
    240  1.1  jruoho 
    241  1.1  jruoho 
    242  1.1  jruoho     case PARSEOP_ARG0:
    243  1.1  jruoho     case PARSEOP_ARG1:
    244  1.1  jruoho     case PARSEOP_ARG2:
    245  1.1  jruoho     case PARSEOP_ARG3:
    246  1.1  jruoho     case PARSEOP_ARG4:
    247  1.1  jruoho     case PARSEOP_ARG5:
    248  1.1  jruoho     case PARSEOP_ARG6:
    249  1.1  jruoho 
    250  1.1  jruoho         if (!MethodInfo)
    251  1.1  jruoho         {
    252  1.1  jruoho             /*
    253  1.1  jruoho              * Arg was used outside a control method, or there was an error
    254  1.1  jruoho              * in the method declaration.
    255  1.1  jruoho              */
    256  1.1  jruoho             AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD, Op, Op->Asl.ExternalName);
    257  1.1  jruoho             return (AE_ERROR);
    258  1.1  jruoho         }
    259  1.1  jruoho 
    260  1.1  jruoho         RegisterNumber = (Op->Asl.AmlOpcode & 0x000F) - 8;
    261  1.1  jruoho         ArgName[strlen (ArgName) -1] = (char) (RegisterNumber + 0x30);
    262  1.1  jruoho 
    263  1.1  jruoho         /*
    264  1.1  jruoho          * If the Arg is being used as a target, mark the local
    265  1.1  jruoho          * initialized
    266  1.1  jruoho          */
    267  1.1  jruoho         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
    268  1.1  jruoho         {
    269  1.1  jruoho             MethodInfo->ArgInitialized[RegisterNumber] = TRUE;
    270  1.1  jruoho         }
    271  1.1  jruoho 
    272  1.1  jruoho         /*
    273  1.1  jruoho          * Otherwise, this is a reference, check if the Arg
    274  1.1  jruoho          * has been previously initialized.
    275  1.1  jruoho          *
    276  1.1  jruoho          * The only operator that accepts an uninitialized value is ObjectType()
    277  1.1  jruoho          */
    278  1.1  jruoho         else if ((!MethodInfo->ArgInitialized[RegisterNumber]) &&
    279  1.1  jruoho                  (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
    280  1.1  jruoho         {
    281  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_ARG_INIT, Op, ArgName);
    282  1.1  jruoho         }
    283  1.1  jruoho 
    284  1.1  jruoho         /* Flag this arg if it is not a "real" argument to the method */
    285  1.1  jruoho 
    286  1.1  jruoho         if (RegisterNumber >= MethodInfo->NumArguments)
    287  1.1  jruoho         {
    288  1.1  jruoho             AslError (ASL_REMARK, ASL_MSG_NOT_PARAMETER, Op, ArgName);
    289  1.1  jruoho         }
    290  1.1  jruoho         break;
    291  1.1  jruoho 
    292  1.1  jruoho 
    293  1.1  jruoho     case PARSEOP_RETURN:
    294  1.1  jruoho 
    295  1.1  jruoho         if (!MethodInfo)
    296  1.1  jruoho         {
    297  1.1  jruoho             /*
    298  1.1  jruoho              * Probably was an error in the method declaration,
    299  1.1  jruoho              * no additional error here
    300  1.1  jruoho              */
    301  1.1  jruoho             ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
    302  1.1  jruoho             return (AE_ERROR);
    303  1.1  jruoho         }
    304  1.1  jruoho 
    305  1.1  jruoho         /* Child indicates a return value */
    306  1.1  jruoho 
    307  1.1  jruoho         if ((Op->Asl.Child) &&
    308  1.1  jruoho             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
    309  1.1  jruoho         {
    310  1.1  jruoho             MethodInfo->NumReturnWithValue++;
    311  1.1  jruoho         }
    312  1.1  jruoho         else
    313  1.1  jruoho         {
    314  1.1  jruoho             MethodInfo->NumReturnNoValue++;
    315  1.1  jruoho         }
    316  1.1  jruoho         break;
    317  1.1  jruoho 
    318  1.1  jruoho 
    319  1.1  jruoho     case PARSEOP_BREAK:
    320  1.1  jruoho     case PARSEOP_CONTINUE:
    321  1.1  jruoho 
    322  1.1  jruoho         Next = Op->Asl.Parent;
    323  1.1  jruoho         while (Next)
    324  1.1  jruoho         {
    325  1.1  jruoho             if (Next->Asl.ParseOpcode == PARSEOP_WHILE)
    326  1.1  jruoho             {
    327  1.1  jruoho                 break;
    328  1.1  jruoho             }
    329  1.1  jruoho             Next = Next->Asl.Parent;
    330  1.1  jruoho         }
    331  1.1  jruoho 
    332  1.1  jruoho         if (!Next)
    333  1.1  jruoho         {
    334  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_NO_WHILE, Op, NULL);
    335  1.1  jruoho         }
    336  1.1  jruoho         break;
    337  1.1  jruoho 
    338  1.1  jruoho 
    339  1.1  jruoho     case PARSEOP_STALL:
    340  1.1  jruoho 
    341  1.1  jruoho         /* We can range check if the argument is an integer */
    342  1.1  jruoho 
    343  1.1  jruoho         if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
    344  1.1  jruoho             (Op->Asl.Child->Asl.Value.Integer > ACPI_UINT8_MAX))
    345  1.1  jruoho         {
    346  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_INVALID_TIME, Op, NULL);
    347  1.1  jruoho         }
    348  1.1  jruoho         break;
    349  1.1  jruoho 
    350  1.1  jruoho 
    351  1.1  jruoho     case PARSEOP_DEVICE:
    352  1.1  jruoho     case PARSEOP_EVENT:
    353  1.1  jruoho     case PARSEOP_MUTEX:
    354  1.1  jruoho     case PARSEOP_OPERATIONREGION:
    355  1.1  jruoho     case PARSEOP_POWERRESOURCE:
    356  1.1  jruoho     case PARSEOP_PROCESSOR:
    357  1.1  jruoho     case PARSEOP_THERMALZONE:
    358  1.1  jruoho 
    359  1.1  jruoho         /*
    360  1.1  jruoho          * The first operand is a name to be created in the namespace.
    361  1.1  jruoho          * Check against the reserved list.
    362  1.1  jruoho          */
    363  1.1  jruoho         i = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
    364  1.1  jruoho         if (i < ACPI_VALID_RESERVED_NAME_MAX)
    365  1.1  jruoho         {
    366  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_RESERVED_USE, Op, Op->Asl.ExternalName);
    367  1.1  jruoho         }
    368  1.1  jruoho         break;
    369  1.1  jruoho 
    370  1.1  jruoho 
    371  1.1  jruoho     case PARSEOP_NAME:
    372  1.1  jruoho 
    373  1.1  jruoho         /* Typecheck any predefined names statically defined with Name() */
    374  1.1  jruoho 
    375  1.1  jruoho         ApCheckForPredefinedObject (Op, Op->Asl.NameSeg);
    376  1.1  jruoho 
    377  1.1  jruoho         /* Special typechecking for _HID */
    378  1.1  jruoho 
    379  1.1  jruoho         if (!ACPI_STRCMP (METHOD_NAME__HID, Op->Asl.NameSeg))
    380  1.1  jruoho         {
    381  1.1  jruoho             Next = Op->Asl.Child->Asl.Next;
    382  1.1  jruoho             AnCheckId (Next, ASL_TYPE_HID);
    383  1.1  jruoho         }
    384  1.1  jruoho 
    385  1.1  jruoho         /* Special typechecking for _CID */
    386  1.1  jruoho 
    387  1.1  jruoho         else if (!ACPI_STRCMP (METHOD_NAME__CID, Op->Asl.NameSeg))
    388  1.1  jruoho         {
    389  1.1  jruoho             Next = Op->Asl.Child->Asl.Next;
    390  1.1  jruoho 
    391  1.1  jruoho             if ((Next->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
    392  1.1  jruoho                 (Next->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
    393  1.1  jruoho             {
    394  1.1  jruoho                 Next = Next->Asl.Child;
    395  1.1  jruoho                 while (Next)
    396  1.1  jruoho                 {
    397  1.1  jruoho                     AnCheckId (Next, ASL_TYPE_CID);
    398  1.1  jruoho                     Next = Next->Asl.Next;
    399  1.1  jruoho                 }
    400  1.1  jruoho             }
    401  1.1  jruoho             else
    402  1.1  jruoho             {
    403  1.1  jruoho                 AnCheckId (Next, ASL_TYPE_CID);
    404  1.1  jruoho             }
    405  1.1  jruoho         }
    406  1.1  jruoho         break;
    407  1.1  jruoho 
    408  1.1  jruoho 
    409  1.1  jruoho     default:
    410  1.1  jruoho         break;
    411  1.1  jruoho     }
    412  1.1  jruoho 
    413  1.1  jruoho     return (AE_OK);
    414  1.1  jruoho }
    415  1.1  jruoho 
    416  1.1  jruoho 
    417  1.1  jruoho /*******************************************************************************
    418  1.1  jruoho  *
    419  1.1  jruoho  * FUNCTION:    AnMethodAnalysisWalkEnd
    420  1.1  jruoho  *
    421  1.1  jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
    422  1.1  jruoho  *
    423  1.1  jruoho  * RETURN:      Status
    424  1.1  jruoho  *
    425  1.1  jruoho  * DESCRIPTION: Ascending callback for analysis walk. Complete method
    426  1.1  jruoho  *              return analysis.
    427  1.1  jruoho  *
    428  1.1  jruoho  ******************************************************************************/
    429  1.1  jruoho 
    430  1.1  jruoho ACPI_STATUS
    431  1.1  jruoho AnMethodAnalysisWalkEnd (
    432  1.1  jruoho     ACPI_PARSE_OBJECT       *Op,
    433  1.1  jruoho     UINT32                  Level,
    434  1.1  jruoho     void                    *Context)
    435  1.1  jruoho {
    436  1.1  jruoho     ASL_ANALYSIS_WALK_INFO  *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
    437  1.1  jruoho     ASL_METHOD_INFO         *MethodInfo = WalkInfo->MethodStack;
    438  1.1  jruoho 
    439  1.1  jruoho 
    440  1.1  jruoho     switch (Op->Asl.ParseOpcode)
    441  1.1  jruoho     {
    442  1.1  jruoho     case PARSEOP_METHOD:
    443  1.1  jruoho     case PARSEOP_RETURN:
    444  1.1  jruoho         if (!MethodInfo)
    445  1.1  jruoho         {
    446  1.1  jruoho             printf ("No method info for method! [%s]\n", Op->Asl.Namepath);
    447  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
    448  1.1  jruoho                 "No method info for this method");
    449  1.1  jruoho 
    450  1.1  jruoho             CmCleanupAndExit ();
    451  1.1  jruoho             return (AE_AML_INTERNAL);
    452  1.1  jruoho         }
    453  1.1  jruoho         break;
    454  1.1  jruoho 
    455  1.1  jruoho     default:
    456  1.1  jruoho         break;
    457  1.1  jruoho     }
    458  1.1  jruoho 
    459  1.1  jruoho     switch (Op->Asl.ParseOpcode)
    460  1.1  jruoho     {
    461  1.1  jruoho     case PARSEOP_METHOD:
    462  1.1  jruoho 
    463  1.1  jruoho         WalkInfo->MethodStack = MethodInfo->Next;
    464  1.1  jruoho 
    465  1.1  jruoho         /*
    466  1.1  jruoho          * Check if there is no return statement at the end of the
    467  1.1  jruoho          * method AND we can actually get there -- i.e., the execution
    468  1.1  jruoho          * of the method can possibly terminate without a return statement.
    469  1.1  jruoho          */
    470  1.1  jruoho         if ((!AnLastStatementIsReturn (Op)) &&
    471  1.1  jruoho             (!(Op->Asl.CompileFlags & NODE_HAS_NO_EXIT)))
    472  1.1  jruoho         {
    473  1.1  jruoho             /*
    474  1.1  jruoho              * No return statement, and execution can possibly exit
    475  1.1  jruoho              * via this path. This is equivalent to Return ()
    476  1.1  jruoho              */
    477  1.1  jruoho             MethodInfo->NumReturnNoValue++;
    478  1.1  jruoho         }
    479  1.1  jruoho 
    480  1.1  jruoho         /*
    481  1.1  jruoho          * Check for case where some return statements have a return value
    482  1.1  jruoho          * and some do not. Exit without a return statement is a return with
    483  1.1  jruoho          * no value
    484  1.1  jruoho          */
    485  1.1  jruoho         if (MethodInfo->NumReturnNoValue &&
    486  1.1  jruoho             MethodInfo->NumReturnWithValue)
    487  1.1  jruoho         {
    488  1.1  jruoho             AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Op,
    489  1.1  jruoho                 Op->Asl.ExternalName);
    490  1.1  jruoho         }
    491  1.1  jruoho 
    492  1.1  jruoho         /*
    493  1.1  jruoho          * If there are any RETURN() statements with no value, or there is a
    494  1.1  jruoho          * control path that allows the method to exit without a return value,
    495  1.1  jruoho          * we mark the method as a method that does not return a value. This
    496  1.1  jruoho          * knowledge can be used to check method invocations that expect a
    497  1.1  jruoho          * returned value.
    498  1.1  jruoho          */
    499  1.1  jruoho         if (MethodInfo->NumReturnNoValue)
    500  1.1  jruoho         {
    501  1.1  jruoho             if (MethodInfo->NumReturnWithValue)
    502  1.1  jruoho             {
    503  1.1  jruoho                 Op->Asl.CompileFlags |= NODE_METHOD_SOME_NO_RETVAL;
    504  1.1  jruoho             }
    505  1.1  jruoho             else
    506  1.1  jruoho             {
    507  1.1  jruoho                 Op->Asl.CompileFlags |= NODE_METHOD_NO_RETVAL;
    508  1.1  jruoho             }
    509  1.1  jruoho         }
    510  1.1  jruoho 
    511  1.1  jruoho         /*
    512  1.1  jruoho          * Check predefined method names for correct return behavior
    513  1.1  jruoho          * and correct number of arguments
    514  1.1  jruoho          */
    515  1.1  jruoho         ApCheckForPredefinedMethod (Op, MethodInfo);
    516  1.1  jruoho 
    517  1.1  jruoho         /* Special check for two names like _L01 and _E01 in same scope */
    518  1.1  jruoho 
    519  1.1  jruoho         ApCheckForGpeNameConflict (Op);
    520  1.1  jruoho         ACPI_FREE (MethodInfo);
    521  1.1  jruoho         break;
    522  1.1  jruoho 
    523  1.1  jruoho 
    524  1.1  jruoho     case PARSEOP_NAME:
    525  1.1  jruoho 
    526  1.1  jruoho          /* Special check for two names like _L01 and _E01 in same scope */
    527  1.1  jruoho 
    528  1.1  jruoho         ApCheckForGpeNameConflict (Op);
    529  1.1  jruoho         break;
    530  1.1  jruoho 
    531  1.1  jruoho 
    532  1.1  jruoho     case PARSEOP_RETURN:
    533  1.1  jruoho 
    534  1.1  jruoho         /*
    535  1.1  jruoho          * If the parent is a predefined method name, attempt to typecheck
    536  1.1  jruoho          * the return value. Only static types can be validated.
    537  1.1  jruoho          */
    538  1.1  jruoho         ApCheckPredefinedReturnValue (Op, MethodInfo);
    539  1.1  jruoho 
    540  1.1  jruoho         /*
    541  1.1  jruoho          * The parent block does not "exit" and continue execution -- the
    542  1.1  jruoho          * method is terminated here with the Return() statement.
    543  1.1  jruoho          */
    544  1.1  jruoho         Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
    545  1.1  jruoho 
    546  1.1  jruoho         /* Used in the "typing" pass later */
    547  1.1  jruoho 
    548  1.1  jruoho         Op->Asl.ParentMethod = MethodInfo->Op;
    549  1.1  jruoho 
    550  1.1  jruoho         /*
    551  1.1  jruoho          * If there is a peer node after the return statement, then this
    552  1.1  jruoho          * node is unreachable code -- i.e., it won't be executed because of
    553  1.1  jruoho          * the preceeding Return() statement.
    554  1.1  jruoho          */
    555  1.1  jruoho         if (Op->Asl.Next)
    556  1.1  jruoho         {
    557  1.1  jruoho             AslError (ASL_WARNING, ASL_MSG_UNREACHABLE_CODE, Op->Asl.Next, NULL);
    558  1.1  jruoho         }
    559  1.1  jruoho         break;
    560  1.1  jruoho 
    561  1.1  jruoho 
    562  1.1  jruoho     case PARSEOP_IF:
    563  1.1  jruoho 
    564  1.1  jruoho         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
    565  1.1  jruoho             (Op->Asl.Next) &&
    566  1.1  jruoho             (Op->Asl.Next->Asl.ParseOpcode == PARSEOP_ELSE))
    567  1.1  jruoho         {
    568  1.1  jruoho             /*
    569  1.1  jruoho              * This IF has a corresponding ELSE. The IF block has no exit,
    570  1.1  jruoho              * (it contains an unconditional Return)
    571  1.1  jruoho              * mark the ELSE block to remember this fact.
    572  1.1  jruoho              */
    573  1.1  jruoho             Op->Asl.Next->Asl.CompileFlags |= NODE_IF_HAS_NO_EXIT;
    574  1.1  jruoho         }
    575  1.1  jruoho         break;
    576  1.1  jruoho 
    577  1.1  jruoho 
    578  1.1  jruoho     case PARSEOP_ELSE:
    579  1.1  jruoho 
    580  1.1  jruoho         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
    581  1.1  jruoho             (Op->Asl.CompileFlags & NODE_IF_HAS_NO_EXIT))
    582  1.1  jruoho         {
    583  1.1  jruoho             /*
    584  1.1  jruoho              * This ELSE block has no exit and the corresponding IF block
    585  1.1  jruoho              * has no exit either. Therefore, the parent node has no exit.
    586  1.1  jruoho              */
    587  1.1  jruoho             Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
    588  1.1  jruoho         }
    589  1.1  jruoho         break;
    590  1.1  jruoho 
    591  1.1  jruoho 
    592  1.1  jruoho     default:
    593  1.1  jruoho 
    594  1.1  jruoho         if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
    595  1.1  jruoho             (Op->Asl.Parent))
    596  1.1  jruoho         {
    597  1.1  jruoho             /* If this node has no exit, then the parent has no exit either */
    598  1.1  jruoho 
    599  1.1  jruoho             Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
    600  1.1  jruoho         }
    601  1.1  jruoho         break;
    602  1.1  jruoho     }
    603  1.1  jruoho 
    604  1.1  jruoho     return (AE_OK);
    605  1.1  jruoho }
    606  1.1  jruoho 
    607  1.1  jruoho 
    608  1.1  jruoho /*******************************************************************************
    609  1.1  jruoho  *
    610  1.1  jruoho  * FUNCTION:    AnMethodTypingWalkEnd
    611  1.1  jruoho  *
    612  1.1  jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
    613  1.1  jruoho  *
    614  1.1  jruoho  * RETURN:      Status
    615  1.1  jruoho  *
    616  1.1  jruoho  * DESCRIPTION: Ascending callback for typing walk. Complete the method
    617  1.1  jruoho  *              return analysis. Check methods for:
    618  1.1  jruoho  *              1) Initialized local variables
    619  1.1  jruoho  *              2) Valid arguments
    620  1.1  jruoho  *              3) Return types
    621  1.1  jruoho  *
    622  1.1  jruoho  ******************************************************************************/
    623  1.1  jruoho 
    624  1.1  jruoho ACPI_STATUS
    625  1.1  jruoho AnMethodTypingWalkEnd (
    626  1.1  jruoho     ACPI_PARSE_OBJECT       *Op,
    627  1.1  jruoho     UINT32                  Level,
    628  1.1  jruoho     void                    *Context)
    629  1.1  jruoho {
    630  1.1  jruoho     UINT32                  ThisNodeBtype;
    631  1.1  jruoho 
    632  1.1  jruoho 
    633  1.1  jruoho     switch (Op->Asl.ParseOpcode)
    634  1.1  jruoho     {
    635  1.1  jruoho     case PARSEOP_METHOD:
    636  1.1  jruoho 
    637  1.1  jruoho         Op->Asl.CompileFlags |= NODE_METHOD_TYPED;
    638  1.1  jruoho         break;
    639  1.1  jruoho 
    640  1.1  jruoho     case PARSEOP_RETURN:
    641  1.1  jruoho 
    642  1.1  jruoho         if ((Op->Asl.Child) &&
    643  1.1  jruoho             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
    644  1.1  jruoho         {
    645  1.1  jruoho             ThisNodeBtype = AnGetBtype (Op->Asl.Child);
    646  1.1  jruoho 
    647  1.1  jruoho             if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_METHODCALL) &&
    648  1.1  jruoho                 (ThisNodeBtype == (ACPI_UINT32_MAX -1)))
    649  1.1  jruoho             {
    650  1.1  jruoho                 /*
    651  1.1  jruoho                  * The called method is untyped at this time (typically a
    652  1.1  jruoho                  * forward reference).
    653  1.1  jruoho                  *
    654  1.1  jruoho                  * Check for a recursive method call first.
    655  1.1  jruoho                  */
    656  1.1  jruoho                 if (Op->Asl.ParentMethod != Op->Asl.Child->Asl.Node->Op)
    657  1.1  jruoho                 {
    658  1.1  jruoho                     /* We must type the method here */
    659  1.1  jruoho 
    660  1.1  jruoho                     TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
    661  1.1  jruoho                         ASL_WALK_VISIT_UPWARD, NULL,
    662  1.1  jruoho                         AnMethodTypingWalkEnd, NULL);
    663  1.1  jruoho 
    664  1.1  jruoho                     ThisNodeBtype = AnGetBtype (Op->Asl.Child);
    665  1.1  jruoho                 }
    666  1.1  jruoho             }
    667  1.1  jruoho 
    668  1.1  jruoho             /* Returns a value, save the value type */
    669  1.1  jruoho 
    670  1.1  jruoho             if (Op->Asl.ParentMethod)
    671  1.1  jruoho             {
    672  1.1  jruoho                 Op->Asl.ParentMethod->Asl.AcpiBtype |= ThisNodeBtype;
    673  1.1  jruoho             }
    674  1.1  jruoho         }
    675  1.1  jruoho         break;
    676  1.1  jruoho 
    677  1.1  jruoho     default:
    678  1.1  jruoho         break;
    679  1.1  jruoho     }
    680  1.1  jruoho 
    681  1.1  jruoho     return (AE_OK);
    682  1.1  jruoho }
    683  1.1  jruoho 
    684  1.1  jruoho 
    685  1.1  jruoho /*******************************************************************************
    686  1.1  jruoho  *
    687  1.1  jruoho  * FUNCTION:    AnOperandTypecheckWalkEnd
    688  1.1  jruoho  *
    689  1.1  jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
    690  1.1  jruoho  *
    691  1.1  jruoho  * RETURN:      Status
    692  1.1  jruoho  *
    693  1.1  jruoho  * DESCRIPTION: Ascending callback for analysis walk. Complete method
    694  1.1  jruoho  *              return analysis.
    695  1.1  jruoho  *
    696  1.1  jruoho  ******************************************************************************/
    697  1.1  jruoho 
    698  1.1  jruoho ACPI_STATUS
    699  1.1  jruoho AnOperandTypecheckWalkEnd (
    700  1.1  jruoho     ACPI_PARSE_OBJECT       *Op,
    701  1.1  jruoho     UINT32                  Level,
    702  1.1  jruoho     void                    *Context)
    703  1.1  jruoho {
    704  1.1  jruoho     const ACPI_OPCODE_INFO  *OpInfo;
    705  1.1  jruoho     UINT32                  RuntimeArgTypes;
    706  1.1  jruoho     UINT32                  RuntimeArgTypes2;
    707  1.1  jruoho     UINT32                  RequiredBtypes;
    708  1.1  jruoho     UINT32                  ThisNodeBtype;
    709  1.1  jruoho     UINT32                  CommonBtypes;
    710  1.1  jruoho     UINT32                  OpcodeClass;
    711  1.1  jruoho     ACPI_PARSE_OBJECT       *ArgOp;
    712  1.1  jruoho     UINT32                  ArgType;
    713  1.1  jruoho 
    714  1.1  jruoho 
    715  1.1  jruoho     switch (Op->Asl.AmlOpcode)
    716  1.1  jruoho     {
    717  1.1  jruoho     case AML_RAW_DATA_BYTE:
    718  1.1  jruoho     case AML_RAW_DATA_WORD:
    719  1.1  jruoho     case AML_RAW_DATA_DWORD:
    720  1.1  jruoho     case AML_RAW_DATA_QWORD:
    721  1.1  jruoho     case AML_RAW_DATA_BUFFER:
    722  1.1  jruoho     case AML_RAW_DATA_CHAIN:
    723  1.1  jruoho     case AML_PACKAGE_LENGTH:
    724  1.1  jruoho     case AML_UNASSIGNED_OPCODE:
    725  1.1  jruoho     case AML_DEFAULT_ARG_OP:
    726  1.1  jruoho 
    727  1.1  jruoho         /* Ignore the internal (compiler-only) AML opcodes */
    728  1.1  jruoho 
    729  1.1  jruoho         return (AE_OK);
    730  1.1  jruoho 
    731  1.1  jruoho     default:
    732  1.1  jruoho         break;
    733  1.1  jruoho     }
    734  1.1  jruoho 
    735  1.1  jruoho     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
    736  1.1  jruoho     if (!OpInfo)
    737  1.1  jruoho     {
    738  1.1  jruoho         return (AE_OK);
    739  1.1  jruoho     }
    740  1.1  jruoho 
    741  1.1  jruoho     ArgOp           = Op->Asl.Child;
    742  1.1  jruoho     RuntimeArgTypes = OpInfo->RuntimeArgs;
    743  1.1  jruoho     OpcodeClass     = OpInfo->Class;
    744  1.1  jruoho 
    745  1.1  jruoho #ifdef ASL_ERROR_NAMED_OBJECT_IN_WHILE
    746  1.1  jruoho     /*
    747  1.1  jruoho      * Update 11/2008: In practice, we can't perform this check. A simple
    748  1.1  jruoho      * analysis is not sufficient. Also, it can cause errors when compiling
    749  1.1  jruoho      * disassembled code because of the way Switch operators are implemented
    750  1.1  jruoho      * (a While(One) loop with a named temp variable created within.)
    751  1.1  jruoho      */
    752  1.1  jruoho 
    753  1.1  jruoho     /*
    754  1.1  jruoho      * If we are creating a named object, check if we are within a while loop
    755  1.1  jruoho      * by checking if the parent is a WHILE op. This is a simple analysis, but
    756  1.1  jruoho      * probably sufficient for many cases.
    757  1.1  jruoho      *
    758  1.1  jruoho      * Allow Scope(), Buffer(), and Package().
    759  1.1  jruoho      */
    760  1.1  jruoho     if (((OpcodeClass == AML_CLASS_NAMED_OBJECT) && (Op->Asl.AmlOpcode != AML_SCOPE_OP)) ||
    761  1.1  jruoho         ((OpcodeClass == AML_CLASS_CREATE) && (OpInfo->Flags & AML_NSNODE)))
    762  1.1  jruoho     {
    763  1.1  jruoho         if (Op->Asl.Parent->Asl.AmlOpcode == AML_WHILE_OP)
    764  1.1  jruoho         {
    765  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_NAMED_OBJECT_IN_WHILE, Op, NULL);
    766  1.1  jruoho         }
    767  1.1  jruoho     }
    768  1.1  jruoho #endif
    769  1.1  jruoho 
    770  1.1  jruoho     /*
    771  1.1  jruoho      * Special case for control opcodes IF/RETURN/WHILE since they
    772  1.1  jruoho      * have no runtime arg list (at this time)
    773  1.1  jruoho      */
    774  1.1  jruoho     switch (Op->Asl.AmlOpcode)
    775  1.1  jruoho     {
    776  1.1  jruoho     case AML_IF_OP:
    777  1.1  jruoho     case AML_WHILE_OP:
    778  1.1  jruoho     case AML_RETURN_OP:
    779  1.1  jruoho 
    780  1.1  jruoho         if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
    781  1.1  jruoho         {
    782  1.1  jruoho             /* Check for an internal method */
    783  1.1  jruoho 
    784  1.1  jruoho             if (AnIsInternalMethod (ArgOp))
    785  1.1  jruoho             {
    786  1.1  jruoho                 return (AE_OK);
    787  1.1  jruoho             }
    788  1.1  jruoho 
    789  1.1  jruoho             /* The lone arg is a method call, check it */
    790  1.1  jruoho 
    791  1.1  jruoho             RequiredBtypes = AnMapArgTypeToBtype (ARGI_INTEGER);
    792  1.1  jruoho             if (Op->Asl.AmlOpcode == AML_RETURN_OP)
    793  1.1  jruoho             {
    794  1.1  jruoho                 RequiredBtypes = 0xFFFFFFFF;
    795  1.1  jruoho             }
    796  1.1  jruoho 
    797  1.1  jruoho             ThisNodeBtype = AnGetBtype (ArgOp);
    798  1.1  jruoho             if (ThisNodeBtype == ACPI_UINT32_MAX)
    799  1.1  jruoho             {
    800  1.1  jruoho                 return (AE_OK);
    801  1.1  jruoho             }
    802  1.1  jruoho             AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
    803  1.1  jruoho                 RequiredBtypes, ThisNodeBtype);
    804  1.1  jruoho         }
    805  1.1  jruoho         return (AE_OK);
    806  1.1  jruoho 
    807  1.1  jruoho     default:
    808  1.1  jruoho         break;
    809  1.1  jruoho     }
    810  1.1  jruoho 
    811  1.1  jruoho     /* Ignore the non-executable opcodes */
    812  1.1  jruoho 
    813  1.1  jruoho     if (RuntimeArgTypes == ARGI_INVALID_OPCODE)
    814  1.1  jruoho     {
    815  1.1  jruoho         return (AE_OK);
    816  1.1  jruoho     }
    817  1.1  jruoho 
    818  1.1  jruoho     switch (OpcodeClass)
    819  1.1  jruoho     {
    820  1.1  jruoho     case AML_CLASS_EXECUTE:
    821  1.1  jruoho     case AML_CLASS_CREATE:
    822  1.1  jruoho     case AML_CLASS_CONTROL:
    823  1.1  jruoho     case AML_CLASS_RETURN_VALUE:
    824  1.1  jruoho 
    825  1.1  jruoho         /* TBD: Change class or fix typechecking for these */
    826  1.1  jruoho 
    827  1.1  jruoho         if ((Op->Asl.AmlOpcode == AML_BUFFER_OP)        ||
    828  1.1  jruoho             (Op->Asl.AmlOpcode == AML_PACKAGE_OP)       ||
    829  1.1  jruoho             (Op->Asl.AmlOpcode == AML_VAR_PACKAGE_OP))
    830  1.1  jruoho         {
    831  1.1  jruoho             break;
    832  1.1  jruoho         }
    833  1.1  jruoho 
    834  1.1  jruoho         /* Reverse the runtime argument list */
    835  1.1  jruoho 
    836  1.1  jruoho         RuntimeArgTypes2 = 0;
    837  1.1  jruoho         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes)))
    838  1.1  jruoho         {
    839  1.1  jruoho             RuntimeArgTypes2 <<= ARG_TYPE_WIDTH;
    840  1.1  jruoho             RuntimeArgTypes2 |= ArgType;
    841  1.1  jruoho             INCREMENT_ARG_LIST (RuntimeArgTypes);
    842  1.1  jruoho         }
    843  1.1  jruoho 
    844  1.1  jruoho         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes2)))
    845  1.1  jruoho         {
    846  1.1  jruoho             RequiredBtypes = AnMapArgTypeToBtype (ArgType);
    847  1.1  jruoho 
    848  1.1  jruoho             ThisNodeBtype = AnGetBtype (ArgOp);
    849  1.1  jruoho             if (ThisNodeBtype == ACPI_UINT32_MAX)
    850  1.1  jruoho             {
    851  1.1  jruoho                 goto NextArgument;
    852  1.1  jruoho             }
    853  1.1  jruoho 
    854  1.1  jruoho             /* Examine the arg based on the required type of the arg */
    855  1.1  jruoho 
    856  1.1  jruoho             switch (ArgType)
    857  1.1  jruoho             {
    858  1.1  jruoho             case ARGI_TARGETREF:
    859  1.1  jruoho 
    860  1.1  jruoho                 if (ArgOp->Asl.ParseOpcode == PARSEOP_ZERO)
    861  1.1  jruoho                 {
    862  1.1  jruoho                     /* ZERO is the placeholder for "don't store result" */
    863  1.1  jruoho 
    864  1.1  jruoho                     ThisNodeBtype = RequiredBtypes;
    865  1.1  jruoho                     break;
    866  1.1  jruoho                 }
    867  1.1  jruoho 
    868  1.1  jruoho                 if (ArgOp->Asl.ParseOpcode == PARSEOP_INTEGER)
    869  1.1  jruoho                 {
    870  1.1  jruoho                     /*
    871  1.1  jruoho                      * This is the case where an original reference to a resource
    872  1.1  jruoho                      * descriptor field has been replaced by an (Integer) offset.
    873  1.1  jruoho                      * These named fields are supported at compile-time only;
    874  1.1  jruoho                      * the names are not passed to the interpreter (via the AML).
    875  1.1  jruoho                      */
    876  1.1  jruoho                     if ((ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
    877  1.1  jruoho                         (ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
    878  1.1  jruoho                     {
    879  1.1  jruoho                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_FIELD, ArgOp, NULL);
    880  1.1  jruoho                     }
    881  1.1  jruoho                     else
    882  1.1  jruoho                     {
    883  1.1  jruoho                         AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, NULL);
    884  1.1  jruoho                     }
    885  1.1  jruoho                     break;
    886  1.1  jruoho                 }
    887  1.1  jruoho 
    888  1.1  jruoho                 if ((ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL) ||
    889  1.1  jruoho                     (ArgOp->Asl.ParseOpcode == PARSEOP_DEREFOF))
    890  1.1  jruoho                 {
    891  1.1  jruoho                     break;
    892  1.1  jruoho                 }
    893  1.1  jruoho 
    894  1.1  jruoho                 ThisNodeBtype = RequiredBtypes;
    895  1.1  jruoho                 break;
    896  1.1  jruoho 
    897  1.1  jruoho 
    898  1.1  jruoho             case ARGI_REFERENCE:            /* References */
    899  1.1  jruoho             case ARGI_INTEGER_REF:
    900  1.1  jruoho             case ARGI_OBJECT_REF:
    901  1.1  jruoho             case ARGI_DEVICE_REF:
    902  1.1  jruoho 
    903  1.1  jruoho                 switch (ArgOp->Asl.ParseOpcode)
    904  1.1  jruoho                 {
    905  1.1  jruoho                 case PARSEOP_LOCAL0:
    906  1.1  jruoho                 case PARSEOP_LOCAL1:
    907  1.1  jruoho                 case PARSEOP_LOCAL2:
    908  1.1  jruoho                 case PARSEOP_LOCAL3:
    909  1.1  jruoho                 case PARSEOP_LOCAL4:
    910  1.1  jruoho                 case PARSEOP_LOCAL5:
    911  1.1  jruoho                 case PARSEOP_LOCAL6:
    912  1.1  jruoho                 case PARSEOP_LOCAL7:
    913  1.1  jruoho 
    914  1.1  jruoho                     /* TBD: implement analysis of current value (type) of the local */
    915  1.1  jruoho                     /* For now, just treat any local as a typematch */
    916  1.1  jruoho 
    917  1.1  jruoho                     /*ThisNodeBtype = RequiredBtypes;*/
    918  1.1  jruoho                     break;
    919  1.1  jruoho 
    920  1.1  jruoho                 case PARSEOP_ARG0:
    921  1.1  jruoho                 case PARSEOP_ARG1:
    922  1.1  jruoho                 case PARSEOP_ARG2:
    923  1.1  jruoho                 case PARSEOP_ARG3:
    924  1.1  jruoho                 case PARSEOP_ARG4:
    925  1.1  jruoho                 case PARSEOP_ARG5:
    926  1.1  jruoho                 case PARSEOP_ARG6:
    927  1.1  jruoho 
    928  1.1  jruoho                     /* Hard to analyze argument types, sow we won't */
    929  1.1  jruoho                     /* For now, just treat any arg as a typematch */
    930  1.1  jruoho 
    931  1.1  jruoho                     /* ThisNodeBtype = RequiredBtypes; */
    932  1.1  jruoho                     break;
    933  1.1  jruoho 
    934  1.1  jruoho                 case PARSEOP_DEBUG:
    935  1.1  jruoho                     break;
    936  1.1  jruoho 
    937  1.1  jruoho                 case PARSEOP_REFOF:
    938  1.1  jruoho                 case PARSEOP_INDEX:
    939  1.1  jruoho                 default:
    940  1.1  jruoho                     break;
    941  1.1  jruoho 
    942  1.1  jruoho                 }
    943  1.1  jruoho                 break;
    944  1.1  jruoho 
    945  1.1  jruoho             case ARGI_INTEGER:
    946  1.1  jruoho             default:
    947  1.1  jruoho                 break;
    948  1.1  jruoho             }
    949  1.1  jruoho 
    950  1.1  jruoho 
    951  1.1  jruoho             CommonBtypes = ThisNodeBtype & RequiredBtypes;
    952  1.1  jruoho 
    953  1.1  jruoho             if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
    954  1.1  jruoho             {
    955  1.1  jruoho                 if (AnIsInternalMethod (ArgOp))
    956  1.1  jruoho                 {
    957  1.1  jruoho                     return (AE_OK);
    958  1.1  jruoho                 }
    959  1.1  jruoho 
    960  1.1  jruoho                 /* Check a method call for a valid return value */
    961  1.1  jruoho 
    962  1.1  jruoho                 AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
    963  1.1  jruoho                     RequiredBtypes, ThisNodeBtype);
    964  1.1  jruoho             }
    965  1.1  jruoho 
    966  1.1  jruoho             /*
    967  1.1  jruoho              * Now check if the actual type(s) match at least one
    968  1.1  jruoho              * bit to the required type
    969  1.1  jruoho              */
    970  1.1  jruoho             else if (!CommonBtypes)
    971  1.1  jruoho             {
    972  1.1  jruoho                 /* No match -- this is a type mismatch error */
    973  1.1  jruoho 
    974  1.1  jruoho                 AnFormatBtype (StringBuffer, ThisNodeBtype);
    975  1.1  jruoho                 AnFormatBtype (StringBuffer2, RequiredBtypes);
    976  1.1  jruoho 
    977  1.1  jruoho                 sprintf (MsgBuffer, "[%s] found, %s operator requires [%s]",
    978  1.1  jruoho                             StringBuffer, OpInfo->Name, StringBuffer2);
    979  1.1  jruoho 
    980  1.1  jruoho                 AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
    981  1.1  jruoho             }
    982  1.1  jruoho 
    983  1.1  jruoho         NextArgument:
    984  1.1  jruoho             ArgOp = ArgOp->Asl.Next;
    985  1.1  jruoho             INCREMENT_ARG_LIST (RuntimeArgTypes2);
    986  1.1  jruoho         }
    987  1.1  jruoho         break;
    988  1.1  jruoho 
    989  1.1  jruoho     default:
    990  1.1  jruoho         break;
    991  1.1  jruoho     }
    992  1.1  jruoho 
    993  1.1  jruoho     return (AE_OK);
    994  1.1  jruoho }
    995  1.1  jruoho 
    996  1.1  jruoho 
    997  1.1  jruoho /*******************************************************************************
    998  1.1  jruoho  *
    999  1.1  jruoho  * FUNCTION:    AnOtherSemanticAnalysisWalkBegin
   1000  1.1  jruoho  *
   1001  1.1  jruoho  * PARAMETERS:  ASL_WALK_CALLBACK
   1002  1.1  jruoho  *
   1003  1.1  jruoho  * RETURN:      Status
   1004  1.1  jruoho  *
   1005  1.1  jruoho  * DESCRIPTION: Descending callback for the analysis walk. Checks for
   1006  1.1  jruoho  *              miscellaneous issues in the code.
   1007  1.1  jruoho  *
   1008  1.1  jruoho  ******************************************************************************/
   1009  1.1  jruoho 
   1010  1.1  jruoho ACPI_STATUS
   1011  1.1  jruoho AnOtherSemanticAnalysisWalkBegin (
   1012  1.1  jruoho     ACPI_PARSE_OBJECT       *Op,
   1013  1.1  jruoho     UINT32                  Level,
   1014  1.1  jruoho     void                    *Context)
   1015  1.1  jruoho {
   1016  1.1  jruoho     ACPI_PARSE_OBJECT       *ArgNode;
   1017  1.1  jruoho     ACPI_PARSE_OBJECT       *PrevArgNode = NULL;
   1018  1.1  jruoho     const ACPI_OPCODE_INFO  *OpInfo;
   1019  1.1  jruoho 
   1020  1.1  jruoho 
   1021  1.1  jruoho     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
   1022  1.1  jruoho 
   1023  1.1  jruoho     /*
   1024  1.1  jruoho      * Determine if an execution class operator actually does something by
   1025  1.1  jruoho      * checking if it has a target and/or the function return value is used.
   1026  1.1  jruoho      * (Target is optional, so a standalone statement can actually do nothing.)
   1027  1.1  jruoho      */
   1028  1.1  jruoho     if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
   1029  1.1  jruoho         (OpInfo->Flags & AML_HAS_RETVAL) &&
   1030  1.1  jruoho         (!AnIsResultUsed (Op)))
   1031  1.1  jruoho     {
   1032  1.1  jruoho         if (OpInfo->Flags & AML_HAS_TARGET)
   1033  1.1  jruoho         {
   1034  1.1  jruoho             /*
   1035  1.1  jruoho              * Find the target node, it is always the last child. If the traget
   1036  1.1  jruoho              * is not specified in the ASL, a default node of type Zero was
   1037  1.1  jruoho              * created by the parser.
   1038  1.1  jruoho              */
   1039  1.1  jruoho             ArgNode = Op->Asl.Child;
   1040  1.1  jruoho             while (ArgNode->Asl.Next)
   1041  1.1  jruoho             {
   1042  1.1  jruoho                 PrevArgNode = ArgNode;
   1043  1.1  jruoho                 ArgNode = ArgNode->Asl.Next;
   1044  1.1  jruoho             }
   1045  1.1  jruoho 
   1046  1.1  jruoho             /* Divide() is the only weird case, it has two targets */
   1047  1.1  jruoho 
   1048  1.1  jruoho             if (Op->Asl.AmlOpcode == AML_DIVIDE_OP)
   1049  1.1  jruoho             {
   1050  1.1  jruoho                 if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) &&
   1051  1.1  jruoho                     (PrevArgNode) &&
   1052  1.1  jruoho                     (PrevArgNode->Asl.ParseOpcode == PARSEOP_ZERO))
   1053  1.1  jruoho                 {
   1054  1.1  jruoho                     AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
   1055  1.1  jruoho                         Op, Op->Asl.ExternalName);
   1056  1.1  jruoho                 }
   1057  1.1  jruoho             }
   1058  1.1  jruoho             else if (ArgNode->Asl.ParseOpcode == PARSEOP_ZERO)
   1059  1.1  jruoho             {
   1060  1.1  jruoho                 AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
   1061  1.1  jruoho                     Op, Op->Asl.ExternalName);
   1062  1.1  jruoho             }
   1063  1.1  jruoho         }
   1064  1.1  jruoho         else
   1065  1.1  jruoho         {
   1066  1.1  jruoho             /*
   1067  1.1  jruoho              * Has no target and the result is not used. Only a couple opcodes
   1068  1.1  jruoho              * can have this combination.
   1069  1.1  jruoho              */
   1070  1.1  jruoho             switch (Op->Asl.ParseOpcode)
   1071  1.1  jruoho             {
   1072  1.1  jruoho             case PARSEOP_ACQUIRE:
   1073  1.1  jruoho             case PARSEOP_WAIT:
   1074  1.1  jruoho             case PARSEOP_LOADTABLE:
   1075  1.1  jruoho                 break;
   1076  1.1  jruoho 
   1077  1.1  jruoho             default:
   1078  1.1  jruoho                 AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
   1079  1.1  jruoho                     Op, Op->Asl.ExternalName);
   1080  1.1  jruoho                 break;
   1081  1.1  jruoho             }
   1082  1.1  jruoho         }
   1083  1.1  jruoho     }
   1084  1.1  jruoho 
   1085  1.1  jruoho 
   1086  1.1  jruoho     /*
   1087  1.1  jruoho      * Semantic checks for individual ASL operators
   1088  1.1  jruoho      */
   1089  1.1  jruoho     switch (Op->Asl.ParseOpcode)
   1090  1.1  jruoho     {
   1091  1.1  jruoho     case PARSEOP_ACQUIRE:
   1092  1.1  jruoho     case PARSEOP_WAIT:
   1093  1.1  jruoho         /*
   1094  1.1  jruoho          * Emit a warning if the timeout parameter for these operators is not
   1095  1.1  jruoho          * ACPI_WAIT_FOREVER, and the result value from the operator is not
   1096  1.1  jruoho          * checked, meaning that a timeout could happen, but the code
   1097  1.1  jruoho          * would not know about it.
   1098  1.1  jruoho          */
   1099  1.1  jruoho 
   1100  1.1  jruoho         /* First child is the namepath, 2nd child is timeout */
   1101  1.1  jruoho 
   1102  1.1  jruoho         ArgNode = Op->Asl.Child;
   1103  1.1  jruoho         ArgNode = ArgNode->Asl.Next;
   1104  1.1  jruoho 
   1105  1.1  jruoho         /*
   1106  1.1  jruoho          * Check for the WAIT_FOREVER case - defined by the ACPI spec to be
   1107  1.1  jruoho          * 0xFFFF or greater
   1108  1.1  jruoho          */
   1109  1.1  jruoho         if (((ArgNode->Asl.ParseOpcode == PARSEOP_WORDCONST) ||
   1110  1.1  jruoho              (ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER))  &&
   1111  1.1  jruoho              (ArgNode->Asl.Value.Integer >= (UINT64) ACPI_WAIT_FOREVER))
   1112  1.1  jruoho         {
   1113  1.1  jruoho             break;
   1114  1.1  jruoho         }
   1115  1.1  jruoho 
   1116  1.1  jruoho         /*
   1117  1.1  jruoho          * The operation could timeout. If the return value is not used
   1118  1.1  jruoho          * (indicates timeout occurred), issue a warning
   1119  1.1  jruoho          */
   1120  1.1  jruoho         if (!AnIsResultUsed (Op))
   1121  1.1  jruoho         {
   1122  1.1  jruoho             AslError (ASL_WARNING, ASL_MSG_TIMEOUT, ArgNode,
   1123  1.1  jruoho                 Op->Asl.ExternalName);
   1124  1.1  jruoho         }
   1125  1.1  jruoho         break;
   1126  1.1  jruoho 
   1127  1.1  jruoho     case PARSEOP_CREATEFIELD:
   1128  1.1  jruoho         /*
   1129  1.1  jruoho          * Check for a zero Length (NumBits) operand. NumBits is the 3rd operand
   1130  1.1  jruoho          */
   1131  1.1  jruoho         ArgNode = Op->Asl.Child;
   1132  1.1  jruoho         ArgNode = ArgNode->Asl.Next;
   1133  1.1  jruoho         ArgNode = ArgNode->Asl.Next;
   1134  1.1  jruoho 
   1135  1.1  jruoho         if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) ||
   1136  1.1  jruoho            ((ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER) &&
   1137  1.1  jruoho             (ArgNode->Asl.Value.Integer == 0)))
   1138  1.1  jruoho         {
   1139  1.1  jruoho             AslError (ASL_ERROR, ASL_MSG_NON_ZERO, ArgNode, NULL);
   1140  1.1  jruoho         }
   1141  1.1  jruoho         break;
   1142  1.1  jruoho 
   1143  1.1  jruoho     default:
   1144  1.1  jruoho         break;
   1145  1.1  jruoho     }
   1146  1.1  jruoho 
   1147  1.1  jruoho     return (AE_OK);
   1148  1.1  jruoho }
   1149