update-big-endian.patch

   1 Index: acpica-unix2-20170303/source/common/acfileio.c
   2 ===================================================================
   3 --- acpica-unix2-20170303.orig/source/common/acfileio.c
   4 +++ acpica-unix2-20170303/source/common/acfileio.c
   5 @@ -250,6 +250,7 @@ AcGetOneTableFromFile (
   6      ACPI_TABLE_HEADER       *Table;
   7      INT32                   Count;
   8      long                    TableOffset;
   9 +    UINT32                 TableLen;
  10
  11
  12      *ReturnTable = NULL;
  13 @@ -289,7 +290,8 @@ AcGetOneTableFromFile (
  14
  15      /* Allocate a buffer for the entire table */
  16
  17 -    Table = AcpiOsAllocate ((ACPI_SIZE) TableHeader.Length);
  18 +    ACPI_MOVE_32_TO_32(&TableLen, &TableHeader.Length);
  19 +    Table = AcpiOsAllocate ((ACPI_SIZE) TableLen);
  20      if (!Table)
  21      {
  22          return (AE_NO_MEMORY);
  23 @@ -299,8 +301,8 @@ AcGetOneTableFromFile (
  24
  25      fseek (File, TableOffset, SEEK_SET);
  26
  27 -    Count = fread (Table, 1, TableHeader.Length, File);
  28 -    if (Count != (INT32) TableHeader.Length)
  29 +    Count = fread (Table, 1, TableLen, File);
  30 +    if (Count != (INT32) TableLen)
  31      {
  32          Status = AE_ERROR;
  33          goto ErrorExit;
  34 @@ -308,7 +310,7 @@ AcGetOneTableFromFile (
  35
  36      /* Validate the checksum (just issue a warning) */
  37
  38 -    Status = AcpiTbVerifyChecksum (Table, TableHeader.Length);
  39 +    Status = AcpiTbVerifyChecksum (Table, TableLen);
  40      if (ACPI_FAILURE (Status))
  41      {
  42          Status = AcCheckTextModeCorruption (Table);
  43 @@ -400,6 +402,7 @@ AcValidateTableHeader (
  44      ACPI_SIZE               Actual;
  45      long                    OriginalOffset;
  46      UINT32                  FileSize;
  47 +    UINT32                  TableLength;
  48      UINT32                  i;
  49
  50
  51 @@ -431,11 +434,12 @@ AcValidateTableHeader (
  52      /* Validate table length against bytes remaining in the file */
  53
  54      FileSize = CmGetFileSize (File);
  55 -    if (TableHeader.Length > (UINT32) (FileSize - TableOffset))
  56 +    ACPI_MOVE_32_TO_32(&TableLength, &TableHeader.Length);
  57 +    if (TableLength > (UINT32) (FileSize - TableOffset))
  58      {
  59          fprintf (stderr, "Table [%4.4s] is too long for file - "
  60              "needs: 0x%.2X, remaining in file: 0x%.2X\n",
  61 -            TableHeader.Signature, TableHeader.Length,
  62 +            TableHeader.Signature, TableLength,
  63              (UINT32) (FileSize - TableOffset));
  64          return (AE_BAD_HEADER);
  65      }
  66 Index: acpica-unix2-20170303/source/common/dmtable.c
  67 ===================================================================
  68 --- acpica-unix2-20170303.orig/source/common/dmtable.c
  69 +++ acpica-unix2-20170303/source/common/dmtable.c
  70 @@ -499,7 +499,7 @@ AcpiDmDumpDataTable (
  71       */
  72      if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS))
  73      {
  74 -        Length = Table->Length;
  75 +        ACPI_MOVE_32_TO_32(&Length, &Table->Length);
  76          Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
  77          if (ACPI_FAILURE (Status))
  78          {
  79 @@ -513,13 +513,14 @@ AcpiDmDumpDataTable (
  80      else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_S3PT))
  81      {
  82          Length = AcpiDmDumpS3pt (Table);
  83 +        ACPI_MOVE_32_TO_32(&Length, &Table->Length);
  84      }
  85      else
  86      {
  87          /*
  88           * All other tables must use the common ACPI table header, dump it now
  89           */
  90 -        Length = Table->Length;
  91 +        ACPI_MOVE_32_TO_32(&Length, &Table->Length);
  92          Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader);
  93          if (ACPI_FAILURE (Status))
  94          {
  95 @@ -730,6 +731,7 @@ AcpiDmDumpTable (
  96      BOOLEAN                 LastOutputBlankLine = FALSE;
  97      ACPI_STATUS             Status;
  98      char                    RepairedName[8];
  99 +    UINT16                 Val16;
 100
 101
 102      if (!Info)
 103 @@ -1097,8 +1099,9 @@ AcpiDmDumpTable (
 104              /* Checksum, display and validate */
 105
 106              AcpiOsPrintf ("%2.2X", *Target);
 107 -            Temp8 = AcpiDmGenerateChecksum (Table,
 108 -                ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length,
 109 +           ACPI_MOVE_32_TO_32(&Temp32,
 110 +                       &ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length);
 111 +            Temp8 = AcpiDmGenerateChecksum (Table, Temp32,
 112                  ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum);
 113
 114              if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum)
 115 @@ -1163,14 +1166,14 @@ AcpiDmDumpTable (
 116
 117              /* DMAR subtable types */
 118
 119 -            Temp16 = ACPI_GET16 (Target);
 120 +            Val16 = ACPI_GET16 (Target);
 121 +           ACPI_MOVE_16_TO_16(&Temp16, &Val16);
 122              if (Temp16 > ACPI_DMAR_TYPE_RESERVED)
 123              {
 124                  Temp16 = ACPI_DMAR_TYPE_RESERVED;
 125              }
 126
 127 -            AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
 128 -                AcpiDmDmarSubnames[Temp16]);
 129 +            AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmDmarSubnames[Temp16]);
 130              break;
 131
 132          case ACPI_DMT_DMAR_SCOPE:
 133 @@ -1261,14 +1264,14 @@ AcpiDmDumpTable (
 134
 135              /* HEST subtable types */
 136
 137 -            Temp16 = ACPI_GET16 (Target);
 138 +            Val16 = ACPI_GET16 (Target);
 139 +           ACPI_MOVE_16_TO_16(&Temp16, &Val16);
 140              if (Temp16 > ACPI_HEST_TYPE_RESERVED)
 141              {
 142                  Temp16 = ACPI_HEST_TYPE_RESERVED;
 143              }
 144
 145 -            AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
 146 -                AcpiDmHestSubnames[Temp16]);
 147 +            AcpiOsPrintf (UINT16_FORMAT, Temp16, AcpiDmHestSubnames[Temp16]);
 148              break;
 149
 150          case ACPI_DMT_HESTNTFY:
 151 @@ -1334,13 +1337,14 @@ AcpiDmDumpTable (
 152
 153              /* NFIT subtable types */
 154
 155 -            Temp16 = ACPI_GET16 (Target);
 156 +            Val16 = ACPI_GET16 (Target);
 157 +            ACPI_MOVE_16_TO_16(&Temp16, &Val16);
 158              if (Temp16 > ACPI_NFIT_TYPE_RESERVED)
 159              {
 160                  Temp16 = ACPI_NFIT_TYPE_RESERVED;
 161              }
 162
 163 -            AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
 164 +            AcpiOsPrintf (UINT16_FORMAT, Temp16,
 165                  AcpiDmNfitSubnames[Temp16]);
 166              break;
 167
 168 Index: acpica-unix2-20170303/source/common/dmtables.c
 169 ===================================================================
 170 --- acpica-unix2-20170303.orig/source/common/dmtables.c
 171 +++ acpica-unix2-20170303/source/common/dmtables.c
 172 @@ -142,7 +142,9 @@ AdCreateTableHeader (
 173      ACPI_TABLE_HEADER       *Table)
 174  {
 175      UINT8                   Checksum;
 176 -
 177 +    UINT32                 TableLen;
 178 +    UINT32                 OemRev;
 179 +    UINT32                 CompilerRev;
 180
 181      /* Reset globals for External statements */
 182
 183 @@ -154,9 +156,10 @@ AdCreateTableHeader (
 184       */
 185      AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE);
 186
 187 +    ACPI_MOVE_32_TO_32(&TableLen, &Table->Length);
 188      AcpiOsPrintf (" * Original Table Header:\n");
 189      AcpiOsPrintf (" *     Signature        \"%4.4s\"\n",    Table->Signature);
 190 -    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", Table->Length, Table->Length);
 191 +    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", TableLen, TableLen);
 192
 193      /* Print and validate the revision */
 194
 195 @@ -188,7 +191,7 @@ AdCreateTableHeader (
 196
 197      AcpiOsPrintf ("\n *     Checksum         0x%2.2X",        Table->Checksum);
 198
 199 -    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);
 200 +    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), TableLen);
 201      if (Checksum)
 202      {
 203          AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",
 204 @@ -198,9 +201,11 @@ AdCreateTableHeader (
 205      AcpiOsPrintf ("\n");
 206      AcpiOsPrintf (" *     OEM ID           \"%.6s\"\n",     Table->OemId);
 207      AcpiOsPrintf (" *     OEM Table ID     \"%.8s\"\n",     Table->OemTableId);
 208 -    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision);
 209 +    ACPI_MOVE_32_TO_32(&OemRev, &Table->OemRevision);
 210 +    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", OemRev, OemRev);
 211      AcpiOsPrintf (" *     Compiler ID      \"%.4s\"\n",     Table->AslCompilerId);
 212 -    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision);
 213 +    ACPI_MOVE_32_TO_32(&CompilerRev, &Table->AslCompilerRevision);
 214 +    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", CompilerRev, CompilerRev);
 215      AcpiOsPrintf (" */\n");
 216
 217      /*
 218 @@ -221,7 +226,7 @@ AdCreateTableHeader (
 219      AcpiOsPrintf (
 220          "DefinitionBlock (\"\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n",
 221          Table->Signature, Table->Revision,
 222 -        Table->OemId, Table->OemTableId, Table->OemRevision);
 223 +        Table->OemId, Table->OemTableId, OemRev);
 224  }
 225
 226
 227 @@ -396,7 +401,8 @@ AdParseTable (
 228
 229      fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature);
 230
 231 -    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
 232 +    ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length);
 233 +    AmlLength -= sizeof (ACPI_TABLE_HEADER);
 234      AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
 235      ASL_CV_INIT_FILETREE(Table, AmlStart, AmlLength);
 236
 237 Index: acpica-unix2-20170303/source/common/dmtbdump.c
 238 ===================================================================
 239 --- acpica-unix2-20170303.orig/source/common/dmtbdump.c
 240 +++ acpica-unix2-20170303/source/common/dmtbdump.c
 241 @@ -277,6 +277,8 @@ AcpiDmDumpRsdt (
 242      UINT32                  Entries;
 243      UINT32                  Offset;
 244      UINT32                  i;
 245 +    UINT32                 Length;
 246 +    UINT32                 Address;
 247
 248
 249      /* Point to start of table pointer array */
 250 @@ -286,12 +288,14 @@ AcpiDmDumpRsdt (
 251
 252      /* RSDT uses 32-bit pointers */
 253
 254 -    Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
 255 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 256 +    Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
 257
 258      for (i = 0; i < Entries; i++)
 259      {
 260          AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
 261 -        AcpiOsPrintf ("%8.8X\n", Array[i]);
 262 +       ACPI_MOVE_32_TO_32(&Address, &Array[i]);
 263 +        AcpiOsPrintf ("%8.8X\n", Address);
 264          Offset += sizeof (UINT32);
 265      }
 266  }
 267 @@ -317,6 +321,8 @@ AcpiDmDumpXsdt (
 268      UINT32                  Entries;
 269      UINT32                  Offset;
 270      UINT32                  i;
 271 +    UINT32                  Length;
 272 +    UINT64                 Address;
 273
 274
 275      /* Point to start of table pointer array */
 276 @@ -326,12 +332,14 @@ AcpiDmDumpXsdt (
 277
 278      /* XSDT uses 64-bit pointers */
 279
 280 -    Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
 281 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 282 +    Entries = (Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
 283
 284      for (i = 0; i < Entries; i++)
 285      {
 286          AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
 287 -        AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
 288 +       ACPI_MOVE_64_TO_64(&Address, &Array[i]);
 289 +        AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Address));
 290          Offset += sizeof (UINT64);
 291      }
 292  }
 293 @@ -524,17 +532,21 @@ AcpiDmDumpAsf (
 294      UINT32                  DataOffset = 0;
 295      UINT32                  i;
 296      UINT8                   Type;
 297 +    UINT32                 Len;
 298 +    UINT16                 SubLen;
 299
 300
 301      /* No main table, only subtables */
 302
 303 +    ACPI_MOVE_32_TO_32(&Len, &Table->Length);
 304      SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
 305 -    while (Offset < Table->Length)
 306 +    while (Offset < Len)
 307      {
 308          /* Common subtable header */
 309
 310 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 311 -            SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
 312 +       ACPI_MOVE_16_TO_16(&SubLen, &SubTable->Header.Length);
 313 +        Status = AcpiDmDumpTable (Len, Offset, SubTable,
 314 +            SubLen, AcpiDmTableInfoAsfHdr);
 315          if (ACPI_FAILURE (Status))
 316          {
 317              return;
 318 @@ -591,8 +603,7 @@ AcpiDmDumpAsf (
 319              return;
 320          }
 321
 322 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 323 -            SubTable->Header.Length, InfoTable);
 324 +        Status = AcpiDmDumpTable (Len, Offset, SubTable, SubLen, InfoTable);
 325          if (ACPI_FAILURE (Status))
 326          {
 327              return;
 328 @@ -608,7 +619,7 @@ AcpiDmDumpAsf (
 329              for (i = 0; i < DataCount; i++)
 330              {
 331                  AcpiOsPrintf ("\n");
 332 -                Status = AcpiDmDumpTable (Table->Length, DataOffset,
 333 +                Status = AcpiDmDumpTable (Len, DataOffset,
 334                      DataTable, DataLength, DataInfoTable);
 335                  if (ACPI_FAILURE (Status))
 336                  {
 337 @@ -654,15 +665,14 @@ AcpiDmDumpAsf (
 338
 339          /* Point to next subtable */
 340
 341 -        if (!SubTable->Header.Length)
 342 +        if (!SubLen)
 343          {
 344              AcpiOsPrintf ("Invalid zero subtable header length\n");
 345              return;
 346          }
 347
 348 -        Offset += SubTable->Header.Length;
 349 -        SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable,
 350 -            SubTable->Header.Length);
 351 +        Offset += SubLen;
 352 +        SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubLen);
 353      }
 354  }
 355
 356 @@ -686,12 +696,13 @@ AcpiDmDumpCpep (
 357  {
 358      ACPI_STATUS             Status;
 359      ACPI_CPEP_POLLING       *SubTable;
 360 -    UINT32                  Length = Table->Length;
 361 +    UINT32                  Length;
 362      UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
 363
 364
 365      /* Main table */
 366
 367 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 368      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
 369      if (ACPI_FAILURE (Status))
 370      {
 371 @@ -701,7 +712,7 @@ AcpiDmDumpCpep (
 372      /* Subtables */
 373
 374      SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
 375 -    while (Offset < Table->Length)
 376 +    while (Offset < Length)
 377      {
 378          AcpiOsPrintf ("\n");
 379          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 380 @@ -741,7 +752,10 @@ AcpiDmDumpCsrt (
 381      ACPI_CSRT_GROUP         *SubTable;
 382      ACPI_CSRT_SHARED_INFO   *SharedInfoTable;
 383      ACPI_CSRT_DESCRIPTOR    *SubSubTable;
 384 -    UINT32                  Length = Table->Length;
 385 +    UINT32                  Length;
 386 +    UINT32                  SubLength;
 387 +    UINT32                  SubSubLength;
 388 +    UINT32                  SharedInfoLength;
 389      UINT32                  Offset = sizeof (ACPI_TABLE_CSRT);
 390      UINT32                  SubOffset;
 391      UINT32                  SubSubOffset;
 392 @@ -752,14 +766,16 @@ AcpiDmDumpCsrt (
 393
 394      /* Subtables (Resource Groups) */
 395
 396 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 397      SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
 398 -    while (Offset < Table->Length)
 399 +    while (Offset < Length)
 400      {
 401          /* Resource group subtable */
 402
 403          AcpiOsPrintf ("\n");
 404 +        ACPI_MOVE_32_TO_32(&SubLength, &SubTable->Length);
 405          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 406 -            SubTable->Length, AcpiDmTableInfoCsrt0);
 407 +            SubLength, AcpiDmTableInfoCsrt0);
 408          if (ACPI_FAILURE (Status))
 409          {
 410              return;
 411 @@ -779,19 +795,20 @@ AcpiDmDumpCsrt (
 412              return;
 413          }
 414
 415 -        SubOffset += SubTable->SharedInfoLength;
 416 +       ACPI_MOVE_32_TO_32(&SharedInfoLength, &SubTable->SharedInfoLength);
 417 +        SubOffset += SharedInfoLength;
 418
 419          /* Sub-Subtables (Resource Descriptors) */
 420
 421          SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
 422              Offset + SubOffset);
 423
 424 -        while ((SubOffset < SubTable->Length) &&
 425 -              ((Offset + SubOffset) < Table->Length))
 426 +        while ((SubOffset < SubLength) && ((Offset + SubOffset) < Length))
 427          {
 428              AcpiOsPrintf ("\n");
 429 +           ACPI_MOVE_32_TO_32(&SubSubLength, &SubSubTable->Length);
 430              Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
 431 -                SubSubTable->Length, AcpiDmTableInfoCsrt2);
 432 +                SubSubLength, AcpiDmTableInfoCsrt2);
 433              if (ACPI_FAILURE (Status))
 434              {
 435                  return;
 436 @@ -801,7 +818,7 @@ AcpiDmDumpCsrt (
 437
 438              /* Resource-specific info buffer */
 439
 440 -            InfoLength = SubSubTable->Length - SubSubOffset;
 441 +            InfoLength = SubSubLength - SubSubOffset;
 442              if (InfoLength)
 443              {
 444                  Status = AcpiDmDumpTable (Length,
 445 @@ -816,16 +833,15 @@ AcpiDmDumpCsrt (
 446
 447              /* Point to next sub-subtable */
 448
 449 -            SubOffset += SubSubTable->Length;
 450 +            SubOffset += SubSubLength;
 451              SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
 452 -                SubSubTable->Length);
 453 +                SubSubLength);
 454          }
 455
 456          /* Point to next subtable */
 457
 458 -        Offset += SubTable->Length;
 459 -        SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
 460 -            SubTable->Length);
 461 +        Offset += SubLength;
 462 +        SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, SubLength);
 463      }
 464  }
 465
 466 @@ -849,16 +865,20 @@ AcpiDmDumpDbg2 (
 467  {
 468      ACPI_STATUS             Status;
 469      ACPI_DBG2_DEVICE        *SubTable;
 470 -    UINT32                  Length = Table->Length;
 471 +    UINT32                  Length;
 472 +    UINT16                  SubLength;
 473      UINT32                  Offset = sizeof (ACPI_TABLE_DBG2);
 474      UINT32                  i;
 475      UINT32                  ArrayOffset;
 476      UINT32                  AbsoluteOffset;
 477      UINT8                   *Array;
 478 +    UINT16                 Tmp16;
 479 +    UINT16                 AlsoTmp16;
 480
 481
 482      /* Main table */
 483
 484 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 485      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
 486      if (ACPI_FAILURE (Status))
 487      {
 488 @@ -868,11 +888,12 @@ AcpiDmDumpDbg2 (
 489      /* Subtables */
 490
 491      SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
 492 -    while (Offset < Table->Length)
 493 +    while (Offset < Length)
 494      {
 495          AcpiOsPrintf ("\n");
 496 +        ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
 497          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 498 -            SubTable->Length, AcpiDmTableInfoDbg2Device);
 499 +            SubLength, AcpiDmTableInfoDbg2Device);
 500          if (ACPI_FAILURE (Status))
 501          {
 502              return;
 503 @@ -882,13 +903,13 @@ AcpiDmDumpDbg2 (
 504
 505          for (i = 0; i < SubTable->RegisterCount; i++)
 506          {
 507 -            ArrayOffset = SubTable->BaseAddressOffset +
 508 -                (sizeof (ACPI_GENERIC_ADDRESS) * i);
 509 +           ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->BaseAddressOffset);
 510 +            ArrayOffset = Tmp16 + (sizeof (ACPI_GENERIC_ADDRESS) * i);
 511              AbsoluteOffset = Offset + ArrayOffset;
 512              Array = (UINT8 *) SubTable + ArrayOffset;
 513
 514              Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 515 -                SubTable->Length, AcpiDmTableInfoDbg2Addr);
 516 +                SubLength, AcpiDmTableInfoDbg2Addr);
 517              if (ACPI_FAILURE (Status))
 518              {
 519                  return;
 520 @@ -899,13 +920,13 @@ AcpiDmDumpDbg2 (
 521
 522          for (i = 0; i < SubTable->RegisterCount; i++)
 523          {
 524 -            ArrayOffset = SubTable->AddressSizeOffset +
 525 -                (sizeof (UINT32) * i);
 526 +           ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->AddressSizeOffset);
 527 +            ArrayOffset = Tmp16 + (sizeof (UINT32) * i);
 528              AbsoluteOffset = Offset + ArrayOffset;
 529              Array = (UINT8 *) SubTable + ArrayOffset;
 530
 531              Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 532 -                SubTable->Length, AcpiDmTableInfoDbg2Size);
 533 +                SubLength, AcpiDmTableInfoDbg2Size);
 534              if (ACPI_FAILURE (Status))
 535              {
 536                  return;
 537 @@ -915,12 +936,13 @@ AcpiDmDumpDbg2 (
 538          /* Dump the Namestring (required) */
 539
 540          AcpiOsPrintf ("\n");
 541 -        ArrayOffset = SubTable->NamepathOffset;
 542 +       ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->NamepathOffset);
 543 +        ArrayOffset = Tmp16;
 544          AbsoluteOffset = Offset + ArrayOffset;
 545          Array = (UINT8 *) SubTable + ArrayOffset;
 546
 547          Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 548 -            SubTable->Length, AcpiDmTableInfoDbg2Name);
 549 +            SubLength, AcpiDmTableInfoDbg2Name);
 550          if (ACPI_FAILURE (Status))
 551          {
 552              return;
 553 @@ -930,9 +952,10 @@ AcpiDmDumpDbg2 (
 554
 555          if (SubTable->OemDataOffset)
 556          {
 557 -            Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset,
 558 -                Table, SubTable->OemDataLength,
 559 -                AcpiDmTableInfoDbg2OemData);
 560 +           ACPI_MOVE_16_TO_16(&Tmp16, &SubTable->OemDataOffset);
 561 +           ACPI_MOVE_16_TO_16(&AlsoTmp16, &SubTable->OemDataLength);
 562 +            Status = AcpiDmDumpTable (Length, Offset + Tmp16,
 563 +                Table, AlsoTmp16, AcpiDmTableInfoDbg2OemData);
 564              if (ACPI_FAILURE (Status))
 565              {
 566                  return;
 567 @@ -941,9 +964,9 @@ AcpiDmDumpDbg2 (
 568
 569          /* Point to next subtable */
 570
 571 -        Offset += SubTable->Length;
 572 +        Offset += SubLength;
 573          SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
 574 -            SubTable->Length);
 575 +            SubLength);
 576      }
 577  }
 578
 579 @@ -967,17 +990,20 @@ AcpiDmDumpDmar (
 580  {
 581      ACPI_STATUS             Status;
 582      ACPI_DMAR_HEADER        *SubTable;
 583 -    UINT32                  Length = Table->Length;
 584 +    UINT32                  Length;
 585 +    UINT16                  SubLength;
 586      UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
 587      ACPI_DMTABLE_INFO       *InfoTable;
 588      ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
 589      UINT32                  ScopeOffset;
 590      UINT8                   *PciPath;
 591      UINT32                  PathOffset;
 592 +    UINT16                 SubType;
 593
 594
 595      /* Main table */
 596
 597 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 598      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
 599      if (ACPI_FAILURE (Status))
 600      {
 601 @@ -987,13 +1013,14 @@ AcpiDmDumpDmar (
 602      /* Subtables */
 603
 604      SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
 605 -    while (Offset < Table->Length)
 606 +    while (Offset < Length)
 607      {
 608          /* Common subtable header */
 609
 610          AcpiOsPrintf ("\n");
 611 +       ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
 612          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 613 -            SubTable->Length, AcpiDmTableInfoDmarHdr);
 614 +            SubLength, AcpiDmTableInfoDmarHdr);
 615          if (ACPI_FAILURE (Status))
 616          {
 617              return;
 618 @@ -1001,7 +1028,8 @@ AcpiDmDumpDmar (
 619
 620          AcpiOsPrintf ("\n");
 621
 622 -        switch (SubTable->Type)
 623 +       ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type);
 624 +        switch (SubType)
 625          {
 626          case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 627
 628 @@ -1036,12 +1064,12 @@ AcpiDmDumpDmar (
 629          default:
 630
 631              AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
 632 -                SubTable->Type);
 633 +                SubType);
 634              return;
 635          }
 636
 637          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 638 -            SubTable->Length, InfoTable);
 639 +            SubLength, InfoTable);
 640          if (ACPI_FAILURE (Status))
 641          {
 642              return;
 643 @@ -1050,8 +1078,8 @@ AcpiDmDumpDmar (
 644          /*
 645           * Dump the optional device scope entries
 646           */
 647 -        if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
 648 -            (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE))
 649 +        if ((SubType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
 650 +            (SubType == ACPI_DMAR_TYPE_NAMESPACE))
 651          {
 652              /* These types do not support device scopes */
 653
 654 @@ -1059,7 +1087,7 @@ AcpiDmDumpDmar (
 655          }
 656
 657          ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
 658 -        while (ScopeOffset < SubTable->Length)
 659 +        while (ScopeOffset < SubLength)
 660          {
 661              AcpiOsPrintf ("\n");
 662              Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
 663 @@ -1100,9 +1128,8 @@ AcpiDmDumpDmar (
 664  NextSubtable:
 665          /* Point to next subtable */
 666
 667 -        Offset += SubTable->Length;
 668 -        SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable,
 669 -            SubTable->Length);
 670 +        Offset += SubLength;
 671 +        SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubLength);
 672      }
 673  }
 674
 675 @@ -1129,12 +1156,15 @@ AcpiDmDumpDrtm (
 676      ACPI_DRTM_RESOURCE_LIST *DrtmRl;
 677      ACPI_DRTM_DPS_ID        *DrtmDps;
 678      UINT32                  Count;
 679 +    UINT32                  ValidatedCount;
 680 +    UINT32                  ResourceCount;
 681 +    UINT32                 Length;
 682
 683
 684      /* Main table */
 685
 686 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
 687 -        AcpiDmTableInfoDrtm);
 688 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 689 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDrtm);
 690      if (ACPI_FAILURE (Status))
 691      {
 692          return;
 693 @@ -1148,7 +1178,7 @@ AcpiDmDumpDrtm (
 694
 695      DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
 696      AcpiOsPrintf ("\n");
 697 -    Status = AcpiDmDumpTable (Table->Length, Offset,
 698 +    Status = AcpiDmDumpTable (Length, Offset,
 699          DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
 700          AcpiDmTableInfoDrtm0);
 701      if (ACPI_FAILURE (Status))
 702 @@ -1161,10 +1191,11 @@ AcpiDmDumpDrtm (
 703      /* Dump Validated table addresses */
 704
 705      Count = 0;
 706 -    while ((Offset < Table->Length) &&
 707 -            (DrtmVtl->ValidatedTableCount > Count))
 708 +    ACPI_MOVE_32_TO_32(&ValidatedCount, &DrtmVtl->ValidatedTableCount);
 709 +    while ((Offset < Length) &&
 710 +            (ValidatedCount > Count))
 711      {
 712 -        Status = AcpiDmDumpTable (Table->Length, Offset,
 713 +        Status = AcpiDmDumpTable (Length, Offset,
 714              ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
 715              AcpiDmTableInfoDrtm0a);
 716          if (ACPI_FAILURE (Status))
 717 @@ -1180,7 +1211,7 @@ AcpiDmDumpDrtm (
 718
 719      DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
 720      AcpiOsPrintf ("\n");
 721 -    Status = AcpiDmDumpTable (Table->Length, Offset,
 722 +    Status = AcpiDmDumpTable (Length, Offset,
 723          DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
 724          AcpiDmTableInfoDrtm1);
 725      if (ACPI_FAILURE (Status))
 726 @@ -1193,10 +1224,11 @@ AcpiDmDumpDrtm (
 727      /* Dump the Resource List */
 728
 729      Count = 0;
 730 -    while ((Offset < Table->Length) &&
 731 -           (DrtmRl->ResourceCount > Count))
 732 +    ACPI_MOVE_32_TO_32(&ResourceCount, &DrtmRl->ResourceCount);
 733 +    while ((Offset < Length) &&
 734 +           (ResourceCount > Count))
 735      {
 736 -        Status = AcpiDmDumpTable (Table->Length, Offset,
 737 +        Status = AcpiDmDumpTable (Length, Offset,
 738              ACPI_ADD_PTR (void, Table, Offset),
 739              sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
 740          if (ACPI_FAILURE (Status))
 741 @@ -1212,7 +1244,7 @@ AcpiDmDumpDrtm (
 742
 743      DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
 744      AcpiOsPrintf ("\n");
 745 -    (void) AcpiDmDumpTable (Table->Length, Offset,
 746 +    (void) AcpiDmDumpTable (Length, Offset,
 747          DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
 748  }
 749
 750 @@ -1236,12 +1268,13 @@ AcpiDmDumpEinj (
 751  {
 752      ACPI_STATUS             Status;
 753      ACPI_WHEA_HEADER        *SubTable;
 754 -    UINT32                  Length = Table->Length;
 755 +    UINT32                  Length;
 756      UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
 757
 758
 759      /* Main table */
 760
 761 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 762      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
 763      if (ACPI_FAILURE (Status))
 764      {
 765 @@ -1251,7 +1284,7 @@ AcpiDmDumpEinj (
 766      /* Subtables */
 767
 768      SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 769 -    while (Offset < Table->Length)
 770 +    while (Offset < Length)
 771      {
 772          AcpiOsPrintf ("\n");
 773          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 774 @@ -1289,12 +1322,13 @@ AcpiDmDumpErst (
 775  {
 776      ACPI_STATUS             Status;
 777      ACPI_WHEA_HEADER        *SubTable;
 778 -    UINT32                  Length = Table->Length;
 779 +    UINT32                  Length;
 780      UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
 781
 782
 783      /* Main table */
 784
 785 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 786      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
 787      if (ACPI_FAILURE (Status))
 788      {
 789 @@ -1304,7 +1338,7 @@ AcpiDmDumpErst (
 790      /* Subtables */
 791
 792      SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 793 -    while (Offset < Table->Length)
 794 +    while (Offset < Length)
 795      {
 796          AcpiOsPrintf ("\n");
 797          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 798 @@ -1342,17 +1376,19 @@ AcpiDmDumpFpdt (
 799  {
 800      ACPI_STATUS             Status;
 801      ACPI_FPDT_HEADER        *SubTable;
 802 -    UINT32                  Length = Table->Length;
 803 +    UINT32                  Length;
 804      UINT32                  Offset = sizeof (ACPI_TABLE_FPDT);
 805      ACPI_DMTABLE_INFO       *InfoTable;
 806 +    UINT16                 Type;
 807
 808
 809      /* There is no main table (other than the standard ACPI header) */
 810
 811      /* Subtables */
 812
 813 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 814      SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
 815 -    while (Offset < Table->Length)
 816 +    while (Offset < Length)
 817      {
 818          /* Common subtable header */
 819
 820 @@ -1364,7 +1400,8 @@ AcpiDmDumpFpdt (
 821              return;
 822          }
 823
 824 -        switch (SubTable->Type)
 825 +       ACPI_MOVE_16_TO_16(&Type, &SubTable->Type);
 826 +        switch (Type)
 827          {
 828          case ACPI_FPDT_TYPE_BOOT:
 829
 830 @@ -1378,8 +1415,7 @@ AcpiDmDumpFpdt (
 831
 832          default:
 833
 834 -            AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
 835 -                SubTable->Type);
 836 +            AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", Type);
 837
 838              /* Attempt to continue */
 839
 840 @@ -1427,16 +1463,19 @@ AcpiDmDumpGtdt (
 841  {
 842      ACPI_STATUS             Status;
 843      ACPI_GTDT_HEADER        *SubTable;
 844 -    UINT32                  Length = Table->Length;
 845 +    UINT32                  Length;
 846 +    UINT16                  SubLength;
 847      UINT32                  Offset = sizeof (ACPI_TABLE_GTDT);
 848      ACPI_DMTABLE_INFO       *InfoTable;
 849      UINT32                  SubTableLength;
 850      UINT32                  GtCount;
 851 +    UINT32                  Tmp32;
 852      ACPI_GTDT_TIMER_ENTRY   *GtxTable;
 853
 854
 855      /* Main table */
 856
 857 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 858      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
 859      if (ACPI_FAILURE (Status))
 860      {
 861 @@ -1446,7 +1485,7 @@ AcpiDmDumpGtdt (
 862      /* Subtables */
 863
 864      SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
 865 -    while (Offset < Table->Length)
 866 +    while (Offset < Length)
 867      {
 868          /* Common subtable header */
 869
 870 @@ -1464,8 +1503,9 @@ AcpiDmDumpGtdt (
 871          case ACPI_GTDT_TYPE_TIMER_BLOCK:
 872
 873              SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
 874 -            GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
 875 +            Tmp32 = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
 876                  SubTable))->TimerCount;
 877 +           ACPI_MOVE_32_TO_32(&GtCount, &Tmp32);
 878
 879              InfoTable = AcpiDmTableInfoGtdt0;
 880              break;
 881 @@ -1486,8 +1526,9 @@ AcpiDmDumpGtdt (
 882              return;
 883          }
 884
 885 +       ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
 886          Status = AcpiDmDumpTable (Length, Offset, SubTable,
 887 -            SubTable->Length, InfoTable);
 888 +            SubLength, InfoTable);
 889          if (ACPI_FAILURE (Status))
 890          {
 891              return;
 892 @@ -1546,16 +1587,18 @@ AcpiDmDumpHest (
 893  {
 894      ACPI_STATUS             Status;
 895      ACPI_HEST_HEADER        *SubTable;
 896 -    UINT32                  Length = Table->Length;
 897 +    UINT32                  Length;
 898      UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
 899      ACPI_DMTABLE_INFO       *InfoTable;
 900      UINT32                  SubTableLength;
 901      UINT32                  BankCount;
 902      ACPI_HEST_IA_ERROR_BANK *BankTable;
 903 +    UINT16                 SubType;
 904
 905
 906      /* Main table */
 907
 908 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
 909      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
 910      if (ACPI_FAILURE (Status))
 911      {
 912 @@ -1565,10 +1608,11 @@ AcpiDmDumpHest (
 913      /* Subtables */
 914
 915      SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
 916 -    while (Offset < Table->Length)
 917 +    while (Offset < Length)
 918      {
 919          BankCount = 0;
 920 -        switch (SubTable->Type)
 921 +       ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type);
 922 +        switch (SubType)
 923          {
 924          case ACPI_HEST_TYPE_IA32_CHECK:
 925
 926 @@ -1697,15 +1741,21 @@ AcpiDmDumpIort (
 927      ACPI_IORT_SMMU          *IortSmmu = NULL;
 928      UINT32                  Offset;
 929      UINT32                  NodeOffset;
 930 +    UINT16                 NodeLength;
 931      UINT32                  Length;
 932      ACPI_DMTABLE_INFO       *InfoTable;
 933      char                    *String;
 934      UINT32                  i;
 935 -
 936 +    UINT32                 TableLen;
 937 +    UINT32                 ItsCount;
 938 +    UINT32                 MappingCount;
 939 +    UINT32                 CtxIntCount;
 940 +    UINT32                 PmuIntCount;
 941
 942      /* Main table */
 943
 944 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
 945 +    ACPI_MOVE_32_TO_32(&TableLen, &Table->Length);
 946 +    Status = AcpiDmDumpTable (TableLen, 0, Table, 0, AcpiDmTableInfoIort);
 947      if (ACPI_FAILURE (Status))
 948      {
 949          return;
 950 @@ -1716,18 +1766,19 @@ AcpiDmDumpIort (
 951
 952      /* Dump the OptionalPadding (optional) */
 953
 954 -    if (Iort->NodeOffset > Offset)
 955 +    ACPI_MOVE_32_TO_32(&NodeOffset, &Iort->NodeOffset);
 956 +    if (NodeOffset > Offset)
 957      {
 958 -        Status = AcpiDmDumpTable (Table->Length, Offset, Table,
 959 -            Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
 960 +        Status = AcpiDmDumpTable (TableLen, Offset, Table,
 961 +            NodeOffset - Offset, AcpiDmTableInfoIortPad);
 962          if (ACPI_FAILURE (Status))
 963          {
 964              return;
 965          }
 966      }
 967
 968 -    Offset = Iort->NodeOffset;
 969 -    while (Offset < Table->Length)
 970 +    ACPI_MOVE_32_TO_32(&Offset, &Iort->NodeOffset);
 971 +    while (Offset < TableLen)
 972      {
 973          /* Common subtable header */
 974
 975 @@ -1763,7 +1814,8 @@ AcpiDmDumpIort (
 976          case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
 977
 978              InfoTable = AcpiDmTableInfoIort2;
 979 -            Length = IortNode->Length - NodeOffset;
 980 +           ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
 981 +            Length = NodeLength - NodeOffset;
 982              break;
 983
 984          case ACPI_IORT_NODE_SMMU:
 985 @@ -1776,7 +1828,8 @@ AcpiDmDumpIort (
 986          case ACPI_IORT_NODE_SMMU_V3:
 987
 988              InfoTable = AcpiDmTableInfoIort4;
 989 -            Length = IortNode->Length - NodeOffset;
 990 +           ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
 991 +            Length = NodeLength - NodeOffset;
 992              break;
 993
 994          default:
 995 @@ -1786,7 +1839,8 @@ AcpiDmDumpIort (
 996
 997              /* Attempt to continue */
 998
 999 -            if (!IortNode->Length)
1000 +           ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
1001 +            if (!NodeLength)
1002              {
1003                  AcpiOsPrintf ("Invalid zero length IORT node\n");
1004                  return;
1005 @@ -1797,7 +1851,7 @@ AcpiDmDumpIort (
1006          /* Dump the node subtable header */
1007
1008          AcpiOsPrintf ("\n");
1009 -        Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1010 +        Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1011              ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1012              Length, InfoTable);
1013          if (ACPI_FAILURE (Status))
1014 @@ -1817,9 +1871,10 @@ AcpiDmDumpIort (
1015
1016              if (IortItsGroup)
1017              {
1018 -                for (i = 0; i < IortItsGroup->ItsCount; i++)
1019 +               ACPI_MOVE_32_TO_32(&ItsCount, &IortItsGroup->ItsCount);
1020 +                for (i = 0; i < ItsCount; i++)
1021                  {
1022 -                    Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1023 +                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1024                          ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1025                          4, AcpiDmTableInfoIort0a);
1026                      NodeOffset += 4;
1027 @@ -1831,11 +1886,11 @@ AcpiDmDumpIort (
1028
1029              /* Dump the Padding (optional) */
1030
1031 -            if (IortNode->Length > NodeOffset)
1032 +           ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
1033 +            if (NodeLength > NodeOffset)
1034              {
1035 -                Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1036 -                    Table, IortNode->Length - NodeOffset,
1037 -                    AcpiDmTableInfoIort1a);
1038 +                Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1039 +                    Table, NodeLength - NodeOffset, AcpiDmTableInfoIort1a);
1040                  if (ACPI_FAILURE (Status))
1041                  {
1042                      return;
1043 @@ -1852,8 +1907,8 @@ AcpiDmDumpIort (
1044              if (IortSmmu)
1045              {
1046                  Length = 2 * sizeof (UINT64);
1047 -                NodeOffset = IortSmmu->GlobalInterruptOffset;
1048 -                Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1049 +                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->GlobalInterruptOffset);
1050 +                Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1051                      ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1052                      Length, AcpiDmTableInfoIort3a);
1053                  if (ACPI_FAILURE (Status))
1054 @@ -1861,10 +1916,11 @@ AcpiDmDumpIort (
1055                      return;
1056                  }
1057
1058 -                NodeOffset = IortSmmu->ContextInterruptOffset;
1059 -                for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
1060 +                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->ContextInterruptOffset);
1061 +                ACPI_MOVE_32_TO_32(&CtxIntCount, &IortSmmu->ContextInterruptCount);
1062 +                for (i = 0; i < CtxIntCount; i++)
1063                  {
1064 -                    Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1065 +                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1066                          ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1067                          8, AcpiDmTableInfoIort3b);
1068                      if (ACPI_FAILURE (Status))
1069 @@ -1875,10 +1931,11 @@ AcpiDmDumpIort (
1070                      NodeOffset += 8;
1071                  }
1072
1073 -                NodeOffset = IortSmmu->PmuInterruptOffset;
1074 -                for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
1075 +                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->PmuInterruptOffset);
1076 +                ACPI_MOVE_32_TO_32(&PmuIntCount, &IortSmmu->PmuInterruptCount);
1077 +                for (i = 0; i < PmuIntCount; i++)
1078                  {
1079 -                    Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1080 +                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1081                          ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1082                          8, AcpiDmTableInfoIort3c);
1083                      if (ACPI_FAILURE (Status))
1084 @@ -1898,12 +1955,13 @@ AcpiDmDumpIort (
1085
1086          /* Dump the ID mappings */
1087
1088 -        NodeOffset = IortNode->MappingOffset;
1089 -        for (i = 0; i < IortNode->MappingCount; i++)
1090 +        ACPI_MOVE_32_TO_32(&NodeOffset, &IortNode->MappingOffset);
1091 +        ACPI_MOVE_32_TO_32(&MappingCount, &IortNode->MappingCount);
1092 +        for (i = 0; i < MappingCount; i++)
1093          {
1094              AcpiOsPrintf ("\n");
1095              Length = sizeof (ACPI_IORT_ID_MAPPING);
1096 -            Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1097 +            Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,
1098                  ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1099                  Length, AcpiDmTableInfoIortMap);
1100              if (ACPI_FAILURE (Status))
1101 @@ -1917,8 +1975,9 @@ AcpiDmDumpIort (
1102  NextSubTable:
1103          /* Point to next node subtable */
1104
1105 -        Offset += IortNode->Length;
1106 -        IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
1107 +       ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);
1108 +        Offset += NodeLength;
1109 +        IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeLength);
1110      }
1111  }
1112
1113 @@ -1949,11 +2008,14 @@ AcpiDmDumpIvrs (
1114      ACPI_IVRS_DE_HEADER     *DeviceEntry;
1115      ACPI_IVRS_HEADER        *SubTable;
1116      ACPI_DMTABLE_INFO       *InfoTable;
1117 +    UINT32                 Length;
1118 +    UINT16                 SubLength;
1119
1120
1121      /* Main table */
1122
1123 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
1124 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1125 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoIvrs);
1126      if (ACPI_FAILURE (Status))
1127      {
1128          return;
1129 @@ -1962,13 +2024,14 @@ AcpiDmDumpIvrs (
1130      /* Subtables */
1131
1132      SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
1133 -    while (Offset < Table->Length)
1134 +    while (Offset < Length)
1135      {
1136          /* Common subtable header */
1137
1138          AcpiOsPrintf ("\n");
1139 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1140 -            SubTable->Length, AcpiDmTableInfoIvrsHdr);
1141 +        ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
1142 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1143 +            SubLength, AcpiDmTableInfoIvrsHdr);
1144          if (ACPI_FAILURE (Status))
1145          {
1146              return;
1147 @@ -1995,7 +2058,7 @@ AcpiDmDumpIvrs (
1148
1149              /* Attempt to continue */
1150
1151 -            if (!SubTable->Length)
1152 +            if (!SubLength)
1153              {
1154                  AcpiOsPrintf ("Invalid zero length subtable\n");
1155                  return;
1156 @@ -2006,8 +2069,8 @@ AcpiDmDumpIvrs (
1157          /* Dump the subtable */
1158
1159          AcpiOsPrintf ("\n");
1160 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1161 -            SubTable->Length, InfoTable);
1162 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1163 +            SubLength, InfoTable);
1164          if (ACPI_FAILURE (Status))
1165          {
1166              return;
1167 @@ -2021,7 +2084,7 @@ AcpiDmDumpIvrs (
1168              DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
1169                  sizeof (ACPI_IVRS_HARDWARE));
1170
1171 -            while (EntryOffset < (Offset + SubTable->Length))
1172 +            while (EntryOffset < (Offset + SubLength))
1173              {
1174                  AcpiOsPrintf ("\n");
1175                  /*
1176 @@ -2083,7 +2146,7 @@ AcpiDmDumpIvrs (
1177
1178                  /* Dump the Device Entry */
1179
1180 -                Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1181 +                Status = AcpiDmDumpTable (Length, EntryOffset,
1182                      DeviceEntry, EntryLength, InfoTable);
1183                  if (ACPI_FAILURE (Status))
1184                  {
1185 @@ -2099,8 +2162,8 @@ AcpiDmDumpIvrs (
1186  NextSubTable:
1187          /* Point to next subtable */
1188
1189 -        Offset += SubTable->Length;
1190 -        SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1191 +        Offset += SubLength;
1192 +        SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubLength);
1193      }
1194  }
1195
1196 @@ -2126,7 +2189,7 @@ AcpiDmDumpLpit (
1197  {
1198      ACPI_STATUS             Status;
1199      ACPI_LPIT_HEADER        *SubTable;
1200 -    UINT32                  Length = Table->Length;
1201 +    UINT32                  Length;
1202      UINT32                  Offset = sizeof (ACPI_TABLE_LPIT);
1203      ACPI_DMTABLE_INFO       *InfoTable;
1204      UINT32                  SubTableLength;
1205 @@ -2134,8 +2197,9 @@ AcpiDmDumpLpit (
1206
1207      /* Subtables */
1208
1209 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1210      SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
1211 -    while (Offset < Table->Length)
1212 +    while (Offset < Length)
1213      {
1214          /* Common subtable header */
1215
1216 @@ -2199,13 +2263,14 @@ AcpiDmDumpMadt (
1217  {
1218      ACPI_STATUS             Status;
1219      ACPI_SUBTABLE_HEADER    *SubTable;
1220 -    UINT32                  Length = Table->Length;
1221 +    UINT32                  Length;
1222      UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
1223      ACPI_DMTABLE_INFO       *InfoTable;
1224
1225
1226      /* Main table */
1227
1228 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1229      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1230      if (ACPI_FAILURE (Status))
1231      {
1232 @@ -2215,7 +2280,7 @@ AcpiDmDumpMadt (
1233      /* Subtables */
1234
1235      SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1236 -    while (Offset < Table->Length)
1237 +    while (Offset < Length)
1238      {
1239          /* Common subtable header */
1240
1241 @@ -2361,11 +2426,13 @@ AcpiDmDumpMcfg (
1242      ACPI_STATUS             Status;
1243      UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
1244      ACPI_MCFG_ALLOCATION    *SubTable;
1245 +    UINT32                 Len;
1246
1247
1248      /* Main table */
1249
1250 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1251 +    ACPI_MOVE_32_TO_32(&Len, &Table->Length);
1252 +    Status = AcpiDmDumpTable (Len, 0, Table, 0, AcpiDmTableInfoMcfg);
1253      if (ACPI_FAILURE (Status))
1254      {
1255          return;
1256 @@ -2374,17 +2441,17 @@ AcpiDmDumpMcfg (
1257      /* Subtables */
1258
1259      SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1260 -    while (Offset < Table->Length)
1261 +    while (Offset < Len)
1262      {
1263 -        if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1264 +        if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Len)
1265          {
1266              AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1267 -                sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1268 +                sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Len));
1269              return;
1270          }
1271
1272          AcpiOsPrintf ("\n");
1273 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1274 +        Status = AcpiDmDumpTable (Len, Offset, SubTable,
1275              sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1276          if (ACPI_FAILURE (Status))
1277          {
1278 @@ -2418,6 +2485,7 @@ AcpiDmDumpMpst (
1279  {
1280      ACPI_STATUS             Status;
1281      UINT32                  Offset = sizeof (ACPI_TABLE_MPST);
1282 +    ACPI_TABLE_MPST        *Mpst;
1283      ACPI_MPST_POWER_NODE    *SubTable0;
1284      ACPI_MPST_POWER_STATE   *SubTable0A;
1285      ACPI_MPST_COMPONENT     *SubTable0B;
1286 @@ -2426,11 +2494,13 @@ AcpiDmDumpMpst (
1287      UINT16                  SubtableCount;
1288      UINT32                  PowerStateCount;
1289      UINT32                  ComponentCount;
1290 +    UINT32                 Length;
1291
1292
1293      /* Main table */
1294
1295 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1296 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1297 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMpst);
1298      if (ACPI_FAILURE (Status))
1299      {
1300          return;
1301 @@ -2438,13 +2508,14 @@ AcpiDmDumpMpst (
1302
1303      /* Subtable: Memory Power Node(s) */
1304
1305 -    SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1306 +    Mpst = ACPI_CAST_PTR (ACPI_TABLE_MPST, Table);
1307 +    ACPI_MOVE_16_TO_16(&SubtableCount, &Mpst->PowerNodeCount);
1308      SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1309
1310 -    while ((Offset < Table->Length) && SubtableCount)
1311 +    while ((Offset < Length) && SubtableCount)
1312      {
1313          AcpiOsPrintf ("\n");
1314 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
1315 +        Status = AcpiDmDumpTable (Length, Offset, SubTable0,
1316              sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1317          if (ACPI_FAILURE (Status))
1318          {
1319 @@ -2453,8 +2524,8 @@ AcpiDmDumpMpst (
1320
1321          /* Extract the sub-subtable counts */
1322
1323 -        PowerStateCount = SubTable0->NumPowerStates;
1324 -        ComponentCount = SubTable0->NumPhysicalComponents;
1325 +        ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates);
1326 +        ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents);
1327          Offset += sizeof (ACPI_MPST_POWER_NODE);
1328
1329          /* Sub-subtables - Memory Power State Structure(s) */
1330 @@ -2465,7 +2536,7 @@ AcpiDmDumpMpst (
1331          while (PowerStateCount)
1332          {
1333              AcpiOsPrintf ("\n");
1334 -            Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
1335 +            Status = AcpiDmDumpTable (Length, Offset, SubTable0A,
1336                  sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1337              if (ACPI_FAILURE (Status))
1338              {
1339 @@ -2475,7 +2546,7 @@ AcpiDmDumpMpst (
1340              SubTable0A++;
1341              PowerStateCount--;
1342              Offset += sizeof (ACPI_MPST_POWER_STATE);
1343 -       }
1344 +        }
1345
1346          /* Sub-subtables - Physical Component ID Structure(s) */
1347
1348 @@ -2488,7 +2559,7 @@ AcpiDmDumpMpst (
1349
1350          while (ComponentCount)
1351          {
1352 -            Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
1353 +            Status = AcpiDmDumpTable (Length, Offset, SubTable0B,
1354                  sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1355              if (ACPI_FAILURE (Status))
1356              {
1357 @@ -2503,17 +2574,19 @@ AcpiDmDumpMpst (
1358          /* Point to next Memory Power Node subtable */
1359
1360          SubtableCount--;
1361 +        ACPI_MOVE_32_TO_32(&PowerStateCount, &SubTable0->NumPowerStates);
1362 +        ACPI_MOVE_32_TO_32(&ComponentCount, &SubTable0->NumPhysicalComponents);
1363          SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
1364              sizeof (ACPI_MPST_POWER_NODE) +
1365 -            (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
1366 -            (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
1367 +            (sizeof (ACPI_MPST_POWER_STATE) * PowerStateCount) +
1368 +            (sizeof (ACPI_MPST_COMPONENT) * ComponentCount));
1369      }
1370
1371      /* Subtable: Count of Memory Power State Characteristic structures */
1372
1373      AcpiOsPrintf ("\n");
1374      SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
1375 -    Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
1376 +    Status = AcpiDmDumpTable (Length, Offset, SubTable1,
1377          sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1378      if (ACPI_FAILURE (Status))
1379      {
1380 @@ -2528,10 +2601,10 @@ AcpiDmDumpMpst (
1381      SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
1382          sizeof (ACPI_MPST_DATA_HDR));
1383
1384 -    while ((Offset < Table->Length) && SubtableCount)
1385 +    while ((Offset < Length) && SubtableCount)
1386      {
1387          AcpiOsPrintf ("\n");
1388 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
1389 +        Status = AcpiDmDumpTable (Length, Offset, SubTable2,
1390              sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1391          if (ACPI_FAILURE (Status))
1392          {
1393 @@ -2564,11 +2637,13 @@ AcpiDmDumpMsct (
1394      ACPI_STATUS             Status;
1395      UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
1396      ACPI_MSCT_PROXIMITY     *SubTable;
1397 +    UINT32                 Length;
1398
1399
1400      /* Main table */
1401
1402 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1403 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1404 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMsct);
1405      if (ACPI_FAILURE (Status))
1406      {
1407          return;
1408 @@ -2577,12 +2652,12 @@ AcpiDmDumpMsct (
1409      /* Subtables */
1410
1411      SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1412 -    while (Offset < Table->Length)
1413 +    while (Offset < Length)
1414      {
1415          /* Common subtable header */
1416
1417          AcpiOsPrintf ("\n");
1418 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1419 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1420              sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1421          if (ACPI_FAILURE (Status))
1422          {
1423 @@ -2617,11 +2692,13 @@ AcpiDmDumpMtmr (
1424      ACPI_STATUS             Status;
1425      UINT32                  Offset = sizeof (ACPI_TABLE_MTMR);
1426      ACPI_MTMR_ENTRY         *SubTable;
1427 +    UINT32                 Length;
1428
1429
1430      /* Main table */
1431
1432 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
1433 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1434 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMtmr);
1435      if (ACPI_FAILURE (Status))
1436      {
1437          return;
1438 @@ -2630,12 +2707,12 @@ AcpiDmDumpMtmr (
1439      /* Subtables */
1440
1441      SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
1442 -    while (Offset < Table->Length)
1443 +    while (Offset < Length)
1444      {
1445          /* Common subtable header */
1446
1447          AcpiOsPrintf ("\n");
1448 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1449 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1450              sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
1451          if (ACPI_FAILURE (Status))
1452          {
1453 @@ -2677,11 +2754,17 @@ AcpiDmDumpNfit (
1454      ACPI_NFIT_SMBIOS        *SmbiosInfo = NULL;
1455      ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1456      UINT32                  i;
1457 +    UINT32                  TableLength;
1458 +    UINT16                  SubLength;
1459 +    UINT16                  SubType;
1460 +    UINT32                  Count;
1461 +    UINT16                  Count16;
1462
1463
1464      /* Main table */
1465
1466 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1467 +    ACPI_MOVE_32_TO_32(&TableLength, &Table->Length);
1468 +    Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNfit);
1469      if (ACPI_FAILURE (Status))
1470      {
1471          return;
1472 @@ -2690,19 +2773,21 @@ AcpiDmDumpNfit (
1473      /* Subtables */
1474
1475      SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1476 -    while (Offset < Table->Length)
1477 +    while (Offset < TableLength)
1478      {
1479          /* NFIT subtable header */
1480
1481          AcpiOsPrintf ("\n");
1482 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1483 -            SubTable->Length, AcpiDmTableInfoNfitHdr);
1484 +       ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
1485 +        Status = AcpiDmDumpTable (TableLength, Offset, SubTable,
1486 +            SubLength, AcpiDmTableInfoNfitHdr);
1487          if (ACPI_FAILURE (Status))
1488          {
1489              return;
1490          }
1491
1492 -        switch (SubTable->Type)
1493 +       ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type);
1494 +        switch (SubType)
1495          {
1496          case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1497
1498 @@ -2754,7 +2839,7 @@ AcpiDmDumpNfit (
1499
1500              /* Attempt to continue */
1501
1502 -            if (!SubTable->Length)
1503 +            if (!SubLength)
1504              {
1505                  AcpiOsPrintf ("Invalid zero length subtable\n");
1506                  return;
1507 @@ -2763,8 +2848,8 @@ AcpiDmDumpNfit (
1508          }
1509
1510          AcpiOsPrintf ("\n");
1511 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1512 -            SubTable->Length, InfoTable);
1513 +        Status = AcpiDmDumpTable (TableLength, Offset, SubTable,
1514 +            SubLength, InfoTable);
1515          if (ACPI_FAILURE (Status))
1516          {
1517              return;
1518 @@ -2772,13 +2857,14 @@ AcpiDmDumpNfit (
1519
1520          /* Per-subtable variable-length fields */
1521
1522 -        switch (SubTable->Type)
1523 +        switch (SubType)
1524          {
1525          case ACPI_NFIT_TYPE_INTERLEAVE:
1526
1527 -            for (i = 0; i < Interleave->LineCount; i++)
1528 +           ACPI_MOVE_32_TO_32(&Count, &Interleave->LineCount);
1529 +            for (i = 0; i < Count; i++)
1530              {
1531 -                Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1532 +                Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset,
1533                      &Interleave->LineOffset[i],
1534                      sizeof (UINT32), AcpiDmTableInfoNfit2a);
1535                  if (ACPI_FAILURE (Status))
1536 @@ -2792,12 +2878,11 @@ AcpiDmDumpNfit (
1537
1538          case ACPI_NFIT_TYPE_SMBIOS:
1539
1540 -            Length = SubTable->Length -
1541 -                sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
1542 +            Length = SubLength - sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
1543
1544              if (Length)
1545              {
1546 -                Status = AcpiDmDumpTable (Table->Length,
1547 +                Status = AcpiDmDumpTable (TableLength,
1548                      sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
1549                      SmbiosInfo,
1550                      Length, AcpiDmTableInfoNfit3a);
1551 @@ -2811,9 +2896,10 @@ AcpiDmDumpNfit (
1552
1553          case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1554
1555 -            for (i = 0; i < Hint->HintCount; i++)
1556 +           ACPI_MOVE_16_TO_16(&Count16, &Hint->HintCount);
1557 +            for (i = 0; i < Count16; i++)
1558              {
1559 -                Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1560 +                Status = AcpiDmDumpTable (TableLength, Offset + FieldOffset,
1561                      &Hint->HintAddress[i],
1562                      sizeof (UINT64), AcpiDmTableInfoNfit6a);
1563                  if (ACPI_FAILURE (Status))
1564 @@ -2832,8 +2918,8 @@ AcpiDmDumpNfit (
1565  NextSubTable:
1566          /* Point to next subtable */
1567
1568 -        Offset += SubTable->Length;
1569 -        SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length);
1570 +        Offset += SubLength;
1571 +        SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubLength);
1572      }
1573  }
1574
1575 @@ -2858,12 +2944,13 @@ AcpiDmDumpPcct (
1576      ACPI_STATUS             Status;
1577      ACPI_PCCT_SUBSPACE      *SubTable;
1578      ACPI_DMTABLE_INFO       *InfoTable;
1579 -    UINT32                  Length = Table->Length;
1580 +    UINT32                  Length;
1581      UINT32                  Offset = sizeof (ACPI_TABLE_PCCT);
1582
1583
1584      /* Main table */
1585
1586 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1587      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1588      if (ACPI_FAILURE (Status))
1589      {
1590 @@ -2873,7 +2960,7 @@ AcpiDmDumpPcct (
1591      /* Subtables */
1592
1593      SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1594 -    while (Offset < Table->Length)
1595 +    while (Offset < Length)
1596      {
1597          /* Common subtable header */
1598
1599 @@ -2949,16 +3036,21 @@ AcpiDmDumpPmtt (
1600      ACPI_PMTT_HEADER        *MemSubTable;
1601      ACPI_PMTT_HEADER        *DimmSubTable;
1602      ACPI_PMTT_DOMAIN        *DomainArray;
1603 -    UINT32                  Length = Table->Length;
1604 +    UINT32                  Length;
1605      UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
1606      UINT32                  MemOffset;
1607      UINT32                  DimmOffset;
1608      UINT32                  DomainOffset;
1609 -    UINT32                  DomainCount;
1610 +    UINT16                  DomainCount;
1611 +    UINT16                 SubLength;
1612 +    UINT16                 Tmp16;
1613 +    UINT16                 MemLength;
1614 +    UINT16                 DimmLength;
1615
1616
1617      /* Main table */
1618
1619 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1620      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
1621      if (ACPI_FAILURE (Status))
1622      {
1623 @@ -2968,13 +3060,14 @@ AcpiDmDumpPmtt (
1624      /* Subtables */
1625
1626      SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
1627 -    while (Offset < Table->Length)
1628 +    while (Offset < Length)
1629      {
1630          /* Common subtable header */
1631
1632          AcpiOsPrintf ("\n");
1633 +        ACPI_MOVE_16_TO_16(&SubLength, &SubTable->Length);
1634          Status = AcpiDmDumpTable (Length, Offset, SubTable,
1635 -            SubTable->Length, AcpiDmTableInfoPmttHdr);
1636 +            SubLength, AcpiDmTableInfoPmttHdr);
1637          if (ACPI_FAILURE (Status))
1638          {
1639              return;
1640 @@ -2993,7 +3086,7 @@ AcpiDmDumpPmtt (
1641          /* Dump the fixed-length portion of the subtable */
1642
1643          Status = AcpiDmDumpTable (Length, Offset, SubTable,
1644 -            SubTable->Length, AcpiDmTableInfoPmtt0);
1645 +            SubLength, AcpiDmTableInfoPmtt0);
1646          if (ACPI_FAILURE (Status))
1647          {
1648              return;
1649 @@ -3005,15 +3098,16 @@ AcpiDmDumpPmtt (
1650          MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
1651              sizeof (ACPI_PMTT_SOCKET));
1652
1653 -        while (((Offset + MemOffset) < Table->Length) &&
1654 -            (MemOffset < SubTable->Length))
1655 +        while (((Offset + MemOffset) < Length) &&
1656 +            (MemOffset < SubLength))
1657          {
1658              /* Common subtable header */
1659
1660              AcpiOsPrintf ("\n");
1661 +           ACPI_MOVE_16_TO_16(&MemLength, &MemSubTable->Length);
1662              Status = AcpiDmDumpTable (Length,
1663                  Offset + MemOffset, MemSubTable,
1664 -                MemSubTable->Length, AcpiDmTableInfoPmttHdr);
1665 +                MemLength, AcpiDmTableInfoPmttHdr);
1666              if (ACPI_FAILURE (Status))
1667              {
1668                  return;
1669 @@ -3033,7 +3127,7 @@ AcpiDmDumpPmtt (
1670
1671              Status = AcpiDmDumpTable (Length,
1672                  Offset + MemOffset, MemSubTable,
1673 -                MemSubTable->Length, AcpiDmTableInfoPmtt1);
1674 +                MemLength, AcpiDmTableInfoPmtt1);
1675              if (ACPI_FAILURE (Status))
1676              {
1677                  return;
1678 @@ -3041,13 +3135,14 @@ AcpiDmDumpPmtt (
1679
1680              /* Walk the variable count of proximity domains */
1681
1682 -            DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
1683 +           Tmp16 = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
1684 +            ACPI_MOVE_16_TO_16(&DomainCount, &Tmp16);
1685              DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
1686              DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
1687                  sizeof (ACPI_PMTT_CONTROLLER));
1688
1689 -            while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
1690 -                ((MemOffset + DomainOffset) < SubTable->Length) &&
1691 +            while (((Offset + MemOffset + DomainOffset) < Length) &&
1692 +                ((MemOffset + DomainOffset) < SubLength) &&
1693                  DomainCount)
1694              {
1695                  Status = AcpiDmDumpTable (Length,
1696 @@ -3075,15 +3170,16 @@ AcpiDmDumpPmtt (
1697              DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
1698                  DomainOffset);
1699
1700 -            while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
1701 -                (DimmOffset < MemSubTable->Length))
1702 +            while (((Offset + MemOffset + DimmOffset) < Length) &&
1703 +                (DimmOffset < MemLength))
1704              {
1705                  /* Common subtable header */
1706
1707                  AcpiOsPrintf ("\n");
1708 +               ACPI_MOVE_16_TO_16(&DimmLength, &DimmSubTable->Length);
1709                  Status = AcpiDmDumpTable (Length,
1710                      Offset + MemOffset + DimmOffset, DimmSubTable,
1711 -                    DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
1712 +                    DimmLength, AcpiDmTableInfoPmttHdr);
1713                  if (ACPI_FAILURE (Status))
1714                  {
1715                      return;
1716 @@ -3103,7 +3199,7 @@ AcpiDmDumpPmtt (
1717
1718                  Status = AcpiDmDumpTable (Length,
1719                      Offset + MemOffset + DimmOffset, DimmSubTable,
1720 -                    DimmSubTable->Length, AcpiDmTableInfoPmtt2);
1721 +                    DimmLength, AcpiDmTableInfoPmtt2);
1722                  if (ACPI_FAILURE (Status))
1723                  {
1724                      return;
1725 @@ -3111,23 +3207,22 @@ AcpiDmDumpPmtt (
1726
1727                  /* Point to next DIMM subtable */
1728
1729 -                DimmOffset += DimmSubTable->Length;
1730 +                DimmOffset += DimmLength;
1731                  DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1732 -                    DimmSubTable, DimmSubTable->Length);
1733 +                    DimmSubTable, DimmLength);
1734              }
1735
1736              /* Point to next Controller subtable */
1737
1738 -            MemOffset += MemSubTable->Length;
1739 +            MemOffset += MemLength;
1740              MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1741 -                MemSubTable, MemSubTable->Length);
1742 +                MemSubTable, MemLength);
1743          }
1744
1745          /* Point to next Socket subtable */
1746
1747 -        Offset += SubTable->Length;
1748 -        SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1749 -            SubTable, SubTable->Length);
1750 +        Offset += SubLength;
1751 +        SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, SubLength);
1752      }
1753  }
1754
1755 @@ -3153,6 +3248,8 @@ AcpiDmDumpS3pt (
1756      ACPI_FPDT_HEADER        *SubTable;
1757      ACPI_DMTABLE_INFO       *InfoTable;
1758      ACPI_TABLE_S3PT         *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
1759 +    UINT32                 Length;
1760 +    UINT16                  SubType;
1761
1762
1763      /* Main table */
1764 @@ -3163,20 +3260,22 @@ AcpiDmDumpS3pt (
1765          return 0;
1766      }
1767
1768 +    ACPI_MOVE_32_TO_32(&Length, &S3ptTable->Length);
1769      SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
1770 -    while (Offset < S3ptTable->Length)
1771 +    while (Offset < Length)
1772      {
1773          /* Common subtable header */
1774
1775          AcpiOsPrintf ("\n");
1776 -        Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
1777 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1778              SubTable->Length, AcpiDmTableInfoS3ptHdr);
1779          if (ACPI_FAILURE (Status))
1780          {
1781              return 0;
1782          }
1783
1784 -        switch (SubTable->Type)
1785 +        ACPI_MOVE_16_TO_16(&SubType, &SubTable->Type);
1786 +        switch (SubType)
1787          {
1788          case ACPI_S3PT_TYPE_RESUME:
1789
1790 @@ -3191,7 +3290,7 @@ AcpiDmDumpS3pt (
1791          default:
1792
1793              AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
1794 -                SubTable->Type);
1795 +                SubType);
1796
1797              /* Attempt to continue */
1798
1799 @@ -3204,7 +3303,7 @@ AcpiDmDumpS3pt (
1800          }
1801
1802          AcpiOsPrintf ("\n");
1803 -        Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
1804 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1805              SubTable->Length, InfoTable);
1806          if (ACPI_FAILURE (Status))
1807          {
1808 @@ -3238,9 +3337,11 @@ void
1809  AcpiDmDumpSlic (
1810      ACPI_TABLE_HEADER       *Table)
1811  {
1812 +    UINT32     Length;
1813
1814 -    (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
1815 -        Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
1816 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1817 +    (void) AcpiDmDumpTable (Length, sizeof (ACPI_TABLE_HEADER), Table,
1818 +        Length - sizeof (*Table), AcpiDmTableInfoSlic);
1819  }
1820
1821
1822 @@ -3263,14 +3364,17 @@ AcpiDmDumpSlit (
1823      ACPI_STATUS             Status;
1824      UINT32                  Offset;
1825      UINT8                   *Row;
1826 -    UINT32                  Localities;
1827 +    UINT64                  Localities;
1828      UINT32                  i;
1829      UINT32                  j;
1830 +    UINT32                 Length;
1831 +    UINT64                  Tmp64;
1832
1833
1834      /* Main table */
1835
1836 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1837 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1838 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSlit);
1839      if (ACPI_FAILURE (Status))
1840      {
1841          return;
1842 @@ -3278,7 +3382,8 @@ AcpiDmDumpSlit (
1843
1844      /* Display the Locality NxN Matrix */
1845
1846 -    Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1847 +    Tmp64 = (UINT64) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1848 +    ACPI_MOVE_64_TO_64(&Localities, &Tmp64);
1849      Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1850      Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1851
1852 @@ -3291,7 +3396,7 @@ AcpiDmDumpSlit (
1853          {
1854              /* Check for beyond EOT */
1855
1856 -            if (Offset >= Table->Length)
1857 +            if (Offset >= Length)
1858              {
1859                  AcpiOsPrintf (
1860                      "\n**** Not enough room in table for all localities\n");
1861 @@ -3343,11 +3448,13 @@ AcpiDmDumpSrat (
1862      UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
1863      ACPI_SUBTABLE_HEADER    *SubTable;
1864      ACPI_DMTABLE_INFO       *InfoTable;
1865 +    UINT32                 Length;
1866
1867
1868      /* Main table */
1869
1870 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1871 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1872 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSrat);
1873      if (ACPI_FAILURE (Status))
1874      {
1875          return;
1876 @@ -3356,12 +3463,12 @@ AcpiDmDumpSrat (
1877      /* Subtables */
1878
1879      SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1880 -    while (Offset < Table->Length)
1881 +    while (Offset < Length)
1882      {
1883          /* Common subtable header */
1884
1885          AcpiOsPrintf ("\n");
1886 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1887 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1888              SubTable->Length, AcpiDmTableInfoSratHdr);
1889          if (ACPI_FAILURE (Status))
1890          {
1891 @@ -3405,7 +3512,7 @@ AcpiDmDumpSrat (
1892          }
1893
1894          AcpiOsPrintf ("\n");
1895 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1896 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1897              SubTable->Length, InfoTable);
1898          if (ACPI_FAILURE (Status))
1899          {
1900 @@ -3442,13 +3549,14 @@ AcpiDmDumpStao (
1901  {
1902      ACPI_STATUS             Status;
1903      char                    *Namepath;
1904 -    UINT32                  Length = Table->Length;
1905 +    UINT32                  Length;
1906      UINT32                  StringLength;
1907      UINT32                  Offset = sizeof (ACPI_TABLE_STAO);
1908
1909
1910      /* Main table */
1911
1912 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1913      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
1914      if (ACPI_FAILURE (Status))
1915      {
1916 @@ -3457,7 +3565,7 @@ AcpiDmDumpStao (
1917
1918      /* The rest of the table consists of Namepath strings */
1919
1920 -    while (Offset < Table->Length)
1921 +    while (Offset < Length)
1922      {
1923          Namepath = ACPI_ADD_PTR (char, Table, Offset);
1924          StringLength = strlen (Namepath) + 1;
1925 @@ -3499,11 +3607,14 @@ AcpiDmDumpTcpa (
1926      ACPI_TABLE_TCPA_HDR     *SubTable = ACPI_ADD_PTR (
1927                                  ACPI_TABLE_TCPA_HDR, Table, Offset);
1928      ACPI_STATUS             Status;
1929 +    UINT32                 Length;
1930 +    UINT16                 PlatformClass;
1931
1932
1933      /* Main table */
1934
1935 -    Status = AcpiDmDumpTable (Table->Length, 0, Table,
1936 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1937 +    Status = AcpiDmDumpTable (Length, 0, Table,
1938          0, AcpiDmTableInfoTcpaHdr);
1939      if (ACPI_FAILURE (Status))
1940      {
1941 @@ -3514,18 +3625,19 @@ AcpiDmDumpTcpa (
1942       * Examine the PlatformClass field to determine the table type.
1943       * Either a client or server table. Only one.
1944       */
1945 -    switch (CommonHeader->PlatformClass)
1946 +    ACPI_MOVE_16_TO_16(&PlatformClass, &CommonHeader->PlatformClass);
1947 +    switch (PlatformClass)
1948      {
1949      case ACPI_TCPA_CLIENT_TABLE:
1950
1951 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1952 -            Table->Length - Offset, AcpiDmTableInfoTcpaClient);
1953 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1954 +            Length - Offset, AcpiDmTableInfoTcpaClient);
1955          break;
1956
1957      case ACPI_TCPA_SERVER_TABLE:
1958
1959 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1960 -            Table->Length - Offset, AcpiDmTableInfoTcpaServer);
1961 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1962 +            Length - Offset, AcpiDmTableInfoTcpaServer);
1963          break;
1964
1965      default:
1966 @@ -3562,11 +3674,13 @@ AcpiDmDumpVrtc (
1967      ACPI_STATUS             Status;
1968      UINT32                  Offset = sizeof (ACPI_TABLE_VRTC);
1969      ACPI_VRTC_ENTRY         *SubTable;
1970 +    UINT32                 Length;
1971
1972
1973      /* Main table */
1974
1975 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
1976 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
1977 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoVrtc);
1978      if (ACPI_FAILURE (Status))
1979      {
1980          return;
1981 @@ -3575,12 +3689,12 @@ AcpiDmDumpVrtc (
1982      /* Subtables */
1983
1984      SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
1985 -    while (Offset < Table->Length)
1986 +    while (Offset < Length)
1987      {
1988          /* Common subtable header */
1989
1990          AcpiOsPrintf ("\n");
1991 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1992 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1993              sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
1994          if (ACPI_FAILURE (Status))
1995          {
1996 @@ -3615,11 +3729,13 @@ AcpiDmDumpWdat (
1997      ACPI_STATUS             Status;
1998      UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
1999      ACPI_WDAT_ENTRY         *SubTable;
2000 +    UINT32                 Length;
2001
2002
2003      /* Main table */
2004
2005 -    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
2006 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
2007 +    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWdat);
2008      if (ACPI_FAILURE (Status))
2009      {
2010          return;
2011 @@ -3628,12 +3744,12 @@ AcpiDmDumpWdat (
2012      /* Subtables */
2013
2014      SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
2015 -    while (Offset < Table->Length)
2016 +    while (Offset < Length)
2017      {
2018          /* Common subtable header */
2019
2020          AcpiOsPrintf ("\n");
2021 -        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2022 +        Status = AcpiDmDumpTable (Length, Offset, SubTable,
2023              sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
2024          if (ACPI_FAILURE (Status))
2025          {
2026 @@ -3668,12 +3784,13 @@ AcpiDmDumpWpbt (
2027  {
2028      ACPI_STATUS             Status;
2029      ACPI_TABLE_WPBT         *SubTable;
2030 -    UINT32                  Length = Table->Length;
2031 +    UINT32                  Length;
2032      UINT16                  ArgumentsLength;
2033
2034
2035      /* Dump the main table */
2036
2037 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
2038      Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
2039      if (ACPI_FAILURE (Status))
2040      {
2041 @@ -3683,10 +3800,10 @@ AcpiDmDumpWpbt (
2042      /* Extract the arguments buffer length from the main table */
2043
2044      SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
2045 -    ArgumentsLength = SubTable->ArgumentsLength;
2046 +    ACPI_MOVE_16_TO_16(&ArgumentsLength, &SubTable->ArgumentsLength);
2047
2048      /* Dump the arguments buffer */
2049
2050 -    (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
2051 +    (void) AcpiDmDumpTable (Length, 0, Table, ArgumentsLength,
2052          AcpiDmTableInfoWpbt0);
2053  }
2054 Index: acpica-unix2-20170303/source/compiler/aslrestype2.c
2055 ===================================================================
2056 --- acpica-unix2-20170303.orig/source/compiler/aslrestype2.c
2057 +++ acpica-unix2-20170303/source/compiler/aslrestype2.c
2058 @@ -98,21 +98,33 @@ RsDoGeneralRegisterDescriptor (
2059          {
2060          case 0: /* Address space */
2061
2062 +           /*
2063              Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
2064 +           */
2065 +            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AddressSpaceId,
2066 +                             &InitializerOp->Asl.Value.Integer);
2067              RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE,
2068                  CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));
2069             break;
2070
2071          case 1: /* Register Bit Width */
2072
2073 +           /*
2074              Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
2075 +           */
2076 +            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitWidth,
2077 +                             &InitializerOp->Asl.Value.Integer);
2078              RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH,
2079                  CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));
2080              break;
2081
2082          case 2: /* Register Bit Offset */
2083
2084 +           /*
2085              Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
2086 +           */
2087 +            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitOffset,
2088 +                             &InitializerOp->Asl.Value.Integer);
2089              RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET,
2090                  CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));
2091              break;
2092 @@ -127,7 +139,11 @@ RsDoGeneralRegisterDescriptor (
2093
2094          case 4: /* Access Size (ACPI 3.0) */
2095
2096 +           /*
2097              Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;
2098 +           */
2099 +           ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AccessSize,
2100 +                             &InitializerOp->Asl.Value.Integer);
2101              RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,
2102                  CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
2103
2104 Index: acpica-unix2-20170303/source/compiler/dtfield.c
2105 ===================================================================
2106 --- acpica-unix2-20170303.orig/source/compiler/dtfield.c
2107 +++ acpica-unix2-20170303/source/compiler/dtfield.c
2108 @@ -360,7 +360,27 @@ DtCompileInteger (
2109          DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer);
2110      }
2111
2112 -    memcpy (Buffer, &Value, ByteLength);
2113 +    switch (ByteLength) {
2114 +    case 1:
2115 +       ACPI_MOVE_64_TO_8(Buffer, &Value);
2116 +       break;
2117 +
2118 +    case 2:
2119 +       ACPI_MOVE_64_TO_16(Buffer, &Value);
2120 +       break;
2121 +
2122 +    case 4:
2123 +       ACPI_MOVE_64_TO_32(Buffer, &Value);
2124 +       break;
2125 +
2126 +    case 8:
2127 +       ACPI_MOVE_64_TO_64(Buffer, &Value);
2128 +       break;
2129 +
2130 +    default:
2131 +       memcpy (Buffer, &Value, ByteLength);
2132 +       break;
2133 +    }
2134      return;
2135  }
2136
2137 Index: acpica-unix2-20170303/source/compiler/dtsubtable.c
2138 ===================================================================
2139 --- acpica-unix2-20170303.orig/source/compiler/dtsubtable.c
2140 +++ acpica-unix2-20170303/source/compiler/dtsubtable.c
2141 @@ -379,6 +379,21 @@ DtSetSubtableLength (
2142          return;
2143      }
2144
2145 -    memcpy (Subtable->LengthField, &Subtable->TotalLength,
2146 -        Subtable->SizeOfLengthField);
2147 +    switch(Subtable->SizeOfLengthField) {
2148 +    case 1:
2149 +       ACPI_MOVE_32_TO_8(Subtable->LengthField, &Subtable->TotalLength);
2150 +       break;
2151 +
2152 +    case 2:
2153 +       ACPI_MOVE_32_TO_16(Subtable->LengthField, &Subtable->TotalLength);
2154 +       break;
2155 +
2156 +    case 4:
2157 +       ACPI_MOVE_32_TO_32(Subtable->LengthField, &Subtable->TotalLength);
2158 +       break;
2159 +
2160 +    default:
2161 +       memcpy (Subtable->LengthField, &Subtable->TotalLength,
2162 +               Subtable->SizeOfLengthField);
2163 +    }
2164  }
2165 Index: acpica-unix2-20170303/source/compiler/dttable1.c
2166 ===================================================================
2167 --- acpica-unix2-20170303.orig/source/compiler/dttable1.c
2168 +++ acpica-unix2-20170303/source/compiler/dttable1.c
2169 @@ -282,6 +282,8 @@ DtCompileCsrt (
2170      DT_FIELD                **PFieldList = (DT_FIELD **) List;
2171      UINT32                  DescriptorCount;
2172      UINT32                  GroupLength;
2173 +    ACPI_CSRT_GROUP        *Pgrp;
2174 +    UINT32                 Tmp32;
2175
2176
2177      /* Subtables (Resource Groups) */
2178 @@ -300,12 +302,20 @@ DtCompileCsrt (
2179
2180          /* Compute the number of resource descriptors */
2181
2182 +       /*
2183          GroupLength =
2184              (ACPI_CAST_PTR (ACPI_CSRT_GROUP,
2185                  Subtable->Buffer))->Length -
2186              (ACPI_CAST_PTR (ACPI_CSRT_GROUP,
2187                  Subtable->Buffer))->SharedInfoLength -
2188              sizeof (ACPI_CSRT_GROUP);
2189 +       */
2190 +       Pgrp = ACPI_CAST_PTR(ACPI_CSRT_GROUP, Subtable->Buffer);
2191 +       ACPI_MOVE_32_TO_32(&Tmp32, &Pgrp->Length);
2192 +       GroupLength = Tmp32;
2193 +       ACPI_MOVE_32_TO_32(&Tmp32, &Pgrp->SharedInfoLength);
2194 +       GroupLength -= Tmp32;
2195 +        GroupLength -= sizeof (ACPI_CSRT_GROUP);
2196
2197          DescriptorCount = (GroupLength  /
2198              sizeof (ACPI_CSRT_DESCRIPTOR));
2199 @@ -393,6 +403,8 @@ DtCompileDbg2 (
2200      ACPI_DBG2_DEVICE        *DeviceInfo;
2201      UINT16                  CurrentOffset;
2202      UINT32                  i;
2203 +    UINT16                  Tmp16;
2204 +    UINT32                  Tmp32;
2205
2206
2207      /* Main table */
2208 @@ -409,10 +421,11 @@ DtCompileDbg2 (
2209      /* Main table fields */
2210
2211      Dbg2Header = ACPI_CAST_PTR (ACPI_DBG2_HEADER, Subtable->Buffer);
2212 -    Dbg2Header->InfoOffset = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF (
2213 +    Tmp32 = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF (
2214          ACPI_ADD_PTR (UINT8, Dbg2Header, sizeof (ACPI_DBG2_HEADER)), Dbg2Header);
2215 +    ACPI_MOVE_32_TO_32(&Dbg2Header->InfoOffset, &Tmp32);
2216
2217 -    SubtableCount = Dbg2Header->InfoCount;
2218 +    ACPI_MOVE_32_TO_32(&SubtableCount, &Dbg2Header->InfoCount);
2219      DtPushSubtable (Subtable);
2220
2221      /* Process all Device Information subtables (Count = InfoCount) */
2222 @@ -439,7 +452,7 @@ DtCompileDbg2 (
2223
2224          /* BaseAddressRegister GAS array (Required, size is RegisterCount) */
2225
2226 -        DeviceInfo->BaseAddressOffset = CurrentOffset;
2227 +        ACPI_MOVE_16_TO_16(&DeviceInfo->BaseAddressOffset, &CurrentOffset);
2228          for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
2229          {
2230              Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr,
2231 @@ -455,7 +468,7 @@ DtCompileDbg2 (
2232
2233          /* AddressSize array (Required, size = RegisterCount) */
2234
2235 -        DeviceInfo->AddressSizeOffset = CurrentOffset;
2236 +        ACPI_MOVE_16_TO_16(&DeviceInfo->AddressSizeOffset, &CurrentOffset);
2237          for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
2238          {
2239              Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size,
2240 @@ -471,7 +484,7 @@ DtCompileDbg2 (
2241
2242          /* NamespaceString device identifier (Required, size = NamePathLength) */
2243
2244 -        DeviceInfo->NamepathOffset = CurrentOffset;
2245 +        ACPI_MOVE_16_TO_16(&DeviceInfo->NamepathOffset, &CurrentOffset);
2246          Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name,
2247              &Subtable, TRUE);
2248          if (ACPI_FAILURE (Status))
2249 @@ -481,8 +494,9 @@ DtCompileDbg2 (
2250
2251          /* Update the device info header */
2252
2253 -        DeviceInfo->NamepathLength = (UINT16) Subtable->Length;
2254 -        CurrentOffset += (UINT16) DeviceInfo->NamepathLength;
2255 +        ACPI_MOVE_32_TO_16(&DeviceInfo->NamepathLength, &Subtable->Length);
2256 +        ACPI_MOVE_16_TO_16(&Tmp16, &DeviceInfo->NamepathLength);
2257 +        CurrentOffset += Tmp16;
2258          DtInsertSubtable (ParentTable, Subtable);
2259
2260          /* OemData - Variable-length data (Optional, size = OemDataLength) */
2261 @@ -503,8 +517,8 @@ DtCompileDbg2 (
2262
2263          if (Subtable && Subtable->Length)
2264          {
2265 -            DeviceInfo->OemDataOffset = CurrentOffset;
2266 -            DeviceInfo->OemDataLength = (UINT16) Subtable->Length;
2267 +            ACPI_MOVE_16_TO_16(&DeviceInfo->OemDataOffset, &CurrentOffset);
2268 +            ACPI_MOVE_32_TO_16(&DeviceInfo->OemDataLength, &Subtable->Length);
2269
2270              DtInsertSubtable (ParentTable, Subtable);
2271          }
2272 @@ -544,6 +558,8 @@ DtCompileDmar (
2273      ACPI_DMAR_DEVICE_SCOPE  *DmarDeviceScope;
2274      UINT32                  DeviceScopeLength;
2275      UINT32                  PciPathLength;
2276 +    UINT16                 Tmp16;
2277 +    UINT16                 HdrType;
2278
2279
2280      Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE);
2281 @@ -573,8 +589,11 @@ DtCompileDmar (
2282          DtPushSubtable (Subtable);
2283
2284          DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer);
2285 +       ACPI_MOVE_16_TO_16(&Tmp16, &DmarHeader->Length);
2286 +       DmarHeader->Length = Tmp16;
2287
2288 -        switch (DmarHeader->Type)
2289 +       ACPI_MOVE_16_TO_16(&HdrType, &DmarHeader->Type);
2290 +        switch (HdrType)
2291          {
2292          case ACPI_DMAR_TYPE_HARDWARE_UNIT:
2293
2294 @@ -621,8 +640,8 @@ DtCompileDmar (
2295          /*
2296           * Optional Device Scope subtables
2297           */
2298 -        if ((DmarHeader->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
2299 -            (DmarHeader->Type == ACPI_DMAR_TYPE_NAMESPACE))
2300 +        if ((HdrType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
2301 +            (HdrType == ACPI_DMAR_TYPE_NAMESPACE))
2302          {
2303              /* These types do not support device scopes */
2304
2305 @@ -631,8 +650,8 @@ DtCompileDmar (
2306          }
2307
2308          DtPushSubtable (Subtable);
2309 -        DeviceScopeLength = DmarHeader->Length - Subtable->Length -
2310 -            ParentTable->Length;
2311 +        DeviceScopeLength = DmarHeader->Length - Subtable->Length -
2312 +               ParentTable->Length;
2313          while (DeviceScopeLength)
2314          {
2315              Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope,
2316 @@ -757,7 +776,7 @@ DtCompileDrtm (
2317          Count++;
2318      }
2319
2320 -    DrtmVtl->ValidatedTableCount = Count;
2321 +    ACPI_MOVE_32_TO_32(&DrtmVtl->ValidatedTableCount, &Count);
2322      DtPopSubtable ();
2323      ParentTable = DtPeekSubtable ();
2324
2325 @@ -795,7 +814,7 @@ DtCompileDrtm (
2326          Count++;
2327      }
2328
2329 -    DrtmRl->ResourceCount = Count;
2330 +    ACPI_MOVE_32_TO_32(&DrtmRl->ResourceCount, &Count);
2331      DtPopSubtable ();
2332      ParentTable = DtPeekSubtable ();
2333
2334 @@ -889,6 +908,7 @@ DtCompileGtdt (
2335      ACPI_SUBTABLE_HEADER    *GtdtHeader;
2336      ACPI_DMTABLE_INFO       *InfoTable;
2337      UINT32                  GtCount;
2338 +    ACPI_GTDT_TIMER_BLOCK   *TimerBlock;
2339
2340
2341      Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt,
2342 @@ -955,8 +975,9 @@ DtCompileGtdt (
2343              DtPushSubtable (Subtable);
2344              ParentTable = DtPeekSubtable ();
2345
2346 -            GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
2347 -                Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount;
2348 +           TimerBlock = ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
2349 +                Subtable->Buffer - sizeof(ACPI_GTDT_HEADER));
2350 +           ACPI_MOVE_32_TO_32(&GtCount, &TimerBlock->TimerCount);
2351
2352              while (GtCount)
2353              {
2354 @@ -1009,6 +1030,7 @@ DtCompileFpdt (
2355      ACPI_DMTABLE_INFO       *InfoTable;
2356      DT_FIELD                **PFieldList = (DT_FIELD **) List;
2357      DT_FIELD                *SubtableStart;
2358 +    UINT16                 HdrType;
2359
2360
2361      while (*PFieldList)
2362 @@ -1027,7 +1049,8 @@ DtCompileFpdt (
2363
2364          FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
2365
2366 -        switch (FpdtHeader->Type)
2367 +       ACPI_MOVE_16_TO_16(&HdrType, &FpdtHeader->Type);
2368 +        switch (HdrType)
2369          {
2370          case ACPI_FPDT_TYPE_BOOT:
2371
2372 @@ -1085,6 +1108,7 @@ DtCompileHest (
2373      ACPI_DMTABLE_INFO       *InfoTable;
2374      UINT16                  Type;
2375      UINT32                  BankCount;
2376 +    UINT16                 Tmp16;
2377
2378
2379      Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
2380 @@ -1102,8 +1126,9 @@ DtCompileHest (
2381          /* Get subtable type */
2382
2383          SubtableStart = *PFieldList;
2384 -        DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0);
2385 +        DtCompileInteger ((UINT8 *) &Tmp16, *PFieldList, 2, 0);
2386
2387 +       ACPI_MOVE_16_TO_16(&Type, &Tmp16);
2388          switch (Type)
2389          {
2390          case ACPI_HEST_TYPE_IA32_CHECK:
2391 @@ -1225,11 +1250,13 @@ DtCompileIort (
2392      ACPI_IORT_SMMU          *IortSmmu;
2393      UINT32                  NodeNumber;
2394      UINT32                  NodeLength;
2395 +    UINT32                  NodeOffset;
2396      UINT32                  IdMappingNumber;
2397      UINT32                  ItsNumber;
2398      UINT32                  ContextIrptNumber;
2399      UINT32                  PmuIrptNumber;
2400      UINT32                  PaddingLength;
2401 +    UINT32                  MappingOffset;
2402
2403
2404      ParentTable = DtPeekSubtable ();
2405 @@ -1255,7 +1282,7 @@ DtCompileIort (
2406       * Optionally allows the generic data types to be used for filling
2407       * this field.
2408       */
2409 -    Iort->NodeOffset = sizeof (ACPI_TABLE_IORT);
2410 +    NodeOffset = sizeof (ACPI_TABLE_IORT);
2411      Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad,
2412          &Subtable, TRUE);
2413      if (ACPI_FAILURE (Status))
2414 @@ -1265,7 +1292,7 @@ DtCompileIort (
2415      if (Subtable)
2416      {
2417          DtInsertSubtable (ParentTable, Subtable);
2418 -        Iort->NodeOffset += Subtable->Length;
2419 +        NodeOffset += Subtable->Length;
2420      }
2421      else
2422      {
2423 @@ -1275,8 +1302,9 @@ DtCompileIort (
2424          {
2425              return (Status);
2426          }
2427 -        Iort->NodeOffset += PaddingLength;
2428 +        NodeOffset += PaddingLength;
2429      }
2430 +    ACPI_MOVE_32_TO_32(&Iort->NodeOffset, &NodeOffset);
2431
2432      NodeNumber = 0;
2433      while (*PFieldList)
2434 @@ -1330,7 +1358,7 @@ DtCompileIort (
2435                  ItsNumber++;
2436              }
2437
2438 -            IortItsGroup->ItsCount = ItsNumber;
2439 +            ACPI_MOVE_32_TO_32(&IortItsGroup->ItsCount, &ItsNumber);
2440              break;
2441
2442          case ACPI_IORT_NODE_NAMED_COMPONENT:
2443 @@ -1364,15 +1392,16 @@ DtCompileIort (
2444              }
2445              else
2446              {
2447 -                if (NodeLength > IortNode->MappingOffset)
2448 +               ACPI_MOVE_32_TO_32(&MappingOffset, &IortNode->MappingOffset);
2449 +                if (NodeLength > MappingOffset)
2450                  {
2451                      return (AE_BAD_DATA);
2452                  }
2453
2454 -                if (NodeLength < IortNode->MappingOffset)
2455 +                if (NodeLength < MappingOffset)
2456                  {
2457                      Status = DtCompilePadding (
2458 -                        IortNode->MappingOffset - NodeLength,
2459 +                        MappingOffset - NodeLength,
2460                          &Subtable);
2461                      if (ACPI_FAILURE (Status))
2462                      {
2463 @@ -1380,7 +1409,8 @@ DtCompileIort (
2464                      }
2465
2466                      DtInsertSubtable (ParentTable, Subtable);
2467 -                    NodeLength = IortNode->MappingOffset;
2468 +                   ACPI_MOVE_32_TO_32(&MappingOffset, &IortNode->MappingOffset);
2469 +                    NodeLength = MappingOffset;
2470                  }
2471              }
2472              break;
2473 @@ -1413,7 +1443,7 @@ DtCompileIort (
2474
2475              /* Compile global interrupt array */
2476
2477 -            IortSmmu->GlobalInterruptOffset = NodeLength;
2478 +            ACPI_MOVE_32_TO_32(&IortSmmu->GlobalInterruptOffset, &NodeLength);
2479              Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a,
2480                  &Subtable, TRUE);
2481              if (ACPI_FAILURE (Status))
2482 @@ -1427,7 +1457,7 @@ DtCompileIort (
2483              /* Compile context interrupt array */
2484
2485              ContextIrptNumber = 0;
2486 -            IortSmmu->ContextInterruptOffset = NodeLength;
2487 +            ACPI_MOVE_32_TO_32(&IortSmmu->ContextInterruptOffset, &NodeLength);
2488              while (*PFieldList)
2489              {
2490                  Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b,
2491 @@ -1447,12 +1477,12 @@ DtCompileIort (
2492                  ContextIrptNumber++;
2493              }
2494
2495 -            IortSmmu->ContextInterruptCount = ContextIrptNumber;
2496 +            ACPI_MOVE_32_TO_32(&IortSmmu->ContextInterruptCount, &ContextIrptNumber);
2497
2498              /* Compile PMU interrupt array */
2499
2500              PmuIrptNumber = 0;
2501 -            IortSmmu->PmuInterruptOffset = NodeLength;
2502 +            ACPI_MOVE_32_TO_32(&IortSmmu->PmuInterruptOffset, &NodeLength);
2503              while (*PFieldList)
2504              {
2505                  Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c,
2506 @@ -1472,7 +1502,7 @@ DtCompileIort (
2507                  PmuIrptNumber++;
2508              }
2509
2510 -            IortSmmu->PmuInterruptCount = PmuIrptNumber;
2511 +            ACPI_MOVE_32_TO_32(&IortSmmu->PmuInterruptCount, &PmuIrptNumber);
2512              break;
2513
2514          case ACPI_IORT_NODE_SMMU_V3:
2515 @@ -1496,7 +1526,7 @@ DtCompileIort (
2516
2517          /* Compile Array of ID mappings */
2518
2519 -        IortNode->MappingOffset = NodeLength;
2520 +        ACPI_MOVE_32_TO_32(&IortNode->MappingOffset, &NodeLength);
2521          IdMappingNumber = 0;
2522          while (*PFieldList)
2523          {
2524 @@ -1517,7 +1547,7 @@ DtCompileIort (
2525              IdMappingNumber++;
2526          }
2527
2528 -        IortNode->MappingCount = IdMappingNumber;
2529 +        ACPI_MOVE_32_TO_32(&IortNode->MappingCount, &IdMappingNumber);
2530          if (!IdMappingNumber)
2531          {
2532              IortNode->MappingOffset = 0;
2533 @@ -1532,7 +1562,7 @@ DtCompileIort (
2534          NodeNumber++;
2535      }
2536
2537 -    Iort->NodeCount = NodeNumber;
2538 +    ACPI_MOVE_32_TO_32(&Iort->NodeCount, &NodeNumber);
2539      return (AE_OK);
2540  }
2541
2542 Index: acpica-unix2-20170303/source/compiler/dttable2.c
2543 ===================================================================
2544 --- acpica-unix2-20170303.orig/source/compiler/dttable2.c
2545 +++ acpica-unix2-20170303/source/compiler/dttable2.c
2546 @@ -346,7 +346,7 @@ DtCompileMpst (
2547      DtPushSubtable (Subtable);
2548
2549      MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
2550 -    SubtableCount = MpstChannelInfo->PowerNodeCount;
2551 +    ACPI_MOVE_16_TO_16(&SubtableCount, &MpstChannelInfo->PowerNodeCount);
2552
2553      while (*PFieldList && SubtableCount)
2554      {
2555 @@ -364,8 +364,8 @@ DtCompileMpst (
2556          DtPushSubtable (Subtable);
2557
2558          MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
2559 -        PowerStateCount = MpstPowerNode->NumPowerStates;
2560 -        ComponentCount = MpstPowerNode->NumPhysicalComponents;
2561 +        ACPI_MOVE_32_TO_32(&PowerStateCount, &MpstPowerNode->NumPowerStates);
2562 +        ACPI_MOVE_32_TO_32(&ComponentCount, &MpstPowerNode->NumPhysicalComponents);
2563
2564          ParentTable = DtPeekSubtable ();
2565
2566 @@ -518,6 +518,7 @@ DtCompileNfit (
2567      UINT32                  Count;
2568      ACPI_NFIT_INTERLEAVE    *Interleave = NULL;
2569      ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
2570 +    UINT16                 SubType;
2571
2572
2573      /* Main table */
2574 @@ -551,7 +552,8 @@ DtCompileNfit (
2575
2576          NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer);
2577
2578 -        switch (NfitHeader->Type)
2579 +       ACPI_MOVE_16_TO_16(&SubType, &NfitHeader->Type);
2580 +        switch (SubType)
2581          {
2582          case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
2583
2584 @@ -606,7 +608,7 @@ DtCompileNfit (
2585          DtInsertSubtable (ParentTable, Subtable);
2586          DtPopSubtable ();
2587
2588 -        switch (NfitHeader->Type)
2589 +        switch (SubType)
2590          {
2591          case ACPI_NFIT_TYPE_INTERLEAVE:
2592
2593 @@ -632,7 +634,7 @@ DtCompileNfit (
2594                  Count++;
2595              }
2596
2597 -            Interleave->LineCount = Count;
2598 +            ACPI_MOVE_32_TO_32(&Interleave->LineCount, &Count);
2599              DtPopSubtable ();
2600              break;
2601
2602 @@ -678,7 +680,7 @@ DtCompileNfit (
2603                  Count++;
2604              }
2605
2606 -            Hint->HintCount = (UINT16) Count;
2607 +            ACPI_MOVE_32_TO_16(&Hint->HintCount, &Count);
2608              DtPopSubtable ();
2609              break;
2610
2611 @@ -885,7 +887,7 @@ DtCompilePmtt (
2612
2613              PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
2614                  (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
2615 -            DomainCount = PmttController->DomainCount;
2616 +            ACPI_MOVE_16_TO_16(&DomainCount, &PmttController->DomainCount);
2617
2618              while (DomainCount)
2619              {
2620 @@ -986,6 +988,7 @@ DtCompileS3pt (
2621      DT_SUBTABLE             *ParentTable;
2622      ACPI_DMTABLE_INFO       *InfoTable;
2623      DT_FIELD                *SubtableStart;
2624 +    UINT16                 HdrType;
2625
2626
2627      Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
2628 @@ -1013,7 +1016,8 @@ DtCompileS3pt (
2629
2630          S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
2631
2632 -        switch (S3ptHeader->Type)
2633 +       ACPI_MOVE_16_TO_16(&HdrType, &S3ptHeader->Type);
2634 +        switch (HdrType)
2635          {
2636          case ACPI_S3PT_TYPE_RESUME:
2637
2638 @@ -1110,6 +1114,7 @@ DtCompileSlit (
2639      DT_FIELD                *FieldList;
2640      UINT32                  Localities;
2641      UINT8                   *LocalityBuffer;
2642 +    UINT32                 Tmp;
2643
2644
2645      Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
2646 @@ -1122,7 +1127,8 @@ DtCompileSlit (
2647      ParentTable = DtPeekSubtable ();
2648      DtInsertSubtable (ParentTable, Subtable);
2649
2650 -    Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
2651 +    Tmp = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
2652 +    ACPI_MOVE_32_TO_32(&Localities, &Tmp);
2653      LocalityBuffer = UtLocalCalloc (Localities);
2654
2655      /* Compile each locality buffer */
2656 @@ -1311,6 +1317,7 @@ DtCompileTcpa (
2657      ACPI_TABLE_TCPA_HDR     *TcpaHeader;
2658      DT_SUBTABLE             *ParentTable;
2659      ACPI_STATUS             Status;
2660 +    UINT16                 PlatClass;
2661
2662
2663      /* Compile the main table */
2664 @@ -1331,7 +1338,8 @@ DtCompileTcpa (
2665       */
2666      TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
2667
2668 -    switch (TcpaHeader->PlatformClass)
2669 +    ACPI_MOVE_16_TO_16(&PlatClass, &TcpaHeader->PlatformClass);
2670 +    switch (PlatClass)
2671      {
2672      case ACPI_TCPA_CLIENT_TABLE:
2673
2674 @@ -1527,6 +1535,9 @@ DtCompileWpbt (
2675      ACPI_TABLE_WPBT         *Table;
2676      ACPI_STATUS             Status;
2677      UINT16                  Length;
2678 +    UINT16                  Tmp16;
2679 +    UINT16                 *Ptr16;
2680 +    UINT32                 ii;
2681
2682
2683      /* Compile the main table */
2684 @@ -1554,7 +1565,16 @@ DtCompileWpbt (
2685
2686      Length = (UINT16) Subtable->TotalLength;
2687      Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
2688 -    Table->ArgumentsLength = Length;
2689 +    ACPI_MOVE_16_TO_16(&Table->ArgumentsLength, &Length);
2690 +
2691 +    /* The arguments are in Unicode, so make sure the byte order is correct */
2692 +    Ptr16 = (UINT16 *)Subtable->Buffer;
2693 +    for (ii = 0; ii < Length; ii++)
2694 +    {
2695 +       ACPI_MOVE_16_TO_16(&Tmp16, Ptr16);
2696 +       *Ptr16 = Tmp16;
2697 +        Ptr16++;
2698 +    }
2699
2700      ParentTable = DtPeekSubtable ();
2701      DtInsertSubtable (ParentTable, Subtable);
2702 Index: acpica-unix2-20170303/source/components/disassembler/dmbuffer.c
2703 ===================================================================
2704 --- acpica-unix2-20170303.orig/source/components/disassembler/dmbuffer.c
2705 +++ acpica-unix2-20170303/source/components/disassembler/dmbuffer.c
2706 @@ -204,7 +204,7 @@ AcpiDmByteList (
2707
2708
2709      ByteData = Op->Named.Data;
2710 -    ByteCount = (UINT32) Op->Common.Value.Integer;
2711 +    ByteCount = (UINT32) Op->Common.Value.Size;
2712
2713      /*
2714       * The byte list belongs to a buffer, and can be produced by either
2715 @@ -304,7 +304,8 @@ AcpiDmIsUuidBuffer (
2716      /* Extract the byte list info */
2717
2718      ByteData = NextOp->Named.Data;
2719 -    ByteCount = (UINT32) NextOp->Common.Value.Integer;
2720 +    /* ByteCount = (UINT32) NextOp->Common.Value.Integer; */
2721 +    ByteCount = (UINT32) NextOp->Common.Value.Size;
2722
2723      /* Byte count must be exactly 16 */
2724
2725 @@ -424,7 +425,8 @@ AcpiDmIsUnicodeBuffer (
2726      /* Extract the byte list info */
2727
2728      ByteData = NextOp->Named.Data;
2729 -    ByteCount = (UINT32) NextOp->Common.Value.Integer;
2730 +    /* ByteCount = (UINT32) NextOp->Common.Value.Integer; */
2731 +    ByteCount = (UINT32) NextOp->Common.Value.Size;
2732      WordCount = ACPI_DIV_2 (ByteCount);
2733
2734      /*
2735 @@ -852,19 +854,22 @@ AcpiDmUnicode (
2736      UINT32                  WordCount;
2737      UINT32                  i;
2738      int                     OutputValue;
2739 +    UINT16                 Tmp16;
2740
2741
2742      /* Extract the buffer info as a WORD buffer */
2743
2744      WordData = ACPI_CAST_PTR (UINT16, Op->Named.Data);
2745 -    WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Integer));
2746 +    WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Size));
2747
2748      /* Write every other byte as an ASCII character */
2749
2750      AcpiOsPrintf ("\"");
2751      for (i = 0; i < (WordCount - 1); i++)
2752      {
2753 -        OutputValue = (int) WordData[i];
2754 +        /* OutputValue = (int) WordData[i]; */
2755 +       ACPI_MOVE_16_TO_16(&Tmp16, &WordData[i]);
2756 +       OutputValue = (int) Tmp16;
2757
2758          /* Handle values that must be escaped */
2759
2760 @@ -973,16 +978,18 @@ AcpiDmCheckForHardwareId (
2761      ACPI_PARSE_OBJECT       *Op)
2762  {
2763      UINT32                  Name;
2764 +    UINT32                  TmpName;
2765      ACPI_PARSE_OBJECT       *NextOp;
2766
2767
2768      /* Get the NameSegment */
2769
2770 -    Name = AcpiPsGetName (Op);
2771 -    if (!Name)
2772 +    TmpName = AcpiPsGetName (Op);
2773 +    if (!TmpName)
2774      {
2775          return;
2776      }
2777 +    ACPI_MOVE_32_TO_32(&Name, &TmpName);
2778
2779      NextOp = AcpiPsGetDepthNext (NULL, Op);
2780      if (!NextOp)
2781 Index: acpica-unix2-20170303/source/components/disassembler/dmopcode.c
2782 ===================================================================
2783 --- acpica-unix2-20170303.orig/source/components/disassembler/dmopcode.c
2784 +++ acpica-unix2-20170303/source/components/disassembler/dmopcode.c
2785 @@ -253,6 +253,7 @@ AcpiDmPredefinedDescription (
2786      char                        *NameString;
2787      int                         LastCharIsDigit;
2788      int                         LastCharsAreHex;
2789 +    char                       TmpName[ACPI_NAME_SIZE + 1];
2790
2791
2792      if (!Op)
2793 @@ -270,7 +271,9 @@ AcpiDmPredefinedDescription (
2794
2795      /* Predefined name must start with an underscore */
2796
2797 -    NameString = ACPI_CAST_PTR (char, &Op->Named.Name);
2798 +    memset(TmpName, 0, ACPI_NAME_SIZE + 1);
2799 +    ACPI_MOVE_32_TO_32(TmpName, &Op->Named.Name);
2800 +    NameString = TmpName;
2801      if (NameString[0] != '_')
2802      {
2803          return;
2804 @@ -884,25 +887,29 @@ AcpiDmDisassembleOneOp (
2805          AcpiDmNamestring (Op->Common.Value.Name);
2806          break;
2807
2808 -    case AML_INT_NAMEDFIELD_OP:
2809 +    case AML_INT_NAMEDFIELD_OP: {
2810
2811 -        Length = AcpiDmDumpName (Op->Named.Name);
2812 +       UINT32 TmpName;
2813 +
2814 +       ACPI_MOVE_32_TO_32(&TmpName, &Op->Named.Name);
2815 +        Length = AcpiDmDumpName (TmpName);
2816
2817          AcpiOsPrintf (",");
2818          ASL_CV_PRINT_ONE_COMMENT (Op, AML_NAMECOMMENT, NULL, 0);
2819          AcpiOsPrintf ("%*.s  %u", (unsigned) (5 - Length), " ",
2820 -            (UINT32) Op->Common.Value.Integer);
2821 +            (UINT32) Op->Common.Value.Size);
2822
2823          AcpiDmCommaIfFieldMember (Op);
2824
2825 -        Info->BitOffset += (UINT32) Op->Common.Value.Integer;
2826 +        Info->BitOffset += (UINT32) Op->Common.Value.Size;
2827          break;
2828 +    }
2829
2830      case AML_INT_RESERVEDFIELD_OP:
2831
2832          /* Offset() -- Must account for previous offsets */
2833
2834 -        Offset = (UINT32) Op->Common.Value.Integer;
2835 +        Offset = Op->Common.Value.Size;
2836          Info->BitOffset += Offset;
2837
2838          if (Info->BitOffset % 8 == 0)
2839 Index: acpica-unix2-20170303/source/components/disassembler/dmresrcl2.c
2840 ===================================================================
2841 --- acpica-unix2-20170303.orig/source/components/disassembler/dmresrcl2.c
2842 +++ acpica-unix2-20170303/source/components/disassembler/dmresrcl2.c
2843 @@ -191,22 +191,24 @@ AcpiDmGpioCommon (
2844      char                    *DeviceName = NULL;
2845      UINT32                  PinCount;
2846      UINT32                  i;
2847 +    UINT16                 Tmp16;
2848
2849
2850      /* ResourceSource, ResourceSourceIndex, ResourceType */
2851
2852      AcpiDmIndent (Level + 1);
2853 -    if (Resource->Gpio.ResSourceOffset)
2854 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.ResSourceOffset);
2855 +    if (Tmp16)
2856      {
2857 -        DeviceName = ACPI_ADD_PTR (char,
2858 -            Resource, Resource->Gpio.ResSourceOffset),
2859 +        DeviceName = ACPI_ADD_PTR (char, Resource, Tmp16),
2860          AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
2861      }
2862
2863      AcpiOsPrintf (", ");
2864      AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.ResSourceIndex);
2865 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.Flags);
2866      AcpiOsPrintf ("%s, ",
2867 -        AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.Flags)]);
2868 +        AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Tmp16)]);
2869
2870      /* Insert a descriptor name */
2871
2872 @@ -215,15 +217,16 @@ AcpiDmGpioCommon (
2873
2874      /* Dump the vendor data */
2875
2876 -    if (Resource->Gpio.VendorOffset)
2877 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorOffset);
2878 +    if (Tmp16)
2879      {
2880          AcpiOsPrintf ("\n");
2881          AcpiDmIndent (Level + 1);
2882 -        VendorData = ACPI_ADD_PTR (UINT8, Resource,
2883 -            Resource->Gpio.VendorOffset);
2884 +       ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorOffset);
2885 +        VendorData = ACPI_ADD_PTR (UINT8, Resource, Tmp16);
2886
2887 -        AcpiDmDumpRawDataBuffer (VendorData,
2888 -            Resource->Gpio.VendorLength, Level);
2889 +       ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.VendorLength);
2890 +        AcpiDmDumpRawDataBuffer (VendorData, Tmp16, Level);
2891      }
2892
2893      AcpiOsPrintf (")\n");
2894 @@ -233,17 +236,25 @@ AcpiDmGpioCommon (
2895      AcpiDmIndent (Level + 1);
2896      AcpiOsPrintf ("{   // Pin list\n");
2897
2898 +    /*
2899      PinCount = ((UINT32) (Resource->Gpio.ResSourceOffset -
2900          Resource->Gpio.PinTableOffset)) /
2901          sizeof (UINT16);
2902 +    */
2903 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.ResSourceOffset);
2904 +    PinCount = (UINT32) Tmp16;
2905 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.PinTableOffset);
2906 +    PinCount -= (UINT32) Tmp16;
2907 +    PinCount /= sizeof (UINT16);
2908
2909 -    PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource,
2910 -        Resource->Gpio.PinTableOffset);
2911 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.PinTableOffset);
2912 +    PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource, Tmp16);
2913
2914      for (i = 0; i < PinCount; i++)
2915      {
2916          AcpiDmIndent (Level + 2);
2917 -        AcpiOsPrintf ("0x%4.4X%s\n", PinList[i],
2918 +       ACPI_MOVE_16_TO_16(&Tmp16, &PinList[i]);
2919 +        AcpiOsPrintf ("0x%4.4X%s\n", Tmp16,
2920              ((i + 1) < PinCount) ? "," : "");
2921      }
2922
2923 @@ -277,16 +288,18 @@ AcpiDmGpioIntDescriptor (
2924      UINT32                  Length,
2925      UINT32                  Level)
2926  {
2927 +    UINT16                 Tmp16;
2928
2929      /* Dump the GpioInt-specific portion of the descriptor */
2930
2931      /* EdgeLevel, ActiveLevel, Shared */
2932
2933      AcpiDmIndent (Level);
2934 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags);
2935      AcpiOsPrintf ("GpioInt (%s, %s, %s, ",
2936 -        AcpiGbl_HeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.IntFlags)],
2937 -        AcpiGbl_LlDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 1)],
2938 -        AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]);
2939 +        AcpiGbl_HeDecode [ACPI_GET_1BIT_FLAG (Tmp16)],
2940 +        AcpiGbl_LlDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 1)],
2941 +        AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 3)]);
2942
2943      /* PinConfig, DebounceTimeout */
2944
2945 @@ -299,7 +312,8 @@ AcpiDmGpioIntDescriptor (
2946      {
2947          AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.PinConfig);
2948      }
2949 -    AcpiOsPrintf ("0x%4.4X,\n", Resource->Gpio.DebounceTimeout);
2950 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DebounceTimeout);
2951 +    AcpiOsPrintf ("0x%4.4X,\n", Tmp16);
2952
2953      /* Dump the GpioInt/GpioIo common portion of the descriptor */
2954
2955 @@ -329,14 +343,16 @@ AcpiDmGpioIoDescriptor (
2956      UINT32                  Length,
2957      UINT32                  Level)
2958  {
2959 +    UINT16                 Tmp16;
2960
2961      /* Dump the GpioIo-specific portion of the descriptor */
2962
2963      /* Shared, PinConfig */
2964
2965      AcpiDmIndent (Level);
2966 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags);
2967      AcpiOsPrintf ("GpioIo (%s, ",
2968 -        AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]);
2969 +        AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Tmp16, 3)]);
2970
2971      if (Resource->Gpio.PinConfig <= 3)
2972      {
2973 @@ -350,10 +366,13 @@ AcpiDmGpioIoDescriptor (
2974
2975      /* DebounceTimeout, DriveStrength, IoRestriction */
2976
2977 -    AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DebounceTimeout);
2978 -    AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DriveStrength);
2979 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DebounceTimeout);
2980 +    AcpiOsPrintf ("0x%4.4X, ", Tmp16);
2981 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.DriveStrength);
2982 +    AcpiOsPrintf ("0x%4.4X, ", Tmp16);
2983 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Gpio.IntFlags);
2984      AcpiOsPrintf ("%s,\n",
2985 -        AcpiGbl_IorDecode [ACPI_GET_2BIT_FLAG (Resource->Gpio.IntFlags)]);
2986 +        AcpiGbl_IorDecode [ACPI_GET_2BIT_FLAG (Tmp16)]);
2987
2988      /* Dump the GpioInt/GpioIo common portion of the descriptor */
2989
2990 @@ -427,6 +446,7 @@ AcpiDmDumpSerialBusVendorData (
2991  {
2992      UINT8                   *VendorData;
2993      UINT32                  VendorLength;
2994 +    UINT16                  Tmp16;
2995
2996
2997      /* Get the (optional) vendor data and length */
2998 @@ -435,8 +455,8 @@ AcpiDmDumpSerialBusVendorData (
2999      {
3000      case AML_RESOURCE_I2C_SERIALBUSTYPE:
3001
3002 -        VendorLength = Resource->CommonSerialBus.TypeDataLength -
3003 -            AML_RESOURCE_I2C_MIN_DATA_LEN;
3004 +       ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength);
3005 +        VendorLength = Tmp16 - AML_RESOURCE_I2C_MIN_DATA_LEN;
3006
3007          VendorData = ACPI_ADD_PTR (UINT8, Resource,
3008              sizeof (AML_RESOURCE_I2C_SERIALBUS));
3009 @@ -444,8 +464,8 @@ AcpiDmDumpSerialBusVendorData (
3010
3011      case AML_RESOURCE_SPI_SERIALBUSTYPE:
3012
3013 -        VendorLength = Resource->CommonSerialBus.TypeDataLength -
3014 -            AML_RESOURCE_SPI_MIN_DATA_LEN;
3015 +       ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength);
3016 +        VendorLength = Tmp16 - AML_RESOURCE_SPI_MIN_DATA_LEN;
3017
3018          VendorData = ACPI_ADD_PTR (UINT8, Resource,
3019              sizeof (AML_RESOURCE_SPI_SERIALBUS));
3020 @@ -453,8 +473,8 @@ AcpiDmDumpSerialBusVendorData (
3021
3022      case AML_RESOURCE_UART_SERIALBUSTYPE:
3023
3024 -        VendorLength = Resource->CommonSerialBus.TypeDataLength -
3025 -            AML_RESOURCE_UART_MIN_DATA_LEN;
3026 +       ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength);
3027 +        VendorLength = Tmp16 - AML_RESOURCE_UART_MIN_DATA_LEN;
3028
3029          VendorData = ACPI_ADD_PTR (UINT8, Resource,
3030              sizeof (AML_RESOURCE_UART_SERIALBUS));
3031 @@ -495,15 +515,19 @@ AcpiDmI2cSerialBusDescriptor (
3032  {
3033      UINT32                  ResourceSourceOffset;
3034      char                    *DeviceName;
3035 +    UINT16                 Tmp16;
3036 +    UINT32                 Tmp32;
3037
3038
3039      /* SlaveAddress, SlaveMode, ConnectionSpeed, AddressingMode */
3040
3041 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->I2cSerialBus.SlaveAddress);
3042 +    ACPI_MOVE_32_TO_32(&Tmp32, &Resource->I2cSerialBus.ConnectionSpeed);
3043      AcpiDmIndent (Level);
3044      AcpiOsPrintf ("I2cSerialBusV2 (0x%4.4X, %s, 0x%8.8X,\n",
3045 -        Resource->I2cSerialBus.SlaveAddress,
3046 +        Tmp16,
3047          AcpiGbl_SmDecode [ACPI_GET_1BIT_FLAG (Resource->I2cSerialBus.Flags)],
3048 -        Resource->I2cSerialBus.ConnectionSpeed);
3049 +        Tmp32);
3050
3051      AcpiDmIndent (Level + 1);
3052      AcpiOsPrintf ("%s, ",
3053 @@ -511,8 +535,8 @@ AcpiDmI2cSerialBusDescriptor (
3054
3055      /* ResourceSource is a required field */
3056
3057 -    ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
3058 -        Resource->CommonSerialBus.TypeDataLength;
3059 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->CommonSerialBus.TypeDataLength);
3060 +    ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) + Tmp16;
3061
3062      DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
3063      AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
3064 Index: acpica-unix2-20170303/source/components/disassembler/dmresrcl.c
3065 ===================================================================
3066 --- acpica-unix2-20170303.orig/source/components/disassembler/dmresrcl.c
3067 +++ acpica-unix2-20170303/source/components/disassembler/dmresrcl.c
3068 @@ -141,7 +141,8 @@ AcpiDmMemoryFields (
3069      UINT32                  Level)
3070  {
3071      UINT32                  i;
3072 -
3073 +    UINT16                 Tmp16;
3074 +    UINT32                 Tmp32;
3075
3076      for (i = 0; i < 4; i++)
3077      {
3078 @@ -151,14 +152,14 @@ AcpiDmMemoryFields (
3079          {
3080          case 16:
3081
3082 -            AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
3083 -                AcpiDmMemoryNames[i]);
3084 +           ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i]));
3085 +            AcpiDmDumpInteger16 (Tmp16, AcpiDmMemoryNames[i]);
3086              break;
3087
3088          case 32:
3089
3090 -            AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
3091 -                AcpiDmMemoryNames[i]);
3092 +           ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i]));
3093 +            AcpiDmDumpInteger32 (Tmp32, AcpiDmMemoryNames[i]);
3094              break;
3095
3096          default:
3097 @@ -190,7 +191,9 @@ AcpiDmAddressFields (
3098      UINT32                  Level)
3099  {
3100      UINT32                  i;
3101 -
3102 +    UINT16                 Tmp16;
3103 +    UINT32                 Tmp32;
3104 +    UINT64                 Tmp64;
3105
3106      AcpiOsPrintf ("\n");
3107
3108 @@ -202,20 +205,20 @@ AcpiDmAddressFields (
3109          {
3110          case 16:
3111
3112 -            AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
3113 -                AcpiDmAddressNames[i]);
3114 +           ACPI_MOVE_16_TO_16(&Tmp16, &(ACPI_CAST_PTR (UINT16, Source)[i]));
3115 +            AcpiDmDumpInteger16 (Tmp16, AcpiDmAddressNames[i]);
3116              break;
3117
3118          case 32:
3119
3120 -            AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
3121 -                AcpiDmAddressNames[i]);
3122 +           ACPI_MOVE_32_TO_32(&Tmp32, &(ACPI_CAST_PTR (UINT32, Source)[i]));
3123 +            AcpiDmDumpInteger32 (Tmp32, AcpiDmAddressNames[i]);
3124              break;
3125
3126          case 64:
3127
3128 -            AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i],
3129 -                AcpiDmAddressNames[i]);
3130 +           ACPI_MOVE_64_TO_64(&Tmp64, &(ACPI_CAST_PTR (UINT64, Source)[i]));
3131 +            AcpiDmDumpInteger64 (Tmp64, AcpiDmAddressNames[i]);
3132              break;
3133
3134          default:
3135 @@ -868,6 +871,7 @@ AcpiDmFixedMemory32Descriptor (
3136      UINT32                  Length,
3137      UINT32                  Level)
3138  {
3139 +    UINT32 Tmp;
3140
3141      /* Dump name and read/write flag */
3142
3143 @@ -876,12 +880,12 @@ AcpiDmFixedMemory32Descriptor (
3144          AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->FixedMemory32.Flags)]);
3145
3146      AcpiDmIndent (Level + 1);
3147 -    AcpiDmDumpInteger32 (Resource->FixedMemory32.Address,
3148 -        "Address Base");
3149 +    ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.Address);
3150 +    AcpiDmDumpInteger32 (Tmp, "Address Base");
3151
3152      AcpiDmIndent (Level + 1);
3153 -    AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength,
3154 -        "Address Length");
3155 +    ACPI_MOVE_32_TO_32(&Tmp, &Resource->FixedMemory32.AddressLength);
3156 +    AcpiDmDumpInteger32 (Tmp, "Address Length");
3157
3158      /* Insert a descriptor name */
3159
3160 @@ -913,6 +917,7 @@ AcpiDmGenericRegisterDescriptor (
3161      UINT32                  Length,
3162      UINT32                  Level)
3163  {
3164 +    UINT64                 Tmp64;
3165
3166      AcpiDmIndent (Level);
3167      AcpiOsPrintf ("Register (");
3168 @@ -926,7 +931,9 @@ AcpiDmGenericRegisterDescriptor (
3169      AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset");
3170
3171      AcpiDmIndent (Level + 1);
3172 -    AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address");
3173 +    /* AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address"); */
3174 +    ACPI_MOVE_64_TO_64(&Tmp64, &Resource->GenericReg.Address);
3175 +    AcpiDmDumpInteger64 (Tmp64, "Address");
3176
3177      /* Optional field for ACPI 3.0 */
3178
3179 @@ -972,7 +979,7 @@ AcpiDmInterruptDescriptor (
3180      UINT32                  Level)
3181  {
3182      UINT32                  i;
3183 -
3184 +    UINT16                 Tmp16;
3185
3186      AcpiDmIndent (Level);
3187      AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ",
3188 @@ -986,10 +993,11 @@ AcpiDmInterruptDescriptor (
3189       * list. Must compute length based on length of the list. First xrupt
3190       * is included in the struct (reason for -1 below)
3191       */
3192 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->ExtendedIrq.ResourceLength);
3193      AcpiDmResourceSource (Resource,
3194          sizeof (AML_RESOURCE_EXTENDED_IRQ) +
3195              ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32),
3196 -        Resource->ExtendedIrq.ResourceLength);
3197 +        Tmp16);
3198
3199      /* Insert a descriptor name */
3200
3201 @@ -1002,9 +1010,12 @@ AcpiDmInterruptDescriptor (
3202      AcpiOsPrintf ("{\n");
3203      for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++)
3204      {
3205 +       UINT32 Tmp32, Val32;
3206 +
3207          AcpiDmIndent (Level + 1);
3208 -        AcpiOsPrintf ("0x%8.8X,\n",
3209 -            (UINT32) Resource->ExtendedIrq.Interrupts[i]);
3210 +       Val32 = (UINT32) Resource->ExtendedIrq.Interrupts[i];
3211 +       ACPI_MOVE_32_TO_32(&Tmp32, &Val32);
3212 +        AcpiOsPrintf ("0x%8.8X,\n", Tmp32);
3213      }
3214
3215      AcpiDmIndent (Level);
3216 Index: acpica-unix2-20170303/source/components/disassembler/dmresrcs.c
3217 ===================================================================
3218 --- acpica-unix2-20170303.orig/source/components/disassembler/dmresrcs.c
3219 +++ acpica-unix2-20170303/source/components/disassembler/dmresrcs.c
3220 @@ -72,6 +72,7 @@ AcpiDmIrqDescriptor (
3221      UINT32                  Length,
3222      UINT32                  Level)
3223  {
3224 +    UINT16 Tmp;
3225
3226      AcpiDmIndent (Level);
3227      AcpiOsPrintf ("%s (",
3228 @@ -93,7 +94,8 @@ AcpiDmIrqDescriptor (
3229      AcpiOsPrintf (")\n");
3230
3231      AcpiDmIndent (Level + 1);
3232 -    AcpiDmBitList (Resource->Irq.IrqMask);
3233 +    ACPI_MOVE_16_TO_16(&Tmp, &Resource->Irq.IrqMask);
3234 +    AcpiDmBitList (Tmp);
3235  }
3236
3237
3238 @@ -204,16 +206,19 @@ AcpiDmIoDescriptor (
3239      UINT32                  Length,
3240      UINT32                  Level)
3241  {
3242 +    UINT16 Tmp16;
3243
3244      AcpiDmIndent (Level);
3245      AcpiOsPrintf ("IO (%s,\n",
3246          AcpiGbl_IoDecode [ACPI_GET_1BIT_FLAG (Resource->Io.Flags)]);
3247
3248      AcpiDmIndent (Level + 1);
3249 -    AcpiDmDumpInteger16 (Resource->Io.Minimum, "Range Minimum");
3250 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Minimum);
3251 +    AcpiDmDumpInteger16 (Tmp16, "Range Minimum");
3252
3253      AcpiDmIndent (Level + 1);
3254 -    AcpiDmDumpInteger16 (Resource->Io.Maximum, "Range Maximum");
3255 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->Io.Maximum);
3256 +    AcpiDmDumpInteger16 (Tmp16, "Range Maximum");
3257
3258      AcpiDmIndent (Level + 1);
3259      AcpiDmDumpInteger8 (Resource->Io.Alignment, "Alignment");
3260 @@ -251,12 +256,14 @@ AcpiDmFixedIoDescriptor (
3261      UINT32                  Length,
3262      UINT32                  Level)
3263  {
3264 +    UINT16                  Tmp16;
3265
3266      AcpiDmIndent (Level);
3267      AcpiOsPrintf ("FixedIO (\n");
3268
3269      AcpiDmIndent (Level + 1);
3270 -    AcpiDmDumpInteger16 (Resource->FixedIo.Address, "Address");
3271 +    ACPI_MOVE_16_TO_16(&Tmp16, &Resource->FixedIo.Address);
3272 +    AcpiDmDumpInteger16 (Tmp16, "Address");
3273
3274      AcpiDmIndent (Level + 1);
3275      AcpiDmDumpInteger8 (Resource->FixedIo.AddressLength, "Length");
3276 Index: acpica-unix2-20170303/source/components/dispatcher/dsfield.c
3277 ===================================================================
3278 --- acpica-unix2-20170303.orig/source/components/dispatcher/dsfield.c
3279 +++ acpica-unix2-20170303/source/components/dispatcher/dsfield.c
3280 @@ -318,6 +318,7 @@ AcpiDsGetFieldNames (
3281      ACPI_STATUS             Status;
3282      UINT64                  Position;
3283      ACPI_PARSE_OBJECT       *Child;
3284 +    UINT32 TmpName;
3285
3286
3287      ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info);
3288 @@ -424,10 +425,17 @@ AcpiDsGetFieldNames (
3289
3290              /* Lookup the name, it should already exist */
3291
3292 +           ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name);
3293 +            Status = AcpiNsLookup (WalkState->ScopeInfo,
3294 +                (char *) &TmpName, Info->FieldType,
3295 +                ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
3296 +                WalkState, &Info->FieldNode);
3297 +       /*
3298              Status = AcpiNsLookup (WalkState->ScopeInfo,
3299                  (char *) &Arg->Named.Name, Info->FieldType,
3300                  ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
3301                  WalkState, &Info->FieldNode);
3302 +       */
3303              if (ACPI_FAILURE (Status))
3304              {
3305                  ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
3306 @@ -652,9 +660,17 @@ AcpiDsInitFieldObjects (
3307           */
3308          if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)
3309          {
3310 +           UINT32 TmpName;
3311 +
3312 +            ACPI_MOVE_32_TO_32(&TmpName, &Arg->Named.Name);
3313 +            Status = AcpiNsLookup (WalkState->ScopeInfo,
3314 +                (char *) &TmpName, Type, ACPI_IMODE_LOAD_PASS1,
3315 +                Flags, WalkState, &Node);
3316 +       /*
3317              Status = AcpiNsLookup (WalkState->ScopeInfo,
3318                  (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1,
3319                  Flags, WalkState, &Node);
3320 +       */
3321              if (ACPI_FAILURE (Status))
3322              {
3323                  ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
3324 Index: acpica-unix2-20170303/source/components/events/evgpeblk.c
3325 ===================================================================
3326 --- acpica-unix2-20170303.orig/source/components/events/evgpeblk.c
3327 +++ acpica-unix2-20170303/source/components/events/evgpeblk.c
3328 @@ -376,6 +376,7 @@ AcpiEvCreateGpeBlock (
3329      ACPI_STATUS             Status;
3330      ACPI_GPE_BLOCK_INFO     *GpeBlock;
3331      ACPI_GPE_WALK_INFO      WalkInfo;
3332 +    char                   Name[ACPI_NAME_SIZE + 1];
3333
3334
3335      ACPI_FUNCTION_TRACE (EvCreateGpeBlock);
3336 @@ -396,7 +397,7 @@ AcpiEvCreateGpeBlock (
3337
3338      /* Initialize the new GPE block */
3339
3340 -    GpeBlock->Address = Address;
3341 +    ACPI_MOVE_64_TO_64(&GpeBlock->Address, &Address);
3342      GpeBlock->SpaceId = SpaceId;
3343      GpeBlock->Node = GpeDevice;
3344      GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
3345 @@ -445,11 +446,13 @@ AcpiEvCreateGpeBlock (
3346          (*ReturnGpeBlock) = GpeBlock;
3347      }
3348
3349 +    memset(&Name, 0, ACPI_NAME_SIZE + 1);
3350 +    ACPI_MOVE_32_TO_32(&Name, &GpeDevice->Name.Ascii);
3351      ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
3352          "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
3353          (UINT32) GpeBlock->BlockBaseNumber,
3354          (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
3355 -        GpeDevice->Name.Ascii, GpeBlock->RegisterCount, InterruptNumber,
3356 +        Name, GpeBlock->RegisterCount, InterruptNumber,
3357          InterruptNumber == AcpiGbl_FADT.SciInterrupt ? " (SCI)" : ""));
3358
3359      /* Update global count of currently available GPEs */
3360 Index: acpica-unix2-20170303/source/components/hardware/hwregs.c
3361 ===================================================================
3362 --- acpica-unix2-20170303.orig/source/components/hardware/hwregs.c
3363 +++ acpica-unix2-20170303/source/components/hardware/hwregs.c
3364 @@ -197,7 +197,7 @@ AcpiHwValidateRegister (
3365       * Address must not be null. A null address also indicates an optional
3366       * ACPI register that is not supported, so no error message.
3367       */
3368 -    ACPI_MOVE_64_TO_64 (Address, &Reg->Address);
3369 +    *Address =  Reg->Address;
3370      if (!(*Address))
3371      {
3372          return (AE_BAD_ADDRESS);
3373 Index: acpica-unix2-20170303/source/components/hardware/hwvalid.c
3374 ===================================================================
3375 --- acpica-unix2-20170303.orig/source/components/hardware/hwvalid.c
3376 +++ acpica-unix2-20170303/source/components/hardware/hwvalid.c
3377 @@ -135,6 +135,8 @@ AcpiHwValidateIoRequest (
3378      UINT32                  ByteWidth;
3379      ACPI_IO_ADDRESS         LastAddress;
3380      const ACPI_PORT_INFO    *PortInfo;
3381 +    UINT64                  Max16;
3382 +    UINT64                  Tmp64;
3383
3384
3385      ACPI_FUNCTION_NAME (HwValidateIoRequest);
3386 @@ -161,7 +163,10 @@ AcpiHwValidateIoRequest (
3387
3388      /* Maximum 16-bit address in I/O space */
3389
3390 -    if (LastAddress > ACPI_UINT16_MAX)
3391 +    Max16 = (UINT64) ACPI_UINT16_MAX;
3392 +    ACPI_MOVE_64_TO_64(&Tmp64, &Max16);
3393 +
3394 +    if ((UINT64)LastAddress > Tmp64)
3395      {
3396          ACPI_ERROR ((AE_INFO,
3397              "Illegal I/O port address/length above 64K: %8.8X%8.8X/0x%X",
3398 Index: acpica-unix2-20170303/source/components/namespace/nsaccess.c
3399 ===================================================================
3400 --- acpica-unix2-20170303.orig/source/components/namespace/nsaccess.c
3401 +++ acpica-unix2-20170303/source/components/namespace/nsaccess.c
3402 @@ -309,6 +309,7 @@ AcpiNsLookup (
3403      ACPI_OBJECT_TYPE        ThisSearchType;
3404      UINT32                  SearchParentFlag = ACPI_NS_SEARCH_PARENT;
3405      UINT32                  LocalFlags;
3406 +    UINT32                 Tmp32;
3407
3408
3409      ACPI_FUNCTION_TRACE (NsLookup);
3410 @@ -657,9 +658,10 @@ AcpiNsLookup (
3411              {
3412                  /* Complain about a type mismatch */
3413
3414 +               ACPI_MOVE_32_TO_32(&Tmp32, &SimpleName);
3415                  ACPI_WARNING ((AE_INFO,
3416                      "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
3417 -                    ACPI_CAST_PTR (char, &SimpleName),
3418 +                    ACPI_CAST_PTR (char, &Tmp32),
3419                      AcpiUtGetTypeName (ThisNode->Type),
3420                      AcpiUtGetTypeName (TypeToCheckFor)));
3421              }
3422 Index: acpica-unix2-20170303/source/components/namespace/nsparse.c
3423 ===================================================================
3424 --- acpica-unix2-20170303.orig/source/components/namespace/nsparse.c
3425 +++ acpica-unix2-20170303/source/components/namespace/nsparse.c
3426 @@ -196,13 +196,14 @@ AcpiNsOneCompleteParse (
3427
3428      /* Table must consist of at least a complete header */
3429
3430 -    if (Table->Length < sizeof (ACPI_TABLE_HEADER))
3431 +    ACPI_MOVE_32_TO_32(&AmlLength, &Table->Length);
3432 +    if (AmlLength < sizeof (ACPI_TABLE_HEADER))
3433      {
3434          return_ACPI_STATUS (AE_BAD_HEADER);
3435      }
3436
3437      AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);
3438 -    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
3439 +    AmlLength -= sizeof (ACPI_TABLE_HEADER);
3440
3441      Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);
3442      if (ACPI_FAILURE (Status))
3443 Index: acpica-unix2-20170303/source/components/tables/tbdata.c
3444 ===================================================================
3445 --- acpica-unix2-20170303.orig/source/components/tables/tbdata.c
3446 +++ acpica-unix2-20170303/source/components/tables/tbdata.c
3447 @@ -407,6 +407,7 @@ AcpiTbVerifyTempTable (
3448      char                    *Signature)
3449  {
3450      ACPI_STATUS             Status = AE_OK;
3451 +    UINT32                 Length;
3452
3453
3454      ACPI_FUNCTION_TRACE (TbVerifyTempTable);
3455 @@ -436,7 +437,8 @@ AcpiTbVerifyTempTable (
3456
3457      if (AcpiGbl_VerifyTableChecksum)
3458      {
3459 -        Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length);
3460 +       ACPI_MOVE_32_TO_32(&Length, &TableDesc->Length);
3461 +        Status = AcpiTbVerifyChecksum (TableDesc->Pointer, Length);
3462          if (ACPI_FAILURE (Status))
3463          {
3464              ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY,
3465 Index: acpica-unix2-20170303/source/components/tables/tbfadt.c
3466 ===================================================================
3467 --- acpica-unix2-20170303.orig/source/components/tables/tbfadt.c
3468 +++ acpica-unix2-20170303/source/components/tables/tbfadt.c
3469 @@ -520,6 +520,8 @@ AcpiTbConvertFadt (
3470      UINT8                   Length;
3471      UINT8                   Flags;
3472      UINT32                  i;
3473 +    UINT32                 Tmp32;
3474 +    UINT64                 Tmp64;
3475
3476
3477      /*
3478 @@ -533,7 +535,8 @@ AcpiTbConvertFadt (
3479       * Note: The FADT revision value is unreliable. Only the length can be
3480       * trusted.
3481       */
3482 -    if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
3483 +    ACPI_MOVE_32_TO_32(&Tmp32, &AcpiGbl_FADT.Header.Length);
3484 +    if (Tmp32 <= ACPI_FADT_V2_SIZE)
3485      {
3486          AcpiGbl_FADT.PreferredProfile = 0;
3487          AcpiGbl_FADT.PstateControl = 0;
3488 @@ -546,14 +549,15 @@ AcpiTbConvertFadt (
3489       * current FADT version as defined by the ACPI specification.
3490       * Thus, we will have a common FADT internally.
3491       */
3492 -    AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT);
3493 +    Tmp32 = sizeof (ACPI_TABLE_FADT);
3494 +    ACPI_MOVE_32_TO_32(&AcpiGbl_FADT.Header.Length, &Tmp32);
3495
3496      /*
3497       * Expand the 32-bit DSDT addresses to 64-bit as necessary.
3498       * Later ACPICA code will always use the X 64-bit field.
3499       */
3500 -    AcpiGbl_FADT.XDsdt = AcpiTbSelectAddress ("DSDT",
3501 -        AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
3502 +    Tmp64 = AcpiTbSelectAddress ("DSDT", AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
3503 +    ACPI_MOVE_64_TO_64(&AcpiGbl_FADT.XDsdt, &Tmp64);
3504
3505      /* If Hardware Reduced flag is set, we are all done */
3506
3507 @@ -614,7 +618,9 @@ AcpiTbConvertFadt (
3508          {
3509              if (Address64->Address)
3510              {
3511 -                if (Address64->Address != (UINT64) Address32)
3512 +               ACPI_MOVE_32_TO_32(&Tmp32, &Address32);
3513 +               ACPI_MOVE_64_TO_64(&Tmp64, &Address64->Address);
3514 +                if (Tmp64 != (UINT64) Tmp32)
3515                  {
3516                      /* Address mismatch */
3517
3518 @@ -655,9 +661,11 @@ AcpiTbConvertFadt (
3519               */
3520              if (!Address64->Address || AcpiGbl_Use32BitFadtAddresses)
3521              {
3522 +               ACPI_MOVE_32_TO_32(&Tmp32, &Address32); /* back to host order */
3523 +               Tmp64 = (UINT64) Tmp32;                 /* promote only */
3524                  AcpiTbInitGenericAddress (Address64,
3525                      ACPI_ADR_SPACE_SYSTEM_IO, Length,
3526 -                    (UINT64) Address32, Name, Flags);
3527 +                    Tmp64, Name, Flags);
3528              }
3529          }
3530
3531 @@ -780,10 +788,14 @@ AcpiTbSetupFadtRegisters (
3532
3533          if (Source64->Address)
3534          {
3535 +           UINT64 Tmp64, Addr64;
3536 +
3537 +           ACPI_MOVE_64_TO_64(&Tmp64, &Source64->Address);
3538 +           Tmp64 += (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth);
3539 +           ACPI_MOVE_64_TO_64(&Addr64, &Tmp64);
3540              AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target,
3541                  Source64->SpaceId, Pm1RegisterByteWidth,
3542 -                Source64->Address +
3543 -                    (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth),
3544 +                Addr64,
3545                  "PmRegisters", 0);
3546          }
3547      }
3548 Index: acpica-unix2-20170303/source/components/tables/tbfind.c
3549 ===================================================================
3550 --- acpica-unix2-20170303.orig/source/components/tables/tbfind.c
3551 +++ acpica-unix2-20170303/source/components/tables/tbfind.c
3552 @@ -108,8 +108,11 @@ AcpiTbFindTable (
3553      (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
3554      for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
3555      {
3556 +        UINT32 Tmp32;
3557 +
3558 +        ACPI_MOVE_32_TO_32(&Tmp32, &Header.Signature);
3559          if (memcmp (&(AcpiGbl_RootTableList.Tables[i].Signature),
3560 -            Header.Signature, ACPI_NAME_SIZE))
3561 +            &Tmp32, ACPI_NAME_SIZE))
3562          {
3563              /* Not the requested table */
3564
3565 Index: acpica-unix2-20170303/source/components/tables/tbprint.c
3566 ===================================================================
3567 --- acpica-unix2-20170303.orig/source/components/tables/tbprint.c
3568 +++ acpica-unix2-20170303/source/components/tables/tbprint.c
3569 @@ -143,15 +143,18 @@ AcpiTbPrintTableHeader (
3570      ACPI_TABLE_HEADER       *Header)
3571  {
3572      ACPI_TABLE_HEADER       LocalHeader;
3573 +    UINT32                 Len;
3574 +    UINT32                 OemRev;
3575 +    UINT32                 CompilerRev;
3576
3577
3578      if (ACPI_COMPARE_NAME (Header->Signature, ACPI_SIG_FACS))
3579      {
3580          /* FACS only has signature and length fields */
3581
3582 +       ACPI_MOVE_32_TO_32(&Len, &Header->Length);
3583          ACPI_INFO (("%-4.4s 0x%8.8X%8.8X %06X",
3584 -            Header->Signature, ACPI_FORMAT_UINT64 (Address),
3585 -            Header->Length));
3586 +            Header->Signature, ACPI_FORMAT_UINT64 (Address), Len));
3587      }
3588      else if (ACPI_VALIDATE_RSDP_SIG (Header->Signature))
3589      {
3590 @@ -174,13 +177,16 @@ AcpiTbPrintTableHeader (
3591
3592          AcpiTbCleanupTableHeader (&LocalHeader, Header);
3593
3594 +       ACPI_MOVE_32_TO_32(&Len, &LocalHeader.Length);
3595 +       ACPI_MOVE_32_TO_32(&OemRev, &LocalHeader.OemRevision);
3596 +       ACPI_MOVE_32_TO_32(&CompilerRev, &LocalHeader.AslCompilerRevision);
3597          ACPI_INFO ((
3598              "%-4.4s 0x%8.8X%8.8X"
3599              " %06X (v%.2d %-6.6s %-8.8s %08X %-4.4s %08X)",
3600              LocalHeader.Signature, ACPI_FORMAT_UINT64 (Address),
3601 -            LocalHeader.Length, LocalHeader.Revision, LocalHeader.OemId,
3602 -            LocalHeader.OemTableId, LocalHeader.OemRevision,
3603 -            LocalHeader.AslCompilerId, LocalHeader.AslCompilerRevision));
3604 +            Len, LocalHeader.Revision, LocalHeader.OemId,
3605 +            LocalHeader.OemTableId, OemRev,
3606 +            LocalHeader.AslCompilerId, CompilerRev));
3607      }
3608  }
3609
3610 Index: acpica-unix2-20170303/source/components/tables/tbutils.c
3611 ===================================================================
3612 --- acpica-unix2-20170303.orig/source/components/tables/tbutils.c
3613 +++ acpica-unix2-20170303/source/components/tables/tbutils.c
3614 @@ -238,7 +238,7 @@ AcpiTbGetRootTableEntry (
3615           * 64-bit platform, XSDT: Move (unaligned) 64-bit to local,
3616           *  return 64-bit
3617           */
3618 -        ACPI_MOVE_64_TO_64 (&Address64, TableEntry);
3619 +       Address64 = (UINT64) TableEntry;
3620
3621  #if ACPI_MACHINE_WIDTH == 32
3622          if (Address64 > ACPI_UINT32_MAX)
3623 @@ -251,7 +251,8 @@ AcpiTbGetRootTableEntry (
3624                  ACPI_FORMAT_UINT64 (Address64)));
3625          }
3626  #endif
3627 -        return ((ACPI_PHYSICAL_ADDRESS) (Address64));
3628 +        return ((ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST_PTR (
3629 +            UINT64, Address64)));
3630      }
3631  }
3632
3633 @@ -287,6 +288,7 @@ AcpiTbParseRootTable (
3634      UINT8                   *TableEntry;
3635      ACPI_STATUS             Status;
3636      UINT32                  TableIndex;
3637 +    UINT32                  Tmp32;
3638
3639
3640      ACPI_FUNCTION_TRACE (TbParseRootTable);
3641 @@ -345,7 +347,7 @@ AcpiTbParseRootTable (
3642       * Validate length of the table, and map entire table.
3643       * Minimum length table must contain at least one entry.
3644       */
3645 -    Length = Table->Length;
3646 +    ACPI_MOVE_32_TO_32(&Length, &Table->Length);
3647      AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER));
3648
3649      if (Length < (sizeof (ACPI_TABLE_HEADER) + TableEntrySize))
3650 @@ -372,7 +374,7 @@ AcpiTbParseRootTable (
3651
3652      /* Get the number of entries and pointer to first entry */
3653
3654 -    TableCount = (UINT32) ((Table->Length - sizeof (ACPI_TABLE_HEADER)) /
3655 +    TableCount = (UINT32) ((Length - sizeof (ACPI_TABLE_HEADER)) /
3656          TableEntrySize);
3657      TableEntry = ACPI_ADD_PTR (UINT8, Table, sizeof (ACPI_TABLE_HEADER));
3658
3659 @@ -394,10 +396,10 @@ AcpiTbParseRootTable (
3660          Status = AcpiTbInstallStandardTable (Address,
3661              ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE, &TableIndex);
3662
3663 +       ACPI_MOVE_32_TO_32(&Tmp32,
3664 +                          &AcpiGbl_RootTableList.Tables[TableIndex].Signature);
3665          if (ACPI_SUCCESS (Status) &&
3666 -            ACPI_COMPARE_NAME (
3667 -                &AcpiGbl_RootTableList.Tables[TableIndex].Signature,
3668 -                ACPI_SIG_FADT))
3669 +            ACPI_COMPARE_NAME (&Tmp32, ACPI_SIG_FADT))
3670          {
3671              AcpiGbl_FadtIndex = TableIndex;
3672              AcpiTbParseFadt ();
3673 Index: acpica-unix2-20170303/source/components/tables/tbxface.c
3674 ===================================================================
3675 --- acpica-unix2-20170303.orig/source/components/tables/tbxface.c
3676 +++ acpica-unix2-20170303/source/components/tables/tbxface.c
3677 @@ -263,8 +263,11 @@ AcpiGetTableHeader (
3678
3679      for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
3680      {
3681 +       UINT32 Tmp32;
3682 +
3683 +       ACPI_MOVE_32_TO_32(&Tmp32, (UINT32 *)Signature);
3684          if (!ACPI_COMPARE_NAME (
3685 -                &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
3686 +                &(AcpiGbl_RootTableList.Tables[i].Signature), &Tmp32))
3687          {
3688              continue;
3689          }
3690 Index: acpica-unix2-20170303/source/components/tables/tbxfload.c
3691 ===================================================================
3692 --- acpica-unix2-20170303.orig/source/components/tables/tbxfload.c
3693 +++ acpica-unix2-20170303/source/components/tables/tbxfload.c
3694 @@ -156,6 +156,7 @@ AcpiTbLoadNamespace (
3695      ACPI_TABLE_DESC         *Table;
3696      UINT32                  TablesLoaded = 0;
3697      UINT32                  TablesFailed = 0;
3698 +    UINT32                 Tmp32;
3699
3700
3701      ACPI_FUNCTION_TRACE (TbLoadNamespace);
3702 @@ -169,8 +170,9 @@ AcpiTbLoadNamespace (
3703       */
3704      Table = &AcpiGbl_RootTableList.Tables[AcpiGbl_DsdtIndex];
3705
3706 +    ACPI_MOVE_32_TO_32(&Tmp32, &Table->Signature.Ascii);
3707      if (!AcpiGbl_RootTableList.CurrentTableCount ||
3708 -        !ACPI_COMPARE_NAME (Table->Signature.Ascii, ACPI_SIG_DSDT) ||
3709 +        !ACPI_COMPARE_NAME (&Tmp32, ACPI_SIG_DSDT) ||
3710           ACPI_FAILURE (AcpiTbValidateTable (Table)))
3711      {
3712          Status = AE_NO_ACPI_TABLES;
3713 Index: acpica-unix2-20170303/source/include/acmacros.h
3714 ===================================================================
3715 --- acpica-unix2-20170303.orig/source/include/acmacros.h
3716 +++ acpica-unix2-20170303/source/include/acmacros.h
3717 @@ -98,7 +98,9 @@
3718                                             ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
3719                                             ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
3720
3721 -/* 32-bit source, 16/32/64 destination */
3722 +/* 32-bit source, 8/16/32/64 destination */
3723 +
3724 +#define ACPI_MOVE_32_TO_8(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];}
3725
3726  #define ACPI_MOVE_32_TO_16(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\
3727                                           ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];}
3728 @@ -114,7 +116,9 @@
3729                                             ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
3730                                             ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
3731
3732 -/* 64-bit source, 16/32/64 destination */
3733 +/* 64-bit source, 8/16/32/64 destination */
3734 +
3735 +#define ACPI_MOVE_64_TO_8(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];}
3736
3737  #define ACPI_MOVE_64_TO_16(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\
3738                                           ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];}
3739 @@ -141,13 +145,16 @@
3740
3741  /* The hardware supports unaligned transfers, just do the little-endian move */
3742
3743 -/* 16-bit source, 16/32/64 destination */
3744 +/* 16-bit source, 8/16/32/64 destination */
3745
3746 +#define ACPI_MOVE_16_TO_8(d, s)         *(UINT8 *)(void *)(d) = *(UINT16 *)(void *)(s)
3747  #define ACPI_MOVE_16_TO_16(d, s)        *(UINT16 *)(void *)(d) = *(UINT16 *)(void *)(s)
3748  #define ACPI_MOVE_16_TO_32(d, s)        *(UINT32 *)(void *)(d) = *(UINT16 *)(void *)(s)
3749  #define ACPI_MOVE_16_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT16 *)(void *)(s)
3750
3751 -/* 32-bit source, 16/32/64 destination */
3752 +/* 32-bit source, 8/16/32/64 destination */
3753 +
3754 +#define ACPI_MOVE_32_TO_8(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];}
3755
3756  #define ACPI_MOVE_32_TO_16(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
3757                                           ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];}
3758 @@ -155,8 +162,9 @@
3759  #define ACPI_MOVE_32_TO_32(d, s)        *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s)
3760  #define ACPI_MOVE_32_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s)
3761
3762 -/* 64-bit source, 16/32/64 destination */
3763 +/* 64-bit source, 8/16/32/64 destination */
3764
3765 +#define ACPI_MOVE_64_TO_8(d, s)         ACPI_MOVE_16_TO_8(d, s)    /* Truncate to 8 */
3766  #define ACPI_MOVE_64_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
3767  #define ACPI_MOVE_64_TO_32(d, s)        ACPI_MOVE_32_TO_32(d, s)    /* Truncate to 32 */
3768  #define ACPI_MOVE_64_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT64 *)(void *)(s)
3769 @@ -176,7 +184,9 @@
3770  #define ACPI_MOVE_16_TO_32(d, s)        {(*(UINT32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);}
3771  #define ACPI_MOVE_16_TO_64(d, s)        {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);}
3772
3773 -/* 32-bit source, 16/32/64 destination */
3774 +/* 32-bit source, 8/16/32/64 destination */
3775 +
3776 +#define ACPI_MOVE_32_TO_8(d, s)         ACPI_MOVE_16_TO_8(d, s)    /* Truncate to 8 */
3777
3778  #define ACPI_MOVE_32_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
3779
3780 Index: acpica-unix2-20170303/source/include/platform/aclinux.h
3781 ===================================================================
3782 --- acpica-unix2-20170303.orig/source/include/platform/aclinux.h
3783 +++ acpica-unix2-20170303/source/include/platform/aclinux.h
3784 @@ -219,6 +219,10 @@
3785  #define __cdecl
3786  #endif
3787
3788 +#if defined(__PPC64__) || defined(__s390x__)
3789 +#define ACPI_BIG_ENDIAN
3790 +#endif
3791 +
3792  #endif /* __KERNEL__ */
3793
3794  #endif /* __ACLINUX_H__ */
3795 Index: acpica-unix2-20170303/source/tools/acpiexec/aetables.c
3796 ===================================================================
3797 --- acpica-unix2-20170303.orig/source/tools/acpiexec/aetables.c
3798 +++ acpica-unix2-20170303/source/tools/acpiexec/aetables.c
3799 @@ -146,21 +146,25 @@ AeInitializeTableHeader (
3800      char                    *Signature,
3801      UINT32                  Length)
3802  {
3803 +    UINT16                 Tmp16;
3804 +    UINT32                 Tmp32;
3805
3806      ACPI_MOVE_NAME (Header->Signature, Signature);
3807 -    Header->Length = Length;
3808 +    ACPI_MOVE_32_TO_32(&Header->Length, &Length);
3809
3810 -    Header->OemRevision = 0x1001;
3811 +    Tmp16 = 0x1001;
3812 +    ACPI_MOVE_16_TO_16(&Header->OemRevision, &Tmp16);
3813      strncpy (Header->OemId, "Intel", ACPI_OEM_ID_SIZE);
3814      strncpy (Header->OemTableId, "AcpiExec", ACPI_OEM_TABLE_ID_SIZE);
3815      strncpy (Header->AslCompilerId, "INTL", ACPI_NAME_SIZE);
3816 -    Header->AslCompilerRevision = ACPI_CA_VERSION;
3817 +    Tmp32 = ACPI_CA_VERSION;
3818 +    ACPI_MOVE_32_TO_32(&Header->AslCompilerRevision, &Tmp32);
3819
3820      /* Set the checksum, must set to zero first */
3821
3822      Header->Checksum = 0;
3823      Header->Checksum = (UINT8) -AcpiTbChecksum (
3824 -        (void *) Header, Header->Length);
3825 +        (void *) Header, Length);
3826  }
3827
3828
3829 @@ -188,6 +192,7 @@ AeBuildLocalTables (
3830      ACPI_NEW_TABLE_DESC     *NextTable;
3831      UINT32                  NextIndex;
3832      ACPI_TABLE_FADT         *ExternalFadt = NULL;
3833 +    UINT32                 Tmp32;
3834
3835
3836      /*
3837 @@ -374,6 +379,8 @@ AeBuildLocalTables (
3838      }
3839      else
3840      {
3841 +        UINT64             Tmp64;
3842 +
3843          /*
3844           * Build a local FADT so we can test the hardware/event init
3845           */
3846 @@ -385,34 +392,44 @@ AeBuildLocalTables (
3847          LocalFADT.Facs = 0;
3848
3849          LocalFADT.XDsdt = DsdtAddress;
3850 -        LocalFADT.XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
3851 +        Tmp64 = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
3852 +        ACPI_MOVE_64_TO_64(&LocalFADT.XFacs, &Tmp64);
3853
3854          /* Miscellaneous FADT fields */
3855
3856          LocalFADT.Gpe0BlockLength = 0x08;
3857 -        LocalFADT.Gpe0Block = 0x00001234;
3858 +        Tmp32 = 0x00001234;
3859 +        ACPI_MOVE_32_TO_32(&LocalFADT.Gpe0Block, &Tmp32);
3860
3861          LocalFADT.Gpe1BlockLength = 0x80;
3862 -        LocalFADT.Gpe1Block = 0x00005678;
3863 +        Tmp32 = 0x00005678;
3864 +        ACPI_MOVE_32_TO_32(&LocalFADT.Gpe1Block, &Tmp32);
3865          LocalFADT.Gpe1Base = 100;
3866
3867          LocalFADT.Pm1EventLength = 4;
3868 -        LocalFADT.Pm1aEventBlock = 0x00001aaa;
3869 -        LocalFADT.Pm1bEventBlock = 0x00001bbb;
3870 +        Tmp32 = 0x00001aaa;
3871 +        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1aEventBlock, &Tmp32);
3872 +        Tmp32 = 0x00001bbb;
3873 +        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1bEventBlock, &Tmp32);
3874
3875          LocalFADT.Pm1ControlLength = 2;
3876 -        LocalFADT.Pm1aControlBlock = 0xB0;
3877 +        Tmp32 = 0xB0;
3878 +        ACPI_MOVE_32_TO_32(&LocalFADT.Pm1aControlBlock, &Tmp32);
3879
3880          LocalFADT.PmTimerLength = 4;
3881 -        LocalFADT.PmTimerBlock = 0xA0;
3882 +        Tmp32 = 0xA0;
3883 +        ACPI_MOVE_32_TO_32(&LocalFADT.PmTimerBlock, &Tmp32);
3884
3885 -        LocalFADT.Pm2ControlBlock = 0xC0;
3886 +        Tmp32 = 0xC0;
3887 +        ACPI_MOVE_32_TO_32(&LocalFADT.Pm2ControlBlock, &Tmp32);
3888          LocalFADT.Pm2ControlLength = 1;
3889
3890          /* Setup one example X-64 GAS field */
3891
3892          LocalFADT.XPm1bEventBlock.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
3893 -        LocalFADT.XPm1bEventBlock.Address = LocalFADT.Pm1bEventBlock;
3894 +       ACPI_MOVE_32_TO_32(&Tmp32, &LocalFADT.Pm1bEventBlock);
3895 +       Tmp64 = (UINT64)Tmp32;
3896 +        ACPI_MOVE_64_TO_64(&LocalFADT.XPm1bEventBlock.Address, &Tmp64);
3897          LocalFADT.XPm1bEventBlock.BitWidth = (UINT8)
3898              ACPI_MUL_8 (LocalFADT.Pm1EventLength);
3899      }
3900 @@ -425,13 +442,17 @@ AeBuildLocalTables (
3901      memset (&LocalFACS, 0, sizeof (ACPI_TABLE_FACS));
3902      ACPI_MOVE_NAME (LocalFACS.Signature, ACPI_SIG_FACS);
3903
3904 -    LocalFACS.Length = sizeof (ACPI_TABLE_FACS);
3905 -    LocalFACS.GlobalLock = 0x11AA0011;
3906 +    Tmp32 = sizeof (ACPI_TABLE_FACS);
3907 +    ACPI_MOVE_32_TO_32(&LocalFACS.Length, &Tmp32);
3908 +    Tmp32 = 0x11AA0011;
3909 +    ACPI_MOVE_32_TO_32(&LocalFACS.GlobalLock, &Tmp32);
3910
3911      /* Build the optional local tables */
3912
3913      if (AcpiGbl_LoadTestTables)
3914      {
3915 +       UINT32 Tmp32;
3916 +
3917          /*
3918           * Build a fake table [TEST] so that we make sure that the
3919           * ACPICA core ignores it
3920 @@ -440,11 +461,12 @@ AeBuildLocalTables (
3921          ACPI_MOVE_NAME (LocalTEST.Signature, "TEST");
3922
3923          LocalTEST.Revision = 1;
3924 -        LocalTEST.Length = sizeof (ACPI_TABLE_HEADER);
3925 +        Tmp32 = sizeof (ACPI_TABLE_HEADER);
3926 +        ACPI_MOVE_32_TO_32(&LocalTEST.Length, &Tmp32);
3927
3928          LocalTEST.Checksum = 0;
3929          LocalTEST.Checksum = (UINT8) -AcpiTbChecksum (
3930 -            (void *) &LocalTEST, LocalTEST.Length);
3931 +            (void *) &LocalTEST, Tmp32);
3932
3933          /*
3934           * Build a fake table with a bad signature [BAD!] so that we make
3935 @@ -454,11 +476,12 @@ AeBuildLocalTables (
3936          ACPI_MOVE_NAME (LocalBADTABLE.Signature, "BAD!");
3937
3938          LocalBADTABLE.Revision = 1;
3939 -        LocalBADTABLE.Length = sizeof (ACPI_TABLE_HEADER);
3940 +        Tmp32 = sizeof (ACPI_TABLE_HEADER);
3941 +        ACPI_MOVE_32_TO_32(&LocalBADTABLE.Length, &Tmp32);
3942
3943          LocalBADTABLE.Checksum = 0;
3944          LocalBADTABLE.Checksum = (UINT8) -AcpiTbChecksum (
3945 -            (void *) &LocalBADTABLE, LocalBADTABLE.Length);
3946 +            (void *) &LocalBADTABLE, Tmp32);
3947      }
3948
3949      return (AE_OK);