Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / acpi / dispatcher / dsutils.c
1 /*******************************************************************************
2  *
3  * Module Name: dsutils - Dispatcher utilities
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2006, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acparser.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acdispat.h>
48 #include <acpi/acinterp.h>
49 #include <acpi/acnamesp.h>
50 #include <acpi/acdebug.h>
51
52 #define _COMPONENT          ACPI_DISPATCHER
53 ACPI_MODULE_NAME("dsutils")
54
55 /*******************************************************************************
56  *
57  * FUNCTION:    acpi_ds_clear_implicit_return
58  *
59  * PARAMETERS:  walk_state          - Current State
60  *
61  * RETURN:      None.
62  *
63  * DESCRIPTION: Clear and remove a reference on an implicit return value.  Used
64  *              to delete "stale" return values (if enabled, the return value
65  *              from every operator is saved at least momentarily, in case the
66  *              parent method exits.)
67  *
68  ******************************************************************************/
69 void acpi_ds_clear_implicit_return(struct acpi_walk_state *walk_state)
70 {
71         ACPI_FUNCTION_NAME("ds_clear_implicit_return");
72
73         /*
74          * Slack must be enabled for this feature
75          */
76         if (!acpi_gbl_enable_interpreter_slack) {
77                 return;
78         }
79
80         if (walk_state->implicit_return_obj) {
81                 /*
82                  * Delete any "stale" implicit return. However, in
83                  * complex statements, the implicit return value can be
84                  * bubbled up several levels.
85                  */
86                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
87                                   "Removing reference on stale implicit return obj %p\n",
88                                   walk_state->implicit_return_obj));
89
90                 acpi_ut_remove_reference(walk_state->implicit_return_obj);
91                 walk_state->implicit_return_obj = NULL;
92         }
93 }
94
95 #ifndef ACPI_NO_METHOD_EXECUTION
96 /*******************************************************************************
97  *
98  * FUNCTION:    acpi_ds_do_implicit_return
99  *
100  * PARAMETERS:  return_desc         - The return value
101  *              walk_state          - Current State
102  *              add_reference       - True if a reference should be added to the
103  *                                    return object
104  *
105  * RETURN:      TRUE if implicit return enabled, FALSE otherwise
106  *
107  * DESCRIPTION: Implements the optional "implicit return".  We save the result
108  *              of every ASL operator and control method invocation in case the
109  *              parent method exit.  Before storing a new return value, we
110  *              delete the previous return value.
111  *
112  ******************************************************************************/
113
114 u8
115 acpi_ds_do_implicit_return(union acpi_operand_object *return_desc,
116                            struct acpi_walk_state *walk_state, u8 add_reference)
117 {
118         ACPI_FUNCTION_NAME("ds_do_implicit_return");
119
120         /*
121          * Slack must be enabled for this feature, and we must
122          * have a valid return object
123          */
124         if ((!acpi_gbl_enable_interpreter_slack) || (!return_desc)) {
125                 return (FALSE);
126         }
127
128         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
129                           "Result %p will be implicitly returned; Prev=%p\n",
130                           return_desc, walk_state->implicit_return_obj));
131
132         /*
133          * Delete any "stale" implicit return value first. However, in
134          * complex statements, the implicit return value can be
135          * bubbled up several levels, so we don't clear the value if it
136          * is the same as the return_desc.
137          */
138         if (walk_state->implicit_return_obj) {
139                 if (walk_state->implicit_return_obj == return_desc) {
140                         return (TRUE);
141                 }
142                 acpi_ds_clear_implicit_return(walk_state);
143         }
144
145         /* Save the implicit return value, add a reference if requested */
146
147         walk_state->implicit_return_obj = return_desc;
148         if (add_reference) {
149                 acpi_ut_add_reference(return_desc);
150         }
151
152         return (TRUE);
153 }
154
155 /*******************************************************************************
156  *
157  * FUNCTION:    acpi_ds_is_result_used
158  *
159  * PARAMETERS:  Op                  - Current Op
160  *              walk_state          - Current State
161  *
162  * RETURN:      TRUE if result is used, FALSE otherwise
163  *
164  * DESCRIPTION: Check if a result object will be used by the parent
165  *
166  ******************************************************************************/
167
168 u8
169 acpi_ds_is_result_used(union acpi_parse_object * op,
170                        struct acpi_walk_state * walk_state)
171 {
172         const struct acpi_opcode_info *parent_info;
173
174         ACPI_FUNCTION_TRACE_PTR("ds_is_result_used", op);
175
176         /* Must have both an Op and a Result Object */
177
178         if (!op) {
179                 ACPI_ERROR((AE_INFO, "Null Op"));
180                 return_UINT8(TRUE);
181         }
182
183         /*
184          * We know that this operator is not a
185          * Return() operator (would not come here.) The following code is the
186          * optional support for a so-called "implicit return". Some AML code
187          * assumes that the last value of the method is "implicitly" returned
188          * to the caller. Just save the last result as the return value.
189          * NOTE: this is optional because the ASL language does not actually
190          * support this behavior.
191          */
192         (void)acpi_ds_do_implicit_return(walk_state->result_obj, walk_state,
193                                          TRUE);
194
195         /*
196          * Now determine if the parent will use the result
197          *
198          * If there is no parent, or the parent is a scope_op, we are executing
199          * at the method level. An executing method typically has no parent,
200          * since each method is parsed separately.  A method invoked externally
201          * via execute_control_method has a scope_op as the parent.
202          */
203         if ((!op->common.parent) ||
204             (op->common.parent->common.aml_opcode == AML_SCOPE_OP)) {
205                 /* No parent, the return value cannot possibly be used */
206
207                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
208                                   "At Method level, result of [%s] not used\n",
209                                   acpi_ps_get_opcode_name(op->common.
210                                                           aml_opcode)));
211                 return_UINT8(FALSE);
212         }
213
214         /* Get info on the parent. The root_op is AML_SCOPE */
215
216         parent_info =
217             acpi_ps_get_opcode_info(op->common.parent->common.aml_opcode);
218         if (parent_info->class == AML_CLASS_UNKNOWN) {
219                 ACPI_ERROR((AE_INFO, "Unknown parent opcode Op=%p", op));
220                 return_UINT8(FALSE);
221         }
222
223         /*
224          * Decide what to do with the result based on the parent.  If
225          * the parent opcode will not use the result, delete the object.
226          * Otherwise leave it as is, it will be deleted when it is used
227          * as an operand later.
228          */
229         switch (parent_info->class) {
230         case AML_CLASS_CONTROL:
231
232                 switch (op->common.parent->common.aml_opcode) {
233                 case AML_RETURN_OP:
234
235                         /* Never delete the return value associated with a return opcode */
236
237                         goto result_used;
238
239                 case AML_IF_OP:
240                 case AML_WHILE_OP:
241
242                         /*
243                          * If we are executing the predicate AND this is the predicate op,
244                          * we will use the return value
245                          */
246                         if ((walk_state->control_state->common.state ==
247                              ACPI_CONTROL_PREDICATE_EXECUTING)
248                             && (walk_state->control_state->control.
249                                 predicate_op == op)) {
250                                 goto result_used;
251                         }
252                         break;
253
254                 default:
255                         /* Ignore other control opcodes */
256                         break;
257                 }
258
259                 /* The general control opcode returns no result */
260
261                 goto result_not_used;
262
263         case AML_CLASS_CREATE:
264
265                 /*
266                  * These opcodes allow term_arg(s) as operands and therefore
267                  * the operands can be method calls.  The result is used.
268                  */
269                 goto result_used;
270
271         case AML_CLASS_NAMED_OBJECT:
272
273                 if ((op->common.parent->common.aml_opcode == AML_REGION_OP) ||
274                     (op->common.parent->common.aml_opcode == AML_DATA_REGION_OP)
275                     || (op->common.parent->common.aml_opcode == AML_PACKAGE_OP)
276                     || (op->common.parent->common.aml_opcode ==
277                         AML_VAR_PACKAGE_OP)
278                     || (op->common.parent->common.aml_opcode == AML_BUFFER_OP)
279                     || (op->common.parent->common.aml_opcode ==
280                         AML_INT_EVAL_SUBTREE_OP)) {
281                         /*
282                          * These opcodes allow term_arg(s) as operands and therefore
283                          * the operands can be method calls.  The result is used.
284                          */
285                         goto result_used;
286                 }
287
288                 goto result_not_used;
289
290         default:
291
292                 /*
293                  * In all other cases. the parent will actually use the return
294                  * object, so keep it.
295                  */
296                 goto result_used;
297         }
298
299       result_used:
300         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
301                           "Result of [%s] used by Parent [%s] Op=%p\n",
302                           acpi_ps_get_opcode_name(op->common.aml_opcode),
303                           acpi_ps_get_opcode_name(op->common.parent->common.
304                                                   aml_opcode), op));
305
306         return_UINT8(TRUE);
307
308       result_not_used:
309         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
310                           "Result of [%s] not used by Parent [%s] Op=%p\n",
311                           acpi_ps_get_opcode_name(op->common.aml_opcode),
312                           acpi_ps_get_opcode_name(op->common.parent->common.
313                                                   aml_opcode), op));
314
315         return_UINT8(FALSE);
316 }
317
318 /*******************************************************************************
319  *
320  * FUNCTION:    acpi_ds_delete_result_if_not_used
321  *
322  * PARAMETERS:  Op              - Current parse Op
323  *              result_obj      - Result of the operation
324  *              walk_state      - Current state
325  *
326  * RETURN:      Status
327  *
328  * DESCRIPTION: Used after interpretation of an opcode.  If there is an internal
329  *              result descriptor, check if the parent opcode will actually use
330  *              this result.  If not, delete the result now so that it will
331  *              not become orphaned.
332  *
333  ******************************************************************************/
334
335 void
336 acpi_ds_delete_result_if_not_used(union acpi_parse_object *op,
337                                   union acpi_operand_object *result_obj,
338                                   struct acpi_walk_state *walk_state)
339 {
340         union acpi_operand_object *obj_desc;
341         acpi_status status;
342
343         ACPI_FUNCTION_TRACE_PTR("ds_delete_result_if_not_used", result_obj);
344
345         if (!op) {
346                 ACPI_ERROR((AE_INFO, "Null Op"));
347                 return_VOID;
348         }
349
350         if (!result_obj) {
351                 return_VOID;
352         }
353
354         if (!acpi_ds_is_result_used(op, walk_state)) {
355                 /* Must pop the result stack (obj_desc should be equal to result_obj) */
356
357                 status = acpi_ds_result_pop(&obj_desc, walk_state);
358                 if (ACPI_SUCCESS(status)) {
359                         acpi_ut_remove_reference(result_obj);
360                 }
361         }
362
363         return_VOID;
364 }
365
366 /*******************************************************************************
367  *
368  * FUNCTION:    acpi_ds_resolve_operands
369  *
370  * PARAMETERS:  walk_state          - Current walk state with operands on stack
371  *
372  * RETURN:      Status
373  *
374  * DESCRIPTION: Resolve all operands to their values.  Used to prepare
375  *              arguments to a control method invocation (a call from one
376  *              method to another.)
377  *
378  ******************************************************************************/
379
380 acpi_status acpi_ds_resolve_operands(struct acpi_walk_state *walk_state)
381 {
382         u32 i;
383         acpi_status status = AE_OK;
384
385         ACPI_FUNCTION_TRACE_PTR("ds_resolve_operands", walk_state);
386
387         /*
388          * Attempt to resolve each of the valid operands
389          * Method arguments are passed by reference, not by value.  This means
390          * that the actual objects are passed, not copies of the objects.
391          */
392         for (i = 0; i < walk_state->num_operands; i++) {
393                 status =
394                     acpi_ex_resolve_to_value(&walk_state->operands[i],
395                                              walk_state);
396                 if (ACPI_FAILURE(status)) {
397                         break;
398                 }
399         }
400
401         return_ACPI_STATUS(status);
402 }
403
404 /*******************************************************************************
405  *
406  * FUNCTION:    acpi_ds_clear_operands
407  *
408  * PARAMETERS:  walk_state          - Current walk state with operands on stack
409  *
410  * RETURN:      None
411  *
412  * DESCRIPTION: Clear all operands on the current walk state operand stack.
413  *
414  ******************************************************************************/
415
416 void acpi_ds_clear_operands(struct acpi_walk_state *walk_state)
417 {
418         u32 i;
419
420         ACPI_FUNCTION_TRACE_PTR("ds_clear_operands", walk_state);
421
422         /* Remove a reference on each operand on the stack */
423
424         for (i = 0; i < walk_state->num_operands; i++) {
425                 /*
426                  * Remove a reference to all operands, including both
427                  * "Arguments" and "Targets".
428                  */
429                 acpi_ut_remove_reference(walk_state->operands[i]);
430                 walk_state->operands[i] = NULL;
431         }
432
433         walk_state->num_operands = 0;
434         return_VOID;
435 }
436 #endif
437
438 /*******************************************************************************
439  *
440  * FUNCTION:    acpi_ds_create_operand
441  *
442  * PARAMETERS:  walk_state      - Current walk state
443  *              Arg             - Parse object for the argument
444  *              arg_index       - Which argument (zero based)
445  *
446  * RETURN:      Status
447  *
448  * DESCRIPTION: Translate a parse tree object that is an argument to an AML
449  *              opcode to the equivalent interpreter object.  This may include
450  *              looking up a name or entering a new name into the internal
451  *              namespace.
452  *
453  ******************************************************************************/
454
455 acpi_status
456 acpi_ds_create_operand(struct acpi_walk_state *walk_state,
457                        union acpi_parse_object *arg, u32 arg_index)
458 {
459         acpi_status status = AE_OK;
460         char *name_string;
461         u32 name_length;
462         union acpi_operand_object *obj_desc;
463         union acpi_parse_object *parent_op;
464         u16 opcode;
465         acpi_interpreter_mode interpreter_mode;
466         const struct acpi_opcode_info *op_info;
467
468         ACPI_FUNCTION_TRACE_PTR("ds_create_operand", arg);
469
470         /* A valid name must be looked up in the namespace */
471
472         if ((arg->common.aml_opcode == AML_INT_NAMEPATH_OP) &&
473             (arg->common.value.string)) {
474                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n",
475                                   arg));
476
477                 /* Get the entire name string from the AML stream */
478
479                 status =
480                     acpi_ex_get_name_string(ACPI_TYPE_ANY,
481                                             arg->common.value.buffer,
482                                             &name_string, &name_length);
483
484                 if (ACPI_FAILURE(status)) {
485                         return_ACPI_STATUS(status);
486                 }
487
488                 /* All prefixes have been handled, and the name is in name_string */
489
490                 /*
491                  * Special handling for buffer_field declarations. This is a deferred
492                  * opcode that unfortunately defines the field name as the last
493                  * parameter instead of the first.  We get here when we are performing
494                  * the deferred execution, so the actual name of the field is already
495                  * in the namespace.  We don't want to attempt to look it up again
496                  * because we may be executing in a different scope than where the
497                  * actual opcode exists.
498                  */
499                 if ((walk_state->deferred_node) &&
500                     (walk_state->deferred_node->type == ACPI_TYPE_BUFFER_FIELD)
501                     && (arg_index != 0)) {
502                         obj_desc =
503                             ACPI_CAST_PTR(union acpi_operand_object,
504                                           walk_state->deferred_node);
505                         status = AE_OK;
506                 } else {        /* All other opcodes */
507
508                         /*
509                          * Differentiate between a namespace "create" operation
510                          * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
511                          * IMODE_EXECUTE) in order to support the creation of
512                          * namespace objects during the execution of control methods.
513                          */
514                         parent_op = arg->common.parent;
515                         op_info =
516                             acpi_ps_get_opcode_info(parent_op->common.
517                                                     aml_opcode);
518                         if ((op_info->flags & AML_NSNODE)
519                             && (parent_op->common.aml_opcode !=
520                                 AML_INT_METHODCALL_OP)
521                             && (parent_op->common.aml_opcode != AML_REGION_OP)
522                             && (parent_op->common.aml_opcode !=
523                                 AML_INT_NAMEPATH_OP)) {
524                                 /* Enter name into namespace if not found */
525
526                                 interpreter_mode = ACPI_IMODE_LOAD_PASS2;
527                         } else {
528                                 /* Return a failure if name not found */
529
530                                 interpreter_mode = ACPI_IMODE_EXECUTE;
531                         }
532
533                         status =
534                             acpi_ns_lookup(walk_state->scope_info, name_string,
535                                            ACPI_TYPE_ANY, interpreter_mode,
536                                            ACPI_NS_SEARCH_PARENT |
537                                            ACPI_NS_DONT_OPEN_SCOPE, walk_state,
538                                            ACPI_CAST_INDIRECT_PTR(struct
539                                                                   acpi_namespace_node,
540                                                                   &obj_desc));
541                         /*
542                          * The only case where we pass through (ignore) a NOT_FOUND
543                          * error is for the cond_ref_of opcode.
544                          */
545                         if (status == AE_NOT_FOUND) {
546                                 if (parent_op->common.aml_opcode ==
547                                     AML_COND_REF_OF_OP) {
548                                         /*
549                                          * For the Conditional Reference op, it's OK if
550                                          * the name is not found;  We just need a way to
551                                          * indicate this to the interpreter, set the
552                                          * object to the root
553                                          */
554                                         obj_desc =
555                                             ACPI_CAST_PTR(union
556                                                           acpi_operand_object,
557                                                           acpi_gbl_root_node);
558                                         status = AE_OK;
559                                 } else {
560                                         /*
561                                          * We just plain didn't find it -- which is a
562                                          * very serious error at this point
563                                          */
564                                         status = AE_AML_NAME_NOT_FOUND;
565                                 }
566                         }
567
568                         if (ACPI_FAILURE(status)) {
569                                 ACPI_ERROR_NAMESPACE(name_string, status);
570                         }
571                 }
572
573                 /* Free the namestring created above */
574
575                 ACPI_MEM_FREE(name_string);
576
577                 /* Check status from the lookup */
578
579                 if (ACPI_FAILURE(status)) {
580                         return_ACPI_STATUS(status);
581                 }
582
583                 /* Put the resulting object onto the current object stack */
584
585                 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
586                 if (ACPI_FAILURE(status)) {
587                         return_ACPI_STATUS(status);
588                 }
589                 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
590                                    (obj_desc, walk_state));
591         } else {
592                 /* Check for null name case */
593
594                 if (arg->common.aml_opcode == AML_INT_NAMEPATH_OP) {
595                         /*
596                          * If the name is null, this means that this is an
597                          * optional result parameter that was not specified
598                          * in the original ASL.  Create a Zero Constant for a
599                          * placeholder.  (Store to a constant is a Noop.)
600                          */
601                         opcode = AML_ZERO_OP;   /* Has no arguments! */
602
603                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
604                                           "Null namepath: Arg=%p\n", arg));
605                 } else {
606                         opcode = arg->common.aml_opcode;
607                 }
608
609                 /* Get the object type of the argument */
610
611                 op_info = acpi_ps_get_opcode_info(opcode);
612                 if (op_info->object_type == ACPI_TYPE_INVALID) {
613                         return_ACPI_STATUS(AE_NOT_IMPLEMENTED);
614                 }
615
616                 if (op_info->flags & AML_HAS_RETVAL) {
617                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
618                                           "Argument previously created, already stacked\n"));
619
620                         ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
621                                            (walk_state->
622                                             operands[walk_state->num_operands -
623                                                      1], walk_state));
624
625                         /*
626                          * Use value that was already previously returned
627                          * by the evaluation of this argument
628                          */
629                         status =
630                             acpi_ds_result_pop_from_bottom(&obj_desc,
631                                                            walk_state);
632                         if (ACPI_FAILURE(status)) {
633                                 /*
634                                  * Only error is underflow, and this indicates
635                                  * a missing or null operand!
636                                  */
637                                 ACPI_EXCEPTION((AE_INFO, status,
638                                                 "Missing or null operand"));
639                                 return_ACPI_STATUS(status);
640                         }
641                 } else {
642                         /* Create an ACPI_INTERNAL_OBJECT for the argument */
643
644                         obj_desc =
645                             acpi_ut_create_internal_object(op_info->
646                                                            object_type);
647                         if (!obj_desc) {
648                                 return_ACPI_STATUS(AE_NO_MEMORY);
649                         }
650
651                         /* Initialize the new object */
652
653                         status =
654                             acpi_ds_init_object_from_op(walk_state, arg, opcode,
655                                                         &obj_desc);
656                         if (ACPI_FAILURE(status)) {
657                                 acpi_ut_delete_object_desc(obj_desc);
658                                 return_ACPI_STATUS(status);
659                         }
660                 }
661
662                 /* Put the operand object on the object stack */
663
664                 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
665                 if (ACPI_FAILURE(status)) {
666                         return_ACPI_STATUS(status);
667                 }
668
669                 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
670                                    (obj_desc, walk_state));
671         }
672
673         return_ACPI_STATUS(AE_OK);
674 }
675
676 /*******************************************************************************
677  *
678  * FUNCTION:    acpi_ds_create_operands
679  *
680  * PARAMETERS:  walk_state          - Current state
681  *              first_arg           - First argument of a parser argument tree
682  *
683  * RETURN:      Status
684  *
685  * DESCRIPTION: Convert an operator's arguments from a parse tree format to
686  *              namespace objects and place those argument object on the object
687  *              stack in preparation for evaluation by the interpreter.
688  *
689  ******************************************************************************/
690
691 acpi_status
692 acpi_ds_create_operands(struct acpi_walk_state *walk_state,
693                         union acpi_parse_object *first_arg)
694 {
695         acpi_status status = AE_OK;
696         union acpi_parse_object *arg;
697         u32 arg_count = 0;
698
699         ACPI_FUNCTION_TRACE_PTR("ds_create_operands", first_arg);
700
701         /* For all arguments in the list... */
702
703         arg = first_arg;
704         while (arg) {
705                 status = acpi_ds_create_operand(walk_state, arg, arg_count);
706                 if (ACPI_FAILURE(status)) {
707                         goto cleanup;
708                 }
709
710                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
711                                   "Arg #%d (%p) done, Arg1=%p\n", arg_count,
712                                   arg, first_arg));
713
714                 /* Move on to next argument, if any */
715
716                 arg = arg->common.next;
717                 arg_count++;
718         }
719
720         return_ACPI_STATUS(status);
721
722       cleanup:
723         /*
724          * We must undo everything done above; meaning that we must
725          * pop everything off of the operand stack and delete those
726          * objects
727          */
728         (void)acpi_ds_obj_stack_pop_and_delete(arg_count, walk_state);
729
730         ACPI_EXCEPTION((AE_INFO, status, "While creating Arg %d",
731                         (arg_count + 1)));
732         return_ACPI_STATUS(status);
733 }