void
UtDisplaySummary (
UINT32 FileId)
{
UINT32 i;
if (FileId != ASL_FILE_STDOUT)
{
/* Compiler name and version number */
FlPrintFile (FileId, "%s version %X%s [%s]\n\n",
ASL_COMPILER_NAME, (UINT32) ACPI_CA_VERSION, ACPI_WIDTH, ACPI_DATE);
}
/* Summary of main input and output files */
if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_DATA)
{
FlPrintFile (FileId,
"%-14s %s - %u lines, %u bytes, %u fields\n",
"Table Input:",
Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_CurrentLineNumber,
Gbl_InputByteCount, Gbl_InputFieldCount);
if ((Gbl_ExceptionCount[ASL_ERROR] == 0) || (Gbl_IgnoreErrors))
{
FlPrintFile (FileId,
"%-14s %s - %u bytes\n",
"Binary Output:",
Gbl_Files[ASL_FILE_AML_OUTPUT].Filename, Gbl_TableLength);
}
}
else
{
FlPrintFile (FileId,
"%-14s %s - %u lines, %u bytes, %u keywords\n",
"ASL Input:",
Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_CurrentLineNumber,
Gbl_OriginalInputFileSize, TotalKeywords);
/* AML summary */
if ((Gbl_ExceptionCount[ASL_ERROR] == 0) || (Gbl_IgnoreErrors))
{
if (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle)
{
FlPrintFile (FileId,
"%-14s %s - %u bytes, %u named objects, "
"%u executable opcodes\n",
"AML Output:",
Gbl_Files[ASL_FILE_AML_OUTPUT].Filename,
FlGetFileSize (ASL_FILE_AML_OUTPUT),
TotalNamedObjects, TotalExecutableOpcodes);
}
}
}
/* Display summary of any optional files */
for (i = ASL_FILE_SOURCE_OUTPUT; i <= ASL_MAX_FILE_TYPE; i++)
{
if (!Gbl_Files[i].Filename || !Gbl_Files[i].Handle)
{
continue;
}
/* .SRC is a temp file unless specifically requested */
if ((i == ASL_FILE_SOURCE_OUTPUT) && (!Gbl_SourceOutputFlag))
{
continue;
}
/* .PRE is the preprocessor intermediate file */
if ((i == ASL_FILE_PREPROCESSOR) && (!Gbl_KeepPreprocessorTempFile))
{
continue;
}
FlPrintFile (FileId, "%14s %s - %u bytes\n",
Gbl_Files[i].ShortDescription,
Gbl_Files[i].Filename, FlGetFileSize (i));
}
/* Error summary */
FlPrintFile (FileId,
"\nCompilation complete. %u Errors, %u Warnings, %u Remarks",
Gbl_ExceptionCount[ASL_ERROR],
Gbl_ExceptionCount[ASL_WARNING] +
Gbl_ExceptionCount[ASL_WARNING2] +
Gbl_ExceptionCount[ASL_WARNING3],
Gbl_ExceptionCount[ASL_REMARK]);
if (Gbl_FileType != ASL_INPUT_TYPE_ASCII_DATA)
{
FlPrintFile (FileId, ", %u Optimizations",
Gbl_ExceptionCount[ASL_OPTIMIZATION]);
if (TotalFolds)
{
FlPrintFile (FileId, ", %u Constants Folded", TotalFolds);
}
}
FlPrintFile (FileId, "\n");
}
ACPI_STATUS
LsAmlOffsetWalk (
ACPI_PARSE_OBJECT *Op,
UINT32 Level,
void *Context)
{
UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context);
ACPI_NAMESPACE_NODE *Node;
UINT32 Length;
UINT32 NamepathOffset;
UINT32 DataOffset;
ACPI_PARSE_OBJECT *NextOp;
/* Ignore actual data blocks for resource descriptors */
if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DATA)
{
return (AE_OK); /* Do NOT update the global AML offset */
}
/* We are only interested in named objects (have a namespace node) */
Node = Op->Asl.Node;
if (!Node)
{
Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength;
return (AE_OK);
}
/* Named resource descriptor (has a descriptor tag) */
if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE) &&
(Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC))
{
LsEmitOffsetTableEntry (FileId, Node, 0, Gbl_CurrentAmlOffset,
Op->Asl.ParseOpName, 0, Op->Asl.Extra, AML_BUFFER_OP);
Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength;
return (AE_OK);
}
switch (Op->Asl.AmlOpcode)
{
case AML_NAME_OP:
/* Named object -- Name (NameString, DataRefObject) */
if (!Op->Asl.Child)
{
FlPrintFile (FileId, "%s NO CHILD!\n", MsgBuffer);
return (AE_OK);
}
Length = Op->Asl.FinalAmlLength;
/* Get to the NameSeg/NamePath Op (and length of the name) */
Op = Op->Asl.Child;
/* Get offset of last nameseg and the actual data */
NamepathOffset = Gbl_CurrentAmlOffset + Length +
(Op->Asl.FinalAmlLength - ACPI_NAME_SIZE);
DataOffset = Gbl_CurrentAmlOffset + Length +
Op->Asl.FinalAmlLength;
/* Get actual value associated with the name */
Op = Op->Asl.Next;
switch (Op->Asl.AmlOpcode)
{
case AML_BYTE_OP:
case AML_WORD_OP:
case AML_DWORD_OP:
case AML_QWORD_OP:
/* The +1 is to handle the integer size prefix (opcode) */
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, (DataOffset + 1),
Op->Asl.ParseOpName, Op->Asl.Value.Integer,
(UINT8) Op->Asl.AmlOpcode, AML_NAME_OP);
break;
case AML_ONE_OP:
case AML_ONES_OP:
case AML_ZERO_OP:
/* For these, offset will point to the opcode */
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset,
Op->Asl.ParseOpName, Op->Asl.Value.Integer,
(UINT8) Op->Asl.AmlOpcode, AML_NAME_OP);
break;
case AML_PACKAGE_OP:
case AML_VARIABLE_PACKAGE_OP:
/* Get the package element count */
NextOp = Op->Asl.Child;
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset,
Op->Asl.ParseOpName, NextOp->Asl.Value.Integer,
(UINT8) Op->Asl.AmlOpcode, AML_NAME_OP);
break;
default:
break;
}
Gbl_CurrentAmlOffset += Length;
return (AE_OK);
case AML_REGION_OP:
/* OperationRegion (NameString, RegionSpace, RegionOffset, RegionLength) */
Length = Op->Asl.FinalAmlLength;
/* Get the name/namepath node */
NextOp = Op->Asl.Child;
/* Get offset of last nameseg and the actual data */
NamepathOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE);
DataOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength + 1);
/* Get the SpaceId node, then the Offset (address) node */
NextOp = NextOp->Asl.Next;
NextOp = NextOp->Asl.Next;
switch (NextOp->Asl.AmlOpcode)
{
/*
* We are only interested in integer constants that can be changed
* at boot time. Note, the One/Ones/Zero opcodes are considered
* non-changeable, so we ignore them here.
*/
case AML_BYTE_OP:
case AML_WORD_OP:
case AML_DWORD_OP:
case AML_QWORD_OP:
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, (DataOffset + 1),
Op->Asl.ParseOpName, NextOp->Asl.Value.Integer,
(UINT8) NextOp->Asl.AmlOpcode, AML_REGION_OP);
Gbl_CurrentAmlOffset += Length;
return (AE_OK);
default:
break;
}
break;
case AML_METHOD_OP:
/* Method (Namepath, ...) */
Length = Op->Asl.FinalAmlLength;
/* Get the NameSeg/NamePath Op */
NextOp = Op->Asl.Child;
/* Get offset of last nameseg and the actual data (flags byte) */
NamepathOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE);
DataOffset = Gbl_CurrentAmlOffset + Length +
NextOp->Asl.FinalAmlLength;
/* Get the flags byte Op */
NextOp = NextOp->Asl.Next;
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset,
Op->Asl.ParseOpName, NextOp->Asl.Value.Integer,
(UINT8) Op->Asl.AmlOpcode, AML_METHOD_OP);
break;
case AML_PROCESSOR_OP:
/* Processor (Namepath, ProcessorId, Address, Length) */
Length = Op->Asl.FinalAmlLength;
NextOp = Op->Asl.Child; /* Get Namepath */
/* Get offset of last nameseg and the actual data (PBlock address) */
NamepathOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE);
DataOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength + 1);
NextOp = NextOp->Asl.Next; /* Get ProcessorID (BYTE) */
NextOp = NextOp->Asl.Next; /* Get Address (DWORD) */
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset,
Op->Asl.ParseOpName, NextOp->Asl.Value.Integer,
(UINT8) AML_DWORD_OP, AML_PROCESSOR_OP);
break;
case AML_DEVICE_OP:
case AML_SCOPE_OP:
case AML_THERMAL_ZONE_OP:
/* Device/Scope/ThermalZone (Namepath) */
Length = Op->Asl.FinalAmlLength;
NextOp = Op->Asl.Child; /* Get Namepath */
/* Get offset of last nameseg */
NamepathOffset = Gbl_CurrentAmlOffset + Length +
(NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE);
LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, 0,
Op->Asl.ParseOpName, 0, (UINT8) 0, Op->Asl.AmlOpcode);
break;
default:
break;
}
Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength;
return (AE_OK);
}
static void
CgWriteAmlOpcode (
ACPI_PARSE_OBJECT *Op)
{
UINT8 PkgLenFirstByte;
UINT32 i;
union {
UINT16 Opcode;
UINT8 OpcodeBytes[2];
} Aml;
union {
UINT32 Len;
UINT8 LenBytes[4];
} PkgLen;
/* We expect some DEFAULT_ARGs, just ignore them */
if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
{
return;
}
switch (Op->Asl.AmlOpcode)
{
case AML_UNASSIGNED_OPCODE:
/* These opcodes should not get here */
printf ("Found a node with an unassigned AML opcode\n");
FlPrintFile (ASL_FILE_STDERR, "Found a node with an unassigned AML opcode\n");
return;
case AML_INT_RESERVEDFIELD_OP:
/* Special opcodes for within a field definition */
Aml.Opcode = AML_FIELD_OFFSET_OP;
break;
case AML_INT_ACCESSFIELD_OP:
Aml.Opcode = AML_FIELD_ACCESS_OP;
break;
case AML_INT_CONNECTION_OP:
Aml.Opcode = AML_FIELD_CONNECTION_OP;
break;
default:
Aml.Opcode = Op->Asl.AmlOpcode;
break;
}
switch (Aml.Opcode)
{
case AML_PACKAGE_LENGTH:
/* Value is the length to be encoded (Used in field definitions) */
PkgLen.Len = (UINT32) Op->Asl.Value.Integer;
break;
default:
/* Check for two-byte opcode */
if (Aml.Opcode > 0x00FF)
{
/* Write the high byte first */
CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1);
}
CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1);
/* Subtreelength doesn't include length of package length bytes */
PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;
break;
}
/* Does this opcode have an associated "PackageLength" field? */
if (Op->Asl.CompileFlags & NODE_AML_PACKAGE)
{
if (Op->Asl.AmlPkgLenBytes == 1)
{
/* Simplest case -- no bytes to follow, just write the count */
CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);
}
else if (Op->Asl.AmlPkgLenBytes != 0)
{
/*
* Encode the "bytes to follow" in the first byte, top two bits.
* The low-order nybble of the length is in the bottom 4 bits
*/
PkgLenFirstByte = (UINT8)
(((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) |
(PkgLen.LenBytes[0] & 0x0F));
CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);
/*
* Shift the length over by the 4 bits we just stuffed
* in the first byte
*/
PkgLen.Len >>= 4;
/* Now we can write the remaining bytes - either 1, 2, or 3 bytes */
for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++)
{
CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1);
}
}
}
void
LsWriteListingHexBytes (
UINT8 *Buffer,
UINT32 Length,
UINT32 FileId)
{
UINT32 i;
/* Transfer all requested bytes */
for (i = 0; i < Length; i++)
{
/* Print line header when buffer is empty */
if (Gbl_CurrentHexColumn == 0)
{
if (Gbl_HasIncludeFiles)
{
FlPrintFile (FileId, "%*s", 10, " ");
}
switch (FileId)
{
case ASL_FILE_LISTING_OUTPUT:
FlPrintFile (FileId, "%8.8X%s", Gbl_CurrentAmlOffset,
ASL_LISTING_LINE_PREFIX);
break;
case ASL_FILE_ASM_SOURCE_OUTPUT:
FlPrintFile (FileId, " db ");
break;
case ASL_FILE_C_SOURCE_OUTPUT:
FlPrintFile (FileId, " ");
break;
default:
/* No other types supported */
return;
}
}
/* Transfer AML byte and update counts */
Gbl_AmlBuffer[Gbl_CurrentHexColumn] = Buffer[i];
Gbl_CurrentHexColumn++;
Gbl_CurrentAmlOffset++;
/* Flush buffer when it is full */
if (Gbl_CurrentHexColumn >= HEX_LISTING_LINE_SIZE)
{
LsFlushListingBuffer (FileId);
}
}
}
static void
LsWriteNodeToListing (
ACPI_PARSE_OBJECT *Op,
UINT32 FileId)
{
const ACPI_OPCODE_INFO *OpInfo;
UINT32 OpClass;
char *Pathname;
UINT32 Length;
UINT32 i;
OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
OpClass = OpInfo->Class;
/* TBD: clean this up with a single flag that says:
* I start a named output block
*/
if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
{
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_DEFINITIONBLOCK:
case PARSEOP_METHODCALL:
case PARSEOP_INCLUDE:
case PARSEOP_INCLUDE_END:
case PARSEOP_DEFAULT_ARG:
break;
default:
switch (OpClass)
{
case AML_CLASS_NAMED_OBJECT:
switch (Op->Asl.AmlOpcode)
{
case AML_SCOPE_OP:
case AML_ALIAS_OP:
break;
default:
if (Op->Asl.ExternalName)
{
LsFlushListingBuffer (FileId);
FlPrintFile (FileId, " };\n");
}
break;
}
break;
default:
/* Don't care about other objects */
break;
}
break;
}
}
/* These cases do not have a corresponding AML opcode */
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_DEFINITIONBLOCK:
LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId);
/* Use the table Signature and TableId to build a unique name */
if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
{
FlPrintFile (FileId,
"%s_%s_Header \\\n",
Gbl_TableSignature, Gbl_TableId);
}
if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
{
FlPrintFile (FileId,
" unsigned char %s_%s_Header [] =\n {\n",
Gbl_TableSignature, Gbl_TableId);
}
if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT)
{
FlPrintFile (FileId,
"extrn %s_%s_Header : byte\n",
Gbl_TableSignature, Gbl_TableId);
}
if (FileId == ASL_FILE_C_INCLUDE_OUTPUT)
{
FlPrintFile (FileId,
"extern unsigned char %s_%s_Header [];\n",
Gbl_TableSignature, Gbl_TableId);
}
return;
case PARSEOP_METHODCALL:
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
return;
case PARSEOP_INCLUDE:
/* Flush everything up to and including the include source line */
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
/* Create a new listing node and push it */
LsPushNode (Op->Asl.Child->Asl.Value.String);
return;
case PARSEOP_INCLUDE_END:
/* Flush out the rest of the include file */
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
/* Pop off this listing node and go back to the parent file */
(void) LsPopNode ();
return;
case PARSEOP_DEFAULT_ARG:
if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
{
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
FileId);
}
return;
default:
/* All other opcodes have an AML opcode */
break;
}
/*
* Otherwise, we look at the AML opcode because we can
* switch on the opcode type, getting an entire class
* at once
*/
switch (OpClass)
{
case AML_CLASS_ARGUMENT: /* argument type only */
case AML_CLASS_INTERNAL:
break;
case AML_CLASS_NAMED_OBJECT:
switch (Op->Asl.AmlOpcode)
{
case AML_FIELD_OP:
case AML_INDEX_FIELD_OP:
case AML_BANK_FIELD_OP:
/*
* For fields, we want to dump all the AML after the
* entire definition
*/
LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
FileId);
break;
case AML_NAME_OP:
if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
{
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
}
else
{
/*
* For fields, we want to dump all the AML after the
* entire definition
*/
LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
FileId);
}
break;
default:
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
break;
}
switch (Op->Asl.AmlOpcode)
{
case AML_SCOPE_OP:
case AML_ALIAS_OP:
/* These opcodes do not declare a new object, ignore them */
break;
default:
/* All other named object opcodes come here */
switch (FileId)
{
case ASL_FILE_ASM_SOURCE_OUTPUT:
case ASL_FILE_C_SOURCE_OUTPUT:
case ASL_FILE_ASM_INCLUDE_OUTPUT:
case ASL_FILE_C_INCLUDE_OUTPUT:
/*
* For named objects, we will create a valid symbol so that the
* AML code can be referenced from C or ASM
*/
if (Op->Asl.ExternalName)
{
/* Get the full pathname associated with this node */
Pathname = AcpiNsGetExternalPathname (Op->Asl.Node);
Length = strlen (Pathname);
if (Length >= 4)
{
/* Convert all dots in the path to underscores */
for (i = 0; i < Length; i++)
{
if (Pathname[i] == '.')
{
Pathname[i] = '_';
}
}
/* Create the appropriate symbol in the output file */
if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
{
FlPrintFile (FileId,
"%s_%s_%s \\\n",
Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
}
if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
{
FlPrintFile (FileId,
" unsigned char %s_%s_%s [] =\n {\n",
Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
}
if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT)
{
FlPrintFile (FileId,
"extrn %s_%s_%s : byte\n",
Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
}
if (FileId == ASL_FILE_C_INCLUDE_OUTPUT)
{
FlPrintFile (FileId,
"extern unsigned char %s_%s_%s [];\n",
Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
}
}
ACPI_FREE (Pathname);
}
break;
default:
/* Nothing to do for listing file */
break;
}
}
break;
case AML_CLASS_EXECUTE:
case AML_CLASS_CREATE:
default:
if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
(Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC))
{
return;
}
LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
FileId);
break;
case AML_CLASS_UNKNOWN:
break;
}
}
static ACPI_STATUS
NsDoOneNamespaceObject (
ACPI_HANDLE ObjHandle,
UINT32 Level,
void *Context,
void **ReturnValue)
{
ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_PARSE_OBJECT *Op;
Gbl_NumNamespaceObjects++;
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, "%5u [%u] %*s %4.4s - %s",
Gbl_NumNamespaceObjects, Level, (Level * 3), " ",
&Node->Name, AcpiUtGetTypeName (Node->Type));
Op = Node->Op;
ObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Node->Object);
if (!Op)
{
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, "\n");
return (AE_OK);
}
if ((ObjDesc) &&
(ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND))
{
switch (Node->Type)
{
case ACPI_TYPE_INTEGER:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Value 0x%8.8X%8.8X]",
ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
break;
case ACPI_TYPE_STRING:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Value \"%s\"]",
ObjDesc->String.Pointer);
break;
default:
/* Nothing to do for other types */
break;
}
}
else
{
switch (Node->Type)
{
case ACPI_TYPE_INTEGER:
if (Op->Asl.ParseOpcode == PARSEOP_NAME)
{
Op = Op->Asl.Child;
}
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
{
Op = Op->Asl.Next;
}
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Value 0x%8.8X%8.8X]",
ACPI_FORMAT_UINT64 (Op->Asl.Value.Integer));
break;
case ACPI_TYPE_STRING:
if (Op->Asl.ParseOpcode == PARSEOP_NAME)
{
Op = Op->Asl.Child;
}
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
{
Op = Op->Asl.Next;
}
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Value \"%s\"]",
Op->Asl.Value.String);
break;
case ACPI_TYPE_LOCAL_REGION_FIELD:
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
{
Op = Op->Asl.Child;
}
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Offset 0x%04X Length 0x%04X bits]",
Op->Asl.Parent->Asl.ExtraValue, (UINT32) Op->Asl.Value.Integer);
break;
case ACPI_TYPE_BUFFER_FIELD:
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_CREATEBYTEFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [BYTE ( 8 bit)]");
break;
case PARSEOP_CREATEDWORDFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [DWORD (32 bit)]");
break;
case PARSEOP_CREATEQWORDFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [QWORD (64 bit)]");
break;
case PARSEOP_CREATEWORDFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [WORD (16 bit)]");
break;
case PARSEOP_CREATEBITFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [BIT ( 1 bit)]");
break;
case PARSEOP_CREATEFIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, " [Arbitrary Bit Field]");
break;
default:
break;
}
break;
case ACPI_TYPE_PACKAGE:
if (Op->Asl.ParseOpcode == PARSEOP_NAME)
{
Op = Op->Asl.Child;
}
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
{
Op = Op->Asl.Next;
}
Op = Op->Asl.Child;
if ((Op->Asl.ParseOpcode == PARSEOP_BYTECONST) ||
(Op->Asl.ParseOpcode == PARSEOP_RAW_DATA))
{
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Length 0x%.2X elements]",
Op->Asl.Value.Integer);
}
break;
case ACPI_TYPE_BUFFER:
if (Op->Asl.ParseOpcode == PARSEOP_NAME)
{
Op = Op->Asl.Child;
}
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
{
Op = Op->Asl.Next;
}
Op = Op->Asl.Child;
if (Op && (Op->Asl.ParseOpcode == PARSEOP_INTEGER))
{
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Initial Length 0x%.2X bytes]",
Op->Asl.Value.Integer);
}
break;
case ACPI_TYPE_METHOD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Code Length 0x%.4X bytes]",
Op->Asl.AmlSubtreeLength);
break;
case ACPI_TYPE_LOCAL_RESOURCE:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Desc Offset 0x%.4X Bytes]", Node->Value);
break;
case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
" [Field Offset 0x%.4X Bits 0x%.4X Bytes] ",
Node->Value, Node->Value / 8);
if (Node->Flags & ANOBJ_IS_REFERENCED)
{
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
"Referenced");
}
else
{
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
"Name not referenced");
}
break;
default:
/* Nothing to do for other types */
break;
}
}
FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, "\n");
return (AE_OK);
}
void
FlOpenIncludeFile (
ACPI_PARSE_OBJECT *Op)
{
FILE *IncludeFile;
ASL_INCLUDE_DIR *NextDir;
/* Op must be valid */
if (!Op)
{
AslCommonError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_InputByteCount, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, " - Null parse node");
return;
}
/*
* Flush out the "include ()" statement on this line, start
* the actual include file on the next line
*/
AslResetCurrentLineBuffer ();
FlPrintFile (ASL_FILE_SOURCE_OUTPUT, "\n");
Gbl_CurrentLineOffset++;
/* Attempt to open the include file */
/* If the file specifies an absolute path, just open it */
if ((Op->Asl.Value.String[0] == '/') ||
(Op->Asl.Value.String[0] == '\\') ||
(Op->Asl.Value.String[1] == ':'))
{
IncludeFile = FlOpenIncludeWithPrefix ("", Op->Asl.Value.String);
if (!IncludeFile)
{
goto ErrorExit;
}
return;
}
/*
* The include filename is not an absolute path.
*
* First, search for the file within the "local" directory -- meaning
* the same directory that contains the source file.
*
* Construct the file pathname from the global directory name.
*/
IncludeFile = FlOpenIncludeWithPrefix (Gbl_DirectoryPath, Op->Asl.Value.String);
if (IncludeFile)
{
return;
}
/*
* Second, search for the file within the (possibly multiple) directories
* specified by the -I option on the command line.
*/
NextDir = Gbl_IncludeDirList;
while (NextDir)
{
IncludeFile = FlOpenIncludeWithPrefix (NextDir->Dir, Op->Asl.Value.String);
if (IncludeFile)
{
return;
}
NextDir = NextDir->Next;
}
/* We could not open the include file after trying very hard */
ErrorExit:
sprintf (MsgBuffer, "%s, %s", Op->Asl.Value.String, strerror (errno));
AslError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, Op, MsgBuffer);
}
ACPI_STATUS
FlOpenMiscOutputFiles (
char *FilenamePrefix)
{
char *Filename;
/* Create/Open a map file if requested */
if (Gbl_MapfileFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_MAP);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the hex file, text mode (closed at compiler exit) */
FlOpenFile (ASL_FILE_MAP_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_MAP_OUTPUT);
AslCompilerFileHeader (ASL_FILE_MAP_OUTPUT);
}
/* All done for disassembler */
if (Gbl_FileType == ASL_INPUT_TYPE_BINARY_ACPI_TABLE)
{
return (AE_OK);
}
/* Create/Open a hex output file if asked */
if (Gbl_HexOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_HEX_DUMP);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the hex file, text mode */
FlOpenFile (ASL_FILE_HEX_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_HEX_OUTPUT);
AslCompilerFileHeader (ASL_FILE_HEX_OUTPUT);
}
/* Create/Open a debug output file if asked */
if (Gbl_DebugFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_DEBUG);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the debug file as STDERR, text mode */
Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Filename = Filename;
Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle =
freopen (Filename, "w+t", stderr);
if (!Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle)
{
/*
* A problem with freopen is that on error, we no longer
* have stderr and cannot emit normal error messages.
* Emit error to stdout, close files, and exit.
*/
fprintf (stdout,
"\nCould not open debug output file: %s\n\n", Filename);
CmCleanupAndExit ();
exit (1);
}
AslCompilerSignon (ASL_FILE_DEBUG_OUTPUT);
AslCompilerFileHeader (ASL_FILE_DEBUG_OUTPUT);
}
/* Create/Open a cross-reference output file if asked */
if (Gbl_CrossReferenceOutput)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_XREF);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
FlOpenFile (ASL_FILE_XREF_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_XREF_OUTPUT);
AslCompilerFileHeader (ASL_FILE_XREF_OUTPUT);
}
/* Create/Open a listing output file if asked */
if (Gbl_ListingFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_LISTING);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the listing file, text mode */
FlOpenFile (ASL_FILE_LISTING_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_LISTING_OUTPUT);
AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT);
}
/* Create the preprocessor output temp file if preprocessor enabled */
if (Gbl_PreprocessFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_PREPROCESSOR);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_PREPROCESSOR_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
FlOpenFile (ASL_FILE_PREPROCESSOR, Filename, "w+t");
}
/*
* Create the "user" preprocessor output file if -li flag set.
* Note, this file contains no embedded #line directives.
*/
if (Gbl_PreprocessorOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_PREPROC_USER);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_PREPROCESSOR_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
FlOpenFile (ASL_FILE_PREPROCESSOR_USER, Filename, "w+t");
}
/* All done for data table compiler */
if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_DATA)
{
return (AE_OK);
}
/* Create/Open a combined source output file */
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/*
* Open the source output file, binary mode (so that LF does not get
* expanded to CR/LF on some systems, messing up our seek
* calculations.)
*/
FlOpenFile (ASL_FILE_SOURCE_OUTPUT, Filename, "w+b");
/*
// TBD: TEMP
// AslCompilerin = Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle;
*/
/* Create/Open a assembly code source output file if asked */
if (Gbl_AsmOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the assembly code source file, text mode */
FlOpenFile (ASL_FILE_ASM_SOURCE_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_ASM_SOURCE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_ASM_SOURCE_OUTPUT);
}
/* Create/Open a C code source output file if asked */
if (Gbl_C_OutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the C code source file, text mode */
FlOpenFile (ASL_FILE_C_SOURCE_OUTPUT, Filename, "w+t");
FlPrintFile (ASL_FILE_C_SOURCE_OUTPUT, "/*\n");
AslCompilerSignon (ASL_FILE_C_SOURCE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_C_SOURCE_OUTPUT);
}
/* Create/Open a C code source output file for the offset table if asked */
if (Gbl_C_OffsetTableFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_OFFSET);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the C code source file, text mode */
FlOpenFile (ASL_FILE_C_OFFSET_OUTPUT, Filename, "w+t");
FlPrintFile (ASL_FILE_C_OFFSET_OUTPUT, "/*\n");
AslCompilerSignon (ASL_FILE_C_OFFSET_OUTPUT);
AslCompilerFileHeader (ASL_FILE_C_OFFSET_OUTPUT);
}
/* Create/Open a assembly include output file if asked */
if (Gbl_AsmIncludeOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_INCLUDE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the assembly include file, text mode */
FlOpenFile (ASL_FILE_ASM_INCLUDE_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_ASM_INCLUDE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_ASM_INCLUDE_OUTPUT);
}
/* Create/Open a C include output file if asked */
if (Gbl_C_IncludeOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_INCLUDE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the C include file, text mode */
FlOpenFile (ASL_FILE_C_INCLUDE_OUTPUT, Filename, "w+t");
FlPrintFile (ASL_FILE_C_INCLUDE_OUTPUT, "/*\n");
AslCompilerSignon (ASL_FILE_C_INCLUDE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_C_INCLUDE_OUTPUT);
}
/* Create a namespace output file if asked */
if (Gbl_NsOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_NAMESPACE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the namespace file, text mode */
FlOpenFile (ASL_FILE_NAMESPACE_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_NAMESPACE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_NAMESPACE_OUTPUT);
}
/* Create a debug file for the converter */
if (AcpiGbl_DebugAslConversion)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_CONVERT_DEBUG);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the converter debug file, text mode */
FlOpenFile (ASL_FILE_CONV_DEBUG_OUTPUT, Filename, "w+t");
AslCompilerSignon (ASL_FILE_CONV_DEBUG_OUTPUT);
AslCompilerFileHeader (ASL_FILE_CONV_DEBUG_OUTPUT);
AcpiGbl_ConvDebugFile = Gbl_Files[ASL_FILE_CONV_DEBUG_OUTPUT].Handle;
}
return (AE_OK);
}
static void
PrDoDirective (
char *DirectiveToken,
char **Next)
{
char *Token = Gbl_MainTokenBuffer;
char *Token2 = NULL;
char *End;
UINT64 Value;
ACPI_SIZE TokenOffset;
int Directive;
ACPI_STATUS Status;
if (!DirectiveToken)
{
goto SyntaxError;
}
Directive = PrMatchDirective (DirectiveToken);
if (Directive == ASL_DIRECTIVE_NOT_FOUND)
{
PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
THIS_TOKEN_OFFSET (DirectiveToken));
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"#%s: Unknown directive\n",
Gbl_CurrentLineNumber, DirectiveToken);
return;
}
/*
* Emit a line directive into the preprocessor file (.pre) after
* every matched directive. This is passed through to the compiler
* so that error/warning messages are kept in sync with the
* original source file.
*/
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename,
Gbl_DirectiveInfo[Directive].Name);
/*
* If we are currently ignoring this block and we encounter a #else or
* #elif, we must ignore their blocks also if the parent block is also
* being ignored.
*/
if (Gbl_IgnoringThisCodeBlock)
{
switch (Directive)
{
case PR_DIRECTIVE_ELSE:
case PR_DIRECTIVE_ELIF:
if (Gbl_DirectiveStack && Gbl_DirectiveStack->IgnoringThisCodeBlock)
{
PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
return;
}
break;
default:
break;
}
}
/*
* Need to always check for #else, #elif, #endif regardless of
* whether we are ignoring the current code block, since these
* are conditional code block terminators.
*/
switch (Directive)
{
case PR_DIRECTIVE_ELSE:
Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
PrDbgPrint ("Executing", "else block");
return;
case PR_DIRECTIVE_ELIF:
Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
Directive = PR_DIRECTIVE_IF;
if (Gbl_IgnoringThisCodeBlock == TRUE)
{
/* Not executing the ELSE part -- all done here */
PrDbgPrint ("Ignoring", "elif block");
return;
}
/*
* After this, we will execute the IF part further below.
* First, however, pop off the original #if directive.
*/
if (ACPI_FAILURE (PrPopDirective ()))
{
PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
THIS_TOKEN_OFFSET (DirectiveToken));
}
PrDbgPrint ("Executing", "elif block");
break;
case PR_DIRECTIVE_ENDIF:
PrDbgPrint ("Executing", "endif");
/* Pop the owning #if/#ifdef/#ifndef */
if (ACPI_FAILURE (PrPopDirective ()))
{
PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
THIS_TOKEN_OFFSET (DirectiveToken));
}
return;
default:
break;
}
/* Most directives have at least one argument */
if (Gbl_DirectiveInfo[Directive].ArgCount >= 1)
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
}
if (Gbl_DirectiveInfo[Directive].ArgCount >= 2)
{
Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token2)
{
goto SyntaxError;
}
}
/*
* At this point, if we are ignoring the current code block,
* do not process any more directives (i.e., ignore them also.)
* For "if" style directives, open/push a new block anyway. We
* must do this to keep track of #endif directives
*/
if (Gbl_IgnoringThisCodeBlock)
{
switch (Directive)
{
case PR_DIRECTIVE_IF:
case PR_DIRECTIVE_IFDEF:
case PR_DIRECTIVE_IFNDEF:
PrPushDirective (Directive, Token);
PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
break;
default:
break;
}
return;
}
/*
* Execute the directive
*/
PrDbgPrint ("Begin execution", Gbl_DirectiveInfo[Directive].Name);
switch (Directive)
{
case PR_DIRECTIVE_IF:
TokenOffset = Token - Gbl_MainTokenBuffer;
/* Need to expand #define macros in the expression string first */
Status = PrResolveIntegerExpression (
&Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
if (ACPI_FAILURE (Status))
{
return;
}
PrPushDirective (Directive, Token);
if (!Value)
{
Gbl_IgnoringThisCodeBlock = TRUE;
}
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Resolved #if: %8.8X%8.8X %s\n",
Gbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
Gbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
break;
case PR_DIRECTIVE_IFDEF:
PrPushDirective (Directive, Token);
if (!PrMatchDefine (Token))
{
Gbl_IgnoringThisCodeBlock = TRUE;
}
PrDbgPrint ("Evaluated", "ifdef");
break;
case PR_DIRECTIVE_IFNDEF:
PrPushDirective (Directive, Token);
if (PrMatchDefine (Token))
{
Gbl_IgnoringThisCodeBlock = TRUE;
}
PrDbgPrint ("Evaluated", "ifndef");
break;
case PR_DIRECTIVE_DEFINE:
/*
* By definition, if first char after the name is a paren,
* this is a function macro.
*/
TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(')
{
#ifndef MACROS_SUPPORTED
AcpiOsPrintf ("%s ERROR - line %u: #define macros are not supported yet\n",
Gbl_CurrentLineBuffer, Gbl_LogicalLineNumber);
exit(1);
#else
PrAddMacro (Token, Next);
#endif
}
else
{
/* Use the remainder of the line for the #define */
Token2 = *Next;
if (Token2)
{
while ((*Token2 == ' ') || (*Token2 == '\t'))
{
Token2++;
}
End = Token2;
while (*End != '\n')
{
End++;
}
*End = 0;
}
else
{
Token2 = "";
}
#if 0
Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
if (!Token2)
{
Token2 = "";
}
#endif
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"New #define: %s->%s\n",
Gbl_LogicalLineNumber, Token, Token2);
PrAddDefine (Token, Token2, FALSE);
}
break;
case PR_DIRECTIVE_ERROR:
/* Note: No macro expansion */
PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
THIS_TOKEN_OFFSET (Token));
Gbl_SourceLine = 0;
Gbl_NextError = Gbl_ErrorLog;
CmCleanupAndExit ();
exit(1);
case PR_DIRECTIVE_INCLUDE:
Token = PrGetNextToken (NULL, " \"<>", Next);
if (!Token)
{
goto SyntaxError;
}
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Start #include file \"%s\"\n", Gbl_CurrentLineNumber,
Token, Gbl_CurrentLineNumber);
PrDoIncludeFile (Token);
break;
case PR_DIRECTIVE_INCLUDEBUFFER:
Token = PrGetNextToken (NULL, " \"<>", Next);
if (!Token)
{
goto SyntaxError;
}
Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token2)
{
goto SyntaxError;
}
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Start #includebuffer input from file \"%s\", buffer name %s\n",
Gbl_CurrentLineNumber, Token, Token2);
PrDoIncludeBuffer (Token, Token2);
break;
case PR_DIRECTIVE_LINE:
TokenOffset = Token - Gbl_MainTokenBuffer;
Status = PrResolveIntegerExpression (
&Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
if (ACPI_FAILURE (Status))
{
return;
}
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"User #line invocation %s\n", Gbl_CurrentLineNumber,
Token);
Gbl_CurrentLineNumber = (UINT32) Value;
/* Emit #line into the preprocessor file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
break;
case PR_DIRECTIVE_PRAGMA:
if (!strcmp (Token, "disable"))
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
TokenOffset = Token - Gbl_MainTokenBuffer;
AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]);
}
else if (!strcmp (Token, "message"))
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
TokenOffset = Token - Gbl_MainTokenBuffer;
AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]);
}
else
{
PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
THIS_TOKEN_OFFSET (Token));
return;
}
break;
case PR_DIRECTIVE_UNDEF:
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"#undef: %s\n", Gbl_CurrentLineNumber, Token);
PrRemoveDefine (Token);
break;
case PR_DIRECTIVE_WARNING:
PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
THIS_TOKEN_OFFSET (Token));
Gbl_SourceLine = 0;
Gbl_NextError = Gbl_ErrorLog;
break;
default:
/* Should never get here */
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Unrecognized directive: %u\n",
Gbl_CurrentLineNumber, Directive);
break;
}
return;
SyntaxError:
PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
THIS_TOKEN_OFFSET (DirectiveToken));
return;
}
static void
PrPreprocessInputFile (
void)
{
UINT32 Offset;
char *Token;
char *ReplaceString;
PR_DEFINE_INFO *DefineInfo;
ACPI_SIZE TokenOffset;
BOOLEAN IgnoringThisCodeBlock = FALSE;
char *Next;
int OffsetAdjust;
/* Scan line-by-line. Comments and blank lines are skipped by this function */
while ((Offset = DtGetNextLine (Gbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
{
/* Need a copy of the input line for strok() */
strcpy (Gbl_MainTokenBuffer, Gbl_CurrentLineBuffer);
Token = PrGetNextToken (Gbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
OffsetAdjust = 0;
/* All preprocessor directives must begin with '#' */
if (Token && (*Token == '#'))
{
if (strlen (Token) == 1)
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
}
else
{
Token++; /* Skip leading # */
}
/* Execute the directive, do not write line to output file */
PrDoDirective (Token, &Next, &IgnoringThisCodeBlock);
continue;
}
/*
* If we are currently within the part of an IF/ELSE block that is
* FALSE, ignore the line and do not write it to the output file.
* This continues until an #else or #endif is encountered.
*/
if (IgnoringThisCodeBlock == TRUE)
{
continue;
}
/* Match and replace all #defined names within this source line */
while (Token)
{
DefineInfo = PrMatchDefine (Token);
if (DefineInfo)
{
if (DefineInfo->Body)
{
/* This is a macro */
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Matched Macro: %s->%s\n",
Gbl_CurrentLineNumber, DefineInfo->Identifier,
DefineInfo->Replacement);
PrDoMacroInvocation (Gbl_MainTokenBuffer, Token,
DefineInfo, &Next);
}
else
{
ReplaceString = DefineInfo->Replacement;
/* Replace the name in the original line buffer */
TokenOffset = Token - Gbl_MainTokenBuffer + OffsetAdjust;
PrReplaceData (
&Gbl_CurrentLineBuffer[TokenOffset], strlen (Token),
ReplaceString, strlen (ReplaceString));
/* Adjust for length difference between old and new name length */
OffsetAdjust += strlen (ReplaceString) - strlen (Token);
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Matched #define: %s->%s\n",
Gbl_CurrentLineNumber, Token,
*ReplaceString ? ReplaceString : "(NULL STRING)");
}
}
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
}
#if 0
/* Line prefix */
FlPrintFile (ASL_FILE_PREPROCESSOR, "/* %14s %.5u i:%.5u */ ",
Gbl_Files[ASL_FILE_INPUT].Filename,
Gbl_CurrentLineNumber, Gbl_PreprocessorLineNumber);
#endif
/*
* Emit a #line directive if necessary, to keep the line numbers in
* the (.i) file synchronized with the original source code file, so
* that the correct line number appears in any error messages
* generated by the actual compiler.
*/
if (Gbl_CurrentLineNumber > (Gbl_PreviousLineNumber + 1))
{
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u\n",
Gbl_CurrentLineNumber);
}
Gbl_PreviousLineNumber = Gbl_CurrentLineNumber;
Gbl_PreprocessorLineNumber++;
/*
* Now we can write the possibly modified source line to the
* preprocessor (.i) file
*/
FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer,
strlen (Gbl_CurrentLineBuffer));
}
}
static void
PrDoDirective (
char *DirectiveToken,
char **Next,
BOOLEAN *IgnoringThisCodeBlock)
{
char *Token = Gbl_MainTokenBuffer;
char *Token2;
char *End;
UINT64 Value;
ACPI_SIZE TokenOffset;
int Directive;
ACPI_STATUS Status;
if (!DirectiveToken)
{
goto SyntaxError;
}
Directive = PrMatchDirective (DirectiveToken);
if (Directive == ASL_DIRECTIVE_NOT_FOUND)
{
PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
THIS_TOKEN_OFFSET (DirectiveToken));
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"#%s: Unknown directive\n",
Gbl_CurrentLineNumber, DirectiveToken);
return;
}
/* TBD: Need a faster way to do this: */
if ((Directive == PR_DIRECTIVE_ELIF) ||
(Directive == PR_DIRECTIVE_ELSE) ||
(Directive == PR_DIRECTIVE_ENDIF))
{
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID "Begin #%s\n",
Gbl_CurrentLineNumber, Gbl_DirectiveInfo[Directive].Name);
}
/*
* Need to always check for #else, #elif, #endif regardless of
* whether we are ignoring the current code block, since these
* are conditional code block terminators.
*/
switch (Directive)
{
case PR_DIRECTIVE_ELIF:
*IgnoringThisCodeBlock = !(*IgnoringThisCodeBlock);
if (*IgnoringThisCodeBlock == TRUE)
{
/* Not executing the ELSE part -- all done here */
return;
}
/* Will execute the ELSE..IF part */
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"#elif - Executing else block\n",
Gbl_CurrentLineNumber);
Directive = PR_DIRECTIVE_IF;
break;
case PR_DIRECTIVE_ELSE:
*IgnoringThisCodeBlock = !(*IgnoringThisCodeBlock);
return;
case PR_DIRECTIVE_ENDIF:
*IgnoringThisCodeBlock = FALSE;
Gbl_IfDepth--;
if (Gbl_IfDepth < 0)
{
PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
THIS_TOKEN_OFFSET (DirectiveToken));
Gbl_IfDepth = 0;
}
return;
default:
break;
}
/*
* At this point, if we are ignoring the current code block,
* do not process any more directives (i.e., ignore them also.)
*/
if (*IgnoringThisCodeBlock == TRUE)
{
return;
}
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID "Begin #%s\n",
Gbl_CurrentLineNumber, Gbl_DirectiveInfo[Directive].Name);
/* Most directives have at least one argument */
if (Gbl_DirectiveInfo[Directive].ArgCount == 1)
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
}
switch (Directive)
{
case PR_DIRECTIVE_DEFINE:
/*
* By definition, if first char after the name is a paren,
* this is a function macro.
*/
TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(')
{
#ifndef MACROS_SUPPORTED
AcpiOsPrintf ("%s ERROR - line %u: #define macros are not supported yet\n",
Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber);
exit(1);
#else
PrAddMacro (Token, Next);
#endif
}
else
{
/* Use the remainder of the line for the #define */
Token2 = *Next;
if (Token2)
{
while ((*Token2 == ' ') || (*Token2 == '\t'))
{
Token2++;
}
End = Token2;
while (*End != '\n')
{
End++;
}
*End = 0;
}
else
{
Token2 = "";
}
#if 0
Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
if (!Token2)
{
Token2 = "";
}
#endif
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"New #define: %s->%s\n",
Gbl_CurrentLineNumber, Token, Token2);
PrAddDefine (Token, Token2, FALSE);
}
break;
case PR_DIRECTIVE_ERROR:
/* TBD compiler should abort */
/* Note: No macro expansion */
PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
THIS_TOKEN_OFFSET (Token));
break;
case PR_DIRECTIVE_IF:
TokenOffset = Token - Gbl_MainTokenBuffer;
/* Need to expand #define macros in the expression string first */
Status = PrResolveIntegerExpression (
&Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
if (ACPI_FAILURE (Status))
{
return;
}
if (!Value)
{
*IgnoringThisCodeBlock = TRUE;
}
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Resolved #if: %8.8X%8.8X %s\n",
Gbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
*IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
Gbl_IfDepth++;
break;
case PR_DIRECTIVE_IFDEF:
if (!PrMatchDefine (Token))
{
*IgnoringThisCodeBlock = TRUE;
}
Gbl_IfDepth++;
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Start #ifdef %s\n", Gbl_CurrentLineNumber,
*IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
break;
case PR_DIRECTIVE_IFNDEF:
if (PrMatchDefine (Token))
{
*IgnoringThisCodeBlock = TRUE;
}
Gbl_IfDepth++;
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Start #ifndef %2.2X\n", Gbl_CurrentLineNumber,
*IgnoringThisCodeBlock, Gbl_CurrentLineNumber);
break;
case PR_DIRECTIVE_INCLUDE:
Token = PrGetNextToken (NULL, " \"<>", Next);
if (!Token)
{
goto SyntaxError;
}
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Start #include file \"%s\"\n", Gbl_CurrentLineNumber,
Token, Gbl_CurrentLineNumber);
PrOpenIncludeFile (Token);
break;
case PR_DIRECTIVE_LINE:
TokenOffset = Token - Gbl_MainTokenBuffer;
Status = PrResolveIntegerExpression (
&Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
if (ACPI_FAILURE (Status))
{
return;
}
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"User #line invocation %s\n", Gbl_CurrentLineNumber,
Token);
/* Update local line numbers */
Gbl_CurrentLineNumber = (UINT32) Value;
Gbl_PreviousLineNumber = 0;
/* Emit #line into the preprocessor file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
break;
case PR_DIRECTIVE_PRAGMA:
if (!strcmp (Token, "disable"))
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
TokenOffset = Token - Gbl_MainTokenBuffer;
AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]);
}
else if (!strcmp (Token, "message"))
{
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
if (!Token)
{
goto SyntaxError;
}
TokenOffset = Token - Gbl_MainTokenBuffer;
AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]);
}
else
{
PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
THIS_TOKEN_OFFSET (Token));
return;
}
break;
case PR_DIRECTIVE_UNDEF:
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"#undef: %s\n", Gbl_CurrentLineNumber, Token);
PrRemoveDefine (Token);
break;
case PR_DIRECTIVE_WARNING:
PrError (ASL_WARNING, ASL_MSG_ERROR_DIRECTIVE,
THIS_TOKEN_OFFSET (Token));
break;
default:
/* Should never get here */
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"Unrecognized directive: %u\n",
Gbl_CurrentLineNumber, Directive);
break;
}
return;
SyntaxError:
PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
THIS_TOKEN_OFFSET (DirectiveToken));
return;
}
ACPI_STATUS
LsAmlOffsetWalk (
ACPI_PARSE_OBJECT *Op,
UINT32 Level,
void *Context)
{
UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context);
ACPI_NAMESPACE_NODE *Node;
UINT32 Length;
UINT32 OffsetOfOpcode;
ACPI_PARSE_OBJECT *AddressOp;
/* Ignore actual data blocks for resource descriptors */
if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA)
{
return (AE_OK); /* Do NOT update the global AML offset */
}
/* We are only interested in named objects (have a namespace node) */
Node = Op->Asl.Node;
if (!Node)
{
Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength;
return (AE_OK);
}
/* Named resource descriptor (has a descriptor tag) */
if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE) &&
(Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC))
{
LsEmitOffsetTableEntry (FileId, Node, Gbl_CurrentAmlOffset,
Op->Asl.ParseOpName, 0, Op->Asl.Extra);
}
/* Named object -- Name (NameString, DataRefObject) */
else if (Op->Asl.AmlOpcode == AML_NAME_OP)
{
if (!Op->Asl.Child)
{
FlPrintFile (FileId, "%s NO CHILD!\n", MsgBuffer);
return (AE_OK);
}
Length = Op->Asl.FinalAmlLength;
/* Get to the NameSeg/NamePath Op (and length of the name) */
Op = Op->Asl.Child;
OffsetOfOpcode = Length + Op->Asl.FinalAmlLength;
/* Get actual value associated with the name */
Op = Op->Asl.Next;
switch (Op->Asl.AmlOpcode)
{
/*
* We are only interested in integer constants that can be changed
* at boot time. Note, the One/Ones/Zero opcodes are considered
* non-changeable, so we ignore them here.
*/
case AML_BYTE_OP:
case AML_WORD_OP:
case AML_DWORD_OP:
case AML_QWORD_OP:
/* The +1/-1 is to handle the integer size prefix (opcode) */
LsEmitOffsetTableEntry (FileId, Node,
(Gbl_CurrentAmlOffset + OffsetOfOpcode + 1),
Op->Asl.ParseOpName, Op->Asl.Value.Integer,
(UINT8) Op->Asl.AmlOpcode);
break;
default:
break;
}
Gbl_CurrentAmlOffset += Length;
return (AE_OK);
}
/* OperationRegion (NameString, RegionSpace, RegionOffset, RegionLength) */
else if (Op->Asl.AmlOpcode == AML_REGION_OP)
{
Length = Op->Asl.FinalAmlLength;
/* Get the name/namepath node */
AddressOp = Op->Asl.Child;
OffsetOfOpcode = Length + AddressOp->Asl.FinalAmlLength + 1;
/* Get the SpaceId node, then the Offset (address) node */
AddressOp = AddressOp->Asl.Next;
AddressOp = AddressOp->Asl.Next;
switch (AddressOp->Asl.AmlOpcode)
{
/*
* We are only interested in integer constants that can be changed
* at boot time. Note, the One/Ones/Zero opcodes are considered
* non-changeable, so we ignore them here.
*/
case AML_BYTE_OP:
case AML_WORD_OP:
case AML_DWORD_OP:
case AML_QWORD_OP:
/* The +1/-1 is to handle the integer size prefix (opcode) */
LsEmitOffsetTableEntry (FileId, Node,
(Gbl_CurrentAmlOffset + OffsetOfOpcode + 1),
Op->Asl.ParseOpName, AddressOp->Asl.Value.Integer,
(UINT8) AddressOp->Asl.AmlOpcode);
Gbl_CurrentAmlOffset += Length;
return (AE_OK);
default:
break;
}
}
else if (Op->Asl.AmlOpcode == AML_METHOD_OP)
{
Length = Op->Asl.FinalAmlLength;
LsEmitOffsetTableEntry (FileId, Node,
(Gbl_CurrentAmlOffset + Length),
Op->Asl.ParseOpName, 0, (UINT8) Op->Asl.AmlOpcode);
}
Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength;
return (AE_OK);
}
void
LsFlushListingBuffer (
UINT32 FileId)
{
UINT32 i;
if (Gbl_CurrentHexColumn == 0)
{
return;
}
/* Write the hex bytes */
switch (FileId)
{
case ASL_FILE_LISTING_OUTPUT:
for (i = 0; i < Gbl_CurrentHexColumn; i++)
{
FlPrintFile (FileId, "%2.2X ", Gbl_AmlBuffer[i]);
}
for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 3); i++)
{
FlWriteFile (FileId, ".", 1);
}
/* Write the ASCII character associated with each of the bytes */
LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
break;
case ASL_FILE_ASM_SOURCE_OUTPUT:
for (i = 0; i < Gbl_CurrentHexColumn; i++)
{
if (i > 0)
{
FlPrintFile (FileId, ",");
}
FlPrintFile (FileId, "0%2.2Xh", Gbl_AmlBuffer[i]);
}
for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++)
{
FlWriteFile (FileId, " ", 1);
}
FlPrintFile (FileId, " ;%8.8X",
Gbl_CurrentAmlOffset - HEX_LISTING_LINE_SIZE);
/* Write the ASCII character associated with each of the bytes */
LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
break;
case ASL_FILE_C_SOURCE_OUTPUT:
for (i = 0; i < Gbl_CurrentHexColumn; i++)
{
FlPrintFile (FileId, "0x%2.2X,", Gbl_AmlBuffer[i]);
}
/* Pad hex output with spaces if line is shorter than max line size */
for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++)
{
FlWriteFile (FileId, " ", 1);
}
/* AML offset for the start of the line */
FlPrintFile (FileId, " /* %8.8X",
Gbl_CurrentAmlOffset - Gbl_CurrentHexColumn);
/* Write the ASCII character associated with each of the bytes */
LsDumpAsciiInComment (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
FlPrintFile (FileId, " */");
break;
default:
/* No other types supported */
return;
}
FlPrintFile (FileId, "\n");
Gbl_CurrentHexColumn = 0;
Gbl_HexBytesWereWritten = TRUE;
}
UINT32
LsWriteOneSourceLine (
UINT32 FileId)
{
UINT8 FileByte;
UINT32 Column = 0;
UINT32 Index = 16;
BOOLEAN StartOfLine = FALSE;
BOOLEAN ProcessLongLine = FALSE;
Gbl_SourceLine++;
Gbl_ListingNode->LineNumber++;
/* Ignore lines that are completely blank (but count the line above) */
if (FlReadFile (ASL_FILE_SOURCE_OUTPUT, &FileByte, 1) != AE_OK)
{
return (0);
}
if (FileByte == '\n')
{
return (1);
}
/*
* This is a non-empty line, we will print the entire line with
* the line number and possibly other prefixes and transforms.
*/
/* Line prefixes for special files, C and ASM output */
if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
{
FlPrintFile (FileId, " *");
}
if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
{
FlPrintFile (FileId, "; ");
}
if (Gbl_HasIncludeFiles)
{
/*
* This file contains "include" statements, print the current
* filename and line number within the current file
*/
FlPrintFile (FileId, "%12s %5d%s",
Gbl_ListingNode->Filename, Gbl_ListingNode->LineNumber,
ASL_LISTING_LINE_PREFIX);
}
else
{
/* No include files, just print the line number */
FlPrintFile (FileId, "%8u%s", Gbl_SourceLine,
ASL_LISTING_LINE_PREFIX);
}
/* Read the rest of this line (up to a newline or EOF) */
do
{
if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
{
if (FileByte == '/')
{
FileByte = '*';
}
}
/* Split long input lines for readability in the listing */
Column++;
if (Column >= 128)
{
if (!ProcessLongLine)
{
if ((FileByte != '}') &&
(FileByte != '{'))
{
goto WriteByte;
}
ProcessLongLine = TRUE;
}
if (FileByte == '{')
{
FlPrintFile (FileId, "\n%*s{\n", Index, " ");
StartOfLine = TRUE;
Index += 4;
continue;
}
else if (FileByte == '}')
{
if (!StartOfLine)
{
FlPrintFile (FileId, "\n");
}
StartOfLine = TRUE;
Index -= 4;
FlPrintFile (FileId, "%*s}\n", Index, " ");
continue;
}
/* Ignore spaces/tabs at the start of line */
else if ((FileByte == ' ') && StartOfLine)
{
continue;
}
else if (StartOfLine)
{
StartOfLine = FALSE;
FlPrintFile (FileId, "%*s", Index, " ");
}
WriteByte:
FlWriteFile (FileId, &FileByte, 1);
if (FileByte == '\n')
{
/*
* This line has been completed.
* Check if an error occurred on this source line during the compile.
* If so, we print the error message after the source line.
*/
LsCheckException (Gbl_SourceLine, FileId);
return (1);
}
}
else
{
FlWriteFile (FileId, &FileByte, 1);
if (FileByte == '\n')
{
/*
* This line has been completed.
* Check if an error occurred on this source line during the compile.
* If so, we print the error message after the source line.
*/
LsCheckException (Gbl_SourceLine, FileId);
return (1);
}
}
} while (FlReadFile (ASL_FILE_SOURCE_OUTPUT, &FileByte, 1) == AE_OK);
/* EOF on the input file was reached */
return (0);
}
void
AslCompilerSignon (
UINT32 FileId)
{
char *Prefix = "";
char *UtilityName;
/* Set line prefix depending on the destination file type */
switch (FileId)
{
case ASL_FILE_ASM_SOURCE_OUTPUT:
case ASL_FILE_ASM_INCLUDE_OUTPUT:
Prefix = "; ";
break;
case ASL_FILE_HEX_OUTPUT:
if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
{
Prefix = "; ";
}
else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
(Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
{
FlPrintFile (ASL_FILE_HEX_OUTPUT, "/*\n");
Prefix = " * ";
}
break;
case ASL_FILE_C_SOURCE_OUTPUT:
case ASL_FILE_C_OFFSET_OUTPUT:
case ASL_FILE_C_INCLUDE_OUTPUT:
Prefix = " * ";
break;
default:
/* No other output types supported */
break;
}
/* Running compiler or disassembler? */
if (Gbl_DisasmFlag)
{
UtilityName = AML_DISASSEMBLER_NAME;
}
else
{
UtilityName = ASL_COMPILER_NAME;
}
/* Compiler signon with copyright */
FlPrintFile (FileId, "%s\n", Prefix);
FlPrintFile (FileId, ACPI_COMMON_HEADER (UtilityName, Prefix));
}
static void
MpEmitGpioInfo (
void)
{
ACPI_GPIO_INFO *Info;
char *Type;
char *PrevDeviceName = NULL;
const char *Direction;
const char *Polarity;
char *ParentPathname;
const char *Description;
char *HidString;
const AH_DEVICE_ID *HidInfo;
/* Walk the GPIO descriptor list */
Info = Gbl_GpioList;
while (Info)
{
HidString = MpGetHidViaNamestring (Info->DeviceName);
/* Print header info for the controller itself */
if (!PrevDeviceName ||
ACPI_STRCMP (PrevDeviceName, Info->DeviceName))
{
FlPrintFile (ASL_FILE_MAP_OUTPUT,
"\n\nGPIO Controller: %-8s %-28s",
HidString, Info->DeviceName);
HidInfo = AcpiAhMatchHardwareId (HidString);
if (HidInfo)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s",
HidInfo->Description);
}
FlPrintFile (ASL_FILE_MAP_OUTPUT,
"\n\nPin Type Direction Polarity"
" Dest _HID Destination\n");
}
PrevDeviceName = Info->DeviceName;
/* Setup various strings based upon the type (GpioInt or GpioIo) */
switch (Info->Type)
{
case AML_RESOURCE_GPIO_TYPE_INT:
Type = "GpioInt";
Direction = "-Interrupt-";
Polarity = PolarityDecode[Info->Polarity];
break;
case AML_RESOURCE_GPIO_TYPE_IO:
Type = "GpioIo ";
Direction = DirectionDecode[Info->Direction];
Polarity = " ";
break;
default:
continue;
}
/* Emit the GPIO info */
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%4.4X %s %s %s ",
Info->PinNumber, Type, Direction, Polarity);
ParentPathname = NULL;
HidString = MpGetConnectionInfo (Info->Op, Info->PinIndex,
&Info->TargetNode, &ParentPathname);
if (HidString)
{
/*
* This is a Connection() field
* Attempt to find all references to the field.
*/
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%8s %-28s",
HidString, ParentPathname);
MpXrefDevices (Info);
}
else
{
/*
* For Devices, attempt to get the _HID description string.
* Failing that (many _HIDs are not recognized), attempt to
* get the _DDN description string.
*/
HidString = MpGetParentDeviceHid (Info->Op, &Info->TargetNode,
&ParentPathname);
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%8s %-28s",
HidString, ParentPathname);
/* Get the _HID description or _DDN string */
HidInfo = AcpiAhMatchHardwareId (HidString);
if (HidInfo)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s",
HidInfo->Description);
}
else if ((Description = MpGetDdnValue (ParentPathname)))
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s (_DDN)",
Description);
}
}
FlPrintFile (ASL_FILE_MAP_OUTPUT, "\n");
ACPI_FREE (ParentPathname);
Info = Info->Next;
}
}
void
AslCompilerFileHeader (
UINT32 FileId)
{
struct tm *NewTime;
time_t Aclock;
char *Prefix = "";
/* Set line prefix depending on the destination file type */
switch (FileId)
{
case ASL_FILE_ASM_SOURCE_OUTPUT:
case ASL_FILE_ASM_INCLUDE_OUTPUT:
Prefix = "; ";
break;
case ASL_FILE_HEX_OUTPUT:
if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
{
Prefix = "; ";
}
else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
(Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
{
Prefix = " * ";
}
break;
case ASL_FILE_C_SOURCE_OUTPUT:
case ASL_FILE_C_OFFSET_OUTPUT:
case ASL_FILE_C_INCLUDE_OUTPUT:
Prefix = " * ";
break;
default:
/* No other output types supported */
break;
}
/* Compilation header with timestamp */
(void) time (&Aclock);
NewTime = localtime (&Aclock);
FlPrintFile (FileId,
"%sCompilation of \"%s\" - %s%s\n",
Prefix, Gbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
Prefix);
switch (FileId)
{
case ASL_FILE_C_SOURCE_OUTPUT:
case ASL_FILE_C_OFFSET_OUTPUT:
case ASL_FILE_C_INCLUDE_OUTPUT:
FlPrintFile (FileId, " */\n");
break;
default:
/* Nothing to do for other output types */
break;
}
}
static void
MpEmitSerialInfo (
void)
{
ACPI_SERIAL_INFO *Info;
char *Type;
char *ParentPathname;
char *PrevDeviceName = NULL;
char *HidString;
const AH_DEVICE_ID *HidInfo;
const char *Description;
AML_RESOURCE *Resource;
/* Walk the constructed serial descriptor list */
Info = Gbl_SerialList;
while (Info)
{
Resource = Info->Resource;
switch (Resource->CommonSerialBus.Type)
{
case AML_RESOURCE_I2C_SERIALBUSTYPE:
Type = "I2C ";
break;
case AML_RESOURCE_SPI_SERIALBUSTYPE:
Type = "SPI ";
break;
case AML_RESOURCE_UART_SERIALBUSTYPE:
Type = "UART";
break;
default:
Type = "UNKN";
break;
}
HidString = MpGetHidViaNamestring (Info->DeviceName);
/* Print header info for the controller itself */
if (!PrevDeviceName ||
ACPI_STRCMP (PrevDeviceName, Info->DeviceName))
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, "\n\n%s Controller: ",
Type);
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%-8s %-28s",
HidString, Info->DeviceName);
HidInfo = AcpiAhMatchHardwareId (HidString);
if (HidInfo)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s",
HidInfo->Description);
}
FlPrintFile (ASL_FILE_MAP_OUTPUT, "\n\n");
FlPrintFile (ASL_FILE_MAP_OUTPUT,
"Type Address Speed Dest _HID Destination\n");
}
PrevDeviceName = Info->DeviceName;
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%s %4.4X %8.8X ",
Type, Info->Address, Info->Speed);
ParentPathname = NULL;
HidString = MpGetConnectionInfo (Info->Op, 0, &Info->TargetNode,
&ParentPathname);
if (HidString)
{
/*
* This is a Connection() field
* Attempt to find all references to the field.
*/
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%8s %-28s",
HidString, ParentPathname);
}
else
{
/* Normal resource template */
HidString = MpGetParentDeviceHid (Info->Op, &Info->TargetNode,
&ParentPathname);
FlPrintFile (ASL_FILE_MAP_OUTPUT, "%8s %-28s",
HidString, ParentPathname);
/* Get the _HID description or _DDN string */
HidInfo = AcpiAhMatchHardwareId (HidString);
if (HidInfo)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s",
HidInfo->Description);
}
else if ((Description = MpGetDdnValue (ParentPathname)))
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // %s (_DDN)",
Description);
}
}
FlPrintFile (ASL_FILE_MAP_OUTPUT, "\n");
ACPI_FREE (ParentPathname);
Info = Info->Next;
}
}
static void
DtDumpBuffer (
UINT32 FileId,
UINT8 *Buffer,
UINT32 Offset,
UINT32 Length)
{
UINT32 i;
UINT32 j;
UINT8 BufChar;
FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
Offset, Offset, Length);
i = 0;
while (i < Length)
{
if (i >= 16)
{
FlPrintFile (FileId, "%24s", "");
}
/* Print 16 hex chars */
for (j = 0; j < 16;)
{
if (i + j >= Length)
{
/* Dump fill spaces */
FlPrintFile (FileId, " ");
j++;
continue;
}
FlPrintFile (FileId, "%02X ", Buffer[i+j]);
j++;
}
FlPrintFile (FileId, " ");
for (j = 0; j < 16; j++)
{
if (i + j >= Length)
{
FlPrintFile (FileId, "\n\n");
return;
}
BufChar = Buffer[(ACPI_SIZE) i + j];
if (ACPI_IS_PRINT (BufChar))
{
FlPrintFile (FileId, "%c", BufChar);
}
else
{
FlPrintFile (FileId, ".");
}
}
/* Done with that line. */
FlPrintFile (FileId, "\n");
i += 16;
}
FlPrintFile (FileId, "\n\n");
}
static ACPI_STATUS
MpNamespaceXrefBegin (
ACPI_PARSE_OBJECT *Op,
UINT32 Level,
void *Context)
{
ACPI_GPIO_INFO *Info = ACPI_CAST_PTR (ACPI_GPIO_INFO, Context);
const ACPI_OPCODE_INFO *OpInfo;
char *DevicePathname;
ACPI_PARSE_OBJECT *ParentOp;
char *HidString;
ACPI_FUNCTION_TRACE_PTR (MpNamespaceXrefBegin, Op);
/*
* If this node is the actual declaration of a name
* [such as the XXXX name in "Method (XXXX)"],
* we are not interested in it here. We only care about names that
* are references to other objects within the namespace and the
* parent objects of name declarations
*/
if (Op->Asl.CompileFlags & NODE_IS_NAME_DECLARATION)
{
return (AE_OK);
}
/* We are only interested in opcodes that have an associated name */
OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
if ((OpInfo->Flags & AML_NAMED) ||
(OpInfo->Flags & AML_CREATE))
{
return (AE_OK);
}
if ((Op->Asl.ParseOpcode != PARSEOP_NAMESTRING) &&
(Op->Asl.ParseOpcode != PARSEOP_NAMESEG) &&
(Op->Asl.ParseOpcode != PARSEOP_METHODCALL))
{
return (AE_OK);
}
if (!Op->Asl.Node)
{
return (AE_OK);
}
ParentOp = Op->Asl.Parent;
if (ParentOp->Asl.ParseOpcode == PARSEOP_FIELD)
{
return (AE_OK);
}
if (Op->Asl.Node == Info->TargetNode)
{
while (ParentOp && (!ParentOp->Asl.Node))
{
ParentOp = ParentOp->Asl.Parent;
}
if (ParentOp)
{
DevicePathname = AcpiNsGetExternalPathname (
ParentOp->Asl.Node);
if (!Info->References)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT, " // References:");
}
HidString = MpGetHidViaNamestring (DevicePathname);
FlPrintFile (ASL_FILE_MAP_OUTPUT, " %s [%s]",
DevicePathname, HidString);
Info->References++;
ACPI_FREE (DevicePathname);
}
}
return (AE_OK);
}
ACPI_STATUS
FlOpenMiscOutputFiles (
char *FilenamePrefix)
{
char *Filename;
/* Create/Open a combined source output file */
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/*
* Open the source output file, binary mode (so that LF does not get
* expanded to CR/LF on some systems, messing up our seek
* calculations.)
*/
FlOpenFile (ASL_FILE_SOURCE_OUTPUT, Filename, "w+b");
/* Create/Open a listing output file if asked */
if (Gbl_ListingFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_LISTING);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the listing file, text mode */
FlOpenFile (ASL_FILE_LISTING_OUTPUT, Filename, "w+");
AslCompilerSignon (ASL_FILE_LISTING_OUTPUT);
AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT);
}
/* Create/Open a assembly code source output file if asked */
if (Gbl_AsmOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the assembly code source file, text mode */
FlOpenFile (ASL_FILE_ASM_SOURCE_OUTPUT, Filename, "w+");
AslCompilerSignon (ASL_FILE_ASM_SOURCE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_ASM_SOURCE_OUTPUT);
}
/* Create/Open a C code source output file if asked */
if (Gbl_C_OutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_SOURCE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the C code source file, text mode */
FlOpenFile (ASL_FILE_C_SOURCE_OUTPUT, Filename, "w+");
FlPrintFile (ASL_FILE_C_SOURCE_OUTPUT, "/*\n");
AslCompilerSignon (ASL_FILE_C_SOURCE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_C_SOURCE_OUTPUT);
}
/* Create/Open a assembly include output file if asked */
if (Gbl_AsmIncludeOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_INCLUDE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the assembly include file, text mode */
FlOpenFile (ASL_FILE_ASM_INCLUDE_OUTPUT, Filename, "w+");
AslCompilerSignon (ASL_FILE_ASM_INCLUDE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_ASM_INCLUDE_OUTPUT);
}
/* Create/Open a C include output file if asked */
if (Gbl_C_IncludeOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_INCLUDE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the C include file, text mode */
FlOpenFile (ASL_FILE_C_INCLUDE_OUTPUT, Filename, "w+");
FlPrintFile (ASL_FILE_C_INCLUDE_OUTPUT, "/*\n");
AslCompilerSignon (ASL_FILE_C_INCLUDE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_C_INCLUDE_OUTPUT);
}
/* Create/Open a hex output file if asked */
if (Gbl_HexOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_HEX_DUMP);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the hex file, text mode */
FlOpenFile (ASL_FILE_HEX_OUTPUT, Filename, "w+");
AslCompilerSignon (ASL_FILE_HEX_OUTPUT);
AslCompilerFileHeader (ASL_FILE_HEX_OUTPUT);
}
/* Create a namespace output file if asked */
if (Gbl_NsOutputFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_NAMESPACE);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the namespace file, text mode */
FlOpenFile (ASL_FILE_NAMESPACE_OUTPUT, Filename, "w+");
AslCompilerSignon (ASL_FILE_NAMESPACE_OUTPUT);
AslCompilerFileHeader (ASL_FILE_NAMESPACE_OUTPUT);
}
/* Create/Open a debug output file if asked */
if (Gbl_DebugFlag)
{
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_DEBUG);
if (!Filename)
{
AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
/* Open the debug file as STDERR, text mode */
/* TBD: hide this behind a FlReopenFile function */
Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Filename = Filename;
Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle =
freopen (Filename, "w+t", stderr);
AslCompilerSignon (ASL_FILE_DEBUG_OUTPUT);
AslCompilerFileHeader (ASL_FILE_DEBUG_OUTPUT);
}
return (AE_OK);
}
void
MpEmitMappingInfo (
void)
{
char *NewFilename;
/* Mapfile option enabled? */
if (!Gbl_MapfileFlag)
{
return;
}
/* Create/Open a map file */
NewFilename = FlGenerateFilename (Gbl_OutputFilenamePrefix,
FILE_SUFFIX_MAP);
if (!NewFilename)
{
AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
0, 0, 0, 0, NULL, NULL);
}
/* Open the hex file, text mode (closed at compiler exit) */
FlOpenFile (ASL_FILE_MAP_OUTPUT, NewFilename, "w+t");
AslCompilerSignon (ASL_FILE_MAP_OUTPUT);
AslCompilerFileHeader (ASL_FILE_MAP_OUTPUT);
if (!Gbl_GpioList)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT,
"\nNo GPIO devices found\n");
}
if (!Gbl_SerialList)
{
FlPrintFile (ASL_FILE_MAP_OUTPUT,
"\nNo Serial devices found (I2C/SPI/UART)\n");
}
if (!Gbl_GpioList && !Gbl_SerialList)
{
return;
}
/* Headers */
FlPrintFile (ASL_FILE_MAP_OUTPUT, "\nResource Descriptor Connectivity Map\n");
FlPrintFile (ASL_FILE_MAP_OUTPUT, "------------------------------------\n");
/* Emit GPIO and Serial descriptors, then entire ACPI device tree */
MpEmitGpioInfo ();
MpEmitSerialInfo ();
MpEmitDeviceTree ();
/* Clear the lists - no need to free memory here */
Gbl_SerialList = NULL;
Gbl_GpioList = NULL;
}
