exresop.c revision 241973 
1/******************************************************************************
2 *
3 * Module Name: exresop - AML Interpreter operand/object resolution
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#define __EXRESOP_C__
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48#include <contrib/dev/acpica/include/amlcode.h>
49#include <contrib/dev/acpica/include/acparser.h>
50#include <contrib/dev/acpica/include/acinterp.h>
51#include <contrib/dev/acpica/include/acnamesp.h>
52
53
54#define _COMPONENT          ACPI_EXECUTER
55        ACPI_MODULE_NAME    ("exresop")
56
57/* Local prototypes */
58
59static ACPI_STATUS
60AcpiExCheckObjectType (
61    ACPI_OBJECT_TYPE        TypeNeeded,
62    ACPI_OBJECT_TYPE        ThisType,
63    void                    *Object);
64
65
66/*******************************************************************************
67 *
68 * FUNCTION:    AcpiExCheckObjectType
69 *
70 * PARAMETERS:  TypeNeeded          Object type needed
71 *              ThisType            Actual object type
72 *              Object              Object pointer
73 *
74 * RETURN:      Status
75 *
76 * DESCRIPTION: Check required type against actual type
77 *
78 ******************************************************************************/
79
80static ACPI_STATUS
81AcpiExCheckObjectType (
82    ACPI_OBJECT_TYPE        TypeNeeded,
83    ACPI_OBJECT_TYPE        ThisType,
84    void                    *Object)
85{
86    ACPI_FUNCTION_ENTRY ();
87
88
89    if (TypeNeeded == ACPI_TYPE_ANY)
90    {
91        /* All types OK, so we don't perform any typechecks */
92
93        return (AE_OK);
94    }
95
96    if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE)
97    {
98        /*
99         * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
100         * objects and thus allow them to be targets. (As per the ACPI
101         * specification, a store to a constant is a noop.)
102         */
103        if ((ThisType == ACPI_TYPE_INTEGER) &&
104            (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT))
105        {
106            return (AE_OK);
107        }
108    }
109
110    if (TypeNeeded != ThisType)
111    {
112        ACPI_ERROR ((AE_INFO,
113            "Needed type [%s], found [%s] %p",
114            AcpiUtGetTypeName (TypeNeeded),
115            AcpiUtGetTypeName (ThisType), Object));
116
117        return (AE_AML_OPERAND_TYPE);
118    }
119
120    return (AE_OK);
121}
122
123
124/*******************************************************************************
125 *
126 * FUNCTION:    AcpiExResolveOperands
127 *
128 * PARAMETERS:  Opcode              - Opcode being interpreted
129 *              StackPtr            - Pointer to the operand stack to be
130 *                                    resolved
131 *              WalkState           - Current state
132 *
133 * RETURN:      Status
134 *
135 * DESCRIPTION: Convert multiple input operands to the types required by the
136 *              target operator.
137 *
138 *      Each 5-bit group in ArgTypes represents one required
139 *      operand and indicates the required Type. The corresponding operand
140 *      will be converted to the required type if possible, otherwise we
141 *      abort with an exception.
142 *
143 ******************************************************************************/
144
145ACPI_STATUS
146AcpiExResolveOperands (
147    UINT16                  Opcode,
148    ACPI_OPERAND_OBJECT     **StackPtr,
149    ACPI_WALK_STATE         *WalkState)
150{
151    ACPI_OPERAND_OBJECT     *ObjDesc;
152    ACPI_STATUS             Status = AE_OK;
153    UINT8                   ObjectType;
154    UINT32                  ArgTypes;
155    const ACPI_OPCODE_INFO  *OpInfo;
156    UINT32                  ThisArgType;
157    ACPI_OBJECT_TYPE        TypeNeeded;
158    UINT16                  TargetOp = 0;
159
160
161    ACPI_FUNCTION_TRACE_U32 (ExResolveOperands, Opcode);
162
163
164    OpInfo = AcpiPsGetOpcodeInfo (Opcode);
165    if (OpInfo->Class == AML_CLASS_UNKNOWN)
166    {
167        return_ACPI_STATUS (AE_AML_BAD_OPCODE);
168    }
169
170    ArgTypes = OpInfo->RuntimeArgs;
171    if (ArgTypes == ARGI_INVALID_OPCODE)
172    {
173        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
174            Opcode));
175
176        return_ACPI_STATUS (AE_AML_INTERNAL);
177    }
178
179    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
180        "Opcode %X [%s] RequiredOperandTypes=%8.8X\n",
181        Opcode, OpInfo->Name, ArgTypes));
182
183    /*
184     * Normal exit is with (ArgTypes == 0) at end of argument list.
185     * Function will return an exception from within the loop upon
186     * finding an entry which is not (or cannot be converted
187     * to) the required type; if stack underflows; or upon
188     * finding a NULL stack entry (which should not happen).
189     */
190    while (GET_CURRENT_ARG_TYPE (ArgTypes))
191    {
192        if (!StackPtr || !*StackPtr)
193        {
194            ACPI_ERROR ((AE_INFO, "Null stack entry at %p",
195                StackPtr));
196
197            return_ACPI_STATUS (AE_AML_INTERNAL);
198        }
199
200        /* Extract useful items */
201
202        ObjDesc = *StackPtr;
203
204        /* Decode the descriptor type */
205
206        switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
207        {
208        case ACPI_DESC_TYPE_NAMED:
209
210            /* Namespace Node */
211
212            ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
213
214            /*
215             * Resolve an alias object. The construction of these objects
216             * guarantees that there is only one level of alias indirection;
217             * thus, the attached object is always the aliased namespace node
218             */
219            if (ObjectType == ACPI_TYPE_LOCAL_ALIAS)
220            {
221                ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjDesc);
222                *StackPtr = ObjDesc;
223                ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
224            }
225            break;
226
227
228        case ACPI_DESC_TYPE_OPERAND:
229
230            /* ACPI internal object */
231
232            ObjectType = ObjDesc->Common.Type;
233
234            /* Check for bad ACPI_OBJECT_TYPE */
235
236            if (!AcpiUtValidObjectType (ObjectType))
237            {
238                ACPI_ERROR ((AE_INFO,
239                    "Bad operand object type [0x%X]", ObjectType));
240
241                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
242            }
243
244            if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE)
245            {
246                /* Validate the Reference */
247
248                switch (ObjDesc->Reference.Class)
249                {
250                case ACPI_REFCLASS_DEBUG:
251
252                    TargetOp = AML_DEBUG_OP;
253
254                    /*lint -fallthrough */
255
256                case ACPI_REFCLASS_ARG:
257                case ACPI_REFCLASS_LOCAL:
258                case ACPI_REFCLASS_INDEX:
259                case ACPI_REFCLASS_REFOF:
260                case ACPI_REFCLASS_TABLE:    /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */
261                case ACPI_REFCLASS_NAME:     /* Reference to a named object */
262
263                    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
264                        "Operand is a Reference, Class [%s] %2.2X\n",
265                        AcpiUtGetReferenceName (ObjDesc),
266                        ObjDesc->Reference.Class));
267                    break;
268
269                default:
270
271                    ACPI_ERROR ((AE_INFO,
272                        "Unknown Reference Class 0x%2.2X in %p",
273                        ObjDesc->Reference.Class, ObjDesc));
274
275                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
276                }
277            }
278            break;
279
280
281        default:
282
283            /* Invalid descriptor */
284
285            ACPI_ERROR ((AE_INFO, "Invalid descriptor %p [%s]",
286                ObjDesc, AcpiUtGetDescriptorName (ObjDesc)));
287
288            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
289        }
290
291        /* Get one argument type, point to the next */
292
293        ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes);
294        INCREMENT_ARG_LIST (ArgTypes);
295
296        /*
297         * Handle cases where the object does not need to be
298         * resolved to a value
299         */
300        switch (ThisArgType)
301        {
302        case ARGI_REF_OR_STRING:        /* Can be a String or Reference */
303
304            if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) &&
305                (ObjDesc->Common.Type == ACPI_TYPE_STRING))
306            {
307                /*
308                 * String found - the string references a named object and
309                 * must be resolved to a node
310                 */
311                goto NextOperand;
312            }
313
314            /*
315             * Else not a string - fall through to the normal Reference
316             * case below
317             */
318            /*lint -fallthrough */
319
320        case ARGI_REFERENCE:            /* References: */
321        case ARGI_INTEGER_REF:
322        case ARGI_OBJECT_REF:
323        case ARGI_DEVICE_REF:
324        case ARGI_TARGETREF:     /* Allows implicit conversion rules before store */
325        case ARGI_FIXED_TARGET:  /* No implicit conversion before store to target */
326        case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion  */
327
328            /*
329             * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE
330             * A Namespace Node is OK as-is
331             */
332            if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
333            {
334                goto NextOperand;
335            }
336
337            Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE,
338                            ObjectType, ObjDesc);
339            if (ACPI_FAILURE (Status))
340            {
341                return_ACPI_STATUS (Status);
342            }
343            goto NextOperand;
344
345
346        case ARGI_DATAREFOBJ:  /* Store operator only */
347
348            /*
349             * We don't want to resolve IndexOp reference objects during
350             * a store because this would be an implicit DeRefOf operation.
351             * Instead, we just want to store the reference object.
352             * -- All others must be resolved below.
353             */
354            if ((Opcode == AML_STORE_OP) &&
355                ((*StackPtr)->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
356                ((*StackPtr)->Reference.Class == ACPI_REFCLASS_INDEX))
357            {
358                goto NextOperand;
359            }
360            break;
361
362        default:
363            /* All cases covered above */
364            break;
365        }
366
367        /*
368         * Resolve this object to a value
369         */
370        Status = AcpiExResolveToValue (StackPtr, WalkState);
371        if (ACPI_FAILURE (Status))
372        {
373            return_ACPI_STATUS (Status);
374        }
375
376        /* Get the resolved object */
377
378        ObjDesc = *StackPtr;
379
380        /*
381         * Check the resulting object (value) type
382         */
383        switch (ThisArgType)
384        {
385        /*
386         * For the simple cases, only one type of resolved object
387         * is allowed
388         */
389        case ARGI_MUTEX:
390
391            /* Need an operand of type ACPI_TYPE_MUTEX */
392
393            TypeNeeded = ACPI_TYPE_MUTEX;
394            break;
395
396        case ARGI_EVENT:
397
398            /* Need an operand of type ACPI_TYPE_EVENT */
399
400            TypeNeeded = ACPI_TYPE_EVENT;
401            break;
402
403        case ARGI_PACKAGE:   /* Package */
404
405            /* Need an operand of type ACPI_TYPE_PACKAGE */
406
407            TypeNeeded = ACPI_TYPE_PACKAGE;
408            break;
409
410        case ARGI_ANYTYPE:
411
412            /* Any operand type will do */
413
414            TypeNeeded = ACPI_TYPE_ANY;
415            break;
416
417        case ARGI_DDBHANDLE:
418
419            /* Need an operand of type ACPI_TYPE_DDB_HANDLE */
420
421            TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE;
422            break;
423
424
425        /*
426         * The more complex cases allow multiple resolved object types
427         */
428        case ARGI_INTEGER:
429
430            /*
431             * Need an operand of type ACPI_TYPE_INTEGER,
432             * But we can implicitly convert from a STRING or BUFFER
433             * Aka - "Implicit Source Operand Conversion"
434             */
435            Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16);
436            if (ACPI_FAILURE (Status))
437            {
438                if (Status == AE_TYPE)
439                {
440                    ACPI_ERROR ((AE_INFO,
441                        "Needed [Integer/String/Buffer], found [%s] %p",
442                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
443
444                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
445                }
446
447                return_ACPI_STATUS (Status);
448            }
449
450            if (ObjDesc != *StackPtr)
451            {
452                AcpiUtRemoveReference (ObjDesc);
453            }
454            goto NextOperand;
455
456
457        case ARGI_BUFFER:
458
459            /*
460             * Need an operand of type ACPI_TYPE_BUFFER,
461             * But we can implicitly convert from a STRING or INTEGER
462             * Aka - "Implicit Source Operand Conversion"
463             */
464            Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
465            if (ACPI_FAILURE (Status))
466            {
467                if (Status == AE_TYPE)
468                {
469                    ACPI_ERROR ((AE_INFO,
470                        "Needed [Integer/String/Buffer], found [%s] %p",
471                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
472
473                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
474                }
475
476                return_ACPI_STATUS (Status);
477            }
478
479            if (ObjDesc != *StackPtr)
480            {
481                AcpiUtRemoveReference (ObjDesc);
482            }
483            goto NextOperand;
484
485
486        case ARGI_STRING:
487
488            /*
489             * Need an operand of type ACPI_TYPE_STRING,
490             * But we can implicitly convert from a BUFFER or INTEGER
491             * Aka - "Implicit Source Operand Conversion"
492             */
493            Status = AcpiExConvertToString (ObjDesc, StackPtr,
494                        ACPI_IMPLICIT_CONVERT_HEX);
495            if (ACPI_FAILURE (Status))
496            {
497                if (Status == AE_TYPE)
498                {
499                    ACPI_ERROR ((AE_INFO,
500                        "Needed [Integer/String/Buffer], found [%s] %p",
501                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
502
503                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
504                }
505
506                return_ACPI_STATUS (Status);
507            }
508
509            if (ObjDesc != *StackPtr)
510            {
511                AcpiUtRemoveReference (ObjDesc);
512            }
513            goto NextOperand;
514
515
516        case ARGI_COMPUTEDATA:
517
518            /* Need an operand of type INTEGER, STRING or BUFFER */
519
520            switch (ObjDesc->Common.Type)
521            {
522            case ACPI_TYPE_INTEGER:
523            case ACPI_TYPE_STRING:
524            case ACPI_TYPE_BUFFER:
525
526                /* Valid operand */
527               break;
528
529            default:
530                ACPI_ERROR ((AE_INFO,
531                    "Needed [Integer/String/Buffer], found [%s] %p",
532                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
533
534                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
535            }
536            goto NextOperand;
537
538
539        case ARGI_BUFFER_OR_STRING:
540
541            /* Need an operand of type STRING or BUFFER */
542
543            switch (ObjDesc->Common.Type)
544            {
545            case ACPI_TYPE_STRING:
546            case ACPI_TYPE_BUFFER:
547
548                /* Valid operand */
549               break;
550
551            case ACPI_TYPE_INTEGER:
552
553                /* Highest priority conversion is to type Buffer */
554
555                Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
556                if (ACPI_FAILURE (Status))
557                {
558                    return_ACPI_STATUS (Status);
559                }
560
561                if (ObjDesc != *StackPtr)
562                {
563                    AcpiUtRemoveReference (ObjDesc);
564                }
565                break;
566
567            default:
568                ACPI_ERROR ((AE_INFO,
569                    "Needed [Integer/String/Buffer], found [%s] %p",
570                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
571
572                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
573            }
574            goto NextOperand;
575
576
577        case ARGI_DATAOBJECT:
578            /*
579             * ARGI_DATAOBJECT is only used by the SizeOf operator.
580             * Need a buffer, string, package, or RefOf reference.
581             *
582             * The only reference allowed here is a direct reference to
583             * a namespace node.
584             */
585            switch (ObjDesc->Common.Type)
586            {
587            case ACPI_TYPE_PACKAGE:
588            case ACPI_TYPE_STRING:
589            case ACPI_TYPE_BUFFER:
590            case ACPI_TYPE_LOCAL_REFERENCE:
591
592                /* Valid operand */
593                break;
594
595            default:
596                ACPI_ERROR ((AE_INFO,
597                    "Needed [Buffer/String/Package/Reference], found [%s] %p",
598                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
599
600                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
601            }
602            goto NextOperand;
603
604
605        case ARGI_COMPLEXOBJ:
606
607            /* Need a buffer or package or (ACPI 2.0) String */
608
609            switch (ObjDesc->Common.Type)
610            {
611            case ACPI_TYPE_PACKAGE:
612            case ACPI_TYPE_STRING:
613            case ACPI_TYPE_BUFFER:
614
615                /* Valid operand */
616                break;
617
618            default:
619                ACPI_ERROR ((AE_INFO,
620                    "Needed [Buffer/String/Package], found [%s] %p",
621                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
622
623                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
624            }
625            goto NextOperand;
626
627
628        case ARGI_REGION_OR_BUFFER: /* Used by Load() only */
629
630            /* Need an operand of type REGION or a BUFFER (which could be a resolved region field) */
631
632            switch (ObjDesc->Common.Type)
633            {
634            case ACPI_TYPE_BUFFER:
635            case ACPI_TYPE_REGION:
636
637                /* Valid operand */
638                break;
639
640            default:
641                ACPI_ERROR ((AE_INFO,
642                    "Needed [Region/Buffer], found [%s] %p",
643                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
644
645                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
646            }
647            goto NextOperand;
648
649
650        case ARGI_DATAREFOBJ:
651
652            /* Used by the Store() operator only */
653
654            switch (ObjDesc->Common.Type)
655            {
656            case ACPI_TYPE_INTEGER:
657            case ACPI_TYPE_PACKAGE:
658            case ACPI_TYPE_STRING:
659            case ACPI_TYPE_BUFFER:
660            case ACPI_TYPE_BUFFER_FIELD:
661            case ACPI_TYPE_LOCAL_REFERENCE:
662            case ACPI_TYPE_LOCAL_REGION_FIELD:
663            case ACPI_TYPE_LOCAL_BANK_FIELD:
664            case ACPI_TYPE_LOCAL_INDEX_FIELD:
665            case ACPI_TYPE_DDB_HANDLE:
666
667                /* Valid operand */
668                break;
669
670            default:
671
672                if (AcpiGbl_EnableInterpreterSlack)
673                {
674                    /*
675                     * Enable original behavior of Store(), allowing any and all
676                     * objects as the source operand. The ACPI spec does not
677                     * allow this, however.
678                     */
679                    break;
680                }
681
682                if (TargetOp == AML_DEBUG_OP)
683                {
684                    /* Allow store of any object to the Debug object */
685
686                    break;
687                }
688
689                ACPI_ERROR ((AE_INFO,
690                    "Needed Integer/Buffer/String/Package/Ref/Ddb], found [%s] %p",
691                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
692
693                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
694            }
695            goto NextOperand;
696
697
698        default:
699
700            /* Unknown type */
701
702            ACPI_ERROR ((AE_INFO,
703                "Internal - Unknown ARGI (required operand) type 0x%X",
704                ThisArgType));
705
706            return_ACPI_STATUS (AE_BAD_PARAMETER);
707        }
708
709        /*
710         * Make sure that the original object was resolved to the
711         * required object type (Simple cases only).
712         */
713        Status = AcpiExCheckObjectType (TypeNeeded,
714                        (*StackPtr)->Common.Type, *StackPtr);
715        if (ACPI_FAILURE (Status))
716        {
717            return_ACPI_STATUS (Status);
718        }
719
720NextOperand:
721        /*
722         * If more operands needed, decrement StackPtr to point
723         * to next operand on stack
724         */
725        if (GET_CURRENT_ARG_TYPE (ArgTypes))
726        {
727            StackPtr--;
728        }
729    }
730
731    ACPI_DUMP_OPERANDS (WalkState->Operands,
732        AcpiPsGetOpcodeName (Opcode), WalkState->NumOperands);
733
734    return_ACPI_STATUS (Status);
735}
736