sys/contrib/dev/acpica/compiler/aslcodegen.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslcodegen - AML code generation
   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
  45 #include <contrib/dev/acpica/compiler/aslcompiler.h>
  46 #include "aslcompiler.y.h"
  47 #include <contrib/dev/acpica/include/amlcode.h>
  48
  49 #define _COMPONENT          ACPI_COMPILER
  50         ACPI_MODULE_NAME    ("aslcodegen")
  51
  52 /* Local prototypes */
  53
  54 static ACPI_STATUS
  55 CgAmlWriteWalk (
  56     ACPI_PARSE_OBJECT       *Op,
  57     UINT32                  Level,
  58     void                    *Context);
  59
  60 static void
  61 CgLocalWriteAmlData (
  62     ACPI_PARSE_OBJECT       *Op,
  63     void                    *Buffer,
  64     UINT32                  Length);
  65
  66 static void
  67 CgWriteAmlOpcode (
  68     ACPI_PARSE_OBJECT       *Op);
  69
  70 static void
  71 CgWriteTableHeader (
  72     ACPI_PARSE_OBJECT       *Op);
  73
  74 static void
  75 CgCloseTable (
  76     void);
  77
  78 static void
  79 CgWriteNode (
  80     ACPI_PARSE_OBJECT       *Op);
  81
  82
  83 /*******************************************************************************
  84  *
  85  * FUNCTION:    CgGenerateAmlOutput
  86  *
  87  * PARAMETERS:  None.
  88  *
  89  * RETURN:      None
  90  *
  91  * DESCRIPTION: Generate AML code. Currently generates the listing file
  92  *              simultaneously.
  93  *
  94  ******************************************************************************/
  95
  96 void
  97 CgGenerateAmlOutput (
  98     void)
  99 {
 100
 101     DbgPrint (ASL_DEBUG_OUTPUT, "\nWriting AML\n\n");
 102
 103     /* Generate the AML output file */
 104
 105     FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
 106     Gbl_SourceLine = 0;
 107     Gbl_NextError = Gbl_ErrorLog;
 108
 109     TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
 110         CgAmlWriteWalk, NULL, NULL);
 111     CgCloseTable ();
 112 }
 113
 114
 115 /*******************************************************************************
 116  *
 117  * FUNCTION:    CgAmlWriteWalk
 118  *
 119  * PARAMETERS:  ASL_WALK_CALLBACK
 120  *
 121  * RETURN:      Status
 122  *
 123  * DESCRIPTION: Parse tree walk to generate the AML code.
 124  *
 125  ******************************************************************************/
 126
 127 static ACPI_STATUS
 128 CgAmlWriteWalk (
 129     ACPI_PARSE_OBJECT       *Op,
 130     UINT32                  Level,
 131     void                    *Context)
 132 {
 133
 134     /*
 135      * Print header at level 0. Alignment assumes 32-bit pointers
 136      */
 137     if (!Level)
 138     {
 139         DbgPrint (ASL_TREE_OUTPUT,
 140             "Final parse tree used for AML output:\n");
 141         DbgPrint (ASL_TREE_OUTPUT,
 142             "%*s Value    P_Op A_Op OpLen PByts Len  SubLen PSubLen OpPtr    Child    Parent   Flags    AcTyp    Final Col L\n",
 143             76, " ");
 144     }
 145
 146     /* Debug output */
 147
 148     DbgPrint (ASL_TREE_OUTPUT,
 149         "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level);
 150     UtPrintFormattedName (Op->Asl.ParseOpcode, Level);
 151
 152     if (Op->Asl.ParseOpcode == PARSEOP_NAMESEG    ||
 153         Op->Asl.ParseOpcode == PARSEOP_NAMESTRING ||
 154         Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
 155     {
 156         DbgPrint (ASL_TREE_OUTPUT,
 157             "%10.32s      ", Op->Asl.ExternalName);
 158     }
 159     else
 160     {
 161         DbgPrint (ASL_TREE_OUTPUT, "                ");
 162     }
 163
 164     DbgPrint (ASL_TREE_OUTPUT,
 165     "%08X %04X %04X %01X     %04X  %04X %04X   %04X    %08X %08X %08X %08X %08X %04X  %02d  %02d\n",
 166             /* 1  */ (UINT32) Op->Asl.Value.Integer,
 167             /* 2  */ Op->Asl.ParseOpcode,
 168             /* 3  */ Op->Asl.AmlOpcode,
 169             /* 4  */ Op->Asl.AmlOpcodeLength,
 170             /* 5  */ Op->Asl.AmlPkgLenBytes,
 171             /* 6  */ Op->Asl.AmlLength,
 172             /* 7  */ Op->Asl.AmlSubtreeLength,
 173             /* 8  */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0,
 174             /* 9  */ Op,
 175             /* 10 */ Op->Asl.Child,
 176             /* 11 */ Op->Asl.Parent,
 177             /* 12 */ Op->Asl.CompileFlags,
 178             /* 13 */ Op->Asl.AcpiBtype,
 179             /* 14 */ Op->Asl.FinalAmlLength,
 180             /* 15 */ Op->Asl.Column,
 181             /* 16 */ Op->Asl.LineNumber);
 182
 183     /* Generate the AML for this node */
 184
 185     CgWriteNode (Op);
 186     return (AE_OK);
 187 }
 188
 189
 190 /*******************************************************************************
 191  *
 192  * FUNCTION:    CgLocalWriteAmlData
 193  *
 194  * PARAMETERS:  Op              - Current parse op
 195  *              Buffer          - Buffer to write
 196  *              Length          - Size of data in buffer
 197  *
 198  * RETURN:      None
 199  *
 200  * DESCRIPTION: Write a buffer of AML data to the AML output file.
 201  *
 202  ******************************************************************************/
 203
 204 static void
 205 CgLocalWriteAmlData (
 206     ACPI_PARSE_OBJECT       *Op,
 207     void                    *Buffer,
 208     UINT32                  Length)
 209 {
 210
 211     /* Write the raw data to the AML file */
 212
 213     FlWriteFile (ASL_FILE_AML_OUTPUT, Buffer, Length);
 214
 215     /* Update the final AML length for this node (used for listings) */
 216
 217     if (Op)
 218     {
 219         Op->Asl.FinalAmlLength += Length;
 220     }
 221 }
 222
 223
 224 /*******************************************************************************
 225  *
 226  * FUNCTION:    CgWriteAmlOpcode
 227  *
 228  * PARAMETERS:  Op            - Parse node with an AML opcode
 229  *
 230  * RETURN:      None.
 231  *
 232  * DESCRIPTION: Write the AML opcode corresponding to a parse node.
 233  *
 234  ******************************************************************************/
 235
 236 static void
 237 CgWriteAmlOpcode (
 238     ACPI_PARSE_OBJECT       *Op)
 239 {
 240     UINT8                   PkgLenFirstByte;
 241     UINT32                  i;
 242     union {
 243         UINT16                  Opcode;
 244         UINT8                   OpcodeBytes[2];
 245     } Aml;
 246     union {
 247         UINT32                  Len;
 248         UINT8                   LenBytes[4];
 249     } PkgLen;
 250
 251
 252     /* We expect some DEFAULT_ARGs, just ignore them */
 253
 254     if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 255     {
 256         return;
 257     }
 258
 259     switch (Op->Asl.AmlOpcode)
 260     {
 261     case AML_UNASSIGNED_OPCODE:
 262
 263         /* These opcodes should not get here */
 264
 265         printf ("Found a node with an unassigned AML opcode\n");
 266         FlPrintFile (ASL_FILE_STDERR, "Found a node with an unassigned AML opcode\n");
 267         return;
 268
 269     case AML_INT_RESERVEDFIELD_OP:
 270
 271         /* Special opcodes for within a field definition */
 272
 273         Aml.Opcode = AML_FIELD_OFFSET_OP;
 274         break;
 275
 276     case AML_INT_ACCESSFIELD_OP:
 277
 278         Aml.Opcode = AML_FIELD_ACCESS_OP;
 279         break;
 280
 281     case AML_INT_CONNECTION_OP:
 282
 283         Aml.Opcode = AML_FIELD_CONNECTION_OP;
 284         break;
 285
 286     default:
 287
 288         Aml.Opcode = Op->Asl.AmlOpcode;
 289         break;
 290     }
 291
 292
 293     switch (Aml.Opcode)
 294     {
 295     case AML_PACKAGE_LENGTH:
 296
 297         /* Value is the length to be encoded (Used in field definitions) */
 298
 299         PkgLen.Len = (UINT32) Op->Asl.Value.Integer;
 300         break;
 301
 302     default:
 303
 304         /* Check for two-byte opcode */
 305
 306         if (Aml.Opcode > 0x00FF)
 307         {
 308             /* Write the high byte first */
 309
 310             CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1);
 311         }
 312
 313         CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1);
 314
 315         /* Subtreelength doesn't include length of package length bytes */
 316
 317         PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;
 318         break;
 319     }
 320
 321     /* Does this opcode have an associated "PackageLength" field? */
 322
 323     if (Op->Asl.CompileFlags & NODE_AML_PACKAGE)
 324     {
 325         if (Op->Asl.AmlPkgLenBytes == 1)
 326         {
 327             /* Simplest case -- no bytes to follow, just write the count */
 328
 329             CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);
 330         }
 331         else if (Op->Asl.AmlPkgLenBytes != 0)
 332         {
 333             /*
 334              * Encode the "bytes to follow" in the first byte, top two bits.
 335              * The low-order nybble of the length is in the bottom 4 bits
 336              */
 337             PkgLenFirstByte = (UINT8)
 338                 (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) |
 339                 (PkgLen.LenBytes[0] & 0x0F));
 340
 341             CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);
 342
 343             /*
 344              * Shift the length over by the 4 bits we just stuffed
 345              * in the first byte
 346              */
 347             PkgLen.Len >>= 4;
 348
 349             /* Now we can write the remaining bytes - either 1, 2, or 3 bytes */
 350
 351             for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++)
 352             {
 353                 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1);
 354             }
 355         }
 356     }
 357
 358     switch (Aml.Opcode)
 359     {
 360     case AML_BYTE_OP:
 361
 362         CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1);
 363         break;
 364
 365     case AML_WORD_OP:
 366
 367         CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2);
 368        break;
 369
 370     case AML_DWORD_OP:
 371
 372         CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4);
 373         break;
 374
 375     case AML_QWORD_OP:
 376
 377         CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8);
 378         break;
 379
 380     case AML_STRING_OP:
 381
 382         CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
 383         break;
 384
 385     default:
 386
 387         /* All data opcodes must appear above */
 388
 389         break;
 390     }
 391 }
 392
 393
 394 /*******************************************************************************
 395  *
 396  * FUNCTION:    CgWriteTableHeader
 397  *
 398  * PARAMETERS:  Op        - The DEFINITIONBLOCK node
 399  *
 400  * RETURN:      None
 401  *
 402  * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK
 403  *
 404  ******************************************************************************/
 405
 406 static void
 407 CgWriteTableHeader (
 408     ACPI_PARSE_OBJECT       *Op)
 409 {
 410     ACPI_PARSE_OBJECT       *Child;
 411
 412
 413     /* AML filename */
 414
 415     Child = Op->Asl.Child;
 416
 417     /* Signature */
 418
 419     Child = Child->Asl.Next;
 420     strncpy (TableHeader.Signature, Child->Asl.Value.String, 4);
 421
 422     /* Revision */
 423
 424     Child = Child->Asl.Next;
 425     TableHeader.Revision = (UINT8) Child->Asl.Value.Integer;
 426
 427     /* Command-line Revision override */
 428
 429     if (Gbl_RevisionOverride)
 430     {
 431         TableHeader.Revision = Gbl_RevisionOverride;
 432     }
 433
 434     /* OEMID */
 435
 436     Child = Child->Asl.Next;
 437     strncpy (TableHeader.OemId, Child->Asl.Value.String, 6);
 438
 439     /* OEM TableID */
 440
 441     Child = Child->Asl.Next;
 442     strncpy (TableHeader.OemTableId, Child->Asl.Value.String, 8);
 443
 444     /* OEM Revision */
 445
 446     Child = Child->Asl.Next;
 447     TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer;
 448
 449     /* Compiler ID */
 450
 451     ACPI_MOVE_NAME (TableHeader.AslCompilerId, ASL_CREATOR_ID);
 452
 453     /* Compiler version */
 454
 455     TableHeader.AslCompilerRevision = ASL_REVISION;
 456
 457     /* Table length. Checksum zero for now, will rewrite later */
 458
 459     TableHeader.Length   = Gbl_TableLength;
 460     TableHeader.Checksum = 0;
 461
 462     CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER));
 463 }
 464
 465
 466 /*******************************************************************************
 467  *
 468  * FUNCTION:    CgCloseTable
 469  *
 470  * PARAMETERS:  None.
 471  *
 472  * RETURN:      None.
 473  *
 474  * DESCRIPTION: Complete the ACPI table by calculating the checksum and
 475  *              re-writing the header.
 476  *
 477  ******************************************************************************/
 478
 479 static void
 480 CgCloseTable (
 481     void)
 482 {
 483     signed char         Sum;
 484     UINT8               FileByte;
 485
 486
 487     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
 488     Sum = 0;
 489
 490     /* Calculate the checksum over the entire file */
 491
 492     while (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1) == AE_OK)
 493     {
 494         Sum = (signed char) (Sum + FileByte);
 495     }
 496
 497     /* Re-write the table header with the checksum */
 498
 499     TableHeader.Checksum = (UINT8) (0 - Sum);
 500
 501     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
 502     CgLocalWriteAmlData (NULL, &TableHeader, sizeof (ACPI_TABLE_HEADER));
 503 }
 504
 505
 506 /*******************************************************************************
 507  *
 508  * FUNCTION:    CgWriteNode
 509  *
 510  * PARAMETERS:  Op            - Parse node to write.
 511  *
 512  * RETURN:      None.
 513  *
 514  * DESCRIPTION: Write the AML that corresponds to a parse node.
 515  *
 516  ******************************************************************************/
 517
 518 static void
 519 CgWriteNode (
 520     ACPI_PARSE_OBJECT       *Op)
 521 {
 522     ASL_RESOURCE_NODE       *Rnode;
 523
 524
 525     /* Always check for DEFAULT_ARG and other "Noop" nodes */
 526     /* TBD: this may not be the best place for this check */
 527
 528     if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)  ||
 529         (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL)     ||
 530         (Op->Asl.ParseOpcode == PARSEOP_INCLUDE)      ||
 531         (Op->Asl.ParseOpcode == PARSEOP_INCLUDE_END))
 532     {
 533         return;
 534     }
 535
 536     Op->Asl.FinalAmlLength = 0;
 537
 538     switch (Op->Asl.AmlOpcode)
 539     {
 540     case AML_RAW_DATA_BYTE:
 541     case AML_RAW_DATA_WORD:
 542     case AML_RAW_DATA_DWORD:
 543     case AML_RAW_DATA_QWORD:
 544
 545         CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength);
 546         return;
 547
 548
 549     case AML_RAW_DATA_BUFFER:
 550
 551         CgLocalWriteAmlData (Op, Op->Asl.Value.Buffer, Op->Asl.AmlLength);
 552         return;
 553
 554
 555     case AML_RAW_DATA_CHAIN:
 556
 557         Rnode = ACPI_CAST_PTR (ASL_RESOURCE_NODE, Op->Asl.Value.Buffer);
 558         while (Rnode)
 559         {
 560             CgLocalWriteAmlData (Op, Rnode->Buffer, Rnode->BufferLength);
 561             Rnode = Rnode->Next;
 562         }
 563         return;
 564
 565     default:
 566
 567         /* Internal data opcodes must all appear above */
 568
 569         break;
 570     }
 571
 572     switch (Op->Asl.ParseOpcode)
 573     {
 574     case PARSEOP_DEFAULT_ARG:
 575
 576         break;
 577
 578     case PARSEOP_DEFINITIONBLOCK:
 579
 580         CgWriteTableHeader (Op);
 581         break;
 582
 583     case PARSEOP_NAMESEG:
 584     case PARSEOP_NAMESTRING:
 585     case PARSEOP_METHODCALL:
 586
 587         CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
 588         break;
 589
 590     default:
 591
 592         CgWriteAmlOpcode (Op);
 593         break;
 594     }
 595 }