sys/contrib/dev/acpica-unix-20050309/interpreter/executer/exresop.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exresop - AML Interpreter operand/object resolution
   5  *              $Revision: 74 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #define __EXRESOP_C__
 119
 120 #include "acpi.h"
 121 #include "amlcode.h"
 122 #include "acparser.h"
 123 #include "acinterp.h"
 124
 125
 126 #define _COMPONENT          ACPI_EXECUTER
 127         ACPI_MODULE_NAME    ("exresop")
 128
 129
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    AcpiExCheckObjectType
 133  *
 134  * PARAMETERS:  TypeNeeded          Object type needed
 135  *              ThisType            Actual object type
 136  *              Object              Object pointer
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Check required type against actual type
 141  *
 142  ******************************************************************************/
 143
 144 ACPI_STATUS
 145 AcpiExCheckObjectType (
 146     ACPI_OBJECT_TYPE        TypeNeeded,
 147     ACPI_OBJECT_TYPE        ThisType,
 148     void                    *Object)
 149 {
 150     ACPI_FUNCTION_NAME ("ExCheckObjectType");
 151
 152
 153     if (TypeNeeded == ACPI_TYPE_ANY)
 154     {
 155         /* All types OK, so we don't perform any typechecks */
 156
 157         return (AE_OK);
 158     }
 159
 160     if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE)
 161     {
 162         /*
 163          * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
 164          * objects and thus allow them to be targets.  (As per the ACPI
 165          * specification, a store to a constant is a noop.)
 166          */
 167         if ((ThisType == ACPI_TYPE_INTEGER) &&
 168             (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT))
 169         {
 170             return (AE_OK);
 171         }
 172     }
 173
 174     if (TypeNeeded != ThisType)
 175     {
 176         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 177             "Needed [%s], found [%s] %p\n",
 178             AcpiUtGetTypeName (TypeNeeded),
 179             AcpiUtGetTypeName (ThisType), Object));
 180
 181         return (AE_AML_OPERAND_TYPE);
 182     }
 183
 184     return (AE_OK);
 185 }
 186
 187
 188 /*******************************************************************************
 189  *
 190  * FUNCTION:    AcpiExResolveOperands
 191  *
 192  * PARAMETERS:  Opcode              - Opcode being interpreted
 193  *              StackPtr            - Pointer to the operand stack to be
 194  *                                    resolved
 195  *              WalkState           - Current state
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Convert multiple input operands to the types required by the
 200  *              target operator.
 201  *
 202  *      Each 5-bit group in ArgTypes represents one required
 203  *      operand and indicates the required Type. The corresponding operand
 204  *      will be converted to the required type if possible, otherwise we
 205  *      abort with an exception.
 206  *
 207  ******************************************************************************/
 208
 209 ACPI_STATUS
 210 AcpiExResolveOperands (
 211     UINT16                  Opcode,
 212     ACPI_OPERAND_OBJECT     **StackPtr,
 213     ACPI_WALK_STATE         *WalkState)
 214 {
 215     ACPI_OPERAND_OBJECT     *ObjDesc;
 216     ACPI_STATUS             Status = AE_OK;
 217     UINT8                   ObjectType;
 218     void                    *TempNode;
 219     UINT32                  ArgTypes;
 220     const ACPI_OPCODE_INFO  *OpInfo;
 221     UINT32                  ThisArgType;
 222     ACPI_OBJECT_TYPE        TypeNeeded;
 223
 224
 225     ACPI_FUNCTION_TRACE_U32 ("ExResolveOperands", Opcode);
 226
 227
 228     OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 229     if (OpInfo->Class == AML_CLASS_UNKNOWN)
 230     {
 231         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 232     }
 233
 234     ArgTypes = OpInfo->RuntimeArgs;
 235     if (ArgTypes == ARGI_INVALID_OPCODE)
 236     {
 237         ACPI_REPORT_ERROR (("ResolveOperands: %X is not a valid AML opcode\n",
 238             Opcode));
 239
 240         return_ACPI_STATUS (AE_AML_INTERNAL);
 241     }
 242
 243     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Opcode %X [%s] RequiredOperandTypes=%8.8X \n",
 244         Opcode, OpInfo->Name, ArgTypes));
 245
 246     /*
 247      * Normal exit is with (ArgTypes == 0) at end of argument list.
 248      * Function will return an exception from within the loop upon
 249      * finding an entry which is not (or cannot be converted
 250      * to) the required type; if stack underflows; or upon
 251      * finding a NULL stack entry (which should not happen).
 252      */
 253     while (GET_CURRENT_ARG_TYPE (ArgTypes))
 254     {
 255         if (!StackPtr || !*StackPtr)
 256         {
 257             ACPI_REPORT_ERROR (("ResolveOperands: Null stack entry at %p\n",
 258                 StackPtr));
 259
 260             return_ACPI_STATUS (AE_AML_INTERNAL);
 261         }
 262
 263         /* Extract useful items */
 264
 265         ObjDesc = *StackPtr;
 266
 267         /* Decode the descriptor type */
 268
 269         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
 270         {
 271         case ACPI_DESC_TYPE_NAMED:
 272
 273             /* Node */
 274
 275             ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
 276             break;
 277
 278
 279         case ACPI_DESC_TYPE_OPERAND:
 280
 281             /* ACPI internal object */
 282
 283             ObjectType = ACPI_GET_OBJECT_TYPE (ObjDesc);
 284
 285             /* Check for bad ACPI_OBJECT_TYPE */
 286
 287             if (!AcpiUtValidObjectType (ObjectType))
 288             {
 289                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad operand object type [%X]\n",
 290                     ObjectType));
 291
 292                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 293             }
 294
 295             if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE)
 296             {
 297                 /*
 298                  * Decode the Reference
 299                  */
 300                 OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 301                 if (OpInfo->Class == AML_CLASS_UNKNOWN)
 302                 {
 303                     return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 304                 }
 305
 306                 switch (ObjDesc->Reference.Opcode)
 307                 {
 308                 case AML_DEBUG_OP:
 309                 case AML_NAME_OP:
 310                 case AML_INDEX_OP:
 311                 case AML_REF_OF_OP:
 312                 case AML_ARG_OP:
 313                 case AML_LOCAL_OP:
 314                 case AML_LOAD_OP:   /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */
 315
 316                     ACPI_DEBUG_ONLY_MEMBERS (ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 317                         "Operand is a Reference, RefOpcode [%s]\n",
 318                         (AcpiPsGetOpcodeInfo (ObjDesc->Reference.Opcode))->Name)));
 319                     break;
 320
 321                 default:
 322                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 323                         "Operand is a Reference, Unknown Reference Opcode %X [%s]\n",
 324                         ObjDesc->Reference.Opcode,
 325                         (AcpiPsGetOpcodeInfo (ObjDesc->Reference.Opcode))->Name));
 326
 327                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 328                 }
 329             }
 330             break;
 331
 332
 333         default:
 334
 335             /* Invalid descriptor */
 336
 337             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 338                     "Invalid descriptor %p [%s]\n",
 339                     ObjDesc, AcpiUtGetDescriptorName (ObjDesc)));
 340
 341             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 342         }
 343
 344
 345         /*
 346          * Get one argument type, point to the next
 347          */
 348         ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes);
 349         INCREMENT_ARG_LIST (ArgTypes);
 350
 351         /*
 352          * Handle cases where the object does not need to be
 353          * resolved to a value
 354          */
 355         switch (ThisArgType)
 356         {
 357         case ARGI_REF_OR_STRING:        /* Can be a String or Reference */
 358
 359             if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) &&
 360                 (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_STRING))
 361             {
 362                 /*
 363                  * String found - the string references a named object and must be
 364                  * resolved to a node
 365                  */
 366                 goto NextOperand;
 367             }
 368
 369             /* Else not a string - fall through to the normal Reference case below */
 370             /*lint -fallthrough */
 371
 372         case ARGI_REFERENCE:            /* References: */
 373         case ARGI_INTEGER_REF:
 374         case ARGI_OBJECT_REF:
 375         case ARGI_DEVICE_REF:
 376         case ARGI_TARGETREF:            /* Allows implicit conversion rules before store */
 377         case ARGI_FIXED_TARGET:         /* No implicit conversion before store to target */
 378         case ARGI_SIMPLE_TARGET:        /* Name, Local, or Arg - no implicit conversion  */
 379
 380             /* Need an operand of type ACPI_TYPE_LOCAL_REFERENCE */
 381
 382             if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) /* Node (name) ptr OK as-is */
 383             {
 384                 goto NextOperand;
 385             }
 386
 387             Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE,
 388                             ObjectType, ObjDesc);
 389             if (ACPI_FAILURE (Status))
 390             {
 391                 return_ACPI_STATUS (Status);
 392             }
 393
 394             if (AML_NAME_OP == ObjDesc->Reference.Opcode)
 395             {
 396                 /*
 397                  * Convert an indirect name ptr to direct name ptr and put
 398                  * it on the stack
 399                  */
 400                 TempNode = ObjDesc->Reference.Object;
 401                 AcpiUtRemoveReference (ObjDesc);
 402                 (*StackPtr) = TempNode;
 403             }
 404             goto NextOperand;
 405
 406
 407         case ARGI_DATAREFOBJ:  /* Store operator only */
 408
 409             /*
 410              * We don't want to resolve IndexOp reference objects during
 411              * a store because this would be an implicit DeRefOf operation.
 412              * Instead, we just want to store the reference object.
 413              * -- All others must be resolved below.
 414              */
 415             if ((Opcode == AML_STORE_OP) &&
 416                 (ACPI_GET_OBJECT_TYPE (*StackPtr) == ACPI_TYPE_LOCAL_REFERENCE) &&
 417                 ((*StackPtr)->Reference.Opcode == AML_INDEX_OP))
 418             {
 419                 goto NextOperand;
 420             }
 421             break;
 422
 423         default:
 424             /* All cases covered above */
 425             break;
 426         }
 427
 428
 429         /*
 430          * Resolve this object to a value
 431          */
 432         Status = AcpiExResolveToValue (StackPtr, WalkState);
 433         if (ACPI_FAILURE (Status))
 434         {
 435             return_ACPI_STATUS (Status);
 436         }
 437
 438         /* Get the resolved object */
 439
 440         ObjDesc = *StackPtr;
 441
 442         /*
 443          * Check the resulting object (value) type
 444          */
 445         switch (ThisArgType)
 446         {
 447         /*
 448          * For the simple cases, only one type of resolved object
 449          * is allowed
 450          */
 451         case ARGI_MUTEX:
 452
 453             /* Need an operand of type ACPI_TYPE_MUTEX */
 454
 455             TypeNeeded = ACPI_TYPE_MUTEX;
 456             break;
 457
 458         case ARGI_EVENT:
 459
 460             /* Need an operand of type ACPI_TYPE_EVENT */
 461
 462             TypeNeeded = ACPI_TYPE_EVENT;
 463             break;
 464
 465         case ARGI_PACKAGE:   /* Package */
 466
 467             /* Need an operand of type ACPI_TYPE_PACKAGE */
 468
 469             TypeNeeded = ACPI_TYPE_PACKAGE;
 470             break;
 471
 472         case ARGI_ANYTYPE:
 473
 474             /* Any operand type will do */
 475
 476             TypeNeeded = ACPI_TYPE_ANY;
 477             break;
 478
 479         case ARGI_DDBHANDLE:
 480
 481             /* Need an operand of type ACPI_TYPE_DDB_HANDLE */
 482
 483             TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE;
 484             break;
 485
 486
 487         /*
 488          * The more complex cases allow multiple resolved object types
 489          */
 490         case ARGI_INTEGER:   /* Number */
 491
 492             /*
 493              * Need an operand of type ACPI_TYPE_INTEGER,
 494              * But we can implicitly convert from a STRING or BUFFER
 495              * Aka - "Implicit Source Operand Conversion"
 496              */
 497             Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16);
 498             if (ACPI_FAILURE (Status))
 499             {
 500                 if (Status == AE_TYPE)
 501                 {
 502                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 503                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 504                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 505
 506                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 507                 }
 508
 509                 return_ACPI_STATUS (Status);
 510             }
 511             goto NextOperand;
 512
 513
 514         case ARGI_BUFFER:
 515
 516             /*
 517              * Need an operand of type ACPI_TYPE_BUFFER,
 518              * But we can implicitly convert from a STRING or INTEGER
 519              * Aka - "Implicit Source Operand Conversion"
 520              */
 521             Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
 522             if (ACPI_FAILURE (Status))
 523             {
 524                 if (Status == AE_TYPE)
 525                 {
 526                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 527                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 528                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 529
 530                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 531                 }
 532
 533                 return_ACPI_STATUS (Status);
 534             }
 535             goto NextOperand;
 536
 537
 538         case ARGI_STRING:
 539
 540             /*
 541              * Need an operand of type ACPI_TYPE_STRING,
 542              * But we can implicitly convert from a BUFFER or INTEGER
 543              * Aka - "Implicit Source Operand Conversion"
 544              */
 545             Status = AcpiExConvertToString (ObjDesc, StackPtr,
 546                         ACPI_IMPLICIT_CONVERT_HEX);
 547             if (ACPI_FAILURE (Status))
 548             {
 549                 if (Status == AE_TYPE)
 550                 {
 551                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 552                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 553                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 554
 555                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 556                 }
 557
 558                 return_ACPI_STATUS (Status);
 559             }
 560             goto NextOperand;
 561
 562
 563         case ARGI_COMPUTEDATA:
 564
 565             /* Need an operand of type INTEGER, STRING or BUFFER */
 566
 567             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 568             {
 569             case ACPI_TYPE_INTEGER:
 570             case ACPI_TYPE_STRING:
 571             case ACPI_TYPE_BUFFER:
 572
 573                 /* Valid operand */
 574                break;
 575
 576             default:
 577                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 578                     "Needed [Integer/String/Buffer], found [%s] %p\n",
 579                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 580
 581                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 582             }
 583             goto NextOperand;
 584
 585
 586         case ARGI_BUFFER_OR_STRING:
 587
 588             /* Need an operand of type STRING or BUFFER */
 589
 590             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 591             {
 592             case ACPI_TYPE_STRING:
 593             case ACPI_TYPE_BUFFER:
 594
 595                 /* Valid operand */
 596                break;
 597
 598             case ACPI_TYPE_INTEGER:
 599
 600                 /* Highest priority conversion is to type Buffer */
 601
 602                 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
 603                 if (ACPI_FAILURE (Status))
 604                 {
 605                     return_ACPI_STATUS (Status);
 606                 }
 607                 break;
 608
 609             default:
 610                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 611                     "Needed [Integer/String/Buffer], found [%s] %p\n",
 612                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 613
 614                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 615             }
 616             goto NextOperand;
 617
 618
 619         case ARGI_DATAOBJECT:
 620             /*
 621              * ARGI_DATAOBJECT is only used by the SizeOf operator.
 622              * Need a buffer, string, package, or RefOf reference.
 623              *
 624              * The only reference allowed here is a direct reference to
 625              * a namespace node.
 626              */
 627             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 628             {
 629             case ACPI_TYPE_PACKAGE:
 630             case ACPI_TYPE_STRING:
 631             case ACPI_TYPE_BUFFER:
 632             case ACPI_TYPE_LOCAL_REFERENCE:
 633
 634                 /* Valid operand */
 635                 break;
 636
 637             default:
 638                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 639                     "Needed [Buffer/String/Package/Reference], found [%s] %p\n",
 640                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 641
 642                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 643             }
 644             goto NextOperand;
 645
 646
 647         case ARGI_COMPLEXOBJ:
 648
 649             /* Need a buffer or package or (ACPI 2.0) String */
 650
 651             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 652             {
 653             case ACPI_TYPE_PACKAGE:
 654             case ACPI_TYPE_STRING:
 655             case ACPI_TYPE_BUFFER:
 656
 657                 /* Valid operand */
 658                 break;
 659
 660             default:
 661                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 662                     "Needed [Buffer/String/Package], found [%s] %p\n",
 663                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 664
 665                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 666             }
 667             goto NextOperand;
 668
 669
 670         case ARGI_REGION_OR_FIELD:
 671
 672             /* Need an operand of type ACPI_TYPE_REGION or a FIELD in a region */
 673
 674             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 675             {
 676             case ACPI_TYPE_REGION:
 677             case ACPI_TYPE_LOCAL_REGION_FIELD:
 678             case ACPI_TYPE_LOCAL_BANK_FIELD:
 679             case ACPI_TYPE_LOCAL_INDEX_FIELD:
 680
 681                 /* Valid operand */
 682                 break;
 683
 684             default:
 685                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 686                     "Needed [Region/RegionField], found [%s] %p\n",
 687                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 688
 689                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 690             }
 691             goto NextOperand;
 692
 693
 694         case ARGI_DATAREFOBJ:
 695
 696             /* Used by the Store() operator only */
 697
 698             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 699             {
 700             case ACPI_TYPE_INTEGER:
 701             case ACPI_TYPE_PACKAGE:
 702             case ACPI_TYPE_STRING:
 703             case ACPI_TYPE_BUFFER:
 704             case ACPI_TYPE_BUFFER_FIELD:
 705             case ACPI_TYPE_LOCAL_REFERENCE:
 706             case ACPI_TYPE_LOCAL_REGION_FIELD:
 707             case ACPI_TYPE_LOCAL_BANK_FIELD:
 708             case ACPI_TYPE_LOCAL_INDEX_FIELD:
 709             case ACPI_TYPE_DDB_HANDLE:
 710
 711                 /* Valid operand */
 712                 break;
 713
 714             default:
 715
 716                 if (AcpiGbl_EnableInterpreterSlack)
 717                 {
 718                     /*
 719                      * Enable original behavior of Store(), allowing any and all
 720                      * objects as the source operand.  The ACPI spec does not
 721                      * allow this, however.
 722                      */
 723                     break;
 724                 }
 725
 726                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 727                     "Needed Integer/Buffer/String/Package/Ref/Ddb], found [%s] %p\n",
 728                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 729
 730                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 731             }
 732             goto NextOperand;
 733
 734
 735         default:
 736
 737             /* Unknown type */
 738
 739             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 740                 "Internal - Unknown ARGI (required operand) type %X\n",
 741                 ThisArgType));
 742
 743             return_ACPI_STATUS (AE_BAD_PARAMETER);
 744         }
 745
 746         /*
 747          * Make sure that the original object was resolved to the
 748          * required object type (Simple cases only).
 749          */
 750         Status = AcpiExCheckObjectType (TypeNeeded,
 751                         ACPI_GET_OBJECT_TYPE (*StackPtr), *StackPtr);
 752         if (ACPI_FAILURE (Status))
 753         {
 754             return_ACPI_STATUS (Status);
 755         }
 756
 757 NextOperand:
 758         /*
 759          * If more operands needed, decrement StackPtr to point
 760          * to next operand on stack
 761          */
 762         if (GET_CURRENT_ARG_TYPE (ArgTypes))
 763         {
 764             StackPtr--;
 765         }
 766
 767     }   /* while (*Types) */
 768
 769     return_ACPI_STATUS (Status);
 770 }
 771
 772