From 73ae2f70cb206ba8f2bdcb8ee61abdb59158122b Mon Sep 17 00:00:00 2001 From: Al Stone Date: Sep 07 2017 23:19:48 +0000 Subject: New upstream version 20170831 --- diff --git a/changes.txt b/changes.txt index d0fe928..db25f7e 100644 --- a/changes.txt +++ b/changes.txt @@ -1,4 +1,53 @@ ---------------------------------------- +31 August 2017. Summary of changes for version 20170831: + + +1) ACPICA kernel-resident subsystem: + +Implemented internal support for full 64-bit addresses that appear in all +Generic Address Structure (GAS) structures. Previously, only the lower 32 +bits were used. Affects the use of GAS structures in the FADT and other +tables, as well as the GAS structures passed to the AcpiRead and +AcpiWrite public external interfaces that are used by drivers. Lv Zheng. + +Added header support for the PDTT ACPI table (Processor Debug Trigger +Table). Full support in the iASL Data Table Compiler and disassembler is +forthcoming. + + +2) iASL Compiler/Disassembler and Tools: + +iASL/Disassembler: Fixed a problem with the PPTT ACPI table (Processor +Properties Topology Table) where a flag bit was specified in the wrong +bit position ("Line Size Valid", bit 6). + +iASL: Implemented support for Octal integer constants as defined by the +ASL language grammar, per the ACPI specification. Any integer constant +that starts with a zero is an octal constant. For example, + Store (037777, Local0) /* Octal constant */ + Store (0x3FFF, Local0) /* Hex equivalent */ + Store (16383, Local0) /* Decimal equivalent */ + +iASL: Improved overflow detection for 64-bit string conversions during +compilation of integer constants. "Overflow" in this case means a string +that represents an integer that is too large to fit into a 64-bit value. +Any 64-bit constants within a 32-bit DSDT or SSDT are still truncated to +the low-order 32 bits with a warning, as previously implemented. Several +new exceptions are defined that indicate a 64-bit overflow, as well as +the base (radix) that was used during the attempted conversion. Examples: + Local0 = 0xAAAABBBBCCCCDDDDEEEEFFFF // AE_HEX_OVERFLOW + Local0 = 01111222233334444555566667777 // AE_OCTAL_OVERFLOW + Local0 = 11112222333344445555666677778888 // AE_DECIMAL_OVERFLOW + +iASL: Added a warning for the case where a ResourceTemplate is declared +with no ResourceDescriptor entries (coded as "ResourceTemplate(){}"). In +this case, the resulting template is created with a single END_TAG +descriptor, which is essentially useless. + +iASL: Expanded the -vw option (ignore specific warnings/remarks) to +include compilation error codes as well. + +---------------------------------------- 28 July 2017. Summary of changes for version 20170728: diff --git a/generate/unix/acpidump/Makefile b/generate/unix/acpidump/Makefile index 7e3723f..884708b 100644 --- a/generate/unix/acpidump/Makefile +++ b/generate/unix/acpidump/Makefile @@ -47,6 +47,7 @@ OBJECTS = \ $(OBJDIR)/utmath.o\ $(OBJDIR)/utnonansi.o\ $(OBJDIR)/utstring.o\ + $(OBJDIR)/utstrsuppt.o\ $(OBJDIR)/utstrtoul64.o\ $(OBJDIR)/utxferror.o diff --git a/generate/unix/acpiexamples/Makefile b/generate/unix/acpiexamples/Makefile index 6aa2ba9..1689de1 100644 --- a/generate/unix/acpiexamples/Makefile +++ b/generate/unix/acpiexamples/Makefile @@ -157,6 +157,7 @@ OBJECTS = \ $(OBJDIR)/utresrc.o\ $(OBJDIR)/utstate.o\ $(OBJDIR)/utstring.o\ + $(OBJDIR)/utstrsuppt.o\ $(OBJDIR)/utstrtoul64.o\ $(OBJDIR)/utxface.o\ $(OBJDIR)/utxferror.o\ diff --git a/generate/unix/acpiexec/Makefile b/generate/unix/acpiexec/Makefile index fcb638b..681442c 100644 --- a/generate/unix/acpiexec/Makefile +++ b/generate/unix/acpiexec/Makefile @@ -230,6 +230,7 @@ OBJECTS = \ $(OBJDIR)/utresrc.o\ $(OBJDIR)/utstate.o\ $(OBJDIR)/utstring.o\ + $(OBJDIR)/utstrsuppt.o\ $(OBJDIR)/utstrtoul64.o\ $(OBJDIR)/uttrack.o\ $(OBJDIR)/utuuid.o\ diff --git a/generate/unix/iasl/Makefile b/generate/unix/iasl/Makefile index b302572..02390ea 100644 --- a/generate/unix/iasl/Makefile +++ b/generate/unix/iasl/Makefile @@ -231,6 +231,7 @@ OBJECTS = \ $(OBJDIR)/utresrc.o\ $(OBJDIR)/utstate.o\ $(OBJDIR)/utstrtoul64.o\ + $(OBJDIR)/utstrsuppt.o\ $(OBJDIR)/utstring.o\ $(OBJDIR)/utuuid.o\ $(OBJDIR)/utxface.o\ diff --git a/source/common/dmtbinfo.c b/source/common/dmtbinfo.c index 8d97c02..36a5dbb 100644 --- a/source/common/dmtbinfo.c +++ b/source/common/dmtbinfo.c @@ -2720,7 +2720,7 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoPptt1[] = {ACPI_DMT_FLAG3, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Allocation Type valid", 0}, {ACPI_DMT_FLAG4, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Cache Type valid", 0}, {ACPI_DMT_FLAG5, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Write Policy valid", 0}, - {ACPI_DMT_FLAG5, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Line Size valid", 0}, + {ACPI_DMT_FLAG6, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Line Size valid", 0}, {ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (NextLevelOfCache), "Next Level of Cache", 0}, {ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (Size), "Size", 0}, {ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (NumberOfSets), "Number of Sets", 0}, diff --git a/source/compiler/aslcompiler.h b/source/compiler/aslcompiler.h index 04b392d..c370cc5 100644 --- a/source/compiler/aslcompiler.h +++ b/source/compiler/aslcompiler.h @@ -782,6 +782,11 @@ void TrSetOpCurrentFilename ( ACPI_PARSE_OBJECT *Op); +void +TrSetOpIntegerWidth ( + ACPI_PARSE_OBJECT *TableSignature, + ACPI_PARSE_OBJECT *Revision); + ACPI_PARSE_OBJECT * TrLinkOpChildren ( ACPI_PARSE_OBJECT *Op, diff --git a/source/compiler/aslcompiler.l b/source/compiler/aslcompiler.l index 091c28c..b72fcdf 100644 --- a/source/compiler/aslcompiler.l +++ b/source/compiler/aslcompiler.l @@ -87,6 +87,7 @@ count (int type); LeadNameChar [A-Za-z_] DigitChar [0-9] +OctalChar [0-7] HexDigitChar [A-Fa-f0-9] RootChar [\\] Nothing [] @@ -170,8 +171,7 @@ NamePathTail [.]{NameSeg} /* * Begin standard ASL grammar */ -0[xX]{HexDigitChar}+ | -{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); +[0-9][a-zA-Z0-9]* { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); count (1); return (PARSEOP_INTEGER); } "Include" { count (1); return (PARSEOP_INCLUDE); } diff --git a/source/compiler/asldebug.c b/source/compiler/asldebug.c index 12f3c34..775d117 100644 --- a/source/compiler/asldebug.c +++ b/source/compiler/asldebug.c @@ -57,6 +57,10 @@ UtDumpParseOpName ( UINT32 Level, UINT32 DataLength); +static char * +UtCreateEscapeSequences ( + char *InString); + /******************************************************************************* * @@ -164,7 +168,6 @@ UtDumpStringOp ( String = Op->Asl.Value.String; - if (Op->Asl.ParseOpcode != PARSEOP_STRING_LITERAL) { /* @@ -186,6 +189,8 @@ UtDumpStringOp ( return; } + String = UtCreateEscapeSequences (String); + /* Emit the ParseOp name, leaving room for the string */ UtDumpParseOpName (Op, Level, strlen (String)); @@ -195,6 +200,86 @@ UtDumpStringOp ( /******************************************************************************* * + * FUNCTION: UtCreateEscapeSequences + * + * PARAMETERS: InString - ASCII string to be expanded + * + * RETURN: Expanded string + * + * DESCRIPTION: Expand all non-printable ASCII bytes (0-0x1F) to escape + * sequences. For example, hex 14 becomes \x14 + * + * NOTE: Since this function is used for debug output only, it does + * not attempt to translate into the "known" escape sequences + * such as \a, \f, \t, etc. + * + ******************************************************************************/ + +static char * +UtCreateEscapeSequences ( + char *InString) +{ + char *String = InString; + char *OutString; + char *OutStringPtr; + UINT32 InStringLength = 0; + UINT32 EscapeCount = 0; + + + /* + * Determine up front how many escapes are within the string. + * Obtain the input string length while doing so. + */ + while (*String) + { + if ((*String <= 0x1F) || (*String >= 0x7F)) + { + EscapeCount++; + } + + InStringLength++; + String++; + } + + if (!EscapeCount) + { + return (InString); /* No escapes, nothing to do */ + } + + /* New string buffer, 3 extra chars per escape (4 total) */ + + OutString = UtLocalCalloc (InStringLength + (EscapeCount * 3)); + OutStringPtr = OutString; + + /* Convert non-ascii or non-printable chars to escape sequences */ + + while (*InString) + { + if ((*InString <= 0x1F) || (*InString >= 0x7F)) + { + /* Insert a \x hex escape sequence */ + + OutStringPtr[0] = '\\'; + OutStringPtr[1] = 'x'; + OutStringPtr[2] = AcpiUtHexToAsciiChar (*InString, 4); + OutStringPtr[3] = AcpiUtHexToAsciiChar (*InString, 0); + OutStringPtr += 4; + } + else /* Normal ASCII character */ + { + *OutStringPtr = *InString; + OutStringPtr++; + } + + InString++; + } + + return (OutString); +} + + +/******************************************************************************* + * * FUNCTION: UtDumpBasicOp * * PARAMETERS: Op - Current parse op diff --git a/source/compiler/aslerror.c b/source/compiler/aslerror.c index 174bf21..9332eb0 100644 --- a/source/compiler/aslerror.c +++ b/source/compiler/aslerror.c @@ -649,6 +649,11 @@ AslCommonError ( ASL_ERROR_MSG *Enode; + if (AslIsExceptionIgnored (Level, MessageId)) + { + return; + } + Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG)); if (ExtraMessage) @@ -841,9 +846,9 @@ AslDisableException ( MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); - if ((MessageId < 2000) || (MessageId > 5999)) + if ((MessageId < 2000) || (MessageId > 6999)) { - printf ("\"%s\" is not a valid warning/remark ID\n", + printf ("\"%s\" is not a valid warning/remark/error ID\n", MessageIdString); return (AE_BAD_PARAMETER); } @@ -942,8 +947,9 @@ AslIsExceptionDisabled ( case ASL_WARNING: case ASL_REMARK: + case ASL_ERROR: /* - * Ignore this warning/remark if it has been disabled by + * Ignore this error/warning/remark if it has been disabled by * the user (-vw option) */ EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); @@ -989,14 +995,6 @@ AslError ( ACPI_PARSE_OBJECT *Op, char *ExtraMessage) { - - /* Check if user wants to ignore this exception */ - - if (AslIsExceptionIgnored (Level, MessageId)) - { - return; - } - if (Op) { AslCommonError (Level, MessageId, Op->Asl.LineNumber, diff --git a/source/compiler/aslhelp.c b/source/compiler/aslhelp.c index e3f9831..b6a4841 100644 --- a/source/compiler/aslhelp.c +++ b/source/compiler/aslhelp.c @@ -96,7 +96,7 @@ Usage ( ACPI_OPTION ("-ve", "Report only errors (ignore warnings and remarks)"); ACPI_OPTION ("-vi", "Less verbose errors and warnings for use with IDEs"); ACPI_OPTION ("-vr", "Disable remarks"); - ACPI_OPTION ("-vw ", "Disable specific warning or remark"); + ACPI_OPTION ("-vw ", "Ignore specific error, warning or remark"); ACPI_OPTION ("-vx ", "Expect a specific warning, remark, or error"); ACPI_OPTION ("-w <1|2|3>", "Set warning reporting level"); ACPI_OPTION ("-we", "Report warnings as errors"); diff --git a/source/compiler/aslmain.c b/source/compiler/aslmain.c index 215bff1..eb9d025 100644 --- a/source/compiler/aslmain.c +++ b/source/compiler/aslmain.c @@ -278,11 +278,11 @@ AslInitialize ( AcpiGbl_DmOpt_Verbose = FALSE; - /* Default integer width is 64 bits */ + /* Default integer width is 32 bits */ - AcpiGbl_IntegerBitWidth = 64; - AcpiGbl_IntegerNybbleWidth = 16; - AcpiGbl_IntegerByteWidth = 8; + AcpiGbl_IntegerBitWidth = 32; + AcpiGbl_IntegerNybbleWidth = 8; + AcpiGbl_IntegerByteWidth = 4; for (i = 0; i < ASL_NUM_FILES; i++) { diff --git a/source/compiler/aslmessages.c b/source/compiler/aslmessages.c index a5e2b9b..1faf25c 100644 --- a/source/compiler/aslmessages.c +++ b/source/compiler/aslmessages.c @@ -130,7 +130,7 @@ const char *AslCompilerMsgs [] = /* ASL_MSG_HID_SUFFIX */ "_HID suffix must be all hex digits", /* ASL_MSG_INCLUDE_FILE_OPEN */ "Could not open include file", /* ASL_MSG_INPUT_FILE_OPEN */ "Could not open input file", -/* ASL_MSG_INTEGER_LENGTH */ "64-bit integer in 32-bit table, truncating (DSDT or SSDT version < 2)", +/* ASL_MSG_INTEGER_LENGTH */ "Truncating 64-bit constant found in 32-bit table", /* ASL_MSG_INTEGER_OPTIMIZATION */ "Integer optimized to single-byte AML opcode", /* ASL_MSG_INTERRUPT_LIST */ "Too many interrupts (16 max)", /* ASL_MSG_INTERRUPT_NUMBER */ "Invalid interrupt number (must be 0-15)", @@ -241,7 +241,8 @@ const char *AslCompilerMsgs [] = /* ASL_MSG_ARG_NOT_USED */ "Method Argument is never used", /* ASL_MSG_CONSTANT_REQUIRED */ "Non-reducible expression", /* ASL_MSG_CROSS_TABLE_SCOPE */ "Illegal open scope on external object from within DSDT", -/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:" +/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:", +/* ASL_MSG_NULL_RESOURCE_TEMPLATE */ "Empty Resource Template (END_TAG only)" }; /* Table compiler */ diff --git a/source/compiler/aslmessages.h b/source/compiler/aslmessages.h index ee84fdc..f5ac9f0 100644 --- a/source/compiler/aslmessages.h +++ b/source/compiler/aslmessages.h @@ -244,6 +244,7 @@ typedef enum ASL_MSG_CONSTANT_REQUIRED, ASL_MSG_CROSS_TABLE_SCOPE, ASL_MSG_EXCEPTION_NOT_RECEIVED, + ASL_MSG_NULL_RESOURCE_TEMPLATE, /* These messages are used by the Data Table compiler only */ diff --git a/source/compiler/aslresource.c b/source/compiler/aslresource.c index 406434e..cf3764b 100644 --- a/source/compiler/aslresource.c +++ b/source/compiler/aslresource.c @@ -1040,6 +1040,14 @@ RsDoResourceTemplate ( DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp); + /* DEFAULT_ARG indicates null template - ResourceTemplate(){} */ + + if (DescriptorTypeOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) + { + AslError (ASL_WARNING, ASL_MSG_NULL_RESOURCE_TEMPLATE, + DescriptorTypeOp, DescriptorTypeOp->Asl.Value.String); + } + /* * Process all resource descriptors in the list * Note: It is assumed that the EndTag node has been automatically diff --git a/source/compiler/aslrules.y b/source/compiler/aslrules.y index 1862781..23b3445 100644 --- a/source/compiler/aslrules.y +++ b/source/compiler/aslrules.y @@ -91,7 +91,8 @@ DefinitionBlockTerm String ',' String ',' DWordConst - PARSEOP_CLOSE_PAREN {TrSetOpEndLineNumber ($3); COMMENT_CAPTURE_ON;} + PARSEOP_CLOSE_PAREN {TrSetOpIntegerWidth ($6,$8); + TrSetOpEndLineNumber ($3); COMMENT_CAPTURE_ON;} '{' TermList '}' {$$ = TrLinkOpChildren ($3,7, $4,$6,$8,$10,$12,$14,$18);} ; diff --git a/source/compiler/asltree.c b/source/compiler/asltree.c index a7c71da..13c8736 100644 --- a/source/compiler/asltree.c +++ b/source/compiler/asltree.c @@ -270,6 +270,39 @@ TrSetOpCurrentFilename ( /******************************************************************************* * + * FUNCTION: TrSetOpIntegerWidth + * + * PARAMETERS: Op - An existing parse op + * + * RETURN: None + * + * DESCRIPTION: + * + ******************************************************************************/ + +void +TrSetOpIntegerWidth ( + ACPI_PARSE_OBJECT *TableSignatureOp, + ACPI_PARSE_OBJECT *RevisionOp) +{ + + /* TBD: Check table sig? (DSDT vs. SSDT) */ + + /* Handle command-line version override */ + + if (Gbl_RevisionOverride) + { + AcpiUtSetIntegerWidth (Gbl_RevisionOverride); + } + else + { + AcpiUtSetIntegerWidth ((UINT8) RevisionOp->Asl.Value.Integer); + } +} + + +/******************************************************************************* + * * FUNCTION: TrSetOpEndLineNumber * * PARAMETERS: Op - An existing parse op diff --git a/source/compiler/aslutils.c b/source/compiler/aslutils.c index 066a604..65807ea 100644 --- a/source/compiler/aslutils.c +++ b/source/compiler/aslutils.c @@ -896,11 +896,11 @@ UtAttachNamepathToOwner ( * * FUNCTION: UtDoConstant * - * PARAMETERS: String - Hexadecimal or decimal string + * PARAMETERS: String - Hex/Decimal/Octal * * RETURN: Converted Integer * - * DESCRIPTION: Convert a string to an integer, with error checking. + * DESCRIPTION: Convert a string to an integer, with overflow/error checking. * ******************************************************************************/ @@ -909,17 +909,20 @@ UtDoConstant ( char *String) { ACPI_STATUS Status; - UINT64 Converted; + UINT64 ConvertedInteger; char ErrBuf[64]; - Status = AcpiUtStrtoul64 (String, ACPI_STRTOUL_64BIT, &Converted); + Status = AcpiUtStrtoul64 (String, &ConvertedInteger); if (ACPI_FAILURE (Status)) { - sprintf (ErrBuf, "%s %s\n", "Conversion error:", + sprintf (ErrBuf, "While creating 64-bit constant: %s\n", AcpiFormatException (Status)); - AslCompilererror (ErrBuf); + + AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, Gbl_CurrentLineNumber, + Gbl_LogicalLineNumber, Gbl_CurrentLineOffset, + Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename, ErrBuf); } - return (Converted); + return (ConvertedInteger); } diff --git a/source/compiler/dtcompile.c b/source/compiler/dtcompile.c index 567028b..260ecc5 100644 --- a/source/compiler/dtcompile.c +++ b/source/compiler/dtcompile.c @@ -211,6 +211,8 @@ DtInitialize ( return (Status); } + AcpiUtSetIntegerWidth (2); /* Set width to 64 bits */ + Gbl_FieldList = NULL; Gbl_RootTable = NULL; Gbl_SubtableStack = NULL; diff --git a/source/compiler/dtcompiler.h b/source/compiler/dtcompiler.h index ef3db7e..09cc24f 100644 --- a/source/compiler/dtcompiler.h +++ b/source/compiler/dtcompiler.h @@ -373,6 +373,10 @@ DtFatal ( DT_FIELD *FieldObject, char *ExtraMessage); +UINT64 +DtDoConstant ( + char *String); + char* DtGetFieldValue ( DT_FIELD *Field); diff --git a/source/compiler/dtfield.c b/source/compiler/dtfield.c index f7c4a49..afe869c 100644 --- a/source/compiler/dtfield.c +++ b/source/compiler/dtfield.c @@ -520,15 +520,9 @@ DtCompileFlag ( UINT64 Value = 0; UINT32 BitLength = 1; UINT8 BitPosition = 0; - ACPI_STATUS Status; - Status = AcpiUtStrtoul64 (Field->Value, - (ACPI_STRTOUL_64BIT | ACPI_STRTOUL_BASE16), &Value); - if (ACPI_FAILURE (Status)) - { - DtError (ASL_ERROR, ASL_MSG_INVALID_HEX_INTEGER, Field, NULL); - } + Value = AcpiUtImplicitStrtoul64 (Field->Value); switch (Info->Opcode) { diff --git a/source/compiler/dtparser.y b/source/compiler/dtparser.y index 4ec72ed..93f0719 100644 --- a/source/compiler/dtparser.y +++ b/source/compiler/dtparser.y @@ -167,17 +167,24 @@ Expression | EXPOP_LABEL { $$ = DtResolveLabel (DtParsertext);} - /* Default base for a non-prefixed integer is 16 */ + /* + * All constants for the data table compiler are in hex, whether a (optional) 0x + * prefix is present or not. For example, these two input strings are equivalent: + * 1234 + * 0x1234 + */ - | EXPOP_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);} + /* Non-prefixed hex number */ + + | EXPOP_NUMBER { $$ = DtDoConstant (DtParsertext);} /* Standard hex number (0x1234) */ - | EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);} + | EXPOP_HEX_NUMBER { $$ = DtDoConstant (DtParsertext);} - /* TBD: Decimal number with prefix (0d1234) - Not supported by strtoul64 at this time */ + /* Possible TBD: Decimal number with prefix (0d1234) - Not supported this time */ - | EXPOP_DECIMAL_NUMBER { AcpiUtStrtoul64 (DtParsertext, ACPI_STRTOUL_64BIT, &$$);} + | EXPOP_DECIMAL_NUMBER { $$ = DtDoConstant (DtParsertext);} ; %% diff --git a/source/compiler/dtutils.c b/source/compiler/dtutils.c index 81a2d45..ce374ce 100644 --- a/source/compiler/dtutils.c +++ b/source/compiler/dtutils.c @@ -195,6 +195,38 @@ DtFatal ( } +/******************************************************************************* + * + * FUNCTION: DtDoConstant + * + * PARAMETERS: String - Only hex constants are supported, + * regardless of whether the 0x prefix + * is used + * + * RETURN: Converted Integer + * + * DESCRIPTION: Convert a string to an integer, with overflow/error checking. + * + ******************************************************************************/ + +UINT64 +DtDoConstant ( + char *String) +{ + UINT64 ConvertedInteger; + + + /* + * TBD: The ImplicitStrtoul64 function does not report overflow + * conditions. The input string is simply truncated. If it is + * desired to report overflow to the table compiler, this should + * somehow be added here. Note: integers that are prefixed with 0x + * or not are both hex integers. + */ + ConvertedInteger = AcpiUtImplicitStrtoul64 (String); + return (ConvertedInteger); +} + /****************************************************************************** * * FUNCTION: DtGetFieldValue diff --git a/source/compiler/prparser.y b/source/compiler/prparser.y index 795e1df..f967b9a 100644 --- a/source/compiler/prparser.y +++ b/source/compiler/prparser.y @@ -182,11 +182,11 @@ Expression /* Default base for a non-prefixed integer is 10 */ - | EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, ACPI_STRTOUL_64BIT, &$$);} + | EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, &$$);} /* Standard hex number (0x1234) */ - | EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);} + | EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, &$$);} ; %% diff --git a/source/components/debugger/dbconvert.c b/source/components/debugger/dbconvert.c index a85a542..4b0667e 100644 --- a/source/components/debugger/dbconvert.c +++ b/source/components/debugger/dbconvert.c @@ -321,9 +321,7 @@ AcpiDbConvertToObject ( default: Object->Type = ACPI_TYPE_INTEGER; - Status = AcpiUtStrtoul64 (String, - (AcpiGbl_IntegerByteWidth | ACPI_STRTOUL_BASE16), - &Object->Integer.Value); + Status = AcpiUtStrtoul64 (String, &Object->Integer.Value); break; } diff --git a/source/components/disassembler/dmresrc.c b/source/components/disassembler/dmresrc.c index 33cc78f..53e249f 100644 --- a/source/components/disassembler/dmresrc.c +++ b/source/components/disassembler/dmresrc.c @@ -432,6 +432,20 @@ AcpiDmIsResourceTemplate ( BufferLength = NextOp->Common.Value.Size; /* + * Any buffer smaller than one byte cannot possibly be a resource + * template. Two bytes could possibly be a "NULL" resource template + * with a lone end tag descriptor (as generated via + * "ResourceTemplate(){}"), but this would be an extremely unusual + * case, as the template would be essentially useless. The disassembler + * therefore does not recognize any two-byte buffer as a resource + * template. + */ + if (BufferLength <= 2) + { + return (AE_TYPE); + } + + /* * Not a template if declared buffer length != actual length of the * intialization byte list. Because the resource macros will create * a buffer of the exact required length (buffer length will be equal diff --git a/source/components/dispatcher/dswexec.c b/source/components/dispatcher/dswexec.c index a5b5db8..d5a9053 100644 --- a/source/components/dispatcher/dswexec.c +++ b/source/components/dispatcher/dswexec.c @@ -145,7 +145,7 @@ AcpiDsGetPredicateValue ( * object. Implicitly convert the argument if necessary. */ Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc, - ACPI_STRTOUL_BASE16); + ACPI_IMPLICIT_CONVERSION); if (ACPI_FAILURE (Status)) { goto Cleanup; diff --git a/source/components/events/evgpe.c b/source/components/events/evgpe.c index d496430..7896ab3 100644 --- a/source/components/events/evgpe.c +++ b/source/components/events/evgpe.c @@ -443,8 +443,8 @@ AcpiEvGpeDetect ( ACPI_GPE_HANDLER_INFO *GpeHandlerInfo; UINT32 IntStatus = ACPI_INTERRUPT_NOT_HANDLED; UINT8 EnabledStatusByte; - UINT32 StatusReg; - UINT32 EnableReg; + UINT64 StatusReg; + UINT64 EnableReg; ACPI_CPU_FLAGS Flags; UINT32 i; UINT32 j; @@ -521,7 +521,7 @@ AcpiEvGpeDetect ( "RunEnable=%02X, WakeEnable=%02X\n", GpeRegisterInfo->BaseGpeNumber, GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1), - StatusReg, EnableReg, + (UINT32) StatusReg, (UINT32) EnableReg, GpeRegisterInfo->EnableForRun, GpeRegisterInfo->EnableForWake)); diff --git a/source/components/executer/exconcat.c b/source/components/executer/exconcat.c index aeb33bb..97a1b6a 100644 --- a/source/components/executer/exconcat.c +++ b/source/components/executer/exconcat.c @@ -165,7 +165,7 @@ AcpiExDoConcatenate ( case ACPI_TYPE_INTEGER: Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1, - ACPI_STRTOUL_BASE16); + ACPI_IMPLICIT_CONVERSION); break; case ACPI_TYPE_BUFFER: diff --git a/source/components/executer/exconvrt.c b/source/components/executer/exconvrt.c index 2a6a14c..856b295 100644 --- a/source/components/executer/exconvrt.c +++ b/source/components/executer/exconvrt.c @@ -64,10 +64,10 @@ AcpiExConvertToAscii ( * * FUNCTION: AcpiExConvertToInteger * - * PARAMETERS: ObjDesc - Object to be converted. Must be an - * Integer, Buffer, or String - * ResultDesc - Where the new Integer object is returned - * Flags - Used for string conversion + * PARAMETERS: ObjDesc - Object to be converted. Must be an + * Integer, Buffer, or String + * ResultDesc - Where the new Integer object is returned + * ImplicitConversion - Used for string conversion * * RETURN: Status * @@ -79,14 +79,13 @@ ACPI_STATUS AcpiExConvertToInteger ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, - UINT32 Flags) + UINT32 ImplicitConversion) { ACPI_OPERAND_OBJECT *ReturnDesc; UINT8 *Pointer; UINT64 Result; UINT32 i; UINT32 Count; - ACPI_STATUS Status; ACPI_FUNCTION_TRACE_PTR (ExConvertToInteger, ObjDesc); @@ -136,12 +135,17 @@ AcpiExConvertToInteger ( * hexadecimal as per the ACPI specification. The only exception (as * of ACPI 3.0) is that the ToInteger() operator allows both decimal * and hexadecimal strings (hex prefixed with "0x"). + * + * Explicit conversion is used only by ToInteger. + * All other string-to-integer conversions are implicit conversions. */ - Status = AcpiUtStrtoul64 (ACPI_CAST_PTR (char, Pointer), - (AcpiGbl_IntegerByteWidth | Flags), &Result); - if (ACPI_FAILURE (Status)) + if (ImplicitConversion) + { + Result = AcpiUtImplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer)); + } + else { - return_ACPI_STATUS (Status); + Result = AcpiUtExplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer)); } break; @@ -684,7 +688,7 @@ AcpiExConvertToTargetType ( * a Buffer or a String to an Integer if necessary. */ Status = AcpiExConvertToInteger (SourceDesc, ResultDesc, - ACPI_STRTOUL_BASE16); + ACPI_IMPLICIT_CONVERSION); break; case ACPI_TYPE_STRING: diff --git a/source/components/executer/exmisc.c b/source/components/executer/exmisc.c index 67b8e11..edc1bff 100644 --- a/source/components/executer/exmisc.c +++ b/source/components/executer/exmisc.c @@ -363,7 +363,7 @@ AcpiExDoLogicalOp ( case ACPI_TYPE_INTEGER: Status = AcpiExConvertToInteger (Operand1, &LocalOperand1, - ACPI_STRTOUL_BASE16); + ACPI_IMPLICIT_CONVERSION); break; case ACPI_TYPE_STRING: diff --git a/source/components/executer/exresop.c b/source/components/executer/exresop.c index 98bbeed..9785eb6 100644 --- a/source/components/executer/exresop.c +++ b/source/components/executer/exresop.c @@ -433,7 +433,7 @@ AcpiExResolveOperands ( * Known as "Implicit Source Operand Conversion" */ Status = AcpiExConvertToInteger (ObjDesc, StackPtr, - ACPI_STRTOUL_BASE16); + ACPI_IMPLICIT_CONVERSION); if (ACPI_FAILURE (Status)) { if (Status == AE_TYPE) diff --git a/source/components/hardware/hwgpe.c b/source/components/hardware/hwgpe.c index af33c93..83045dd 100644 --- a/source/components/hardware/hwgpe.c +++ b/source/components/hardware/hwgpe.c @@ -109,7 +109,7 @@ AcpiHwLowSetGpe ( { ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; ACPI_STATUS Status = AE_OK; - UINT32 EnableMask; + UINT64 EnableMask; UINT32 RegisterBit; @@ -234,7 +234,7 @@ AcpiHwGetGpeStatus ( ACPI_GPE_EVENT_INFO *GpeEventInfo, ACPI_EVENT_STATUS *EventStatus) { - UINT32 InByte; + UINT64 InByte; UINT32 RegisterBit; ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; ACPI_EVENT_STATUS LocalEventStatus = 0; diff --git a/source/components/hardware/hwregs.c b/source/components/hardware/hwregs.c index e287932..7273acf 100644 --- a/source/components/hardware/hwregs.c +++ b/source/components/hardware/hwregs.c @@ -247,9 +247,8 @@ AcpiHwValidateRegister ( * * RETURN: Status * - * DESCRIPTION: Read from either memory or IO space. This is a 32-bit max - * version of AcpiRead, used internally since the overhead of - * 64-bit values is not needed. + * DESCRIPTION: Read from either memory or IO space. This is a 64-bit max + * version of AcpiRead. * * LIMITATIONS: * SpaceID must be SystemMemory or SystemIO. @@ -258,7 +257,7 @@ AcpiHwValidateRegister ( ACPI_STATUS AcpiHwRead ( - UINT32 *Value, + UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg) { UINT64 Address; @@ -276,18 +275,18 @@ AcpiHwRead ( /* Validate contents of the GAS register */ - Status = AcpiHwValidateRegister (Reg, 32, &Address); + Status = AcpiHwValidateRegister (Reg, 64, &Address); if (ACPI_FAILURE (Status)) { return (Status); } /* - * Initialize entire 32-bit return value to zero, convert AccessWidth + * Initialize entire 64-bit return value to zero, convert AccessWidth * into number of bits based */ *Value = 0; - AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32); + AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64); BitWidth = Reg->BitOffset + Reg->BitWidth; BitOffset = Reg->BitOffset; @@ -300,7 +299,7 @@ AcpiHwRead ( { if (BitOffset >= AccessWidth) { - Value32 = 0; + Value64 = 0; BitOffset -= AccessWidth; } else @@ -310,31 +309,31 @@ AcpiHwRead ( Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS) Address + Index * ACPI_DIV_8 (AccessWidth), &Value64, AccessWidth); - Value32 = (UINT32) Value64; } else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ { Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) Address + Index * ACPI_DIV_8 (AccessWidth), &Value32, AccessWidth); + Value64 = (UINT64) Value32; } } /* * Use offset style bit writes because "Index * AccessWidth" is - * ensured to be less than 32-bits by AcpiHwValidateRegister(). + * ensured to be less than 64-bits by AcpiHwValidateRegister(). */ ACPI_SET_BITS (Value, Index * AccessWidth, - ACPI_MASK_BITS_ABOVE_32 (AccessWidth), Value32); + ACPI_MASK_BITS_ABOVE_64 (AccessWidth), Value64); BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth; Index++; } ACPI_DEBUG_PRINT ((ACPI_DB_IO, - "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n", - *Value, AccessWidth, ACPI_FORMAT_UINT64 (Address), - AcpiUtGetRegionName (Reg->SpaceId))); + "Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n", + ACPI_FORMAT_UINT64 (*Value), AccessWidth, + ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId))); return (Status); } @@ -349,15 +348,14 @@ AcpiHwRead ( * * RETURN: Status * - * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max - * version of AcpiWrite, used internally since the overhead of - * 64-bit values is not needed. + * DESCRIPTION: Write to either memory or IO space. This is a 64-bit max + * version of AcpiWrite. * ******************************************************************************/ ACPI_STATUS AcpiHwWrite ( - UINT32 Value, + UINT64 Value, ACPI_GENERIC_ADDRESS *Reg) { UINT64 Address; @@ -365,7 +363,6 @@ AcpiHwWrite ( UINT32 BitWidth; UINT8 BitOffset; UINT64 Value64; - UINT32 Value32; UINT8 Index; ACPI_STATUS Status; @@ -375,7 +372,7 @@ AcpiHwWrite ( /* Validate contents of the GAS register */ - Status = AcpiHwValidateRegister (Reg, 32, &Address); + Status = AcpiHwValidateRegister (Reg, 64, &Address); if (ACPI_FAILURE (Status)) { return (Status); @@ -383,7 +380,7 @@ AcpiHwWrite ( /* Convert AccessWidth into number of bits based */ - AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32); + AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64); BitWidth = Reg->BitOffset + Reg->BitWidth; BitOffset = Reg->BitOffset; @@ -396,10 +393,10 @@ AcpiHwWrite ( { /* * Use offset style bit reads because "Index * AccessWidth" is - * ensured to be less than 32-bits by AcpiHwValidateRegister(). + * ensured to be less than 64-bits by AcpiHwValidateRegister(). */ - Value32 = ACPI_GET_BITS (&Value, Index * AccessWidth, - ACPI_MASK_BITS_ABOVE_32 (AccessWidth)); + Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth, + ACPI_MASK_BITS_ABOVE_64 (AccessWidth)); if (BitOffset >= AccessWidth) { @@ -409,7 +406,6 @@ AcpiHwWrite ( { if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY) { - Value64 = (UINT64) Value32; Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS) Address + Index * ACPI_DIV_8 (AccessWidth), Value64, AccessWidth); @@ -418,7 +414,7 @@ AcpiHwWrite ( { Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) Address + Index * ACPI_DIV_8 (AccessWidth), - Value32, AccessWidth); + (UINT32) Value64, AccessWidth); } } @@ -431,9 +427,9 @@ AcpiHwWrite ( } ACPI_DEBUG_PRINT ((ACPI_DB_IO, - "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n", - Value, AccessWidth, ACPI_FORMAT_UINT64 (Address), - AcpiUtGetRegionName (Reg->SpaceId))); + "Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n", + ACPI_FORMAT_UINT64 (Value), AccessWidth, + ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId))); return (Status); } @@ -580,6 +576,7 @@ AcpiHwRegisterRead ( UINT32 *ReturnValue) { UINT32 Value = 0; + UINT64 Value64; ACPI_STATUS Status; @@ -618,12 +615,14 @@ AcpiHwRegisterRead ( case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ - Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock); + Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPm2ControlBlock); + Value = (UINT32) Value64; break; case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ - Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock); + Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPmTimerBlock); + Value = (UINT32) Value64; break; case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ @@ -641,7 +640,7 @@ AcpiHwRegisterRead ( if (ACPI_SUCCESS (Status)) { - *ReturnValue = Value; + *ReturnValue = (UINT32) Value; } return_ACPI_STATUS (Status); @@ -681,6 +680,7 @@ AcpiHwRegisterWrite ( { ACPI_STATUS Status; UINT32 ReadValue; + UINT64 ReadValue64; ACPI_FUNCTION_TRACE (HwRegisterWrite); @@ -742,11 +742,12 @@ AcpiHwRegisterWrite ( * For control registers, all reserved bits must be preserved, * as per the ACPI spec. */ - Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock); + Status = AcpiHwRead (&ReadValue64, &AcpiGbl_FADT.XPm2ControlBlock); if (ACPI_FAILURE (Status)) { goto Exit; } + ReadValue = (UINT32) ReadValue64; /* Insert the bits to be preserved */ @@ -802,26 +803,29 @@ AcpiHwReadMultiple ( { UINT32 ValueA = 0; UINT32 ValueB = 0; + UINT64 Value64; ACPI_STATUS Status; /* The first register is always required */ - Status = AcpiHwRead (&ValueA, RegisterA); + Status = AcpiHwRead (&Value64, RegisterA); if (ACPI_FAILURE (Status)) { return (Status); } + ValueA = (UINT32) Value64; /* Second register is optional */ if (RegisterB->Address) { - Status = AcpiHwRead (&ValueB, RegisterB); + Status = AcpiHwRead (&Value64, RegisterB); if (ACPI_FAILURE (Status)) { return (Status); } + ValueB = (UINT32) Value64; } /* diff --git a/source/components/hardware/hwtimer.c b/source/components/hardware/hwtimer.c index f90d27b..5e10e45 100644 --- a/source/components/hardware/hwtimer.c +++ b/source/components/hardware/hwtimer.c @@ -107,6 +107,7 @@ AcpiGetTimer ( UINT32 *Ticks) { ACPI_STATUS Status; + UINT64 TimerValue; ACPI_FUNCTION_TRACE (AcpiGetTimer); @@ -124,7 +125,14 @@ AcpiGetTimer ( return_ACPI_STATUS (AE_SUPPORT); } - Status = AcpiHwRead (Ticks, &AcpiGbl_FADT.XPmTimerBlock); + Status = AcpiHwRead (&TimerValue, &AcpiGbl_FADT.XPmTimerBlock); + if (ACPI_SUCCESS (Status)) + { + /* ACPI PM Timer is defined to be 32 bits (PM_TMR_LEN) */ + + *Ticks = (UINT32) TimerValue; + } + return_ACPI_STATUS (Status); } diff --git a/source/components/hardware/hwxface.c b/source/components/hardware/hwxface.c index e367814..f4ebe57 100644 --- a/source/components/hardware/hwxface.c +++ b/source/components/hardware/hwxface.c @@ -139,84 +139,14 @@ AcpiRead ( UINT64 *ReturnValue, ACPI_GENERIC_ADDRESS *Reg) { - UINT32 ValueLo; - UINT32 ValueHi; - UINT32 Width; - UINT64 Address; ACPI_STATUS Status; ACPI_FUNCTION_NAME (AcpiRead); - if (!ReturnValue) - { - return (AE_BAD_PARAMETER); - } - - /* Validate contents of the GAS register. Allow 64-bit transfers */ - - Status = AcpiHwValidateRegister (Reg, 64, &Address); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - - /* - * Two address spaces supported: Memory or I/O. PCI_Config is - * not supported here because the GAS structure is insufficient - */ - if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY) - { - Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS) - Address, ReturnValue, Reg->BitWidth); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - } - else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ - { - ValueLo = 0; - ValueHi = 0; - - Width = Reg->BitWidth; - if (Width == 64) - { - Width = 32; /* Break into two 32-bit transfers */ - } - - Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) - Address, &ValueLo, Width); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - - if (Reg->BitWidth == 64) - { - /* Read the top 32 bits */ - - Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) - (Address + 4), &ValueHi, 32); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - } - - /* Set the return value only if status is AE_OK */ - - *ReturnValue = (ValueLo | ((UINT64) ValueHi << 32)); - } - - ACPI_DEBUG_PRINT ((ACPI_DB_IO, - "Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n", - ACPI_FORMAT_UINT64 (*ReturnValue), Reg->BitWidth, - ACPI_FORMAT_UINT64 (Address), - AcpiUtGetRegionName (Reg->SpaceId))); - - return (AE_OK); + Status = AcpiHwRead (ReturnValue, Reg); + return (Status); } ACPI_EXPORT_SYMBOL (AcpiRead) @@ -240,67 +170,13 @@ AcpiWrite ( UINT64 Value, ACPI_GENERIC_ADDRESS *Reg) { - UINT32 Width; - UINT64 Address; ACPI_STATUS Status; ACPI_FUNCTION_NAME (AcpiWrite); - /* Validate contents of the GAS register. Allow 64-bit transfers */ - - Status = AcpiHwValidateRegister (Reg, 64, &Address); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - - /* - * Two address spaces supported: Memory or IO. PCI_Config is - * not supported here because the GAS structure is insufficient - */ - if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY) - { - Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS) - Address, Value, Reg->BitWidth); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - } - else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ - { - Width = Reg->BitWidth; - if (Width == 64) - { - Width = 32; /* Break into two 32-bit transfers */ - } - - Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) - Address, ACPI_LODWORD (Value), Width); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - - if (Reg->BitWidth == 64) - { - Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) - (Address + 4), ACPI_HIDWORD (Value), 32); - if (ACPI_FAILURE (Status)) - { - return (Status); - } - } - } - - ACPI_DEBUG_PRINT ((ACPI_DB_IO, - "Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n", - ACPI_FORMAT_UINT64 (Value), Reg->BitWidth, - ACPI_FORMAT_UINT64 (Address), - AcpiUtGetRegionName (Reg->SpaceId))); - + Status = AcpiHwWrite (Value, Reg); return (Status); } diff --git a/source/components/namespace/nsconvert.c b/source/components/namespace/nsconvert.c index 17125ef..847c176 100644 --- a/source/components/namespace/nsconvert.c +++ b/source/components/namespace/nsconvert.c @@ -83,8 +83,7 @@ AcpiNsConvertToInteger ( /* String-to-Integer conversion */ - Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer, - AcpiGbl_IntegerByteWidth, &Value); + Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer, &Value); if (ACPI_FAILURE (Status)) { return (Status); diff --git a/source/components/tables/tbxface.c b/source/components/tables/tbxface.c index a34e445..388802d 100644 --- a/source/components/tables/tbxface.c +++ b/source/components/tables/tbxface.c @@ -192,10 +192,13 @@ AcpiReallocateRootTable ( /* - * Only reallocate the root table if the host provided a static buffer - * for the table array in the call to AcpiInitializeTables. + * If there are tables unverified, it is required to reallocate the + * root table list to clean up invalid table entries. Otherwise only + * reallocate the root table list if the host provided a static buffer + * for the table array in the call to AcpiInitializeTables(). */ - if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) + if ((AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) && + AcpiGbl_EnableTableValidation) { return_ACPI_STATUS (AE_SUPPORT); } diff --git a/source/components/utilities/utstrsuppt.c b/source/components/utilities/utstrsuppt.c new file mode 100644 index 0000000..35aca8e --- /dev/null +++ b/source/components/utilities/utstrsuppt.c @@ -0,0 +1,505 @@ +/******************************************************************************* + * + * Module Name: utstrsuppt - Support functions for string-to-integer conversion + * + ******************************************************************************/ + +/* + * Copyright (C) 2000 - 2017, Intel Corp. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. Redistributions in binary form must reproduce at minimum a disclaimer + * substantially similar to the "NO WARRANTY" disclaimer below + * ("Disclaimer") and any redistribution must be conditioned upon + * including a substantially similar Disclaimer requirement for further + * binary redistribution. + * 3. Neither the names of the above-listed copyright holders nor the names + * of any contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License ("GPL") version 2 as published by the Free + * Software Foundation. + * + * NO WARRANTY + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGES. + */ + +#include "acpi.h" +#include "accommon.h" + +#define _COMPONENT ACPI_UTILITIES + ACPI_MODULE_NAME ("utstrsuppt") + + +/* Local prototypes */ + +static ACPI_STATUS +AcpiUtInsertDigit ( + UINT64 *AccumulatedValue, + UINT32 Base, + int AsciiDigit); + +static ACPI_STATUS +AcpiUtStrtoulMultiply64 ( + UINT64 Multiplicand, + UINT64 Multiplier, + UINT64 *OutProduct); + +static ACPI_STATUS +AcpiUtStrtoulAdd64 ( + UINT64 Addend1, + UINT64 Addend2, + UINT64 *OutSum); + + +/******************************************************************************* + * + * FUNCTION: AcpiUtConvertOctalString + * + * PARAMETERS: String - Null terminated input string + * ReturnValuePtr - Where the converted value is returned + * + * RETURN: Status and 64-bit converted integer + * + * DESCRIPTION: Performs a base 8 conversion of the input string to an + * integer value, either 32 or 64 bits. + * + * NOTE: Maximum 64-bit unsigned octal value is 01777777777777777777777 + * Maximum 32-bit unsigned octal value is 037777777777 + * + ******************************************************************************/ + +ACPI_STATUS +AcpiUtConvertOctalString ( + char *String, + UINT64 *ReturnValuePtr) +{ + UINT64 AccumulatedValue = 0; + ACPI_STATUS Status = AE_OK; + + + /* Convert each ASCII byte in the input string */ + + while (*String) + { + /* Character must be ASCII 0-7, otherwise terminate with no error */ + + if (!(ACPI_IS_OCTAL_DIGIT (*String))) + { + break; + } + + /* Convert and insert this octal digit into the accumulator */ + + Status = AcpiUtInsertDigit (&AccumulatedValue, 8, *String); + if (ACPI_FAILURE (Status)) + { + Status = AE_OCTAL_OVERFLOW; + break; + } + + String++; + } + + /* Always return the value that has been accumulated */ + + *ReturnValuePtr = AccumulatedValue; + return (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtConvertDecimalString + * + * PARAMETERS: String - Null terminated input string + * ReturnValuePtr - Where the converted value is returned + * + * RETURN: Status and 64-bit converted integer + * + * DESCRIPTION: Performs a base 10 conversion of the input string to an + * integer value, either 32 or 64 bits. + * + * NOTE: Maximum 64-bit unsigned decimal value is 18446744073709551615 + * Maximum 32-bit unsigned decimal value is 4294967295 + * + ******************************************************************************/ + +ACPI_STATUS +AcpiUtConvertDecimalString ( + char *String, + UINT64 *ReturnValuePtr) +{ + UINT64 AccumulatedValue = 0; + ACPI_STATUS Status = AE_OK; + + + /* Convert each ASCII byte in the input string */ + + while (*String) + { + /* Character must be ASCII 0-9, otherwise terminate with no error */ + + if (!isdigit (*String)) + { + break; + } + + /* Convert and insert this decimal digit into the accumulator */ + + Status = AcpiUtInsertDigit (&AccumulatedValue, 10, *String); + if (ACPI_FAILURE (Status)) + { + Status = AE_DECIMAL_OVERFLOW; + break; + } + + String++; + } + + /* Always return the value that has been accumulated */ + + *ReturnValuePtr = AccumulatedValue; + return (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtConvertHexString + * + * PARAMETERS: String - Null terminated input string + * ReturnValuePtr - Where the converted value is returned + * + * RETURN: Status and 64-bit converted integer + * + * DESCRIPTION: Performs a base 16 conversion of the input string to an + * integer value, either 32 or 64 bits. + * + * NOTE: Maximum 64-bit unsigned hex value is 0xFFFFFFFFFFFFFFFF + * Maximum 32-bit unsigned hex value is 0xFFFFFFFF + * + ******************************************************************************/ + +ACPI_STATUS +AcpiUtConvertHexString ( + char *String, + UINT64 *ReturnValuePtr) +{ + UINT64 AccumulatedValue = 0; + ACPI_STATUS Status = AE_OK; + + + /* Convert each ASCII byte in the input string */ + + while (*String) + { + /* Must be ASCII A-F, a-f, or 0-9, otherwise terminate with no error */ + + if (!isxdigit (*String)) + { + break; + } + + /* Convert and insert this hex digit into the accumulator */ + + Status = AcpiUtInsertDigit (&AccumulatedValue, 16, *String); + if (ACPI_FAILURE (Status)) + { + Status = AE_HEX_OVERFLOW; + break; + } + + String++; + } + + /* Always return the value that has been accumulated */ + + *ReturnValuePtr = AccumulatedValue; + return (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtRemoveLeadingZeros + * + * PARAMETERS: String - Pointer to input ASCII string + * + * RETURN: Next character after any leading zeros. This character may be + * used by the caller to detect end-of-string. + * + * DESCRIPTION: Remove any leading zeros in the input string. Return the + * next character after the final ASCII zero to enable the caller + * to check for the end of the string (NULL terminator). + * + ******************************************************************************/ + +char +AcpiUtRemoveLeadingZeros ( + char **String) +{ + + while (**String == ACPI_ASCII_ZERO) + { + *String += 1; + } + + return (**String); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtRemoveWhitespace + * + * PARAMETERS: String - Pointer to input ASCII string + * + * RETURN: Next character after any whitespace. This character may be + * used by the caller to detect end-of-string. + * + * DESCRIPTION: Remove any leading whitespace in the input string. Return the + * next character after the final ASCII zero to enable the caller + * to check for the end of the string (NULL terminator). + * + ******************************************************************************/ + +char +AcpiUtRemoveWhitespace ( + char **String) +{ + + while (isspace ((UINT8) **String)) + { + *String += 1; + } + + return (**String); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtDetectHexPrefix + * + * PARAMETERS: String - Pointer to input ASCII string + * + * RETURN: TRUE if a "0x" prefix was found at the start of the string + * + * DESCRIPTION: Detect and remove a hex "0x" prefix + * + ******************************************************************************/ + +BOOLEAN +AcpiUtDetectHexPrefix ( + char **String) +{ + + if ((**String == ACPI_ASCII_ZERO) && + (tolower ((int) *(*String + 1)) == 'x')) + { + *String += 2; /* Go past the leading 0x */ + return (TRUE); + } + + return (FALSE); /* Not a hex string */ +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtDetectOctalPrefix + * + * PARAMETERS: String - Pointer to input ASCII string + * + * RETURN: True if an octal "0" prefix was found at the start of the + * string + * + * DESCRIPTION: Detect and remove an octal prefix (zero) + * + ******************************************************************************/ + +BOOLEAN +AcpiUtDetectOctalPrefix ( + char **String) +{ + + if (**String == ACPI_ASCII_ZERO) + { + *String += 1; /* Go past the leading 0 */ + return (TRUE); + } + + return (FALSE); /* Not an octal string */ +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtInsertDigit + * + * PARAMETERS: AccumulatedValue - Current value of the integer value + * accumulator. The new value is + * returned here. + * Base - Radix, either 8/10/16 + * AsciiDigit - ASCII single digit to be inserted + * + * RETURN: Status and result of the convert/insert operation. The only + * possible returned exception code is numeric overflow of + * either the multiply or add conversion operations. + * + * DESCRIPTION: Generic conversion and insertion function for all bases: + * + * 1) Multiply the current accumulated/converted value by the + * base in order to make room for the new character. + * + * 2) Convert the new character to binary and add it to the + * current accumulated value. + * + * Note: The only possible exception indicates an integer + * overflow (AE_NUMERIC_OVERFLOW) + * + ******************************************************************************/ + +static ACPI_STATUS +AcpiUtInsertDigit ( + UINT64 *AccumulatedValue, + UINT32 Base, + int AsciiDigit) +{ + ACPI_STATUS Status; + UINT64 Product; + + + /* Make room in the accumulated value for the incoming digit */ + + Status = AcpiUtStrtoulMultiply64 (*AccumulatedValue, Base, &Product); + if (ACPI_FAILURE (Status)) + { + return (Status); + } + + /* Add in the new digit, and store the sum to the accumulated value */ + + Status = AcpiUtStrtoulAdd64 (Product, AcpiUtAsciiCharToHex (AsciiDigit), + AccumulatedValue); + + return (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtStrtoulMultiply64 + * + * PARAMETERS: Multiplicand - Current accumulated converted integer + * Multiplier - Base/Radix + * OutProduct - Where the product is returned + * + * RETURN: Status and 64-bit product + * + * DESCRIPTION: Multiply two 64-bit values, with checking for 64-bit overflow as + * well as 32-bit overflow if necessary (if the current global + * integer width is 32). + * + ******************************************************************************/ + +static ACPI_STATUS +AcpiUtStrtoulMultiply64 ( + UINT64 Multiplicand, + UINT64 Multiplier, + UINT64 *OutProduct) +{ + UINT64 Product; + + + /* Exit if either operand is zero */ + + *OutProduct = 0; + if (!Multiplicand || !Multiplier) + { + return (AE_OK); + } + + /* Check for 64-bit overflow before the actual multiplication */ + + if (Multiplicand > (ACPI_UINT64_MAX / Multiplier)) + { + return (AE_NUMERIC_OVERFLOW); + } + + Product = Multiplicand * Multiplier; + + /* Check for 32-bit overflow if necessary */ + + if ((AcpiGbl_IntegerBitWidth == 32) && (Product > ACPI_UINT32_MAX)) + { + return (AE_NUMERIC_OVERFLOW); + } + + *OutProduct = Product; + return (AE_OK); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiUtStrtoulAdd64 + * + * PARAMETERS: Addend1 - Current accumulated converted integer + * Addend2 - New hex value/char + * OutSum - Where sum is returned (Accumulator) + * + * RETURN: Status and 64-bit sum + * + * DESCRIPTION: Add two 64-bit values, with checking for 64-bit overflow as + * well as 32-bit overflow if necessary (if the current global + * integer width is 32). + * + ******************************************************************************/ + +static ACPI_STATUS +AcpiUtStrtoulAdd64 ( + UINT64 Addend1, + UINT64 Addend2, + UINT64 *OutSum) +{ + UINT64 Sum; + + + /* Check for 64-bit overflow before the actual addition */ + + if ((Addend1 > 0) && (Addend2 > (ACPI_UINT64_MAX - Addend1))) + { + return (AE_NUMERIC_OVERFLOW); + } + + Sum = Addend1 + Addend2; + + /* Check for 32-bit overflow if necessary */ + + if ((AcpiGbl_IntegerBitWidth == 32) && (Sum > ACPI_UINT32_MAX)) + { + return (AE_NUMERIC_OVERFLOW); + } + + *OutSum = Sum; + return (AE_OK); +} diff --git a/source/components/utilities/utstrtoul64.c b/source/components/utilities/utstrtoul64.c index 7894a4c..e3b9c51 100644 --- a/source/components/utilities/utstrtoul64.c +++ b/source/components/utilities/utstrtoul64.c @@ -1,6 +1,7 @@ /******************************************************************************* * - * Module Name: utstrtoul64 - string to 64-bit integer support + * Module Name: utstrtoul64 - String-to-integer conversion support for both + * 64-bit and 32-bit integers * ******************************************************************************/ @@ -44,84 +45,47 @@ #include "acpi.h" #include "accommon.h" - -/******************************************************************************* - * - * The functions in this module satisfy the need for 64-bit string-to-integer - * conversions on both 32-bit and 64-bit platforms. - * - ******************************************************************************/ - #define _COMPONENT ACPI_UTILITIES ACPI_MODULE_NAME ("utstrtoul64") -/* Local prototypes */ - -static UINT64 -AcpiUtStrtoulBase10 ( - char *String, - UINT32 Flags); - -static UINT64 -AcpiUtStrtoulBase16 ( - char *String, - UINT32 Flags); - /******************************************************************************* * - * String conversion rules as written in the ACPI specification. The error - * conditions and behavior are different depending on the type of conversion. - * - * - * Implicit data type conversion: string-to-integer - * -------------------------------------------------- - * - * Base is always 16. This is the ACPI_STRTOUL_BASE16 case. - * - * Example: - * Add ("BA98", Arg0, Local0) - * - * The integer is initialized to the value zero. - * The ASCII string is interpreted as a hexadecimal constant. - * - * 1) A "0x" prefix is not allowed. However, ACPICA allows this for - * compatibility with previous ACPICA. (NO ERROR) - * - * 2) Terminates when the size of an integer is reached (32 or 64 bits). - * (NO ERROR) - * - * 3) The first non-hex character terminates the conversion without error. - * (NO ERROR) - * - * 4) Conversion of a null (zero-length) string to an integer is not - * allowed. However, ACPICA allows this for compatibility with previous - * ACPICA. This conversion returns the value 0. (NO ERROR) + * This module contains the top-level string to 64/32-bit unsigned integer + * conversion functions: * + * 1) A standard strtoul() function that supports 64-bit integers, base + * 8/10/16, with integer overflow support. This is used mainly by the + * iASL compiler, which implements tighter constraints on integer + * constants than the runtime (interpreter) integer-to-string conversions. + * 2) Runtime "Explicit conversion" as defined in the ACPI specification. + * 3) Runtime "Implicit conversion" as defined in the ACPI specification. * - * Explicit data type conversion: ToInteger() with string operand - * --------------------------------------------------------------- + * Current users of this module: * - * Base is either 10 (default) or 16 (with 0x prefix) - * - * Examples: - * ToInteger ("1000") - * ToInteger ("0xABCD") - * - * 1) Can be (must be) either a decimal or hexadecimal numeric string. - * A hex value must be prefixed by "0x" or it is interpreted as a decimal. + * iASL - Preprocessor (constants and math expressions) + * iASL - Main parser, conversion of constants to integers + * iASL - Data Table Compiler parser (constants and math expressions) + * Interpreter - Implicit and explicit conversions, GPE method names + * Interpreter - Repair code for return values from predefined names + * Debugger - Command line input string conversion + * AcpiDump - ACPI table physical addresses + * AcpiExec - Support for namespace overrides * - * 2) The value must not exceed the maximum of an integer value. ACPI spec - * states the behavior is "unpredictable", so ACPICA matches the behavior - * of the implicit conversion case.(NO ERROR) + * Notes concerning users of these interfaces: * - * 3) Behavior on the first non-hex character is not specified by the ACPI - * spec, so ACPICA matches the behavior of the implicit conversion case - * and terminates. (NO ERROR) + * AcpiGbl_IntegerByteWidth is used to set the 32/64 bit limit for explicit + * and implicit conversions. This global must be set to the proper width. + * For the core ACPICA code, the width depends on the DSDT version. For the + * AcpiUtStrtoul64 interface, all conversions are 64 bits. This interface is + * used primarily for iASL, where the default width is 64 bits for all parsers, + * but error checking is performed later to flag cases where a 64-bit constant + * is wrongly defined in a 32-bit DSDT/SSDT. * - * 4) A null (zero-length) string is illegal. - * However, ACPICA allows this for compatibility with previous ACPICA. - * This conversion returns the value 0. (NO ERROR) + * In ACPI, the only place where octal numbers are supported is within + * the ASL language itself. This is implemented via the main AcpiUtStrtoul64 + * interface. According the ACPI specification, there is no ACPI runtime + * support (explicit/implicit) for octal string conversions. * ******************************************************************************/ @@ -130,261 +94,301 @@ AcpiUtStrtoulBase16 ( * * FUNCTION: AcpiUtStrtoul64 * - * PARAMETERS: String - Null terminated input string - * Flags - Conversion info, see below + * PARAMETERS: String - Null terminated input string, + * must be a valid pointer * ReturnValue - Where the converted integer is - * returned - * - * RETURN: Status and Converted value + * returned. Must be a valid pointer * - * DESCRIPTION: Convert a string into an unsigned value. Performs either a - * 32-bit or 64-bit conversion, depending on the input integer - * size in Flags (often the current mode of the interpreter). + * RETURN: Status and converted integer. Returns an exception on a + * 64-bit numeric overflow * - * Values for Flags: - * ACPI_STRTOUL_32BIT - Max integer value is 32 bits - * ACPI_STRTOUL_64BIT - Max integer value is 64 bits - * ACPI_STRTOUL_BASE16 - Input string is hexadecimal. Default - * is 10/16 based on string prefix (0x). + * DESCRIPTION: Convert a string into an unsigned integer. Always performs a + * full 64-bit conversion, regardless of the current global + * integer width. Supports Decimal, Hex, and Octal strings. * - * NOTES: - * Negative numbers are not supported, as they are not supported by ACPI. + * Current users of this function: * - * Supports only base 16 or base 10 strings/values. Does not - * support Octal strings, as these are not supported by ACPI. - * - * Current users of this support: - * - * Interpreter - Implicit and explicit conversions, GPE method names - * Debugger - Command line input string conversion - * iASL - Main parser, conversion of constants to integers - * iASL - Data Table Compiler parser (constant math expressions) - * iASL - Preprocessor (constant math expressions) - * AcpiDump - Input table addresses - * AcpiExec - Testing of the AcpiUtStrtoul64 function - * - * Note concerning callers: - * AcpiGbl_IntegerByteWidth can be used to set the 32/64 limit. If used, - * this global should be set to the proper width. For the core ACPICA code, - * this width depends on the DSDT version. For iASL, the default byte - * width is always 8 for the parser, but error checking is performed later - * to flag cases where a 64-bit constant is defined in a 32-bit DSDT/SSDT. + * iASL - Preprocessor (constants and math expressions) + * iASL - Main ASL parser, conversion of ASL constants to integers + * iASL - Data Table Compiler parser (constants and math expressions) + * Interpreter - Repair code for return values from predefined names + * AcpiDump - ACPI table physical addresses + * AcpiExec - Support for namespace overrides * ******************************************************************************/ ACPI_STATUS AcpiUtStrtoul64 ( char *String, - UINT32 Flags, UINT64 *ReturnValue) { ACPI_STATUS Status = AE_OK; - UINT32 Base; + UINT8 OriginalBitWidth; + UINT32 Base = 10; /* Default is decimal */ ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String); - /* Parameter validation */ - - if (!String || !ReturnValue) - { - return_ACPI_STATUS (AE_BAD_PARAMETER); - } - *ReturnValue = 0; - /* Check for zero-length string, returns 0 */ + /* A NULL return string returns a value of zero */ if (*String == 0) { return_ACPI_STATUS (AE_OK); } - /* Skip over any white space at start of string */ - - while (isspace ((int) *String)) - { - String++; - } - - /* End of string? return 0 */ - - if (*String == 0) + if (!AcpiUtRemoveWhitespace (&String)) { return_ACPI_STATUS (AE_OK); } /* - * 1) The "0x" prefix indicates base 16. Per the ACPI specification, - * the "0x" prefix is only allowed for implicit (non-strict) conversions. - * However, we always allow it for compatibility with older ACPICA. + * 1) Check for a hex constant. A "0x" prefix indicates base 16. */ - if ((*String == ACPI_ASCII_ZERO) && - (tolower ((int) *(String + 1)) == 'x')) + if (AcpiUtDetectHexPrefix (&String)) { - String += 2; /* Go past the 0x */ - if (*String == 0) - { - return_ACPI_STATUS (AE_OK); /* Return value 0 */ - } - Base = 16; } - /* 2) Force to base 16 (implicit conversion case) */ - - else if (Flags & ACPI_STRTOUL_BASE16) + /* + * 2) Check for an octal constant, defined to be a leading zero + * followed by sequence of octal digits (0-7) + */ + else if (AcpiUtDetectOctalPrefix (&String)) { - Base = 16; + Base = 8; } - /* 3) Default fallback is to Base 10 */ - - else + if (!AcpiUtRemoveLeadingZeros (&String)) { - Base = 10; + return_ACPI_STATUS (AE_OK); /* Return value 0 */ } - /* Skip all leading zeros */ + /* + * Force a full 64-bit conversion. The caller (usually iASL) must + * check for a 32-bit overflow later as necessary (If current mode + * is 32-bit, meaning a 32-bit DSDT). + */ + OriginalBitWidth = AcpiGbl_IntegerBitWidth; + AcpiGbl_IntegerBitWidth = 64; - while (*String == ACPI_ASCII_ZERO) + /* + * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow + * will return an exception (to allow iASL to flag the statement). + */ + switch (Base) { - String++; - if (*String == 0) - { - return_ACPI_STATUS (AE_OK); /* Return value 0 */ - } + case 8: + Status = AcpiUtConvertOctalString (String, ReturnValue); + break; + + case 10: + Status = AcpiUtConvertDecimalString (String, ReturnValue); + break; + + case 16: + default: + Status = AcpiUtConvertHexString (String, ReturnValue); + break; } - /* Perform the base 16 or 10 conversion */ - - if (Base == 16) - { - *ReturnValue = AcpiUtStrtoulBase16 (String, Flags); - } - else - { - *ReturnValue = AcpiUtStrtoulBase10 (String, Flags); - } + /* Only possible exception from above is a 64-bit overflow */ + AcpiGbl_IntegerBitWidth = OriginalBitWidth; return_ACPI_STATUS (Status); } /******************************************************************************* * - * FUNCTION: AcpiUtStrtoulBase10 + * FUNCTION: AcpiUtImplicitStrtoul64 + * + * PARAMETERS: String - Null terminated input string, + * must be a valid pointer + * + * RETURN: Converted integer + * + * DESCRIPTION: Perform a 64-bit conversion with restrictions placed upon + * an "implicit conversion" by the ACPI specification. Used by + * many ASL operators that require an integer operand, and support + * an automatic (implicit) conversion from a string operand + * to the final integer operand. The major restriction is that + * only hex strings are supported. + * + * ----------------------------------------------------------------------------- + * + * Base is always 16, either with or without the 0x prefix. Decimal and + * Octal strings are not supported, as per the ACPI specification. + * + * Examples (both are hex values): + * Add ("BA98", Arg0, Local0) + * Subtract ("0x12345678", Arg1, Local1) + * + * Conversion rules as extracted from the ACPI specification: + * + * The converted integer is initialized to the value zero. + * The ASCII string is always interpreted as a hexadecimal constant. + * + * 1) According to the ACPI specification, a "0x" prefix is not allowed. + * However, ACPICA allows this as an ACPI extension on general + * principle. (NO ERROR) + * + * 2) The conversion terminates when the size of an integer is reached + * (32 or 64 bits). There are no numeric overflow conditions. (NO ERROR) + * + * 3) The first non-hex character terminates the conversion and returns + * the current accumulated value of the converted integer (NO ERROR). * - * PARAMETERS: String - Null terminated input string - * Flags - Conversion info + * 4) Conversion of a null (zero-length) string to an integer is + * technically not allowed. However, ACPICA allows this as an ACPI + * extension. The conversion returns the value 0. (NO ERROR) * - * RETURN: 64-bit converted integer + * NOTE: There are no error conditions returned by this function. At + * the minimum, a value of zero is returned. * - * DESCRIPTION: Performs a base 10 conversion of the input string to an - * integer value, either 32 or 64 bits. - * Note: String must be valid and non-null. + * Current users of this function: + * + * Interpreter - All runtime implicit conversions, as per ACPI specification + * iASL - Data Table Compiler parser (constants and math expressions) * ******************************************************************************/ -static UINT64 -AcpiUtStrtoulBase10 ( - char *String, - UINT32 Flags) +UINT64 +AcpiUtImplicitStrtoul64 ( + char *String) { - int AsciiDigit; - UINT64 NextValue; - UINT64 ReturnValue = 0; + UINT64 ConvertedInteger = 0; - /* Main loop: convert each ASCII byte in the input string */ - - while (*String) - { - AsciiDigit = *String; - if (!isdigit (AsciiDigit)) - { - /* Not ASCII 0-9, terminate */ + ACPI_FUNCTION_TRACE_STR (UtImplicitStrtoul64, String); - goto Exit; - } - /* Convert and insert (add) the decimal digit */ - - AcpiUtShortMultiply (ReturnValue, 10, &NextValue); - NextValue += (AsciiDigit - ACPI_ASCII_ZERO); - - /* Check for overflow (32 or 64 bit) - return current converted value */ + if (!AcpiUtRemoveWhitespace (&String)) + { + return_VALUE (0); + } - if (((Flags & ACPI_STRTOUL_32BIT) && (NextValue > ACPI_UINT32_MAX)) || - (NextValue < ReturnValue)) /* 64-bit overflow case */ - { - goto Exit; - } + /* + * Per the ACPI specification, only hexadecimal is supported for + * implicit conversions, and the "0x" prefix is "not allowed". + * However, allow a "0x" prefix as an ACPI extension. + */ + AcpiUtDetectHexPrefix (&String); - ReturnValue = NextValue; - String++; + if (!AcpiUtRemoveLeadingZeros (&String)) + { + return_VALUE (0); } -Exit: - return (ReturnValue); + /* + * Ignore overflow as per the ACPI specification. This is implemented by + * ignoring the return status from the conversion function called below. + * On overflow, the input string is simply truncated. + */ + AcpiUtConvertHexString (String, &ConvertedInteger); + return_VALUE (ConvertedInteger); } /******************************************************************************* * - * FUNCTION: AcpiUtStrtoulBase16 + * FUNCTION: AcpiUtExplicitStrtoul64 + * + * PARAMETERS: String - Null terminated input string, + * must be a valid pointer * - * PARAMETERS: String - Null terminated input string - * Flags - conversion info + * RETURN: Converted integer * - * RETURN: 64-bit converted integer + * DESCRIPTION: Perform a 64-bit conversion with the restrictions placed upon + * an "explicit conversion" by the ACPI specification. The + * main restriction is that only hex and decimal are supported. * - * DESCRIPTION: Performs a base 16 conversion of the input string to an - * integer value, either 32 or 64 bits. - * Note: String must be valid and non-null. + * ----------------------------------------------------------------------------- + * + * Base is either 10 (default) or 16 (with 0x prefix). Octal (base 8) strings + * are not supported, as per the ACPI specification. + * + * Examples: + * ToInteger ("1000") Decimal + * ToInteger ("0xABCD") Hex + * + * Conversion rules as extracted from the ACPI specification: + * + * 1) The input string is either a decimal or hexadecimal numeric string. + * A hex value must be prefixed by "0x" or it is interpreted as decimal. + * + * 2) The value must not exceed the maximum of an integer value + * (32 or 64 bits). The ACPI specification states the behavior is + * "unpredictable", so ACPICA matches the behavior of the implicit + * conversion case. There are no numeric overflow conditions. (NO ERROR) + * + * 3) Behavior on the first non-hex character is not defined by the ACPI + * specification (for the ToInteger operator), so ACPICA matches the + * behavior of the implicit conversion case. It terminates the + * conversion and returns the current accumulated value of the converted + * integer. (NO ERROR) + * + * 4) Conversion of a null (zero-length) string to an integer is + * technically not allowed. However, ACPICA allows this as an ACPI + * extension. The conversion returns the value 0. (NO ERROR) + * + * NOTE: There are no error conditions returned by this function. At the + * minimum, a value of zero is returned. + * + * Current users of this function: + * + * Interpreter - Runtime ASL ToInteger operator, as per the ACPI specification * ******************************************************************************/ -static UINT64 -AcpiUtStrtoulBase16 ( - char *String, - UINT32 Flags) +UINT64 +AcpiUtExplicitStrtoul64 ( + char *String) { - int AsciiDigit; - UINT32 ValidDigits = 1; - UINT64 ReturnValue = 0; - + UINT64 ConvertedInteger = 0; + UINT32 Base = 10; /* Default is decimal */ - /* Main loop: convert each ASCII byte in the input string */ - while (*String) - { - /* Check for overflow (32 or 64 bit) - return current converted value */ + ACPI_FUNCTION_TRACE_STR (UtExplicitStrtoul64, String); - if ((ValidDigits > 16) || - ((ValidDigits > 8) && (Flags & ACPI_STRTOUL_32BIT))) - { - goto Exit; - } - AsciiDigit = *String; - if (!isxdigit (AsciiDigit)) - { - /* Not Hex ASCII A-F, a-f, or 0-9, terminate */ - - goto Exit; - } + if (!AcpiUtRemoveWhitespace (&String)) + { + return_VALUE (0); + } - /* Convert and insert the hex digit */ + /* + * Only Hex and Decimal are supported, as per the ACPI specification. + * A "0x" prefix indicates hex; otherwise decimal is assumed. + */ + if (AcpiUtDetectHexPrefix (&String)) + { + Base = 16; + } - AcpiUtShortShiftLeft (ReturnValue, 4, &ReturnValue); - ReturnValue |= AcpiUtAsciiCharToHex (AsciiDigit); + if (!AcpiUtRemoveLeadingZeros (&String)) + { + return_VALUE (0); + } - String++; - ValidDigits++; + /* + * Ignore overflow as per the ACPI specification. This is implemented by + * ignoring the return status from the conversion functions called below. + * On overflow, the input string is simply truncated. + */ + switch (Base) + { + case 10: + default: + AcpiUtConvertDecimalString (String, &ConvertedInteger); + break; + + case 16: + AcpiUtConvertHexString (String, &ConvertedInteger); + break; } -Exit: - return (ReturnValue); + return_VALUE (ConvertedInteger); } diff --git a/source/include/acexcep.h b/source/include/acexcep.h index 6bc741c..1154e73 100644 --- a/source/include/acexcep.h +++ b/source/include/acexcep.h @@ -129,8 +129,12 @@ typedef struct acpi_exception_info #define AE_NOT_CONFIGURED EXCEP_ENV (0x001C) #define AE_ACCESS EXCEP_ENV (0x001D) #define AE_IO_ERROR EXCEP_ENV (0x001E) +#define AE_NUMERIC_OVERFLOW EXCEP_ENV (0x001F) +#define AE_HEX_OVERFLOW EXCEP_ENV (0x0020) +#define AE_DECIMAL_OVERFLOW EXCEP_ENV (0x0021) +#define AE_OCTAL_OVERFLOW EXCEP_ENV (0x0022) -#define AE_CODE_ENV_MAX 0x001E +#define AE_CODE_ENV_MAX 0x0022 /* @@ -263,7 +267,11 @@ static const ACPI_EXCEPTION_INFO AcpiGbl_ExceptionNames_Env[] = EXCEP_TXT ("AE_OWNER_ID_LIMIT", "There are no more Owner IDs available for ACPI tables or control methods"), EXCEP_TXT ("AE_NOT_CONFIGURED", "The interface is not part of the current subsystem configuration"), EXCEP_TXT ("AE_ACCESS", "Permission denied for the requested operation"), - EXCEP_TXT ("AE_IO_ERROR", "An I/O error occurred") + EXCEP_TXT ("AE_IO_ERROR", "An I/O error occurred"), + EXCEP_TXT ("AE_NUMERIC_OVERFLOW", "Overflow during string-to-integer conversion"), + EXCEP_TXT ("AE_HEX_OVERFLOW", "Overflow during ASCII hex-to-binary conversion"), + EXCEP_TXT ("AE_DECIMAL_OVERFLOW", "Overflow during ASCII decimal-to-binary conversion"), + EXCEP_TXT ("AE_OCTAL_OVERFLOW", "Overflow during ASCII octal-to-binary conversion") }; static const ACPI_EXCEPTION_INFO AcpiGbl_ExceptionNames_Pgm[] = diff --git a/source/include/achware.h b/source/include/achware.h index a97ec57..4c940ef 100644 --- a/source/include/achware.h +++ b/source/include/achware.h @@ -77,12 +77,12 @@ AcpiHwValidateRegister ( ACPI_STATUS AcpiHwRead ( - UINT32 *Value, + UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg); ACPI_STATUS AcpiHwWrite ( - UINT32 Value, + UINT64 Value, ACPI_GENERIC_ADDRESS *Reg); ACPI_BIT_REGISTER_INFO * diff --git a/source/include/acinterp.h b/source/include/acinterp.h index 78eaa1a..06f9f31 100644 --- a/source/include/acinterp.h +++ b/source/include/acinterp.h @@ -106,7 +106,7 @@ ACPI_STATUS AcpiExConvertToInteger ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, - UINT32 Flags); + UINT32 ImplicitConversion); ACPI_STATUS AcpiExConvertToBuffer ( @@ -575,9 +575,6 @@ AcpiExStoreObjectToNode ( ACPI_WALK_STATE *WalkState, UINT8 ImplicitConversion); -#define ACPI_IMPLICIT_CONVERSION TRUE -#define ACPI_NO_IMPLICIT_CONVERSION FALSE - /* * exstoren - resolve/store object diff --git a/source/include/acpixf.h b/source/include/acpixf.h index e063533..99473c6 100644 --- a/source/include/acpixf.h +++ b/source/include/acpixf.h @@ -46,7 +46,7 @@ /* Current ACPICA subsystem version in YYYYMMDD format */ -#define ACPI_CA_VERSION 0x20170728 +#define ACPI_CA_VERSION 0x20170831 #include "acconfig.h" #include "actypes.h" diff --git a/source/include/actbl1.h b/source/include/actbl1.h index bd60167..d88cc59 100644 --- a/source/include/actbl1.h +++ b/source/include/actbl1.h @@ -71,6 +71,7 @@ #define ACPI_SIG_HEST "HEST" /* Hardware Error Source Table */ #define ACPI_SIG_MADT "APIC" /* Multiple APIC Description Table */ #define ACPI_SIG_MSCT "MSCT" /* Maximum System Characteristics Table */ +#define ACPI_SIG_PDTT "PDTT" /* Processor Debug Trigger Table */ #define ACPI_SIG_PPTT "PPTT" /* Processor Properties Topology Table */ #define ACPI_SIG_SBST "SBST" /* Smart Battery Specification Table */ #define ACPI_SIG_SLIT "SLIT" /* System Locality Distance Information Table */ @@ -1494,6 +1495,42 @@ typedef struct acpi_nfit_flush_address /******************************************************************************* * + * PDTT - Processor Debug Trigger Table (ACPI 6.2) + * Version 0 + * + ******************************************************************************/ + +typedef struct acpi_table_pdtt +{ + ACPI_TABLE_HEADER Header; /* Common ACPI table header */ + UINT8 TriggerCount; + UINT8 Reserved[3]; + UINT32 ArrayOffset; + +} ACPI_TABLE_PDTT; + + +/* + * PDTT Communication Channel Identifier Structure. + * The number of these structures is defined by TriggerCount above, + * starting at ArrayOffset. + */ +typedef struct acpi_pdtt_channel +{ + UINT16 SubChannelId; + +} ACPI_PDTT_CHANNEL; + + +/* Mask and Flags for above */ + +#define ACPI_PDTT_SUBCHANNEL_ID_MASK 0x00FF +#define ACPI_PDTT_RUNTIME_TRIGGER (1<<8) +#define ACPI_PPTT_WAIT_COMPLETION (1<<9) + + +/******************************************************************************* + * * PPTT - Processor Properties Topology Table (ACPI 6.2) * Version 1 * @@ -1518,7 +1555,8 @@ enum AcpiPpttType /* 0: Processor Hierarchy Node Structure */ -typedef struct acpi_pptt_processor { +typedef struct acpi_pptt_processor +{ ACPI_SUBTABLE_HEADER Header; UINT16 Reserved; UINT32 Flags; @@ -1536,7 +1574,8 @@ typedef struct acpi_pptt_processor { /* 1: Cache Type Structure */ -typedef struct acpi_pptt_cache { +typedef struct acpi_pptt_cache +{ ACPI_SUBTABLE_HEADER Header; UINT16 Reserved; UINT32 Flags; @@ -1568,7 +1607,8 @@ typedef struct acpi_pptt_cache { /* 2: ID Structure */ -typedef struct acpi_pptt_id { +typedef struct acpi_pptt_id +{ ACPI_SUBTABLE_HEADER Header; UINT16 Reserved; UINT32 VendorId; diff --git a/source/include/actbl2.h b/source/include/actbl2.h index a618a1f..e2b4830 100644 --- a/source/include/actbl2.h +++ b/source/include/actbl2.h @@ -922,6 +922,7 @@ typedef struct acpi_iort_smmu_gsi UINT32 NSgIrptFlags; UINT32 NSgCfgIrpt; UINT32 NSgCfgIrptFlags; + } ACPI_IORT_SMMU_GSI; diff --git a/source/include/acutils.h b/source/include/acutils.h index 1450b85..3049617 100644 --- a/source/include/acutils.h +++ b/source/include/acutils.h @@ -142,6 +142,10 @@ extern const char *AcpiGbl_PtypDecode[]; #define ACPI_MSG_SUFFIX \ AcpiOsPrintf (" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, ModuleName, LineNumber) +/* Flags to indicate implicit or explicit string-to-integer conversion */ + +#define ACPI_IMPLICIT_CONVERSION TRUE +#define ACPI_NO_IMPLICIT_CONVERSION FALSE /* Types for Resource descriptor entries */ @@ -222,19 +226,57 @@ AcpiUtStricmp ( char *String1, char *String2); + +/* + * utstrsuppt - string-to-integer conversion support functions + */ ACPI_STATUS -AcpiUtStrtoul64 ( +AcpiUtConvertOctalString ( char *String, - UINT32 Flags, - UINT64 *RetInteger); + UINT64 *ReturnValue); + +ACPI_STATUS +AcpiUtConvertDecimalString ( + char *String, + UINT64 *ReturnValuePtr); + +ACPI_STATUS +AcpiUtConvertHexString ( + char *String, + UINT64 *ReturnValuePtr); + +char +AcpiUtRemoveWhitespace ( + char **String); + +char +AcpiUtRemoveLeadingZeros ( + char **String); + +BOOLEAN +AcpiUtDetectHexPrefix ( + char **String); + +BOOLEAN +AcpiUtDetectOctalPrefix ( + char **String); + /* - * Values for Flags above - * Note: LIMIT values correspond to AcpiGbl_IntegerByteWidth values (4/8) + * utstrtoul64 - string-to-integer conversion functions */ -#define ACPI_STRTOUL_32BIT 0x04 /* 4 bytes */ -#define ACPI_STRTOUL_64BIT 0x08 /* 8 bytes */ -#define ACPI_STRTOUL_BASE16 0x10 /* Default: Base10/16 */ +ACPI_STATUS +AcpiUtStrtoul64 ( + char *String, + UINT64 *RetInteger); + +UINT64 +AcpiUtExplicitStrtoul64 ( + char *String); + +UINT64 +AcpiUtImplicitStrtoul64 ( + char *String); /* diff --git a/source/tools/acpidump/apdump.c b/source/tools/acpidump/apdump.c index 9cc5613..f9932d9 100644 --- a/source/tools/acpidump/apdump.c +++ b/source/tools/acpidump/apdump.c @@ -326,8 +326,7 @@ ApDumpTableByAddress ( /* Convert argument to an integer physical address */ - Status = AcpiUtStrtoul64 (AsciiAddress, ACPI_STRTOUL_64BIT, - &LongAddress); + Status = AcpiUtStrtoul64 (AsciiAddress, &LongAddress); if (ACPI_FAILURE (Status)) { fprintf (stderr, "%s: Could not convert to a physical address\n", diff --git a/source/tools/acpidump/apmain.c b/source/tools/acpidump/apmain.c index 4bc561a..54f992d 100644 --- a/source/tools/acpidump/apmain.c +++ b/source/tools/acpidump/apmain.c @@ -235,8 +235,7 @@ ApDoOptions ( case 'r': /* Dump tables from specified RSDP */ - Status = AcpiUtStrtoul64 (AcpiGbl_Optarg, ACPI_STRTOUL_64BIT, - &Gbl_RsdpBase); + Status = AcpiUtStrtoul64 (AcpiGbl_Optarg, &Gbl_RsdpBase); if (ACPI_FAILURE (Status)) { fprintf (stderr, "%s: Could not convert to a physical address\n", diff --git a/source/tools/acpiexec/aeinitfile.c b/source/tools/acpiexec/aeinitfile.c index 1a85bf5..dcd6b3d 100644 --- a/source/tools/acpiexec/aeinitfile.c +++ b/source/tools/acpiexec/aeinitfile.c @@ -203,8 +203,7 @@ AeDoOneOverride ( /* Extract the 64-bit integer */ - Status = AcpiUtStrtoul64 (ValueString, - (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &Value); + Status = AcpiUtStrtoul64 (ValueString, &Value); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("%s %s\n", ValueString, diff --git a/source/tools/acpiexec/aemain.c b/source/tools/acpiexec/aemain.c index 02ca687..f51dc01 100644 --- a/source/tools/acpiexec/aemain.c +++ b/source/tools/acpiexec/aemain.c @@ -490,11 +490,6 @@ main ( goto ErrorExit; } - /* ACPICA runtime configuration */ - - AcpiGbl_MaxLoopIterations = 400; - - /* Initialize the AML debugger */ Status = AcpiInitializeDebugger (); diff --git a/source/tools/acpiexec/aetables.c b/source/tools/acpiexec/aetables.c index e837458..8fa2724 100644 --- a/source/tools/acpiexec/aetables.c +++ b/source/tools/acpiexec/aetables.c @@ -490,6 +490,14 @@ AeInstallTables ( Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE); ACPI_CHECK_OK (AcpiInitializeTables, Status); + /* + * The following code is prepared to test the deferred table + * verification mechanism. When AcpiGbl_EnableTableValidation is set + * to FALSE by default, AcpiReallocateRootTable() sets it back to TRUE + * and triggers the deferred table verification mechanism accordingly. + */ + (void) AcpiReallocateRootTable (); + if (AcpiGbl_LoadTestTables) { /* Test multiple table/UEFI support. First, get the headers */ diff --git a/source/tools/acpisrc/acpisrc.h b/source/tools/acpisrc/acpisrc.h index 5a6fdac..3e8886d 100644 --- a/source/tools/acpisrc/acpisrc.h +++ b/source/tools/acpisrc/acpisrc.h @@ -122,6 +122,7 @@ extern BOOLEAN Gbl_IgnoreLoneLineFeeds; extern BOOLEAN Gbl_HasLoneLineFeeds; extern BOOLEAN Gbl_Cleanup; extern BOOLEAN Gbl_IgnoreTranslationEscapes; +extern BOOLEAN Gbl_CheckAscii; extern void *Gbl_StructDefs; #define PARAM_LIST(pl) pl diff --git a/source/tools/acpisrc/asfile.c b/source/tools/acpisrc/asfile.c index 465b12b..c3bf277 100644 --- a/source/tools/acpisrc/asfile.c +++ b/source/tools/acpisrc/asfile.c @@ -59,6 +59,11 @@ AsDetectLoneLineFeeds ( char *Filename, char *Buffer); +static BOOLEAN +AsCheckForNonPrintableChars ( + char *FileBuffer, + UINT32 FileSize); + static ACPI_INLINE int AsMaxInt (int a, int b) { @@ -528,6 +533,45 @@ AsConvertFile ( } } +/******************************************************************************* + * + * FUNCTION: AsCheckForNonPrintableChars + * + * PARAMETERS: FileBuffer - Buffer with contents of entire file + * FileSize - Size of the file and buffer + * + * RETURN: TRUE if there are no non-printable characters + * + * DESCRIPTION: Scan a file for any non-printable ASCII bytes. + * + ******************************************************************************/ + +static BOOLEAN +AsCheckForNonPrintableChars ( + char *FileBuffer, + UINT32 FileSize) +{ + BOOLEAN Found = TRUE; + UINT8 Byte; + UINT32 i; + + + /* Scan entire file for any non-printable characters */ + + for (i = 0; i < FileSize; i++) + { + Byte = FileBuffer[i]; + if (!isprint (Byte) && !isspace (Byte)) + { + printf ( "Non-printable character (0x%2.2X) " + "at file offset: %8u (0x%X)\n", Byte, i, i); + Found = FALSE; + } + } + + return (Found); +} + /****************************************************************************** * @@ -572,13 +616,20 @@ AsProcessOneFile ( } strcat (Pathname, Filename); - if (AsGetFile (Pathname, &Gbl_FileBuffer, &Gbl_FileSize)) { Status = -1; goto Exit1; } + /* Exit now if simply checking the file for printable ascii chars */ + + if (Gbl_CheckAscii) + { + Status = 0; + goto Exit2; + } + Gbl_HeaderSize = 0; if (strstr (Filename, ".asl")) { @@ -765,6 +816,19 @@ AsGetFile ( Buffer [Size] = 0; /* Null terminate the buffer */ fclose (File); + /* This option checks the entire file for non-printable chars */ + + if (Gbl_CheckAscii) + { + if (AsCheckForNonPrintableChars (Buffer, Size)) + { + printf ("File contains only printable ASCII characters\n"); + } + + free (Buffer); + return (0); + } + /* Check for unix contamination */ Gbl_HasLoneLineFeeds = AsDetectLoneLineFeeds (Filename, Buffer); @@ -783,7 +847,6 @@ ErrorFree: free (Buffer); ErrorExit: - fclose (File); return (-1); } diff --git a/source/tools/acpisrc/asmain.c b/source/tools/acpisrc/asmain.c index ef89f64..f408659 100644 --- a/source/tools/acpisrc/asmain.c +++ b/source/tools/acpisrc/asmain.c @@ -80,6 +80,7 @@ struct stat Gbl_StatBuf; char *Gbl_FileBuffer; UINT32 Gbl_FileSize; UINT32 Gbl_FileType; +BOOLEAN Gbl_CheckAscii = FALSE; BOOLEAN Gbl_VerboseMode = FALSE; BOOLEAN Gbl_QuietMode = FALSE; BOOLEAN Gbl_BatchMode = FALSE; @@ -93,7 +94,7 @@ BOOLEAN Gbl_Cleanup = FALSE; BOOLEAN Gbl_IgnoreTranslationEscapes = FALSE; #define AS_UTILITY_NAME "ACPI Source Code Conversion Utility" -#define AS_SUPPORTED_OPTIONS "cdhilqsuv^y" +#define AS_SUPPORTED_OPTIONS "acdhilqsuv^y" /****************************************************************************** @@ -253,6 +254,7 @@ AsDisplayUsage ( ACPI_USAGE_HEADER ("acpisrc [-c|l|u] [-dsvy] "); + ACPI_OPTION ("-a ", "Check entire file for non-printable characters"); ACPI_OPTION ("-c", "Generate cleaned version of the source"); ACPI_OPTION ("-h", "Insert dual-license header into all modules"); ACPI_OPTION ("-i", "Cleanup macro indentation"); @@ -397,6 +399,11 @@ main ( Gbl_QuietMode = TRUE; break; + case 'a': + + Gbl_CheckAscii = TRUE; + break; + default: AsDisplayUsage (); @@ -412,6 +419,14 @@ main ( return (-1); } + /* This option checks the entire file for printable ascii chars */ + + if (Gbl_CheckAscii) + { + AsProcessOneFile (NULL, NULL, NULL, 0, SourcePath, FILE_TYPE_SOURCE); + return (0); + } + TargetPath = argv[AcpiGbl_Optind+1]; if (!ConversionTable) @@ -450,6 +465,13 @@ main ( } else { + if (Gbl_CheckAscii) + { + AsProcessOneFile (NULL, NULL, NULL, 0, + SourcePath, FILE_TYPE_SOURCE); + return (0); + } + /* Process a single file */ /* Differentiate between source and header files */ diff --git a/tests/aslts.sh b/tests/aslts.sh index 7ad7199..8df422f 100755 --- a/tests/aslts.sh +++ b/tests/aslts.sh @@ -116,15 +116,13 @@ run_aslts() { version=`$ASL | grep version | awk '{print $5}'` rm -rf $ASLTSDIR/tmp/aml/$version - if [ "x$TEST_CASES" = "x" ]; then - # Compile all ASL test modules - Do 0 aslts $EXECONLY - if [ $? -ne 0 ]; then - echo "ASLTS Compile Failure" - exit 1 - fi - else - Do 0 $TEST_CASES $EXECONLY + if [ "x$TEST_MODES" = "x" ]; then + TEST_MODES="n32 n64 o32 o64" + fi + Do 0 $TEST_MODES $TEST_CASES $EXECONLY + if [ $? -ne 0 ]; then + echo "ASLTS Compile Failure" + exit 1 fi # Execute the test suite diff --git a/tests/aslts/Makefile.def b/tests/aslts/Makefile.def index ab55a17..56b2e6c 100644 --- a/tests/aslts/Makefile.def +++ b/tests/aslts/Makefile.def @@ -22,13 +22,39 @@ # nopt/32 | -oa | -r 1 # nopt/64 | -oa | -r 2 -SETOF_INDEXES= 0 1 2 3 -SETOF_AMLDIRS= nopt/32 nopt/64 opt/32 opt/64 -SETOF_ASLFAGS= "-oa -r 1" "-oa -r 2" "-r 1" "-r 2" -COMMON_ASL_FLAGS= "-of -cr -vs -l -sc -sa -ic -ta -ts -so -lm -ln -ls -li" - -COMPILER_LOG="$(TOP)/tmp/aml/$(aslversion)/compile.txt" -COMPILER_ERROR_LOG="$(TOP)/tmp/aml/$(aslversion)/error.txt" +ifndef ASLTS_AMLDIR +ifeq ("$(ASLTS_MODE)", "n32") + ASLTS_AMLDIR=nopt/32 + ASLTS_ASLFLAGS="-oa -r 1" +endif +ifeq ("$(ASLTS_MODE)", "n64") + ASLTS_AMLDIR=nopt/64 + ASLTS_ASLFLAGS="-oa -r 2" +endif +ifeq ("$(ASLTS_MODE)", "o32") + ASLTS_AMLDIR=opt/32 + ASLTS_ASLFLAGS="-r 1" +endif +ifeq ("$(ASLTS_MODE)", "o64") + ASLTS_AMLDIR=opt/64 + ASLTS_ASLFLAGS="-r 2" +endif +ifeq ("$(ASLTS_MODE)", "aslminus") + ASLTS_AMLDIR=aslminus/ + ASLTS_ASLFLAGS="-oa -r 2" +endif +ifeq ("$(ASLTS_MODE)", "aslplus") + ASLTS_AMLDIR=aslplus/ + ASLTS_ASLFLAGS="-oa -r 2" +endif +endif +ASLTS_VER ?= $(ASLTS_VER) + +COMMON_NO_OUTPUT_ASL_FLAGS= "-of -cr -vs" +COMMON_ASL_FLAGS= $(COMMON_NO_OUTPUT_ASL_FLAGS)" -l -sc -sa -ic -ta -ts -so -lm -ln -ls -li" + +COMPILER_LOG="$(TOP)/tmp/aml/$(ASLTS_VER)/compile.txt" +COMPILER_ERROR_LOG="$(TOP)/tmp/aml/$(ASLTS_VER)/error.txt" # Create general directory @@ -42,125 +68,57 @@ ASLMOD= MAIN empty_all: FORCE # Rule to create directories located into aslts/tmp/aml; -# aslversion is determined dynamically. -${SETOF_AMLDIRS:%=$(TOP)/tmp/aml/$(aslversion)/%}: +$(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR): @$(INST.dir) # Make-install one particular Test Case for all modes -install_all_modes_of_test_case: ${SETOF_AMLDIRS:%=$(TOP)/tmp/aml/$(aslversion)/%} +install_all_modes_of_test_case: $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR) @rval=0; \ if [ -f "$(ASL)" ]; then \ dd=`pwd`; \ echo "---- Test path: $$dd" >> $(COMPILER_LOG); \ echo "---- Test path: $$dd" >> $(COMPILER_ERROR_LOG); \ >&2 echo "Test path: $$dd"; \ - for i in ${SETOF_INDEXES}; do \ - set -- $(SETOF_AMLDIRS); \ - shift $$i; \ - CUR_AMLDIR=$$1; \ - set -- $(SETOF_ASLFAGS); \ - shift $$i; \ - CUR_ASLFLAGS=$$1; \ - echo "---- Test type: $$CUR_AMLDIR (Flags $(COMMON_ASL_FLAGS) $$CUR_ASLFLAGS $(ADD_ASLFLAGS))" >> $(COMPILER_LOG); \ - echo "---- Test type: $$CUR_AMLDIR (Flags $(COMMON_ASL_FLAGS) $$CUR_ASLFLAGS $(ADD_ASLFLAGS))" >> $(COMPILER_ERROR_LOG); \ - for j in ${AMLMOD}; do \ - rm -f $$j.aml; \ - done; \ - for j in ${ASLMOD} $(ASLMODADD); do \ - echo "---- Compile: $$j.asl" >> $(COMPILER_LOG); \ - >&2 printf "%-18s" " Type: $$CUR_AMLDIR "; \ - >&2 printf "Compile"; \ - "$(ASL)" $$CUR_ASLFLAGS "$(COMMON_ASL_FLAGS)" $(ADD_ASLFLAGS) $$j.asl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ - ret=$$?; \ - echo "" >> $(COMPILER_LOG); \ - if [ $(OPT) -eq 0 ] && [ "x$(ADD_ASLFLAGS)" != "x-f" ]; then \ - for k in ${AMLMOD}; do \ - >&2 printf " => Compile Ext in-place"; \ - "$(ASL)" -p $$k-extInPlace -oE $$CUR_ASLFLAGS "$(COMMON_ASL_FLAGS)" $(ADD_ASLFLAGS) $$j.asl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ - if [ ! -f $$k-extInPlace.aml ]; then \ - >&2 printf " [[ Error: disassembly failed of $$k.aml failed ]]\n"; \ - >&2 printf " Flags used: -p $$k-aslminus -oE -cr -vs $$CUR_ASLFLAGS $(ADD_ASLFLAGS) -od -dl\n\n"; \ - #exit 1; \ - fi; \ - >&2 printf " => Disassemble"; \ - echo "---- Diasassemble: $$k.aml" >> $(COMPILER_LOG); \ - echo "---- Diasassemble: $$k.aml" >> $(COMPILER_ERROR_LOG); \ - "$(ASL)" -p $$k-aslminus -oe -cr -vs $$CUR_ASLFLAGS $(ADD_ASLFLAGS) -od -dl $$k-extInPlace.aml >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ - if [ ! -f $$k-aslminus.dsl ]; then \ - >&2 printf " [[ Error: disassembly failed of $$k.aml failed ]]\n"; \ - >&2 printf " Flags used: -p $$k-aslminus -cr -vs $$CUR_ASLFLAGS $(ADD_ASLFLAGS) -od -dl\n\n"; \ - #exit 1; \ - fi; \ - >&2 printf " => Recompile"; \ - echo "---- Recompile: $$k.dsl" >> $(COMPILER_LOG); \ - echo "---- Recompile: $$k.dsl" >> $(COMPILER_ERROR_LOG); \ - "$(ASL)" $$CUR_ASLFLAGS "$(COMMON_ASL_FLAGS)" $(ADD_ASLFLAGS) $$k-aslminus.dsl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ - if [ ! -f $$k-aslminus.aml ]; then \ - >&2 printf " [[ Error: re-compilation of $$k-aslminus.dsl failed]]\n"; \ - >&2 printf " Flags used: $$CUR_ASLFLAGS "$(COMMON_ASL_FLAGS)" $(ADD_ASLFLAGS)\n\n"; \ - #exit 1; \ - fi; \ - if [ $$CUR_AMLDIR = "nopt/32" ] || [ $$CUR_AMLDIR = "nopt/64" ]; then \ - >&2 printf " => Binary compare"; \ - rm -f comparison_output.txt; \ - acpibin -c $$k.aml $$k-aslminus.aml >> comparison_output.txt; \ - if [ $$? != 0 ]; then \ - >&2 printf " [[ Error: comparison of $$k.aml and $$k-aslminus.aml do not match ]]"; \ - cat comparison_output.txt | sed '1,/^Error/d' | sed 's/Error - Byte mismatch at offset / => /g' | sed -n 1,10p > comparison_output.txt;\ - >&2 printf "\n"; \ - cat comparison_output.txt >&2 ; \ - >&2 printf " "; \ - #exit 1; \ - else \ - >&2 printf " => Success!"; \ - rm comparison_output.txt; \ - fi; \ - fi; \ - if [ ! -f comparison_output.txt ]; then \ - >&2 printf " => Removing files"; \ - rm $$k-aslminus.lst; \ - rm $$k-aslminus.aml; \ - rm $$k-aslminus.dsl; \ - fi; \ - for n in "$$k-aslminus" "$$k-extInPlace"; do \ - rm $$n.i $$n.asm $$n.nsp; \ - rm $$n.c $$n.hex $$n.map; \ - rm $$n.h $$n.src $$n.offset.h; \ - done; \ - rm $$k-extInPlace.aml; \ - rm $$k-extInPlace.lst; \ - >&2 printf " => Done"; \ - done; \ - fi; \ - >&2 printf " => Removing files"; \ - rm $$j.asm; \ - rm $$j.c; \ - rm $$j.h; \ - rm $$j.i; \ - rm $$j.hex; \ - rm $$j.lst; \ - rm $$j.map; \ - rm $$j.nsp; \ - rm $$j.offset.h; \ - rm $$j.src; \ - >&2 printf " => Done"; \ - if [ $$ret != 0 ]; then \ - rval=1; \ - >&2 echo "**** Unexpected iASL failure in $$dd/$$j.asl!"; \ - exit 1; \ - fi; \ - done; \ - >&2 echo ""; \ - if [ $$ret != 0 ]; then break; fi; \ - for j in ${AMLMOD}; do \ - ls -l $$j.aml >> $(COMPILER_LOG); \ - echo "---- Move: $$j.aml $(TOP)/tmp/aml/$(aslversion)/$$CUR_AMLDIR" >> $(COMPILER_LOG); \ - mv $$j.aml $(TOP)/tmp/aml/$(aslversion)/$$CUR_AMLDIR; \ - ret=$$?; \ - if [ $$ret != 0 ]; then rval=2; echo "**** mv failed!" >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); break; fi; \ - done; \ + echo "---- Test type: $(ASLTS_AMLDIR) (Flags $(COMMON_ASL_FLAGS) $(ASLTS_ASLFLAGS) $(ADD_ASLFLAGS))" >> $(COMPILER_LOG); \ + echo "---- Test type: $(ASLTS_AMLDIR) (Flags $(COMMON_ASL_FLAGS) $(ASLTS_ASLFLAGS) $(ADD_ASLFLAGS))" >> $(COMPILER_ERROR_LOG); \ + for j in ${AMLMOD}; do \ + rm -f $$j.aml; \ + done; \ + for j in ${ASLMOD} $(ASLMODADD); do \ + echo "---- Compile: $$j.asl" >> $(COMPILER_LOG); \ + >&2 printf "%-18s" " Type: $(ASLTS_AMLDIR) "; \ + >&2 printf "Compile"; \ + "$(ASL)" $(ASLTS_ASLFLAGS) "$(COMMON_ASL_FLAGS)" $(ADD_ASLFLAGS) $$j.asl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ + ret=$$?; \ + echo "" >> $(COMPILER_LOG); \ + >&2 printf " => Removing files"; \ + rm $$j.asm; \ + rm $$j.c; \ + rm $$j.h; \ + rm $$j.i; \ + rm $$j.hex; \ + rm $$j.lst; \ + rm $$j.map; \ + rm $$j.nsp; \ + rm $$j.offset.h; \ + rm $$j.src; \ + >&2 printf " => Done"; \ + if [ $$ret != 0 ]; then \ + rval=1; \ + >&2 echo "**** Unexpected iASL failure in $$dd/$$j.asl!"; \ + exit 1; \ + fi; \ + done; \ + >&2 echo ""; \ + if [ $$ret != 0 ]; then break; fi; \ + for j in ${AMLMOD}; do \ + ls -l $$j.aml >> $(COMPILER_LOG); \ + echo "---- Move: $$j.aml $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR)" >> $(COMPILER_LOG); \ + mv $$j.aml $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR); \ + ret=$$?; \ + if [ $$ret != 0 ]; then rval=2; echo "**** mv failed!" >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); break; fi; \ done; \ else \ echo "Bad iASL 0: <$(ASL)> does not exist"; \ @@ -169,65 +127,77 @@ install_all_modes_of_test_case: ${SETOF_AMLDIRS:%=$(TOP)/tmp/aml/$(aslversion)/% if [ $$rval != 0 ]; then exit 1; fi # Make-install one particular Test Case for all modes. -# Move results to aslts/tmp/aml directory. -# Determine current version of iASL. -# Create aslts/tmp/aml/ directory with the precautions. install_test_case: @if [ ! -f "$(ASL)" ]; then \ echo "Bad iASL 1: <$(ASL)> does not exist"; exit 1; \ + fi; \ + if [ "$(ASLTS_MODE)" = "aslminus" ]; then \ + make install_disasm_test_case DISASM_FLAG="-dl" ASLTS_MODE=$(ASLTS_MODE) ASLTS_VER=$(ASLTS_VER); \ + elif [ "$(ASLTS_MODE)" = "aslplus" ]; then \ + make install_disasm_test_case DISASM_FLAG="-d" ASLTS_MODE=$(ASLTS_MODE) ASLTS_VER=$(ASLTS_VER); \ else \ - aslversion=""; \ - testcasedir=`pwd`; \ - cd $(TOP); \ - if [ $$? -ne 0 ]; then \ - echo "Bad dir: $(TOP)"; exit 1; \ - else \ - dd=`pwd`; \ - base=`basename "$$dd"`; \ - if [ x$$base != xaslts ]; then \ - echo "Bad base name of ASLTS Test Suite: <$$base> of <$$dd>"; exit 1; \ - else \ - x=`"$(ASL)" -va xxx | grep "Compiler/Disassembler version"`; \ - echo "---- iASL version: $$x"; \ - if [ -z "$$x" ]; then \ - echo "Bad iASL 2: bad signon <$(ASL)>"; exit 1; \ - else \ - aslversion=`echo "$$x" | awk -F" " '{ print $$5}'`; \ - if [ -z "$$aslversion" ]; then \ - echo "Bad iASL 3: could not get version <$(ASL)>"; exit 1; \ - else \ - if [ ! -d ./tmp ]; then \ - mkdir tmp; \ - fi; \ - cd ./tmp; \ - if [ $$? -ne 0 ]; then \ - echo "Bad dir: aslts/tmp"; exit 1; \ - else \ - if [ ! -d ./aml ]; then \ - mkdir aml; \ - fi; \ - cd ./aml; \ - if [ $$? -ne 0 ]; then \ - echo "Bad dir: aslts/tmp/aml"; exit 1; \ - else \ - if [ ! -d "./$$aslversion" ]; then \ - mkdir $$aslversion; \ - fi; \ - cd ./$$aslversion; \ - if [ $$? -ne 0 ]; then \ - echo "Bad dir: aslts/tmp"; exit 1; \ - else \ - cd "$$testcasedir"; \ - export aslversion; make install_all_modes_of_test_case OPT=$(OPT); \ - fi; \ - fi; \ - fi; \ - fi; \ - fi; \ + make install_all_modes_of_test_case ASLTS_MODE=$(ASLTS_MODE) ASLTS_VER=$(ASLTS_VER); \ + fi + + +TEST_SEQUENCE_ASL_FLAGS="$(ASLTS_ASLFLAGS) $(COMMON_NO_OUTPUT_ASL_FLAGS) $(ADD_ASLFLAGS)" + +disasm_test_compile: $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR) + @rval=0; \ + for j in ${ASLMOD} $(ASLMODADD); do \ + for k in ${AMLMOD}; do \ + >&2 printf " => Compile Ext in-place"; \ + "$(ASL)" -p $$k-extInPlace -oE $(TEST_SEQUENCE_ASL_FLAGS) $$j.asl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ + ret=$$?; \ + if [ $$ret != 0 ]; then \ + rval=2; \ + >&2 printf " [[ Error: compiling $$k.aml with externals in place failed ]]\n"; \ + >&2 printf " Flags used: -p $$k-extInPlace -oE $(TEST_SEQUENCE_ASL_FLAGS)\n\n"; \ fi; \ + done; \ + done; \ + if [ $$rval != 0 ]; then exit 1; fi + +disasm_test_disassemble: disasm_test_compile + @rval=0; \ + for k in ${AMLMOD}; do \ + >&2 printf " => Disassemble"; \ + "$(ASL)" -p $$k -oe -od $(COMMON_NO_OUTPUT_ASL_FLAGS) $(ADD_ASLFLAGS) $(DISASM_FLAG) $$k-extInPlace.aml >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ + ret=$$?; \ + if [ $$ret != 0 ]; then \ + retval=2; \ + >&2 printf " [[ Error: disassembly of $$k-extInPlace.aml failed ]]\n"; \ + >&2 printf " Flags used: -oe -od $(COMMON_NO_OUTPUT_ASL_FLAGS) $(ADD_ASLFLAGS) $(DISASM_FLAG)\n\n"; \ fi; \ - fi + done; \ + if [ $$rval != 0 ]; then exit 1; fi + +disasm_test_recompile: disasm_test_disassemble + @rval=0; \ + for k in ${AMLMOD}; do \ + >&2 printf " => Recompile\n"; \ + "$(ASL)" $(TEST_SEQUENCE_ASL_FLAGS) $$k.dsl >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); \ + ret=$$?; \ + if [ $$ret != 0 ]; then \ + rval=2; \ + >&2 printf " [[ Error: re-compilation of $$k-$$l.dsl failed]]\n"; \ + >&2 printf " Flags used: $(TEST_SEQUENCE_ASL_FLAGS)\n\n"; \ + fi; \ + rm $$k.dsl; \ + echo "---- Move: $$k.aml $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR)" >> $(COMPILER_LOG); \ + mv $$k.aml $(TOP)/tmp/aml/$(ASLTS_VER)/$(ASLTS_AMLDIR); \ + ret=$$?; \ + if [ $$ret != 0 ]; then rval=2; echo "**** mv failed!" >> $(COMPILER_LOG) 2>> $(COMPILER_ERROR_LOG); break; fi; \ + done; \ + +install_disasm_test_case: + if [ "x$(ADD_ASLFLAGS)" != "x-f" ]; then \ + make disasm_test_recompile; \ + make clean; \ + else \ + >&2 echo "Skipping disassembler test for this test case"; \ + fi; # Compile one particular Test Case for all modes. # No moving results to aslts/tmp/aml directory. @@ -238,18 +208,10 @@ compile_test_case: echo "Compile_test_case" if [ -f "$(ASL)" ]; then \ - for i in ${SETOF_INDEXES}; do \ - set -- $(SETOF_AMLDIRS); \ - shift $$i; \ - CUR_AMLDIR=$$1; \ - set -- $(SETOF_ASLFAGS); \ - shift $$i; \ - CUR_ASLFLAGS=$$1; \ - for j in ${ASLMOD} $(ASLMODADD); do \ - "$(ASL)" $$CUR_ASLFLAGS $(ADD_ASLFLAGS) $$j.asl; \ - ret=$$?; \ - if [ $$ret != 0 ]; then rval=1; echo "**** Unexpected iASL failure!"; exit 1; fi; \ - done; \ + for j in ${ASLMOD} $(ASLMODADD); do \ + "$(ASL)" $(ASLTS_ASLFLAGS) $(ADD_ASLFLAGS) $$j.asl; \ + ret=$$?; \ + if [ $$ret != 0 ]; then rval=1; echo "**** Unexpected iASL failure!"; exit 1; fi; \ done; \ else \ echo "Bad iASL 4: <$(ASL)> does not exist"; \ diff --git a/tests/aslts/Makefile.switch b/tests/aslts/Makefile.switch index 04fcbc3..3a449da 100644 --- a/tests/aslts/Makefile.switch +++ b/tests/aslts/Makefile.switch @@ -1,5 +1,7 @@ # common switch make +ASLTS_VER ?= 00000000 + all: ${MDIRS} ${MDIRS}: FORCE @cd $@; pwd; make @@ -12,19 +14,33 @@ install: FORCE else \ pwd; \ >&2 echo "Begin compiling test package: [$$d]"; \ - if ($(MAKE) install); then \ - :; \ - else \ + $(MAKE) install ASLTS_MODE=$(ASLTS_MODE) ASLTS_VER=$(ASLTS_VER); \ + if [ $$? -ne 0 ]; then \ r=1; \ false; \ fi; \ fi); \ - if [ $$r -ne 0 ]; then \ - exit $r; \ - fi; \ - >&2 echo "Compiled test package: [$$d]"; \ + if [ $$r -ne 0 ]; then \ + exit $r; \ + fi; \ + >&2 echo "Compiled test package: [$$d]"; \ done +install_n32: + $(MAKE) install ASLTS_MODE=n32 ASLTS_VER=$(ASLTS_VER) +install_n64: + $(MAKE) install ASLTS_MODE=n64 ASLTS_VER=$(ASLTS_VER) +install_o32: + $(MAKE) install ASLTS_MODE=o32 ASLTS_VER=$(ASLTS_VER) +install_o64: + $(MAKE) install ASLTS_MODE=o64 ASLTS_VER=$(ASLTS_VER) +install_aslminus: + $(MAKE) install ASLTS_MODE=aslminus ASLTS_VER=$(ASLTS_VER) +install_aslplus: + $(MAKE) install ASLTS_MODE=aslplus ASLTS_VER=$(ASLTS_VER) + +install_all: install_n32 install_n64 install_o32 install_o64 install_aslminus install_aslplus + clean: FORCE @for d in ${MDIRS}; do \ (cd $$d; \ diff --git a/tests/aslts/bin/Do b/tests/aslts/bin/Do index 5001d36..c7e26b8 100755 --- a/tests/aslts/bin/Do +++ b/tests/aslts/bin/Do @@ -295,31 +295,138 @@ do_bdemo_table() bdemostabs "$DIR0" "$DIR1" "$ALLBUGS" "$KBSUM" "$LBSUM" "$BUG_STATE_DIR" } - -# Make-install all the provided test cases -# (make install from aslts directory) -# arg1 - root directory of aslts -make_install_1() +make_target() { - local dir restore_dir diasm + local dir restore_dir mode options aslversion restore_dir=$PWD - dir="$1" - execonly=$2 + target=$1 + dir="$2" + mode=$3 + aslversion=`get_iasl_version` cd "$dir" - echo "Running make install from $dir" - if [ "$execonly" = "yes" ]; then - make install OPT=1 > /dev/null - else - make install OPT=0 > /dev/null + echo "Running make $target from $dir" + options="ASLTS_VER=$aslversion" + if [ ! -z $mode ]; then + options="$options ASLTS_MODE=$mode" fi + make $target $options > /dev/null + res=$? + + cd "$restore_dir" + return $res +} + + +binary_compare() +{ + mode=$1 + aslversion=`get_iasl_version` + + disasm_compile_dir="$ASLTSDIR/tmp/aml/$aslversion/$mode" + normal_compile_dir="$ASLTSDIR/tmp/aml/$aslversion/nopt/64" + if [ ! -d $disasm_compile_dir ]; then + echo "$dism_compile_dir does not exist. Aborting binary compare" + return; + fi + if [ ! -d $normal_compile_dir ]; then + echo "$normal_compile_dir does not exist. Aborting binary compare" + return; + fi + for f in $disasm_compile_dir/* + do + filename=`basename $f` + acpibin -a "$f" "$normal_compile_dir/$filename" > /dev/null + if [ $? -ne 0 ]; then + echo "[[ Error: $mode Binary compare for $filename failed ]]" + else + echo "$mode Binary compare for $filename passed" + fi + done +} + +make_install() +{ + local res=0 nres=0 + execonly=$2 + + if [ $ENABLENORM32 != 0 ]; then + echo "Make n32" + make_target install "$1" "n32" + nres=$? + if [ $nres -ne 0 ]; then + res=$nres + fi + fi + if [ $ENABLENORM64 != 0 ]; then + echo "Make n64" + make_target install "$1" "n64" + nres=$? + if [ $nres -ne 0 ]; then + res=$nres + fi + fi + if [ $ENABLEOPT32 != 0 ]; then + echo "Make s32" + make_target install "$1" "o32" + nres=$? + if [ $nres -ne 0 ]; then + res=$nres + fi + fi + if [ $ENABLEOPT64 != 0 ]; then + echo "Make s64" + make_target install "$1" "o64" + nres=$? + if [ $nres -ne 0 ]; then + res=$nres + fi + fi + if [ "x$execonly" = "xno" ]; then + # for binary compare, we need to compare with normal 64 bit aml + # files build n64 mode normal 64 bit aml files build n64 mode + # if this test run does not include it. + if [ $ENABLENORM64 -eq 0 ]; then + echo "Make n64" + make_target install "$1" "n64" + nres=$? + if [ $nres -ne 0 ]; then + res=$nres + fi + fi + echo "Make ASL plus" + make_target install "$1" "aslplus" + nres=$? + binary_compare "aslplus" + nres=$(($nres+ $?)) + if [ $nres -ne 0 ]; then + res=$nres + fi + echo "Make ASL minus" + make_target install "$1" "aslminus" + nres=$? + binary_compare "aslplus" + nres=$(($nres+ $?)) + if [ $nres -ne 0 ]; then + res=$(($res + $nres)) + fi + fi + + return $res +} + +# Make-install all the provided test cases +# (make install from aslts directory) +# arg1 - root directory of aslts +make_install_1() +{ + make_install "$1" "$2" if [ $? -ne 0 ]; then do_exit 1 "make install error" fi - cd "$restore_dir" } # Check parameters to be the names of test @@ -347,13 +454,7 @@ do_test_cases_make_install() check_dir "$dir" if [ $3 != 0 ]; then - cd "$dir" - if [ "x$execonly" = "xyes" ]; then - make install OPT=1 > /dev/null - else - make install OPT=0 > /dev/null - fi - + make_install "$dir" "$execonly" if [ $? -ne 0 ]; then errors=1 fi @@ -361,8 +462,6 @@ do_test_cases_make_install() done cd "$restore_dir" - - return $errors } # Make-install a list of specified test cases @@ -404,12 +503,7 @@ do_collections_make_install() check_dir "$dir" if [ $3 != 0 ]; then - cd "$dir" - if [ "$execonly" = "yes" ]; then - make install OPT=1 > /dev/null - else - make install OPT=0 > /dev/null - fi + make_install "$dir" "$execonly" if [ $? -ne 0 ]; then errors=1 fi @@ -457,36 +551,30 @@ make_install_3() # arg3 - all parameters passed to Do utility run_asl_compiler() { - local lexem list nparam=$2 action=100 execonly=$4 - - lexem=`echo "$3" | awk '{ print $2}'` - - if [ $nparam -le 1 ]; then - usage - do_exit 1 "Bad parameters 0" - elif [ $lexem == ASLTS -o $lexem == aslts ]; then - if [ $nparam != 3 ]; then - usage - do_exit 1 "Bad parameters 1" - else - action=1 - fi - elif [ $lexem == ALL -o $lexem == all ]; then - if [ $nparam -le 3 ]; then - usage - do_exit 1 "Bad parameters 2" - else - list=`echo "$3" | cut -c 7-` - action=3 - fi + local list="$2" execonly=$3 + local action=100 + + # It's better to split this function into a special 'asltscomp' + # script. For now, still uses it as an inline function. + RESET_SETTINGS + INIT_ALL_AVAILABLE_CASES + INIT_ALL_AVAILABLE_MODES + INIT_SET_OF_TEST_CASES + INIT_SET_OF_TEST_MODES + INIT_LOG_RESULTS + INIT_MEM_STAT + + if [ $list == ASLTS -o $list == aslts ]; then + action=1 + elif [ $list == ALL -o $list == all ]; then + list=`echo "$3" | cut -c 7-` + action=3 else action=2 - list=`echo "$3" | cut -c 3-` fi - # cut the last item from the list. It's a yes or no from execonly. - list=`echo $list | rev | cut -c 4- | rev ` - >&2 echo "list of testcases: $list" + echo "list of testcases: $list" + if [ $action == 1 ]; then echo "Make-install all the provided test cases" make_install_1 "$1" "$execonly" @@ -501,6 +589,28 @@ run_asl_compiler() fi } +get_iasl_version() +{ + local x version + + if [ ! -f $ASL ]; then + do_exit 1 "Bad iASL 1: <$ASL> does not exist" + else + x=`$ASL -version | grep "Compiler/Disassembler version"` + if [ x"$x" == x ]; then + version=00000000 + do_exit 1 "Bad iASL 2: bad signon <$ASL>" + else + version=`echo "$x" | awk -F" " '{print $5}'` + if [ x"$version" == x ]; then + do_exit 1 "Bad iASL 3: could not get version <$ASL>" + else + echo "$version" + fi + fi + fi +} + get_aslts_bin_line() { echo "$1" | awk -F: '{ for (i=1; i<=NF; i++) { print $i}}' |\ @@ -619,9 +729,59 @@ if [ $CMD == $ASLCOMPILE ]; then do_exit 1 "Undefined ASL variable! Set it to pathname of ASL compiler." fi - x="$@" - >&2 echo "disassemble: $EXECONLY" - run_asl_compiler "$ASLTSDIR" $NPARAM "$x" "$EXECONLY" + shift 1 + ENABLED_TMODES= + while : + do + check_mode_id $1 + if [ $? -eq 1 ]; then + break + fi + ENABLED_TMODES="$1 $ENABLED_TMODES" + shift 1 + done + export ENABLED_TMODES + + #NPARAM counts the number of enabled test cases + NPARAM=0 + ENABLED_TCASES= + while : + do + get_collection_opcode $1 + if [ $? -eq $COLLS_NUM ]; then + break + fi + ENABLED_TCASES="$1 $ENABLED_TCASES" + shift 1 + NPARAM=$(($NPARAM + 1)) + done + export ENABLED_TCASES + + if [ "x$ENABLED_TCASES" == "x" ]; then + x=aslts + NPARAM=$(($NPARAM + 1)) + else + x="$ENABLED_TCASES" + fi + + if [ $NPARAM -le 0 ]; then + usage + do_exit 1 "Bad parameters 0" + elif [ $x == ASLTS -o $x == aslts ]; then + if [ $NPARAM != 1 ]; then + usage + do_exit 1 "Bad parameters 1" + fi + elif [ $x == ALL -o $x == all ]; then + if [ $NPARAM -le 0 ]; then + usage + do_exit 1 "Bad parameters 2" + fi + fi + + + EXECONLY=$1 + run_asl_compiler "$ASLTSDIR" "$x" "$EXECONLY" elif [ $CMD == $RUNTESTS ]; then diff --git a/tests/aslts/bin/common b/tests/aslts/bin/common index f2743a8..62cfe00 100755 --- a/tests/aslts/bin/common +++ b/tests/aslts/bin/common @@ -212,42 +212,46 @@ get_collection_opcode() { local rval=0 - echo $FUNC_COLL | grep $1 > /dev/null + if [ -z $1 ]; then + return $COLLS_NUM + fi + + echo $FUNC_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $FUNC_COLL_OP fi - echo $CPLX_COLL | grep $1 > /dev/null + echo $CPLX_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $CPLX_COLL_OP fi - echo $EXCP_COLL | grep $1 > /dev/null + echo $EXCP_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $EXCP_COLL_OP fi - echo $BDEMO_COLL | grep $1 > /dev/null + echo $BDEMO_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $BDEMO_COLL_OP fi - echo $SERV_COLL | grep $1 > /dev/null + echo $SERV_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $SERV_COLL_OP fi - echo $MT_COLL | grep $1 > /dev/null + echo $MT_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $MT_COLL_OP fi - echo $MS_IDENT_COLL | grep $1 > /dev/null + echo $MS_IDENT_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $MS_IDENT_COLL_OP fi - echo $IMPL_COLL | grep $1 > /dev/null + echo $IMPL_COLL | grep -w $1 > /dev/null if [ $? -eq 0 ]; then return $IMPL_COLL_OP fi diff --git a/tests/aslts/src/runtime/collections/exceptions/exc/exc.asl b/tests/aslts/src/runtime/collections/exceptions/exc/exc.asl index 93bf8fc..ed2a2b2 100644 --- a/tests/aslts/src/runtime/collections/exceptions/exc/exc.asl +++ b/tests/aslts/src/runtime/collections/exceptions/exc/exc.asl @@ -794,6 +794,9 @@ Method(m154,, Serialized) * Updated specs 12.03.05: * "Note: the first non-hex character terminates the conversion * without error, and a '0x' prefix is not allowed." + * + * Update 08.10.17 + * Allow '0x' prefix for usability and clarity. */ Method(m155,, Serialized) { @@ -810,7 +813,7 @@ Method(m155,, Serialized) * New: */ CH03(ts, z058, 106, __LINE__, 0) - if (LNotEqual(Local0, 0)) { + if (LNotEqual(Local0, 0x1111)) { // Bug 63, Bugzilla 5329. err(ts, z058, __LINE__, 0, 0, Local0, 0) } diff --git a/tests/misc/grammar.aml b/tests/misc/grammar.aml index b7c111d..a7ddf08 100755 Binary files a/tests/misc/grammar.aml and b/tests/misc/grammar.aml differ diff --git a/tests/misc/grammar.dsl b/tests/misc/grammar.dsl index 832aba6..18f68fe 100755 --- a/tests/misc/grammar.dsl +++ b/tests/misc/grammar.dsl @@ -1,22 +1,22 @@ /* * Intel ACPI Component Architecture - * AML/ASL+ Disassembler version 20170726 (32-bit version) + * AML/ASL+ Disassembler version 20170728 (32-bit version) * Copyright (c) 2000 - 2017 Intel Corporation * * Disassembling to symbolic ASL+ operators * - * Disassembly of grammar.aml, Thu Jul 27 12:12:05 2017 + * Disassembly of grammar.aml, Wed Aug 23 14:34:44 2017 * * Original Table Header: * Signature "DSDT" - * Length 0x0000AAEE (43758) + * Length 0x0000AAE6 (43750) * Revision 0x01 **** 32-bit table (V1), no 64-bit math support - * Checksum 0x8D + * Checksum 0x43 * OEM ID "Intel" * OEM Table ID "GRMTEST" * OEM Revision 0x20090511 (537462033) * Compiler ID "INTL" - * Compiler Version 0x20170726 (538380070) + * Compiler Version 0x20170728 (538380072) */ DefinitionBlock ("", "DSDT", 1, "Intel", "GRMTEST", 0x20090511) { @@ -1294,9 +1294,9 @@ DefinitionBlock ("", "DSDT", 1, "Intel", "GRMTEST", 0x20090511) Debug = "++++++++ Dword BufferField I/O PASS" } - QWD2 = 0x1234567887654321 + QWD2 = 0x12345678 Local0 = QWD2 /* \FLDS.QWD2 */ - If ((Local0 != 0x1234567887654321)) + If ((Local0 != 0x12345678)) { ERR (One, 0x0576) }