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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslfold - Constant folding
   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 "amlcode.h"
  48
  49 #include "acdispat.h"
  50 #include "acparser.h"
  51
  52 #define _COMPONENT          ACPI_COMPILER
  53         ACPI_MODULE_NAME    ("aslfold")
  54
  55 /* Local prototypes */
  56
  57 static ACPI_STATUS
  58 OpcAmlEvaluationWalk1 (
  59     ACPI_PARSE_OBJECT       *Op,
  60     UINT32                  Level,
  61     void                    *Context);
  62
  63 static ACPI_STATUS
  64 OpcAmlEvaluationWalk2 (
  65     ACPI_PARSE_OBJECT       *Op,
  66     UINT32                  Level,
  67     void                    *Context);
  68
  69 static ACPI_STATUS
  70 OpcAmlCheckForConstant (
  71     ACPI_PARSE_OBJECT       *Op,
  72     UINT32                  Level,
  73     void                    *Context);
  74
  75 static void
  76 OpcUpdateIntegerNode (
  77     ACPI_PARSE_OBJECT       *Op,
  78     UINT64                  Value);
  79
  80
  81 /*******************************************************************************
  82  *
  83  * FUNCTION:    OpcAmlEvaluationWalk1
  84  *
  85  * PARAMETERS:  ASL_WALK_CALLBACK
  86  *
  87  * RETURN:      Status
  88  *
  89  * DESCRIPTION: Descending callback for AML execution of constant subtrees
  90  *
  91  ******************************************************************************/
  92
  93 static ACPI_STATUS
  94 OpcAmlEvaluationWalk1 (
  95     ACPI_PARSE_OBJECT       *Op,
  96     UINT32                  Level,
  97     void                    *Context)
  98 {
  99     ACPI_WALK_STATE         *WalkState = Context;
 100     ACPI_STATUS             Status;
 101     ACPI_PARSE_OBJECT       *OutOp;
 102
 103
 104     WalkState->Op = Op;
 105     WalkState->Opcode = Op->Common.AmlOpcode;
 106     WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 107
 108     /* Copy child pointer to Arg for compatibility with Interpreter */
 109
 110     if (Op->Asl.Child)
 111     {
 112         Op->Common.Value.Arg = Op->Asl.Child;
 113     }
 114
 115     /* Call AML dispatcher */
 116
 117     Status = AcpiDsExecBeginOp (WalkState, &OutOp);
 118     if (ACPI_FAILURE (Status))
 119     {
 120         AcpiOsPrintf ("Constant interpretation failed - %s\n",
 121                         AcpiFormatException (Status));
 122     }
 123
 124     return (Status);
 125 }
 126
 127
 128 /*******************************************************************************
 129  *
 130  * FUNCTION:    OpcAmlEvaluationWalk2
 131  *
 132  * PARAMETERS:  ASL_WALK_CALLBACK
 133  *
 134  * RETURN:      Status
 135  *
 136  * DESCRIPTION: Ascending callback for AML execution of constant subtrees
 137  *
 138  ******************************************************************************/
 139
 140 static ACPI_STATUS
 141 OpcAmlEvaluationWalk2 (
 142     ACPI_PARSE_OBJECT       *Op,
 143     UINT32                  Level,
 144     void                    *Context)
 145 {
 146     ACPI_WALK_STATE         *WalkState = Context;
 147     ACPI_STATUS             Status;
 148
 149
 150     WalkState->Op = Op;
 151     WalkState->Opcode = Op->Common.AmlOpcode;
 152     WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 153
 154     /* Copy child pointer to Arg for compatibility with Interpreter */
 155
 156     if (Op->Asl.Child)
 157     {
 158         Op->Common.Value.Arg = Op->Asl.Child;
 159     }
 160
 161     /* Call AML dispatcher */
 162
 163     Status = AcpiDsExecEndOp (WalkState);
 164     if (ACPI_FAILURE (Status))
 165     {
 166         AcpiOsPrintf ("Constant interpretation failed - %s\n",
 167                         AcpiFormatException (Status));
 168     }
 169
 170     return (Status);
 171 }
 172
 173
 174 /*******************************************************************************
 175  *
 176  * FUNCTION:    OpcAmlCheckForConstant
 177  *
 178  * PARAMETERS:  ASL_WALK_CALLBACK
 179  *
 180  * RETURN:      Status
 181  *
 182  * DESCRIPTION: Check one Op for a type 3/4/5 AML opcode
 183  *
 184  ******************************************************************************/
 185
 186 static ACPI_STATUS
 187 OpcAmlCheckForConstant (
 188     ACPI_PARSE_OBJECT       *Op,
 189     UINT32                  Level,
 190     void                    *Context)
 191 {
 192     ACPI_WALK_STATE         *WalkState = Context;
 193
 194
 195     WalkState->Op = Op;
 196     WalkState->Opcode = Op->Common.AmlOpcode;
 197     WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 198
 199     DbgPrint (ASL_PARSE_OUTPUT, "[%.4d] Opcode: %12.12s ",
 200                 Op->Asl.LogicalLineNumber, Op->Asl.ParseOpName);
 201
 202     /*
 203      * These opcodes do not appear in the OpcodeInfo table, but
 204      * they represent constants, so abort the constant walk now.
 205      */
 206     if ((WalkState->Opcode == AML_RAW_DATA_BYTE) ||
 207         (WalkState->Opcode == AML_RAW_DATA_WORD) ||
 208         (WalkState->Opcode == AML_RAW_DATA_DWORD) ||
 209         (WalkState->Opcode == AML_RAW_DATA_QWORD))
 210     {
 211         WalkState->WalkType = ACPI_WALK_CONST_OPTIONAL;
 212         return (AE_TYPE);
 213     }
 214
 215     if (!(WalkState->OpInfo->Flags & AML_CONSTANT))
 216     {
 217         /* The opcode is not a Type 3/4/5 opcode */
 218
 219         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
 220         {
 221             DbgPrint (ASL_PARSE_OUTPUT,
 222                 "**** Valid Target, cannot reduce ****\n");
 223         }
 224         else
 225         {
 226             DbgPrint (ASL_PARSE_OUTPUT,
 227                 "**** Not a Type 3/4/5 opcode ****\n");
 228         }
 229
 230         if (WalkState->WalkType == ACPI_WALK_CONST_OPTIONAL)
 231         {
 232             /*
 233              * We are looking at at normal expression to see if it can be
 234              * reduced. It can't. No error
 235              */
 236             return (AE_TYPE);
 237         }
 238
 239         /*
 240          * This is an expression that MUST reduce to a constant, and it
 241          * can't be reduced. This is an error
 242          */
 243         if (Op->Asl.CompileFlags & NODE_IS_TARGET)
 244         {
 245             AslError (ASL_ERROR, ASL_MSG_INVALID_TARGET, Op,
 246                 Op->Asl.ParseOpName);
 247         }
 248         else
 249         {
 250             AslError (ASL_ERROR, ASL_MSG_INVALID_CONSTANT_OP, Op,
 251                 Op->Asl.ParseOpName);
 252         }
 253
 254         return (AE_TYPE);
 255     }
 256
 257     /* Debug output */
 258
 259     DbgPrint (ASL_PARSE_OUTPUT, "TYPE_345");
 260
 261     if (Op->Asl.CompileFlags & NODE_IS_TARGET)
 262     {
 263         DbgPrint (ASL_PARSE_OUTPUT, " TARGET");
 264     }
 265     if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
 266     {
 267         DbgPrint (ASL_PARSE_OUTPUT, " TERMARG");
 268     }
 269
 270     DbgPrint (ASL_PARSE_OUTPUT, "\n");
 271     return (AE_OK);
 272 }
 273
 274
 275 /*******************************************************************************
 276  *
 277  * FUNCTION:    OpcAmlConstantWalk
 278  *
 279  * PARAMETERS:  ASL_WALK_CALLBACK
 280  *
 281  * RETURN:      Status
 282  *
 283  * DESCRIPTION: Reduce an Op and its subtree to a constant if possible
 284  *
 285  ******************************************************************************/
 286
 287 ACPI_STATUS
 288 OpcAmlConstantWalk (
 289     ACPI_PARSE_OBJECT       *Op,
 290     UINT32                  Level,
 291     void                    *Context)
 292 {
 293     ACPI_WALK_STATE         *WalkState;
 294     ACPI_STATUS             Status = AE_OK;
 295     ACPI_OPERAND_OBJECT     *ObjDesc;
 296     ACPI_PARSE_OBJECT       *RootOp;
 297     ACPI_PARSE_OBJECT       *OriginalParentOp;
 298     UINT8                   WalkType;
 299
 300
 301     /*
 302      * Only interested in subtrees that could possibly contain
 303      * expressions that can be evaluated at this time
 304      */
 305     if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||
 306           (Op->Asl.CompileFlags & NODE_IS_TARGET))
 307     {
 308         return (AE_OK);
 309     }
 310
 311     /* Set the walk type based on the reduction used for this op */
 312
 313     if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
 314     {
 315         /* Op is a TermArg, constant folding is merely optional */
 316
 317         if (!Gbl_FoldConstants)
 318         {
 319             return (AE_CTRL_DEPTH);
 320         }
 321
 322         WalkType = ACPI_WALK_CONST_OPTIONAL;
 323     }
 324     else
 325     {
 326         /* Op is a DataObject, the expression MUST reduced to a constant */
 327
 328         WalkType = ACPI_WALK_CONST_REQUIRED;
 329     }
 330
 331     /* Create a new walk state */
 332
 333     WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
 334     if (!WalkState)
 335     {
 336         return (AE_NO_MEMORY);
 337     }
 338
 339     WalkState->NextOp = NULL;
 340     WalkState->Params = NULL;
 341     WalkState->WalkType = WalkType;
 342     WalkState->CallerReturnDesc = &ObjDesc;
 343
 344     /*
 345      * Examine the entire subtree -- all nodes must be constants
 346      * or type 3/4/5 opcodes
 347      */
 348     Status = TrWalkParseTree (Op, ASL_WALK_VISIT_DOWNWARD,
 349         OpcAmlCheckForConstant, NULL, WalkState);
 350
 351     /*
 352      * Did we find an entire subtree that contains all constants and type 3/4/5
 353      * opcodes?  (Only AE_OK or AE_TYPE returned from above)
 354      */
 355     if (Status == AE_TYPE)
 356     {
 357         /* Subtree cannot be reduced to a constant */
 358
 359         if (WalkState->WalkType == ACPI_WALK_CONST_OPTIONAL)
 360         {
 361             AcpiDsDeleteWalkState (WalkState);
 362             return (AE_OK);
 363         }
 364
 365         /* Don't descend any further, and use a default "constant" value */
 366
 367         Status = AE_CTRL_DEPTH;
 368     }
 369     else
 370     {
 371         /* Subtree can be reduced */
 372
 373         /* Allocate a new temporary root for this subtree */
 374
 375         RootOp = TrAllocateNode (PARSEOP_INTEGER);
 376         if (!RootOp)
 377         {
 378             return (AE_NO_MEMORY);
 379         }
 380
 381         RootOp->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
 382
 383         OriginalParentOp = Op->Common.Parent;
 384         Op->Common.Parent = RootOp;
 385
 386         /* Hand off the subtree to the AML interpreter */
 387
 388         Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
 389             OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
 390         Op->Common.Parent = OriginalParentOp;
 391
 392         /* TBD: we really *should* release the RootOp node */
 393
 394         if (ACPI_SUCCESS (Status))
 395         {
 396             TotalFolds++;
 397
 398             /* Get the final result */
 399
 400             Status = AcpiDsResultPop (&ObjDesc, WalkState);
 401         }
 402
 403         /* Check for error from the ACPICA core */
 404
 405         if (ACPI_FAILURE (Status))
 406         {
 407             AslCoreSubsystemError (Op, Status,
 408                 "Failure during constant evaluation", FALSE);
 409         }
 410     }
 411
 412     if (ACPI_FAILURE (Status))
 413     {
 414         /* We could not resolve the subtree for some reason */
 415
 416         AslError (ASL_ERROR, ASL_MSG_CONSTANT_EVALUATION, Op,
 417             Op->Asl.ParseOpName);
 418
 419         /* Set the subtree value to ZERO anyway. Eliminates further errors */
 420
 421         OpcUpdateIntegerNode (Op, 0);
 422     }
 423     else
 424     {
 425         AslError (ASL_OPTIMIZATION, ASL_MSG_CONSTANT_FOLDED, Op,
 426             Op->Asl.ParseOpName);
 427
 428         /*
 429          * Because we know we executed type 3/4/5 opcodes above, we know that
 430          * the result must be either an Integer, String, or Buffer.
 431          */
 432         switch (ObjDesc->Common.Type)
 433         {
 434         case ACPI_TYPE_INTEGER:
 435
 436             OpcUpdateIntegerNode (Op, ObjDesc->Integer.Value);
 437
 438             DbgPrint (ASL_PARSE_OUTPUT,
 439                 "Constant expression reduced to (%s) %8.8X%8.8X\n",
 440                 Op->Asl.ParseOpName,
 441                 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
 442             break;
 443
 444         case ACPI_TYPE_STRING:
 445
 446             Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
 447             Op->Common.AmlOpcode = AML_STRING_OP;
 448             Op->Asl.AmlLength = ACPI_STRLEN (ObjDesc->String.Pointer) + 1;
 449             Op->Common.Value.String = ObjDesc->String.Pointer;
 450
 451             DbgPrint (ASL_PARSE_OUTPUT,
 452                 "Constant expression reduced to (STRING) %s\n",
 453                 Op->Common.Value.String);
 454
 455             break;
 456
 457         case ACPI_TYPE_BUFFER:
 458
 459             Op->Asl.ParseOpcode = PARSEOP_BUFFER;
 460             Op->Common.AmlOpcode = AML_BUFFER_OP;
 461             Op->Asl.CompileFlags = NODE_AML_PACKAGE;
 462             UtSetParseOpName (Op);
 463
 464             /* Child node is the buffer length */
 465
 466             RootOp = TrAllocateNode (PARSEOP_INTEGER);
 467
 468             RootOp->Asl.AmlOpcode = AML_DWORD_OP;
 469             RootOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
 470             RootOp->Asl.Parent = Op;
 471
 472             (void) OpcSetOptimalIntegerSize (RootOp);
 473
 474             Op->Asl.Child = RootOp;
 475             Op = RootOp;
 476             UtSetParseOpName (Op);
 477
 478             /* Peer to the child is the raw buffer data */
 479
 480             RootOp = TrAllocateNode (PARSEOP_RAW_DATA);
 481             RootOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
 482             RootOp->Asl.AmlLength = ObjDesc->Buffer.Length;
 483             RootOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
 484             RootOp->Asl.Parent = Op->Asl.Parent;
 485
 486             Op->Asl.Next = RootOp;
 487             Op = RootOp;
 488
 489             DbgPrint (ASL_PARSE_OUTPUT,
 490                 "Constant expression reduced to (BUFFER) length %X\n",
 491                 ObjDesc->Buffer.Length);
 492             break;
 493
 494         default:
 495
 496             printf ("Unsupported return type: %s\n",
 497                 AcpiUtGetObjectTypeName (ObjDesc));
 498             break;
 499         }
 500     }
 501
 502     UtSetParseOpName (Op);
 503     Op->Asl.Child = NULL;
 504
 505     AcpiDsDeleteWalkState (WalkState);
 506     return (AE_CTRL_DEPTH);
 507 }
 508
 509
 510 /*******************************************************************************
 511  *
 512  * FUNCTION:    OpcUpdateIntegerNode
 513  *
 514  * PARAMETERS:  Op                  - Current parse object
 515  *
 516  * RETURN:      None
 517  *
 518  * DESCRIPTION: Update node to the correct integer type.
 519  *
 520  ******************************************************************************/
 521
 522 static void
 523 OpcUpdateIntegerNode (
 524     ACPI_PARSE_OBJECT       *Op,
 525     UINT64                  Value)
 526 {
 527
 528     Op->Common.Value.Integer = Value;
 529
 530     /*
 531      * The AmlLength is used by the parser to indicate a constant,
 532      * (if non-zero). Length is either (1/2/4/8)
 533      */
 534     switch (Op->Asl.AmlLength)
 535     {
 536     case 1:
 537
 538         TrUpdateNode (PARSEOP_BYTECONST, Op);
 539         Op->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
 540         break;
 541
 542     case 2:
 543
 544         TrUpdateNode (PARSEOP_WORDCONST, Op);
 545         Op->Asl.AmlOpcode = AML_RAW_DATA_WORD;
 546         break;
 547
 548     case 4:
 549
 550         TrUpdateNode (PARSEOP_DWORDCONST, Op);
 551         Op->Asl.AmlOpcode = AML_RAW_DATA_DWORD;
 552         break;
 553
 554     case 8:
 555
 556         TrUpdateNode (PARSEOP_QWORDCONST, Op);
 557         Op->Asl.AmlOpcode = AML_RAW_DATA_QWORD;
 558         break;
 559
 560     case 0:
 561     default:
 562
 563         OpcSetOptimalIntegerSize (Op);
 564         TrUpdateNode (PARSEOP_INTEGER, Op);
 565         break;
 566     }
 567
 568     Op->Asl.AmlLength = 0;
 569 }