sys/contrib/dev/acpica-unix/compiler/aslbtypes.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslbtypes - Support for bitfield types
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116
 117 #include "aslcompiler.h"
 118 #include "aslcompiler.y.h"
 119 #include "amlcode.h"
 120
 121
 122 #define _COMPONENT          ACPI_COMPILER
 123         ACPI_MODULE_NAME    ("aslbtypes")
 124
 125 /* Local prototypes */
 126
 127 static UINT32
 128 AnMapEtypeToBtype (
 129     UINT32                  Etype);
 130
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    AnMapArgTypeToBtype
 135  *
 136  * PARAMETERS:  ArgType             - The ARGI required type(s) for this
 137  *                                    argument, from the opcode info table
 138  *
 139  * RETURN:      The corresponding Bit-encoded types
 140  *
 141  * DESCRIPTION: Convert an encoded ARGI required argument type code into a
 142  *              bitfield type code. Implements the implicit source conversion
 143  *              rules.
 144  *
 145  ******************************************************************************/
 146
 147 UINT32
 148 AnMapArgTypeToBtype (
 149     UINT32                  ArgType)
 150 {
 151
 152     switch (ArgType)
 153     {
 154
 155     /* Simple types */
 156
 157     case ARGI_ANYTYPE:
 158         return (ACPI_BTYPE_OBJECTS_AND_REFS);
 159
 160     case ARGI_PACKAGE:
 161         return (ACPI_BTYPE_PACKAGE);
 162
 163     case ARGI_EVENT:
 164         return (ACPI_BTYPE_EVENT);
 165
 166     case ARGI_MUTEX:
 167         return (ACPI_BTYPE_MUTEX);
 168
 169     case ARGI_DDBHANDLE:
 170         /*
 171          * DDBHandleObject := SuperName
 172          * ACPI_BTYPE_REFERENCE: Index reference as parameter of Load/Unload
 173          */
 174         return (ACPI_BTYPE_DDB_HANDLE | ACPI_BTYPE_REFERENCE);
 175
 176     /* Interchangeable types */
 177     /*
 178      * Source conversion rules:
 179      * Integer, String, and Buffer are all interchangeable
 180      */
 181     case ARGI_INTEGER:
 182     case ARGI_STRING:
 183     case ARGI_BUFFER:
 184     case ARGI_BUFFER_OR_STRING:
 185     case ARGI_COMPUTEDATA:
 186         return (ACPI_BTYPE_COMPUTE_DATA);
 187
 188     /* References */
 189
 190     case ARGI_INTEGER_REF:
 191         return (ACPI_BTYPE_INTEGER);
 192
 193     case ARGI_OBJECT_REF:
 194         return (ACPI_BTYPE_ALL_OBJECTS);
 195
 196     case ARGI_DEVICE_REF:
 197         return (ACPI_BTYPE_DEVICE_OBJECTS);
 198
 199     case ARGI_REFERENCE:
 200         return (ACPI_BTYPE_REFERENCE);
 201
 202     case ARGI_TARGETREF:
 203     case ARGI_FIXED_TARGET:
 204     case ARGI_SIMPLE_TARGET:
 205         return (ACPI_BTYPE_OBJECTS_AND_REFS);
 206
 207     /* Complex types */
 208
 209     case ARGI_DATAOBJECT:
 210
 211         /*
 212          * Buffer, string, package or reference to a Op -
 213          * Used only by SizeOf operator
 214          */
 215         return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
 216             ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE);
 217
 218     case ARGI_COMPLEXOBJ:
 219
 220         /* Buffer, String, or package */
 221
 222         return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | ACPI_BTYPE_PACKAGE);
 223
 224     case ARGI_REF_OR_STRING:
 225         return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE);
 226
 227     case ARGI_REGION_OR_BUFFER:
 228
 229         /* Used by Load() only. Allow buffers in addition to regions/fields */
 230
 231         return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER | ACPI_BTYPE_FIELD_UNIT);
 232
 233     case ARGI_DATAREFOBJ:
 234         return (ACPI_BTYPE_INTEGER |ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
 235             ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE | ACPI_BTYPE_DDB_HANDLE);
 236
 237     default:
 238         break;
 239     }
 240
 241     return (ACPI_BTYPE_OBJECTS_AND_REFS);
 242 }
 243
 244
 245 /*******************************************************************************
 246  *
 247  * FUNCTION:    AnMapEtypeToBtype
 248  *
 249  * PARAMETERS:  Etype               - Encoded ACPI Type
 250  *
 251  * RETURN:      Btype corresponding to the Etype
 252  *
 253  * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
 254  *              operand conversion rules. In other words, returns the type(s)
 255  *              this Etype is implicitly converted to during interpretation.
 256  *
 257  ******************************************************************************/
 258
 259 static UINT32
 260 AnMapEtypeToBtype (
 261     UINT32                  Etype)
 262 {
 263
 264
 265     if (Etype == ACPI_TYPE_ANY)
 266     {
 267         return (ACPI_BTYPE_OBJECTS_AND_REFS);
 268     }
 269
 270     /* Try the standard ACPI data types */
 271
 272     if (Etype <= ACPI_TYPE_EXTERNAL_MAX)
 273     {
 274         /*
 275          * This switch statement implements the allowed operand conversion
 276          * rules as per the "ASL Data Types" section of the ACPI
 277          * specification.
 278          */
 279         switch (Etype)
 280         {
 281         case ACPI_TYPE_INTEGER:
 282             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE);
 283
 284         case ACPI_TYPE_STRING:
 285         case ACPI_TYPE_BUFFER:
 286             return (ACPI_BTYPE_COMPUTE_DATA);
 287
 288         case ACPI_TYPE_PACKAGE:
 289             return (ACPI_BTYPE_PACKAGE);
 290
 291         case ACPI_TYPE_FIELD_UNIT:
 292             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
 293
 294         case ACPI_TYPE_BUFFER_FIELD:
 295             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD);
 296
 297         case ACPI_TYPE_DDB_HANDLE:
 298             return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE);
 299
 300         case ACPI_BTYPE_DEBUG_OBJECT:
 301
 302             /* Cannot be used as a source operand */
 303
 304             return (0);
 305
 306         default:
 307             return (1 << (Etype - 1));
 308         }
 309     }
 310
 311     /* Try the internal data types */
 312
 313     switch (Etype)
 314     {
 315     case ACPI_TYPE_LOCAL_REGION_FIELD:
 316     case ACPI_TYPE_LOCAL_BANK_FIELD:
 317     case ACPI_TYPE_LOCAL_INDEX_FIELD:
 318
 319         /* Named fields can be either Integer/Buffer/String */
 320
 321         return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
 322
 323     case ACPI_TYPE_LOCAL_ALIAS:
 324
 325         return (ACPI_BTYPE_INTEGER);
 326
 327
 328     case ACPI_TYPE_LOCAL_RESOURCE:
 329     case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
 330
 331         return (ACPI_BTYPE_REFERENCE);
 332
 333     default:
 334         printf ("Unhandled encoded type: %X\n", Etype);
 335         return (0);
 336     }
 337 }
 338
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    AnFormatBtype
 343  *
 344  * PARAMETERS:  Btype               - Bitfield of ACPI types
 345  *              Buffer              - Where to put the ascii string
 346  *
 347  * RETURN:      None.
 348  *
 349  * DESCRIPTION: Convert a Btype to a string of ACPI types
 350  *
 351  ******************************************************************************/
 352
 353 void
 354 AnFormatBtype (
 355     char                    *Buffer,
 356     UINT32                  Btype)
 357 {
 358     UINT32                  Type;
 359     BOOLEAN                 First = TRUE;
 360
 361
 362     *Buffer = 0;
 363
 364     if (Btype == 0)
 365     {
 366         strcat (Buffer, "NoReturnValue");
 367         return;
 368     }
 369
 370     for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++)
 371     {
 372         if (Btype & 0x00000001)
 373         {
 374             if (!First)
 375             {
 376                 strcat (Buffer, "|");
 377             }
 378             First = FALSE;
 379             strcat (Buffer, AcpiUtGetTypeName (Type));
 380         }
 381         Btype >>= 1;
 382     }
 383
 384     if (Btype & 0x00000001)
 385     {
 386         if (!First)
 387         {
 388             strcat (Buffer, "|");
 389         }
 390         First = FALSE;
 391         strcat (Buffer, "Reference");
 392     }
 393
 394     Btype >>= 1;
 395     if (Btype & 0x00000001)
 396     {
 397         if (!First)
 398         {
 399             strcat (Buffer, "|");
 400         }
 401         First = FALSE;
 402         strcat (Buffer, "Resource");
 403     }
 404 }
 405
 406
 407 /*******************************************************************************
 408  *
 409  * FUNCTION:    AnGetBtype
 410  *
 411  * PARAMETERS:  Op                  - Parse node whose type will be returned.
 412  *
 413  * RETURN:      The Btype associated with the Op.
 414  *
 415  * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node.
 416  *              Handles the case where the node is a name or method call and
 417  *              the actual type must be obtained from the namespace node.
 418  *
 419  ******************************************************************************/
 420
 421 UINT32
 422 AnGetBtype (
 423     ACPI_PARSE_OBJECT       *Op)
 424 {
 425     ACPI_NAMESPACE_NODE     *Node;
 426     ACPI_PARSE_OBJECT       *ReferencedNode;
 427     UINT32                  ThisNodeBtype = 0;
 428
 429
 430     if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG)     ||
 431         (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING)  ||
 432         (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
 433     {
 434         Node = Op->Asl.Node;
 435         if (!Node)
 436         {
 437             DbgPrint (ASL_DEBUG_OUTPUT,
 438                 "No attached Nsnode: [%s] at line %u name [%s], ignoring typecheck\n",
 439                 Op->Asl.ParseOpName, Op->Asl.LineNumber,
 440                 Op->Asl.ExternalName);
 441             return (ACPI_UINT32_MAX);
 442         }
 443
 444         ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
 445         if (!ThisNodeBtype)
 446         {
 447             AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
 448                 "could not map type");
 449         }
 450
 451         /*
 452          * Since it was a named reference, enable the
 453          * reference bit also
 454          */
 455         ThisNodeBtype |= ACPI_BTYPE_REFERENCE;
 456
 457         if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
 458         {
 459             ReferencedNode = Node->Op;
 460             if (!ReferencedNode)
 461             {
 462                 /* Check for an internal method */
 463
 464                 if (AnIsInternalMethod (Op))
 465                 {
 466                     return (AnGetInternalMethodReturnType (Op));
 467                 }
 468
 469                 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
 470                     "null Op pointer");
 471                 return (ACPI_UINT32_MAX);
 472             }
 473
 474             if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
 475             {
 476                 ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
 477             }
 478             else
 479             {
 480                 return (ACPI_UINT32_MAX -1);
 481             }
 482         }
 483     }
 484     else
 485     {
 486         ThisNodeBtype = Op->Asl.AcpiBtype;
 487     }
 488
 489     return (ThisNodeBtype);
 490 }
 491
 492
 493 /*******************************************************************************
 494  *
 495  * FUNCTION:    AnMapObjTypeToBtype
 496  *
 497  * PARAMETERS:  Op                  - A parse node
 498  *
 499  * RETURN:      A Btype
 500  *
 501  * DESCRIPTION: Map object to the associated "Btype"
 502  *
 503  ******************************************************************************/
 504
 505 UINT32
 506 AnMapObjTypeToBtype (
 507     ACPI_PARSE_OBJECT       *Op)
 508 {
 509
 510     switch (Op->Asl.ParseOpcode)
 511     {
 512     case PARSEOP_OBJECTTYPE_BFF:        /* "BuffFieldObj" */
 513         return (ACPI_BTYPE_BUFFER_FIELD);
 514
 515     case PARSEOP_OBJECTTYPE_BUF:        /* "BuffObj" */
 516         return (ACPI_BTYPE_BUFFER);
 517
 518     case PARSEOP_OBJECTTYPE_DDB:        /* "DDBHandleObj" */
 519         return (ACPI_BTYPE_DDB_HANDLE);
 520
 521     case PARSEOP_OBJECTTYPE_DEV:        /* "DeviceObj" */
 522         return (ACPI_BTYPE_DEVICE);
 523
 524     case PARSEOP_OBJECTTYPE_EVT:        /* "EventObj" */
 525         return (ACPI_BTYPE_EVENT);
 526
 527     case PARSEOP_OBJECTTYPE_FLD:        /* "FieldUnitObj" */
 528         return (ACPI_BTYPE_FIELD_UNIT);
 529
 530     case PARSEOP_OBJECTTYPE_INT:        /* "IntObj" */
 531         return (ACPI_BTYPE_INTEGER);
 532
 533     case PARSEOP_OBJECTTYPE_MTH:        /* "MethodObj" */
 534         return (ACPI_BTYPE_METHOD);
 535
 536     case PARSEOP_OBJECTTYPE_MTX:        /* "MutexObj" */
 537         return (ACPI_BTYPE_MUTEX);
 538
 539     case PARSEOP_OBJECTTYPE_OPR:        /* "OpRegionObj" */
 540         return (ACPI_BTYPE_REGION);
 541
 542     case PARSEOP_OBJECTTYPE_PKG:        /* "PkgObj" */
 543         return (ACPI_BTYPE_PACKAGE);
 544
 545     case PARSEOP_OBJECTTYPE_POW:        /* "PowerResObj" */
 546         return (ACPI_BTYPE_POWER);
 547
 548     case PARSEOP_OBJECTTYPE_STR:        /* "StrObj" */
 549         return (ACPI_BTYPE_STRING);
 550
 551     case PARSEOP_OBJECTTYPE_THZ:        /* "ThermalZoneObj" */
 552         return (ACPI_BTYPE_THERMAL);
 553
 554     case PARSEOP_OBJECTTYPE_UNK:        /* "UnknownObj" */
 555         return (ACPI_BTYPE_OBJECTS_AND_REFS);
 556
 557     default:
 558         return (0);
 559     }
 560 }
 561
 562
 563 #ifdef ACPI_OBSOLETE_FUNCTIONS
 564 /*******************************************************************************
 565  *
 566  * FUNCTION:    AnMapBtypeToEtype
 567  *
 568  * PARAMETERS:  Btype               - Bitfield of ACPI types
 569  *
 570  * RETURN:      The Etype corresponding the the Btype
 571  *
 572  * DESCRIPTION: Convert a bitfield type to an encoded type
 573  *
 574  ******************************************************************************/
 575
 576 UINT32
 577 AnMapBtypeToEtype (
 578     UINT32              Btype)
 579 {
 580     UINT32              i;
 581     UINT32              Etype;
 582
 583
 584     if (Btype == 0)
 585     {
 586         return (0);
 587     }
 588
 589     Etype = 1;
 590     for (i = 1; i < Btype; i *= 2)
 591     {
 592         Etype++;
 593     }
 594
 595     return (Etype);
 596 }
 597 #endif