UINT64 DtResolveLabel ( char *LabelString) { DT_FIELD *LabelField; DbgPrint (ASL_DEBUG_OUTPUT, "Resolve Label: %s\n", LabelString); /* Resolve a label reference to an integer (table offset) */ if (*LabelString != '$') { return (0); } LabelField = DtLookupLabel (LabelString); if (!LabelField) { DtError (ASL_ERROR, ASL_MSG_UNKNOWN_LABEL, Gbl_CurrentField, LabelString); return (0); } /* All we need from the label is the offset in the table */ DbgPrint (ASL_DEBUG_OUTPUT, "Resolved Label: 0x%8.8X\n", LabelField->TableOffset); return (LabelField->TableOffset); }
UINT32 DtCompileBuffer ( UINT8 *Buffer, char *StringValue, DT_FIELD *Field, UINT32 ByteLength) { char *Substring; ACPI_STATUS Status; UINT32 Count; UINT32 i; /* Allow several different types of value separators */ StringValue = DtNormalizeBuffer (StringValue, &Count); Substring = StringValue; /* Each element of StringValue is now three chars (2 hex + 1 space) */ for (i = 0; i < Count; i++, Substring += 3) { /* Check for byte value too long */ if (*(&Substring[2]) && (*(&Substring[2]) != ' ')) { DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring); goto Exit; } /* Convert two ASCII characters to one hex byte */ Status = AcpiUtAsciiToHexByte (Substring, &Buffer[i]); if (ACPI_FAILURE (Status)) { DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring); goto Exit; } } Exit: ACPI_FREE (StringValue); return (ByteLength - Count); }
void DtFatal ( UINT8 MessageId, DT_FIELD *FieldObject, char *ExtraMessage) { DtError (ASL_ERROR, MessageId, FieldObject, ExtraMessage); CmCleanupAndExit (); exit (1); }
UINT32 DtCompileBuffer ( UINT8 *Buffer, char *StringValue, DT_FIELD *Field, UINT32 ByteLength) { ACPI_STATUS Status; char Hex[3]; UINT64 Value; UINT32 i; UINT32 Count; /* Allow several different types of value separators */ StringValue = DtNormalizeBuffer (StringValue, &Count); Hex[2] = 0; for (i = 0; i < Count; i++) { /* Each element of StringValue is three chars */ Hex[0] = StringValue[(3 * i)]; Hex[1] = StringValue[(3 * i) + 1]; /* Convert one hex byte */ Value = 0; Status = DtStrtoul64 (Hex, &Value); if (ACPI_FAILURE (Status)) { DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, MsgBuffer); goto Exit; } Buffer[i] = (UINT8) Value; } Exit: ACPI_FREE (StringValue); return (ByteLength - Count); }
void DtFatal ( UINT16 MessageId, DT_FIELD *FieldObject, char *ExtraMessage) { DtError (ASL_ERROR, MessageId, FieldObject, ExtraMessage); /* * TBD: remove this entire function, DtFatal * * We cannot abort the compiler on error, because we may be compiling a * list of files. We must move on to the next file. */ #ifdef __OBSOLETE CmCleanupAndExit (); exit (1); #endif }
static void DtCompileString ( UINT8 *Buffer, DT_FIELD *Field, UINT32 ByteLength) { UINT32 Length; Length = ACPI_STRLEN (Field->Value); /* Check if the string is too long for the field */ if (Length > ByteLength) { sprintf (MsgBuffer, "Maximum %u characters", ByteLength); DtError (ASL_ERROR, ASL_MSG_STRING_LENGTH, Field, MsgBuffer); Length = ByteLength; } ACPI_MEMCPY (Buffer, Field->Value, Length); }
ACPI_STATUS DtDoCompile ( void) { ACPI_STATUS Status; UINT8 Event; DT_FIELD *FieldList; /* Initialize globals */ Status = DtInitialize (); if (ACPI_FAILURE (Status)) { printf ("Error during compiler initialization, 0x%X\n", Status); return (Status); } /* Preprocessor */ Event = UtBeginEvent ("Preprocess input file"); PrDoPreprocess (); UtEndEvent (Event); if (Gbl_PreprocessOnly) { return (AE_OK); } /* * Scan the input file (file is already open) and * build the parse tree */ Event = UtBeginEvent ("Scan and parse input file"); FieldList = DtScanFile (Gbl_Files[ASL_FILE_INPUT].Handle); UtEndEvent (Event); /* Did the parse tree get successfully constructed? */ if (!FieldList) { /* TBD: temporary error message. Msgs should come from function above */ DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL, "Input file does not appear to be an ASL or data table source file"); Status = AE_ERROR; goto CleanupAndExit; } Event = UtBeginEvent ("Compile parse tree"); /* * Compile the parse tree */ Status = DtCompileDataTable (&FieldList); UtEndEvent (Event); DtFreeFieldList (); if (ACPI_FAILURE (Status)) { /* TBD: temporary error message. Msgs should come from function above */ DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL, "Could not compile input file"); goto CleanupAndExit; } /* Create/open the binary output file */ Gbl_Files[ASL_FILE_AML_OUTPUT].Filename = NULL; Status = FlOpenAmlOutputFile (Gbl_OutputFilenamePrefix); if (ACPI_FAILURE (Status)) { goto CleanupAndExit; } /* Write the binary, then the optional hex file */ DtOutputBinary (Gbl_RootTable); HxDoHexOutput (); DtWriteTableToListing (); CleanupAndExit: CmCleanupAndExit (); return (Status); }
ACPI_STATUS DtCompileFadt ( void **List) { ACPI_STATUS Status; DT_SUBTABLE *Subtable; DT_SUBTABLE *ParentTable; DT_FIELD **PFieldList = (DT_FIELD **) List; ACPI_TABLE_HEADER *Table; UINT8 FadtRevision; UINT32 i; /* Minimum table is the FADT version 1 (ACPI 1.0) */ Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1, &Subtable, TRUE); if (ACPI_FAILURE (Status)) { return (Status); } ParentTable = DtPeekSubtable (); DtInsertSubtable (ParentTable, Subtable); Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); FadtRevision = Table->Revision; /* Revision 0 and 2 are illegal */ if ((FadtRevision == 0) || (FadtRevision == 2)) { DtError (ASL_ERROR, 0, NULL, "Invalid value for FADT revision"); return (AE_BAD_VALUE); } /* Revision out of supported range? */ if (FadtRevision > ACPI_FADT_MAX_VERSION) { DtError (ASL_ERROR, 0, NULL, "Unknown or unsupported value for FADT revision"); return (AE_BAD_VALUE); } /* Compile individual sub-parts of the FADT, per-revision */ for (i = 3; i <= ACPI_FADT_MAX_VERSION; i++) { if (i > FadtRevision) { break; } /* Compile the fields specific to this FADT revision */ Status = DtCompileTable (PFieldList, FadtRevisionInfo[i], &Subtable, TRUE); if (ACPI_FAILURE (Status)) { return (Status); } DtInsertSubtable (ParentTable, Subtable); } return (AE_OK); }
UINT64 DtDoOperator ( UINT64 LeftValue, UINT32 Operator, UINT64 RightValue) { UINT64 Result; /* Perform the requested operation */ switch (Operator) { case EXPOP_ONES_COMPLIMENT: Result = ~RightValue; break; case EXPOP_LOGICAL_NOT: Result = !RightValue; break; case EXPOP_MULTIPLY: Result = LeftValue * RightValue; break; case EXPOP_DIVIDE: if (!RightValue) { DtError (ASL_ERROR, ASL_MSG_DIVIDE_BY_ZERO, Gbl_CurrentField, NULL); return (0); } Result = LeftValue / RightValue; break; case EXPOP_MODULO: if (!RightValue) { DtError (ASL_ERROR, ASL_MSG_DIVIDE_BY_ZERO, Gbl_CurrentField, NULL); return (0); } Result = LeftValue % RightValue; break; case EXPOP_ADD: Result = LeftValue + RightValue; break; case EXPOP_SUBTRACT: Result = LeftValue - RightValue; break; case EXPOP_SHIFT_RIGHT: Result = LeftValue >> RightValue; break; case EXPOP_SHIFT_LEFT: Result = LeftValue << RightValue; break; case EXPOP_LESS: Result = LeftValue < RightValue; break; case EXPOP_GREATER: Result = LeftValue > RightValue; break; case EXPOP_LESS_EQUAL: Result = LeftValue <= RightValue; break; case EXPOP_GREATER_EQUAL: Result = LeftValue >= RightValue; break; case EXPOP_EQUAL: Result = LeftValue == RightValue; break; case EXPOP_NOT_EQUAL: Result = LeftValue != RightValue; break; case EXPOP_AND: Result = LeftValue & RightValue; break; case EXPOP_XOR: Result = LeftValue ^ RightValue; break; case EXPOP_OR: Result = LeftValue | RightValue; break; case EXPOP_LOGICAL_AND: Result = LeftValue && RightValue; break; case EXPOP_LOGICAL_OR: Result = LeftValue || RightValue; break; default: /* Unknown operator */ DtFatal (ASL_MSG_INVALID_EXPRESSION, Gbl_CurrentField, NULL); return (0); } DbgPrint (ASL_DEBUG_OUTPUT, "IntegerEval: (%8.8X%8.8X %s %8.8X%8.8X) = %8.8X%8.8X\n", ACPI_FORMAT_UINT64 (LeftValue), DtGetOpName (Operator), ACPI_FORMAT_UINT64 (RightValue), ACPI_FORMAT_UINT64 (Result)); return (Result); }
void DtCompileFlag ( UINT8 *Buffer, DT_FIELD *Field, ACPI_DMTABLE_INFO *Info) { UINT64 Value = 0; UINT32 BitLength = 1; UINT8 BitPosition = 0; ACPI_STATUS Status; Status = DtStrtoul64 (Field->Value, &Value); if (ACPI_FAILURE (Status)) { DtError (ASL_ERROR, ASL_MSG_INVALID_HEX_INTEGER, Field, NULL); } switch (Info->Opcode) { case ACPI_DMT_FLAG0: case ACPI_DMT_FLAG1: case ACPI_DMT_FLAG2: case ACPI_DMT_FLAG3: case ACPI_DMT_FLAG4: case ACPI_DMT_FLAG5: case ACPI_DMT_FLAG6: case ACPI_DMT_FLAG7: BitPosition = Info->Opcode; BitLength = 1; break; case ACPI_DMT_FLAGS0: BitPosition = 0; BitLength = 2; break; case ACPI_DMT_FLAGS1: BitPosition = 1; BitLength = 2; break; case ACPI_DMT_FLAGS2: BitPosition = 2; BitLength = 2; break; case ACPI_DMT_FLAGS4: BitPosition = 4; BitLength = 2; break; default: DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid flag opcode"); break; } /* Check range of the input flag value */ if (Value >= ((UINT64) 1 << BitLength)) { sprintf (MsgBuffer, "Maximum %u bit", BitLength); DtError (ASL_ERROR, ASL_MSG_FLAG_VALUE, Field, MsgBuffer); Value = 0; } *Buffer |= (UINT8) (Value << BitPosition); }
void DtCompileInteger ( UINT8 *Buffer, DT_FIELD *Field, UINT32 ByteLength, UINT8 Flags) { UINT64 Value; UINT64 MaxValue; ACPI_STATUS Status; /* Output buffer byte length must be in range 1-8 */ if ((ByteLength > 8) || (ByteLength == 0)) { DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid internal Byte length"); return; } /* Resolve integer expression to a single integer value */ Status = DtResolveIntegerExpression (Field, &Value); if (ACPI_FAILURE (Status)) { return; } /* * Ensure that reserved fields are set properly. Note: uses * the DT_NON_ZERO flag to indicate that the reserved value * must be exactly one. Otherwise, the value must be zero. * This is sufficient for now. */ /* TBD: Should use a flag rather than compare "Reserved" */ if (!ACPI_STRCMP (Field->Name, "Reserved")) { if (Flags & DT_NON_ZERO) { if (Value != 1) { DtError (ASL_WARNING, ASL_MSG_RESERVED_VALUE, Field, "Must be one, setting to one"); Value = 1; } } else if (Value != 0) { DtError (ASL_WARNING, ASL_MSG_RESERVED_VALUE, Field, "Must be zero, setting to zero"); Value = 0; } } /* Check if the value must be non-zero */ else if ((Flags & DT_NON_ZERO) && (Value == 0)) { DtError (ASL_ERROR, ASL_MSG_ZERO_VALUE, Field, NULL); } /* * Generate the maximum value for the data type (ByteLength) * Note: construct chosen for maximum portability */ MaxValue = ((UINT64) (-1)) >> (64 - (ByteLength * 8)); /* Validate that the input value is within range of the target */ if (Value > MaxValue) { sprintf (MsgBuffer, "%8.8X%8.8X - max %u bytes", ACPI_FORMAT_UINT64 (Value), ByteLength); DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer); } ACPI_MEMCPY (Buffer, &Value, ByteLength); return; }
void DtCompileFlag ( UINT8 *Buffer, DT_FIELD *Field, ACPI_DMTABLE_INFO *Info) { UINT64 Value = 0; UINT32 BitLength = 1; UINT8 BitPosition = 0; Value = AcpiUtImplicitStrtoul64 (Field->Value); switch (Info->Opcode) { case ACPI_DMT_FLAG0: case ACPI_DMT_FLAG1: case ACPI_DMT_FLAG2: case ACPI_DMT_FLAG3: case ACPI_DMT_FLAG4: case ACPI_DMT_FLAG5: case ACPI_DMT_FLAG6: case ACPI_DMT_FLAG7: BitPosition = Info->Opcode; BitLength = 1; break; case ACPI_DMT_FLAGS0: BitPosition = 0; BitLength = 2; break; case ACPI_DMT_FLAGS1: BitPosition = 1; BitLength = 2; break; case ACPI_DMT_FLAGS2: BitPosition = 2; BitLength = 2; break; case ACPI_DMT_FLAGS4: BitPosition = 4; BitLength = 2; break; case ACPI_DMT_FLAGS4_0: BitPosition = 0; BitLength = 4; break; case ACPI_DMT_FLAGS4_4: BitPosition = 4; BitLength = 4; break; case ACPI_DMT_FLAGS4_8: BitPosition = 8; BitLength = 4; break; case ACPI_DMT_FLAGS4_12: BitPosition = 12; BitLength = 4; break; case ACPI_DMT_FLAGS16_16: BitPosition = 16; BitLength = 16; break; default: DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid flag opcode"); break; } /* Check range of the input flag value */ if (Value >= ((UINT64) 1 << BitLength)) { sprintf (AslGbl_MsgBuffer, "Maximum %u bit", BitLength); DtError (ASL_ERROR, ASL_MSG_FLAG_VALUE, Field, AslGbl_MsgBuffer); Value = 0; } *Buffer |= (UINT8) (Value << BitPosition); }
void DtCompileInteger ( UINT8 *Buffer, DT_FIELD *Field, UINT32 ByteLength, UINT8 Flags) { UINT64 Value; UINT64 MaxValue; ACPI_STATUS Status; /* Output buffer byte length must be in range 1-8 */ if ((ByteLength > 8) || (ByteLength == 0)) { DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid internal Byte length"); return; } /* Resolve integer expression to a single integer value */ Status = DtResolveIntegerExpression (Field, &Value); if (ACPI_FAILURE (Status)) { return; } /* Ensure that reserved fields are set to zero */ /* TBD: should we set to zero, or just make this an ERROR? */ /* TBD: Probably better to use a flag */ if (!ACPI_STRCMP (Field->Name, "Reserved") && (Value != 0)) { DtError (ASL_WARNING, ASL_MSG_RESERVED_VALUE, Field, "Setting to zero"); Value = 0; } /* Check if the value must be non-zero */ if ((Value == 0) && (Flags & DT_NON_ZERO)) { DtError (ASL_ERROR, ASL_MSG_ZERO_VALUE, Field, NULL); } /* * Generate the maximum value for the data type (ByteLength) * Note: construct chosen for maximum portability */ MaxValue = ((UINT64) (-1)) >> (64 - (ByteLength * 8)); /* Validate that the input value is within range of the target */ if (Value > MaxValue) { snprintf (MsgBuffer, sizeof(MsgBuffer), "%8.8X%8.8X - max %u bytes", ACPI_FORMAT_UINT64 (Value), ByteLength); DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer); } ACPI_MEMCPY (Buffer, &Value, ByteLength); return; }