1 /******************************************************************************
3 * Module Name: aslfold - Constant folding
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
45 #include "aslcompiler.y.h"
46 #include <contrib/dev/acpica/include/amlcode.h>
48 #include <contrib/dev/acpica/include/acdispat.h>
49 #include <contrib/dev/acpica/include/acparser.h>
51 #define _COMPONENT ACPI_COMPILER
52 ACPI_MODULE_NAME ("aslfold")
54 /* Local prototypes */
57 OpcAmlEvaluationWalk1 (
58 ACPI_PARSE_OBJECT *Op,
63 OpcAmlEvaluationWalk2 (
64 ACPI_PARSE_OBJECT *Op,
69 OpcAmlCheckForConstant (
70 ACPI_PARSE_OBJECT *Op,
75 OpcUpdateIntegerNode (
76 ACPI_PARSE_OBJECT *Op,
80 TrTransformToStoreOp (
81 ACPI_PARSE_OBJECT *Op,
82 ACPI_WALK_STATE *WalkState);
85 TrSimpleConstantReduction (
86 ACPI_PARSE_OBJECT *Op,
87 ACPI_WALK_STATE *WalkState);
90 TrInstallReducedConstant (
91 ACPI_PARSE_OBJECT *Op,
92 ACPI_OPERAND_OBJECT *ObjDesc);
95 /*******************************************************************************
97 * FUNCTION: OpcAmlConstantWalk
99 * PARAMETERS: ASL_WALK_CALLBACK
103 * DESCRIPTION: Reduce an Op and its subtree to a constant if possible.
104 * Called during ascent of the parse tree.
106 ******************************************************************************/
110 ACPI_PARSE_OBJECT *Op,
114 ACPI_WALK_STATE *WalkState;
115 ACPI_STATUS Status = AE_OK;
118 if (Op->Asl.CompileFlags == 0)
124 * Only interested in subtrees that could possibly contain
125 * expressions that can be evaluated at this time
127 if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||
128 (Op->Asl.CompileFlags & NODE_IS_TARGET))
133 /* Create a new walk state */
135 WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
138 return (AE_NO_MEMORY);
141 WalkState->NextOp = NULL;
142 WalkState->Params = NULL;
145 * Examine the entire subtree -- all nodes must be constants
146 * or type 3/4/5 opcodes
148 Status = TrWalkParseTree (Op, ASL_WALK_VISIT_DOWNWARD,
149 OpcAmlCheckForConstant, NULL, WalkState);
152 * Did we find an entire subtree that contains all constants
153 * and type 3/4/5 opcodes?
159 /* Simple case, like Add(3,4) -> 7 */
161 Status = TrSimpleConstantReduction (Op, WalkState);
164 case AE_CTRL_RETURN_VALUE:
166 /* More complex case, like Add(3,4,Local0) -> Store(7,Local0) */
168 Status = TrTransformToStoreOp (Op, WalkState);
173 AcpiDsDeleteWalkState (WalkState);
177 AcpiDsDeleteWalkState (WalkState);
181 if (ACPI_FAILURE (Status))
183 DbgPrint (ASL_PARSE_OUTPUT, "Cannot resolve, %s\n",
184 AcpiFormatException (Status));
186 /* We could not resolve the subtree for some reason */
188 AslError (ASL_ERROR, ASL_MSG_CONSTANT_EVALUATION, Op,
189 (char *) AcpiFormatException (Status));
191 /* Set the subtree value to ZERO anyway. Eliminates further errors */
193 OpcUpdateIntegerNode (Op, 0);
200 /*******************************************************************************
202 * FUNCTION: OpcAmlCheckForConstant
204 * PARAMETERS: ASL_WALK_CALLBACK
208 * DESCRIPTION: Check one Op for a reducible type 3/4/5 AML opcode.
209 * This is performed via an upward walk of the parse subtree.
211 ******************************************************************************/
214 OpcAmlCheckForConstant (
215 ACPI_PARSE_OBJECT *Op,
219 ACPI_WALK_STATE *WalkState = Context;
220 ACPI_STATUS Status = AE_OK;
221 ACPI_PARSE_OBJECT *NextOp;
222 const ACPI_OPCODE_INFO *OpInfo;
226 WalkState->Opcode = Op->Common.AmlOpcode;
227 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
229 DbgPrint (ASL_PARSE_OUTPUT, "[%.4d] Opcode: %12.12s ",
230 Op->Asl.LogicalLineNumber, Op->Asl.ParseOpName);
233 * These opcodes do not appear in the OpcodeInfo table, but
234 * they represent constants, so abort the constant walk now.
236 if ((WalkState->Opcode == AML_RAW_DATA_BYTE) ||
237 (WalkState->Opcode == AML_RAW_DATA_WORD) ||
238 (WalkState->Opcode == AML_RAW_DATA_DWORD) ||
239 (WalkState->Opcode == AML_RAW_DATA_QWORD))
241 DbgPrint (ASL_PARSE_OUTPUT, "RAW DATA");
247 * Search upwards for a possible Name() operator. This is done
248 * because a type 3/4/5 opcode within a Name() expression
249 * MUST be reduced to a simple constant.
251 NextOp = Op->Asl.Parent;
254 /* Finished if we find a Name() opcode */
256 if (NextOp->Asl.AmlOpcode == AML_NAME_OP)
262 * Any "deferred" opcodes contain one or more TermArg parameters,
263 * and thus are not required to be folded to constants at compile
264 * time. This affects things like Buffer() and Package() objects.
265 * We just ignore them here. However, any sub-expressions can and
266 * will still be typechecked. Note: These are called the
267 * "deferred" opcodes in the AML interpreter.
269 OpInfo = AcpiPsGetOpcodeInfo (NextOp->Common.AmlOpcode);
270 if (OpInfo->Flags & AML_DEFER)
276 NextOp = NextOp->Asl.Parent;
279 /* Type 3/4/5 opcodes have the AML_CONSTANT flag set */
281 if (!(WalkState->OpInfo->Flags & AML_CONSTANT))
284 * From the ACPI specification:
286 * "The Type 3/4/5 opcodes return a value and can be used in an
287 * expression that evaluates to a constant. These opcodes may be
288 * evaluated at ASL compile-time. To ensure that these opcodes
289 * will evaluate to a constant, the following rules apply: The
290 * term cannot have a destination (target) operand, and must have
291 * either a Type3Opcode, Type4Opcode, Type5Opcode, ConstExprTerm,
292 * Integer, BufferTerm, Package, or String for all arguments."
296 * The value (second) operand for the Name() operator MUST
297 * reduce to a single constant, as per the ACPI specification
298 * (the operand is a DataObject). This also implies that there
299 * can be no target operand. Name() is the only ASL operator
300 * with a "DataObject" as an operand and is thus special-
303 if (NextOp) /* Inspect a Name() operator */
305 /* Error if there is a target operand */
307 if (Op->Asl.CompileFlags & NODE_IS_TARGET)
309 AslError (ASL_ERROR, ASL_MSG_INVALID_TARGET, Op, NULL);
313 /* Error if expression cannot be reduced (folded) */
315 if (!(NextOp->Asl.CompileFlags & NODE_COULD_NOT_REDUCE))
317 /* Ensure only one error message per statement */
319 NextOp->Asl.CompileFlags |= NODE_COULD_NOT_REDUCE;
320 DbgPrint (ASL_PARSE_OUTPUT,
321 "**** Could not reduce operands for NAME opcode ****\n");
323 AslError (ASL_ERROR, ASL_MSG_CONSTANT_REQUIRED, Op,
324 "Constant is required for Name operator");
329 if (ACPI_FAILURE (Status))
334 /* This is not a 3/4/5 opcode, but maybe can convert to STORE */
336 if (Op->Asl.CompileFlags & NODE_IS_TARGET)
338 DbgPrint (ASL_PARSE_OUTPUT,
339 "**** Valid Target, transform to Store ****\n");
340 return (AE_CTRL_RETURN_VALUE);
343 /* Expression cannot be reduced */
345 DbgPrint (ASL_PARSE_OUTPUT,
346 "**** Not a Type 3/4/5 opcode or cannot reduce/fold (%s) ****\n",
347 Op->Asl.ParseOpName);
354 * TBD: Ignore buffer constants for now. The problem is that these
355 * constants have been transformed into RAW_DATA at this point, from
356 * the parse tree transform process which currently happens before
357 * the constant folding process. We may need to defer this transform
358 * for buffer until after the constant folding.
360 if (WalkState->Opcode == AML_BUFFER_OP)
362 DbgPrint (ASL_PARSE_OUTPUT,
363 "\nBuffer constant reduction is not supported yet\n");
365 if (NextOp) /* Found a Name() operator, error */
367 AslError (ASL_ERROR, ASL_MSG_UNSUPPORTED, Op,
368 "Buffer expression cannot be reduced");
377 DbgPrint (ASL_PARSE_OUTPUT, "TYPE_345");
379 if (Op->Asl.CompileFlags & NODE_IS_TARGET)
381 if (Op->Asl.ParseOpcode == PARSEOP_ZERO)
383 DbgPrint (ASL_PARSE_OUTPUT, "%-16s", " NULL TARGET");
387 DbgPrint (ASL_PARSE_OUTPUT, "%-16s", " VALID TARGET");
391 if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
393 DbgPrint (ASL_PARSE_OUTPUT, "%-16s", " TERMARG");
398 /* Dump the node compile flags also */
400 TrPrintNodeCompileFlags (Op->Asl.CompileFlags);
401 DbgPrint (ASL_PARSE_OUTPUT, "\n");
406 /*******************************************************************************
408 * FUNCTION: TrSimpleConstantReduction
410 * PARAMETERS: Op - Parent operator to be transformed
411 * WalkState - Current walk state
415 * DESCRIPTION: Reduce an entire AML operation to a single constant. The
416 * operation must not have a target operand.
420 ******************************************************************************/
423 TrSimpleConstantReduction (
424 ACPI_PARSE_OBJECT *Op,
425 ACPI_WALK_STATE *WalkState)
427 ACPI_PARSE_OBJECT *RootOp;
428 ACPI_PARSE_OBJECT *OriginalParentOp;
429 ACPI_OPERAND_OBJECT *ObjDesc;
433 DbgPrint (ASL_PARSE_OUTPUT,
434 "Simple subtree constant reduction, operator to constant\n");
436 /* Allocate a new temporary root for this subtree */
438 RootOp = TrAllocateNode (PARSEOP_INTEGER);
441 return (AE_NO_MEMORY);
444 RootOp->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
446 OriginalParentOp = Op->Common.Parent;
447 Op->Common.Parent = RootOp;
449 /* Hand off the subtree to the AML interpreter */
451 WalkState->CallerReturnDesc = &ObjDesc;
453 Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
454 OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
456 /* Restore original parse tree */
458 Op->Common.Parent = OriginalParentOp;
460 if (ACPI_FAILURE (Status))
462 DbgPrint (ASL_PARSE_OUTPUT,
463 "Constant Subtree evaluation(1), %s\n",
464 AcpiFormatException (Status));
468 /* Get the final result */
470 Status = AcpiDsResultPop (&ObjDesc, WalkState);
471 if (ACPI_FAILURE (Status))
473 DbgPrint (ASL_PARSE_OUTPUT,
474 "Constant Subtree evaluation(2), %s\n",
475 AcpiFormatException (Status));
479 /* Disconnect any existing children, install new constant */
481 Op->Asl.Child = NULL;
482 TrInstallReducedConstant (Op, ObjDesc);
484 UtSetParseOpName (Op);
489 /*******************************************************************************
491 * FUNCTION: TrTransformToStoreOp
493 * PARAMETERS: Op - Parent operator to be transformed
494 * WalkState - Current walk state
498 * DESCRIPTION: Transforms a single AML operation with a constant and target
499 * to a simple store operation:
501 * Add (32,64,DATA) --> Store (96,DATA)
503 ******************************************************************************/
506 TrTransformToStoreOp (
507 ACPI_PARSE_OBJECT *Op,
508 ACPI_WALK_STATE *WalkState)
510 ACPI_PARSE_OBJECT *OriginalTarget;
511 ACPI_PARSE_OBJECT *NewTarget;
512 ACPI_PARSE_OBJECT *Child1;
513 ACPI_PARSE_OBJECT *Child2;
514 ACPI_OPERAND_OBJECT *ObjDesc;
515 ACPI_PARSE_OBJECT *NewParent;
516 ACPI_PARSE_OBJECT *OriginalParent;
520 /* Extract the operands */
522 Child1 = Op->Asl.Child;
523 Child2 = Child1->Asl.Next;
526 * Special case for DIVIDE -- it has two targets. The first
527 * is for the remainder and if present, we will not attempt
528 * to reduce the expression.
530 if (Op->Asl.ParseOpcode == PARSEOP_DIVIDE)
532 Child2 = Child2->Asl.Next;
533 if (Child2->Asl.ParseOpcode != PARSEOP_ZERO)
535 DbgPrint (ASL_PARSE_OUTPUT,
536 "Cannot reduce DIVIDE - has two targets\n\n");
541 DbgPrint (ASL_PARSE_OUTPUT,
542 "Reduction/Transform to StoreOp: Store(%s, %s)\n",
543 Child1->Asl.ParseOpName, Child2->Asl.ParseOpName);
546 * Create a NULL (zero) target so that we can use the
547 * interpreter to evaluate the expression.
549 NewTarget = TrCreateNullTarget ();
550 NewTarget->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
552 /* Handle one-operand cases (NOT, TOBCD, etc.) */
554 if (!Child2->Asl.Next)
559 /* Link in new NULL target as the last operand */
561 OriginalTarget = Child2->Asl.Next;
562 Child2->Asl.Next = NewTarget;
563 NewTarget->Asl.Parent = OriginalTarget->Asl.Parent;
565 NewParent = TrAllocateNode (PARSEOP_INTEGER);
566 NewParent->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
568 OriginalParent = Op->Common.Parent;
569 Op->Common.Parent = NewParent;
571 /* Hand off the subtree to the AML interpreter */
573 WalkState->CallerReturnDesc = &ObjDesc;
575 Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
576 OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
577 if (ACPI_FAILURE (Status))
579 DbgPrint (ASL_PARSE_OUTPUT,
580 "Constant Subtree evaluation(3), %s\n",
581 AcpiFormatException (Status));
585 /* Get the final result */
587 Status = AcpiDsResultPop (&ObjDesc, WalkState);
588 if (ACPI_FAILURE (Status))
590 DbgPrint (ASL_PARSE_OUTPUT,
591 "Constant Subtree evaluation(4), %s\n",
592 AcpiFormatException (Status));
596 /* Truncate any subtree expressions, they have been evaluated */
598 Child1->Asl.Child = NULL;
600 /* Folded constant is in ObjDesc, store into Child1 */
602 TrInstallReducedConstant (Child1, ObjDesc);
604 /* Convert operator to STORE */
606 Op->Asl.ParseOpcode = PARSEOP_STORE;
607 Op->Asl.AmlOpcode = AML_STORE_OP;
608 UtSetParseOpName (Op);
609 Op->Common.Parent = OriginalParent;
611 /* First child is the folded constant */
613 /* Second child will be the target */
615 Child1->Asl.Next = OriginalTarget;
621 /* Restore original links */
623 Op->Common.Parent = OriginalParent;
624 Child2->Asl.Next = OriginalTarget;
629 /*******************************************************************************
631 * FUNCTION: TrInstallReducedConstant
633 * PARAMETERS: Op - Parent operator to be transformed
634 * ObjDesc - Reduced constant to be installed
638 * DESCRIPTION: Transform the original operator to a simple constant.
639 * Handles Integers, Strings, and Buffers.
641 ******************************************************************************/
644 TrInstallReducedConstant (
645 ACPI_PARSE_OBJECT *Op,
646 ACPI_OPERAND_OBJECT *ObjDesc)
648 ACPI_PARSE_OBJECT *LengthOp;
649 ACPI_PARSE_OBJECT *DataOp;
653 AslError (ASL_OPTIMIZATION, ASL_MSG_CONSTANT_FOLDED, Op,
654 Op->Asl.ParseOpName);
657 * Because we know we executed type 3/4/5 opcodes above, we know that
658 * the result must be either an Integer, String, or Buffer.
660 switch (ObjDesc->Common.Type)
662 case ACPI_TYPE_INTEGER:
664 OpcUpdateIntegerNode (Op, ObjDesc->Integer.Value);
666 DbgPrint (ASL_PARSE_OUTPUT,
667 "Constant expression reduced to (%s) %8.8X%8.8X\n\n",
669 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
672 case ACPI_TYPE_STRING:
674 Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
675 Op->Common.AmlOpcode = AML_STRING_OP;
676 Op->Asl.AmlLength = strlen (ObjDesc->String.Pointer) + 1;
677 Op->Common.Value.String = ObjDesc->String.Pointer;
679 DbgPrint (ASL_PARSE_OUTPUT,
680 "Constant expression reduced to (STRING) %s\n\n",
681 Op->Common.Value.String);
684 case ACPI_TYPE_BUFFER:
686 * Create a new parse subtree of the form:
688 * BUFFER (Buffer AML opcode)
689 * INTEGER (Buffer length in bytes)
690 * RAW_DATA (Buffer byte data)
692 Op->Asl.ParseOpcode = PARSEOP_BUFFER;
693 Op->Common.AmlOpcode = AML_BUFFER_OP;
694 Op->Asl.CompileFlags = NODE_AML_PACKAGE;
695 UtSetParseOpName (Op);
697 /* Child node is the buffer length */
699 LengthOp = TrAllocateNode (PARSEOP_INTEGER);
701 LengthOp->Asl.AmlOpcode = AML_DWORD_OP;
702 LengthOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
703 LengthOp->Asl.Parent = Op;
704 (void) OpcSetOptimalIntegerSize (LengthOp);
706 Op->Asl.Child = LengthOp;
708 /* Next child is the raw buffer data */
710 DataOp = TrAllocateNode (PARSEOP_RAW_DATA);
711 DataOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
712 DataOp->Asl.AmlLength = ObjDesc->Buffer.Length;
713 DataOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
714 DataOp->Asl.Parent = Op;
716 LengthOp->Asl.Next = DataOp;
718 DbgPrint (ASL_PARSE_OUTPUT,
719 "Constant expression reduced to (BUFFER) length %X\n\n",
720 ObjDesc->Buffer.Length);
729 /*******************************************************************************
731 * FUNCTION: OpcUpdateIntegerNode
733 * PARAMETERS: Op - Current parse object
734 * Value - Value for the integer op
738 * DESCRIPTION: Update node to the correct Integer type and value
740 ******************************************************************************/
743 OpcUpdateIntegerNode (
744 ACPI_PARSE_OBJECT *Op,
748 Op->Common.Value.Integer = Value;
751 * The AmlLength is used by the parser to indicate a constant,
752 * (if non-zero). Length is either (1/2/4/8)
754 switch (Op->Asl.AmlLength)
758 TrUpdateNode (PARSEOP_BYTECONST, Op);
759 Op->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
764 TrUpdateNode (PARSEOP_WORDCONST, Op);
765 Op->Asl.AmlOpcode = AML_RAW_DATA_WORD;
770 TrUpdateNode (PARSEOP_DWORDCONST, Op);
771 Op->Asl.AmlOpcode = AML_RAW_DATA_DWORD;
776 TrUpdateNode (PARSEOP_QWORDCONST, Op);
777 Op->Asl.AmlOpcode = AML_RAW_DATA_QWORD;
783 OpcSetOptimalIntegerSize (Op);
784 TrUpdateNode (PARSEOP_INTEGER, Op);
788 Op->Asl.AmlLength = 0;
792 /*******************************************************************************
794 * FUNCTION: OpcAmlEvaluationWalk1
796 * PARAMETERS: ASL_WALK_CALLBACK
800 * DESCRIPTION: Descending callback for AML execution of constant subtrees
802 ******************************************************************************/
805 OpcAmlEvaluationWalk1 (
806 ACPI_PARSE_OBJECT *Op,
810 ACPI_WALK_STATE *WalkState = Context;
812 ACPI_PARSE_OBJECT *OutOp;
816 WalkState->Opcode = Op->Common.AmlOpcode;
817 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
819 /* Copy child pointer to Arg for compatibility with Interpreter */
823 Op->Common.Value.Arg = Op->Asl.Child;
826 /* Call AML dispatcher */
828 Status = AcpiDsExecBeginOp (WalkState, &OutOp);
829 if (ACPI_FAILURE (Status))
831 DbgPrint (ASL_PARSE_OUTPUT,
832 "%s Constant interpretation failed (1) - %s\n",
833 Op->Asl.ParseOpName, AcpiFormatException (Status));
840 /*******************************************************************************
842 * FUNCTION: OpcAmlEvaluationWalk2
844 * PARAMETERS: ASL_WALK_CALLBACK
848 * DESCRIPTION: Ascending callback for AML execution of constant subtrees
850 ******************************************************************************/
853 OpcAmlEvaluationWalk2 (
854 ACPI_PARSE_OBJECT *Op,
858 ACPI_WALK_STATE *WalkState = Context;
863 WalkState->Opcode = Op->Common.AmlOpcode;
864 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
866 /* Copy child pointer to Arg for compatibility with Interpreter */
870 Op->Common.Value.Arg = Op->Asl.Child;
873 /* Call AML dispatcher */
875 Status = AcpiDsExecEndOp (WalkState);
876 if (ACPI_FAILURE (Status))
878 DbgPrint (ASL_PARSE_OUTPUT,
879 "%s: Constant interpretation failed (2) - %s\n",
880 Op->Asl.ParseOpName, AcpiFormatException (Status));