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

   1 /******************************************************************************
   2  *
   3  * Module Name: exresop - AML Interpreter operand/object resolution
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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
  59 static ACPI_STATUS
  60 AcpiExCheckObjectType (
  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
  80 static ACPI_STATUS
  81 AcpiExCheckObjectType (
  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
 145 ACPI_STATUS
 146 AcpiExResolveOperands (
 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
 720 NextOperand:
 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 }