drivers/acpi/compiler/aslanalyze.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslanalyze.c - Support functions for parse tree walks
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "aslcompiler.h"
 117 #include "aslcompiler.y.h"
 118 #include <string.h>
 119
 120
 121 #define _COMPONENT          ACPI_COMPILER
 122         ACPI_MODULE_NAME    ("aslanalyze")
 123
 124
 125 /*******************************************************************************
 126  *
 127  * FUNCTION:    AnIsInternalMethod
 128  *
 129  * PARAMETERS:  Op                  - Current op
 130  *
 131  * RETURN:      Boolean
 132  *
 133  * DESCRIPTION: Check for an internal control method.
 134  *
 135  ******************************************************************************/
 136
 137 BOOLEAN
 138 AnIsInternalMethod (
 139     ACPI_PARSE_OBJECT       *Op)
 140 {
 141
 142     if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
 143         (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
 144     {
 145         return (TRUE);
 146     }
 147
 148     return (FALSE);
 149 }
 150
 151
 152 /*******************************************************************************
 153  *
 154  * FUNCTION:    AnGetInternalMethodReturnType
 155  *
 156  * PARAMETERS:  Op                  - Current op
 157  *
 158  * RETURN:      Btype
 159  *
 160  * DESCRIPTION: Get the return type of an internal method
 161  *
 162  ******************************************************************************/
 163
 164 UINT32
 165 AnGetInternalMethodReturnType (
 166     ACPI_PARSE_OBJECT       *Op)
 167 {
 168
 169     if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
 170         (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
 171     {
 172         return (ACPI_BTYPE_STRING);
 173     }
 174
 175     return (0);
 176 }
 177
 178
 179 /*******************************************************************************
 180  *
 181  * FUNCTION:    AnCheckId
 182  *
 183  * PARAMETERS:  Op                  - Current parse op
 184  *              Type                - HID or CID
 185  *
 186  * RETURN:      None
 187  *
 188  * DESCRIPTION: Perform various checks on _HID and _CID strings. Only limited
 189  *              checks can be performed on _CID strings.
 190  *
 191  ******************************************************************************/
 192
 193 void
 194 AnCheckId (
 195     ACPI_PARSE_OBJECT       *Op,
 196     ACPI_NAME               Type)
 197 {
 198     UINT32                  i;
 199     ACPI_SIZE               Length;
 200
 201
 202     /* Only care about string versions of _HID/_CID (integers are legal) */
 203
 204     if (Op->Asl.ParseOpcode != PARSEOP_STRING_LITERAL)
 205     {
 206         return;
 207     }
 208
 209     /* For both _HID and _CID, the string must be non-null */
 210
 211     Length = strlen (Op->Asl.Value.String);
 212     if (!Length)
 213     {
 214         AslError (ASL_ERROR, ASL_MSG_NULL_STRING,
 215             Op, NULL);
 216         return;
 217     }
 218
 219     /*
 220      * One of the things we want to catch here is the use of a leading
 221      * asterisk in the string -- an odd construct that certain platform
 222      * manufacturers are fond of. Technically, a leading asterisk is OK
 223      * for _CID, but a valid use of this has not been seen.
 224      */
 225     if (*Op->Asl.Value.String == '*')
 226     {
 227         AslError (ASL_ERROR, ASL_MSG_LEADING_ASTERISK,
 228             Op, Op->Asl.Value.String);
 229         return;
 230     }
 231
 232     /* _CID strings are bus-specific, no more checks can be performed */
 233
 234     if (Type == ASL_TYPE_CID)
 235     {
 236         return;
 237     }
 238
 239     /* For _HID, all characters must be alphanumeric */
 240
 241     for (i = 0; Op->Asl.Value.String[i]; i++)
 242     {
 243         if (!isalnum ((int) Op->Asl.Value.String[i]))
 244         {
 245             AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
 246                 Op, Op->Asl.Value.String);
 247             return;
 248         }
 249     }
 250
 251     /*
 252      * _HID String must be one of these forms:
 253      *
 254      * "AAA####"    A is an uppercase letter and # is a hex digit
 255      * "ACPI####"   # is a hex digit
 256      * "NNNN####"   N is an uppercase letter or decimal digit (0-9)
 257      *              # is a hex digit (ACPI 5.0)
 258      */
 259     if ((Length < 7) || (Length > 8))
 260     {
 261         AslError (ASL_ERROR, ASL_MSG_HID_LENGTH,
 262             Op, Op->Asl.Value.String);
 263         return;
 264     }
 265
 266     /* _HID Length is valid (7 or 8), now check the prefix (first 3 or 4 chars) */
 267
 268     if (Length == 7)
 269     {
 270         /* AAA####: Ensure the alphabetic prefix is all uppercase */
 271
 272         for (i = 0; i < 3; i++)
 273         {
 274             if (!isupper ((int) Op->Asl.Value.String[i]))
 275             {
 276                 AslError (ASL_ERROR, ASL_MSG_UPPER_CASE,
 277                     Op, &Op->Asl.Value.String[i]);
 278                 return;
 279             }
 280         }
 281     }
 282     else /* Length == 8 */
 283     {
 284         /*
 285          * ACPI#### or NNNN####:
 286          * Ensure the prefix contains only uppercase alpha or decimal digits
 287          */
 288         for (i = 0; i < 4; i++)
 289         {
 290             if (!isupper ((int) Op->Asl.Value.String[i]) &&
 291                 !isdigit ((int) Op->Asl.Value.String[i]))
 292             {
 293                 AslError (ASL_ERROR, ASL_MSG_HID_PREFIX,
 294                     Op, &Op->Asl.Value.String[i]);
 295                 return;
 296             }
 297         }
 298     }
 299
 300     /* Remaining characters (suffix) must be hex digits */
 301
 302     for (; i < Length; i++)
 303     {
 304         if (!isxdigit ((int) Op->Asl.Value.String[i]))
 305         {
 306          AslError (ASL_ERROR, ASL_MSG_HID_SUFFIX,
 307             Op, &Op->Asl.Value.String[i]);
 308             break;
 309         }
 310     }
 311 }
 312
 313
 314 /*******************************************************************************
 315  *
 316  * FUNCTION:    AnLastStatementIsReturn
 317  *
 318  * PARAMETERS:  Op                  - A method parse node
 319  *
 320  * RETURN:      TRUE if last statement is an ASL RETURN. False otherwise
 321  *
 322  * DESCRIPTION: Walk down the list of top level statements within a method
 323  *              to find the last one. Check if that last statement is in
 324  *              fact a RETURN statement.
 325  *
 326  ******************************************************************************/
 327
 328 BOOLEAN
 329 AnLastStatementIsReturn (
 330     ACPI_PARSE_OBJECT       *Op)
 331 {
 332     ACPI_PARSE_OBJECT       *Next;
 333
 334
 335     /* Check if last statement is a return */
 336
 337     Next = ASL_GET_CHILD_NODE (Op);
 338     while (Next)
 339     {
 340         if ((!Next->Asl.Next) &&
 341             (Next->Asl.ParseOpcode == PARSEOP_RETURN))
 342         {
 343             return (TRUE);
 344         }
 345
 346         Next = ASL_GET_PEER_NODE (Next);
 347     }
 348
 349     return (FALSE);
 350 }
 351
 352
 353 /*******************************************************************************
 354  *
 355  * FUNCTION:    AnCheckMethodReturnValue
 356  *
 357  * PARAMETERS:  Op                  - Parent
 358  *              OpInfo              - Parent info
 359  *              ArgOp               - Method invocation op
 360  *              RequiredBtypes      - What caller requires
 361  *              ThisNodeBtype       - What this node returns (if anything)
 362  *
 363  * RETURN:      None
 364  *
 365  * DESCRIPTION: Check a method invocation for 1) A return value and if it does
 366  *              in fact return a value, 2) check the type of the return value.
 367  *
 368  ******************************************************************************/
 369
 370 void
 371 AnCheckMethodReturnValue (
 372     ACPI_PARSE_OBJECT       *Op,
 373     const ACPI_OPCODE_INFO  *OpInfo,
 374     ACPI_PARSE_OBJECT       *ArgOp,
 375     UINT32                  RequiredBtypes,
 376     UINT32                  ThisNodeBtype)
 377 {
 378     ACPI_PARSE_OBJECT       *OwningOp;
 379     ACPI_NAMESPACE_NODE     *Node;
 380
 381
 382     Node = ArgOp->Asl.Node;
 383
 384
 385     /* Examine the parent op of this method */
 386
 387     OwningOp = Node->Op;
 388     if (OwningOp->Asl.CompileFlags & NODE_METHOD_NO_RETVAL)
 389     {
 390         /* Method NEVER returns a value */
 391
 392         AslError (ASL_ERROR, ASL_MSG_NO_RETVAL, Op, Op->Asl.ExternalName);
 393     }
 394     else if (OwningOp->Asl.CompileFlags & NODE_METHOD_SOME_NO_RETVAL)
 395     {
 396         /* Method SOMETIMES returns a value, SOMETIMES not */
 397
 398         AslError (ASL_WARNING, ASL_MSG_SOME_NO_RETVAL, Op, Op->Asl.ExternalName);
 399     }
 400     else if (!(ThisNodeBtype & RequiredBtypes))
 401     {
 402         /* Method returns a value, but the type is wrong */
 403
 404         AnFormatBtype (StringBuffer, ThisNodeBtype);
 405         AnFormatBtype (StringBuffer2, RequiredBtypes);
 406
 407         /*
 408          * The case where the method does not return any value at all
 409          * was already handled in the namespace cross reference
 410          * -- Only issue an error if the method in fact returns a value,
 411          * but it is of the wrong type
 412          */
 413         if (ThisNodeBtype != 0)
 414         {
 415             sprintf (MsgBuffer,
 416                 "Method returns [%s], %s operator requires [%s]",
 417                 StringBuffer, OpInfo->Name, StringBuffer2);
 418
 419             AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
 420         }
 421     }
 422 }
 423
 424
 425 /*******************************************************************************
 426  *
 427  * FUNCTION:    AnIsResultUsed
 428  *
 429  * PARAMETERS:  Op                  - Parent op for the operator
 430  *
 431  * RETURN:      TRUE if result from this operation is actually consumed
 432  *
 433  * DESCRIPTION: Determine if the function result value from an operator is
 434  *              used.
 435  *
 436  ******************************************************************************/
 437
 438 BOOLEAN
 439 AnIsResultUsed (
 440     ACPI_PARSE_OBJECT       *Op)
 441 {
 442     ACPI_PARSE_OBJECT       *Parent;
 443
 444
 445     switch (Op->Asl.ParseOpcode)
 446     {
 447     case PARSEOP_INCREMENT:
 448     case PARSEOP_DECREMENT:
 449
 450         /* These are standalone operators, no return value */
 451
 452         return (TRUE);
 453
 454     default:
 455
 456         break;
 457     }
 458
 459     /* Examine parent to determine if the return value is used */
 460
 461     Parent = Op->Asl.Parent;
 462     switch (Parent->Asl.ParseOpcode)
 463     {
 464     /* If/While - check if the operator is the predicate */
 465
 466     case PARSEOP_IF:
 467     case PARSEOP_WHILE:
 468
 469         /* First child is the predicate */
 470
 471         if (Parent->Asl.Child == Op)
 472         {
 473             return (TRUE);
 474         }
 475         return (FALSE);
 476
 477     /* Not used if one of these is the parent */
 478
 479     case PARSEOP_METHOD:
 480     case PARSEOP_DEFINITIONBLOCK:
 481     case PARSEOP_ELSE:
 482
 483         return (FALSE);
 484
 485     default:
 486
 487         /* Any other type of parent means that the result is used */
 488
 489         return (TRUE);
 490     }
 491 }
 492
 493
 494 /*******************************************************************************
 495  *
 496  * FUNCTION:    ApCheckForGpeNameConflict
 497  *
 498  * PARAMETERS:  Op                  - Current parse op
 499  *
 500  * RETURN:      None
 501  *
 502  * DESCRIPTION: Check for a conflict between GPE names within this scope.
 503  *              Conflict means two GPE names with the same GPE number, but
 504  *              different types -- such as _L1C and _E1C.
 505  *
 506  ******************************************************************************/
 507
 508 void
 509 ApCheckForGpeNameConflict (
 510     ACPI_PARSE_OBJECT       *Op)
 511 {
 512     ACPI_PARSE_OBJECT       *NextOp;
 513     UINT32                  GpeNumber;
 514     char                    Name[ACPI_NAME_SIZE + 1];
 515     char                    Target[ACPI_NAME_SIZE];
 516
 517
 518     /* Need a null-terminated string version of NameSeg */
 519
 520     ACPI_MOVE_32_TO_32 (Name, &Op->Asl.NameSeg);
 521     Name[ACPI_NAME_SIZE] = 0;
 522
 523     /*
 524      * For a GPE method:
 525      * 1st char must be underscore
 526      * 2nd char must be L or E
 527      * 3rd/4th chars must be a hex number
 528      */
 529     if ((Name[0] != '_') ||
 530        ((Name[1] != 'L') && (Name[1] != 'E')))
 531     {
 532         return;
 533     }
 534
 535     /* Verify 3rd/4th chars are a valid hex value */
 536
 537     GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16);
 538     if (GpeNumber == ACPI_UINT32_MAX)
 539     {
 540         return;
 541     }
 542
 543     /*
 544      * We are now sure we have an _Lxx or _Exx.
 545      * Create the target name that would cause collision (Flip E/L)
 546      */
 547     ACPI_MOVE_32_TO_32 (Target, Name);
 548
 549     /* Inject opposite letter ("L" versus "E") */
 550
 551     if (Name[1] == 'L')
 552     {
 553         Target[1] = 'E';
 554     }
 555     else /* Name[1] == 'E' */
 556     {
 557         Target[1] = 'L';
 558     }
 559
 560     /* Search all peers (objects within this scope) for target match */
 561
 562     NextOp = Op->Asl.Next;
 563     while (NextOp)
 564     {
 565         /*
 566          * We mostly care about methods, but check Name() constructs also,
 567          * even though they will get another error for not being a method.
 568          * All GPE names must be defined as control methods.
 569          */
 570         if ((NextOp->Asl.ParseOpcode == PARSEOP_METHOD) ||
 571             (NextOp->Asl.ParseOpcode == PARSEOP_NAME))
 572         {
 573             if (ACPI_COMPARE_NAME (Target, NextOp->Asl.NameSeg))
 574             {
 575                 /* Found both _Exy and _Lxy in the same scope, error */
 576
 577                 AslError (ASL_ERROR, ASL_MSG_GPE_NAME_CONFLICT, NextOp,
 578                     Name);
 579                 return;
 580             }
 581         }
 582
 583         NextOp = NextOp->Asl.Next;
 584     }
 585
 586     /* OK, no conflict found */
 587
 588     return;
 589 }
 590
 591
 592 /*******************************************************************************
 593  *
 594  * FUNCTION:    ApCheckRegMethod
 595  *
 596  * PARAMETERS:  Op                  - Current parse op
 597  *
 598  * RETURN:      None
 599  *
 600  * DESCRIPTION: Ensure that a _REG method has a corresponding Operation
 601  *              Region declaration within the same scope. Note: _REG is defined
 602  *              to have two arguments and must therefore be defined as a
 603  *              control method.
 604  *
 605  ******************************************************************************/
 606
 607 void
 608 ApCheckRegMethod (
 609     ACPI_PARSE_OBJECT       *Op)
 610 {
 611     ACPI_PARSE_OBJECT       *Next;
 612     ACPI_PARSE_OBJECT       *Parent;
 613
 614
 615     /* We are only interested in _REG methods */
 616
 617     if (!ACPI_COMPARE_NAME (METHOD_NAME__REG, &Op->Asl.NameSeg))
 618     {
 619         return;
 620     }
 621
 622     /* Get the start of the current scope */
 623
 624     Parent = Op->Asl.Parent;
 625     Next = Parent->Asl.Child;
 626
 627     /* Search entire scope for an operation region declaration */
 628
 629     while (Next)
 630     {
 631         if (Next->Asl.ParseOpcode == PARSEOP_OPERATIONREGION)
 632         {
 633             return; /* Found region, OK */
 634         }
 635
 636         Next = Next->Asl.Next;
 637     }
 638
 639     /* No region found, issue warning */
 640
 641     AslError (ASL_WARNING, ASL_MSG_NO_REGION, Op, NULL);
 642 }
 643
 644
 645 /*******************************************************************************
 646  *
 647  * FUNCTION:    ApFindNameInScope
 648  *
 649  * PARAMETERS:  Name                - Name to search for
 650  *              Op                  - Current parse op
 651  *
 652  * RETURN:      TRUE if name found in the same scope as Op.
 653  *
 654  * DESCRIPTION: Determine if a name appears in the same scope as Op, as either
 655  *              a Method() or a Name().
 656  *
 657  ******************************************************************************/
 658
 659 BOOLEAN
 660 ApFindNameInScope (
 661     char                    *Name,
 662     ACPI_PARSE_OBJECT       *Op)
 663 {
 664     ACPI_PARSE_OBJECT       *Next;
 665     ACPI_PARSE_OBJECT       *Parent;
 666
 667
 668     /* Get the start of the current scope */
 669
 670     Parent = Op->Asl.Parent;
 671     Next = Parent->Asl.Child;
 672
 673     /* Search entire scope for a match to the name */
 674
 675     while (Next)
 676     {
 677         if ((Next->Asl.ParseOpcode == PARSEOP_METHOD) ||
 678             (Next->Asl.ParseOpcode == PARSEOP_NAME))
 679         {
 680             if (ACPI_COMPARE_NAME (Name, Next->Asl.NameSeg))
 681             {
 682                 return (TRUE);
 683             }
 684         }
 685
 686         Next = Next->Asl.Next;
 687     }
 688
 689     return (FALSE);
 690 }