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 } 570