arch/all-pc/acpica/source/compiler/aslanalyze.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslanalyze.c - Support functions for parse tree walks
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include "aslcompiler.h"
  46 #include "aslcompiler.y.h"
  47 #include <string.h>
  48
  49
  50 #define _COMPONENT          ACPI_COMPILER
  51         ACPI_MODULE_NAME    ("aslanalyze")
  52
  53
  54 /*******************************************************************************
  55  *
  56  * FUNCTION:    AnIsInternalMethod
  57  *
  58  * PARAMETERS:  Op                  - Current op
  59  *
  60  * RETURN:      Boolean
  61  *
  62  * DESCRIPTION: Check for an internal control method.
  63  *
  64  ******************************************************************************/
  65
  66 BOOLEAN
  67 AnIsInternalMethod (
  68     ACPI_PARSE_OBJECT       *Op)
  69 {
  70
  71     if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
  72         (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
  73     {
  74         return (TRUE);
  75     }
  76
  77     return (FALSE);
  78 }
  79
  80
  81 /*******************************************************************************
  82  *
  83  * FUNCTION:    AnGetInternalMethodReturnType
  84  *
  85  * PARAMETERS:  Op                  - Current op
  86  *
  87  * RETURN:      Btype
  88  *
  89  * DESCRIPTION: Get the return type of an internal method
  90  *
  91  ******************************************************************************/
  92
  93 UINT32
  94 AnGetInternalMethodReturnType (
  95     ACPI_PARSE_OBJECT       *Op)
  96 {
  97
  98     if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
  99         (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
 100     {
 101         return (ACPI_BTYPE_STRING);
 102     }
 103
 104     return (0);
 105 }
 106
 107
 108 /*******************************************************************************
 109  *
 110  * FUNCTION:    AnCheckId
 111  *
 112  * PARAMETERS:  Op                  - Current parse op
 113  *              Type                - HID or CID
 114  *
 115  * RETURN:      None
 116  *
 117  * DESCRIPTION: Perform various checks on _HID and _CID strings. Only limited
 118  *              checks can be performed on _CID strings.
 119  *
 120  ******************************************************************************/
 121
 122 void
 123 AnCheckId (
 124     ACPI_PARSE_OBJECT       *Op,
 125     ACPI_NAME               Type)
 126 {
 127     UINT32                  i;
 128     ACPI_SIZE               Length;
 129
 130
 131     /* Only care about string versions of _HID/_CID (integers are legal) */
 132
 133     if (Op->Asl.ParseOpcode != PARSEOP_STRING_LITERAL)
 134     {
 135         return;
 136     }
 137
 138     /* For both _HID and _CID, the string must be non-null */
 139
 140     Length = strlen (Op->Asl.Value.String);
 141     if (!Length)
 142     {
 143         AslError (ASL_ERROR, ASL_MSG_NULL_STRING,
 144             Op, NULL);
 145         return;
 146     }
 147
 148     /*
 149      * One of the things we want to catch here is the use of a leading
 150      * asterisk in the string -- an odd construct that certain platform
 151      * manufacturers are fond of. Technically, a leading asterisk is OK
 152      * for _CID, but a valid use of this has not been seen.
 153      */
 154     if (*Op->Asl.Value.String == '*')
 155     {
 156         AslError (ASL_ERROR, ASL_MSG_LEADING_ASTERISK,
 157             Op, Op->Asl.Value.String);
 158         return;
 159     }
 160
 161     /* _CID strings are bus-specific, no more checks can be performed */
 162
 163     if (Type == ASL_TYPE_CID)
 164     {
 165         return;
 166     }
 167
 168     /* For _HID, all characters must be alphanumeric */
 169
 170     for (i = 0; Op->Asl.Value.String[i]; i++)
 171     {
 172         if (!isalnum ((int) Op->Asl.Value.String[i]))
 173         {
 174             AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
 175                 Op, Op->Asl.Value.String);
 176             return;
 177         }
 178     }
 179
 180     /*
 181      * _HID String must be one of these forms:
 182      *
 183      * "AAA####"    A is an uppercase letter and # is a hex digit
 184      * "ACPI####"   # is a hex digit
 185      * "NNNN####"   N is an uppercase letter or decimal digit (0-9)
 186      *              # is a hex digit (ACPI 5.0)
 187      */
 188     if ((Length < 7) || (Length > 8))
 189     {
 190         AslError (ASL_ERROR, ASL_MSG_HID_LENGTH,
 191             Op, Op->Asl.Value.String);
 192         return;
 193     }
 194
 195     /* _HID Length is valid (7 or 8), now check the prefix (first 3 or 4 chars) */
 196
 197     if (Length == 7)
 198     {
 199         /* AAA####: Ensure the alphabetic prefix is all uppercase */
 200
 201         for (i = 0; i < 3; i++)
 202         {
 203             if (!isupper ((int) Op->Asl.Value.String[i]))
 204             {
 205                 AslError (ASL_ERROR, ASL_MSG_UPPER_CASE,
 206                     Op, &Op->Asl.Value.String[i]);
 207                 return;
 208             }
 209         }
 210     }
 211     else /* Length == 8 */
 212     {
 213         /*
 214          * ACPI#### or NNNN####:
 215          * Ensure the prefix contains only uppercase alpha or decimal digits
 216          */
 217         for (i = 0; i < 4; i++)
 218         {
 219             if (!isupper ((int) Op->Asl.Value.String[i]) &&
 220                 !isdigit ((int) Op->Asl.Value.String[i]))
 221             {
 222                 AslError (ASL_ERROR, ASL_MSG_HID_PREFIX,
 223                     Op, &Op->Asl.Value.String[i]);
 224                 return;
 225             }
 226         }
 227     }
 228
 229     /* Remaining characters (suffix) must be hex digits */
 230
 231     for (; i < Length; i++)
 232     {
 233         if (!isxdigit ((int) Op->Asl.Value.String[i]))
 234         {
 235          AslError (ASL_ERROR, ASL_MSG_HID_SUFFIX,
 236             Op, &Op->Asl.Value.String[i]);
 237             break;
 238         }
 239     }
 240 }
 241
 242
 243 /*******************************************************************************
 244  *
 245  * FUNCTION:    AnLastStatementIsReturn
 246  *
 247  * PARAMETERS:  Op                  - A method parse node
 248  *
 249  * RETURN:      TRUE if last statement is an ASL RETURN. False otherwise
 250  *
 251  * DESCRIPTION: Walk down the list of top level statements within a method
 252  *              to find the last one. Check if that last statement is in
 253  *              fact a RETURN statement.
 254  *
 255  ******************************************************************************/
 256
 257 BOOLEAN
 258 AnLastStatementIsReturn (
 259     ACPI_PARSE_OBJECT       *Op)
 260 {
 261     ACPI_PARSE_OBJECT       *Next;
 262
 263
 264     /* Check if last statement is a return */
 265
 266     Next = ASL_GET_CHILD_NODE (Op);
 267     while (Next)
 268     {
 269         if ((!Next->Asl.Next) &&
 270             (Next->Asl.ParseOpcode == PARSEOP_RETURN))
 271         {
 272             return (TRUE);
 273         }
 274
 275         Next = ASL_GET_PEER_NODE (Next);
 276     }
 277
 278     return (FALSE);
 279 }
 280
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    AnCheckMethodReturnValue
 285  *
 286  * PARAMETERS:  Op                  - Parent
 287  *              OpInfo              - Parent info
 288  *              ArgOp               - Method invocation op
 289  *              RequiredBtypes      - What caller requires
 290  *              ThisNodeBtype       - What this node returns (if anything)
 291  *
 292  * RETURN:      None
 293  *
 294  * DESCRIPTION: Check a method invocation for 1) A return value and if it does
 295  *              in fact return a value, 2) check the type of the return value.
 296  *
 297  ******************************************************************************/
 298
 299 void
 300 AnCheckMethodReturnValue (
 301     ACPI_PARSE_OBJECT       *Op,
 302     const ACPI_OPCODE_INFO  *OpInfo,
 303     ACPI_PARSE_OBJECT       *ArgOp,
 304     UINT32                  RequiredBtypes,
 305     UINT32                  ThisNodeBtype)
 306 {
 307     ACPI_PARSE_OBJECT       *OwningOp;
 308     ACPI_NAMESPACE_NODE     *Node;
 309
 310
 311     Node = ArgOp->Asl.Node;
 312
 313
 314     /* Examine the parent op of this method */
 315
 316     OwningOp = Node->Op;
 317     if (OwningOp->Asl.CompileFlags & NODE_METHOD_NO_RETVAL)
 318     {
 319         /* Method NEVER returns a value */
 320
 321         AslError (ASL_ERROR, ASL_MSG_NO_RETVAL, Op, Op->Asl.ExternalName);
 322     }
 323     else if (OwningOp->Asl.CompileFlags & NODE_METHOD_SOME_NO_RETVAL)
 324     {
 325         /* Method SOMETIMES returns a value, SOMETIMES not */
 326
 327         AslError (ASL_WARNING, ASL_MSG_SOME_NO_RETVAL, Op, Op->Asl.ExternalName);
 328     }
 329     else if (!(ThisNodeBtype & RequiredBtypes))
 330     {
 331         /* Method returns a value, but the type is wrong */
 332
 333         AnFormatBtype (StringBuffer, ThisNodeBtype);
 334         AnFormatBtype (StringBuffer2, RequiredBtypes);
 335
 336         /*
 337          * The case where the method does not return any value at all
 338          * was already handled in the namespace cross reference
 339          * -- Only issue an error if the method in fact returns a value,
 340          * but it is of the wrong type
 341          */
 342         if (ThisNodeBtype != 0)
 343         {
 344             sprintf (MsgBuffer,
 345                 "Method returns [%s], %s operator requires [%s]",
 346                 StringBuffer, OpInfo->Name, StringBuffer2);
 347
 348             AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
 349         }
 350     }
 351 }
 352
 353
 354 /*******************************************************************************
 355  *
 356  * FUNCTION:    AnIsResultUsed
 357  *
 358  * PARAMETERS:  Op                  - Parent op for the operator
 359  *
 360  * RETURN:      TRUE if result from this operation is actually consumed
 361  *
 362  * DESCRIPTION: Determine if the function result value from an operator is
 363  *              used.
 364  *
 365  ******************************************************************************/
 366
 367 BOOLEAN
 368 AnIsResultUsed (
 369     ACPI_PARSE_OBJECT       *Op)
 370 {
 371     ACPI_PARSE_OBJECT       *Parent;
 372
 373
 374     switch (Op->Asl.ParseOpcode)
 375     {
 376     case PARSEOP_INCREMENT:
 377     case PARSEOP_DECREMENT:
 378
 379         /* These are standalone operators, no return value */
 380
 381         return (TRUE);
 382
 383     default:
 384
 385         break;
 386     }
 387
 388     /* Examine parent to determine if the return value is used */
 389
 390     Parent = Op->Asl.Parent;
 391     switch (Parent->Asl.ParseOpcode)
 392     {
 393     /* If/While - check if the operator is the predicate */
 394
 395     case PARSEOP_IF:
 396     case PARSEOP_WHILE:
 397
 398         /* First child is the predicate */
 399
 400         if (Parent->Asl.Child == Op)
 401         {
 402             return (TRUE);
 403         }
 404         return (FALSE);
 405
 406     /* Not used if one of these is the parent */
 407
 408     case PARSEOP_METHOD:
 409     case PARSEOP_DEFINITIONBLOCK:
 410     case PARSEOP_ELSE:
 411
 412         return (FALSE);
 413
 414     default:
 415
 416         /* Any other type of parent means that the result is used */
 417
 418         return (TRUE);
 419     }
 420 }
 421
 422
 423 /*******************************************************************************
 424  *
 425  * FUNCTION:    ApCheckForGpeNameConflict
 426  *
 427  * PARAMETERS:  Op                  - Current parse op
 428  *
 429  * RETURN:      None
 430  *
 431  * DESCRIPTION: Check for a conflict between GPE names within this scope.
 432  *              Conflict means two GPE names with the same GPE number, but
 433  *              different types -- such as _L1C and _E1C.
 434  *
 435  ******************************************************************************/
 436
 437 void
 438 ApCheckForGpeNameConflict (
 439     ACPI_PARSE_OBJECT       *Op)
 440 {
 441     ACPI_PARSE_OBJECT       *NextOp;
 442     UINT32                  GpeNumber;
 443     char                    Name[ACPI_NAME_SIZE + 1];
 444     char                    Target[ACPI_NAME_SIZE];
 445
 446
 447     /* Need a null-terminated string version of NameSeg */
 448
 449     ACPI_MOVE_32_TO_32 (Name, &Op->Asl.NameSeg);
 450     Name[ACPI_NAME_SIZE] = 0;
 451
 452     /*
 453      * For a GPE method:
 454      * 1st char must be underscore
 455      * 2nd char must be L or E
 456      * 3rd/4th chars must be a hex number
 457      */
 458     if ((Name[0] != '_') ||
 459        ((Name[1] != 'L') && (Name[1] != 'E')))
 460     {
 461         return;
 462     }
 463
 464     /* Verify 3rd/4th chars are a valid hex value */
 465
 466     GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16);
 467     if (GpeNumber == ACPI_UINT32_MAX)
 468     {
 469         return;
 470     }
 471
 472     /*
 473      * We are now sure we have an _Lxx or _Exx.
 474      * Create the target name that would cause collision (Flip E/L)
 475      */
 476     ACPI_MOVE_32_TO_32 (Target, Name);
 477
 478     /* Inject opposite letter ("L" versus "E") */
 479
 480     if (Name[1] == 'L')
 481     {
 482         Target[1] = 'E';
 483     }
 484     else /* Name[1] == 'E' */
 485     {
 486         Target[1] = 'L';
 487     }
 488
 489     /* Search all peers (objects within this scope) for target match */
 490
 491     NextOp = Op->Asl.Next;
 492     while (NextOp)
 493     {
 494         /*
 495          * We mostly care about methods, but check Name() constructs also,
 496          * even though they will get another error for not being a method.
 497          * All GPE names must be defined as control methods.
 498          */
 499         if ((NextOp->Asl.ParseOpcode == PARSEOP_METHOD) ||
 500             (NextOp->Asl.ParseOpcode == PARSEOP_NAME))
 501         {
 502             if (ACPI_COMPARE_NAME (Target, NextOp->Asl.NameSeg))
 503             {
 504                 /* Found both _Exy and _Lxy in the same scope, error */
 505
 506                 AslError (ASL_ERROR, ASL_MSG_GPE_NAME_CONFLICT, NextOp,
 507                     Name);
 508                 return;
 509             }
 510         }
 511
 512         NextOp = NextOp->Asl.Next;
 513     }
 514
 515     /* OK, no conflict found */
 516
 517     return;
 518 }
 519
 520
 521 /*******************************************************************************
 522  *
 523  * FUNCTION:    ApCheckRegMethod
 524  *
 525  * PARAMETERS:  Op                  - Current parse op
 526  *
 527  * RETURN:      None
 528  *
 529  * DESCRIPTION: Ensure that a _REG method has a corresponding Operation
 530  *              Region declaration within the same scope. Note: _REG is defined
 531  *              to have two arguments and must therefore be defined as a
 532  *              control method.
 533  *
 534  ******************************************************************************/
 535
 536 void
 537 ApCheckRegMethod (
 538     ACPI_PARSE_OBJECT       *Op)
 539 {
 540     ACPI_PARSE_OBJECT       *Next;
 541     ACPI_PARSE_OBJECT       *Parent;
 542
 543
 544     /* We are only interested in _REG methods */
 545
 546     if (!ACPI_COMPARE_NAME (METHOD_NAME__REG, &Op->Asl.NameSeg))
 547     {
 548         return;
 549     }
 550
 551     /* Get the start of the current scope */
 552
 553     Parent = Op->Asl.Parent;
 554     Next = Parent->Asl.Child;
 555
 556     /* Search entire scope for an operation region declaration */
 557
 558     while (Next)
 559     {
 560         if (Next->Asl.ParseOpcode == PARSEOP_OPERATIONREGION)
 561         {
 562             return; /* Found region, OK */
 563         }
 564
 565         Next = Next->Asl.Next;
 566     }
 567
 568     /* No region found, issue warning */
 569
 570     AslError (ASL_WARNING, ASL_MSG_NO_REGION, Op, NULL);
 571 }