From 6061af375203047e54178bb80b859d9cda61fe94 Mon Sep 17 00:00:00 2001 From: Al Stone Date: Dec 10 2016 00:44:54 +0000 Subject: Update to 20160930 source AND major fixes for big-endian support. Signed-off-by: Al Stone --- diff --git a/acpica-tools.spec b/acpica-tools.spec index 100c058..dcedcfd 100644 --- a/acpica-tools.spec +++ b/acpica-tools.spec @@ -34,8 +34,9 @@ Patch7: f23-harden.patch Patch8: asllookup-ppc64.patch Patch9: template.patch Patch10: s390x-ptrs.patch -Patch11: big-endian-v2.patch +Patch11: big-endian-part1.patch Patch12: free.patch +Patch13: big-endian-part2.patch BuildRequires: bison patchutils flex @@ -96,8 +97,9 @@ gzip -dc %{SOURCE1} | tar -x --strip-components=1 -f - %patch8 -p1 -b .asllookup-ppc64 %patch9 -p1 -b .template %patch10 -p1 -b .s390x-ptrs -%patch11 -p1 -b .big-endian-v2 +%patch11 -p1 -b .big-endian-part1 %patch12 -p1 -b .free +%patch13 -p1 -b .big-endian-part2 cp -p %{SOURCE2} README.Fedora cp -p %{SOURCE3} iasl.1 @@ -192,10 +194,11 @@ fi %changelog -* Fri Oct 28 2016 Al Stone - 20160930-1 +* Fri Dec 9 2016 Al Stone - 20160930-1 - Update to latest upstream. Closes BZ#1381017. - Refresh patches. -- Major repairs to disassembler code to make it endian-neutral again. +- Major repairs to compiler and disassembler code to make it endian-neutral + again (added patches big-endian-part1 and big-endian-part2). * Thu Sep 1 2016 Al Stone - 20160831-1 - Update to latest upstream. Closes BZ#1372107. diff --git a/big-endian-part1.patch b/big-endian-part1.patch new file mode 100644 index 0000000..ba29d31 --- /dev/null +++ b/big-endian-part1.patch @@ -0,0 +1,2540 @@ +Fixup the compiler/disassembler to support big-endian. + +Signed-off-by: Al Stone + +diff -Naur acpica-unix2-20160930/source/common/acfileio.c acpica-unix2-20160930-s390/source/common/acfileio.c +--- acpica-unix2-20160930/source/common/acfileio.c 2016-09-30 10:43:55.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/common/acfileio.c 2016-10-28 14:25:41.845397957 -0600 +@@ -241,6 +241,7 @@ + ACPI_TABLE_HEADER *Table; + INT32 Count; + long TableOffset; ++ UINT32 TableLen; + + + *ReturnTable = NULL; +@@ -281,7 +282,8 @@ + + /* Allocate a buffer for the entire table */ + +- Table = AcpiOsAllocate ((ACPI_SIZE) TableHeader.Length); ++ ACPI_MOVE_32_TO_32(&TableLen, &TableHeader.Length); ++ Table = AcpiOsAllocate ((ACPI_SIZE) TableLen); + if (!Table) + { + return (AE_NO_MEMORY); +@@ -291,8 +293,8 @@ + + fseek (File, TableOffset, SEEK_SET); + +- Count = fread (Table, 1, TableHeader.Length, File); +- if (Count != (INT32) TableHeader.Length) ++ Count = fread (Table, 1, TableLen, File); ++ if (Count != (INT32) TableLen) + { + Status = AE_ERROR; + goto ErrorExit; +@@ -300,7 +302,7 @@ + + /* Validate the checksum (just issue a warning) */ + +- Status = AcpiTbVerifyChecksum (Table, TableHeader.Length); ++ Status = AcpiTbVerifyChecksum (Table, TableLen); + if (ACPI_FAILURE (Status)) + { + Status = AcCheckTextModeCorruption (Table); +@@ -392,6 +394,7 @@ + ACPI_SIZE Actual; + long OriginalOffset; + UINT32 FileSize; ++ UINT32 TableLength; + UINT32 i; + + +@@ -423,11 +426,12 @@ + /* Validate table length against bytes remaining in the file */ + + FileSize = CmGetFileSize (File); +- if (TableHeader.Length > (UINT32) (FileSize - TableOffset)) ++ ACPI_MOVE_32_TO_32(&TableLength, &TableHeader.Length); ++ if (TableLength > (UINT32) (FileSize - TableOffset)) + { + fprintf (stderr, "Table [%4.4s] is too long for file - " + "needs: 0x%.2X, remaining in file: 0x%.2X\n", +- TableHeader.Signature, TableHeader.Length, ++ TableHeader.Signature, TableLength, + (UINT32) (FileSize - TableOffset)); + return (AE_BAD_HEADER); + } +diff -Naur acpica-unix2-20160930/source/common/ahpredef.c acpica-unix2-20160930-s390/source/common/ahpredef.c +--- acpica-unix2-20160930/source/common/ahpredef.c 2016-09-30 10:43:56.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/common/ahpredef.c 2016-10-28 14:25:41.844397962 -0600 +@@ -358,7 +358,7 @@ + char *Nameseg) + { + const AH_PREDEFINED_NAME *Info; +- ++ + + for (Info = AslPredefinedInfo; Info->Name; Info++) + { +diff -Naur acpica-unix2-20160930/source/common/dmtable.c acpica-unix2-20160930-s390/source/common/dmtable.c +--- acpica-unix2-20160930/source/common/dmtable.c 2016-09-30 10:43:56.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/common/dmtable.c 2016-10-28 14:25:41.840397982 -0600 +@@ -499,7 +499,7 @@ + */ + if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS)) + { +- Length = Table->Length; ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs); + if (ACPI_FAILURE (Status)) + { +@@ -513,13 +513,14 @@ + else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_S3PT)) + { + Length = AcpiDmDumpS3pt (Table); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + } + else + { + /* + * All other tables must use the common ACPI table header, dump it now + */ +- Length = Table->Length; ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader); + if (ACPI_FAILURE (Status)) + { +@@ -730,6 +731,7 @@ + BOOLEAN LastOutputBlankLine = FALSE; + ACPI_STATUS Status; + char RepairedName[8]; ++ UINT16 Val16; + + + if (!Info) +@@ -1097,8 +1099,9 @@ + /* Checksum, display and validate */ + + AcpiOsPrintf ("%2.2X", *Target); +- Temp8 = AcpiDmGenerateChecksum (Table, +- ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length, ++ ACPI_MOVE_32_TO_32(&Temp32, ++ &ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length); ++ Temp8 = AcpiDmGenerateChecksum (Table, Temp32, + ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum); + + if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum) +@@ -1163,14 +1166,14 @@ + + /* DMAR subtable types */ + +- Temp16 = ACPI_GET16 (Target); ++ Val16 = ACPI_GET16 (Target); ++ ACPI_MOVE_16_TO_16(&Temp16, &Val16); + if (Temp16 > ACPI_DMAR_TYPE_RESERVED) + { + Temp16 = ACPI_DMAR_TYPE_RESERVED; + } + +- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), +- AcpiDmDmarSubnames[Temp16]); ++ AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmDmarSubnames[Temp16]); + break; + + case ACPI_DMT_DMAR_SCOPE: +@@ -1261,14 +1264,14 @@ + + /* HEST subtable types */ + +- Temp16 = ACPI_GET16 (Target); ++ Val16 = ACPI_GET16 (Target); ++ ACPI_MOVE_16_TO_16(&Temp16, &Val16); + if (Temp16 > ACPI_HEST_TYPE_RESERVED) + { + Temp16 = ACPI_HEST_TYPE_RESERVED; + } + +- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), +- AcpiDmHestSubnames[Temp16]); ++ AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmHestSubnames[Temp16]); + break; + + case ACPI_DMT_HESTNTFY: +@@ -1334,13 +1337,14 @@ + + /* NFIT subtable types */ + +- Temp16 = ACPI_GET16 (Target); ++ Val16 = ACPI_GET16 (Target); ++ ACPI_MOVE_16_TO_16(&Temp16, &Val16); + if (Temp16 > ACPI_NFIT_TYPE_RESERVED) + { + Temp16 = ACPI_NFIT_TYPE_RESERVED; + } + +- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), ++ AcpiOsPrintf (UINT16_FORMAT, Temp16, + AcpiDmNfitSubnames[Temp16]); + break; + +diff -Naur acpica-unix2-20160930/source/common/dmtables.c acpica-unix2-20160930-s390/source/common/dmtables.c +--- acpica-unix2-20160930/source/common/dmtables.c 2016-09-30 10:43:56.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/common/dmtables.c 2016-10-28 14:25:41.844397962 -0600 +@@ -140,7 +140,9 @@ + ACPI_TABLE_HEADER *Table) + { + UINT8 Checksum; +- ++ UINT32 TableLen; ++ UINT32 OemRev; ++ UINT32 CompilerRev; + + /* Reset globals for External statements */ + +@@ -152,9 +154,10 @@ + */ + AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE); + ++ ACPI_MOVE_32_TO_32(&TableLen, &Table->Length); + AcpiOsPrintf (" * Original Table Header:\n"); + AcpiOsPrintf (" * Signature \"%4.4s\"\n", Table->Signature); +- AcpiOsPrintf (" * Length 0x%8.8X (%u)\n", Table->Length, Table->Length); ++ AcpiOsPrintf (" * Length 0x%8.8X (%u)\n", TableLen, TableLen); + + /* Print and validate the revision */ + +@@ -186,7 +189,7 @@ + + AcpiOsPrintf ("\n * Checksum 0x%2.2X", Table->Checksum); + +- Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length); ++ Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), TableLen); + if (Checksum) + { + AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X", +@@ -196,9 +199,11 @@ + AcpiOsPrintf ("\n"); + AcpiOsPrintf (" * OEM ID \"%.6s\"\n", Table->OemId); + AcpiOsPrintf (" * OEM Table ID \"%.8s\"\n", Table->OemTableId); +- AcpiOsPrintf (" * OEM Revision 0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision); ++ ACPI_MOVE_32_TO_32(&OemRev, &Table->OemRevision); ++ AcpiOsPrintf (" * OEM Revision 0x%8.8X (%u)\n", OemRev, OemRev); + AcpiOsPrintf (" * Compiler ID \"%.4s\"\n", Table->AslCompilerId); +- AcpiOsPrintf (" * Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision); ++ ACPI_MOVE_32_TO_32(&CompilerRev, &Table->AslCompilerRevision); ++ AcpiOsPrintf (" * Compiler Version 0x%8.8X (%u)\n", CompilerRev, CompilerRev); + AcpiOsPrintf (" */\n"); + + /* +@@ -211,7 +216,7 @@ + AcpiOsPrintf ( + "DefinitionBlock (\"\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n", + Table->Signature, Table->Revision, +- Table->OemId, Table->OemTableId, Table->OemRevision); ++ Table->OemId, Table->OemTableId, OemRev); + } + + +@@ -386,7 +391,8 @@ + + fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature); + +- AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER); ++ ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length); ++ AmlLength -= sizeof (ACPI_TABLE_HEADER); + AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER)); + + /* Create the root object */ +diff -Naur acpica-unix2-20160930/source/common/dmtbdump.c acpica-unix2-20160930-s390/source/common/dmtbdump.c +--- acpica-unix2-20160930/source/common/dmtbdump.c 2016-09-30 10:43:56.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/common/dmtbdump.c 2016-10-28 14:25:41.841397977 -0600 +@@ -296,6 +296,8 @@ + UINT32 Entries; + UINT32 Offset; + UINT32 i; ++ UINT32 Length; ++ UINT32 Address; + + + /* Point to start of table pointer array */ +@@ -305,12 +307,14 @@ + + /* RSDT uses 32-bit pointers */ + +- Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); + + for (i = 0; i < Entries; i++) + { + AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); +- AcpiOsPrintf ("%8.8X\n", Array[i]); ++ ACPI_MOVE_32_TO_32(&Address, &Array[i]); ++ AcpiOsPrintf ("%8.8X\n", Address); + Offset += sizeof (UINT32); + } + } +@@ -336,6 +340,8 @@ + UINT32 Entries; + UINT32 Offset; + UINT32 i; ++ UINT32 Length; ++ UINT64 Address; + + + /* Point to start of table pointer array */ +@@ -345,12 +351,14 @@ + + /* XSDT uses 64-bit pointers */ + +- Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); + + for (i = 0; i < Entries; i++) + { + AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); +- AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); ++ ACPI_MOVE_64_TO_64(&Address, &Array[i]); ++ AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Address)); + Offset += sizeof (UINT64); + } + } +@@ -384,6 +392,7 @@ + ACPI_STATUS Status; + UINT8 FadtRevision; + UINT32 ExpectedLength; ++ UINT32 ActualLength; + UINT32 i; + + +@@ -400,6 +409,7 @@ + return; + } + ++ ACPI_MOVE_32_TO_32(&ActualLength, &Table->Length); + if (FadtRevision > ACPI_FADT_MAX_VERSION) + { + AcpiOsPrintf ("// ACPI Warning: Revision %u is not fully supported, " +@@ -409,12 +419,12 @@ + else + { + ExpectedLength = FadtRevisionLength[FadtRevision]; +- if (Table->Length != ExpectedLength) ++ if (ActualLength != ExpectedLength) + { + AcpiOsPrintf ( + "// ACPI Warning: Input FADT revision %X does not match " + "expected length: found 0x%X expected 0x%X\n", +- FadtRevision, Table->Length, ExpectedLength); ++ FadtRevision, ActualLength, ExpectedLength); + } + } + +@@ -432,14 +442,14 @@ + + /* Dump the fields specific to FADT revision[i] */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, ++ Status = AcpiDmDumpTable (ActualLength, 0, Table, 0, + FadtRevisionInfo[i]); + if (ACPI_FAILURE (Status)) + { + return; + } + +- if (Table->Length <= FadtRevisionLength[i]) ++ if (ActualLength <= FadtRevisionLength[i]) + { + break; /* End of table */ + } +@@ -447,7 +457,7 @@ + + /* Build a local FADT to test some FADT values */ + +- AcpiTbCreateLocalFadt (Table, Table->Length); ++ AcpiTbCreateLocalFadt (Table, ActualLength); + } + + +@@ -478,17 +488,21 @@ + UINT32 DataOffset = 0; + UINT32 i; + UINT8 Type; ++ UINT32 Len; ++ UINT16 SubLen; + + + /* No main table, only subtables */ + ++ ACPI_MOVE_32_TO_32(&Len, &Table->Length); + SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Len) + { + /* Common subtable header */ + +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Header.Length, AcpiDmTableInfoAsfHdr); ++ ACPI_MOVE_16_TO_16(&SubLen, &SubTable->Header.Length); ++ Status = AcpiDmDumpTable (Len, Offset, SubTable, ++ SubLen, AcpiDmTableInfoAsfHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -545,8 +559,7 @@ + return; + } + +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Header.Length, InfoTable); ++ Status = AcpiDmDumpTable (Len, Offset, SubTable, SubLen, InfoTable); + if (ACPI_FAILURE (Status)) + { + return; +@@ -562,7 +575,7 @@ + for (i = 0; i < DataCount; i++) + { + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, DataOffset, ++ Status = AcpiDmDumpTable (Len, DataOffset, + DataTable, DataLength, DataInfoTable); + if (ACPI_FAILURE (Status)) + { +@@ -608,15 +621,14 @@ + + /* Point to next subtable */ + +- if (!SubTable->Header.Length) ++ if (!SubLen) + { + AcpiOsPrintf ("Invalid zero subtable header length\n"); + return; + } + +- Offset += SubTable->Header.Length; +- SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, +- SubTable->Header.Length); ++ Offset += SubLen; ++ SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubLen); + } + } + +@@ -640,12 +652,13 @@ + { + ACPI_STATUS Status; + ACPI_CPEP_POLLING *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_CPEP); + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); + if (ACPI_FAILURE (Status)) + { +@@ -655,7 +668,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + AcpiOsPrintf ("\n"); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +@@ -695,7 +708,10 @@ + ACPI_CSRT_GROUP *SubTable; + ACPI_CSRT_SHARED_INFO *SharedInfoTable; + ACPI_CSRT_DESCRIPTOR *SubSubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; ++ UINT32 SubLength; ++ UINT32 SubSubLength; ++ UINT32 SharedInfoLength; + UINT32 Offset = sizeof (ACPI_TABLE_CSRT); + UINT32 SubOffset; + UINT32 SubSubOffset; +@@ -706,14 +722,16 @@ + + /* Subtables (Resource Groups) */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Resource group subtable */ + + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_32_TO_32(&SubLength, &SubTable->Length); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoCsrt0); ++ SubLength, AcpiDmTableInfoCsrt0); + if (ACPI_FAILURE (Status)) + { + return; +@@ -733,19 +751,20 @@ + return; + } + +- SubOffset += SubTable->SharedInfoLength; ++ ACPI_MOVE_32_TO_32(&SharedInfoLength, &SubTable->SharedInfoLength); ++ SubOffset += SharedInfoLength; + + /* Sub-Subtables (Resource Descriptors) */ + + SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, + Offset + SubOffset); + +- while ((SubOffset < SubTable->Length) && +- ((Offset + SubOffset) < Table->Length)) ++ while ((SubOffset < SubLength) && ((Offset + SubOffset) < Length)) + { + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_32_TO_32(&SubSubLength, &SubSubTable->Length); + Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, +- SubSubTable->Length, AcpiDmTableInfoCsrt2); ++ SubSubLength, AcpiDmTableInfoCsrt2); + if (ACPI_FAILURE (Status)) + { + return; +@@ -755,7 +774,7 @@ + + /* Resource-specific info buffer */ + +- InfoLength = SubSubTable->Length - SubSubOffset; ++ InfoLength = SubSubLength - SubSubOffset; + if (InfoLength) + { + Status = AcpiDmDumpTable (Length, +@@ -770,16 +789,15 @@ + + /* Point to next sub-subtable */ + +- SubOffset += SubSubTable->Length; ++ SubOffset += SubSubLength; + SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, +- SubSubTable->Length); ++ SubSubLength); + } + + /* Point to next subtable */ + +- Offset += SubTable->Length; +- SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, +- SubTable->Length); ++ Offset += SubLength; ++ SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, SubLength); + } + } + +@@ -803,16 +821,20 @@ + { + ACPI_STATUS Status; + ACPI_DBG2_DEVICE *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; ++ UINT16 SubLength; + UINT32 Offset = sizeof (ACPI_TABLE_DBG2); + UINT32 i; + UINT32 ArrayOffset; + UINT32 AbsoluteOffset; + UINT8 *Array; ++ UINT16 Tmp16; ++ UINT16 AlsoTmp16; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); + if (ACPI_FAILURE (Status)) + { +@@ -822,11 +844,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoDbg2Device); ++ SubLength, AcpiDmTableInfoDbg2Device); + if (ACPI_FAILURE (Status)) + { + return; +@@ -836,13 +859,13 @@ + + for (i = 0; i < SubTable->RegisterCount; i++) + { +- ArrayOffset = SubTable->BaseAddressOffset + +- (sizeof (ACPI_GENERIC_ADDRESS) * i); ++ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->BaseAddressOffset); ++ ArrayOffset = Tmp16 + (sizeof (ACPI_GENERIC_ADDRESS) * i); + AbsoluteOffset = Offset + ArrayOffset; + Array = (UINT8 *) SubTable + ArrayOffset; + + Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, +- SubTable->Length, AcpiDmTableInfoDbg2Addr); ++ SubLength, AcpiDmTableInfoDbg2Addr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -853,13 +876,13 @@ + + for (i = 0; i < SubTable->RegisterCount; i++) + { +- ArrayOffset = SubTable->AddressSizeOffset + +- (sizeof (UINT32) * i); ++ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->AddressSizeOffset); ++ ArrayOffset = Tmp16 + (sizeof (UINT32) * i); + AbsoluteOffset = Offset + ArrayOffset; + Array = (UINT8 *) SubTable + ArrayOffset; + + Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, +- SubTable->Length, AcpiDmTableInfoDbg2Size); ++ SubLength, AcpiDmTableInfoDbg2Size); + if (ACPI_FAILURE (Status)) + { + return; +@@ -869,12 +892,13 @@ + /* Dump the Namestring (required) */ + + AcpiOsPrintf ("\n"); +- ArrayOffset = SubTable->NamepathOffset; ++ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->NamepathOffset); ++ ArrayOffset = Tmp16; + AbsoluteOffset = Offset + ArrayOffset; + Array = (UINT8 *) SubTable + ArrayOffset; + + Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, +- SubTable->Length, AcpiDmTableInfoDbg2Name); ++ SubLength, AcpiDmTableInfoDbg2Name); + if (ACPI_FAILURE (Status)) + { + return; +@@ -884,9 +908,10 @@ + + if (SubTable->OemDataOffset) + { +- Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset, +- Table, SubTable->OemDataLength, +- AcpiDmTableInfoDbg2OemData); ++ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->OemDataOffset); ++ ACPI_MOVE_16_TO_16(&AlsoTmp16, &SubTable->OemDataLength); ++ Status = AcpiDmDumpTable (Length, Offset + Tmp16, ++ Table, AlsoTmp16, AcpiDmTableInfoDbg2OemData); + if (ACPI_FAILURE (Status)) + { + return; +@@ -895,9 +920,9 @@ + + /* Point to next subtable */ + +- Offset += SubTable->Length; ++ Offset += SubLength; + SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, +- SubTable->Length); ++ SubLength); + } + } + +@@ -921,17 +946,20 @@ + { + ACPI_STATUS Status; + ACPI_DMAR_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; ++ UINT16 SubLength; + UINT32 Offset = sizeof (ACPI_TABLE_DMAR); + ACPI_DMTABLE_INFO *InfoTable; + ACPI_DMAR_DEVICE_SCOPE *ScopeTable; + UINT32 ScopeOffset; + UINT8 *PciPath; + UINT32 PathOffset; ++ UINT16 SubType; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); + if (ACPI_FAILURE (Status)) + { +@@ -941,13 +969,14 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoDmarHdr); ++ SubLength, AcpiDmTableInfoDmarHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -955,7 +984,8 @@ + + AcpiOsPrintf ("\n"); + +- switch (SubTable->Type) ++ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); ++ switch (SubType) + { + case ACPI_DMAR_TYPE_HARDWARE_UNIT: + +@@ -990,12 +1020,12 @@ + default: + + AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", +- SubTable->Type); ++ SubType); + return; + } + + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, InfoTable); ++ SubLength, InfoTable); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1004,8 +1034,8 @@ + /* + * Dump the optional device scope entries + */ +- if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || +- (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE)) ++ if ((SubType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || ++ (SubType == ACPI_DMAR_TYPE_NAMESPACE)) + { + /* These types do not support device scopes */ + +@@ -1013,7 +1043,7 @@ + } + + ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); +- while (ScopeOffset < SubTable->Length) ++ while (ScopeOffset < SubLength) + { + AcpiOsPrintf ("\n"); + Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, +@@ -1054,9 +1084,8 @@ + NextSubtable: + /* Point to next subtable */ + +- Offset += SubTable->Length; +- SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, +- SubTable->Length); ++ Offset += SubLength; ++ SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubLength); + } + } + +@@ -1083,12 +1112,15 @@ + ACPI_DRTM_RESOURCE_LIST *DrtmRl; + ACPI_DRTM_DPS_ID *DrtmDps; + UINT32 Count; ++ UINT32 ValidatedCount; ++ UINT32 ResourceCount; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, +- AcpiDmTableInfoDrtm); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDrtm); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1102,7 +1134,7 @@ + + DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, ++ Status = AcpiDmDumpTable (Length, Offset, + DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), + AcpiDmTableInfoDrtm0); + if (ACPI_FAILURE (Status)) +@@ -1115,10 +1147,11 @@ + /* Dump Validated table addresses */ + + Count = 0; +- while ((Offset < Table->Length) && +- (DrtmVtl->ValidatedTableCount > Count)) ++ ACPI_MOVE_32_TO_32(&ValidatedCount, &DrtmVtl->ValidatedTableCount); ++ while ((Offset < Length) && ++ (ValidatedCount > Count)) + { +- Status = AcpiDmDumpTable (Table->Length, Offset, ++ Status = AcpiDmDumpTable (Length, Offset, + ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), + AcpiDmTableInfoDrtm0a); + if (ACPI_FAILURE (Status)) +@@ -1134,7 +1167,7 @@ + + DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, ++ Status = AcpiDmDumpTable (Length, Offset, + DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), + AcpiDmTableInfoDrtm1); + if (ACPI_FAILURE (Status)) +@@ -1147,10 +1180,11 @@ + /* Dump the Resource List */ + + Count = 0; +- while ((Offset < Table->Length) && +- (DrtmRl->ResourceCount > Count)) ++ ACPI_MOVE_32_TO_32(&ResourceCount, &DrtmRl->ResourceCount); ++ while ((Offset < Length) && ++ (ResourceCount > Count)) + { +- Status = AcpiDmDumpTable (Table->Length, Offset, ++ Status = AcpiDmDumpTable (Length, Offset, + ACPI_ADD_PTR (void, Table, Offset), + sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); + if (ACPI_FAILURE (Status)) +@@ -1166,7 +1200,7 @@ + + DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); + AcpiOsPrintf ("\n"); +- (void) AcpiDmDumpTable (Table->Length, Offset, ++ (void) AcpiDmDumpTable (Length, Offset, + DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); + } + +@@ -1190,12 +1224,13 @@ + { + ACPI_STATUS Status; + ACPI_WHEA_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_EINJ); + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); + if (ACPI_FAILURE (Status)) + { +@@ -1205,7 +1240,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + AcpiOsPrintf ("\n"); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +@@ -1243,12 +1278,13 @@ + { + ACPI_STATUS Status; + ACPI_WHEA_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_ERST); + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); + if (ACPI_FAILURE (Status)) + { +@@ -1258,7 +1294,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + AcpiOsPrintf ("\n"); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +@@ -1296,17 +1332,19 @@ + { + ACPI_STATUS Status; + ACPI_FPDT_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_FPDT); + ACPI_DMTABLE_INFO *InfoTable; ++ UINT16 Type; + + + /* There is no main table (other than the standard ACPI header) */ + + /* Subtables */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + +@@ -1318,7 +1356,8 @@ + return; + } + +- switch (SubTable->Type) ++ ACPI_MOVE_16_TO_16(&Type, &SubTable->Type); ++ switch (Type) + { + case ACPI_FPDT_TYPE_BOOT: + +@@ -1332,8 +1371,7 @@ + + default: + +- AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", +- SubTable->Type); ++ AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", Type); + + /* Attempt to continue */ + +@@ -1381,16 +1419,19 @@ + { + ACPI_STATUS Status; + ACPI_GTDT_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; ++ UINT16 SubLength; + UINT32 Offset = sizeof (ACPI_TABLE_GTDT); + ACPI_DMTABLE_INFO *InfoTable; + UINT32 SubTableLength; + UINT32 GtCount; ++ UINT32 Tmp32; + ACPI_GTDT_TIMER_ENTRY *GtxTable; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); + if (ACPI_FAILURE (Status)) + { +@@ -1400,7 +1441,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + +@@ -1418,8 +1459,9 @@ + case ACPI_GTDT_TYPE_TIMER_BLOCK: + + SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); +- GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, ++ Tmp32 = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, + SubTable))->TimerCount; ++ ACPI_MOVE_32_TO_32(&GtCount, &Tmp32); + + InfoTable = AcpiDmTableInfoGtdt0; + break; +@@ -1440,8 +1482,9 @@ + return; + } + ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, InfoTable); ++ SubLength, InfoTable); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1500,16 +1543,18 @@ + { + ACPI_STATUS Status; + ACPI_HEST_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_HEST); + ACPI_DMTABLE_INFO *InfoTable; + UINT32 SubTableLength; + UINT32 BankCount; + ACPI_HEST_IA_ERROR_BANK *BankTable; ++ UINT16 SubType; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); + if (ACPI_FAILURE (Status)) + { +@@ -1519,10 +1564,11 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + BankCount = 0; +- switch (SubTable->Type) ++ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); ++ switch (SubType) + { + case ACPI_HEST_TYPE_IA32_CHECK: + +@@ -1651,15 +1697,21 @@ + ACPI_IORT_SMMU *IortSmmu = NULL; + UINT32 Offset; + UINT32 NodeOffset; ++ UINT16 NodeLength; + UINT32 Length; + ACPI_DMTABLE_INFO *InfoTable; + char *String; + UINT32 i; +- ++ UINT32 TableLen; ++ UINT32 ItsCount; ++ UINT32 MappingCount; ++ UINT32 CtxIntCount; ++ UINT32 PmuIntCount; + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); ++ ACPI_MOVE_32_TO_32(&TableLen, &Table->Length); ++ Status = AcpiDmDumpTable (TableLen, 0, Table, 0, AcpiDmTableInfoIort); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1670,18 +1722,19 @@ + + /* Dump the OptionalPadding (optional) */ + +- if (Iort->NodeOffset > Offset) ++ ACPI_MOVE_32_TO_32(&NodeOffset, &Iort->NodeOffset); ++ if (NodeOffset > Offset) + { +- Status = AcpiDmDumpTable (Table->Length, Offset, Table, +- Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); ++ Status = AcpiDmDumpTable (TableLen, Offset, Table, ++ NodeOffset - Offset, AcpiDmTableInfoIortPad); + if (ACPI_FAILURE (Status)) + { + return; + } + } + +- Offset = Iort->NodeOffset; +- while (Offset < Table->Length) ++ ACPI_MOVE_32_TO_32(&Offset, &Iort->NodeOffset); ++ while (Offset < TableLen) + { + /* Common subtable header */ + +@@ -1717,7 +1770,8 @@ + case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: + + InfoTable = AcpiDmTableInfoIort2; +- Length = IortNode->Length - NodeOffset; ++ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); ++ Length = NodeLength - NodeOffset; + break; + + case ACPI_IORT_NODE_SMMU: +@@ -1730,7 +1784,8 @@ + case ACPI_IORT_NODE_SMMU_V3: + + InfoTable = AcpiDmTableInfoIort4; +- Length = IortNode->Length - NodeOffset; ++ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); ++ Length = NodeLength - NodeOffset; + break; + + default: +@@ -1740,7 +1795,8 @@ + + /* Attempt to continue */ + +- if (!IortNode->Length) ++ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); ++ if (!NodeLength) + { + AcpiOsPrintf ("Invalid zero length IORT node\n"); + return; +@@ -1751,7 +1807,7 @@ + /* Dump the node subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + Length, InfoTable); + if (ACPI_FAILURE (Status)) +@@ -1771,9 +1827,10 @@ + + if (IortItsGroup) + { +- for (i = 0; i < IortItsGroup->ItsCount; i++) ++ ACPI_MOVE_32_TO_32(&ItsCount, &IortItsGroup->ItsCount); ++ for (i = 0; i < ItsCount; i++) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + 4, AcpiDmTableInfoIort0a); + NodeOffset += 4; +@@ -1785,11 +1842,11 @@ + + /* Dump the Padding (optional) */ + +- if (IortNode->Length > NodeOffset) ++ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); ++ if (NodeLength > NodeOffset) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, +- Table, IortNode->Length - NodeOffset, +- AcpiDmTableInfoIort1a); ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, ++ Table, NodeLength - NodeOffset, AcpiDmTableInfoIort1a); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1806,8 +1863,8 @@ + if (IortSmmu) + { + Length = 2 * sizeof (UINT64); +- NodeOffset = IortSmmu->GlobalInterruptOffset; +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->GlobalInterruptOffset); ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + Length, AcpiDmTableInfoIort3a); + if (ACPI_FAILURE (Status)) +@@ -1815,10 +1872,11 @@ + return; + } + +- NodeOffset = IortSmmu->ContextInterruptOffset; +- for (i = 0; i < IortSmmu->ContextInterruptCount; i++) ++ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->ContextInterruptOffset); ++ ACPI_MOVE_32_TO_32(&CtxIntCount, &IortSmmu->ContextInterruptCount); ++ for (i = 0; i < CtxIntCount; i++) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + 8, AcpiDmTableInfoIort3b); + if (ACPI_FAILURE (Status)) +@@ -1829,10 +1887,11 @@ + NodeOffset += 8; + } + +- NodeOffset = IortSmmu->PmuInterruptOffset; +- for (i = 0; i < IortSmmu->PmuInterruptCount; i++) ++ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->PmuInterruptOffset); ++ ACPI_MOVE_32_TO_32(&PmuIntCount, &IortSmmu->PmuInterruptCount); ++ for (i = 0; i < PmuIntCount; i++) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + 8, AcpiDmTableInfoIort3c); + if (ACPI_FAILURE (Status)) +@@ -1852,12 +1911,13 @@ + + /* Dump the ID mappings */ + +- NodeOffset = IortNode->MappingOffset; +- for (i = 0; i < IortNode->MappingCount; i++) ++ ACPI_MOVE_32_TO_32(&NodeOffset, &IortNode->MappingOffset); ++ ACPI_MOVE_32_TO_32(&MappingCount, &IortNode->MappingCount); ++ for (i = 0; i < MappingCount; i++) + { + AcpiOsPrintf ("\n"); + Length = sizeof (ACPI_IORT_ID_MAPPING); +- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, ++ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, + ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), + Length, AcpiDmTableInfoIortMap); + if (ACPI_FAILURE (Status)) +@@ -1871,8 +1931,9 @@ + NextSubTable: + /* Point to next node subtable */ + +- Offset += IortNode->Length; +- IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); ++ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); ++ Offset += NodeLength; ++ IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeLength); + } + } + +@@ -1903,11 +1964,14 @@ + ACPI_IVRS_DE_HEADER *DeviceEntry; + ACPI_IVRS_HEADER *SubTable; + ACPI_DMTABLE_INFO *InfoTable; ++ UINT32 Length; ++ UINT16 SubLength; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoIvrs); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1916,13 +1980,14 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoIvrsHdr); ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, ++ SubLength, AcpiDmTableInfoIvrsHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1949,7 +2014,7 @@ + + /* Attempt to continue */ + +- if (!SubTable->Length) ++ if (!SubLength) + { + AcpiOsPrintf ("Invalid zero length subtable\n"); + return; +@@ -1960,8 +2025,8 @@ + /* Dump the subtable */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Length, InfoTable); ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, ++ SubLength, InfoTable); + if (ACPI_FAILURE (Status)) + { + return; +@@ -1975,7 +2040,7 @@ + DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, + sizeof (ACPI_IVRS_HARDWARE)); + +- while (EntryOffset < (Offset + SubTable->Length)) ++ while (EntryOffset < (Offset + SubLength)) + { + AcpiOsPrintf ("\n"); + /* +@@ -2037,7 +2102,7 @@ + + /* Dump the Device Entry */ + +- Status = AcpiDmDumpTable (Table->Length, EntryOffset, ++ Status = AcpiDmDumpTable (Length, EntryOffset, + DeviceEntry, EntryLength, InfoTable); + if (ACPI_FAILURE (Status)) + { +@@ -2053,8 +2118,8 @@ + NextSubTable: + /* Point to next subtable */ + +- Offset += SubTable->Length; +- SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); ++ Offset += SubLength; ++ SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubLength); + } + } + +@@ -2080,7 +2145,7 @@ + { + ACPI_STATUS Status; + ACPI_LPIT_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_LPIT); + ACPI_DMTABLE_INFO *InfoTable; + UINT32 SubTableLength; +@@ -2088,8 +2153,9 @@ + + /* Subtables */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + +@@ -2153,13 +2219,14 @@ + { + ACPI_STATUS Status; + ACPI_SUBTABLE_HEADER *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_MADT); + ACPI_DMTABLE_INFO *InfoTable; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); + if (ACPI_FAILURE (Status)) + { +@@ -2169,7 +2236,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + +@@ -2315,11 +2382,13 @@ + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_MCFG); + ACPI_MCFG_ALLOCATION *SubTable; ++ UINT32 Len; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); ++ ACPI_MOVE_32_TO_32(&Len, &Table->Length); ++ Status = AcpiDmDumpTable (Len, 0, Table, 0, AcpiDmTableInfoMcfg); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2328,17 +2397,17 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Len) + { +- if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) ++ if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Len) + { + AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", +- sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); ++ sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Len)); + return; + } + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Len, Offset, SubTable, + sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); + if (ACPI_FAILURE (Status)) + { +@@ -2372,6 +2441,7 @@ + { + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_MPST); ++ ACPI_TABLE_MPST *Mpst; + ACPI_MPST_POWER_NODE *SubTable0; + ACPI_MPST_POWER_STATE *SubTable0A; + ACPI_MPST_COMPONENT *SubTable0B; +@@ -2380,11 +2450,13 @@ + UINT16 SubtableCount; + UINT32 PowerStateCount; + UINT32 ComponentCount; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMpst); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2392,13 +2464,14 @@ + + /* Subtable: Memory Power Node(s) */ + +- SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; ++ Mpst = ACPI_CAST_PTR (ACPI_TABLE_MPST, Table); ++ ACPI_MOVE_16_TO_16(&SubtableCount, &Mpst->PowerNodeCount); + SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); + +- while ((Offset < Table->Length) && SubtableCount) ++ while ((Offset < Length) && SubtableCount) + { + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable0, + sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); + if (ACPI_FAILURE (Status)) + { +@@ -2407,8 +2480,8 @@ + + /* Extract the sub-subtable counts */ + +- PowerStateCount = SubTable0->NumPowerStates; +- ComponentCount = SubTable0->NumPhysicalComponents; ++ ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates); ++ ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents); + Offset += sizeof (ACPI_MPST_POWER_NODE); + + /* Sub-subtables - Memory Power State Structure(s) */ +@@ -2419,7 +2492,7 @@ + while (PowerStateCount) + { + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable0A, + sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); + if (ACPI_FAILURE (Status)) + { +@@ -2429,7 +2502,7 @@ + SubTable0A++; + PowerStateCount--; + Offset += sizeof (ACPI_MPST_POWER_STATE); +- } ++ } + + /* Sub-subtables - Physical Component ID Structure(s) */ + +@@ -2442,7 +2515,7 @@ + + while (ComponentCount) + { +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable0B, + sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); + if (ACPI_FAILURE (Status)) + { +@@ -2457,17 +2530,19 @@ + /* Point to next Memory Power Node subtable */ + + SubtableCount--; ++ ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates); ++ ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents); + SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, + sizeof (ACPI_MPST_POWER_NODE) + +- (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + +- (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); ++ (sizeof (ACPI_MPST_POWER_STATE) * PowerStateCount) + ++ (sizeof (ACPI_MPST_COMPONENT) * ComponentCount)); + } + + /* Subtable: Count of Memory Power State Characteristic structures */ + + AcpiOsPrintf ("\n"); + SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable1, + sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); + if (ACPI_FAILURE (Status)) + { +@@ -2482,10 +2557,10 @@ + SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, + sizeof (ACPI_MPST_DATA_HDR)); + +- while ((Offset < Table->Length) && SubtableCount) ++ while ((Offset < Length) && SubtableCount) + { + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable2, + sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); + if (ACPI_FAILURE (Status)) + { +@@ -2518,11 +2593,13 @@ + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_MSCT); + ACPI_MSCT_PROXIMITY *SubTable; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMsct); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2531,12 +2608,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); + if (ACPI_FAILURE (Status)) + { +@@ -2571,11 +2648,13 @@ + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_MTMR); + ACPI_MTMR_ENTRY *SubTable; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMtmr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2584,12 +2663,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); + if (ACPI_FAILURE (Status)) + { +@@ -2631,11 +2710,17 @@ + ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; + ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; + UINT32 i; ++ UINT32 TableLength; ++ UINT16 SubLength; ++ UINT16 SubType; ++ UINT32 Count; ++ UINT16 Count16; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); ++ ACPI_MOVE_32_TO_32(&TableLength, &Table->Length); ++ Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNfit); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2644,19 +2729,21 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < TableLength) + { + /* NFIT subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoNfitHdr); ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); ++ Status = AcpiDmDumpTable (TableLength, Offset, SubTable, ++ SubLength, AcpiDmTableInfoNfitHdr); + if (ACPI_FAILURE (Status)) + { + return; + } + +- switch (SubTable->Type) ++ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); ++ switch (SubType) + { + case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: + +@@ -2708,7 +2795,7 @@ + + /* Attempt to continue */ + +- if (!SubTable->Length) ++ if (!SubLength) + { + AcpiOsPrintf ("Invalid zero length subtable\n"); + return; +@@ -2717,8 +2804,8 @@ + } + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- SubTable->Length, InfoTable); ++ Status = AcpiDmDumpTable (TableLength, Offset, SubTable, ++ SubLength, InfoTable); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2726,13 +2813,14 @@ + + /* Per-subtable variable-length fields */ + +- switch (SubTable->Type) ++ switch (SubType) + { + case ACPI_NFIT_TYPE_INTERLEAVE: + +- for (i = 0; i < Interleave->LineCount; i++) ++ ACPI_MOVE_32_TO_32(&Count, &Interleave->LineCount); ++ for (i = 0; i < Count; i++) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, ++ Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset, + &Interleave->LineOffset[i], + sizeof (UINT32), AcpiDmTableInfoNfit2a); + if (ACPI_FAILURE (Status)) +@@ -2746,12 +2834,11 @@ + + case ACPI_NFIT_TYPE_SMBIOS: + +- Length = SubTable->Length - +- sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); ++ Length = SubLength - sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); + + if (Length) + { +- Status = AcpiDmDumpTable (Table->Length, ++ Status = AcpiDmDumpTable (TableLength, + sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), + SmbiosInfo, + Length, AcpiDmTableInfoNfit3a); +@@ -2765,9 +2852,10 @@ + + case ACPI_NFIT_TYPE_FLUSH_ADDRESS: + +- for (i = 0; i < Hint->HintCount; i++) ++ ACPI_MOVE_16_TO_16(&Count16, &Hint->HintCount); ++ for (i = 0; i < Count16; i++) + { +- Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, ++ Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset, + &Hint->HintAddress[i], + sizeof (UINT64), AcpiDmTableInfoNfit6a); + if (ACPI_FAILURE (Status)) +@@ -2786,8 +2874,8 @@ + NextSubTable: + /* Point to next subtable */ + +- Offset += SubTable->Length; +- SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length); ++ Offset += SubLength; ++ SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubLength); + } + } + +@@ -2812,12 +2900,13 @@ + ACPI_STATUS Status; + ACPI_PCCT_SUBSPACE *SubTable; + ACPI_DMTABLE_INFO *InfoTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_PCCT); + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); + if (ACPI_FAILURE (Status)) + { +@@ -2827,7 +2916,7 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + +@@ -2903,16 +2992,21 @@ + ACPI_PMTT_HEADER *MemSubTable; + ACPI_PMTT_HEADER *DimmSubTable; + ACPI_PMTT_DOMAIN *DomainArray; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 Offset = sizeof (ACPI_TABLE_PMTT); + UINT32 MemOffset; + UINT32 DimmOffset; + UINT32 DomainOffset; +- UINT32 DomainCount; ++ UINT16 DomainCount; ++ UINT16 SubLength; ++ UINT16 Tmp16; ++ UINT16 MemLength; ++ UINT16 DimmLength; + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); + if (ACPI_FAILURE (Status)) + { +@@ -2922,13 +3016,14 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoPmttHdr); ++ SubLength, AcpiDmTableInfoPmttHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2947,7 +3042,7 @@ + /* Dump the fixed-length portion of the subtable */ + + Status = AcpiDmDumpTable (Length, Offset, SubTable, +- SubTable->Length, AcpiDmTableInfoPmtt0); ++ SubLength, AcpiDmTableInfoPmtt0); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2959,15 +3054,16 @@ + MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, + sizeof (ACPI_PMTT_SOCKET)); + +- while (((Offset + MemOffset) < Table->Length) && +- (MemOffset < SubTable->Length)) ++ while (((Offset + MemOffset) < Length) && ++ (MemOffset < SubLength)) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_16_TO_16(&MemLength, &MemSubTable->Length); + Status = AcpiDmDumpTable (Length, + Offset + MemOffset, MemSubTable, +- MemSubTable->Length, AcpiDmTableInfoPmttHdr); ++ MemLength, AcpiDmTableInfoPmttHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2987,7 +3083,7 @@ + + Status = AcpiDmDumpTable (Length, + Offset + MemOffset, MemSubTable, +- MemSubTable->Length, AcpiDmTableInfoPmtt1); ++ MemLength, AcpiDmTableInfoPmtt1); + if (ACPI_FAILURE (Status)) + { + return; +@@ -2995,13 +3091,14 @@ + + /* Walk the variable count of proximity domains */ + +- DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; ++ Tmp16 = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; ++ ACPI_MOVE_16_TO_16(&DomainCount, &Tmp16); + DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); + DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, + sizeof (ACPI_PMTT_CONTROLLER)); + +- while (((Offset + MemOffset + DomainOffset) < Table->Length) && +- ((MemOffset + DomainOffset) < SubTable->Length) && ++ while (((Offset + MemOffset + DomainOffset) < Length) && ++ ((MemOffset + DomainOffset) < SubLength) && + DomainCount) + { + Status = AcpiDmDumpTable (Length, +@@ -3029,15 +3126,16 @@ + DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, + DomainOffset); + +- while (((Offset + MemOffset + DimmOffset) < Table->Length) && +- (DimmOffset < MemSubTable->Length)) ++ while (((Offset + MemOffset + DimmOffset) < Length) && ++ (DimmOffset < MemLength)) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); ++ ACPI_MOVE_16_TO_16(&DimmLength, &DimmSubTable->Length); + Status = AcpiDmDumpTable (Length, + Offset + MemOffset + DimmOffset, DimmSubTable, +- DimmSubTable->Length, AcpiDmTableInfoPmttHdr); ++ DimmLength, AcpiDmTableInfoPmttHdr); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3057,7 +3155,7 @@ + + Status = AcpiDmDumpTable (Length, + Offset + MemOffset + DimmOffset, DimmSubTable, +- DimmSubTable->Length, AcpiDmTableInfoPmtt2); ++ DimmLength, AcpiDmTableInfoPmtt2); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3065,23 +3163,22 @@ + + /* Point to next DIMM subtable */ + +- DimmOffset += DimmSubTable->Length; ++ DimmOffset += DimmLength; + DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, +- DimmSubTable, DimmSubTable->Length); ++ DimmSubTable, DimmLength); + } + + /* Point to next Controller subtable */ + +- MemOffset += MemSubTable->Length; ++ MemOffset += MemLength; + MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, +- MemSubTable, MemSubTable->Length); ++ MemSubTable, MemLength); + } + + /* Point to next Socket subtable */ + +- Offset += SubTable->Length; +- SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, +- SubTable, SubTable->Length); ++ Offset += SubLength; ++ SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, SubLength); + } + } + +@@ -3107,6 +3204,8 @@ + ACPI_FPDT_HEADER *SubTable; + ACPI_DMTABLE_INFO *InfoTable; + ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); ++ UINT32 Length; ++ UINT16 SubType; + + + /* Main table */ +@@ -3117,20 +3216,22 @@ + return 0; + } + ++ ACPI_MOVE_32_TO_32(&Length, &S3ptTable->Length); + SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); +- while (Offset < S3ptTable->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + SubTable->Length, AcpiDmTableInfoS3ptHdr); + if (ACPI_FAILURE (Status)) + { + return 0; + } + +- switch (SubTable->Type) ++ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); ++ switch (SubType) + { + case ACPI_S3PT_TYPE_RESUME: + +@@ -3145,7 +3246,7 @@ + default: + + AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", +- SubTable->Type); ++ SubType); + + /* Attempt to continue */ + +@@ -3158,7 +3259,7 @@ + } + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + SubTable->Length, InfoTable); + if (ACPI_FAILURE (Status)) + { +@@ -3192,9 +3293,11 @@ + AcpiDmDumpSlic ( + ACPI_TABLE_HEADER *Table) + { ++ UINT32 Length; + +- (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table, +- Table->Length - sizeof (*Table), AcpiDmTableInfoSlic); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ (void) AcpiDmDumpTable (Length, sizeof (ACPI_TABLE_HEADER), Table, ++ Length - sizeof (*Table), AcpiDmTableInfoSlic); + } + + +@@ -3217,14 +3320,17 @@ + ACPI_STATUS Status; + UINT32 Offset; + UINT8 *Row; +- UINT32 Localities; ++ UINT64 Localities; + UINT32 i; + UINT32 j; ++ UINT32 Length; ++ UINT64 Tmp64; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSlit); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3232,7 +3338,8 @@ + + /* Display the Locality NxN Matrix */ + +- Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; ++ Tmp64 = (UINT64) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; ++ ACPI_MOVE_64_TO_64(&Localities, &Tmp64); + Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); + Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; + +@@ -3245,7 +3352,7 @@ + { + /* Check for beyond EOT */ + +- if (Offset >= Table->Length) ++ if (Offset >= Length) + { + AcpiOsPrintf ( + "\n**** Not enough room in table for all localities\n"); +@@ -3297,11 +3404,13 @@ + UINT32 Offset = sizeof (ACPI_TABLE_SRAT); + ACPI_SUBTABLE_HEADER *SubTable; + ACPI_DMTABLE_INFO *InfoTable; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSrat); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3310,12 +3419,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + SubTable->Length, AcpiDmTableInfoSratHdr); + if (ACPI_FAILURE (Status)) + { +@@ -3359,7 +3468,7 @@ + } + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + SubTable->Length, InfoTable); + if (ACPI_FAILURE (Status)) + { +@@ -3396,13 +3505,14 @@ + { + ACPI_STATUS Status; + char *Namepath; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT32 StringLength; + UINT32 Offset = sizeof (ACPI_TABLE_STAO); + + + /* Main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao); + if (ACPI_FAILURE (Status)) + { +@@ -3411,7 +3521,7 @@ + + /* The rest of the table consists of Namepath strings */ + +- while (Offset < Table->Length) ++ while (Offset < Length) + { + Namepath = ACPI_ADD_PTR (char, Table, Offset); + StringLength = strlen (Namepath) + 1; +@@ -3453,11 +3563,14 @@ + ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR ( + ACPI_TABLE_TCPA_HDR, Table, Offset); + ACPI_STATUS Status; ++ UINT32 Length; ++ UINT16 PlatformClass; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, + 0, AcpiDmTableInfoTcpaHdr); + if (ACPI_FAILURE (Status)) + { +@@ -3468,18 +3581,19 @@ + * Examine the PlatformClass field to determine the table type. + * Either a client or server table. Only one. + */ +- switch (CommonHeader->PlatformClass) ++ ACPI_MOVE_16_TO_16(&PlatformClass, &CommonHeader->PlatformClass); ++ switch (PlatformClass) + { + case ACPI_TCPA_CLIENT_TABLE: + +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- Table->Length - Offset, AcpiDmTableInfoTcpaClient); ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, ++ Length - Offset, AcpiDmTableInfoTcpaClient); + break; + + case ACPI_TCPA_SERVER_TABLE: + +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, +- Table->Length - Offset, AcpiDmTableInfoTcpaServer); ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, ++ Length - Offset, AcpiDmTableInfoTcpaServer); + break; + + default: +@@ -3516,11 +3630,13 @@ + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_VRTC); + ACPI_VRTC_ENTRY *SubTable; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoVrtc); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3529,12 +3645,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); + if (ACPI_FAILURE (Status)) + { +@@ -3569,11 +3685,13 @@ + ACPI_STATUS Status; + UINT32 Offset = sizeof (ACPI_TABLE_WDAT); + ACPI_WDAT_ENTRY *SubTable; ++ UINT32 Length; + + + /* Main table */ + +- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); ++ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWdat); + if (ACPI_FAILURE (Status)) + { + return; +@@ -3582,12 +3700,12 @@ + /* Subtables */ + + SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); +- while (Offset < Table->Length) ++ while (Offset < Length) + { + /* Common subtable header */ + + AcpiOsPrintf ("\n"); +- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, ++ Status = AcpiDmDumpTable (Length, Offset, SubTable, + sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); + if (ACPI_FAILURE (Status)) + { +@@ -3622,12 +3740,13 @@ + { + ACPI_STATUS Status; + ACPI_TABLE_WPBT *SubTable; +- UINT32 Length = Table->Length; ++ UINT32 Length; + UINT16 ArgumentsLength; + + + /* Dump the main table */ + ++ ACPI_MOVE_32_TO_32(&Length, &Table->Length); + Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt); + if (ACPI_FAILURE (Status)) + { +@@ -3637,10 +3756,10 @@ + /* Extract the arguments buffer length from the main table */ + + SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table); +- ArgumentsLength = SubTable->ArgumentsLength; ++ ACPI_MOVE_16_TO_16(&ArgumentsLength, &SubTable->ArgumentsLength); + + /* Dump the arguments buffer */ + +- (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength, ++ (void) AcpiDmDumpTable (Length, 0, Table, ArgumentsLength, + AcpiDmTableInfoWpbt0); + } +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmbuffer.c acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c +--- acpica-unix2-20160930/source/components/disassembler/dmbuffer.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c 2016-10-28 14:25:41.876397798 -0600 +@@ -204,7 +204,7 @@ + + + ByteData = Op->Named.Data; +- ByteCount = (UINT32) Op->Common.Value.Integer; ++ ByteCount = (UINT32) Op->Common.Value.Size; + + /* + * The byte list belongs to a buffer, and can be produced by either +@@ -304,7 +304,8 @@ + /* Extract the byte list info */ + + ByteData = NextOp->Named.Data; +- ByteCount = (UINT32) NextOp->Common.Value.Integer; ++ /* ByteCount = (UINT32) NextOp->Common.Value.Integer; */ ++ ByteCount = (UINT32) NextOp->Common.Value.Size; + + /* Byte count must be exactly 16 */ + +@@ -954,16 +955,18 @@ + ACPI_PARSE_OBJECT *Op) + { + UINT32 Name; ++ UINT32 TmpName; + ACPI_PARSE_OBJECT *NextOp; + + + /* Get the NameSegment */ + +- Name = AcpiPsGetName (Op); +- if (!Name) ++ TmpName = AcpiPsGetName (Op); ++ if (!TmpName) + { + return; + } ++ ACPI_MOVE_32_TO_32(&Name, &TmpName); + + NextOp = AcpiPsGetDepthNext (NULL, Op); + if (!NextOp) +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmopcode.c acpica-unix2-20160930-s390/source/components/disassembler/dmopcode.c +--- acpica-unix2-20160930/source/components/disassembler/dmopcode.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmopcode.c 2016-10-28 14:25:41.877397793 -0600 +@@ -244,6 +244,7 @@ + char *NameString; + int LastCharIsDigit; + int LastCharsAreHex; ++ char TmpName[ACPI_NAME_SIZE + 1]; + + + if (!Op) +@@ -261,7 +262,9 @@ + + /* Predefined name must start with an underscore */ + +- NameString = ACPI_CAST_PTR (char, &Op->Named.Name); ++ memset(TmpName, 0, ACPI_NAME_SIZE + 1); ++ ACPI_MOVE_32_TO_32(TmpName, &Op->Named.Name); ++ NameString = TmpName; + if (NameString[0] != '_') + { + return; +@@ -871,21 +874,26 @@ + AcpiDmNamestring (Op->Common.Value.Name); + break; + +- case AML_INT_NAMEDFIELD_OP: ++ case AML_INT_NAMEDFIELD_OP: { + +- Length = AcpiDmDumpName (Op->Named.Name); ++ UINT32 TmpName; ++ ++ ACPI_MOVE_32_TO_32(&TmpName, &Op->Named.Name); ++ Length = AcpiDmDumpName (TmpName); + AcpiOsPrintf (",%*.s %u", (unsigned) (5 - Length), " ", +- (UINT32) Op->Common.Value.Integer); ++ (UINT32) Op->Common.Value.Size); + AcpiDmCommaIfFieldMember (Op); + +- Info->BitOffset += (UINT32) Op->Common.Value.Integer; ++ Info->BitOffset += (UINT32) Op->Common.Value.Size; + break; ++ } + + case AML_INT_RESERVEDFIELD_OP: + + /* Offset() -- Must account for previous offsets */ + +- Offset = (UINT32) Op->Common.Value.Integer; ++ //DEBUG ++ Offset = Op->Common.Value.Size; + Info->BitOffset += Offset; + + if (Info->BitOffset % 8 == 0) +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrc.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrc.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrc.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrc.c 2016-10-28 14:25:41.878397788 -0600 +@@ -392,7 +392,7 @@ + ACPI_PARSE_OBJECT *NextOp; + UINT8 *Aml; + UINT8 *EndAml; +- ACPI_SIZE Length; ++ UINT32 Length; + + + /* This op must be a buffer */ +@@ -418,7 +418,7 @@ + } + + Aml = NextOp->Named.Data; +- Length = (ACPI_SIZE) NextOp->Common.Value.Integer; ++ Length = NextOp->Common.Value.Size; + + /* Walk the byte list, abort on any invalid descriptor type or length */ + +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcl.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrcl.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c 2016-10-28 14:25:41.876397798 -0600 +@@ -141,7 +141,8 @@ + UINT32 Level) + { + UINT32 i; +- ++ UINT16 Tmp16; ++ UINT32 Tmp32; + + for (i = 0; i < 4; i++) + { +@@ -151,14 +152,14 @@ + { + case 16: + +- AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], +- AcpiDmMemoryNames[i]); ++ ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i])); ++ AcpiDmDumpInteger16 (Tmp16, AcpiDmMemoryNames[i]); + break; + + case 32: + +- AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], +- AcpiDmMemoryNames[i]); ++ ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i])); ++ AcpiDmDumpInteger32 (Tmp32, AcpiDmMemoryNames[i]); + break; + + default: +@@ -190,7 +191,9 @@ + UINT32 Level) + { + UINT32 i; +- ++ UINT16 Tmp16; ++ UINT32 Tmp32; ++ UINT64 Tmp64; + + AcpiOsPrintf ("\n"); + +@@ -202,20 +205,20 @@ + { + case 16: + +- AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], +- AcpiDmAddressNames[i]); ++ ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i])); ++ AcpiDmDumpInteger16 (Tmp16, AcpiDmAddressNames[i]); + break; + + case 32: + +- AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], +- AcpiDmAddressNames[i]); ++ ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i])); ++ AcpiDmDumpInteger32 (Tmp32, AcpiDmAddressNames[i]); + break; + + case 64: + +- AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i], +- AcpiDmAddressNames[i]); ++ ACPI_MOVE_64_TO_64(&Tmp64, &(ACPI_CAST_PTR (UINT64, Source)[i])); ++ AcpiDmDumpInteger64 (Tmp64, AcpiDmAddressNames[i]); + break; + + default: +@@ -868,6 +871,7 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT32 Tmp; + + /* Dump name and read/write flag */ + +@@ -876,12 +880,12 @@ + AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->FixedMemory32.Flags)]); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger32 (Resource->FixedMemory32.Address, +- "Address Base"); ++ ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.Address); ++ AcpiDmDumpInteger32 (Tmp, "Address Base"); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength, +- "Address Length"); ++ ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.AddressLength); ++ AcpiDmDumpInteger32 (Tmp, "Address Length"); + + /* Insert a descriptor name */ + +@@ -972,7 +976,7 @@ + UINT32 Level) + { + UINT32 i; +- ++ UINT16 Tmp16; + + AcpiDmIndent (Level); + AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ", +@@ -986,10 +990,11 @@ + * list. Must compute length based on length of the list. First xrupt + * is included in the struct (reason for -1 below) + */ ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->ExtendedIrq.ResourceLength); + AcpiDmResourceSource (Resource, + sizeof (AML_RESOURCE_EXTENDED_IRQ) + + ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32), +- Resource->ExtendedIrq.ResourceLength); ++ Tmp16); + + /* Insert a descriptor name */ + +@@ -1002,9 +1007,12 @@ + AcpiOsPrintf ("{\n"); + for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++) + { ++ UINT32 Tmp32, Val32; ++ + AcpiDmIndent (Level + 1); +- AcpiOsPrintf ("0x%8.8X,\n", +- (UINT32) Resource->ExtendedIrq.Interrupts[i]); ++ Val32 = (UINT32) Resource->ExtendedIrq.Interrupts[i]; ++ ACPI_MOVE_32_TO_32(&Tmp32, &Val32); ++ AcpiOsPrintf ("0x%8.8X,\n", Tmp32); + } + + AcpiDmIndent (Level); +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcs.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrcs.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c 2016-10-28 14:25:41.876397798 -0600 +@@ -72,6 +72,7 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT16 Tmp; + + AcpiDmIndent (Level); + AcpiOsPrintf ("%s (", +@@ -93,7 +94,8 @@ + AcpiOsPrintf (")\n"); + + AcpiDmIndent (Level + 1); +- AcpiDmBitList (Resource->Irq.IrqMask); ++ ACPI_MOVE_16_TO_16(&Tmp, &Resource->Irq.IrqMask); ++ AcpiDmBitList (Tmp); + } + + +@@ -204,16 +206,19 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT16 Tmp16; + + AcpiDmIndent (Level); + AcpiOsPrintf ("IO (%s,\n", + AcpiGbl_IoDecode [ACPI_GET_1BIT_FLAG (Resource->Io.Flags)]); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger16 (Resource->Io.Minimum, "Range Minimum"); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Minimum); ++ AcpiDmDumpInteger16 (Tmp16, "Range Minimum"); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger16 (Resource->Io.Maximum, "Range Maximum"); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Maximum); ++ AcpiDmDumpInteger16 (Tmp16, "Range Maximum"); + + AcpiDmIndent (Level + 1); + AcpiDmDumpInteger8 (Resource->Io.Alignment, "Alignment"); +diff -Naur acpica-unix2-20160930/source/components/dispatcher/dsfield.c acpica-unix2-20160930-s390/source/components/dispatcher/dsfield.c +--- acpica-unix2-20160930/source/components/dispatcher/dsfield.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/dispatcher/dsfield.c 2016-10-28 14:25:41.879397782 -0600 +@@ -318,6 +318,7 @@ + ACPI_STATUS Status; + UINT64 Position; + ACPI_PARSE_OBJECT *Child; ++ UINT32 TmpName; + + + ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info); +@@ -424,10 +425,17 @@ + + /* Lookup the name, it should already exist */ + ++ ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name); ++ Status = AcpiNsLookup (WalkState->ScopeInfo, ++ (char *) &TmpName, Info->FieldType, ++ ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, ++ WalkState, &Info->FieldNode); ++ /* + Status = AcpiNsLookup (WalkState->ScopeInfo, + (char *) &Arg->Named.Name, Info->FieldType, + ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, + WalkState, &Info->FieldNode); ++ */ + if (ACPI_FAILURE (Status)) + { + ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); +@@ -652,9 +660,17 @@ + */ + if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP) + { ++ UINT32 TmpName; ++ ++ ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name); ++ Status = AcpiNsLookup (WalkState->ScopeInfo, ++ (char *) &TmpName, Type, ACPI_IMODE_LOAD_PASS1, ++ Flags, WalkState, &Node); ++ /* + Status = AcpiNsLookup (WalkState->ScopeInfo, + (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1, + Flags, WalkState, &Node); ++ */ + if (ACPI_FAILURE (Status)) + { + ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); +diff -Naur acpica-unix2-20160930/source/components/namespace/nsparse.c acpica-unix2-20160930-s390/source/components/namespace/nsparse.c +--- acpica-unix2-20160930/source/components/namespace/nsparse.c 2016-09-30 10:43:59.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/namespace/nsparse.c 2016-10-28 14:25:41.895397700 -0600 +@@ -196,13 +196,14 @@ + + /* Table must consist of at least a complete header */ + +- if (Table->Length < sizeof (ACPI_TABLE_HEADER)) ++ ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length); ++ if (AmlLength < sizeof (ACPI_TABLE_HEADER)) + { + return_ACPI_STATUS (AE_BAD_HEADER); + } + + AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER); +- AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER); ++ AmlLength -= sizeof (ACPI_TABLE_HEADER); + + Status = AcpiTbGetOwnerId (TableIndex, &OwnerId); + if (ACPI_FAILURE (Status)) +diff -Naur acpica-unix2-20160930/source/components/tables/tbprint.c acpica-unix2-20160930-s390/source/components/tables/tbprint.c +--- acpica-unix2-20160930/source/components/tables/tbprint.c 2016-09-30 10:43:59.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/tables/tbprint.c 2016-10-28 14:25:41.902397665 -0600 +@@ -143,15 +143,18 @@ + ACPI_TABLE_HEADER *Header) + { + ACPI_TABLE_HEADER LocalHeader; ++ UINT32 Len; ++ UINT32 OemRev; ++ UINT32 CompilerRev; + + + if (ACPI_COMPARE_NAME (Header->Signature, ACPI_SIG_FACS)) + { + /* FACS only has signature and length fields */ + ++ ACPI_MOVE_32_TO_32(&Len, &Header->Length); + ACPI_INFO (("%-4.4s 0x%8.8X%8.8X %06X", +- Header->Signature, ACPI_FORMAT_UINT64 (Address), +- Header->Length)); ++ Header->Signature, ACPI_FORMAT_UINT64 (Address), Len)); + } + else if (ACPI_VALIDATE_RSDP_SIG (Header->Signature)) + { +@@ -174,13 +177,16 @@ + + AcpiTbCleanupTableHeader (&LocalHeader, Header); + ++ ACPI_MOVE_32_TO_32(&Len, &LocalHeader.Length); ++ ACPI_MOVE_32_TO_32(&OemRev, &LocalHeader.OemRevision); ++ ACPI_MOVE_32_TO_32(&CompilerRev, &LocalHeader.AslCompilerRevision); + ACPI_INFO (( + "%-4.4s 0x%8.8X%8.8X" + " %06X (v%.2d %-6.6s %-8.8s %08X %-4.4s %08X)", + LocalHeader.Signature, ACPI_FORMAT_UINT64 (Address), +- LocalHeader.Length, LocalHeader.Revision, LocalHeader.OemId, +- LocalHeader.OemTableId, LocalHeader.OemRevision, +- LocalHeader.AslCompilerId, LocalHeader.AslCompilerRevision)); ++ Len, LocalHeader.Revision, LocalHeader.OemId, ++ LocalHeader.OemTableId, OemRev, ++ LocalHeader.AslCompilerId, CompilerRev)); + } + } + +diff -Naur acpica-unix2-20160930/source/include/platform/aclinux.h acpica-unix2-20160930-s390/source/include/platform/aclinux.h +--- acpica-unix2-20160930/source/include/platform/aclinux.h 2016-10-28 14:24:20.839813236 -0600 ++++ acpica-unix2-20160930-s390/source/include/platform/aclinux.h 2016-10-28 14:25:41.909397629 -0600 +@@ -210,6 +210,10 @@ + #define __cdecl + #endif + ++#if defined(__PPC64__) || defined(__s390x__) ++#define ACPI_BIG_ENDIAN ++#endif ++ + #endif /* __KERNEL__ */ + + #endif /* __ACLINUX_H__ */ diff --git a/big-endian-part2.patch b/big-endian-part2.patch new file mode 100644 index 0000000..f596a20 --- /dev/null +++ b/big-endian-part2.patch @@ -0,0 +1,1039 @@ +Additional fixup for the compiler/disassembler to support big-endian. + +Signed-off-by: Al Stone + +diff -Naur acpica-unix2-20160930/source/compiler/aslrestype2.c acpica-unix2-20160930-s390/source/compiler/aslrestype2.c +--- acpica-unix2-20160930/source/compiler/aslrestype2.c 2016-12-06 19:25:49.283453253 -0700 ++++ acpica-unix2-20160930-s390/source/compiler/aslrestype2.c 2016-12-08 15:50:38.783785207 -0700 +@@ -98,21 +98,33 @@ + { + case 0: /* Address space */ + ++ /* + Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer; ++ */ ++ ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AddressSpaceId, ++ &InitializerOp->Asl.Value.Integer); + RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE, + CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId)); + break; + + case 1: /* Register Bit Width */ + ++ /* + Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer; ++ */ ++ ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitWidth, ++ &InitializerOp->Asl.Value.Integer); + RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth)); + break; + + case 2: /* Register Bit Offset */ + ++ /* + Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer; ++ */ ++ ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitOffset, ++ &InitializerOp->Asl.Value.Integer); + RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET, + CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset)); + break; +@@ -127,7 +139,11 @@ + + case 4: /* Access Size (ACPI 3.0) */ + ++ /* + Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer; ++ */ ++ ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AccessSize, ++ &InitializerOp->Asl.Value.Integer); + RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE, + CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize)); + +diff -Naur acpica-unix2-20160930/source/compiler/dtfield.c acpica-unix2-20160930-s390/source/compiler/dtfield.c +--- acpica-unix2-20160930/source/compiler/dtfield.c 2016-09-30 10:43:57.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/compiler/dtfield.c 2016-12-06 11:26:37.483785207 -0700 +@@ -360,7 +360,27 @@ + DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer); + } + +- memcpy (Buffer, &Value, ByteLength); ++ switch (ByteLength) { ++ case 1: ++ ACPI_MOVE_64_TO_8(Buffer, &Value); ++ break; ++ ++ case 2: ++ ACPI_MOVE_64_TO_16(Buffer, &Value); ++ break; ++ ++ case 4: ++ ACPI_MOVE_64_TO_32(Buffer, &Value); ++ break; ++ ++ case 8: ++ ACPI_MOVE_64_TO_64(Buffer, &Value); ++ break; ++ ++ default: ++ memcpy (Buffer, &Value, ByteLength); ++ break; ++ } + return; + } + +diff -Naur acpica-unix2-20160930/source/compiler/dtsubtable.c acpica-unix2-20160930-s390/source/compiler/dtsubtable.c +--- acpica-unix2-20160930/source/compiler/dtsubtable.c 2016-09-30 10:43:57.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/compiler/dtsubtable.c 2016-12-06 15:30:17.993785207 -0700 +@@ -379,6 +379,21 @@ + return; + } + +- memcpy (Subtable->LengthField, &Subtable->TotalLength, +- Subtable->SizeOfLengthField); ++ switch(Subtable->SizeOfLengthField) { ++ case 1: ++ ACPI_MOVE_32_TO_8(Subtable->LengthField, &Subtable->TotalLength); ++ break; ++ ++ case 2: ++ ACPI_MOVE_32_TO_16(Subtable->LengthField, &Subtable->TotalLength); ++ break; ++ ++ case 4: ++ ACPI_MOVE_32_TO_32(Subtable->LengthField, &Subtable->TotalLength); ++ break; ++ ++ default: ++ memcpy (Subtable->LengthField, &Subtable->TotalLength, ++ Subtable->SizeOfLengthField); ++ } + } +diff -Naur acpica-unix2-20160930/source/compiler/dttable1.c acpica-unix2-20160930-s390/source/compiler/dttable1.c +--- acpica-unix2-20160930/source/compiler/dttable1.c 2016-09-30 10:43:57.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/compiler/dttable1.c 2016-12-08 11:58:07.353785207 -0700 +@@ -282,6 +282,8 @@ + DT_FIELD **PFieldList = (DT_FIELD **) List; + UINT32 DescriptorCount; + UINT32 GroupLength; ++ ACPI_CSRT_GROUP *Pgrp; ++ UINT32 Tmp32; + + + /* Subtables (Resource Groups) */ +@@ -300,12 +302,20 @@ + + /* Compute the number of resource descriptors */ + ++ /* + GroupLength = + (ACPI_CAST_PTR (ACPI_CSRT_GROUP, + Subtable->Buffer))->Length - + (ACPI_CAST_PTR (ACPI_CSRT_GROUP, + Subtable->Buffer))->SharedInfoLength - + sizeof (ACPI_CSRT_GROUP); ++ */ ++ Pgrp = ACPI_CAST_PTR(ACPI_CSRT_GROUP, Subtable->Buffer); ++ ACPI_MOVE_32_TO_32(&Tmp32, &Pgrp->Length); ++ GroupLength = Tmp32; ++ ACPI_MOVE_32_TO_32(&Tmp32, &Pgrp->SharedInfoLength); ++ GroupLength -= Tmp32; ++ GroupLength -= sizeof (ACPI_CSRT_GROUP); + + DescriptorCount = (GroupLength / + sizeof (ACPI_CSRT_DESCRIPTOR)); +@@ -393,6 +403,8 @@ + ACPI_DBG2_DEVICE *DeviceInfo; + UINT16 CurrentOffset; + UINT32 i; ++ UINT16 Tmp16; ++ UINT32 Tmp32; + + + /* Main table */ +@@ -409,10 +421,11 @@ + /* Main table fields */ + + Dbg2Header = ACPI_CAST_PTR (ACPI_DBG2_HEADER, Subtable->Buffer); +- Dbg2Header->InfoOffset = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF ( ++ Tmp32 = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF ( + ACPI_ADD_PTR (UINT8, Dbg2Header, sizeof (ACPI_DBG2_HEADER)), Dbg2Header); ++ ACPI_MOVE_32_TO_32(&Dbg2Header->InfoOffset, &Tmp32); + +- SubtableCount = Dbg2Header->InfoCount; ++ ACPI_MOVE_32_TO_32(&SubtableCount, &Dbg2Header->InfoCount); + DtPushSubtable (Subtable); + + /* Process all Device Information subtables (Count = InfoCount) */ +@@ -439,7 +452,7 @@ + + /* BaseAddressRegister GAS array (Required, size is RegisterCount) */ + +- DeviceInfo->BaseAddressOffset = CurrentOffset; ++ ACPI_MOVE_16_TO_16(&DeviceInfo->BaseAddressOffset, &CurrentOffset); + for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) + { + Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr, +@@ -455,7 +468,7 @@ + + /* AddressSize array (Required, size = RegisterCount) */ + +- DeviceInfo->AddressSizeOffset = CurrentOffset; ++ ACPI_MOVE_16_TO_16(&DeviceInfo->AddressSizeOffset, &CurrentOffset); + for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) + { + Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size, +@@ -471,7 +484,7 @@ + + /* NamespaceString device identifier (Required, size = NamePathLength) */ + +- DeviceInfo->NamepathOffset = CurrentOffset; ++ ACPI_MOVE_16_TO_16(&DeviceInfo->NamepathOffset, &CurrentOffset); + Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name, + &Subtable, TRUE); + if (ACPI_FAILURE (Status)) +@@ -481,8 +494,9 @@ + + /* Update the device info header */ + +- DeviceInfo->NamepathLength = (UINT16) Subtable->Length; +- CurrentOffset += (UINT16) DeviceInfo->NamepathLength; ++ ACPI_MOVE_32_TO_16(&DeviceInfo->NamepathLength, &Subtable->Length); ++ ACPI_MOVE_16_TO_16(&Tmp16, &DeviceInfo->NamepathLength); ++ CurrentOffset += Tmp16; + DtInsertSubtable (ParentTable, Subtable); + + /* OemData - Variable-length data (Optional, size = OemDataLength) */ +@@ -503,8 +517,8 @@ + + if (Subtable && Subtable->Length) + { +- DeviceInfo->OemDataOffset = CurrentOffset; +- DeviceInfo->OemDataLength = (UINT16) Subtable->Length; ++ ACPI_MOVE_16_TO_16(&DeviceInfo->OemDataOffset, &CurrentOffset); ++ ACPI_MOVE_32_TO_16(&DeviceInfo->OemDataLength, &Subtable->Length); + + DtInsertSubtable (ParentTable, Subtable); + } +@@ -544,6 +558,8 @@ + ACPI_DMAR_DEVICE_SCOPE *DmarDeviceScope; + UINT32 DeviceScopeLength; + UINT32 PciPathLength; ++ UINT16 Tmp16; ++ UINT16 HdrType; + + + Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE); +@@ -573,8 +589,11 @@ + DtPushSubtable (Subtable); + + DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer); ++ ACPI_MOVE_16_TO_16(&Tmp16, &DmarHeader->Length); ++ DmarHeader->Length = Tmp16; + +- switch (DmarHeader->Type) ++ ACPI_MOVE_16_TO_16(&HdrType, &DmarHeader->Type); ++ switch (HdrType) + { + case ACPI_DMAR_TYPE_HARDWARE_UNIT: + +@@ -621,8 +640,8 @@ + /* + * Optional Device Scope subtables + */ +- if ((DmarHeader->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || +- (DmarHeader->Type == ACPI_DMAR_TYPE_NAMESPACE)) ++ if ((HdrType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || ++ (HdrType == ACPI_DMAR_TYPE_NAMESPACE)) + { + /* These types do not support device scopes */ + +@@ -631,8 +650,8 @@ + } + + DtPushSubtable (Subtable); +- DeviceScopeLength = DmarHeader->Length - Subtable->Length - +- ParentTable->Length; ++ DeviceScopeLength = DmarHeader->Length - Subtable->Length - ++ ParentTable->Length; + while (DeviceScopeLength) + { + Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope, +@@ -757,7 +776,7 @@ + Count++; + } + +- DrtmVtl->ValidatedTableCount = Count; ++ ACPI_MOVE_32_TO_32(&DrtmVtl->ValidatedTableCount, &Count); + DtPopSubtable (); + ParentTable = DtPeekSubtable (); + +@@ -795,7 +814,7 @@ + Count++; + } + +- DrtmRl->ResourceCount = Count; ++ ACPI_MOVE_32_TO_32(&DrtmRl->ResourceCount, &Count); + DtPopSubtable (); + ParentTable = DtPeekSubtable (); + +@@ -889,6 +908,7 @@ + ACPI_SUBTABLE_HEADER *GtdtHeader; + ACPI_DMTABLE_INFO *InfoTable; + UINT32 GtCount; ++ ACPI_GTDT_TIMER_BLOCK *TimerBlock; + + + Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt, +@@ -955,8 +975,9 @@ + DtPushSubtable (Subtable); + ParentTable = DtPeekSubtable (); + +- GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, +- Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount; ++ TimerBlock = ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, ++ Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)); ++ ACPI_MOVE_32_TO_32(&GtCount, &TimerBlock->TimerCount); + + while (GtCount) + { +@@ -1009,6 +1030,7 @@ + ACPI_DMTABLE_INFO *InfoTable; + DT_FIELD **PFieldList = (DT_FIELD **) List; + DT_FIELD *SubtableStart; ++ UINT16 HdrType; + + + while (*PFieldList) +@@ -1027,7 +1049,8 @@ + + FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); + +- switch (FpdtHeader->Type) ++ ACPI_MOVE_16_TO_16(&HdrType, &FpdtHeader->Type); ++ switch (HdrType) + { + case ACPI_FPDT_TYPE_BOOT: + +@@ -1085,6 +1108,7 @@ + ACPI_DMTABLE_INFO *InfoTable; + UINT16 Type; + UINT32 BankCount; ++ UINT16 Tmp16; + + + Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest, +@@ -1102,8 +1126,9 @@ + /* Get subtable type */ + + SubtableStart = *PFieldList; +- DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0); ++ DtCompileInteger ((UINT8 *) &Tmp16, *PFieldList, 2, 0); + ++ ACPI_MOVE_16_TO_16(&Type, &Tmp16); + switch (Type) + { + case ACPI_HEST_TYPE_IA32_CHECK: +@@ -1225,11 +1250,13 @@ + ACPI_IORT_SMMU *IortSmmu; + UINT32 NodeNumber; + UINT32 NodeLength; ++ UINT32 NodeOffset; + UINT32 IdMappingNumber; + UINT32 ItsNumber; + UINT32 ContextIrptNumber; + UINT32 PmuIrptNumber; + UINT32 PaddingLength; ++ UINT32 MappingOffset; + + + ParentTable = DtPeekSubtable (); +@@ -1255,7 +1282,7 @@ + * Optionally allows the generic data types to be used for filling + * this field. + */ +- Iort->NodeOffset = sizeof (ACPI_TABLE_IORT); ++ NodeOffset = sizeof (ACPI_TABLE_IORT); + Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad, + &Subtable, TRUE); + if (ACPI_FAILURE (Status)) +@@ -1265,7 +1292,7 @@ + if (Subtable) + { + DtInsertSubtable (ParentTable, Subtable); +- Iort->NodeOffset += Subtable->Length; ++ NodeOffset += Subtable->Length; + } + else + { +@@ -1275,8 +1302,9 @@ + { + return (Status); + } +- Iort->NodeOffset += PaddingLength; ++ NodeOffset += PaddingLength; + } ++ ACPI_MOVE_32_TO_32(&Iort->NodeOffset, &NodeOffset); + + NodeNumber = 0; + while (*PFieldList) +@@ -1330,7 +1358,7 @@ + ItsNumber++; + } + +- IortItsGroup->ItsCount = ItsNumber; ++ ACPI_MOVE_32_TO_32(&IortItsGroup->ItsCount, &ItsNumber); + break; + + case ACPI_IORT_NODE_NAMED_COMPONENT: +@@ -1364,15 +1392,16 @@ + } + else + { +- if (NodeLength > IortNode->MappingOffset) ++ ACPI_MOVE_32_TO_32(&MappingOffset, &IortNode->MappingOffset); ++ if (NodeLength > MappingOffset) + { + return (AE_BAD_DATA); + } + +- if (NodeLength < IortNode->MappingOffset) ++ if (NodeLength < MappingOffset) + { + Status = DtCompilePadding ( +- IortNode->MappingOffset - NodeLength, ++ MappingOffset - NodeLength, + &Subtable); + if (ACPI_FAILURE (Status)) + { +@@ -1380,7 +1409,8 @@ + } + + DtInsertSubtable (ParentTable, Subtable); +- NodeLength = IortNode->MappingOffset; ++ ACPI_MOVE_32_TO_32(&MappingOffset, &IortNode->MappingOffset); ++ NodeLength = MappingOffset; + } + } + break; +@@ -1413,7 +1443,7 @@ + + /* Compile global interrupt array */ + +- IortSmmu->GlobalInterruptOffset = NodeLength; ++ ACPI_MOVE_32_TO_32(&IortSmmu->GlobalInterruptOffset, &NodeLength); + Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a, + &Subtable, TRUE); + if (ACPI_FAILURE (Status)) +@@ -1427,7 +1457,7 @@ + /* Compile context interrupt array */ + + ContextIrptNumber = 0; +- IortSmmu->ContextInterruptOffset = NodeLength; ++ ACPI_MOVE_32_TO_32(&IortSmmu->ContextInterruptOffset, &NodeLength); + while (*PFieldList) + { + Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b, +@@ -1447,12 +1477,12 @@ + ContextIrptNumber++; + } + +- IortSmmu->ContextInterruptCount = ContextIrptNumber; ++ ACPI_MOVE_32_TO_32(&IortSmmu->ContextInterruptCount, &ContextIrptNumber); + + /* Compile PMU interrupt array */ + + PmuIrptNumber = 0; +- IortSmmu->PmuInterruptOffset = NodeLength; ++ ACPI_MOVE_32_TO_32(&IortSmmu->PmuInterruptOffset, &NodeLength); + while (*PFieldList) + { + Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c, +@@ -1472,7 +1502,7 @@ + PmuIrptNumber++; + } + +- IortSmmu->PmuInterruptCount = PmuIrptNumber; ++ ACPI_MOVE_32_TO_32(&IortSmmu->PmuInterruptCount, &PmuIrptNumber); + break; + + case ACPI_IORT_NODE_SMMU_V3: +@@ -1496,7 +1526,7 @@ + + /* Compile Array of ID mappings */ + +- IortNode->MappingOffset = NodeLength; ++ ACPI_MOVE_32_TO_32(&IortNode->MappingOffset, &NodeLength); + IdMappingNumber = 0; + while (*PFieldList) + { +@@ -1517,7 +1547,7 @@ + IdMappingNumber++; + } + +- IortNode->MappingCount = IdMappingNumber; ++ ACPI_MOVE_32_TO_32(&IortNode->MappingCount, &IdMappingNumber); + + /* + * Node length can be determined by DT_LENGTH option +@@ -1528,7 +1558,7 @@ + NodeNumber++; + } + +- Iort->NodeCount = NodeNumber; ++ ACPI_MOVE_32_TO_32(&Iort->NodeCount, &NodeNumber); + return (AE_OK); + } + +diff -Naur acpica-unix2-20160930/source/compiler/dttable2.c acpica-unix2-20160930-s390/source/compiler/dttable2.c +--- acpica-unix2-20160930/source/compiler/dttable2.c 2016-09-30 10:43:57.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/compiler/dttable2.c 2016-12-09 17:35:52.483785207 -0700 +@@ -346,7 +346,7 @@ + DtPushSubtable (Subtable); + + MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer); +- SubtableCount = MpstChannelInfo->PowerNodeCount; ++ ACPI_MOVE_16_TO_16(&SubtableCount, &MpstChannelInfo->PowerNodeCount); + + while (*PFieldList && SubtableCount) + { +@@ -364,8 +364,8 @@ + DtPushSubtable (Subtable); + + MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer); +- PowerStateCount = MpstPowerNode->NumPowerStates; +- ComponentCount = MpstPowerNode->NumPhysicalComponents; ++ ACPI_MOVE_32_TO_32(&PowerStateCount, &MpstPowerNode->NumPowerStates); ++ ACPI_MOVE_32_TO_32(&ComponentCount, &MpstPowerNode->NumPhysicalComponents); + + ParentTable = DtPeekSubtable (); + +@@ -518,6 +518,7 @@ + UINT32 Count; + ACPI_NFIT_INTERLEAVE *Interleave = NULL; + ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; ++ UINT16 SubType; + + + /* Main table */ +@@ -551,7 +552,8 @@ + + NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer); + +- switch (NfitHeader->Type) ++ ACPI_MOVE_16_TO_16(&SubType, &NfitHeader->Type); ++ switch (SubType) + { + case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: + +@@ -606,7 +608,7 @@ + DtInsertSubtable (ParentTable, Subtable); + DtPopSubtable (); + +- switch (NfitHeader->Type) ++ switch (SubType) + { + case ACPI_NFIT_TYPE_INTERLEAVE: + +@@ -632,7 +634,7 @@ + Count++; + } + +- Interleave->LineCount = Count; ++ ACPI_MOVE_32_TO_32(&Interleave->LineCount, &Count); + DtPopSubtable (); + break; + +@@ -678,7 +680,7 @@ + Count++; + } + +- Hint->HintCount = (UINT16) Count; ++ ACPI_MOVE_32_TO_16(&Hint->HintCount, &Count); + DtPopSubtable (); + break; + +@@ -885,7 +887,7 @@ + + PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER, + (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER))); +- DomainCount = PmttController->DomainCount; ++ ACPI_MOVE_16_TO_16(&DomainCount, &PmttController->DomainCount); + + while (DomainCount) + { +@@ -986,6 +988,7 @@ + DT_SUBTABLE *ParentTable; + ACPI_DMTABLE_INFO *InfoTable; + DT_FIELD *SubtableStart; ++ UINT16 HdrType; + + + Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, +@@ -1013,7 +1016,8 @@ + + S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); + +- switch (S3ptHeader->Type) ++ ACPI_MOVE_16_TO_16(&HdrType, &S3ptHeader->Type); ++ switch (HdrType) + { + case ACPI_S3PT_TYPE_RESUME: + +@@ -1110,6 +1114,7 @@ + DT_FIELD *FieldList; + UINT32 Localities; + UINT8 *LocalityBuffer; ++ UINT32 Tmp; + + + Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, +@@ -1122,7 +1127,8 @@ + ParentTable = DtPeekSubtable (); + DtInsertSubtable (ParentTable, Subtable); + +- Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); ++ Tmp = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); ++ ACPI_MOVE_32_TO_32(&Localities, &Tmp); + LocalityBuffer = UtLocalCalloc (Localities); + + /* Compile each locality buffer */ +@@ -1311,6 +1317,7 @@ + ACPI_TABLE_TCPA_HDR *TcpaHeader; + DT_SUBTABLE *ParentTable; + ACPI_STATUS Status; ++ UINT16 PlatClass; + + + /* Compile the main table */ +@@ -1331,7 +1338,8 @@ + */ + TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); + +- switch (TcpaHeader->PlatformClass) ++ ACPI_MOVE_16_TO_16(&PlatClass, &TcpaHeader->PlatformClass); ++ switch (PlatClass) + { + case ACPI_TCPA_CLIENT_TABLE: + +@@ -1527,6 +1535,9 @@ + ACPI_TABLE_WPBT *Table; + ACPI_STATUS Status; + UINT16 Length; ++ UINT16 Tmp16; ++ UINT16 *Ptr16; ++ UINT32 ii; + + + /* Compile the main table */ +@@ -1554,7 +1565,16 @@ + + Length = (UINT16) Subtable->TotalLength; + Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); +- Table->ArgumentsLength = Length; ++ ACPI_MOVE_16_TO_16(&Table->ArgumentsLength, &Length); ++ ++ /* The arguments are in Unicode, so make sure the byte order is correct */ ++ Ptr16 = (UINT16 *)Subtable->Buffer; ++ for (ii = 0; ii < Length; ii++) ++ { ++ ACPI_MOVE_16_TO_16(&Tmp16, Ptr16); ++ *Ptr16 = Tmp16; ++ Ptr16++; ++ } + + ParentTable = DtPeekSubtable (); + DtInsertSubtable (ParentTable, Subtable); +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmbuffer.c acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c +--- acpica-unix2-20160930/source/components/disassembler/dmbuffer.c 2016-12-06 19:25:49.303453108 -0700 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c 2016-12-09 14:27:06.193785207 -0700 +@@ -425,7 +425,8 @@ + /* Extract the byte list info */ + + ByteData = NextOp->Named.Data; +- ByteCount = (UINT32) NextOp->Common.Value.Integer; ++ /* ByteCount = (UINT32) NextOp->Common.Value.Integer; */ ++ ByteCount = (UINT32) NextOp->Common.Value.Size; + WordCount = ACPI_DIV_2 (ByteCount); + + /* +@@ -834,19 +835,22 @@ + UINT32 WordCount; + UINT32 i; + int OutputValue; ++ UINT16 Tmp16; + + + /* Extract the buffer info as a WORD buffer */ + + WordData = ACPI_CAST_PTR (UINT16, Op->Named.Data); +- WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Integer)); ++ WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Size)); + + /* Write every other byte as an ASCII character */ + + AcpiOsPrintf ("\""); + for (i = 0; i < (WordCount - 1); i++) + { +- OutputValue = (int) WordData[i]; ++ /* OutputValue = (int) WordData[i]; */ ++ ACPI_MOVE_16_TO_16(&Tmp16, &WordData[i]); ++ OutputValue = (int) Tmp16; + + /* Handle values that must be escaped */ + +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcl2.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl2.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrcl2.c 2016-09-30 10:43:58.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl2.c 2016-12-09 16:23:07.283785207 -0700 +@@ -191,22 +191,24 @@ + char *DeviceName = NULL; + UINT32 PinCount; + UINT32 i; ++ UINT16 Tmp16; + + + /* ResourceSource, ResourceSourceIndex, ResourceType */ + + AcpiDmIndent (Level + 1); +- if (Resource->Gpio.ResSourceOffset) ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.ResSourceOffset); ++ if (Tmp16) + { +- DeviceName = ACPI_ADD_PTR (char, +- Resource, Resource->Gpio.ResSourceOffset), ++ DeviceName = ACPI_ADD_PTR (char, Resource, Tmp16), + AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX); + } + + AcpiOsPrintf (", "); + AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.ResSourceIndex); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.Flags); + AcpiOsPrintf ("%s, ", +- AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.Flags)]); ++ AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Tmp16)]); + + /* Insert a descriptor name */ + +@@ -215,15 +217,16 @@ + + /* Dump the vendor data */ + +- if (Resource->Gpio.VendorOffset) ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorOffset); ++ if (Tmp16) + { + AcpiOsPrintf ("\n"); + AcpiDmIndent (Level + 1); +- VendorData = ACPI_ADD_PTR (UINT8, Resource, +- Resource->Gpio.VendorOffset); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorOffset); ++ VendorData = ACPI_ADD_PTR (UINT8, Resource, Tmp16); + +- AcpiDmDumpRawDataBuffer (VendorData, +- Resource->Gpio.VendorLength, Level); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorLength); ++ AcpiDmDumpRawDataBuffer (VendorData, Tmp16, Level); + } + + AcpiOsPrintf (")\n"); +@@ -233,17 +236,25 @@ + AcpiDmIndent (Level + 1); + AcpiOsPrintf ("{ // Pin list\n"); + ++ /* + PinCount = ((UINT32) (Resource->Gpio.ResSourceOffset - + Resource->Gpio.PinTableOffset)) / + sizeof (UINT16); ++ */ ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.ResSourceOffset); ++ PinCount = (UINT32) Tmp16; ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.PinTableOffset); ++ PinCount -= (UINT32) Tmp16; ++ PinCount /= sizeof (UINT16); + +- PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource, +- Resource->Gpio.PinTableOffset); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.PinTableOffset); ++ PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource, Tmp16); + + for (i = 0; i < PinCount; i++) + { + AcpiDmIndent (Level + 2); +- AcpiOsPrintf ("0x%4.4X%s\n", PinList[i], ++ ACPI_MOVE_16_TO_16(&Tmp16, &PinList[i]); ++ AcpiOsPrintf ("0x%4.4X%s\n", Tmp16, + ((i + 1) < PinCount) ? "," : ""); + } + +@@ -277,16 +288,18 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT16 Tmp16; + + /* Dump the GpioInt-specific portion of the descriptor */ + + /* EdgeLevel, ActiveLevel, Shared */ + + AcpiDmIndent (Level); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags); + AcpiOsPrintf ("GpioInt (%s, %s, %s, ", +- AcpiGbl_HeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.IntFlags)], +- AcpiGbl_LlDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 1)], +- AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]); ++ AcpiGbl_HeDecode [ACPI_GET_1BIT_FLAG (Tmp16)], ++ AcpiGbl_LlDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 1)], ++ AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 3)]); + + /* PinConfig, DebounceTimeout */ + +@@ -299,7 +312,8 @@ + { + AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.PinConfig); + } +- AcpiOsPrintf ("0x%4.4X,\n", Resource->Gpio.DebounceTimeout); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DebounceTimeout); ++ AcpiOsPrintf ("0x%4.4X,\n", Tmp16); + + /* Dump the GpioInt/GpioIo common portion of the descriptor */ + +@@ -329,14 +343,16 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT16 Tmp16; + + /* Dump the GpioIo-specific portion of the descriptor */ + + /* Shared, PinConfig */ + + AcpiDmIndent (Level); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags); + AcpiOsPrintf ("GpioIo (%s, ", +- AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]); ++ AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 3)]); + + if (Resource->Gpio.PinConfig <= 3) + { +@@ -350,10 +366,13 @@ + + /* DebounceTimeout, DriveStrength, IoRestriction */ + +- AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DebounceTimeout); +- AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DriveStrength); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DebounceTimeout); ++ AcpiOsPrintf ("0x%4.4X, ", Tmp16); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DriveStrength); ++ AcpiOsPrintf ("0x%4.4X, ", Tmp16); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags); + AcpiOsPrintf ("%s,\n", +- AcpiGbl_IorDecode [ACPI_GET_2BIT_FLAG (Resource->Gpio.IntFlags)]); ++ AcpiGbl_IorDecode [ACPI_GET_2BIT_FLAG (Tmp16)]); + + /* Dump the GpioInt/GpioIo common portion of the descriptor */ + +@@ -427,6 +446,7 @@ + { + UINT8 *VendorData; + UINT32 VendorLength; ++ UINT16 Tmp16; + + + /* Get the (optional) vendor data and length */ +@@ -435,8 +455,8 @@ + { + case AML_RESOURCE_I2C_SERIALBUSTYPE: + +- VendorLength = Resource->CommonSerialBus.TypeDataLength - +- AML_RESOURCE_I2C_MIN_DATA_LEN; ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength); ++ VendorLength = Tmp16 - AML_RESOURCE_I2C_MIN_DATA_LEN; + + VendorData = ACPI_ADD_PTR (UINT8, Resource, + sizeof (AML_RESOURCE_I2C_SERIALBUS)); +@@ -444,8 +464,8 @@ + + case AML_RESOURCE_SPI_SERIALBUSTYPE: + +- VendorLength = Resource->CommonSerialBus.TypeDataLength - +- AML_RESOURCE_SPI_MIN_DATA_LEN; ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength); ++ VendorLength = Tmp16 - AML_RESOURCE_SPI_MIN_DATA_LEN; + + VendorData = ACPI_ADD_PTR (UINT8, Resource, + sizeof (AML_RESOURCE_SPI_SERIALBUS)); +@@ -453,8 +473,8 @@ + + case AML_RESOURCE_UART_SERIALBUSTYPE: + +- VendorLength = Resource->CommonSerialBus.TypeDataLength - +- AML_RESOURCE_UART_MIN_DATA_LEN; ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength); ++ VendorLength = Tmp16 - AML_RESOURCE_UART_MIN_DATA_LEN; + + VendorData = ACPI_ADD_PTR (UINT8, Resource, + sizeof (AML_RESOURCE_UART_SERIALBUS)); +@@ -495,15 +515,19 @@ + { + UINT32 ResourceSourceOffset; + char *DeviceName; ++ UINT16 Tmp16; ++ UINT32 Tmp32; + + + /* SlaveAddress, SlaveMode, ConnectionSpeed, AddressingMode */ + ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->I2cSerialBus.SlaveAddress); ++ ACPI_MOVE_32_TO_32(&Tmp32, &Resource->I2cSerialBus.ConnectionSpeed); + AcpiDmIndent (Level); + AcpiOsPrintf ("I2cSerialBusV2 (0x%4.4X, %s, 0x%8.8X,\n", +- Resource->I2cSerialBus.SlaveAddress, ++ Tmp16, + AcpiGbl_SmDecode [ACPI_GET_1BIT_FLAG (Resource->I2cSerialBus.Flags)], +- Resource->I2cSerialBus.ConnectionSpeed); ++ Tmp32); + + AcpiDmIndent (Level + 1); + AcpiOsPrintf ("%s, ", +@@ -511,8 +535,8 @@ + + /* ResourceSource is a required field */ + +- ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) + +- Resource->CommonSerialBus.TypeDataLength; ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength); ++ ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) + Tmp16; + + DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset); + AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX); +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcl.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrcl.c 2016-12-06 19:25:49.303453108 -0700 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c 2016-12-08 16:33:58.673785207 -0700 +@@ -917,6 +917,7 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT64 Tmp64; + + AcpiDmIndent (Level); + AcpiOsPrintf ("Register ("); +@@ -930,7 +931,9 @@ + AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset"); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address"); ++ /* AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address"); */ ++ ACPI_MOVE_64_TO_64(&Tmp64, &Resource->GenericReg.Address); ++ AcpiDmDumpInteger64 (Tmp64, "Address"); + + /* Optional field for ACPI 3.0 */ + +diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcs.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c +--- acpica-unix2-20160930/source/components/disassembler/dmresrcs.c 2016-12-06 19:25:49.304453101 -0700 ++++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c 2016-12-09 16:56:26.153785207 -0700 +@@ -256,12 +256,14 @@ + UINT32 Length, + UINT32 Level) + { ++ UINT16 Tmp16; + + AcpiDmIndent (Level); + AcpiOsPrintf ("FixedIO (\n"); + + AcpiDmIndent (Level + 1); +- AcpiDmDumpInteger16 (Resource->FixedIo.Address, "Address"); ++ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->FixedIo.Address); ++ AcpiDmDumpInteger16 (Tmp16, "Address"); + + AcpiDmIndent (Level + 1); + AcpiDmDumpInteger8 (Resource->FixedIo.AddressLength, "Length"); +diff -Naur acpica-unix2-20160930/source/components/namespace/nsaccess.c acpica-unix2-20160930-s390/source/components/namespace/nsaccess.c +--- acpica-unix2-20160930/source/components/namespace/nsaccess.c 2016-09-30 10:43:59.000000000 -0600 ++++ acpica-unix2-20160930-s390/source/components/namespace/nsaccess.c 2016-12-08 17:11:07.563785207 -0700 +@@ -309,6 +309,7 @@ + ACPI_OBJECT_TYPE ThisSearchType; + UINT32 SearchParentFlag = ACPI_NS_SEARCH_PARENT; + UINT32 LocalFlags; ++ UINT32 Tmp32; + + + ACPI_FUNCTION_TRACE (NsLookup); +@@ -657,9 +658,10 @@ + { + /* Complain about a type mismatch */ + ++ ACPI_MOVE_32_TO_32(&Tmp32, &SimpleName); + ACPI_WARNING ((AE_INFO, + "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)", +- ACPI_CAST_PTR (char, &SimpleName), ++ ACPI_CAST_PTR (char, &Tmp32), + AcpiUtGetTypeName (ThisNode->Type), + AcpiUtGetTypeName (TypeToCheckFor))); + } +diff -Naur acpica-unix2-20160930/source/include/acmacros.h acpica-unix2-20160930-s390/source/include/acmacros.h +--- acpica-unix2-20160930/source/include/acmacros.h 2016-12-06 19:25:49.285453239 -0700 ++++ acpica-unix2-20160930-s390/source/include/acmacros.h 2016-12-06 11:58:04.563785207 -0700 +@@ -98,7 +98,9 @@ + ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\ + ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];} + +-/* 32-bit source, 16/32/64 destination */ ++/* 32-bit source, 8/16/32/64 destination */ ++ ++#define ACPI_MOVE_32_TO_8(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];} + + #define ACPI_MOVE_32_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\ + (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];} +@@ -114,7 +116,9 @@ + ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\ + ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];} + +-/* 64-bit source, 16/32/64 destination */ ++/* 64-bit source, 8/16/32/64 destination */ ++ ++#define ACPI_MOVE_64_TO_8(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];} + + #define ACPI_MOVE_64_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\ + (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];} +@@ -141,13 +145,16 @@ + + /* The hardware supports unaligned transfers, just do the little-endian move */ + +-/* 16-bit source, 16/32/64 destination */ ++/* 16-bit source, 8/16/32/64 destination */ + ++#define ACPI_MOVE_16_TO_8(d, s) *(UINT8 *)(void *)(d) = *(UINT16 *)(void *)(s) + #define ACPI_MOVE_16_TO_16(d, s) *(UINT16 *)(void *)(d) = *(UINT16 *)(void *)(s) + #define ACPI_MOVE_16_TO_32(d, s) *(UINT32 *)(void *)(d) = *(UINT16 *)(void *)(s) + #define ACPI_MOVE_16_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT16 *)(void *)(s) + +-/* 32-bit source, 16/32/64 destination */ ++/* 32-bit source, 8/16/32/64 destination */ ++ ++#define ACPI_MOVE_32_TO_8(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];} + + #define ACPI_MOVE_32_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\ + (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];} +@@ -155,8 +162,9 @@ + #define ACPI_MOVE_32_TO_32(d, s) *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s) + #define ACPI_MOVE_32_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s) + +-/* 64-bit source, 16/32/64 destination */ ++/* 64-bit source, 8/16/32/64 destination */ + ++#define ACPI_MOVE_64_TO_8(d, s) ACPI_MOVE_16_TO_8(d, s) /* Truncate to 8 */ + #define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ + #define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ + #define ACPI_MOVE_64_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT64 *)(void *)(s) +@@ -176,7 +184,9 @@ + #define ACPI_MOVE_16_TO_32(d, s) {(*(UINT32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} + #define ACPI_MOVE_16_TO_64(d, s) {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} + +-/* 32-bit source, 16/32/64 destination */ ++/* 32-bit source, 8/16/32/64 destination */ ++ ++#define ACPI_MOVE_32_TO_8(d, s) ACPI_MOVE_16_TO_8(d, s) /* Truncate to 8 */ + + #define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ + diff --git a/big-endian-v2.patch b/big-endian-v2.patch deleted file mode 100644 index 57ae3db..0000000 --- a/big-endian-v2.patch +++ /dev/null @@ -1,2536 +0,0 @@ -diff -Naur acpica-unix2-20160930/source/common/acfileio.c acpica-unix2-20160930-s390/source/common/acfileio.c ---- acpica-unix2-20160930/source/common/acfileio.c 2016-09-30 10:43:55.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/common/acfileio.c 2016-10-28 14:25:41.845397957 -0600 -@@ -241,6 +241,7 @@ - ACPI_TABLE_HEADER *Table; - INT32 Count; - long TableOffset; -+ UINT32 TableLen; - - - *ReturnTable = NULL; -@@ -281,7 +282,8 @@ - - /* Allocate a buffer for the entire table */ - -- Table = AcpiOsAllocate ((ACPI_SIZE) TableHeader.Length); -+ ACPI_MOVE_32_TO_32(&TableLen, &TableHeader.Length); -+ Table = AcpiOsAllocate ((ACPI_SIZE) TableLen); - if (!Table) - { - return (AE_NO_MEMORY); -@@ -291,8 +293,8 @@ - - fseek (File, TableOffset, SEEK_SET); - -- Count = fread (Table, 1, TableHeader.Length, File); -- if (Count != (INT32) TableHeader.Length) -+ Count = fread (Table, 1, TableLen, File); -+ if (Count != (INT32) TableLen) - { - Status = AE_ERROR; - goto ErrorExit; -@@ -300,7 +302,7 @@ - - /* Validate the checksum (just issue a warning) */ - -- Status = AcpiTbVerifyChecksum (Table, TableHeader.Length); -+ Status = AcpiTbVerifyChecksum (Table, TableLen); - if (ACPI_FAILURE (Status)) - { - Status = AcCheckTextModeCorruption (Table); -@@ -392,6 +394,7 @@ - ACPI_SIZE Actual; - long OriginalOffset; - UINT32 FileSize; -+ UINT32 TableLength; - UINT32 i; - - -@@ -423,11 +426,12 @@ - /* Validate table length against bytes remaining in the file */ - - FileSize = CmGetFileSize (File); -- if (TableHeader.Length > (UINT32) (FileSize - TableOffset)) -+ ACPI_MOVE_32_TO_32(&TableLength, &TableHeader.Length); -+ if (TableLength > (UINT32) (FileSize - TableOffset)) - { - fprintf (stderr, "Table [%4.4s] is too long for file - " - "needs: 0x%.2X, remaining in file: 0x%.2X\n", -- TableHeader.Signature, TableHeader.Length, -+ TableHeader.Signature, TableLength, - (UINT32) (FileSize - TableOffset)); - return (AE_BAD_HEADER); - } -diff -Naur acpica-unix2-20160930/source/common/ahpredef.c acpica-unix2-20160930-s390/source/common/ahpredef.c ---- acpica-unix2-20160930/source/common/ahpredef.c 2016-09-30 10:43:56.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/common/ahpredef.c 2016-10-28 14:25:41.844397962 -0600 -@@ -358,7 +358,7 @@ - char *Nameseg) - { - const AH_PREDEFINED_NAME *Info; -- -+ - - for (Info = AslPredefinedInfo; Info->Name; Info++) - { -diff -Naur acpica-unix2-20160930/source/common/dmtable.c acpica-unix2-20160930-s390/source/common/dmtable.c ---- acpica-unix2-20160930/source/common/dmtable.c 2016-09-30 10:43:56.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/common/dmtable.c 2016-10-28 14:25:41.840397982 -0600 -@@ -499,7 +499,7 @@ - */ - if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS)) - { -- Length = Table->Length; -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs); - if (ACPI_FAILURE (Status)) - { -@@ -513,13 +513,14 @@ - else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_S3PT)) - { - Length = AcpiDmDumpS3pt (Table); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - } - else - { - /* - * All other tables must use the common ACPI table header, dump it now - */ -- Length = Table->Length; -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader); - if (ACPI_FAILURE (Status)) - { -@@ -730,6 +731,7 @@ - BOOLEAN LastOutputBlankLine = FALSE; - ACPI_STATUS Status; - char RepairedName[8]; -+ UINT16 Val16; - - - if (!Info) -@@ -1097,8 +1099,9 @@ - /* Checksum, display and validate */ - - AcpiOsPrintf ("%2.2X", *Target); -- Temp8 = AcpiDmGenerateChecksum (Table, -- ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length, -+ ACPI_MOVE_32_TO_32(&Temp32, -+ &ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length); -+ Temp8 = AcpiDmGenerateChecksum (Table, Temp32, - ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum); - - if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum) -@@ -1163,14 +1166,14 @@ - - /* DMAR subtable types */ - -- Temp16 = ACPI_GET16 (Target); -+ Val16 = ACPI_GET16 (Target); -+ ACPI_MOVE_16_TO_16(&Temp16, &Val16); - if (Temp16 > ACPI_DMAR_TYPE_RESERVED) - { - Temp16 = ACPI_DMAR_TYPE_RESERVED; - } - -- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), -- AcpiDmDmarSubnames[Temp16]); -+ AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmDmarSubnames[Temp16]); - break; - - case ACPI_DMT_DMAR_SCOPE: -@@ -1261,14 +1264,14 @@ - - /* HEST subtable types */ - -- Temp16 = ACPI_GET16 (Target); -+ Val16 = ACPI_GET16 (Target); -+ ACPI_MOVE_16_TO_16(&Temp16, &Val16); - if (Temp16 > ACPI_HEST_TYPE_RESERVED) - { - Temp16 = ACPI_HEST_TYPE_RESERVED; - } - -- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), -- AcpiDmHestSubnames[Temp16]); -+ AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmHestSubnames[Temp16]); - break; - - case ACPI_DMT_HESTNTFY: -@@ -1334,13 +1337,14 @@ - - /* NFIT subtable types */ - -- Temp16 = ACPI_GET16 (Target); -+ Val16 = ACPI_GET16 (Target); -+ ACPI_MOVE_16_TO_16(&Temp16, &Val16); - if (Temp16 > ACPI_NFIT_TYPE_RESERVED) - { - Temp16 = ACPI_NFIT_TYPE_RESERVED; - } - -- AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), -+ AcpiOsPrintf (UINT16_FORMAT, Temp16, - AcpiDmNfitSubnames[Temp16]); - break; - -diff -Naur acpica-unix2-20160930/source/common/dmtables.c acpica-unix2-20160930-s390/source/common/dmtables.c ---- acpica-unix2-20160930/source/common/dmtables.c 2016-09-30 10:43:56.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/common/dmtables.c 2016-10-28 14:25:41.844397962 -0600 -@@ -140,7 +140,9 @@ - ACPI_TABLE_HEADER *Table) - { - UINT8 Checksum; -- -+ UINT32 TableLen; -+ UINT32 OemRev; -+ UINT32 CompilerRev; - - /* Reset globals for External statements */ - -@@ -152,9 +154,10 @@ - */ - AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE); - -+ ACPI_MOVE_32_TO_32(&TableLen, &Table->Length); - AcpiOsPrintf (" * Original Table Header:\n"); - AcpiOsPrintf (" * Signature \"%4.4s\"\n", Table->Signature); -- AcpiOsPrintf (" * Length 0x%8.8X (%u)\n", Table->Length, Table->Length); -+ AcpiOsPrintf (" * Length 0x%8.8X (%u)\n", TableLen, TableLen); - - /* Print and validate the revision */ - -@@ -186,7 +189,7 @@ - - AcpiOsPrintf ("\n * Checksum 0x%2.2X", Table->Checksum); - -- Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length); -+ Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), TableLen); - if (Checksum) - { - AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X", -@@ -196,9 +199,11 @@ - AcpiOsPrintf ("\n"); - AcpiOsPrintf (" * OEM ID \"%.6s\"\n", Table->OemId); - AcpiOsPrintf (" * OEM Table ID \"%.8s\"\n", Table->OemTableId); -- AcpiOsPrintf (" * OEM Revision 0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision); -+ ACPI_MOVE_32_TO_32(&OemRev, &Table->OemRevision); -+ AcpiOsPrintf (" * OEM Revision 0x%8.8X (%u)\n", OemRev, OemRev); - AcpiOsPrintf (" * Compiler ID \"%.4s\"\n", Table->AslCompilerId); -- AcpiOsPrintf (" * Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision); -+ ACPI_MOVE_32_TO_32(&CompilerRev, &Table->AslCompilerRevision); -+ AcpiOsPrintf (" * Compiler Version 0x%8.8X (%u)\n", CompilerRev, CompilerRev); - AcpiOsPrintf (" */\n"); - - /* -@@ -211,7 +216,7 @@ - AcpiOsPrintf ( - "DefinitionBlock (\"\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n", - Table->Signature, Table->Revision, -- Table->OemId, Table->OemTableId, Table->OemRevision); -+ Table->OemId, Table->OemTableId, OemRev); - } - - -@@ -386,7 +391,8 @@ - - fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature); - -- AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER); -+ ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length); -+ AmlLength -= sizeof (ACPI_TABLE_HEADER); - AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER)); - - /* Create the root object */ -diff -Naur acpica-unix2-20160930/source/common/dmtbdump.c acpica-unix2-20160930-s390/source/common/dmtbdump.c ---- acpica-unix2-20160930/source/common/dmtbdump.c 2016-09-30 10:43:56.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/common/dmtbdump.c 2016-10-28 14:25:41.841397977 -0600 -@@ -296,6 +296,8 @@ - UINT32 Entries; - UINT32 Offset; - UINT32 i; -+ UINT32 Length; -+ UINT32 Address; - - - /* Point to start of table pointer array */ -@@ -305,12 +307,14 @@ - - /* RSDT uses 32-bit pointers */ - -- Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); - - for (i = 0; i < Entries; i++) - { - AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); -- AcpiOsPrintf ("%8.8X\n", Array[i]); -+ ACPI_MOVE_32_TO_32(&Address, &Array[i]); -+ AcpiOsPrintf ("%8.8X\n", Address); - Offset += sizeof (UINT32); - } - } -@@ -336,6 +340,8 @@ - UINT32 Entries; - UINT32 Offset; - UINT32 i; -+ UINT32 Length; -+ UINT64 Address; - - - /* Point to start of table pointer array */ -@@ -345,12 +351,14 @@ - - /* XSDT uses 64-bit pointers */ - -- Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); - - for (i = 0; i < Entries; i++) - { - AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); -- AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); -+ ACPI_MOVE_64_TO_64(&Address, &Array[i]); -+ AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Address)); - Offset += sizeof (UINT64); - } - } -@@ -384,6 +392,7 @@ - ACPI_STATUS Status; - UINT8 FadtRevision; - UINT32 ExpectedLength; -+ UINT32 ActualLength; - UINT32 i; - - -@@ -400,6 +409,7 @@ - return; - } - -+ ACPI_MOVE_32_TO_32(&ActualLength, &Table->Length); - if (FadtRevision > ACPI_FADT_MAX_VERSION) - { - AcpiOsPrintf ("// ACPI Warning: Revision %u is not fully supported, " -@@ -409,12 +419,12 @@ - else - { - ExpectedLength = FadtRevisionLength[FadtRevision]; -- if (Table->Length != ExpectedLength) -+ if (ActualLength != ExpectedLength) - { - AcpiOsPrintf ( - "// ACPI Warning: Input FADT revision %X does not match " - "expected length: found 0x%X expected 0x%X\n", -- FadtRevision, Table->Length, ExpectedLength); -+ FadtRevision, ActualLength, ExpectedLength); - } - } - -@@ -432,14 +442,14 @@ - - /* Dump the fields specific to FADT revision[i] */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, -+ Status = AcpiDmDumpTable (ActualLength, 0, Table, 0, - FadtRevisionInfo[i]); - if (ACPI_FAILURE (Status)) - { - return; - } - -- if (Table->Length <= FadtRevisionLength[i]) -+ if (ActualLength <= FadtRevisionLength[i]) - { - break; /* End of table */ - } -@@ -447,7 +457,7 @@ - - /* Build a local FADT to test some FADT values */ - -- AcpiTbCreateLocalFadt (Table, Table->Length); -+ AcpiTbCreateLocalFadt (Table, ActualLength); - } - - -@@ -478,17 +488,21 @@ - UINT32 DataOffset = 0; - UINT32 i; - UINT8 Type; -+ UINT32 Len; -+ UINT16 SubLen; - - - /* No main table, only subtables */ - -+ ACPI_MOVE_32_TO_32(&Len, &Table->Length); - SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Len) - { - /* Common subtable header */ - -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Header.Length, AcpiDmTableInfoAsfHdr); -+ ACPI_MOVE_16_TO_16(&SubLen, &SubTable->Header.Length); -+ Status = AcpiDmDumpTable (Len, Offset, SubTable, -+ SubLen, AcpiDmTableInfoAsfHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -545,8 +559,7 @@ - return; - } - -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Header.Length, InfoTable); -+ Status = AcpiDmDumpTable (Len, Offset, SubTable, SubLen, InfoTable); - if (ACPI_FAILURE (Status)) - { - return; -@@ -562,7 +575,7 @@ - for (i = 0; i < DataCount; i++) - { - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, DataOffset, -+ Status = AcpiDmDumpTable (Len, DataOffset, - DataTable, DataLength, DataInfoTable); - if (ACPI_FAILURE (Status)) - { -@@ -608,15 +621,14 @@ - - /* Point to next subtable */ - -- if (!SubTable->Header.Length) -+ if (!SubLen) - { - AcpiOsPrintf ("Invalid zero subtable header length\n"); - return; - } - -- Offset += SubTable->Header.Length; -- SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, -- SubTable->Header.Length); -+ Offset += SubLen; -+ SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubLen); - } - } - -@@ -640,12 +652,13 @@ - { - ACPI_STATUS Status; - ACPI_CPEP_POLLING *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_CPEP); - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); - if (ACPI_FAILURE (Status)) - { -@@ -655,7 +668,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - AcpiOsPrintf ("\n"); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -@@ -695,7 +708,10 @@ - ACPI_CSRT_GROUP *SubTable; - ACPI_CSRT_SHARED_INFO *SharedInfoTable; - ACPI_CSRT_DESCRIPTOR *SubSubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; -+ UINT32 SubLength; -+ UINT32 SubSubLength; -+ UINT32 SharedInfoLength; - UINT32 Offset = sizeof (ACPI_TABLE_CSRT); - UINT32 SubOffset; - UINT32 SubSubOffset; -@@ -706,14 +722,16 @@ - - /* Subtables (Resource Groups) */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Resource group subtable */ - - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_32_TO_32(&SubLength, &SubTable->Length); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoCsrt0); -+ SubLength, AcpiDmTableInfoCsrt0); - if (ACPI_FAILURE (Status)) - { - return; -@@ -733,19 +751,20 @@ - return; - } - -- SubOffset += SubTable->SharedInfoLength; -+ ACPI_MOVE_32_TO_32(&SharedInfoLength, &SubTable->SharedInfoLength); -+ SubOffset += SharedInfoLength; - - /* Sub-Subtables (Resource Descriptors) */ - - SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, - Offset + SubOffset); - -- while ((SubOffset < SubTable->Length) && -- ((Offset + SubOffset) < Table->Length)) -+ while ((SubOffset < SubLength) && ((Offset + SubOffset) < Length)) - { - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_32_TO_32(&SubSubLength, &SubSubTable->Length); - Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, -- SubSubTable->Length, AcpiDmTableInfoCsrt2); -+ SubSubLength, AcpiDmTableInfoCsrt2); - if (ACPI_FAILURE (Status)) - { - return; -@@ -755,7 +774,7 @@ - - /* Resource-specific info buffer */ - -- InfoLength = SubSubTable->Length - SubSubOffset; -+ InfoLength = SubSubLength - SubSubOffset; - if (InfoLength) - { - Status = AcpiDmDumpTable (Length, -@@ -770,16 +789,15 @@ - - /* Point to next sub-subtable */ - -- SubOffset += SubSubTable->Length; -+ SubOffset += SubSubLength; - SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, -- SubSubTable->Length); -+ SubSubLength); - } - - /* Point to next subtable */ - -- Offset += SubTable->Length; -- SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, -- SubTable->Length); -+ Offset += SubLength; -+ SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, SubLength); - } - } - -@@ -803,16 +821,20 @@ - { - ACPI_STATUS Status; - ACPI_DBG2_DEVICE *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; -+ UINT16 SubLength; - UINT32 Offset = sizeof (ACPI_TABLE_DBG2); - UINT32 i; - UINT32 ArrayOffset; - UINT32 AbsoluteOffset; - UINT8 *Array; -+ UINT16 Tmp16; -+ UINT16 AlsoTmp16; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); - if (ACPI_FAILURE (Status)) - { -@@ -822,11 +844,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoDbg2Device); -+ SubLength, AcpiDmTableInfoDbg2Device); - if (ACPI_FAILURE (Status)) - { - return; -@@ -836,13 +859,13 @@ - - for (i = 0; i < SubTable->RegisterCount; i++) - { -- ArrayOffset = SubTable->BaseAddressOffset + -- (sizeof (ACPI_GENERIC_ADDRESS) * i); -+ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->BaseAddressOffset); -+ ArrayOffset = Tmp16 + (sizeof (ACPI_GENERIC_ADDRESS) * i); - AbsoluteOffset = Offset + ArrayOffset; - Array = (UINT8 *) SubTable + ArrayOffset; - - Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, -- SubTable->Length, AcpiDmTableInfoDbg2Addr); -+ SubLength, AcpiDmTableInfoDbg2Addr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -853,13 +876,13 @@ - - for (i = 0; i < SubTable->RegisterCount; i++) - { -- ArrayOffset = SubTable->AddressSizeOffset + -- (sizeof (UINT32) * i); -+ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->AddressSizeOffset); -+ ArrayOffset = Tmp16 + (sizeof (UINT32) * i); - AbsoluteOffset = Offset + ArrayOffset; - Array = (UINT8 *) SubTable + ArrayOffset; - - Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, -- SubTable->Length, AcpiDmTableInfoDbg2Size); -+ SubLength, AcpiDmTableInfoDbg2Size); - if (ACPI_FAILURE (Status)) - { - return; -@@ -869,12 +892,13 @@ - /* Dump the Namestring (required) */ - - AcpiOsPrintf ("\n"); -- ArrayOffset = SubTable->NamepathOffset; -+ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->NamepathOffset); -+ ArrayOffset = Tmp16; - AbsoluteOffset = Offset + ArrayOffset; - Array = (UINT8 *) SubTable + ArrayOffset; - - Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, -- SubTable->Length, AcpiDmTableInfoDbg2Name); -+ SubLength, AcpiDmTableInfoDbg2Name); - if (ACPI_FAILURE (Status)) - { - return; -@@ -884,9 +908,10 @@ - - if (SubTable->OemDataOffset) - { -- Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset, -- Table, SubTable->OemDataLength, -- AcpiDmTableInfoDbg2OemData); -+ ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->OemDataOffset); -+ ACPI_MOVE_16_TO_16(&AlsoTmp16, &SubTable->OemDataLength); -+ Status = AcpiDmDumpTable (Length, Offset + Tmp16, -+ Table, AlsoTmp16, AcpiDmTableInfoDbg2OemData); - if (ACPI_FAILURE (Status)) - { - return; -@@ -895,9 +920,9 @@ - - /* Point to next subtable */ - -- Offset += SubTable->Length; -+ Offset += SubLength; - SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, -- SubTable->Length); -+ SubLength); - } - } - -@@ -921,17 +946,20 @@ - { - ACPI_STATUS Status; - ACPI_DMAR_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; -+ UINT16 SubLength; - UINT32 Offset = sizeof (ACPI_TABLE_DMAR); - ACPI_DMTABLE_INFO *InfoTable; - ACPI_DMAR_DEVICE_SCOPE *ScopeTable; - UINT32 ScopeOffset; - UINT8 *PciPath; - UINT32 PathOffset; -+ UINT16 SubType; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); - if (ACPI_FAILURE (Status)) - { -@@ -941,13 +969,14 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoDmarHdr); -+ SubLength, AcpiDmTableInfoDmarHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -955,7 +984,8 @@ - - AcpiOsPrintf ("\n"); - -- switch (SubTable->Type) -+ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); -+ switch (SubType) - { - case ACPI_DMAR_TYPE_HARDWARE_UNIT: - -@@ -990,12 +1020,12 @@ - default: - - AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", -- SubTable->Type); -+ SubType); - return; - } - - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, InfoTable); -+ SubLength, InfoTable); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1004,8 +1034,8 @@ - /* - * Dump the optional device scope entries - */ -- if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || -- (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE)) -+ if ((SubType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || -+ (SubType == ACPI_DMAR_TYPE_NAMESPACE)) - { - /* These types do not support device scopes */ - -@@ -1013,7 +1043,7 @@ - } - - ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); -- while (ScopeOffset < SubTable->Length) -+ while (ScopeOffset < SubLength) - { - AcpiOsPrintf ("\n"); - Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, -@@ -1054,9 +1084,8 @@ - NextSubtable: - /* Point to next subtable */ - -- Offset += SubTable->Length; -- SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, -- SubTable->Length); -+ Offset += SubLength; -+ SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubLength); - } - } - -@@ -1083,12 +1112,15 @@ - ACPI_DRTM_RESOURCE_LIST *DrtmRl; - ACPI_DRTM_DPS_ID *DrtmDps; - UINT32 Count; -+ UINT32 ValidatedCount; -+ UINT32 ResourceCount; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, -- AcpiDmTableInfoDrtm); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDrtm); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1102,7 +1134,7 @@ - - DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, -+ Status = AcpiDmDumpTable (Length, Offset, - DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), - AcpiDmTableInfoDrtm0); - if (ACPI_FAILURE (Status)) -@@ -1115,10 +1147,11 @@ - /* Dump Validated table addresses */ - - Count = 0; -- while ((Offset < Table->Length) && -- (DrtmVtl->ValidatedTableCount > Count)) -+ ACPI_MOVE_32_TO_32(&ValidatedCount, &DrtmVtl->ValidatedTableCount); -+ while ((Offset < Length) && -+ (ValidatedCount > Count)) - { -- Status = AcpiDmDumpTable (Table->Length, Offset, -+ Status = AcpiDmDumpTable (Length, Offset, - ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), - AcpiDmTableInfoDrtm0a); - if (ACPI_FAILURE (Status)) -@@ -1134,7 +1167,7 @@ - - DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, -+ Status = AcpiDmDumpTable (Length, Offset, - DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), - AcpiDmTableInfoDrtm1); - if (ACPI_FAILURE (Status)) -@@ -1147,10 +1180,11 @@ - /* Dump the Resource List */ - - Count = 0; -- while ((Offset < Table->Length) && -- (DrtmRl->ResourceCount > Count)) -+ ACPI_MOVE_32_TO_32(&ResourceCount, &DrtmRl->ResourceCount); -+ while ((Offset < Length) && -+ (ResourceCount > Count)) - { -- Status = AcpiDmDumpTable (Table->Length, Offset, -+ Status = AcpiDmDumpTable (Length, Offset, - ACPI_ADD_PTR (void, Table, Offset), - sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); - if (ACPI_FAILURE (Status)) -@@ -1166,7 +1200,7 @@ - - DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); - AcpiOsPrintf ("\n"); -- (void) AcpiDmDumpTable (Table->Length, Offset, -+ (void) AcpiDmDumpTable (Length, Offset, - DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); - } - -@@ -1190,12 +1224,13 @@ - { - ACPI_STATUS Status; - ACPI_WHEA_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_EINJ); - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); - if (ACPI_FAILURE (Status)) - { -@@ -1205,7 +1240,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - AcpiOsPrintf ("\n"); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -@@ -1243,12 +1278,13 @@ - { - ACPI_STATUS Status; - ACPI_WHEA_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_ERST); - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); - if (ACPI_FAILURE (Status)) - { -@@ -1258,7 +1294,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - AcpiOsPrintf ("\n"); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -@@ -1296,17 +1332,19 @@ - { - ACPI_STATUS Status; - ACPI_FPDT_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_FPDT); - ACPI_DMTABLE_INFO *InfoTable; -+ UINT16 Type; - - - /* There is no main table (other than the standard ACPI header) */ - - /* Subtables */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - -@@ -1318,7 +1356,8 @@ - return; - } - -- switch (SubTable->Type) -+ ACPI_MOVE_16_TO_16(&Type, &SubTable->Type); -+ switch (Type) - { - case ACPI_FPDT_TYPE_BOOT: - -@@ -1332,8 +1371,7 @@ - - default: - -- AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", -- SubTable->Type); -+ AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", Type); - - /* Attempt to continue */ - -@@ -1381,16 +1419,19 @@ - { - ACPI_STATUS Status; - ACPI_GTDT_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; -+ UINT16 SubLength; - UINT32 Offset = sizeof (ACPI_TABLE_GTDT); - ACPI_DMTABLE_INFO *InfoTable; - UINT32 SubTableLength; - UINT32 GtCount; -+ UINT32 Tmp32; - ACPI_GTDT_TIMER_ENTRY *GtxTable; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); - if (ACPI_FAILURE (Status)) - { -@@ -1400,7 +1441,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - -@@ -1418,8 +1459,9 @@ - case ACPI_GTDT_TYPE_TIMER_BLOCK: - - SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); -- GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, -+ Tmp32 = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, - SubTable))->TimerCount; -+ ACPI_MOVE_32_TO_32(&GtCount, &Tmp32); - - InfoTable = AcpiDmTableInfoGtdt0; - break; -@@ -1440,8 +1482,9 @@ - return; - } - -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, InfoTable); -+ SubLength, InfoTable); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1500,16 +1543,18 @@ - { - ACPI_STATUS Status; - ACPI_HEST_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_HEST); - ACPI_DMTABLE_INFO *InfoTable; - UINT32 SubTableLength; - UINT32 BankCount; - ACPI_HEST_IA_ERROR_BANK *BankTable; -+ UINT16 SubType; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); - if (ACPI_FAILURE (Status)) - { -@@ -1519,10 +1564,11 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - BankCount = 0; -- switch (SubTable->Type) -+ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); -+ switch (SubType) - { - case ACPI_HEST_TYPE_IA32_CHECK: - -@@ -1651,15 +1697,21 @@ - ACPI_IORT_SMMU *IortSmmu = NULL; - UINT32 Offset; - UINT32 NodeOffset; -+ UINT16 NodeLength; - UINT32 Length; - ACPI_DMTABLE_INFO *InfoTable; - char *String; - UINT32 i; -- -+ UINT32 TableLen; -+ UINT32 ItsCount; -+ UINT32 MappingCount; -+ UINT32 CtxIntCount; -+ UINT32 PmuIntCount; - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); -+ ACPI_MOVE_32_TO_32(&TableLen, &Table->Length); -+ Status = AcpiDmDumpTable (TableLen, 0, Table, 0, AcpiDmTableInfoIort); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1670,18 +1722,19 @@ - - /* Dump the OptionalPadding (optional) */ - -- if (Iort->NodeOffset > Offset) -+ ACPI_MOVE_32_TO_32(&NodeOffset, &Iort->NodeOffset); -+ if (NodeOffset > Offset) - { -- Status = AcpiDmDumpTable (Table->Length, Offset, Table, -- Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); -+ Status = AcpiDmDumpTable (TableLen, Offset, Table, -+ NodeOffset - Offset, AcpiDmTableInfoIortPad); - if (ACPI_FAILURE (Status)) - { - return; - } - } - -- Offset = Iort->NodeOffset; -- while (Offset < Table->Length) -+ ACPI_MOVE_32_TO_32(&Offset, &Iort->NodeOffset); -+ while (Offset < TableLen) - { - /* Common subtable header */ - -@@ -1717,7 +1770,8 @@ - case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: - - InfoTable = AcpiDmTableInfoIort2; -- Length = IortNode->Length - NodeOffset; -+ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); -+ Length = NodeLength - NodeOffset; - break; - - case ACPI_IORT_NODE_SMMU: -@@ -1730,7 +1784,8 @@ - case ACPI_IORT_NODE_SMMU_V3: - - InfoTable = AcpiDmTableInfoIort4; -- Length = IortNode->Length - NodeOffset; -+ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); -+ Length = NodeLength - NodeOffset; - break; - - default: -@@ -1740,7 +1795,8 @@ - - /* Attempt to continue */ - -- if (!IortNode->Length) -+ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); -+ if (!NodeLength) - { - AcpiOsPrintf ("Invalid zero length IORT node\n"); - return; -@@ -1751,7 +1807,7 @@ - /* Dump the node subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - Length, InfoTable); - if (ACPI_FAILURE (Status)) -@@ -1771,9 +1827,10 @@ - - if (IortItsGroup) - { -- for (i = 0; i < IortItsGroup->ItsCount; i++) -+ ACPI_MOVE_32_TO_32(&ItsCount, &IortItsGroup->ItsCount); -+ for (i = 0; i < ItsCount; i++) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - 4, AcpiDmTableInfoIort0a); - NodeOffset += 4; -@@ -1785,11 +1842,11 @@ - - /* Dump the Padding (optional) */ - -- if (IortNode->Length > NodeOffset) -+ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); -+ if (NodeLength > NodeOffset) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -- Table, IortNode->Length - NodeOffset, -- AcpiDmTableInfoIort1a); -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, -+ Table, NodeLength - NodeOffset, AcpiDmTableInfoIort1a); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1806,8 +1863,8 @@ - if (IortSmmu) - { - Length = 2 * sizeof (UINT64); -- NodeOffset = IortSmmu->GlobalInterruptOffset; -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->GlobalInterruptOffset); -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - Length, AcpiDmTableInfoIort3a); - if (ACPI_FAILURE (Status)) -@@ -1815,10 +1872,11 @@ - return; - } - -- NodeOffset = IortSmmu->ContextInterruptOffset; -- for (i = 0; i < IortSmmu->ContextInterruptCount; i++) -+ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->ContextInterruptOffset); -+ ACPI_MOVE_32_TO_32(&CtxIntCount, &IortSmmu->ContextInterruptCount); -+ for (i = 0; i < CtxIntCount; i++) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - 8, AcpiDmTableInfoIort3b); - if (ACPI_FAILURE (Status)) -@@ -1829,10 +1887,11 @@ - NodeOffset += 8; - } - -- NodeOffset = IortSmmu->PmuInterruptOffset; -- for (i = 0; i < IortSmmu->PmuInterruptCount; i++) -+ ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->PmuInterruptOffset); -+ ACPI_MOVE_32_TO_32(&PmuIntCount, &IortSmmu->PmuInterruptCount); -+ for (i = 0; i < PmuIntCount; i++) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - 8, AcpiDmTableInfoIort3c); - if (ACPI_FAILURE (Status)) -@@ -1852,12 +1911,13 @@ - - /* Dump the ID mappings */ - -- NodeOffset = IortNode->MappingOffset; -- for (i = 0; i < IortNode->MappingCount; i++) -+ ACPI_MOVE_32_TO_32(&NodeOffset, &IortNode->MappingOffset); -+ ACPI_MOVE_32_TO_32(&MappingCount, &IortNode->MappingCount); -+ for (i = 0; i < MappingCount; i++) - { - AcpiOsPrintf ("\n"); - Length = sizeof (ACPI_IORT_ID_MAPPING); -- Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, -+ Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset, - ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), - Length, AcpiDmTableInfoIortMap); - if (ACPI_FAILURE (Status)) -@@ -1871,8 +1931,9 @@ - NextSubTable: - /* Point to next node subtable */ - -- Offset += IortNode->Length; -- IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); -+ ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length); -+ Offset += NodeLength; -+ IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeLength); - } - } - -@@ -1903,11 +1964,14 @@ - ACPI_IVRS_DE_HEADER *DeviceEntry; - ACPI_IVRS_HEADER *SubTable; - ACPI_DMTABLE_INFO *InfoTable; -+ UINT32 Length; -+ UINT16 SubLength; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoIvrs); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1916,13 +1980,14 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoIvrsHdr); -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, -+ SubLength, AcpiDmTableInfoIvrsHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1949,7 +2014,7 @@ - - /* Attempt to continue */ - -- if (!SubTable->Length) -+ if (!SubLength) - { - AcpiOsPrintf ("Invalid zero length subtable\n"); - return; -@@ -1960,8 +2025,8 @@ - /* Dump the subtable */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Length, InfoTable); -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, -+ SubLength, InfoTable); - if (ACPI_FAILURE (Status)) - { - return; -@@ -1975,7 +2040,7 @@ - DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, - sizeof (ACPI_IVRS_HARDWARE)); - -- while (EntryOffset < (Offset + SubTable->Length)) -+ while (EntryOffset < (Offset + SubLength)) - { - AcpiOsPrintf ("\n"); - /* -@@ -2037,7 +2102,7 @@ - - /* Dump the Device Entry */ - -- Status = AcpiDmDumpTable (Table->Length, EntryOffset, -+ Status = AcpiDmDumpTable (Length, EntryOffset, - DeviceEntry, EntryLength, InfoTable); - if (ACPI_FAILURE (Status)) - { -@@ -2053,8 +2118,8 @@ - NextSubTable: - /* Point to next subtable */ - -- Offset += SubTable->Length; -- SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); -+ Offset += SubLength; -+ SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubLength); - } - } - -@@ -2080,7 +2145,7 @@ - { - ACPI_STATUS Status; - ACPI_LPIT_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_LPIT); - ACPI_DMTABLE_INFO *InfoTable; - UINT32 SubTableLength; -@@ -2088,8 +2153,9 @@ - - /* Subtables */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - -@@ -2153,13 +2219,14 @@ - { - ACPI_STATUS Status; - ACPI_SUBTABLE_HEADER *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_MADT); - ACPI_DMTABLE_INFO *InfoTable; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); - if (ACPI_FAILURE (Status)) - { -@@ -2169,7 +2236,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - -@@ -2315,11 +2382,13 @@ - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_MCFG); - ACPI_MCFG_ALLOCATION *SubTable; -+ UINT32 Len; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); -+ ACPI_MOVE_32_TO_32(&Len, &Table->Length); -+ Status = AcpiDmDumpTable (Len, 0, Table, 0, AcpiDmTableInfoMcfg); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2328,17 +2397,17 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Len) - { -- if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) -+ if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Len) - { - AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", -- sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); -+ sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Len)); - return; - } - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Len, Offset, SubTable, - sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); - if (ACPI_FAILURE (Status)) - { -@@ -2372,6 +2441,7 @@ - { - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_MPST); -+ ACPI_TABLE_MPST *Mpst; - ACPI_MPST_POWER_NODE *SubTable0; - ACPI_MPST_POWER_STATE *SubTable0A; - ACPI_MPST_COMPONENT *SubTable0B; -@@ -2380,11 +2450,13 @@ - UINT16 SubtableCount; - UINT32 PowerStateCount; - UINT32 ComponentCount; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMpst); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2392,13 +2464,14 @@ - - /* Subtable: Memory Power Node(s) */ - -- SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; -+ Mpst = ACPI_CAST_PTR (ACPI_TABLE_MPST, Table); -+ ACPI_MOVE_16_TO_16(&SubtableCount, &Mpst->PowerNodeCount); - SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); - -- while ((Offset < Table->Length) && SubtableCount) -+ while ((Offset < Length) && SubtableCount) - { - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable0, - sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); - if (ACPI_FAILURE (Status)) - { -@@ -2407,8 +2480,8 @@ - - /* Extract the sub-subtable counts */ - -- PowerStateCount = SubTable0->NumPowerStates; -- ComponentCount = SubTable0->NumPhysicalComponents; -+ ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates); -+ ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents); - Offset += sizeof (ACPI_MPST_POWER_NODE); - - /* Sub-subtables - Memory Power State Structure(s) */ -@@ -2419,7 +2492,7 @@ - while (PowerStateCount) - { - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable0A, - sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); - if (ACPI_FAILURE (Status)) - { -@@ -2429,7 +2502,7 @@ - SubTable0A++; - PowerStateCount--; - Offset += sizeof (ACPI_MPST_POWER_STATE); -- } -+ } - - /* Sub-subtables - Physical Component ID Structure(s) */ - -@@ -2442,7 +2515,7 @@ - - while (ComponentCount) - { -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable0B, - sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); - if (ACPI_FAILURE (Status)) - { -@@ -2457,17 +2530,19 @@ - /* Point to next Memory Power Node subtable */ - - SubtableCount--; -+ ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates); -+ ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents); - SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, - sizeof (ACPI_MPST_POWER_NODE) + -- (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + -- (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); -+ (sizeof (ACPI_MPST_POWER_STATE) * PowerStateCount) + -+ (sizeof (ACPI_MPST_COMPONENT) * ComponentCount)); - } - - /* Subtable: Count of Memory Power State Characteristic structures */ - - AcpiOsPrintf ("\n"); - SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable1, - sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); - if (ACPI_FAILURE (Status)) - { -@@ -2482,10 +2557,10 @@ - SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, - sizeof (ACPI_MPST_DATA_HDR)); - -- while ((Offset < Table->Length) && SubtableCount) -+ while ((Offset < Length) && SubtableCount) - { - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable2, - sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); - if (ACPI_FAILURE (Status)) - { -@@ -2518,11 +2593,13 @@ - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_MSCT); - ACPI_MSCT_PROXIMITY *SubTable; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMsct); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2531,12 +2608,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); - if (ACPI_FAILURE (Status)) - { -@@ -2571,11 +2648,13 @@ - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_MTMR); - ACPI_MTMR_ENTRY *SubTable; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMtmr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2584,12 +2663,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); - if (ACPI_FAILURE (Status)) - { -@@ -2631,11 +2710,17 @@ - ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; - ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; - UINT32 i; -+ UINT32 TableLength; -+ UINT16 SubLength; -+ UINT16 SubType; -+ UINT32 Count; -+ UINT16 Count16; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); -+ ACPI_MOVE_32_TO_32(&TableLength, &Table->Length); -+ Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNfit); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2644,19 +2729,21 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < TableLength) - { - /* NFIT subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoNfitHdr); -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); -+ Status = AcpiDmDumpTable (TableLength, Offset, SubTable, -+ SubLength, AcpiDmTableInfoNfitHdr); - if (ACPI_FAILURE (Status)) - { - return; - } - -- switch (SubTable->Type) -+ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); -+ switch (SubType) - { - case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: - -@@ -2708,7 +2795,7 @@ - - /* Attempt to continue */ - -- if (!SubTable->Length) -+ if (!SubLength) - { - AcpiOsPrintf ("Invalid zero length subtable\n"); - return; -@@ -2717,8 +2804,8 @@ - } - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- SubTable->Length, InfoTable); -+ Status = AcpiDmDumpTable (TableLength, Offset, SubTable, -+ SubLength, InfoTable); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2726,13 +2813,14 @@ - - /* Per-subtable variable-length fields */ - -- switch (SubTable->Type) -+ switch (SubType) - { - case ACPI_NFIT_TYPE_INTERLEAVE: - -- for (i = 0; i < Interleave->LineCount; i++) -+ ACPI_MOVE_32_TO_32(&Count, &Interleave->LineCount); -+ for (i = 0; i < Count; i++) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, -+ Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset, - &Interleave->LineOffset[i], - sizeof (UINT32), AcpiDmTableInfoNfit2a); - if (ACPI_FAILURE (Status)) -@@ -2746,12 +2834,11 @@ - - case ACPI_NFIT_TYPE_SMBIOS: - -- Length = SubTable->Length - -- sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); -+ Length = SubLength - sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); - - if (Length) - { -- Status = AcpiDmDumpTable (Table->Length, -+ Status = AcpiDmDumpTable (TableLength, - sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), - SmbiosInfo, - Length, AcpiDmTableInfoNfit3a); -@@ -2765,9 +2852,10 @@ - - case ACPI_NFIT_TYPE_FLUSH_ADDRESS: - -- for (i = 0; i < Hint->HintCount; i++) -+ ACPI_MOVE_16_TO_16(&Count16, &Hint->HintCount); -+ for (i = 0; i < Count16; i++) - { -- Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, -+ Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset, - &Hint->HintAddress[i], - sizeof (UINT64), AcpiDmTableInfoNfit6a); - if (ACPI_FAILURE (Status)) -@@ -2786,8 +2874,8 @@ - NextSubTable: - /* Point to next subtable */ - -- Offset += SubTable->Length; -- SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length); -+ Offset += SubLength; -+ SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubLength); - } - } - -@@ -2812,12 +2900,13 @@ - ACPI_STATUS Status; - ACPI_PCCT_SUBSPACE *SubTable; - ACPI_DMTABLE_INFO *InfoTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_PCCT); - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); - if (ACPI_FAILURE (Status)) - { -@@ -2827,7 +2916,7 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - -@@ -2903,16 +2992,21 @@ - ACPI_PMTT_HEADER *MemSubTable; - ACPI_PMTT_HEADER *DimmSubTable; - ACPI_PMTT_DOMAIN *DomainArray; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 Offset = sizeof (ACPI_TABLE_PMTT); - UINT32 MemOffset; - UINT32 DimmOffset; - UINT32 DomainOffset; -- UINT32 DomainCount; -+ UINT16 DomainCount; -+ UINT16 SubLength; -+ UINT16 Tmp16; -+ UINT16 MemLength; -+ UINT16 DimmLength; - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); - if (ACPI_FAILURE (Status)) - { -@@ -2922,13 +3016,14 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length); - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoPmttHdr); -+ SubLength, AcpiDmTableInfoPmttHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2947,7 +3042,7 @@ - /* Dump the fixed-length portion of the subtable */ - - Status = AcpiDmDumpTable (Length, Offset, SubTable, -- SubTable->Length, AcpiDmTableInfoPmtt0); -+ SubLength, AcpiDmTableInfoPmtt0); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2959,15 +3054,16 @@ - MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, - sizeof (ACPI_PMTT_SOCKET)); - -- while (((Offset + MemOffset) < Table->Length) && -- (MemOffset < SubTable->Length)) -+ while (((Offset + MemOffset) < Length) && -+ (MemOffset < SubLength)) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_16_TO_16(&MemLength, &MemSubTable->Length); - Status = AcpiDmDumpTable (Length, - Offset + MemOffset, MemSubTable, -- MemSubTable->Length, AcpiDmTableInfoPmttHdr); -+ MemLength, AcpiDmTableInfoPmttHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2987,7 +3083,7 @@ - - Status = AcpiDmDumpTable (Length, - Offset + MemOffset, MemSubTable, -- MemSubTable->Length, AcpiDmTableInfoPmtt1); -+ MemLength, AcpiDmTableInfoPmtt1); - if (ACPI_FAILURE (Status)) - { - return; -@@ -2995,13 +3091,14 @@ - - /* Walk the variable count of proximity domains */ - -- DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; -+ Tmp16 = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; -+ ACPI_MOVE_16_TO_16(&DomainCount, &Tmp16); - DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); - DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, - sizeof (ACPI_PMTT_CONTROLLER)); - -- while (((Offset + MemOffset + DomainOffset) < Table->Length) && -- ((MemOffset + DomainOffset) < SubTable->Length) && -+ while (((Offset + MemOffset + DomainOffset) < Length) && -+ ((MemOffset + DomainOffset) < SubLength) && - DomainCount) - { - Status = AcpiDmDumpTable (Length, -@@ -3029,15 +3126,16 @@ - DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, - DomainOffset); - -- while (((Offset + MemOffset + DimmOffset) < Table->Length) && -- (DimmOffset < MemSubTable->Length)) -+ while (((Offset + MemOffset + DimmOffset) < Length) && -+ (DimmOffset < MemLength)) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -+ ACPI_MOVE_16_TO_16(&DimmLength, &DimmSubTable->Length); - Status = AcpiDmDumpTable (Length, - Offset + MemOffset + DimmOffset, DimmSubTable, -- DimmSubTable->Length, AcpiDmTableInfoPmttHdr); -+ DimmLength, AcpiDmTableInfoPmttHdr); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3057,7 +3155,7 @@ - - Status = AcpiDmDumpTable (Length, - Offset + MemOffset + DimmOffset, DimmSubTable, -- DimmSubTable->Length, AcpiDmTableInfoPmtt2); -+ DimmLength, AcpiDmTableInfoPmtt2); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3065,23 +3163,22 @@ - - /* Point to next DIMM subtable */ - -- DimmOffset += DimmSubTable->Length; -+ DimmOffset += DimmLength; - DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, -- DimmSubTable, DimmSubTable->Length); -+ DimmSubTable, DimmLength); - } - - /* Point to next Controller subtable */ - -- MemOffset += MemSubTable->Length; -+ MemOffset += MemLength; - MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, -- MemSubTable, MemSubTable->Length); -+ MemSubTable, MemLength); - } - - /* Point to next Socket subtable */ - -- Offset += SubTable->Length; -- SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, -- SubTable, SubTable->Length); -+ Offset += SubLength; -+ SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, SubLength); - } - } - -@@ -3107,6 +3204,8 @@ - ACPI_FPDT_HEADER *SubTable; - ACPI_DMTABLE_INFO *InfoTable; - ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); -+ UINT32 Length; -+ UINT16 SubType; - - - /* Main table */ -@@ -3117,20 +3216,22 @@ - return 0; - } - -+ ACPI_MOVE_32_TO_32(&Length, &S3ptTable->Length); - SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); -- while (Offset < S3ptTable->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - SubTable->Length, AcpiDmTableInfoS3ptHdr); - if (ACPI_FAILURE (Status)) - { - return 0; - } - -- switch (SubTable->Type) -+ ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type); -+ switch (SubType) - { - case ACPI_S3PT_TYPE_RESUME: - -@@ -3145,7 +3246,7 @@ - default: - - AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", -- SubTable->Type); -+ SubType); - - /* Attempt to continue */ - -@@ -3158,7 +3259,7 @@ - } - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - SubTable->Length, InfoTable); - if (ACPI_FAILURE (Status)) - { -@@ -3192,9 +3293,11 @@ - AcpiDmDumpSlic ( - ACPI_TABLE_HEADER *Table) - { -+ UINT32 Length; - -- (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table, -- Table->Length - sizeof (*Table), AcpiDmTableInfoSlic); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ (void) AcpiDmDumpTable (Length, sizeof (ACPI_TABLE_HEADER), Table, -+ Length - sizeof (*Table), AcpiDmTableInfoSlic); - } - - -@@ -3217,14 +3320,17 @@ - ACPI_STATUS Status; - UINT32 Offset; - UINT8 *Row; -- UINT32 Localities; -+ UINT64 Localities; - UINT32 i; - UINT32 j; -+ UINT32 Length; -+ UINT64 Tmp64; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSlit); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3232,7 +3338,8 @@ - - /* Display the Locality NxN Matrix */ - -- Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; -+ Tmp64 = (UINT64) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; -+ ACPI_MOVE_64_TO_64(&Localities, &Tmp64); - Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); - Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; - -@@ -3245,7 +3352,7 @@ - { - /* Check for beyond EOT */ - -- if (Offset >= Table->Length) -+ if (Offset >= Length) - { - AcpiOsPrintf ( - "\n**** Not enough room in table for all localities\n"); -@@ -3297,11 +3404,13 @@ - UINT32 Offset = sizeof (ACPI_TABLE_SRAT); - ACPI_SUBTABLE_HEADER *SubTable; - ACPI_DMTABLE_INFO *InfoTable; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSrat); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3310,12 +3419,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - SubTable->Length, AcpiDmTableInfoSratHdr); - if (ACPI_FAILURE (Status)) - { -@@ -3359,7 +3468,7 @@ - } - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - SubTable->Length, InfoTable); - if (ACPI_FAILURE (Status)) - { -@@ -3396,13 +3505,14 @@ - { - ACPI_STATUS Status; - char *Namepath; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT32 StringLength; - UINT32 Offset = sizeof (ACPI_TABLE_STAO); - - - /* Main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao); - if (ACPI_FAILURE (Status)) - { -@@ -3411,7 +3521,7 @@ - - /* The rest of the table consists of Namepath strings */ - -- while (Offset < Table->Length) -+ while (Offset < Length) - { - Namepath = ACPI_ADD_PTR (char, Table, Offset); - StringLength = strlen (Namepath) + 1; -@@ -3453,11 +3563,14 @@ - ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR ( - ACPI_TABLE_TCPA_HDR, Table, Offset); - ACPI_STATUS Status; -+ UINT32 Length; -+ UINT16 PlatformClass; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, - 0, AcpiDmTableInfoTcpaHdr); - if (ACPI_FAILURE (Status)) - { -@@ -3468,18 +3581,19 @@ - * Examine the PlatformClass field to determine the table type. - * Either a client or server table. Only one. - */ -- switch (CommonHeader->PlatformClass) -+ ACPI_MOVE_16_TO_16(&PlatformClass, &CommonHeader->PlatformClass); -+ switch (PlatformClass) - { - case ACPI_TCPA_CLIENT_TABLE: - -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- Table->Length - Offset, AcpiDmTableInfoTcpaClient); -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, -+ Length - Offset, AcpiDmTableInfoTcpaClient); - break; - - case ACPI_TCPA_SERVER_TABLE: - -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -- Table->Length - Offset, AcpiDmTableInfoTcpaServer); -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, -+ Length - Offset, AcpiDmTableInfoTcpaServer); - break; - - default: -@@ -3516,11 +3630,13 @@ - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_VRTC); - ACPI_VRTC_ENTRY *SubTable; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoVrtc); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3529,12 +3645,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); - if (ACPI_FAILURE (Status)) - { -@@ -3569,11 +3685,13 @@ - ACPI_STATUS Status; - UINT32 Offset = sizeof (ACPI_TABLE_WDAT); - ACPI_WDAT_ENTRY *SubTable; -+ UINT32 Length; - - - /* Main table */ - -- Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); -+ Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWdat); - if (ACPI_FAILURE (Status)) - { - return; -@@ -3582,12 +3700,12 @@ - /* Subtables */ - - SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); -- while (Offset < Table->Length) -+ while (Offset < Length) - { - /* Common subtable header */ - - AcpiOsPrintf ("\n"); -- Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, -+ Status = AcpiDmDumpTable (Length, Offset, SubTable, - sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); - if (ACPI_FAILURE (Status)) - { -@@ -3622,12 +3740,13 @@ - { - ACPI_STATUS Status; - ACPI_TABLE_WPBT *SubTable; -- UINT32 Length = Table->Length; -+ UINT32 Length; - UINT16 ArgumentsLength; - - - /* Dump the main table */ - -+ ACPI_MOVE_32_TO_32(&Length, &Table->Length); - Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt); - if (ACPI_FAILURE (Status)) - { -@@ -3637,10 +3756,10 @@ - /* Extract the arguments buffer length from the main table */ - - SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table); -- ArgumentsLength = SubTable->ArgumentsLength; -+ ACPI_MOVE_16_TO_16(&ArgumentsLength, &SubTable->ArgumentsLength); - - /* Dump the arguments buffer */ - -- (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength, -+ (void) AcpiDmDumpTable (Length, 0, Table, ArgumentsLength, - AcpiDmTableInfoWpbt0); - } -diff -Naur acpica-unix2-20160930/source/components/disassembler/dmbuffer.c acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c ---- acpica-unix2-20160930/source/components/disassembler/dmbuffer.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/disassembler/dmbuffer.c 2016-10-28 14:25:41.876397798 -0600 -@@ -204,7 +204,7 @@ - - - ByteData = Op->Named.Data; -- ByteCount = (UINT32) Op->Common.Value.Integer; -+ ByteCount = (UINT32) Op->Common.Value.Size; - - /* - * The byte list belongs to a buffer, and can be produced by either -@@ -304,7 +304,8 @@ - /* Extract the byte list info */ - - ByteData = NextOp->Named.Data; -- ByteCount = (UINT32) NextOp->Common.Value.Integer; -+ /* ByteCount = (UINT32) NextOp->Common.Value.Integer; */ -+ ByteCount = (UINT32) NextOp->Common.Value.Size; - - /* Byte count must be exactly 16 */ - -@@ -954,16 +955,18 @@ - ACPI_PARSE_OBJECT *Op) - { - UINT32 Name; -+ UINT32 TmpName; - ACPI_PARSE_OBJECT *NextOp; - - - /* Get the NameSegment */ - -- Name = AcpiPsGetName (Op); -- if (!Name) -+ TmpName = AcpiPsGetName (Op); -+ if (!TmpName) - { - return; - } -+ ACPI_MOVE_32_TO_32(&Name, &TmpName); - - NextOp = AcpiPsGetDepthNext (NULL, Op); - if (!NextOp) -diff -Naur acpica-unix2-20160930/source/components/disassembler/dmopcode.c acpica-unix2-20160930-s390/source/components/disassembler/dmopcode.c ---- acpica-unix2-20160930/source/components/disassembler/dmopcode.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/disassembler/dmopcode.c 2016-10-28 14:25:41.877397793 -0600 -@@ -244,6 +244,7 @@ - char *NameString; - int LastCharIsDigit; - int LastCharsAreHex; -+ char TmpName[ACPI_NAME_SIZE + 1]; - - - if (!Op) -@@ -261,7 +262,9 @@ - - /* Predefined name must start with an underscore */ - -- NameString = ACPI_CAST_PTR (char, &Op->Named.Name); -+ memset(TmpName, 0, ACPI_NAME_SIZE + 1); -+ ACPI_MOVE_32_TO_32(TmpName, &Op->Named.Name); -+ NameString = TmpName; - if (NameString[0] != '_') - { - return; -@@ -871,21 +874,26 @@ - AcpiDmNamestring (Op->Common.Value.Name); - break; - -- case AML_INT_NAMEDFIELD_OP: -+ case AML_INT_NAMEDFIELD_OP: { - -- Length = AcpiDmDumpName (Op->Named.Name); -+ UINT32 TmpName; -+ -+ ACPI_MOVE_32_TO_32(&TmpName, &Op->Named.Name); -+ Length = AcpiDmDumpName (TmpName); - AcpiOsPrintf (",%*.s %u", (unsigned) (5 - Length), " ", -- (UINT32) Op->Common.Value.Integer); -+ (UINT32) Op->Common.Value.Size); - AcpiDmCommaIfFieldMember (Op); - -- Info->BitOffset += (UINT32) Op->Common.Value.Integer; -+ Info->BitOffset += (UINT32) Op->Common.Value.Size; - break; -+ } - - case AML_INT_RESERVEDFIELD_OP: - - /* Offset() -- Must account for previous offsets */ - -- Offset = (UINT32) Op->Common.Value.Integer; -+ //DEBUG -+ Offset = Op->Common.Value.Size; - Info->BitOffset += Offset; - - if (Info->BitOffset % 8 == 0) -diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrc.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrc.c ---- acpica-unix2-20160930/source/components/disassembler/dmresrc.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrc.c 2016-10-28 14:25:41.878397788 -0600 -@@ -392,7 +392,7 @@ - ACPI_PARSE_OBJECT *NextOp; - UINT8 *Aml; - UINT8 *EndAml; -- ACPI_SIZE Length; -+ UINT32 Length; - - - /* This op must be a buffer */ -@@ -418,7 +418,7 @@ - } - - Aml = NextOp->Named.Data; -- Length = (ACPI_SIZE) NextOp->Common.Value.Integer; -+ Length = NextOp->Common.Value.Size; - - /* Walk the byte list, abort on any invalid descriptor type or length */ - -diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcl.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c ---- acpica-unix2-20160930/source/components/disassembler/dmresrcl.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcl.c 2016-10-28 14:25:41.876397798 -0600 -@@ -141,7 +141,8 @@ - UINT32 Level) - { - UINT32 i; -- -+ UINT16 Tmp16; -+ UINT32 Tmp32; - - for (i = 0; i < 4; i++) - { -@@ -151,14 +152,14 @@ - { - case 16: - -- AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], -- AcpiDmMemoryNames[i]); -+ ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i])); -+ AcpiDmDumpInteger16 (Tmp16, AcpiDmMemoryNames[i]); - break; - - case 32: - -- AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], -- AcpiDmMemoryNames[i]); -+ ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i])); -+ AcpiDmDumpInteger32 (Tmp32, AcpiDmMemoryNames[i]); - break; - - default: -@@ -190,7 +191,9 @@ - UINT32 Level) - { - UINT32 i; -- -+ UINT16 Tmp16; -+ UINT32 Tmp32; -+ UINT64 Tmp64; - - AcpiOsPrintf ("\n"); - -@@ -202,20 +205,20 @@ - { - case 16: - -- AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], -- AcpiDmAddressNames[i]); -+ ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i])); -+ AcpiDmDumpInteger16 (Tmp16, AcpiDmAddressNames[i]); - break; - - case 32: - -- AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], -- AcpiDmAddressNames[i]); -+ ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i])); -+ AcpiDmDumpInteger32 (Tmp32, AcpiDmAddressNames[i]); - break; - - case 64: - -- AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i], -- AcpiDmAddressNames[i]); -+ ACPI_MOVE_64_TO_64(&Tmp64, &(ACPI_CAST_PTR (UINT64, Source)[i])); -+ AcpiDmDumpInteger64 (Tmp64, AcpiDmAddressNames[i]); - break; - - default: -@@ -868,6 +871,7 @@ - UINT32 Length, - UINT32 Level) - { -+ UINT32 Tmp; - - /* Dump name and read/write flag */ - -@@ -876,12 +880,12 @@ - AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->FixedMemory32.Flags)]); - - AcpiDmIndent (Level + 1); -- AcpiDmDumpInteger32 (Resource->FixedMemory32.Address, -- "Address Base"); -+ ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.Address); -+ AcpiDmDumpInteger32 (Tmp, "Address Base"); - - AcpiDmIndent (Level + 1); -- AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength, -- "Address Length"); -+ ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.AddressLength); -+ AcpiDmDumpInteger32 (Tmp, "Address Length"); - - /* Insert a descriptor name */ - -@@ -972,7 +976,7 @@ - UINT32 Level) - { - UINT32 i; -- -+ UINT16 Tmp16; - - AcpiDmIndent (Level); - AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ", -@@ -986,10 +990,11 @@ - * list. Must compute length based on length of the list. First xrupt - * is included in the struct (reason for -1 below) - */ -+ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->ExtendedIrq.ResourceLength); - AcpiDmResourceSource (Resource, - sizeof (AML_RESOURCE_EXTENDED_IRQ) + - ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32), -- Resource->ExtendedIrq.ResourceLength); -+ Tmp16); - - /* Insert a descriptor name */ - -@@ -1002,9 +1007,12 @@ - AcpiOsPrintf ("{\n"); - for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++) - { -+ UINT32 Tmp32, Val32; -+ - AcpiDmIndent (Level + 1); -- AcpiOsPrintf ("0x%8.8X,\n", -- (UINT32) Resource->ExtendedIrq.Interrupts[i]); -+ Val32 = (UINT32) Resource->ExtendedIrq.Interrupts[i]; -+ ACPI_MOVE_32_TO_32(&Tmp32, &Val32); -+ AcpiOsPrintf ("0x%8.8X,\n", Tmp32); - } - - AcpiDmIndent (Level); -diff -Naur acpica-unix2-20160930/source/components/disassembler/dmresrcs.c acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c ---- acpica-unix2-20160930/source/components/disassembler/dmresrcs.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/disassembler/dmresrcs.c 2016-10-28 14:25:41.876397798 -0600 -@@ -72,6 +72,7 @@ - UINT32 Length, - UINT32 Level) - { -+ UINT16 Tmp; - - AcpiDmIndent (Level); - AcpiOsPrintf ("%s (", -@@ -93,7 +94,8 @@ - AcpiOsPrintf (")\n"); - - AcpiDmIndent (Level + 1); -- AcpiDmBitList (Resource->Irq.IrqMask); -+ ACPI_MOVE_16_TO_16(&Tmp, &Resource->Irq.IrqMask); -+ AcpiDmBitList (Tmp); - } - - -@@ -204,16 +206,19 @@ - UINT32 Length, - UINT32 Level) - { -+ UINT16 Tmp16; - - AcpiDmIndent (Level); - AcpiOsPrintf ("IO (%s,\n", - AcpiGbl_IoDecode [ACPI_GET_1BIT_FLAG (Resource->Io.Flags)]); - - AcpiDmIndent (Level + 1); -- AcpiDmDumpInteger16 (Resource->Io.Minimum, "Range Minimum"); -+ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Minimum); -+ AcpiDmDumpInteger16 (Tmp16, "Range Minimum"); - - AcpiDmIndent (Level + 1); -- AcpiDmDumpInteger16 (Resource->Io.Maximum, "Range Maximum"); -+ ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Maximum); -+ AcpiDmDumpInteger16 (Tmp16, "Range Maximum"); - - AcpiDmIndent (Level + 1); - AcpiDmDumpInteger8 (Resource->Io.Alignment, "Alignment"); -diff -Naur acpica-unix2-20160930/source/components/dispatcher/dsfield.c acpica-unix2-20160930-s390/source/components/dispatcher/dsfield.c ---- acpica-unix2-20160930/source/components/dispatcher/dsfield.c 2016-09-30 10:43:58.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/dispatcher/dsfield.c 2016-10-28 14:25:41.879397782 -0600 -@@ -318,6 +318,7 @@ - ACPI_STATUS Status; - UINT64 Position; - ACPI_PARSE_OBJECT *Child; -+ UINT32 TmpName; - - - ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info); -@@ -424,10 +425,17 @@ - - /* Lookup the name, it should already exist */ - -+ ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name); -+ Status = AcpiNsLookup (WalkState->ScopeInfo, -+ (char *) &TmpName, Info->FieldType, -+ ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, -+ WalkState, &Info->FieldNode); -+ /* - Status = AcpiNsLookup (WalkState->ScopeInfo, - (char *) &Arg->Named.Name, Info->FieldType, - ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, - WalkState, &Info->FieldNode); -+ */ - if (ACPI_FAILURE (Status)) - { - ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); -@@ -652,9 +660,17 @@ - */ - if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP) - { -+ UINT32 TmpName; -+ -+ ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name); -+ Status = AcpiNsLookup (WalkState->ScopeInfo, -+ (char *) &TmpName, Type, ACPI_IMODE_LOAD_PASS1, -+ Flags, WalkState, &Node); -+ /* - Status = AcpiNsLookup (WalkState->ScopeInfo, - (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1, - Flags, WalkState, &Node); -+ */ - if (ACPI_FAILURE (Status)) - { - ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); -diff -Naur acpica-unix2-20160930/source/components/namespace/nsparse.c acpica-unix2-20160930-s390/source/components/namespace/nsparse.c ---- acpica-unix2-20160930/source/components/namespace/nsparse.c 2016-09-30 10:43:59.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/namespace/nsparse.c 2016-10-28 14:25:41.895397700 -0600 -@@ -196,13 +196,14 @@ - - /* Table must consist of at least a complete header */ - -- if (Table->Length < sizeof (ACPI_TABLE_HEADER)) -+ ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length); -+ if (AmlLength < sizeof (ACPI_TABLE_HEADER)) - { - return_ACPI_STATUS (AE_BAD_HEADER); - } - - AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER); -- AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER); -+ AmlLength -= sizeof (ACPI_TABLE_HEADER); - - Status = AcpiTbGetOwnerId (TableIndex, &OwnerId); - if (ACPI_FAILURE (Status)) -diff -Naur acpica-unix2-20160930/source/components/tables/tbprint.c acpica-unix2-20160930-s390/source/components/tables/tbprint.c ---- acpica-unix2-20160930/source/components/tables/tbprint.c 2016-09-30 10:43:59.000000000 -0600 -+++ acpica-unix2-20160930-s390/source/components/tables/tbprint.c 2016-10-28 14:25:41.902397665 -0600 -@@ -143,15 +143,18 @@ - ACPI_TABLE_HEADER *Header) - { - ACPI_TABLE_HEADER LocalHeader; -+ UINT32 Len; -+ UINT32 OemRev; -+ UINT32 CompilerRev; - - - if (ACPI_COMPARE_NAME (Header->Signature, ACPI_SIG_FACS)) - { - /* FACS only has signature and length fields */ - -+ ACPI_MOVE_32_TO_32(&Len, &Header->Length); - ACPI_INFO (("%-4.4s 0x%8.8X%8.8X %06X", -- Header->Signature, ACPI_FORMAT_UINT64 (Address), -- Header->Length)); -+ Header->Signature, ACPI_FORMAT_UINT64 (Address), Len)); - } - else if (ACPI_VALIDATE_RSDP_SIG (Header->Signature)) - { -@@ -174,13 +177,16 @@ - - AcpiTbCleanupTableHeader (&LocalHeader, Header); - -+ ACPI_MOVE_32_TO_32(&Len, &LocalHeader.Length); -+ ACPI_MOVE_32_TO_32(&OemRev, &LocalHeader.OemRevision); -+ ACPI_MOVE_32_TO_32(&CompilerRev, &LocalHeader.AslCompilerRevision); - ACPI_INFO (( - "%-4.4s 0x%8.8X%8.8X" - " %06X (v%.2d %-6.6s %-8.8s %08X %-4.4s %08X)", - LocalHeader.Signature, ACPI_FORMAT_UINT64 (Address), -- LocalHeader.Length, LocalHeader.Revision, LocalHeader.OemId, -- LocalHeader.OemTableId, LocalHeader.OemRevision, -- LocalHeader.AslCompilerId, LocalHeader.AslCompilerRevision)); -+ Len, LocalHeader.Revision, LocalHeader.OemId, -+ LocalHeader.OemTableId, OemRev, -+ LocalHeader.AslCompilerId, CompilerRev)); - } - } - -diff -Naur acpica-unix2-20160930/source/include/platform/aclinux.h acpica-unix2-20160930-s390/source/include/platform/aclinux.h ---- acpica-unix2-20160930/source/include/platform/aclinux.h 2016-10-28 14:24:20.839813236 -0600 -+++ acpica-unix2-20160930-s390/source/include/platform/aclinux.h 2016-10-28 14:25:41.909397629 -0600 -@@ -210,6 +210,10 @@ - #define __cdecl - #endif - -+#if defined(__PPC64__) || defined(__s390x__) -+#define ACPI_BIG_ENDIAN -+#endif -+ - #endif /* __KERNEL__ */ - - #endif /* __ACLINUX_H__ */