acpica-tools/update-big-endian.patch

Index: acpica-unix2-20170119/source/common/acfileio.c
===================================================================
--- acpica-unix2-20170119.orig/source/common/acfileio.c
+++ acpica-unix2-20170119/source/common/acfileio.c
@@ -250,6 +250,7 @@ AcGetOneTableFromFile (
     ACPI_TABLE_HEADER       *Table;
     INT32                   Count;
     long                    TableOffset;
+    UINT32		    TableLen;
 
 
     *ReturnTable = NULL;
@@ -289,7 +290,8 @@ AcGetOneTableFromFile (
 
     /* 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);
@@ -299,8 +301,8 @@ AcGetOneTableFromFile (
 
     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;
@@ -308,7 +310,7 @@ AcGetOneTableFromFile (
 
     /* Validate the checksum (just issue a warning) */
 
-    Status = AcpiTbVerifyChecksum (Table, TableHeader.Length);
+    Status = AcpiTbVerifyChecksum (Table, TableLen);
     if (ACPI_FAILURE (Status))
     {
         Status = AcCheckTextModeCorruption (Table);
@@ -400,6 +402,7 @@ AcValidateTableHeader (
     ACPI_SIZE               Actual;
     long                    OriginalOffset;
     UINT32                  FileSize;
+    UINT32                  TableLength;
     UINT32                  i;
 
 
@@ -431,11 +434,12 @@ AcValidateTableHeader (
     /* 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);
     }
Index: acpica-unix2-20170119/source/common/ahpredef.c
===================================================================
--- acpica-unix2-20170119.orig/source/common/ahpredef.c
+++ acpica-unix2-20170119/source/common/ahpredef.c
@@ -358,7 +358,7 @@ AcpiAhMatchPredefinedName (
     char                        *Nameseg)
 {
     const AH_PREDEFINED_NAME    *Info;
-
+  
 
     for (Info = AslPredefinedInfo; Info->Name; Info++)
     {
Index: acpica-unix2-20170119/source/common/dmtable.c
===================================================================
--- acpica-unix2-20170119.orig/source/common/dmtable.c
+++ acpica-unix2-20170119/source/common/dmtable.c
@@ -499,7 +499,7 @@ AcpiDmDumpDataTable (
      */
     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 @@ AcpiDmDumpDataTable (
     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 @@ AcpiDmDumpTable (
     BOOLEAN                 LastOutputBlankLine = FALSE;
     ACPI_STATUS             Status;
     char                    RepairedName[8];
+    UINT16		    Val16;
 
 
     if (!Info)
@@ -1097,8 +1099,9 @@ AcpiDmDumpTable (
             /* 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 @@ AcpiDmDumpTable (
 
             /* 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 @@ AcpiDmDumpTable (
 
             /* 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 @@ AcpiDmDumpTable (
 
             /* 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;
 
Index: acpica-unix2-20170119/source/common/dmtables.c
===================================================================
--- acpica-unix2-20170119.orig/source/common/dmtables.c
+++ acpica-unix2-20170119/source/common/dmtables.c
@@ -140,7 +140,9 @@ AdCreateTableHeader (
     ACPI_TABLE_HEADER       *Table)
 {
     UINT8                   Checksum;
-
+    UINT32		    TableLen;
+    UINT32		    OemRev;
+    UINT32		    CompilerRev;
 
     /* Reset globals for External statements */
 
@@ -152,9 +154,10 @@ AdCreateTableHeader (
      */
     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 @@ AdCreateTableHeader (
 
     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 @@ AdCreateTableHeader (
     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 @@ AdCreateTableHeader (
     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 @@ AdParseTable (
 
     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 */
Index: acpica-unix2-20170119/source/common/dmtbdump.c
===================================================================
--- acpica-unix2-20170119.orig/source/common/dmtbdump.c
+++ acpica-unix2-20170119/source/common/dmtbdump.c
@@ -277,6 +277,8 @@ AcpiDmDumpRsdt (
     UINT32                  Entries;
     UINT32                  Offset;
     UINT32                  i;
+    UINT32		    Length;
+    UINT32		    Address;
 
 
     /* Point to start of table pointer array */
@@ -286,12 +288,14 @@ AcpiDmDumpRsdt (
 
     /* 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);
     }
 }
@@ -317,6 +321,8 @@ AcpiDmDumpXsdt (
     UINT32                  Entries;
     UINT32                  Offset;
     UINT32                  i;
+    UINT32                  Length;
+    UINT64		    Address;
 
 
     /* Point to start of table pointer array */
@@ -326,12 +332,14 @@ AcpiDmDumpXsdt (
 
     /* 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);
     }
 }
@@ -524,17 +532,21 @@ AcpiDmDumpAsf (
     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;
@@ -591,8 +603,7 @@ AcpiDmDumpAsf (
             return;
         }
 
-        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-            SubTable->Header.Length, InfoTable);
+        Status = AcpiDmDumpTable (Len, Offset, SubTable, SubLen, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -608,7 +619,7 @@ AcpiDmDumpAsf (
             for (i = 0; i < DataCount; i++)
             {
                 AcpiOsPrintf ("\n");
-                Status = AcpiDmDumpTable (Table->Length, DataOffset,
+                Status = AcpiDmDumpTable (Len, DataOffset,
                     DataTable, DataLength, DataInfoTable);
                 if (ACPI_FAILURE (Status))
                 {
@@ -654,15 +665,14 @@ AcpiDmDumpAsf (
 
         /* 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);
     }
 }
 
@@ -686,12 +696,13 @@ AcpiDmDumpCpep (
 {
     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))
     {
@@ -701,7 +712,7 @@ AcpiDmDumpCpep (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
@@ -741,7 +752,10 @@ AcpiDmDumpCsrt (
     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;
@@ -752,14 +766,16 @@ AcpiDmDumpCsrt (
 
     /* 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;
@@ -779,19 +795,20 @@ AcpiDmDumpCsrt (
             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;
@@ -801,7 +818,7 @@ AcpiDmDumpCsrt (
 
             /* Resource-specific info buffer */
 
-            InfoLength = SubSubTable->Length - SubSubOffset;
+            InfoLength = SubSubLength - SubSubOffset;
             if (InfoLength)
             {
                 Status = AcpiDmDumpTable (Length,
@@ -816,16 +833,15 @@ AcpiDmDumpCsrt (
 
             /* 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);
     }
 }
 
@@ -849,16 +865,20 @@ AcpiDmDumpDbg2 (
 {
     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))
     {
@@ -868,11 +888,12 @@ AcpiDmDumpDbg2 (
     /* 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;
@@ -882,13 +903,13 @@ AcpiDmDumpDbg2 (
 
         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;
@@ -899,13 +920,13 @@ AcpiDmDumpDbg2 (
 
         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;
@@ -915,12 +936,13 @@ AcpiDmDumpDbg2 (
         /* 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;
@@ -930,9 +952,10 @@ AcpiDmDumpDbg2 (
 
         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;
@@ -941,9 +964,9 @@ AcpiDmDumpDbg2 (
 
         /* Point to next subtable */
 
-        Offset += SubTable->Length;
+        Offset += SubLength;
         SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
-            SubTable->Length);
+            SubLength);
     }
 }
 
@@ -967,17 +990,20 @@ AcpiDmDumpDmar (
 {
     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))
     {
@@ -987,13 +1013,14 @@ AcpiDmDumpDmar (
     /* 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;
@@ -1001,7 +1028,8 @@ AcpiDmDumpDmar (
 
         AcpiOsPrintf ("\n");
 
-        switch (SubTable->Type)
+	ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type);
+        switch (SubType)
         {
         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 
@@ -1036,12 +1064,12 @@ AcpiDmDumpDmar (
         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;
@@ -1050,8 +1078,8 @@ AcpiDmDumpDmar (
         /*
          * 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 */
 
@@ -1059,7 +1087,7 @@ AcpiDmDumpDmar (
         }
 
         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,
@@ -1100,9 +1128,8 @@ AcpiDmDumpDmar (
 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);
     }
 }
 
@@ -1129,12 +1156,15 @@ AcpiDmDumpDrtm (
     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;
@@ -1148,7 +1178,7 @@ AcpiDmDumpDrtm (
 
     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))
@@ -1161,10 +1191,11 @@ AcpiDmDumpDrtm (
     /* 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))
@@ -1180,7 +1211,7 @@ AcpiDmDumpDrtm (
 
     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))
@@ -1193,10 +1224,11 @@ AcpiDmDumpDrtm (
     /* 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))
@@ -1212,7 +1244,7 @@ AcpiDmDumpDrtm (
 
     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);
 }
 
@@ -1236,12 +1268,13 @@ AcpiDmDumpEinj (
 {
     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))
     {
@@ -1251,7 +1284,7 @@ AcpiDmDumpEinj (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
@@ -1289,12 +1322,13 @@ AcpiDmDumpErst (
 {
     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))
     {
@@ -1304,7 +1338,7 @@ AcpiDmDumpErst (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
@@ -1342,17 +1376,19 @@ AcpiDmDumpFpdt (
 {
     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 */
 
@@ -1364,7 +1400,8 @@ AcpiDmDumpFpdt (
             return;
         }
 
-        switch (SubTable->Type)
+	ACPI_MOVE_16_TO_16(&Type, &SubTable->Type);
+        switch (Type)
         {
         case ACPI_FPDT_TYPE_BOOT:
 
@@ -1378,8 +1415,7 @@ AcpiDmDumpFpdt (
 
         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 */
 
@@ -1427,16 +1463,19 @@ AcpiDmDumpGtdt (
 {
     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))
     {
@@ -1446,7 +1485,7 @@ AcpiDmDumpGtdt (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         /* Common subtable header */
 
@@ -1464,8 +1503,9 @@ AcpiDmDumpGtdt (
         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;
@@ -1486,8 +1526,9 @@ AcpiDmDumpGtdt (
             return;
         }
 
+	ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-            SubTable->Length, InfoTable);
+            SubLength, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1546,16 +1587,18 @@ AcpiDmDumpHest (
 {
     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))
     {
@@ -1565,10 +1608,11 @@ AcpiDmDumpHest (
     /* 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:
 
@@ -1697,15 +1741,21 @@ AcpiDmDumpIort (
     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;
@@ -1716,18 +1766,19 @@ AcpiDmDumpIort (
 
     /* 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 */
 
@@ -1763,7 +1814,8 @@ AcpiDmDumpIort (
         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:
@@ -1776,7 +1828,8 @@ AcpiDmDumpIort (
         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:
@@ -1786,7 +1839,8 @@ AcpiDmDumpIort (
 
             /* Attempt to continue */
 
-            if (!IortNode->Length)
+	    ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
+            if (!NodeLength)
             {
                 AcpiOsPrintf ("Invalid zero length IORT node\n");
                 return;
@@ -1797,7 +1851,7 @@ AcpiDmDumpIort (
         /* 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))
@@ -1817,9 +1871,10 @@ AcpiDmDumpIort (
 
             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;
@@ -1831,11 +1886,11 @@ AcpiDmDumpIort (
 
             /* 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;
@@ -1852,8 +1907,8 @@ AcpiDmDumpIort (
             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))
@@ -1861,10 +1916,11 @@ AcpiDmDumpIort (
                     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))
@@ -1875,10 +1931,11 @@ AcpiDmDumpIort (
                     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))
@@ -1898,12 +1955,13 @@ AcpiDmDumpIort (
 
         /* 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))
@@ -1917,8 +1975,9 @@ AcpiDmDumpIort (
 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);
     }
 }
 
@@ -1949,11 +2008,14 @@ AcpiDmDumpIvrs (
     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;
@@ -1962,13 +2024,14 @@ AcpiDmDumpIvrs (
     /* 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;
@@ -1995,7 +2058,7 @@ AcpiDmDumpIvrs (
 
             /* Attempt to continue */
 
-            if (!SubTable->Length)
+            if (!SubLength)
             {
                 AcpiOsPrintf ("Invalid zero length subtable\n");
                 return;
@@ -2006,8 +2069,8 @@ AcpiDmDumpIvrs (
         /* 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;
@@ -2021,7 +2084,7 @@ AcpiDmDumpIvrs (
             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
                 sizeof (ACPI_IVRS_HARDWARE));
 
-            while (EntryOffset < (Offset + SubTable->Length))
+            while (EntryOffset < (Offset + SubLength))
             {
                 AcpiOsPrintf ("\n");
                 /*
@@ -2083,7 +2146,7 @@ AcpiDmDumpIvrs (
 
                 /* Dump the Device Entry */
 
-                Status = AcpiDmDumpTable (Table->Length, EntryOffset,
+                Status = AcpiDmDumpTable (Length, EntryOffset,
                     DeviceEntry, EntryLength, InfoTable);
                 if (ACPI_FAILURE (Status))
                 {
@@ -2099,8 +2162,8 @@ AcpiDmDumpIvrs (
 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);
     }
 }
 
@@ -2126,7 +2189,7 @@ AcpiDmDumpLpit (
 {
     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;
@@ -2134,8 +2197,9 @@ AcpiDmDumpLpit (
 
     /* 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 */
 
@@ -2199,13 +2263,14 @@ AcpiDmDumpMadt (
 {
     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))
     {
@@ -2215,7 +2280,7 @@ AcpiDmDumpMadt (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         /* Common subtable header */
 
@@ -2361,11 +2426,13 @@ AcpiDmDumpMcfg (
     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;
@@ -2374,17 +2441,17 @@ AcpiDmDumpMcfg (
     /* 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))
         {
@@ -2418,6 +2485,7 @@ AcpiDmDumpMpst (
 {
     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;
@@ -2426,11 +2494,13 @@ AcpiDmDumpMpst (
     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;
@@ -2438,13 +2508,14 @@ AcpiDmDumpMpst (
 
     /* 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))
         {
@@ -2453,8 +2524,8 @@ AcpiDmDumpMpst (
 
         /* 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) */
@@ -2465,7 +2536,7 @@ AcpiDmDumpMpst (
         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))
             {
@@ -2475,7 +2546,7 @@ AcpiDmDumpMpst (
             SubTable0A++;
             PowerStateCount--;
             Offset += sizeof (ACPI_MPST_POWER_STATE);
-       }
+        }
 
         /* Sub-subtables - Physical Component ID Structure(s) */
 
@@ -2488,7 +2559,7 @@ AcpiDmDumpMpst (
 
         while (ComponentCount)
         {
-            Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
+            Status = AcpiDmDumpTable (Length, Offset, SubTable0B,
                 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
             if (ACPI_FAILURE (Status))
             {
@@ -2503,17 +2574,19 @@ AcpiDmDumpMpst (
         /* 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))
     {
@@ -2528,10 +2601,10 @@ AcpiDmDumpMpst (
     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))
         {
@@ -2564,11 +2637,13 @@ AcpiDmDumpMsct (
     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;
@@ -2577,12 +2652,12 @@ AcpiDmDumpMsct (
     /* 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))
         {
@@ -2617,11 +2692,13 @@ AcpiDmDumpMtmr (
     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;
@@ -2630,12 +2707,12 @@ AcpiDmDumpMtmr (
     /* 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))
         {
@@ -2677,11 +2754,17 @@ AcpiDmDumpNfit (
     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;
@@ -2690,19 +2773,21 @@ AcpiDmDumpNfit (
     /* 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:
 
@@ -2754,7 +2839,7 @@ AcpiDmDumpNfit (
 
             /* Attempt to continue */
 
-            if (!SubTable->Length)
+            if (!SubLength)
             {
                 AcpiOsPrintf ("Invalid zero length subtable\n");
                 return;
@@ -2763,8 +2848,8 @@ AcpiDmDumpNfit (
         }
 
         AcpiOsPrintf ("\n");
-        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-            SubTable->Length, InfoTable);
+        Status = AcpiDmDumpTable (TableLength, Offset, SubTable,
+            SubLength, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2772,13 +2857,14 @@ AcpiDmDumpNfit (
 
         /* 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))
@@ -2792,12 +2878,11 @@ AcpiDmDumpNfit (
 
         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);
@@ -2811,9 +2896,10 @@ AcpiDmDumpNfit (
 
         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))
@@ -2832,8 +2918,8 @@ AcpiDmDumpNfit (
 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);
     }
 }
 
@@ -2858,12 +2944,13 @@ AcpiDmDumpPcct (
     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))
     {
@@ -2873,7 +2960,7 @@ AcpiDmDumpPcct (
     /* Subtables */
 
     SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
-    while (Offset < Table->Length)
+    while (Offset < Length)
     {
         /* Common subtable header */
 
@@ -2949,16 +3036,21 @@ AcpiDmDumpPmtt (
     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))
     {
@@ -2968,13 +3060,14 @@ AcpiDmDumpPmtt (
     /* 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;
@@ -2993,7 +3086,7 @@ AcpiDmDumpPmtt (
         /* Dump the fixed-length portion of the subtable */
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-            SubTable->Length, AcpiDmTableInfoPmtt0);
+            SubLength, AcpiDmTableInfoPmtt0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -3005,15 +3098,16 @@ AcpiDmDumpPmtt (
         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;
@@ -3033,7 +3127,7 @@ AcpiDmDumpPmtt (
 
             Status = AcpiDmDumpTable (Length,
                 Offset + MemOffset, MemSubTable,
-                MemSubTable->Length, AcpiDmTableInfoPmtt1);
+                MemLength, AcpiDmTableInfoPmtt1);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -3041,13 +3135,14 @@ AcpiDmDumpPmtt (
 
             /* 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,
@@ -3075,15 +3170,16 @@ AcpiDmDumpPmtt (
             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;
@@ -3103,7 +3199,7 @@ AcpiDmDumpPmtt (
 
                 Status = AcpiDmDumpTable (Length,
                     Offset + MemOffset + DimmOffset, DimmSubTable,
-                    DimmSubTable->Length, AcpiDmTableInfoPmtt2);
+                    DimmLength, AcpiDmTableInfoPmtt2);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -3111,23 +3207,22 @@ AcpiDmDumpPmtt (
 
                 /* 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);
     }
 }
 
@@ -3153,6 +3248,8 @@ AcpiDmDumpS3pt (
     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 */
@@ -3163,20 +3260,22 @@ AcpiDmDumpS3pt (
         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:
 
@@ -3191,7 +3290,7 @@ AcpiDmDumpS3pt (
         default:
 
             AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
-                SubTable->Type);
+                SubType);
 
             /* Attempt to continue */
 
@@ -3204,7 +3303,7 @@ AcpiDmDumpS3pt (
         }
 
         AcpiOsPrintf ("\n");
-        Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
+        Status = AcpiDmDumpTable (Length, Offset, SubTable,
             SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
@@ -3238,9 +3337,11 @@ void
 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);
 }
 
 
@@ -3263,14 +3364,17 @@ AcpiDmDumpSlit (
     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;
@@ -3278,7 +3382,8 @@ AcpiDmDumpSlit (
 
     /* 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;
 
@@ -3291,7 +3396,7 @@ AcpiDmDumpSlit (
         {
             /* Check for beyond EOT */
 
-            if (Offset >= Table->Length)
+            if (Offset >= Length)
             {
                 AcpiOsPrintf (
                     "\n**** Not enough room in table for all localities\n");
@@ -3343,11 +3448,13 @@ AcpiDmDumpSrat (
     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;
@@ -3356,12 +3463,12 @@ AcpiDmDumpSrat (
     /* 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))
         {
@@ -3405,7 +3512,7 @@ AcpiDmDumpSrat (
         }
 
         AcpiOsPrintf ("\n");
-        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
+        Status = AcpiDmDumpTable (Length, Offset, SubTable,
             SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
@@ -3442,13 +3549,14 @@ AcpiDmDumpStao (
 {
     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))
     {
@@ -3457,7 +3565,7 @@ AcpiDmDumpStao (
 
     /* 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;
@@ -3499,11 +3607,14 @@ AcpiDmDumpTcpa (
     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))
     {
@@ -3514,18 +3625,19 @@ AcpiDmDumpTcpa (
      * 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:
@@ -3562,11 +3674,13 @@ AcpiDmDumpVrtc (
     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;
@@ -3575,12 +3689,12 @@ AcpiDmDumpVrtc (
     /* 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))
         {
@@ -3615,11 +3729,13 @@ AcpiDmDumpWdat (
     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;
@@ -3628,12 +3744,12 @@ AcpiDmDumpWdat (
     /* 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))
         {
@@ -3668,12 +3784,13 @@ AcpiDmDumpWpbt (
 {
     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))
     {
@@ -3683,10 +3800,10 @@ AcpiDmDumpWpbt (
     /* 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);
 }
Index: acpica-unix2-20170119/source/compiler/aslrestype2.c
===================================================================
--- acpica-unix2-20170119.orig/source/compiler/aslrestype2.c
+++ acpica-unix2-20170119/source/compiler/aslrestype2.c
@@ -98,21 +98,33 @@ RsDoGeneralRegisterDescriptor (
         {
         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 @@ RsDoGeneralRegisterDescriptor (
 
         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));
 
Index: acpica-unix2-20170119/source/compiler/dtfield.c
===================================================================
--- acpica-unix2-20170119.orig/source/compiler/dtfield.c
+++ acpica-unix2-20170119/source/compiler/dtfield.c
@@ -360,7 +360,27 @@ DtCompileInteger (
         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;
 }
 
Index: acpica-unix2-20170119/source/compiler/dtsubtable.c
===================================================================
--- acpica-unix2-20170119.orig/source/compiler/dtsubtable.c
+++ acpica-unix2-20170119/source/compiler/dtsubtable.c
@@ -379,6 +379,21 @@ DtSetSubtableLength (
         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);
+    }
 }
Index: acpica-unix2-20170119/source/compiler/dttable1.c
===================================================================
--- acpica-unix2-20170119.orig/source/compiler/dttable1.c
+++ acpica-unix2-20170119/source/compiler/dttable1.c
@@ -282,6 +282,8 @@ DtCompileCsrt (
     DT_FIELD                **PFieldList = (DT_FIELD **) List;
     UINT32                  DescriptorCount;
     UINT32                  GroupLength;
+    ACPI_CSRT_GROUP	    *Pgrp;
+    UINT32		    Tmp32;
 
 
     /* Subtables (Resource Groups) */
@@ -300,12 +302,20 @@ DtCompileCsrt (
 
         /* 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 @@ DtCompileDbg2 (
     ACPI_DBG2_DEVICE        *DeviceInfo;
     UINT16                  CurrentOffset;
     UINT32                  i;
+    UINT16                  Tmp16;
+    UINT32                  Tmp32;
 
 
     /* Main table */
@@ -409,10 +421,11 @@ DtCompileDbg2 (
     /* 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 @@ DtCompileDbg2 (
 
         /* 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 @@ DtCompileDbg2 (
 
         /* 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 @@ DtCompileDbg2 (
 
         /* 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 @@ DtCompileDbg2 (
 
         /* 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 @@ DtCompileDbg2 (
 
         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 @@ DtCompileDmar (
     ACPI_DMAR_DEVICE_SCOPE  *DmarDeviceScope;
     UINT32                  DeviceScopeLength;
     UINT32                  PciPathLength;
+    UINT16		    Tmp16;
+    UINT16		    HdrType;
 
 
     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE);
@@ -573,8 +589,11 @@ DtCompileDmar (
         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 @@ DtCompileDmar (
         /*
          * 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 @@ DtCompileDmar (
         }
 
         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 @@ DtCompileDrtm (
         Count++;
     }
 
-    DrtmVtl->ValidatedTableCount = Count;
+    ACPI_MOVE_32_TO_32(&DrtmVtl->ValidatedTableCount, &Count);
     DtPopSubtable ();
     ParentTable = DtPeekSubtable ();
 
@@ -795,7 +814,7 @@ DtCompileDrtm (
         Count++;
     }
 
-    DrtmRl->ResourceCount = Count;
+    ACPI_MOVE_32_TO_32(&DrtmRl->ResourceCount, &Count);
     DtPopSubtable ();
     ParentTable = DtPeekSubtable ();
 
@@ -889,6 +908,7 @@ DtCompileGtdt (
     ACPI_SUBTABLE_HEADER    *GtdtHeader;
     ACPI_DMTABLE_INFO       *InfoTable;
     UINT32                  GtCount;
+    ACPI_GTDT_TIMER_BLOCK   *TimerBlock;
 
 
     Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt,
@@ -955,8 +975,9 @@ DtCompileGtdt (
             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 @@ DtCompileFpdt (
     ACPI_DMTABLE_INFO       *InfoTable;
     DT_FIELD                **PFieldList = (DT_FIELD **) List;
     DT_FIELD                *SubtableStart;
+    UINT16		    HdrType;
 
 
     while (*PFieldList)
@@ -1027,7 +1049,8 @@ DtCompileFpdt (
 
         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 @@ DtCompileHest (
     ACPI_DMTABLE_INFO       *InfoTable;
     UINT16                  Type;
     UINT32                  BankCount;
+    UINT16		    Tmp16;
 
 
     Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
@@ -1102,8 +1126,9 @@ DtCompileHest (
         /* 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 @@ DtCompileIort (
     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 @@ DtCompileIort (
      * 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 @@ DtCompileIort (
     if (Subtable)
     {
         DtInsertSubtable (ParentTable, Subtable);
-        Iort->NodeOffset += Subtable->Length;
+        NodeOffset += Subtable->Length;
     }
     else
     {
@@ -1275,8 +1302,9 @@ DtCompileIort (
         {
             return (Status);
         }
-        Iort->NodeOffset += PaddingLength;
+        NodeOffset += PaddingLength;
     }
+    ACPI_MOVE_32_TO_32(&Iort->NodeOffset, &NodeOffset);
 
     NodeNumber = 0;
     while (*PFieldList)
@@ -1330,7 +1358,7 @@ DtCompileIort (
                 ItsNumber++;
             }
 
-            IortItsGroup->ItsCount = ItsNumber;
+            ACPI_MOVE_32_TO_32(&IortItsGroup->ItsCount, &ItsNumber);
             break;
 
         case ACPI_IORT_NODE_NAMED_COMPONENT:
@@ -1364,15 +1392,16 @@ DtCompileIort (
             }
             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 @@ DtCompileIort (
                     }
 
                     DtInsertSubtable (ParentTable, Subtable);
-                    NodeLength = IortNode->MappingOffset;
+		    ACPI_MOVE_32_TO_32(&MappingOffset, &IortNode->MappingOffset);
+                    NodeLength = MappingOffset;
                 }
             }
             break;
@@ -1413,7 +1443,7 @@ DtCompileIort (
 
             /* 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 @@ DtCompileIort (
             /* 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 @@ DtCompileIort (
                 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 @@ DtCompileIort (
                 PmuIrptNumber++;
             }
 
-            IortSmmu->PmuInterruptCount = PmuIrptNumber;
+            ACPI_MOVE_32_TO_32(&IortSmmu->PmuInterruptCount, &PmuIrptNumber);
             break;
 
         case ACPI_IORT_NODE_SMMU_V3:
@@ -1496,7 +1526,7 @@ DtCompileIort (
 
         /* Compile Array of ID mappings */
 
-        IortNode->MappingOffset = NodeLength;
+        ACPI_MOVE_32_TO_32(&IortNode->MappingOffset, &NodeLength);
         IdMappingNumber = 0;
         while (*PFieldList)
         {
@@ -1517,7 +1547,7 @@ DtCompileIort (
             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 @@ DtCompileIort (
         NodeNumber++;
     }
 
-    Iort->NodeCount = NodeNumber;
+    ACPI_MOVE_32_TO_32(&Iort->NodeCount, &NodeNumber);
     return (AE_OK);
 }
 
Index: acpica-unix2-20170119/source/compiler/dttable2.c
===================================================================
--- acpica-unix2-20170119.orig/source/compiler/dttable2.c
+++ acpica-unix2-20170119/source/compiler/dttable2.c
@@ -346,7 +346,7 @@ DtCompileMpst (
     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 @@ DtCompileMpst (
         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 @@ DtCompileNfit (
     UINT32                  Count;
     ACPI_NFIT_INTERLEAVE    *Interleave = NULL;
     ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
+    UINT16		    SubType;
 
 
     /* Main table */
@@ -551,7 +552,8 @@ DtCompileNfit (
 
         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 @@ DtCompileNfit (
         DtInsertSubtable (ParentTable, Subtable);
         DtPopSubtable ();
 
-        switch (NfitHeader->Type)
+        switch (SubType)
         {
         case ACPI_NFIT_TYPE_INTERLEAVE:
 
@@ -632,7 +634,7 @@ DtCompileNfit (
                 Count++;
             }
 
-            Interleave->LineCount = Count;
+            ACPI_MOVE_32_TO_32(&Interleave->LineCount, &Count);
             DtPopSubtable ();
             break;
 
@@ -678,7 +680,7 @@ DtCompileNfit (
                 Count++;
             }
 
-            Hint->HintCount = (UINT16) Count;
+            ACPI_MOVE_32_TO_16(&Hint->HintCount, &Count);
             DtPopSubtable ();
             break;
 
@@ -885,7 +887,7 @@ DtCompilePmtt (
 
             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 @@ DtCompileS3pt (
     DT_SUBTABLE             *ParentTable;
     ACPI_DMTABLE_INFO       *InfoTable;
     DT_FIELD                *SubtableStart;
+    UINT16		    HdrType;
 
 
     Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
@@ -1013,7 +1016,8 @@ DtCompileS3pt (
 
         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 @@ DtCompileSlit (
     DT_FIELD                *FieldList;
     UINT32                  Localities;
     UINT8                   *LocalityBuffer;
+    UINT32		    Tmp;
 
 
     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
@@ -1122,7 +1127,8 @@ DtCompileSlit (
     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 @@ DtCompileTcpa (
     ACPI_TABLE_TCPA_HDR     *TcpaHeader;
     DT_SUBTABLE             *ParentTable;
     ACPI_STATUS             Status;
+    UINT16		    PlatClass;
 
 
     /* Compile the main table */
@@ -1331,7 +1338,8 @@ DtCompileTcpa (
      */
     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 @@ DtCompileWpbt (
     ACPI_TABLE_WPBT         *Table;
     ACPI_STATUS             Status;
     UINT16                  Length;
+    UINT16                  Tmp16;
+    UINT16		    *Ptr16;
+    UINT32		    ii;
 
 
     /* Compile the main table */
@@ -1554,7 +1565,16 @@ DtCompileWpbt (
 
     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);
Index: acpica-unix2-20170119/source/components/disassembler/dmbuffer.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/disassembler/dmbuffer.c
+++ acpica-unix2-20170119/source/components/disassembler/dmbuffer.c
@@ -204,7 +204,7 @@ AcpiDmByteList (
 
 
     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 @@ AcpiDmIsUuidBuffer (
     /* 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 */
 
@@ -424,7 +425,8 @@ AcpiDmIsUnicodeBuffer (
     /* 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);
 
     /*
@@ -852,19 +854,22 @@ AcpiDmUnicode (
     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 */
 
@@ -973,16 +978,18 @@ AcpiDmCheckForHardwareId (
     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)
Index: acpica-unix2-20170119/source/components/disassembler/dmopcode.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/disassembler/dmopcode.c
+++ acpica-unix2-20170119/source/components/disassembler/dmopcode.c
@@ -251,6 +251,7 @@ AcpiDmPredefinedDescription (
     char                        *NameString;
     int                         LastCharIsDigit;
     int                         LastCharsAreHex;
+    char			TmpName[ACPI_NAME_SIZE + 1];
 
 
     if (!Op)
@@ -268,7 +269,9 @@ AcpiDmPredefinedDescription (
 
     /* 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;
@@ -878,21 +881,26 @@ AcpiDmDisassembleOneOp (
         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)
Index: acpica-unix2-20170119/source/components/disassembler/dmresrcl2.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/disassembler/dmresrcl2.c
+++ acpica-unix2-20170119/source/components/disassembler/dmresrcl2.c
@@ -191,22 +191,24 @@ AcpiDmGpioCommon (
     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 @@ AcpiDmGpioCommon (
 
     /* 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 @@ AcpiDmGpioCommon (
     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 @@ AcpiDmGpioIntDescriptor (
     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 @@ AcpiDmGpioIntDescriptor (
     {
         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 @@ AcpiDmGpioIoDescriptor (
     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 @@ AcpiDmGpioIoDescriptor (
 
     /* 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 @@ AcpiDmDumpSerialBusVendorData (
 {
     UINT8                   *VendorData;
     UINT32                  VendorLength;
+    UINT16                  Tmp16;
 
 
     /* Get the (optional) vendor data and length */
@@ -435,8 +455,8 @@ AcpiDmDumpSerialBusVendorData (
     {
     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 @@ AcpiDmDumpSerialBusVendorData (
 
     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 @@ AcpiDmDumpSerialBusVendorData (
 
     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 @@ AcpiDmI2cSerialBusDescriptor (
 {
     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 @@ AcpiDmI2cSerialBusDescriptor (
 
     /* 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);
Index: acpica-unix2-20170119/source/components/disassembler/dmresrcl.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/disassembler/dmresrcl.c
+++ acpica-unix2-20170119/source/components/disassembler/dmresrcl.c
@@ -141,7 +141,8 @@ AcpiDmMemoryFields (
     UINT32                  Level)
 {
     UINT32                  i;
-
+    UINT16		    Tmp16;
+    UINT32		    Tmp32;
 
     for (i = 0; i < 4; i++)
     {
@@ -151,14 +152,14 @@ AcpiDmMemoryFields (
         {
         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 @@ AcpiDmAddressFields (
     UINT32                  Level)
 {
     UINT32                  i;
-
+    UINT16		    Tmp16;
+    UINT32		    Tmp32;
+    UINT64		    Tmp64;
 
     AcpiOsPrintf ("\n");
 
@@ -202,20 +205,20 @@ AcpiDmAddressFields (
         {
         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 @@ AcpiDmFixedMemory32Descriptor (
     UINT32                  Length,
     UINT32                  Level)
 {
+    UINT32 Tmp;
 
     /* Dump name and read/write flag */
 
@@ -876,12 +880,12 @@ AcpiDmFixedMemory32Descriptor (
         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 */
 
@@ -913,6 +917,7 @@ AcpiDmGenericRegisterDescriptor (
     UINT32                  Length,
     UINT32                  Level)
 {
+    UINT64		    Tmp64;
 
     AcpiDmIndent (Level);
     AcpiOsPrintf ("Register (");
@@ -926,7 +931,9 @@ AcpiDmGenericRegisterDescriptor (
     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 */
 
@@ -972,7 +979,7 @@ AcpiDmInterruptDescriptor (
     UINT32                  Level)
 {
     UINT32                  i;
-
+    UINT16		    Tmp16;
 
     AcpiDmIndent (Level);
     AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ",
@@ -986,10 +993,11 @@ AcpiDmInterruptDescriptor (
      * 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 +1010,12 @@ AcpiDmInterruptDescriptor (
     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);
Index: acpica-unix2-20170119/source/components/disassembler/dmresrcs.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/disassembler/dmresrcs.c
+++ acpica-unix2-20170119/source/components/disassembler/dmresrcs.c
@@ -72,6 +72,7 @@ AcpiDmIrqDescriptor (
     UINT32                  Length,
     UINT32                  Level)
 {
+    UINT16 Tmp;
 
     AcpiDmIndent (Level);
     AcpiOsPrintf ("%s (",
@@ -93,7 +94,8 @@ AcpiDmIrqDescriptor (
     AcpiOsPrintf (")\n");
 
     AcpiDmIndent (Level + 1);
-    AcpiDmBitList (Resource->Irq.IrqMask);
+    ACPI_MOVE_16_TO_16(&Tmp, &Resource->Irq.IrqMask);
+    AcpiDmBitList (Tmp);
 }
 
 
@@ -204,16 +206,19 @@ AcpiDmIoDescriptor (
     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");
@@ -251,12 +256,14 @@ AcpiDmFixedIoDescriptor (
     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");
Index: acpica-unix2-20170119/source/components/dispatcher/dsfield.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/dispatcher/dsfield.c
+++ acpica-unix2-20170119/source/components/dispatcher/dsfield.c
@@ -318,6 +318,7 @@ AcpiDsGetFieldNames (
     ACPI_STATUS             Status;
     UINT64                  Position;
     ACPI_PARSE_OBJECT       *Child;
+    UINT32 TmpName;
 
 
     ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info);
@@ -424,10 +425,17 @@ AcpiDsGetFieldNames (
 
             /* 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 @@ AcpiDsInitFieldObjects (
          */
         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);
Index: acpica-unix2-20170119/source/components/events/evgpeblk.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/events/evgpeblk.c
+++ acpica-unix2-20170119/source/components/events/evgpeblk.c
@@ -376,6 +376,7 @@ AcpiEvCreateGpeBlock (
     ACPI_STATUS             Status;
     ACPI_GPE_BLOCK_INFO     *GpeBlock;
     ACPI_GPE_WALK_INFO      WalkInfo;
+    char		    Name[ACPI_NAME_SIZE + 1];
 
 
     ACPI_FUNCTION_TRACE (EvCreateGpeBlock);
@@ -396,7 +397,7 @@ AcpiEvCreateGpeBlock (
 
     /* Initialize the new GPE block */
 
-    GpeBlock->Address = Address;
+    ACPI_MOVE_64_TO_64(&GpeBlock->Address, &Address);
     GpeBlock->SpaceId = SpaceId;
     GpeBlock->Node = GpeDevice;
     GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
@@ -445,11 +446,13 @@ AcpiEvCreateGpeBlock (
         (*ReturnGpeBlock) = GpeBlock;
     }
 
+    memset(&Name, 0, ACPI_NAME_SIZE + 1);
+    ACPI_MOVE_32_TO_32(&Name, &GpeDevice->Name.Ascii);
     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
         "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
         (UINT32) GpeBlock->BlockBaseNumber,
         (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
-        GpeDevice->Name.Ascii, GpeBlock->RegisterCount, InterruptNumber,
+        Name, GpeBlock->RegisterCount, InterruptNumber,
         InterruptNumber == AcpiGbl_FADT.SciInterrupt ? " (SCI)" : ""));
 
     /* Update global count of currently available GPEs */
Index: acpica-unix2-20170119/source/components/hardware/hwregs.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/hardware/hwregs.c
+++ acpica-unix2-20170119/source/components/hardware/hwregs.c
@@ -197,7 +197,7 @@ AcpiHwValidateRegister (
      * Address must not be null. A null address also indicates an optional
      * ACPI register that is not supported, so no error message.
      */
-    ACPI_MOVE_64_TO_64 (Address, &Reg->Address);
+    *Address =  Reg->Address;
     if (!(*Address))
     {
         return (AE_BAD_ADDRESS);
Index: acpica-unix2-20170119/source/components/hardware/hwvalid.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/hardware/hwvalid.c
+++ acpica-unix2-20170119/source/components/hardware/hwvalid.c
@@ -135,6 +135,8 @@ AcpiHwValidateIoRequest (
     UINT32                  ByteWidth;
     ACPI_IO_ADDRESS         LastAddress;
     const ACPI_PORT_INFO    *PortInfo;
+    UINT64                  Max16;
+    UINT64                  Tmp64;
 
 
     ACPI_FUNCTION_TRACE (HwValidateIoRequest);
@@ -161,7 +163,10 @@ AcpiHwValidateIoRequest (
 
     /* Maximum 16-bit address in I/O space */
 
-    if (LastAddress > ACPI_UINT16_MAX)
+    Max16 = (UINT64) ACPI_UINT16_MAX;
+    ACPI_MOVE_64_TO_64(&Tmp64, &Max16);
+
+    if ((UINT64)LastAddress > Tmp64)
     {
         ACPI_ERROR ((AE_INFO,
             "Illegal I/O port address/length above 64K: %8.8X%8.8X/0x%X",
Index: acpica-unix2-20170119/source/components/namespace/nsaccess.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/namespace/nsaccess.c
+++ acpica-unix2-20170119/source/components/namespace/nsaccess.c
@@ -309,6 +309,7 @@ AcpiNsLookup (
     ACPI_OBJECT_TYPE        ThisSearchType;
     UINT32                  SearchParentFlag = ACPI_NS_SEARCH_PARENT;
     UINT32                  LocalFlags;
+    UINT32		    Tmp32;
 
 
     ACPI_FUNCTION_TRACE (NsLookup);
@@ -657,9 +658,10 @@ AcpiNsLookup (
             {
                 /* 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)));
             }
Index: acpica-unix2-20170119/source/components/namespace/nsparse.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/namespace/nsparse.c
+++ acpica-unix2-20170119/source/components/namespace/nsparse.c
@@ -196,13 +196,14 @@ AcpiNsOneCompleteParse (
 
     /* 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))
Index: acpica-unix2-20170119/source/components/tables/tbdata.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbdata.c
+++ acpica-unix2-20170119/source/components/tables/tbdata.c
@@ -407,6 +407,7 @@ AcpiTbVerifyTempTable (
     char                    *Signature)
 {
     ACPI_STATUS             Status = AE_OK;
+    UINT32		    Length;
 
 
     ACPI_FUNCTION_TRACE (TbVerifyTempTable);
@@ -436,7 +437,8 @@ AcpiTbVerifyTempTable (
 
     if (AcpiGbl_VerifyTableChecksum)
     {
-        Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length);
+	ACPI_MOVE_32_TO_32(&Length, &TableDesc->Length);
+        Status = AcpiTbVerifyChecksum (TableDesc->Pointer, Length);
         if (ACPI_FAILURE (Status))
         {
             ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY,
Index: acpica-unix2-20170119/source/components/tables/tbfadt.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbfadt.c
+++ acpica-unix2-20170119/source/components/tables/tbfadt.c
@@ -520,6 +520,8 @@ AcpiTbConvertFadt (
     UINT8                   Length;
     UINT8                   Flags;
     UINT32                  i;
+    UINT32		    Tmp32;
+    UINT64		    Tmp64;
 
 
     /*
@@ -533,7 +535,8 @@ AcpiTbConvertFadt (
      * Note: The FADT revision value is unreliable. Only the length can be
      * trusted.
      */
-    if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
+    ACPI_MOVE_32_TO_32(&Tmp32, &AcpiGbl_FADT.Header.Length);
+    if (Tmp32 <= ACPI_FADT_V2_SIZE)
     {
         AcpiGbl_FADT.PreferredProfile = 0;
         AcpiGbl_FADT.PstateControl = 0;
@@ -546,14 +549,15 @@ AcpiTbConvertFadt (
      * current FADT version as defined by the ACPI specification.
      * Thus, we will have a common FADT internally.
      */
-    AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT);
+    Tmp32 = sizeof (ACPI_TABLE_FADT);
+    ACPI_MOVE_32_TO_32(&AcpiGbl_FADT.Header.Length, &Tmp32);
 
     /*
      * Expand the 32-bit DSDT addresses to 64-bit as necessary.
      * Later ACPICA code will always use the X 64-bit field.
      */
-    AcpiGbl_FADT.XDsdt = AcpiTbSelectAddress ("DSDT",
-        AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
+    Tmp64 = AcpiTbSelectAddress ("DSDT", AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
+    ACPI_MOVE_64_TO_64(&AcpiGbl_FADT.XDsdt, &Tmp64);
 
     /* If Hardware Reduced flag is set, we are all done */
 
@@ -614,7 +618,9 @@ AcpiTbConvertFadt (
         {
             if (Address64->Address)
             {
-                if (Address64->Address != (UINT64) Address32)
+		ACPI_MOVE_32_TO_32(&Tmp32, &Address32);
+		ACPI_MOVE_64_TO_64(&Tmp64, &Address64->Address);
+                if (Tmp64 != (UINT64) Tmp32)
                 {
                     /* Address mismatch */
 
@@ -655,9 +661,11 @@ AcpiTbConvertFadt (
              */
             if (!Address64->Address || AcpiGbl_Use32BitFadtAddresses)
             {
+		ACPI_MOVE_32_TO_32(&Tmp32, &Address32); /* back to host order */
+		Tmp64 = (UINT64) Tmp32;			/* promote only */
                 AcpiTbInitGenericAddress (Address64,
                     ACPI_ADR_SPACE_SYSTEM_IO, Length,
-                    (UINT64) Address32, Name, Flags);
+                    Tmp64, Name, Flags);
             }
         }
 
@@ -780,10 +788,14 @@ AcpiTbSetupFadtRegisters (
 
         if (Source64->Address)
         {
+	    UINT64 Tmp64, Addr64;
+
+	    ACPI_MOVE_64_TO_64(&Tmp64, &Source64->Address);
+	    Tmp64 += (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth);
+	    ACPI_MOVE_64_TO_64(&Addr64, &Tmp64);
             AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target,
                 Source64->SpaceId, Pm1RegisterByteWidth,
-                Source64->Address +
-                    (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth),
+                Addr64,
                 "PmRegisters", 0);
         }
     }
Index: acpica-unix2-20170119/source/components/tables/tbfind.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbfind.c
+++ acpica-unix2-20170119/source/components/tables/tbfind.c
@@ -108,8 +108,11 @@ AcpiTbFindTable (
     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
     for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
     {
+        UINT32 Tmp32;
+
+        ACPI_MOVE_32_TO_32(&Tmp32, &Header.Signature);
         if (memcmp (&(AcpiGbl_RootTableList.Tables[i].Signature),
-            Header.Signature, ACPI_NAME_SIZE))
+            &Tmp32, ACPI_NAME_SIZE))
         {
             /* Not the requested table */
 
Index: acpica-unix2-20170119/source/components/tables/tbprint.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbprint.c
+++ acpica-unix2-20170119/source/components/tables/tbprint.c
@@ -143,15 +143,18 @@ AcpiTbPrintTableHeader (
     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 @@ AcpiTbPrintTableHeader (
 
         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));
     }
 }
 
Index: acpica-unix2-20170119/source/components/tables/tbutils.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbutils.c
+++ acpica-unix2-20170119/source/components/tables/tbutils.c
@@ -238,7 +238,7 @@ AcpiTbGetRootTableEntry (
          * 64-bit platform, XSDT: Move (unaligned) 64-bit to local,
          *  return 64-bit
          */
-        ACPI_MOVE_64_TO_64 (&Address64, TableEntry);
+	Address64 = (UINT64) TableEntry;
 
 #if ACPI_MACHINE_WIDTH == 32
         if (Address64 > ACPI_UINT32_MAX)
@@ -251,7 +251,8 @@ AcpiTbGetRootTableEntry (
                 ACPI_FORMAT_UINT64 (Address64)));
         }
 #endif
-        return ((ACPI_PHYSICAL_ADDRESS) (Address64));
+        return ((ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST_PTR (
+            UINT64, Address64)));
     }
 }
 
@@ -287,6 +288,7 @@ AcpiTbParseRootTable (
     UINT8                   *TableEntry;
     ACPI_STATUS             Status;
     UINT32                  TableIndex;
+    UINT32                  Tmp32;
 
 
     ACPI_FUNCTION_TRACE (TbParseRootTable);
@@ -345,7 +347,7 @@ AcpiTbParseRootTable (
      * Validate length of the table, and map entire table.
      * Minimum length table must contain at least one entry.
      */
-    Length = Table->Length;
+    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
     AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER));
 
     if (Length < (sizeof (ACPI_TABLE_HEADER) + TableEntrySize))
@@ -372,7 +374,7 @@ AcpiTbParseRootTable (
 
     /* Get the number of entries and pointer to first entry */
 
-    TableCount = (UINT32) ((Table->Length - sizeof (ACPI_TABLE_HEADER)) /
+    TableCount = (UINT32) ((Length - sizeof (ACPI_TABLE_HEADER)) /
         TableEntrySize);
     TableEntry = ACPI_ADD_PTR (UINT8, Table, sizeof (ACPI_TABLE_HEADER));
 
@@ -394,10 +396,10 @@ AcpiTbParseRootTable (
         Status = AcpiTbInstallStandardTable (Address,
             ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE, &TableIndex);
 
+	ACPI_MOVE_32_TO_32(&Tmp32,
+			   &AcpiGbl_RootTableList.Tables[TableIndex].Signature);
         if (ACPI_SUCCESS (Status) &&
-            ACPI_COMPARE_NAME (
-                &AcpiGbl_RootTableList.Tables[TableIndex].Signature,
-                ACPI_SIG_FADT))
+            ACPI_COMPARE_NAME (&Tmp32, ACPI_SIG_FADT))
         {
             AcpiGbl_FadtIndex = TableIndex;
             AcpiTbParseFadt ();
Index: acpica-unix2-20170119/source/components/tables/tbxface.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbxface.c
+++ acpica-unix2-20170119/source/components/tables/tbxface.c
@@ -263,8 +263,11 @@ AcpiGetTableHeader (
 
     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
     {
+	UINT32 Tmp32;
+
+	ACPI_MOVE_32_TO_32(&Tmp32, (UINT32 *)Signature);
         if (!ACPI_COMPARE_NAME (
-                &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
+                &(AcpiGbl_RootTableList.Tables[i].Signature), &Tmp32))
         {
             continue;
         }
Index: acpica-unix2-20170119/source/components/tables/tbxfload.c
===================================================================
--- acpica-unix2-20170119.orig/source/components/tables/tbxfload.c
+++ acpica-unix2-20170119/source/components/tables/tbxfload.c
@@ -156,6 +156,7 @@ AcpiTbLoadNamespace (
     ACPI_TABLE_DESC         *Table;
     UINT32                  TablesLoaded = 0;
     UINT32                  TablesFailed = 0;
+    UINT32		    Tmp32;
 
 
     ACPI_FUNCTION_TRACE (TbLoadNamespace);
@@ -169,8 +170,9 @@ AcpiTbLoadNamespace (
      */
     Table = &AcpiGbl_RootTableList.Tables[AcpiGbl_DsdtIndex];
 
+    ACPI_MOVE_32_TO_32(&Tmp32, &Table->Signature.Ascii);
     if (!AcpiGbl_RootTableList.CurrentTableCount ||
-        !ACPI_COMPARE_NAME (Table->Signature.Ascii, ACPI_SIG_DSDT) ||
+        !ACPI_COMPARE_NAME (&Tmp32, ACPI_SIG_DSDT) ||
          ACPI_FAILURE (AcpiTbValidateTable (Table)))
     {
         Status = AE_NO_ACPI_TABLES;
Index: acpica-unix2-20170119/source/include/acmacros.h
===================================================================
--- acpica-unix2-20170119.orig/source/include/acmacros.h
+++ acpica-unix2-20170119/source/include/acmacros.h
@@ -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 */
 
Index: acpica-unix2-20170119/source/include/platform/aclinux.h
===================================================================
--- acpica-unix2-20170119.orig/source/include/platform/aclinux.h
+++ acpica-unix2-20170119/source/include/platform/aclinux.h
@@ -219,6 +219,10 @@
 #define __cdecl
 #endif
 
+#if defined(__PPC64__) || defined(__s390x__)
+#define ACPI_BIG_ENDIAN
+#endif
+
 #endif /* __KERNEL__ */
 
 #endif /* __ACLINUX_H__ */
Index: acpica-unix2-20170119/source/tools/acpiexec/aetables.c
===================================================================
--- acpica-unix2-20170119.orig/source/tools/acpiexec/aetables.c
+++ acpica-unix2-20170119/source/tools/acpiexec/aetables.c
@@ -146,21 +146,25 @@ AeInitializeTableHeader (
     char                    *Signature,
     UINT32                  Length)
 {
+    UINT16		    Tmp16;
+    UINT32		    Tmp32;
 
     ACPI_MOVE_NAME (Header->Signature, Signature);
-    Header->Length = Length;
+    ACPI_MOVE_32_TO_32(&Header->Length, &Length);
 
-    Header->OemRevision = 0x1001;
+    Tmp16 = 0x1001;
+    ACPI_MOVE_16_TO_16(&Header->OemRevision, &Tmp16);
     strncpy (Header->OemId, "Intel", ACPI_OEM_ID_SIZE);
     strncpy (Header->OemTableId, "AcpiExec", ACPI_OEM_TABLE_ID_SIZE);
     strncpy (Header->AslCompilerId, "INTL", ACPI_NAME_SIZE);
-    Header->AslCompilerRevision = ACPI_CA_VERSION;
+    Tmp32 = ACPI_CA_VERSION;
+    ACPI_MOVE_32_TO_32(&Header->AslCompilerRevision, &Tmp32);
 
     /* Set the checksum, must set to zero first */
 
     Header->Checksum = 0;
     Header->Checksum = (UINT8) -AcpiTbChecksum (
-        (void *) Header, Header->Length);
+        (void *) Header, Length);
 }
 
 
@@ -188,6 +192,7 @@ AeBuildLocalTables (
     ACPI_NEW_TABLE_DESC     *NextTable;
     UINT32                  NextIndex;
     ACPI_TABLE_FADT         *ExternalFadt = NULL;
+    UINT32		    Tmp32;
 
 
     /*
@@ -374,6 +379,8 @@ AeBuildLocalTables (
     }
     else
     {
+        UINT64		    Tmp64;
+
         /*
          * Build a local FADT so we can test the hardware/event init
          */
@@ -385,34 +392,44 @@ AeBuildLocalTables (
         LocalFADT.Facs = 0;
 
         LocalFADT.XDsdt = DsdtAddress;
-        LocalFADT.XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
+        Tmp64 = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
+        ACPI_MOVE_64_TO_64(&LocalFADT.XFacs, &Tmp64);
 
         /* Miscellaneous FADT fields */
 
         LocalFADT.Gpe0BlockLength = 0x08;
-        LocalFADT.Gpe0Block = 0x00001234;
+        Tmp32 = 0x00001234;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Gpe0Block, &Tmp32);
 
         LocalFADT.Gpe1BlockLength = 0x80;
-        LocalFADT.Gpe1Block = 0x00005678;
+        Tmp32 = 0x00005678;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Gpe1Block, &Tmp32);
         LocalFADT.Gpe1Base = 100;
 
         LocalFADT.Pm1EventLength = 4;
-        LocalFADT.Pm1aEventBlock = 0x00001aaa;
-        LocalFADT.Pm1bEventBlock = 0x00001bbb;
+        Tmp32 = 0x00001aaa;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1aEventBlock, &Tmp32);
+        Tmp32 = 0x00001bbb;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1bEventBlock, &Tmp32);
 
         LocalFADT.Pm1ControlLength = 2;
-        LocalFADT.Pm1aControlBlock = 0xB0;
+        Tmp32 = 0xB0;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1aControlBlock, &Tmp32);
 
         LocalFADT.PmTimerLength = 4;
-        LocalFADT.PmTimerBlock = 0xA0;
+        Tmp32 = 0xA0;
+        ACPI_MOVE_32_TO_32(&LocalFADT.PmTimerBlock, &Tmp32);
 
-        LocalFADT.Pm2ControlBlock = 0xC0;
+        Tmp32 = 0xC0;
+        ACPI_MOVE_32_TO_32(&LocalFADT.Pm2ControlBlock, &Tmp32);
         LocalFADT.Pm2ControlLength = 1;
 
         /* Setup one example X-64 GAS field */
 
         LocalFADT.XPm1bEventBlock.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
-        LocalFADT.XPm1bEventBlock.Address = LocalFADT.Pm1bEventBlock;
+	ACPI_MOVE_32_TO_32(&Tmp32, &LocalFADT.Pm1bEventBlock);
+	Tmp64 = (UINT64)Tmp32;
+        ACPI_MOVE_64_TO_64(&LocalFADT.XPm1bEventBlock.Address, &Tmp64);
         LocalFADT.XPm1bEventBlock.BitWidth = (UINT8)
             ACPI_MUL_8 (LocalFADT.Pm1EventLength);
     }
@@ -425,13 +442,17 @@ AeBuildLocalTables (
     memset (&LocalFACS, 0, sizeof (ACPI_TABLE_FACS));
     ACPI_MOVE_NAME (LocalFACS.Signature, ACPI_SIG_FACS);
 
-    LocalFACS.Length = sizeof (ACPI_TABLE_FACS);
-    LocalFACS.GlobalLock = 0x11AA0011;
+    Tmp32 = sizeof (ACPI_TABLE_FACS);
+    ACPI_MOVE_32_TO_32(&LocalFACS.Length, &Tmp32);
+    Tmp32 = 0x11AA0011;
+    ACPI_MOVE_32_TO_32(&LocalFACS.GlobalLock, &Tmp32);
 
     /* Build the optional local tables */
 
     if (AcpiGbl_LoadTestTables)
     {
+	UINT32 Tmp32;
+
         /*
          * Build a fake table [TEST] so that we make sure that the
          * ACPICA core ignores it
@@ -440,11 +461,12 @@ AeBuildLocalTables (
         ACPI_MOVE_NAME (LocalTEST.Signature, "TEST");
 
         LocalTEST.Revision = 1;
-        LocalTEST.Length = sizeof (ACPI_TABLE_HEADER);
+        Tmp32 = sizeof (ACPI_TABLE_HEADER);
+        ACPI_MOVE_32_TO_32(&LocalTEST.Length, &Tmp32);
 
         LocalTEST.Checksum = 0;
         LocalTEST.Checksum = (UINT8) -AcpiTbChecksum (
-            (void *) &LocalTEST, LocalTEST.Length);
+            (void *) &LocalTEST, Tmp32);
 
         /*
          * Build a fake table with a bad signature [BAD!] so that we make
@@ -454,11 +476,12 @@ AeBuildLocalTables (
         ACPI_MOVE_NAME (LocalBADTABLE.Signature, "BAD!");
 
         LocalBADTABLE.Revision = 1;
-        LocalBADTABLE.Length = sizeof (ACPI_TABLE_HEADER);
+        Tmp32 = sizeof (ACPI_TABLE_HEADER);
+        ACPI_MOVE_32_TO_32(&LocalBADTABLE.Length, &Tmp32);
 
         LocalBADTABLE.Checksum = 0;
         LocalBADTABLE.Checksum = (UINT8) -AcpiTbChecksum (
-            (void *) &LocalBADTABLE, LocalBADTABLE.Length);
+            (void *) &LocalBADTABLE, Tmp32);
     }
 
     return (AE_OK);