1 /*******************************************************************************
2  *
3  * Module Name: dsutils - Dispatcher utilities
4  *
5  ******************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2023, 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  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #include <contrib/dev/acpica/include/acpi.h>
153 #include <contrib/dev/acpica/include/accommon.h>
154 #include <contrib/dev/acpica/include/acparser.h>
155 #include <contrib/dev/acpica/include/amlcode.h>
156 #include <contrib/dev/acpica/include/acdispat.h>
157 #include <contrib/dev/acpica/include/acinterp.h>
158 #include <contrib/dev/acpica/include/acnamesp.h>
159 #include <contrib/dev/acpica/include/acdebug.h>
160 
161 #define _COMPONENT          ACPI_DISPATCHER
162         ACPI_MODULE_NAME    ("dsutils")
163 
164 
165 /*******************************************************************************
166  *
167  * FUNCTION:    AcpiDsClearImplicitReturn
168  *
169  * PARAMETERS:  WalkState           - Current State
170  *
171  * RETURN:      None.
172  *
173  * DESCRIPTION: Clear and remove a reference on an implicit return value. Used
174  *              to delete "stale" return values (if enabled, the return value
175  *              from every operator is saved at least momentarily, in case the
176  *              parent method exits.)
177  *
178  ******************************************************************************/
179 
180 void
AcpiDsClearImplicitReturn(ACPI_WALK_STATE * WalkState)181 AcpiDsClearImplicitReturn (
182     ACPI_WALK_STATE         *WalkState)
183 {
184     ACPI_FUNCTION_NAME (DsClearImplicitReturn);
185 
186 
187     /*
188      * Slack must be enabled for this feature
189      */
190     if (!AcpiGbl_EnableInterpreterSlack)
191     {
192         return;
193     }
194 
195     if (WalkState->ImplicitReturnObj)
196     {
197         /*
198          * Delete any "stale" implicit return. However, in
199          * complex statements, the implicit return value can be
200          * bubbled up several levels.
201          */
202         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
203             "Removing reference on stale implicit return obj %p\n",
204             WalkState->ImplicitReturnObj));
205 
206         AcpiUtRemoveReference (WalkState->ImplicitReturnObj);
207         WalkState->ImplicitReturnObj = NULL;
208     }
209 }
210 
211 
212 /*******************************************************************************
213  *
214  * FUNCTION:    AcpiDsDoImplicitReturn
215  *
216  * PARAMETERS:  ReturnDesc          - The return value
217  *              WalkState           - Current State
218  *              AddReference        - True if a reference should be added to the
219  *                                    return object
220  *
221  * RETURN:      TRUE if implicit return enabled, FALSE otherwise
222  *
223  * DESCRIPTION: Implements the optional "implicit return".  We save the result
224  *              of every ASL operator and control method invocation in case the
225  *              parent method exit. Before storing a new return value, we
226  *              delete the previous return value.
227  *
228  ******************************************************************************/
229 
230 BOOLEAN
AcpiDsDoImplicitReturn(ACPI_OPERAND_OBJECT * ReturnDesc,ACPI_WALK_STATE * WalkState,BOOLEAN AddReference)231 AcpiDsDoImplicitReturn (
232     ACPI_OPERAND_OBJECT     *ReturnDesc,
233     ACPI_WALK_STATE         *WalkState,
234     BOOLEAN                 AddReference)
235 {
236     ACPI_FUNCTION_NAME (DsDoImplicitReturn);
237 
238 
239     /*
240      * Slack must be enabled for this feature, and we must
241      * have a valid return object
242      */
243     if ((!AcpiGbl_EnableInterpreterSlack) ||
244         (!ReturnDesc))
245     {
246         return (FALSE);
247     }
248 
249     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
250         "Result %p will be implicitly returned; Prev=%p\n",
251         ReturnDesc,
252         WalkState->ImplicitReturnObj));
253 
254     /*
255      * Delete any "stale" implicit return value first. However, in
256      * complex statements, the implicit return value can be
257      * bubbled up several levels, so we don't clear the value if it
258      * is the same as the ReturnDesc.
259      */
260     if (WalkState->ImplicitReturnObj)
261     {
262         if (WalkState->ImplicitReturnObj == ReturnDesc)
263         {
264             return (TRUE);
265         }
266         AcpiDsClearImplicitReturn (WalkState);
267     }
268 
269     /* Save the implicit return value, add a reference if requested */
270 
271     WalkState->ImplicitReturnObj = ReturnDesc;
272     if (AddReference)
273     {
274         AcpiUtAddReference (ReturnDesc);
275     }
276 
277     return (TRUE);
278 }
279 
280 
281 /*******************************************************************************
282  *
283  * FUNCTION:    AcpiDsIsResultUsed
284  *
285  * PARAMETERS:  Op                  - Current Op
286  *              WalkState           - Current State
287  *
288  * RETURN:      TRUE if result is used, FALSE otherwise
289  *
290  * DESCRIPTION: Check if a result object will be used by the parent
291  *
292  ******************************************************************************/
293 
294 BOOLEAN
AcpiDsIsResultUsed(ACPI_PARSE_OBJECT * Op,ACPI_WALK_STATE * WalkState)295 AcpiDsIsResultUsed (
296     ACPI_PARSE_OBJECT       *Op,
297     ACPI_WALK_STATE         *WalkState)
298 {
299     const ACPI_OPCODE_INFO  *ParentInfo;
300 
301     ACPI_FUNCTION_TRACE_PTR (DsIsResultUsed, Op);
302 
303 
304     /* Must have both an Op and a Result Object */
305 
306     if (!Op)
307     {
308         ACPI_ERROR ((AE_INFO, "Null Op"));
309         return_UINT8 (TRUE);
310     }
311 
312     /*
313      * We know that this operator is not a
314      * Return() operator (would not come here.) The following code is the
315      * optional support for a so-called "implicit return". Some AML code
316      * assumes that the last value of the method is "implicitly" returned
317      * to the caller. Just save the last result as the return value.
318      * NOTE: this is optional because the ASL language does not actually
319      * support this behavior.
320      */
321     (void) AcpiDsDoImplicitReturn (WalkState->ResultObj, WalkState, TRUE);
322 
323     /*
324      * Now determine if the parent will use the result
325      *
326      * If there is no parent, or the parent is a ScopeOp, we are executing
327      * at the method level. An executing method typically has no parent,
328      * since each method is parsed separately. A method invoked externally
329      * via ExecuteControlMethod has a ScopeOp as the parent.
330      */
331     if ((!Op->Common.Parent) ||
332         (Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
333     {
334         /* No parent, the return value cannot possibly be used */
335 
336         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
337             "At Method level, result of [%s] not used\n",
338             AcpiPsGetOpcodeName (Op->Common.AmlOpcode)));
339         return_UINT8 (FALSE);
340     }
341 
342     /* Get info on the parent. The RootOp is AML_SCOPE */
343 
344     ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
345     if (ParentInfo->Class == AML_CLASS_UNKNOWN)
346     {
347         ACPI_ERROR ((AE_INFO,
348             "Unknown parent opcode Op=%p", Op));
349         return_UINT8 (FALSE);
350     }
351 
352     /*
353      * Decide what to do with the result based on the parent. If
354      * the parent opcode will not use the result, delete the object.
355      * Otherwise leave it as is, it will be deleted when it is used
356      * as an operand later.
357      */
358     switch (ParentInfo->Class)
359     {
360     case AML_CLASS_CONTROL:
361 
362         switch (Op->Common.Parent->Common.AmlOpcode)
363         {
364         case AML_RETURN_OP:
365 
366             /* Never delete the return value associated with a return opcode */
367 
368             goto ResultUsed;
369 
370         case AML_IF_OP:
371         case AML_WHILE_OP:
372             /*
373              * If we are executing the predicate AND this is the predicate op,
374              * we will use the return value
375              */
376             if ((WalkState->ControlState->Common.State ==
377                     ACPI_CONTROL_PREDICATE_EXECUTING) &&
378                 (WalkState->ControlState->Control.PredicateOp == Op))
379             {
380                 goto ResultUsed;
381             }
382             break;
383 
384         default:
385 
386             /* Ignore other control opcodes */
387 
388             break;
389         }
390 
391         /* The general control opcode returns no result */
392 
393         goto ResultNotUsed;
394 
395     case AML_CLASS_CREATE:
396         /*
397          * These opcodes allow TermArg(s) as operands and therefore
398          * the operands can be method calls. The result is used.
399          */
400         goto ResultUsed;
401 
402     case AML_CLASS_NAMED_OBJECT:
403 
404         if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP)       ||
405             (Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP)  ||
406             (Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP)      ||
407             (Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP)       ||
408             (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP) ||
409             (Op->Common.Parent->Common.AmlOpcode == AML_INT_EVAL_SUBTREE_OP) ||
410             (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP))
411         {
412             /*
413              * These opcodes allow TermArg(s) as operands and therefore
414              * the operands can be method calls. The result is used.
415              */
416             goto ResultUsed;
417         }
418 
419         goto ResultNotUsed;
420 
421     default:
422         /*
423          * In all other cases. the parent will actually use the return
424          * object, so keep it.
425          */
426         goto ResultUsed;
427     }
428 
429 
430 ResultUsed:
431     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
432         "Result of [%s] used by Parent [%s] Op=%p\n",
433         AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
434         AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
435 
436     return_UINT8 (TRUE);
437 
438 
439 ResultNotUsed:
440     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
441         "Result of [%s] not used by Parent [%s] Op=%p\n",
442         AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
443         AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
444 
445     return_UINT8 (FALSE);
446 }
447 
448 
449 /*******************************************************************************
450  *
451  * FUNCTION:    AcpiDsDeleteResultIfNotUsed
452  *
453  * PARAMETERS:  Op              - Current parse Op
454  *              ResultObj       - Result of the operation
455  *              WalkState       - Current state
456  *
457  * RETURN:      Status
458  *
459  * DESCRIPTION: Used after interpretation of an opcode. If there is an internal
460  *              result descriptor, check if the parent opcode will actually use
461  *              this result. If not, delete the result now so that it will
462  *              not become orphaned.
463  *
464  ******************************************************************************/
465 
466 void
AcpiDsDeleteResultIfNotUsed(ACPI_PARSE_OBJECT * Op,ACPI_OPERAND_OBJECT * ResultObj,ACPI_WALK_STATE * WalkState)467 AcpiDsDeleteResultIfNotUsed (
468     ACPI_PARSE_OBJECT       *Op,
469     ACPI_OPERAND_OBJECT     *ResultObj,
470     ACPI_WALK_STATE         *WalkState)
471 {
472     ACPI_OPERAND_OBJECT     *ObjDesc;
473     ACPI_STATUS             Status;
474 
475 
476     ACPI_FUNCTION_TRACE_PTR (DsDeleteResultIfNotUsed, ResultObj);
477 
478 
479     if (!Op)
480     {
481         ACPI_ERROR ((AE_INFO, "Null Op"));
482         return_VOID;
483     }
484 
485     if (!ResultObj)
486     {
487         return_VOID;
488     }
489 
490     if (!AcpiDsIsResultUsed (Op, WalkState))
491     {
492         /* Must pop the result stack (ObjDesc should be equal to ResultObj) */
493 
494         Status = AcpiDsResultPop (&ObjDesc, WalkState);
495         if (ACPI_SUCCESS (Status))
496         {
497             AcpiUtRemoveReference (ResultObj);
498         }
499     }
500 
501     return_VOID;
502 }
503 
504 
505 /*******************************************************************************
506  *
507  * FUNCTION:    AcpiDsResolveOperands
508  *
509  * PARAMETERS:  WalkState           - Current walk state with operands on stack
510  *
511  * RETURN:      Status
512  *
513  * DESCRIPTION: Resolve all operands to their values. Used to prepare
514  *              arguments to a control method invocation (a call from one
515  *              method to another.)
516  *
517  ******************************************************************************/
518 
519 ACPI_STATUS
AcpiDsResolveOperands(ACPI_WALK_STATE * WalkState)520 AcpiDsResolveOperands (
521     ACPI_WALK_STATE         *WalkState)
522 {
523     UINT32                  i;
524     ACPI_STATUS             Status = AE_OK;
525 
526 
527     ACPI_FUNCTION_TRACE_PTR (DsResolveOperands, WalkState);
528 
529 
530     /*
531      * Attempt to resolve each of the valid operands
532      * Method arguments are passed by reference, not by value. This means
533      * that the actual objects are passed, not copies of the objects.
534      */
535     for (i = 0; i < WalkState->NumOperands; i++)
536     {
537         Status = AcpiExResolveToValue (&WalkState->Operands[i], WalkState);
538         if (ACPI_FAILURE (Status))
539         {
540             break;
541         }
542     }
543 
544     return_ACPI_STATUS (Status);
545 }
546 
547 
548 /*******************************************************************************
549  *
550  * FUNCTION:    AcpiDsClearOperands
551  *
552  * PARAMETERS:  WalkState           - Current walk state with operands on stack
553  *
554  * RETURN:      None
555  *
556  * DESCRIPTION: Clear all operands on the current walk state operand stack.
557  *
558  ******************************************************************************/
559 
560 void
AcpiDsClearOperands(ACPI_WALK_STATE * WalkState)561 AcpiDsClearOperands (
562     ACPI_WALK_STATE         *WalkState)
563 {
564     UINT32                  i;
565 
566 
567     ACPI_FUNCTION_TRACE_PTR (DsClearOperands, WalkState);
568 
569 
570     /* Remove a reference on each operand on the stack */
571 
572     for (i = 0; i < WalkState->NumOperands; i++)
573     {
574         /*
575          * Remove a reference to all operands, including both
576          * "Arguments" and "Targets".
577          */
578         AcpiUtRemoveReference (WalkState->Operands[i]);
579         WalkState->Operands[i] = NULL;
580     }
581 
582     WalkState->NumOperands = 0;
583     return_VOID;
584 }
585 
586 
587 /*******************************************************************************
588  *
589  * FUNCTION:    AcpiDsCreateOperand
590  *
591  * PARAMETERS:  WalkState       - Current walk state
592  *              Arg             - Parse object for the argument
593  *              ArgIndex        - Which argument (zero based)
594  *
595  * RETURN:      Status
596  *
597  * DESCRIPTION: Translate a parse tree object that is an argument to an AML
598  *              opcode to the equivalent interpreter object. This may include
599  *              looking up a name or entering a new name into the internal
600  *              namespace.
601  *
602  ******************************************************************************/
603 
604 ACPI_STATUS
AcpiDsCreateOperand(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT * Arg,UINT32 ArgIndex)605 AcpiDsCreateOperand (
606     ACPI_WALK_STATE         *WalkState,
607     ACPI_PARSE_OBJECT       *Arg,
608     UINT32                  ArgIndex)
609 {
610     ACPI_STATUS             Status = AE_OK;
611     char                    *NameString;
612     UINT32                  NameLength;
613     ACPI_OPERAND_OBJECT     *ObjDesc;
614     ACPI_PARSE_OBJECT       *ParentOp;
615     UINT16                  Opcode;
616     ACPI_INTERPRETER_MODE   InterpreterMode;
617     const ACPI_OPCODE_INFO  *OpInfo;
618 
619 
620     ACPI_FUNCTION_TRACE_PTR (DsCreateOperand, Arg);
621 
622 
623     /* A valid name must be looked up in the namespace */
624 
625     if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
626         (Arg->Common.Value.String) &&
627         !(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
628     {
629         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", Arg));
630 
631         /* Get the entire name string from the AML stream */
632 
633         Status = AcpiExGetNameString (ACPI_TYPE_ANY,
634             Arg->Common.Value.Buffer, &NameString, &NameLength);
635 
636         if (ACPI_FAILURE (Status))
637         {
638             return_ACPI_STATUS (Status);
639         }
640 
641         /* All prefixes have been handled, and the name is in NameString */
642 
643         /*
644          * Special handling for BufferField declarations. This is a deferred
645          * opcode that unfortunately defines the field name as the last
646          * parameter instead of the first. We get here when we are performing
647          * the deferred execution, so the actual name of the field is already
648          * in the namespace. We don't want to attempt to look it up again
649          * because we may be executing in a different scope than where the
650          * actual opcode exists.
651          */
652         if ((WalkState->DeferredNode) &&
653             (WalkState->DeferredNode->Type == ACPI_TYPE_BUFFER_FIELD) &&
654             (ArgIndex == (UINT32)
655                 ((WalkState->Opcode == AML_CREATE_FIELD_OP) ? 3 : 2)))
656         {
657             ObjDesc = ACPI_CAST_PTR (
658                 ACPI_OPERAND_OBJECT, WalkState->DeferredNode);
659             Status = AE_OK;
660         }
661         else    /* All other opcodes */
662         {
663             /*
664              * Differentiate between a namespace "create" operation
665              * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
666              * IMODE_EXECUTE) in order to support the creation of
667              * namespace objects during the execution of control methods.
668              */
669             ParentOp = Arg->Common.Parent;
670             OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Common.AmlOpcode);
671 
672             if ((OpInfo->Flags & AML_NSNODE) &&
673                 (ParentOp->Common.AmlOpcode != AML_INT_METHODCALL_OP) &&
674                 (ParentOp->Common.AmlOpcode != AML_REGION_OP) &&
675                 (ParentOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP))
676             {
677                 /* Enter name into namespace if not found */
678 
679                 InterpreterMode = ACPI_IMODE_LOAD_PASS2;
680             }
681             else
682             {
683                 /* Return a failure if name not found */
684 
685                 InterpreterMode = ACPI_IMODE_EXECUTE;
686             }
687 
688             Status = AcpiNsLookup (WalkState->ScopeInfo, NameString,
689                 ACPI_TYPE_ANY, InterpreterMode,
690                 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, WalkState,
691                 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &ObjDesc));
692             /*
693              * The only case where we pass through (ignore) a NOT_FOUND
694              * error is for the CondRefOf opcode.
695              */
696             if (Status == AE_NOT_FOUND)
697             {
698                 if (ParentOp->Common.AmlOpcode == AML_CONDITIONAL_REF_OF_OP)
699                 {
700                     /*
701                      * For the Conditional Reference op, it's OK if
702                      * the name is not found;  We just need a way to
703                      * indicate this to the interpreter, set the
704                      * object to the root
705                      */
706                     ObjDesc = ACPI_CAST_PTR (
707                         ACPI_OPERAND_OBJECT, AcpiGbl_RootNode);
708                     Status = AE_OK;
709                 }
710                 else if (ParentOp->Common.AmlOpcode == AML_EXTERNAL_OP)
711                 {
712                     /*
713                      * This opcode should never appear here. It is used only
714                      * by AML disassemblers and is surrounded by an If(0)
715                      * by the ASL compiler.
716                      *
717                      * Therefore, if we see it here, it is a serious error.
718                      */
719                     Status = AE_AML_BAD_OPCODE;
720                 }
721                 else
722                 {
723                     /*
724                      * We just plain didn't find it -- which is a
725                      * very serious error at this point
726                      */
727                     Status = AE_AML_NAME_NOT_FOUND;
728                 }
729             }
730 
731             if (ACPI_FAILURE (Status))
732             {
733                 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo,
734                     NameString, Status);
735             }
736         }
737 
738         /* Free the namestring created above */
739 
740         ACPI_FREE (NameString);
741 
742         /* Check status from the lookup */
743 
744         if (ACPI_FAILURE (Status))
745         {
746             return_ACPI_STATUS (Status);
747         }
748 
749         /* Put the resulting object onto the current object stack */
750 
751         Status = AcpiDsObjStackPush (ObjDesc, WalkState);
752         if (ACPI_FAILURE (Status))
753         {
754             return_ACPI_STATUS (Status);
755         }
756 
757         AcpiDbDisplayArgumentObject (ObjDesc, WalkState);
758     }
759     else
760     {
761         /* Check for null name case */
762 
763         if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
764             !(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
765         {
766             /*
767              * If the name is null, this means that this is an
768              * optional result parameter that was not specified
769              * in the original ASL. Create a Zero Constant for a
770              * placeholder. (Store to a constant is a Noop.)
771              */
772             Opcode = AML_ZERO_OP;       /* Has no arguments! */
773 
774             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
775                 "Null namepath: Arg=%p\n", Arg));
776         }
777         else
778         {
779             Opcode = Arg->Common.AmlOpcode;
780         }
781 
782         /* Get the object type of the argument */
783 
784         OpInfo = AcpiPsGetOpcodeInfo (Opcode);
785         if (OpInfo->ObjectType == ACPI_TYPE_INVALID)
786         {
787             return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
788         }
789 
790         if ((OpInfo->Flags & AML_HAS_RETVAL) ||
791             (Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
792         {
793             /*
794              * Use value that was already previously returned
795              * by the evaluation of this argument
796              */
797             Status = AcpiDsResultPop (&ObjDesc, WalkState);
798             if (ACPI_FAILURE (Status))
799             {
800                 /*
801                  * Only error is underflow, and this indicates
802                  * a missing or null operand!
803                  */
804                 ACPI_EXCEPTION ((AE_INFO, Status,
805                     "Missing or null operand"));
806                 return_ACPI_STATUS (Status);
807             }
808         }
809         else
810         {
811             /* Create an ACPI_INTERNAL_OBJECT for the argument */
812 
813             ObjDesc = AcpiUtCreateInternalObject (OpInfo->ObjectType);
814             if (!ObjDesc)
815             {
816                 return_ACPI_STATUS (AE_NO_MEMORY);
817             }
818 
819             /* Initialize the new object */
820 
821             Status = AcpiDsInitObjectFromOp (
822                 WalkState, Arg, Opcode, &ObjDesc);
823             if (ACPI_FAILURE (Status))
824             {
825                 AcpiUtDeleteObjectDesc (ObjDesc);
826                 return_ACPI_STATUS (Status);
827             }
828         }
829 
830         /* Put the operand object on the object stack */
831 
832         Status = AcpiDsObjStackPush (ObjDesc, WalkState);
833         if (ACPI_FAILURE (Status))
834         {
835             return_ACPI_STATUS (Status);
836         }
837 
838         AcpiDbDisplayArgumentObject (ObjDesc, WalkState);
839     }
840 
841     return_ACPI_STATUS (AE_OK);
842 }
843 
844 
845 /*******************************************************************************
846  *
847  * FUNCTION:    AcpiDsCreateOperands
848  *
849  * PARAMETERS:  WalkState           - Current state
850  *              FirstArg            - First argument of a parser argument tree
851  *
852  * RETURN:      Status
853  *
854  * DESCRIPTION: Convert an operator's arguments from a parse tree format to
855  *              namespace objects and place those argument object on the object
856  *              stack in preparation for evaluation by the interpreter.
857  *
858  ******************************************************************************/
859 
860 ACPI_STATUS
AcpiDsCreateOperands(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT * FirstArg)861 AcpiDsCreateOperands (
862     ACPI_WALK_STATE         *WalkState,
863     ACPI_PARSE_OBJECT       *FirstArg)
864 {
865     ACPI_STATUS             Status = AE_OK;
866     ACPI_PARSE_OBJECT       *Arg;
867     ACPI_PARSE_OBJECT       *Arguments[ACPI_OBJ_NUM_OPERANDS];
868     UINT32                  ArgCount = 0;
869     UINT32                  Index = WalkState->NumOperands;
870     UINT32                  i;
871 
872 
873     ACPI_FUNCTION_TRACE_PTR (DsCreateOperands, FirstArg);
874 
875 
876     /* Get all arguments in the list */
877 
878     Arg = FirstArg;
879     while (Arg)
880     {
881         if (Index >= ACPI_OBJ_NUM_OPERANDS)
882         {
883             return_ACPI_STATUS (AE_BAD_DATA);
884         }
885 
886         Arguments[Index] = Arg;
887         WalkState->Operands [Index] = NULL;
888 
889         /* Move on to next argument, if any */
890 
891         Arg = Arg->Common.Next;
892         ArgCount++;
893         Index++;
894     }
895 
896     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
897         "NumOperands %d, ArgCount %d, Index %d\n",
898         WalkState->NumOperands, ArgCount, Index));
899 
900     /* Create the interpreter arguments, in reverse order */
901 
902     Index--;
903     for (i = 0; i < ArgCount; i++)
904     {
905         Arg = Arguments[Index];
906         WalkState->OperandIndex = (UINT8) Index;
907 
908         Status = AcpiDsCreateOperand (WalkState, Arg, Index);
909         if (ACPI_FAILURE (Status))
910         {
911             goto Cleanup;
912         }
913 
914         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
915             "Created Arg #%u (%p) %u args total\n",
916             Index, Arg, ArgCount));
917         Index--;
918     }
919 
920     return_ACPI_STATUS (Status);
921 
922 
923 Cleanup:
924     /*
925      * We must undo everything done above; meaning that we must
926      * pop everything off of the operand stack and delete those
927      * objects
928      */
929     AcpiDsObjStackPopAndDelete (ArgCount, WalkState);
930 
931     ACPI_EXCEPTION ((AE_INFO, Status, "While creating Arg %u", Index));
932     return_ACPI_STATUS (Status);
933 }
934 
935 
936 /*****************************************************************************
937  *
938  * FUNCTION:    AcpiDsEvaluateNamePath
939  *
940  * PARAMETERS:  WalkState       - Current state of the parse tree walk,
941  *                                the opcode of current operation should be
942  *                                AML_INT_NAMEPATH_OP
943  *
944  * RETURN:      Status
945  *
946  * DESCRIPTION: Translate the -NamePath- parse tree object to the equivalent
947  *              interpreter object, convert it to value, if needed, duplicate
948  *              it, if needed, and push it onto the current result stack.
949  *
950  ****************************************************************************/
951 
952 ACPI_STATUS
AcpiDsEvaluateNamePath(ACPI_WALK_STATE * WalkState)953 AcpiDsEvaluateNamePath (
954     ACPI_WALK_STATE         *WalkState)
955 {
956     ACPI_STATUS             Status = AE_OK;
957     ACPI_PARSE_OBJECT       *Op = WalkState->Op;
958     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
959     ACPI_OPERAND_OBJECT     *NewObjDesc;
960     UINT8                   Type;
961 
962 
963     ACPI_FUNCTION_TRACE_PTR (DsEvaluateNamePath, WalkState);
964 
965 
966     if (!Op->Common.Parent)
967     {
968         /* This happens after certain exception processing */
969 
970         goto Exit;
971     }
972 
973     if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
974         (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP) ||
975         (Op->Common.Parent->Common.AmlOpcode == AML_REF_OF_OP))
976     {
977         /* TBD: Should we specify this feature as a bit of OpInfo->Flags of these opcodes? */
978 
979         goto Exit;
980     }
981 
982     Status = AcpiDsCreateOperand (WalkState, Op, 0);
983     if (ACPI_FAILURE (Status))
984     {
985         goto Exit;
986     }
987 
988     if (Op->Common.Flags & ACPI_PARSEOP_TARGET)
989     {
990         NewObjDesc = *Operand;
991         goto PushResult;
992     }
993 
994     Type = (*Operand)->Common.Type;
995 
996     Status = AcpiExResolveToValue (Operand, WalkState);
997     if (ACPI_FAILURE (Status))
998     {
999         goto Exit;
1000     }
1001 
1002     if (Type == ACPI_TYPE_INTEGER)
1003     {
1004         /* It was incremented by AcpiExResolveToValue */
1005 
1006         AcpiUtRemoveReference (*Operand);
1007 
1008         Status = AcpiUtCopyIobjectToIobject (
1009             *Operand, &NewObjDesc, WalkState);
1010         if (ACPI_FAILURE (Status))
1011         {
1012             goto Exit;
1013         }
1014     }
1015     else
1016     {
1017         /*
1018          * The object either was anew created or is
1019          * a Namespace node - don't decrement it.
1020          */
1021         NewObjDesc = *Operand;
1022     }
1023 
1024     /* Cleanup for name-path operand */
1025 
1026     Status = AcpiDsObjStackPop (1, WalkState);
1027     if (ACPI_FAILURE (Status))
1028     {
1029         WalkState->ResultObj = NewObjDesc;
1030         goto Exit;
1031     }
1032 
1033 PushResult:
1034 
1035     WalkState->ResultObj = NewObjDesc;
1036 
1037     Status = AcpiDsResultPush (WalkState->ResultObj, WalkState);
1038     if (ACPI_SUCCESS (Status))
1039     {
1040         /* Force to take it from stack */
1041 
1042         Op->Common.Flags |= ACPI_PARSEOP_IN_STACK;
1043     }
1044 
1045 Exit:
1046 
1047     return_ACPI_STATUS (Status);
1048 }
1049