drivers/acpi/compiler/prmacros.c

   1 /******************************************************************************
   2  *
   3  * Module Name: prmacros - Preprocessor #define macro support
   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 "dtcompiler.h"
 118
 119
 120 #define _COMPONENT          ASL_PREPROCESSOR
 121         ACPI_MODULE_NAME    ("prmacros")
 122
 123
 124 /*******************************************************************************
 125  *
 126  * FUNCTION:    PrDumpPredefinedNames
 127  *
 128  * PARAMETERS:  None
 129  *
 130  * RETURN:      None
 131  *
 132  * DESCRIPTION: Dump the list of #defines. Used as the preprocessor starts, to
 133  *              display the names that were defined on the command line.
 134  *              Debug information only.
 135  *
 136  ******************************************************************************/
 137
 138 void
 139 PrDumpPredefinedNames (
 140     void)
 141 {
 142     PR_DEFINE_INFO          *DefineInfo;
 143
 144
 145     DefineInfo = Gbl_DefineList;
 146     while (DefineInfo)
 147     {
 148         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 149             "Predefined #define: %s->%s\n",
 150             0, DefineInfo->Identifier, DefineInfo->Replacement);
 151
 152         DefineInfo = DefineInfo->Next;
 153     }
 154 }
 155
 156
 157 /*******************************************************************************
 158  *
 159  * FUNCTION:    PrAddDefine
 160  *
 161  * PARAMETERS:  Identifier          - Name to be replaced
 162  *              Replacement         - Replacement for Identifier
 163  *              Persist             - Keep define across multiple compiles?
 164  *
 165  * RETURN:      A new define_info struct. NULL on error.
 166  *
 167  * DESCRIPTION: Add a new #define to the global list
 168  *
 169  ******************************************************************************/
 170
 171 PR_DEFINE_INFO *
 172 PrAddDefine (
 173     char                    *Identifier,
 174     char                    *Replacement,
 175     BOOLEAN                 Persist)
 176 {
 177     char                    *IdentifierString;
 178     char                    *ReplacementString;
 179     PR_DEFINE_INFO          *DefineInfo;
 180
 181
 182     if (!Replacement)
 183     {
 184         Replacement = "";
 185     }
 186
 187     /* Check for already-defined first */
 188
 189     DefineInfo = PrMatchDefine (Identifier);
 190     if (DefineInfo)
 191     {
 192         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID,
 193             "#define: name already exists: %s\n",
 194             Gbl_CurrentLineNumber, Identifier);
 195
 196         /*
 197          * Name already exists. This is only an error if the target name
 198          * is different.
 199          */
 200         if (strcmp (Replacement, DefineInfo->Replacement))
 201         {
 202             PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
 203                 THIS_TOKEN_OFFSET (Identifier));
 204
 205             return (NULL);
 206         }
 207
 208         return (DefineInfo);
 209     }
 210
 211     /* Copy input strings */
 212
 213     IdentifierString = UtLocalCalloc (strlen (Identifier) + 1);
 214     strcpy (IdentifierString, Identifier);
 215
 216     ReplacementString = UtLocalCalloc (strlen (Replacement) + 1);
 217     strcpy (ReplacementString, Replacement);
 218
 219     /* Init and link new define info struct */
 220
 221     DefineInfo = UtLocalCalloc (sizeof (PR_DEFINE_INFO));
 222     DefineInfo->Replacement = ReplacementString;
 223     DefineInfo->Identifier = IdentifierString;
 224     DefineInfo->Persist = Persist;
 225
 226     if (Gbl_DefineList)
 227     {
 228         Gbl_DefineList->Previous = DefineInfo;
 229     }
 230
 231     DefineInfo->Next = Gbl_DefineList;
 232     Gbl_DefineList = DefineInfo;
 233     return (DefineInfo);
 234 }
 235
 236
 237 /*******************************************************************************
 238  *
 239  * FUNCTION:    PrRemoveDefine
 240  *
 241  * PARAMETERS:  DefineName          - Name of define to be removed
 242  *
 243  * RETURN:      None
 244  *
 245  * DESCRIPTION: Implements #undef. Remove a #define if found in the global
 246  *              list. No error if the target of the #undef does not exist,
 247  *              as per the C #undef definition.
 248  *
 249  ******************************************************************************/
 250
 251 void
 252 PrRemoveDefine (
 253     char                    *DefineName)
 254 {
 255     PR_DEFINE_INFO          *DefineInfo;
 256
 257
 258     /* Match name and delete the node */
 259
 260     DefineInfo = Gbl_DefineList;
 261     while (DefineInfo)
 262     {
 263         if (!strcmp (DefineName, DefineInfo->Identifier))
 264         {
 265             /* Remove from linked list */
 266
 267             if (DefineInfo->Previous)
 268             {
 269                 (DefineInfo->Previous)->Next = DefineInfo->Next;
 270             }
 271             else
 272             {
 273                 Gbl_DefineList = DefineInfo->Next;
 274             }
 275
 276             if (DefineInfo->Next)
 277             {
 278                 (DefineInfo->Next)->Previous = DefineInfo->Previous;
 279             }
 280
 281             free (DefineInfo);
 282             return;
 283         }
 284
 285         DefineInfo = DefineInfo->Next;
 286     }
 287
 288     /*
 289      * Name was not found. By definition of #undef, this is not
 290      * an error, however.
 291      */
 292     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 293         "#undef: could not find %s\n",
 294         Gbl_CurrentLineNumber, DefineName);
 295 }
 296
 297
 298 /*******************************************************************************
 299  *
 300  * FUNCTION:    PrMatchDefine
 301  *
 302  * PARAMETERS:  MatchString         - Name associated with the #define
 303  *
 304  * RETURN:      Matched string if found. NULL otherwise.
 305  *
 306  * DESCRIPTION: Find a name in global #define list
 307  *
 308  ******************************************************************************/
 309
 310 PR_DEFINE_INFO *
 311 PrMatchDefine (
 312     char                    *MatchString)
 313 {
 314     PR_DEFINE_INFO          *DefineInfo;
 315
 316
 317     DefineInfo = Gbl_DefineList;
 318     while (DefineInfo)
 319     {
 320         if (!strcmp (MatchString, DefineInfo->Identifier))
 321         {
 322             return (DefineInfo);
 323         }
 324
 325         DefineInfo = DefineInfo->Next;
 326     }
 327
 328     return (NULL);
 329 }
 330
 331
 332 /*******************************************************************************
 333  *
 334  * FUNCTION:    PrAddMacro
 335  *
 336  * PARAMETERS:  Name                - Start of the macro definition
 337  *              Next                - "Next" buffer from GetNextToken
 338  *
 339  * RETURN:      None
 340  *
 341  * DESCRIPTION: Add a new macro to the list of #defines. Handles argument
 342  *              processing.
 343  *
 344  ******************************************************************************/
 345
 346 void
 347 PrAddMacro (
 348     char                    *Name,
 349     char                    **Next)
 350 {
 351     char                    *Token = NULL;
 352     ACPI_SIZE               TokenOffset;
 353     ACPI_SIZE               MacroBodyOffset;
 354     PR_DEFINE_INFO          *DefineInfo;
 355     PR_MACRO_ARG            *Args;
 356     char                    *Body;
 357     char                    *BodyInSource;
 358     UINT32                  i;
 359     UINT16                  UseCount = 0;
 360     UINT16                  ArgCount = 0;
 361     UINT32                  Depth = 1;
 362     UINT32                  EndOfArgList;
 363     char                    BufferChar;
 364
 365
 366     /* Find the end of the arguments list */
 367
 368     TokenOffset = Name - Gbl_MainTokenBuffer + strlen (Name) + 1;
 369     while (1)
 370     {
 371         BufferChar = Gbl_CurrentLineBuffer[TokenOffset];
 372         if (BufferChar == '(')
 373         {
 374             Depth++;
 375         }
 376         else if (BufferChar == ')')
 377         {
 378             Depth--;
 379         }
 380         else if (BufferChar == 0)
 381         {
 382             PrError (ASL_ERROR, ASL_MSG_MACRO_SYNTAX, TokenOffset);
 383             return;
 384         }
 385
 386         if (Depth == 0)
 387         {
 388             /* Found arg list end */
 389
 390             EndOfArgList = TokenOffset;
 391             break;
 392         }
 393
 394         TokenOffset++;
 395     }
 396
 397     /* At this point, we know that we have a reasonable argument list */
 398
 399     Args = UtLocalCalloc (sizeof (PR_MACRO_ARG) * PR_MAX_MACRO_ARGS);
 400
 401     /* Get the macro argument names */
 402
 403     for (i = 0; i < PR_MAX_MACRO_ARGS; i++)
 404     {
 405         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
 406         if (!Token)
 407         {
 408             /* This is the case for a NULL macro body */
 409
 410             BodyInSource = "";
 411             goto AddMacroToList;
 412         }
 413
 414         /* Don't go beyond the argument list */
 415
 416         TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
 417         if (TokenOffset > EndOfArgList)
 418         {
 419             break;
 420         }
 421
 422         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 423             "Macro arg: %s \n",
 424             Gbl_CurrentLineNumber, Token);
 425
 426         Args[i].Name = UtLocalCalloc (strlen (Token) + 1);
 427         strcpy (Args[i].Name, Token);
 428
 429         Args[i].UseCount = 0;
 430
 431         ArgCount++;
 432         if (ArgCount >= PR_MAX_MACRO_ARGS)
 433         {
 434             PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS, TokenOffset);
 435             goto ErrorExit;
 436         }
 437     }
 438
 439     /* Get the macro body. Token now points to start of body */
 440
 441     MacroBodyOffset = Token - Gbl_MainTokenBuffer;
 442
 443     /* Match each method arg in the macro body for later use */
 444
 445     Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
 446     while (Token)
 447     {
 448         /* Search the macro arg list for matching arg */
 449
 450         for (i = 0; Args[i].Name && (i < PR_MAX_MACRO_ARGS); i++)
 451         {
 452             /*
 453              * Save argument offset within macro body. This is the mechanism
 454              * used to expand the macro upon invocation.
 455              *
 456              * Handles multiple instances of the same argument
 457              */
 458             if (!strcmp (Token, Args[i].Name))
 459             {
 460                 UseCount = Args[i].UseCount;
 461
 462                 Args[i].Offset[UseCount] = (Token - Gbl_MainTokenBuffer) - MacroBodyOffset;
 463
 464                 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 465                     "Macro Arg #%u: %s UseCount %u Offset %u \n",
 466                     Gbl_CurrentLineNumber, i, Token,
 467                     UseCount+1, Args[i].Offset[UseCount]);
 468
 469                 Args[i].UseCount++;
 470                 if (Args[i].UseCount >= PR_MAX_ARG_INSTANCES)
 471                 {
 472                     PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS,
 473                         THIS_TOKEN_OFFSET (Token));
 474
 475                     goto ErrorExit;
 476                 }
 477                 break;
 478             }
 479         }
 480
 481         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
 482     }
 483
 484     BodyInSource = &Gbl_CurrentLineBuffer[MacroBodyOffset];
 485
 486
 487 AddMacroToList:
 488
 489     /* Check if name is already defined first */
 490
 491     DefineInfo = PrMatchDefine (Name);
 492     if (DefineInfo)
 493     {
 494         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 495             "#define: macro name already exists: %s\n",
 496             Gbl_CurrentLineNumber, Name);
 497
 498         /* Error only if not exactly the same macro */
 499
 500         if (strcmp (DefineInfo->Body, BodyInSource) ||
 501             (DefineInfo->ArgCount != ArgCount))
 502         {
 503             PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
 504                 THIS_TOKEN_OFFSET (Name));
 505         }
 506
 507         goto ErrorExit;
 508     }
 509
 510     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 511         "Macro body: %s \n",
 512         Gbl_CurrentLineNumber, BodyInSource);
 513
 514     /* Add macro to the #define list */
 515
 516     DefineInfo = PrAddDefine (Name, BodyInSource, FALSE);
 517     if (DefineInfo)
 518     {
 519         Body = UtLocalCalloc (strlen (BodyInSource) + 1);
 520         strcpy (Body, BodyInSource);
 521
 522         DefineInfo->Body = Body;
 523         DefineInfo->Args = Args;
 524         DefineInfo->ArgCount = ArgCount;
 525     }
 526
 527     return;
 528
 529
 530 ErrorExit:
 531     ACPI_FREE (Args);
 532     return;
 533 }
 534
 535
 536 /*******************************************************************************
 537  *
 538  * FUNCTION:    PrDoMacroInvocation
 539  *
 540  * PARAMETERS:  TokenBuffer         - Current line buffer
 541  *              MacroStart          - Start of the macro invocation within
 542  *                                    the token buffer
 543  *              DefineInfo          - Info for this macro
 544  *              Next                - "Next" buffer from GetNextToken
 545  *
 546  * RETURN:      None
 547  *
 548  * DESCRIPTION: Expand a macro invocation
 549  *
 550  ******************************************************************************/
 551
 552 void
 553 PrDoMacroInvocation (
 554     char                    *TokenBuffer,
 555     char                    *MacroStart,
 556     PR_DEFINE_INFO          *DefineInfo,
 557     char                    **Next)
 558 {
 559     PR_MACRO_ARG            *Args;
 560     char                    *Token = NULL;
 561     UINT32                  TokenOffset;
 562     UINT32                  Length;
 563     UINT32                  i;
 564
 565
 566     /* Take a copy of the macro body for expansion */
 567
 568     strcpy (Gbl_MacroTokenBuffer, DefineInfo->Body);
 569
 570     /* Replace each argument within the prototype body */
 571
 572     Args = DefineInfo->Args;
 573     if (!Args->Name)
 574     {
 575         /* This macro has no arguments */
 576
 577         Token = PrGetNextToken (NULL, PR_MACRO_ARGUMENTS, Next);
 578         if (!Token)
 579         {
 580             goto BadInvocation;
 581         }
 582
 583         TokenOffset = (MacroStart - TokenBuffer);
 584         Length = Token - MacroStart + strlen (Token) + 1;
 585
 586         PrReplaceData (
 587             &Gbl_CurrentLineBuffer[TokenOffset], Length,
 588             Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer));
 589         return;
 590     }
 591
 592     while (Args->Name)
 593     {
 594         /* Get the next argument from macro invocation */
 595
 596         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
 597         if (!Token)
 598         {
 599             goto BadInvocation;
 600         }
 601
 602         /* Replace all instances of this argument */
 603
 604         for (i = 0; i < Args->UseCount; i++)
 605         {
 606             /* Offset zero indicates "arg not used" */
 607             /* TBD: Not really needed now, with UseCount available */
 608
 609             if (Args->Offset[i] == 0)
 610             {
 611                 break;
 612             }
 613
 614             PrReplaceData (
 615                 &Gbl_MacroTokenBuffer[Args->Offset[i]], strlen (Args->Name),
 616                 Token, strlen (Token));
 617
 618             DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 619                 "ExpandArg: %s \n",
 620                 Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer);
 621         }
 622
 623         Args++;
 624     }
 625
 626     /* TBD: need to make sure macro was not invoked with too many arguments */
 627
 628     if (!Token)
 629     {
 630         return;
 631     }
 632
 633     /* Replace the entire macro invocation with the expanded macro */
 634
 635     TokenOffset = (MacroStart - TokenBuffer);
 636     Length = Token - MacroStart + strlen (Token) + 1;
 637
 638     PrReplaceData (
 639         &Gbl_CurrentLineBuffer[TokenOffset], Length,
 640         Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer));
 641
 642     return;
 643
 644
 645 BadInvocation:
 646     PrError (ASL_ERROR, ASL_MSG_INVALID_INVOCATION,
 647         THIS_TOKEN_OFFSET (MacroStart));
 648
 649     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
 650         "Bad macro invocation: %s \n",
 651         Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer);
 652     return;
 653 }