sys/contrib/dev/acpica/executer/exresop.c

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