xref: /illumos-gate/usr/src/common/acpica/dispatcher/dswexec.c (revision b41e2fb6b2658a36accc73b3b86d99375e700dba)
1 /******************************************************************************
2  *
3  * Module Name: dswexec - Dispatcher method execution callbacks;
4  *                        dispatch to interpreter.
5  *
6  *****************************************************************************/
7 
8 /******************************************************************************
9  *
10  * 1. Copyright Notice
11  *
12  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
13  * All rights reserved.
14  *
15  * 2. License
16  *
17  * 2.1. This is your license from Intel Corp. under its intellectual property
18  * rights. You may have additional license terms from the party that provided
19  * you this software, covering your right to use that party's intellectual
20  * property rights.
21  *
22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23  * copy of the source code appearing in this file ("Covered Code") an
24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25  * base code distributed originally by Intel ("Original Intel Code") to copy,
26  * make derivatives, distribute, use and display any portion of the Covered
27  * Code in any form, with the right to sublicense such rights; and
28  *
29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30  * license (with the right to sublicense), under only those claims of Intel
31  * patents that are infringed by the Original Intel Code, to make, use, sell,
32  * offer to sell, and import the Covered Code and derivative works thereof
33  * solely to the minimum extent necessary to exercise the above copyright
34  * license, and in no event shall the patent license extend to any additions
35  * to or modifications of the Original Intel Code. No other license or right
36  * is granted directly or by implication, estoppel or otherwise;
37  *
38  * The above copyright and patent license is granted only if the following
39  * conditions are met:
40  *
41  * 3. Conditions
42  *
43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44  * Redistribution of source code of any substantial portion of the Covered
45  * Code or modification with rights to further distribute source must include
46  * the above Copyright Notice, the above License, this list of Conditions,
47  * and the following Disclaimer and Export Compliance provision. In addition,
48  * Licensee must cause all Covered Code to which Licensee contributes to
49  * contain a file documenting the changes Licensee made to create that Covered
50  * Code and the date of any change. Licensee must include in that file the
51  * documentation of any changes made by any predecessor Licensee. Licensee
52  * must include a prominent statement that the modification is derived,
53  * directly or indirectly, from Original Intel Code.
54  *
55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56  * Redistribution of source code of any substantial portion of the Covered
57  * Code or modification without rights to further distribute source must
58  * include the following Disclaimer and Export Compliance provision in the
59  * documentation and/or other materials provided with distribution. In
60  * addition, Licensee may not authorize further sublicense of source of any
61  * portion of the Covered Code, and must include terms to the effect that the
62  * license from Licensee to its licensee is limited to the intellectual
63  * property embodied in the software Licensee provides to its licensee, and
64  * not to intellectual property embodied in modifications its licensee may
65  * make.
66  *
67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
68  * substantial portion of the Covered Code or modification must reproduce the
69  * above Copyright Notice, and the following Disclaimer and Export Compliance
70  * provision in the documentation and/or other materials provided with the
71  * distribution.
72  *
73  * 3.4. Intel retains all right, title, and interest in and to the Original
74  * Intel Code.
75  *
76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77  * Intel shall be used in advertising or otherwise to promote the sale, use or
78  * other dealings in products derived from or relating to the Covered Code
79  * without prior written authorization from Intel.
80  *
81  * 4. Disclaimer and Export Compliance
82  *
83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89  * PARTICULAR PURPOSE.
90  *
91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98  * LIMITED REMEDY.
99  *
100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
101  * software or system incorporating such software without first obtaining any
102  * required license or other approval from the U. S. Department of Commerce or
103  * any other agency or department of the United States Government. In the
104  * event Licensee exports any such software from the United States or
105  * re-exports any such software from a foreign destination, Licensee shall
106  * ensure that the distribution and export/re-export of the software is in
107  * compliance with all laws, regulations, orders, or other restrictions of the
108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109  * any of its subsidiaries will export/re-export any technical data, process,
110  * software, or service, directly or indirectly, to any country for which the
111  * United States government or any agency thereof requires an export license,
112  * other governmental approval, or letter of assurance, without first obtaining
113  * such license, approval or letter.
114  *
115  *****************************************************************************
116  *
117  * Alternatively, you may choose to be licensed under the terms of the
118  * following license:
119  *
120  * Redistribution and use in source and binary forms, with or without
121  * modification, are permitted provided that the following conditions
122  * are met:
123  * 1. Redistributions of source code must retain the above copyright
124  *    notice, this list of conditions, and the following disclaimer,
125  *    without modification.
126  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
127  *    substantially similar to the "NO WARRANTY" disclaimer below
128  *    ("Disclaimer") and any redistribution must be conditioned upon
129  *    including a substantially similar Disclaimer requirement for further
130  *    binary redistribution.
131  * 3. Neither the names of the above-listed copyright holders nor the names
132  *    of any contributors may be used to endorse or promote products derived
133  *    from this software without specific prior written permission.
134  *
135  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146  *
147  * Alternatively, you may choose to be licensed under the terms of the
148  * GNU General Public License ("GPL") version 2 as published by the Free
149  * Software Foundation.
150  *
151  *****************************************************************************/
152 
153 #include "acpi.h"
154 #include "accommon.h"
155 #include "acparser.h"
156 #include "amlcode.h"
157 #include "acdispat.h"
158 #include "acinterp.h"
159 #include "acnamesp.h"
160 #include "acdebug.h"
161 
162 
163 #define _COMPONENT          ACPI_DISPATCHER
164         ACPI_MODULE_NAME    ("dswexec")
165 
166 /*
167  * Dispatch table for opcode classes
168  */
169 static ACPI_EXECUTE_OP      AcpiGbl_OpTypeDispatch [] =
170 {
171     AcpiExOpcode_0A_0T_1R,
172     AcpiExOpcode_1A_0T_0R,
173     AcpiExOpcode_1A_0T_1R,
174     AcpiExOpcode_1A_1T_0R,
175     AcpiExOpcode_1A_1T_1R,
176     AcpiExOpcode_2A_0T_0R,
177     AcpiExOpcode_2A_0T_1R,
178     AcpiExOpcode_2A_1T_1R,
179     AcpiExOpcode_2A_2T_1R,
180     AcpiExOpcode_3A_0T_0R,
181     AcpiExOpcode_3A_1T_1R,
182     AcpiExOpcode_6A_0T_1R
183 };
184 
185 
186 /*****************************************************************************
187  *
188  * FUNCTION:    AcpiDsGetPredicateValue
189  *
190  * PARAMETERS:  WalkState       - Current state of the parse tree walk
191  *              ResultObj       - if non-zero, pop result from result stack
192  *
193  * RETURN:      Status
194  *
195  * DESCRIPTION: Get the result of a predicate evaluation
196  *
197  ****************************************************************************/
198 
199 ACPI_STATUS
200 AcpiDsGetPredicateValue (
201     ACPI_WALK_STATE         *WalkState,
202     ACPI_OPERAND_OBJECT     *ResultObj)
203 {
204     ACPI_STATUS             Status = AE_OK;
205     ACPI_OPERAND_OBJECT     *ObjDesc;
206     ACPI_OPERAND_OBJECT     *LocalObjDesc = NULL;
207 
208 
209     ACPI_FUNCTION_TRACE_PTR (DsGetPredicateValue, WalkState);
210 
211 
212     WalkState->ControlState->Common.State = 0;
213 
214     if (ResultObj)
215     {
216         Status = AcpiDsResultPop (&ObjDesc, WalkState);
217         if (ACPI_FAILURE (Status))
218         {
219             ACPI_EXCEPTION ((AE_INFO, Status,
220                 "Could not get result from predicate evaluation"));
221 
222             return_ACPI_STATUS (Status);
223         }
224     }
225     else
226     {
227         Status = AcpiDsCreateOperand (WalkState, WalkState->Op, 0);
228         if (ACPI_FAILURE (Status))
229         {
230             return_ACPI_STATUS (Status);
231         }
232 
233         Status = AcpiExResolveToValue (&WalkState->Operands [0], WalkState);
234         if (ACPI_FAILURE (Status))
235         {
236             return_ACPI_STATUS (Status);
237         }
238 
239         ObjDesc = WalkState->Operands [0];
240     }
241 
242     if (!ObjDesc)
243     {
244         ACPI_ERROR ((AE_INFO,
245             "No predicate ObjDesc=%p State=%p",
246             ObjDesc, WalkState));
247 
248         return_ACPI_STATUS (AE_AML_NO_OPERAND);
249     }
250 
251     /*
252      * Result of predicate evaluation must be an Integer
253      * object. Implicitly convert the argument if necessary.
254      */
255     Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc,
256         ACPI_IMPLICIT_CONVERSION);
257     if (ACPI_FAILURE (Status))
258     {
259         goto Cleanup;
260     }
261 
262     if (LocalObjDesc->Common.Type != ACPI_TYPE_INTEGER)
263     {
264         ACPI_ERROR ((AE_INFO,
265             "Bad predicate (not an integer) ObjDesc=%p State=%p Type=0x%X",
266             ObjDesc, WalkState, ObjDesc->Common.Type));
267 
268         Status = AE_AML_OPERAND_TYPE;
269         goto Cleanup;
270     }
271 
272     /* Truncate the predicate to 32-bits if necessary */
273 
274     (void) AcpiExTruncateFor32bitTable (LocalObjDesc);
275 
276     /*
277      * Save the result of the predicate evaluation on
278      * the control stack
279      */
280     if (LocalObjDesc->Integer.Value)
281     {
282         WalkState->ControlState->Common.Value = TRUE;
283     }
284     else
285     {
286         /*
287          * Predicate is FALSE, we will just toss the
288          * rest of the package
289          */
290         WalkState->ControlState->Common.Value = FALSE;
291         Status = AE_CTRL_FALSE;
292     }
293 
294     /* Predicate can be used for an implicit return value */
295 
296     (void) AcpiDsDoImplicitReturn (LocalObjDesc, WalkState, TRUE);
297 
298 
299 Cleanup:
300 
301     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
302         "Completed a predicate eval=%X Op=%p\n",
303         WalkState->ControlState->Common.Value, WalkState->Op));
304 
305 #ifdef ACPI_DEBUGGER
306     /* Break to debugger to display result */
307 
308     AcpiDbDisplayResultObject (LocalObjDesc, WalkState);
309 #endif
310 
311     /*
312      * Delete the predicate result object (we know that
313      * we don't need it anymore)
314      */
315     if (LocalObjDesc != ObjDesc)
316     {
317         AcpiUtRemoveReference (LocalObjDesc);
318     }
319     AcpiUtRemoveReference (ObjDesc);
320 
321     WalkState->ControlState->Common.State = ACPI_CONTROL_NORMAL;
322     return_ACPI_STATUS (Status);
323 }
324 
325 
326 /*****************************************************************************
327  *
328  * FUNCTION:    AcpiDsExecBeginOp
329  *
330  * PARAMETERS:  WalkState       - Current state of the parse tree walk
331  *              OutOp           - Where to return op if a new one is created
332  *
333  * RETURN:      Status
334  *
335  * DESCRIPTION: Descending callback used during the execution of control
336  *              methods. This is where most operators and operands are
337  *              dispatched to the interpreter.
338  *
339  ****************************************************************************/
340 
341 ACPI_STATUS
342 AcpiDsExecBeginOp (
343     ACPI_WALK_STATE         *WalkState,
344     ACPI_PARSE_OBJECT       **OutOp)
345 {
346     ACPI_PARSE_OBJECT       *Op;
347     ACPI_STATUS             Status = AE_OK;
348     UINT32                  OpcodeClass;
349 
350 
351     ACPI_FUNCTION_TRACE_PTR (DsExecBeginOp, WalkState);
352 
353 
354     Op = WalkState->Op;
355     if (!Op)
356     {
357         Status = AcpiDsLoad2BeginOp (WalkState, OutOp);
358         if (ACPI_FAILURE (Status))
359         {
360             goto ErrorExit;
361         }
362 
363         Op = *OutOp;
364         WalkState->Op = Op;
365         WalkState->Opcode = Op->Common.AmlOpcode;
366         WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
367 
368         if (AcpiNsOpensScope (WalkState->OpInfo->ObjectType))
369         {
370             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
371                 "(%s) Popping scope for Op %p\n",
372                 AcpiUtGetTypeName (WalkState->OpInfo->ObjectType), Op));
373 
374             Status = AcpiDsScopeStackPop (WalkState);
375             if (ACPI_FAILURE (Status))
376             {
377                 goto ErrorExit;
378             }
379         }
380     }
381 
382     if (Op == WalkState->Origin)
383     {
384         if (OutOp)
385         {
386             *OutOp = Op;
387         }
388 
389         return_ACPI_STATUS (AE_OK);
390     }
391 
392     /*
393      * If the previous opcode was a conditional, this opcode
394      * must be the beginning of the associated predicate.
395      * Save this knowledge in the current scope descriptor
396      */
397     if ((WalkState->ControlState) &&
398         (WalkState->ControlState->Common.State ==
399             ACPI_CONTROL_CONDITIONAL_EXECUTING))
400     {
401         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
402             "Exec predicate Op=%p State=%p\n",
403             Op, WalkState));
404 
405         WalkState->ControlState->Common.State =
406             ACPI_CONTROL_PREDICATE_EXECUTING;
407 
408         /* Save start of predicate */
409 
410         WalkState->ControlState->Control.PredicateOp = Op;
411     }
412 
413 
414     OpcodeClass = WalkState->OpInfo->Class;
415 
416     /* We want to send namepaths to the load code */
417 
418     if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP)
419     {
420         OpcodeClass = AML_CLASS_NAMED_OBJECT;
421     }
422 
423     /*
424      * Handle the opcode based upon the opcode type
425      */
426     switch (OpcodeClass)
427     {
428     case AML_CLASS_CONTROL:
429 
430         Status = AcpiDsExecBeginControlOp (WalkState, Op);
431         break;
432 
433     case AML_CLASS_NAMED_OBJECT:
434 
435         if (WalkState->WalkType & ACPI_WALK_METHOD)
436         {
437             /*
438              * Found a named object declaration during method execution;
439              * we must enter this object into the namespace. The created
440              * object is temporary and will be deleted upon completion of
441              * the execution of this method.
442              *
443              * Note 10/2010: Except for the Scope() op. This opcode does
444              * not actually create a new object, it refers to an existing
445              * object. However, for Scope(), we want to indeed open a
446              * new scope.
447              */
448             if (Op->Common.AmlOpcode != AML_SCOPE_OP)
449             {
450                 Status = AcpiDsLoad2BeginOp (WalkState, NULL);
451             }
452             else
453             {
454                 Status = AcpiDsScopeStackPush (
455                     Op->Named.Node, Op->Named.Node->Type, WalkState);
456                 if (ACPI_FAILURE (Status))
457                 {
458                     return_ACPI_STATUS (Status);
459                 }
460             }
461         }
462         break;
463 
464     case AML_CLASS_EXECUTE:
465     case AML_CLASS_CREATE:
466 
467         break;
468 
469     default:
470 
471         break;
472     }
473 
474     /* Nothing to do here during method execution */
475 
476     return_ACPI_STATUS (Status);
477 
478 
479 ErrorExit:
480     Status = AcpiDsMethodError (Status, WalkState);
481     return_ACPI_STATUS (Status);
482 }
483 
484 
485 /*****************************************************************************
486  *
487  * FUNCTION:    AcpiDsExecEndOp
488  *
489  * PARAMETERS:  WalkState       - Current state of the parse tree walk
490  *
491  * RETURN:      Status
492  *
493  * DESCRIPTION: Ascending callback used during the execution of control
494  *              methods. The only thing we really need to do here is to
495  *              notice the beginning of IF, ELSE, and WHILE blocks.
496  *
497  ****************************************************************************/
498 
499 ACPI_STATUS
500 AcpiDsExecEndOp (
501     ACPI_WALK_STATE         *WalkState)
502 {
503     ACPI_PARSE_OBJECT       *Op;
504     ACPI_STATUS             Status = AE_OK;
505     UINT32                  OpType;
506     UINT32                  OpClass;
507     ACPI_PARSE_OBJECT       *NextOp;
508     ACPI_PARSE_OBJECT       *FirstArg;
509 
510 
511     ACPI_FUNCTION_TRACE_PTR (DsExecEndOp, WalkState);
512 
513 
514     Op = WalkState->Op;
515     OpType = WalkState->OpInfo->Type;
516     OpClass = WalkState->OpInfo->Class;
517 
518     if (OpClass == AML_CLASS_UNKNOWN)
519     {
520         ACPI_ERROR ((AE_INFO, "Unknown opcode 0x%X", Op->Common.AmlOpcode));
521         return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
522     }
523 
524     FirstArg = Op->Common.Value.Arg;
525 
526     /* Init the walk state */
527 
528     WalkState->NumOperands = 0;
529     WalkState->OperandIndex = 0;
530     WalkState->ReturnDesc = NULL;
531     WalkState->ResultObj = NULL;
532 
533 #ifdef ACPI_DEBUGGER
534     /* Call debugger for single step support (DEBUG build only) */
535 
536     Status = AcpiDbSingleStep (WalkState, Op, OpClass);
537     if (ACPI_FAILURE (Status))
538     {
539         return_ACPI_STATUS (Status);
540     }
541 #endif
542 
543     /* Decode the Opcode Class */
544 
545     switch (OpClass)
546     {
547     case AML_CLASS_ARGUMENT:    /* Constants, literals, etc. */
548 
549         if (WalkState->Opcode == AML_INT_NAMEPATH_OP)
550         {
551             Status = AcpiDsEvaluateNamePath (WalkState);
552             if (ACPI_FAILURE (Status))
553             {
554                 goto Cleanup;
555             }
556         }
557         break;
558 
559     case AML_CLASS_EXECUTE:     /* Most operators with arguments */
560 
561         /* Build resolved operand stack */
562 
563         Status = AcpiDsCreateOperands (WalkState, FirstArg);
564         if (ACPI_FAILURE (Status))
565         {
566             goto Cleanup;
567         }
568 
569         /*
570          * All opcodes require operand resolution, with the only exceptions
571          * being the ObjectType and SizeOf operators.
572          */
573         if (!(WalkState->OpInfo->Flags & AML_NO_OPERAND_RESOLVE))
574         {
575             /* Resolve all operands */
576 
577             Status = AcpiExResolveOperands (WalkState->Opcode,
578                 &(WalkState->Operands [WalkState->NumOperands -1]),
579                 WalkState);
580         }
581 
582         if (ACPI_SUCCESS (Status))
583         {
584             /*
585              * Dispatch the request to the appropriate interpreter handler
586              * routine. There is one routine per opcode "type" based upon the
587              * number of opcode arguments and return type.
588              */
589             Status = AcpiGbl_OpTypeDispatch[OpType] (WalkState);
590         }
591         else
592         {
593             /*
594              * Treat constructs of the form "Store(LocalX,LocalX)" as noops when the
595              * Local is uninitialized.
596              */
597             if  ((Status == AE_AML_UNINITIALIZED_LOCAL) &&
598                 (WalkState->Opcode == AML_STORE_OP) &&
599                 (WalkState->Operands[0]->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
600                 (WalkState->Operands[1]->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
601                 (WalkState->Operands[0]->Reference.Class ==
602                  WalkState->Operands[1]->Reference.Class) &&
603                 (WalkState->Operands[0]->Reference.Value ==
604                  WalkState->Operands[1]->Reference.Value))
605             {
606                 Status = AE_OK;
607             }
608             else
609             {
610                 ACPI_EXCEPTION ((AE_INFO, Status,
611                     "While resolving operands for [%s]",
612                     AcpiPsGetOpcodeName (WalkState->Opcode)));
613             }
614         }
615 
616         /* Always delete the argument objects and clear the operand stack */
617 
618         AcpiDsClearOperands (WalkState);
619 
620         /*
621          * If a result object was returned from above, push it on the
622          * current result stack
623          */
624         if (ACPI_SUCCESS (Status) &&
625             WalkState->ResultObj)
626         {
627             Status = AcpiDsResultPush (WalkState->ResultObj, WalkState);
628         }
629         break;
630 
631     default:
632 
633         switch (OpType)
634         {
635         case AML_TYPE_CONTROL:    /* Type 1 opcode, IF/ELSE/WHILE/NOOP */
636 
637             /* 1 Operand, 0 ExternalResult, 0 InternalResult */
638 
639             Status = AcpiDsExecEndControlOp (WalkState, Op);
640 
641             break;
642 
643         case AML_TYPE_METHOD_CALL:
644             /*
645              * If the method is referenced from within a package
646              * declaration, it is not a invocation of the method, just
647              * a reference to it.
648              */
649             if ((Op->Asl.Parent) &&
650                ((Op->Asl.Parent->Asl.AmlOpcode == AML_PACKAGE_OP) ||
651                 (Op->Asl.Parent->Asl.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
652             {
653                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
654                     "Method Reference in a Package, Op=%p\n", Op));
655 
656                 Op->Common.Node = (ACPI_NAMESPACE_NODE *)
657                     Op->Asl.Value.Arg->Asl.Node;
658                 AcpiUtAddReference (Op->Asl.Value.Arg->Asl.Node->Object);
659                 return_ACPI_STATUS (AE_OK);
660             }
661 
662             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
663                 "Method invocation, Op=%p\n", Op));
664 
665             /*
666              * (AML_METHODCALL) Op->Asl.Value.Arg->Asl.Node contains
667              * the method Node pointer
668              */
669             /* NextOp points to the op that holds the method name */
670 
671             NextOp = FirstArg;
672 
673             /* NextOp points to first argument op */
674 
675             NextOp = NextOp->Common.Next;
676 
677             /*
678              * Get the method's arguments and put them on the operand stack
679              */
680             Status = AcpiDsCreateOperands (WalkState, NextOp);
681             if (ACPI_FAILURE (Status))
682             {
683                 break;
684             }
685 
686             /*
687              * Since the operands will be passed to another control method,
688              * we must resolve all local references here (Local variables,
689              * arguments to *this* method, etc.)
690              */
691             Status = AcpiDsResolveOperands (WalkState);
692             if (ACPI_FAILURE (Status))
693             {
694                 /* On error, clear all resolved operands */
695 
696                 AcpiDsClearOperands (WalkState);
697                 break;
698             }
699 
700             /*
701              * Tell the walk loop to preempt this running method and
702              * execute the new method
703              */
704             Status = AE_CTRL_TRANSFER;
705 
706             /*
707              * Return now; we don't want to disturb anything,
708              * especially the operand count!
709              */
710             return_ACPI_STATUS (Status);
711 
712         case AML_TYPE_CREATE_FIELD:
713 
714             ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
715                 "Executing CreateField Buffer/Index Op=%p\n", Op));
716 
717             Status = AcpiDsLoad2EndOp (WalkState);
718             if (ACPI_FAILURE (Status))
719             {
720                 break;
721             }
722 
723             Status = AcpiDsEvalBufferFieldOperands (WalkState, Op);
724             break;
725 
726 
727         case AML_TYPE_CREATE_OBJECT:
728 
729             ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
730                 "Executing CreateObject (Buffer/Package) Op=%p Child=%p ParentOpcode=%4.4X\n",
731                 Op, Op->Named.Value.Arg, Op->Common.Parent->Common.AmlOpcode));
732 
733             switch (Op->Common.Parent->Common.AmlOpcode)
734             {
735             case AML_NAME_OP:
736                 /*
737                  * Put the Node on the object stack (Contains the ACPI Name
738                  * of this object)
739                  */
740                 WalkState->Operands[0] = (void *)
741                     Op->Common.Parent->Common.Node;
742                 WalkState->NumOperands = 1;
743 
744                 Status = AcpiDsCreateNode (WalkState,
745                     Op->Common.Parent->Common.Node, Op->Common.Parent);
746                 if (ACPI_FAILURE (Status))
747                 {
748                     break;
749                 }
750 
751                 /* Fall through */
752                 /*lint -fallthrough */
753 
754             case AML_INT_EVAL_SUBTREE_OP:
755 
756                 Status = AcpiDsEvalDataObjectOperands (WalkState, Op,
757                     AcpiNsGetAttachedObject (Op->Common.Parent->Common.Node));
758                 break;
759 
760             default:
761 
762                 Status = AcpiDsEvalDataObjectOperands (WalkState, Op, NULL);
763                 break;
764             }
765 
766             /*
767              * If a result object was returned from above, push it on the
768              * current result stack
769              */
770             if (WalkState->ResultObj)
771             {
772                 Status = AcpiDsResultPush (WalkState->ResultObj, WalkState);
773             }
774             break;
775 
776         case AML_TYPE_NAMED_FIELD:
777         case AML_TYPE_NAMED_COMPLEX:
778         case AML_TYPE_NAMED_SIMPLE:
779         case AML_TYPE_NAMED_NO_OBJ:
780 
781             Status = AcpiDsLoad2EndOp (WalkState);
782             if (ACPI_FAILURE (Status))
783             {
784                 break;
785             }
786 
787             if (Op->Common.AmlOpcode == AML_REGION_OP)
788             {
789                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
790                     "Executing OpRegion Address/Length Op=%p\n", Op));
791 
792                 Status = AcpiDsEvalRegionOperands (WalkState, Op);
793                 if (ACPI_FAILURE (Status))
794                 {
795                     break;
796                 }
797             }
798             else if (Op->Common.AmlOpcode == AML_DATA_REGION_OP)
799             {
800                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
801                     "Executing DataTableRegion Strings Op=%p\n", Op));
802 
803                 Status = AcpiDsEvalTableRegionOperands (WalkState, Op);
804                 if (ACPI_FAILURE (Status))
805                 {
806                     break;
807                 }
808             }
809             else if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
810             {
811                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
812                     "Executing BankField Op=%p\n", Op));
813 
814                 Status = AcpiDsEvalBankFieldOperands (WalkState, Op);
815                 if (ACPI_FAILURE (Status))
816                 {
817                     break;
818                 }
819             }
820             break;
821 
822         case AML_TYPE_UNDEFINED:
823 
824             ACPI_ERROR ((AE_INFO,
825                 "Undefined opcode type Op=%p", Op));
826             return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
827 
828         case AML_TYPE_BOGUS:
829 
830             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
831                 "Internal opcode=%X type Op=%p\n",
832                 WalkState->Opcode, Op));
833             break;
834 
835         default:
836 
837             ACPI_ERROR ((AE_INFO,
838                 "Unimplemented opcode, class=0x%X "
839                 "type=0x%X Opcode=0x%X Op=%p",
840                 OpClass, OpType, Op->Common.AmlOpcode, Op));
841 
842             Status = AE_NOT_IMPLEMENTED;
843             break;
844         }
845     }
846 
847     /*
848      * ACPI 2.0 support for 64-bit integers: Truncate numeric
849      * result value if we are executing from a 32-bit ACPI table
850      */
851     (void) AcpiExTruncateFor32bitTable (WalkState->ResultObj);
852 
853     /*
854      * Check if we just completed the evaluation of a
855      * conditional predicate
856      */
857     if ((ACPI_SUCCESS (Status)) &&
858         (WalkState->ControlState) &&
859         (WalkState->ControlState->Common.State ==
860             ACPI_CONTROL_PREDICATE_EXECUTING) &&
861         (WalkState->ControlState->Control.PredicateOp == Op))
862     {
863         Status = AcpiDsGetPredicateValue (WalkState, WalkState->ResultObj);
864         WalkState->ResultObj = NULL;
865     }
866 
867 
868 Cleanup:
869 
870     if (WalkState->ResultObj)
871     {
872 #ifdef ACPI_DEBUGGER
873         /* Break to debugger to display result */
874 
875         AcpiDbDisplayResultObject (WalkState->ResultObj,WalkState);
876 #endif
877 
878         /*
879          * Delete the result op if and only if:
880          * Parent will not use the result -- such as any
881          * non-nested type2 op in a method (parent will be method)
882          */
883         AcpiDsDeleteResultIfNotUsed (Op, WalkState->ResultObj, WalkState);
884     }
885 
886 #ifdef _UNDER_DEVELOPMENT
887 
888     if (WalkState->ParserState.Aml == WalkState->ParserState.AmlEnd)
889     {
890         AcpiDbMethodEnd (WalkState);
891     }
892 #endif
893 
894     /* Invoke exception handler on error */
895 
896     if (ACPI_FAILURE (Status))
897     {
898         Status = AcpiDsMethodError (Status, WalkState);
899     }
900 
901     /* Always clear the object stack */
902 
903     WalkState->NumOperands = 0;
904     return_ACPI_STATUS (Status);
905 }
906