Big-endian support

This is a combined patch that folds all of the past and present changes

for big-endian support into a single patch, hopefully eliminating any sort

of redundancy but also capturing all such changes in a single location.

To date, this has been critical for the s390x architecture only.

Signed-off-by: Al Stone <ahs3@redhat.com>

---

 source/compiler/aslcodegen.c      |  109 ++++++++++++++++++------------

 source/compiler/aslopcodes.c      |    4 +

 source/compiler/aslrestype1.c     |   68 +++++++++++++------

 source/compiler/aslrestype1i.c    |   38 +++++++---

 source/compiler/aslrestype2.c     |   25 ++++---

 source/compiler/aslrestype2d.c    |  134 +++++++++++++++++++++----------------

 source/compiler/aslrestype2e.c    |   39 +++++++----

 source/compiler/aslrestype2q.c    |  117 +++++++++++++++++++++-----------

 source/compiler/aslrestype2s.c    |   86 +++++++++++++++++-------

 source/compiler/aslrestype2w.c    |  127 +++++++++++++++++++++--------------

 source/include/acmacros.h         |   15 +++-

 source/include/platform/aclinux.h |    8 ++

 12 files changed, 487 insertions(+), 283 deletions(-)

Index: acpica-unix2-20180209/source/compiler/aslcodegen.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslcodegen.c

+++ acpica-unix2-20180209/source/compiler/aslcodegen.c

@@ -240,16 +240,12 @@ CgWriteAmlOpcode (

     ACPI_PARSE_OBJECT       *Op)

 {

     UINT8                   PkgLenFirstByte;

-    UINT32                  i;

-    union {

-        UINT16                  Opcode;

-        UINT8                   OpcodeBytes[2];

-    } Aml;

-    union {

-        UINT32                  Len;

-        UINT8                   LenBytes[4];

-    } PkgLen;

-

+    UINT8                   Byte;

+    UINT16                  Word;

+    UINT32                  DWord;

+    UINT64                  QWord;

+    UINT16                  AmlOpcode;

+    UINT32                  PkgLen;

     /* We expect some DEFAULT_ARGs, just ignore them */

@@ -282,51 +278,52 @@ CgWriteAmlOpcode (

         /* Special opcodes for within a field definition */

-        Aml.Opcode = AML_FIELD_OFFSET_OP;

+        AmlOpcode = AML_FIELD_OFFSET_OP;

         break;

     case AML_INT_ACCESSFIELD_OP:

-        Aml.Opcode = AML_FIELD_ACCESS_OP;

+        AmlOpcode = AML_FIELD_ACCESS_OP;

         break;

     case AML_INT_CONNECTION_OP:

-        Aml.Opcode = AML_FIELD_CONNECTION_OP;

+        AmlOpcode = AML_FIELD_CONNECTION_OP;

         break;

     default:

-        Aml.Opcode = Op->Asl.AmlOpcode;

+        AmlOpcode = Op->Asl.AmlOpcode;

         break;

     }

-    switch (Aml.Opcode)

+    switch (AmlOpcode)

     {

     case AML_PACKAGE_LENGTH:

         /* Value is the length to be encoded (Used in field definitions) */

-        PkgLen.Len = (UINT32) Op->Asl.Value.Integer;

+        PkgLen = (UINT32) Op->Asl.Value.Integer;

         break;

     default:

         /* Check for two-byte opcode */

-        if (Aml.Opcode > 0x00FF)

+        if (AmlOpcode > 0x00FF)

         {

             /* Write the high byte first */

-

-            CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1);

+	    Byte = ACPI_HIBYTE(AmlOpcode);

+	    CgLocalWriteAmlData (Op, &Byte, 1);

         }

-        CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1);

+	Byte = ACPI_LOBYTE(AmlOpcode);

+        CgLocalWriteAmlData (Op, &Byte, 1);

         /* Subtreelength doesn't include length of package length bytes */

-        PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;

+        PkgLen = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;

         break;

     }

@@ -337,8 +334,8 @@ CgWriteAmlOpcode (

         if (Op->Asl.AmlPkgLenBytes == 1)

         {

             /* Simplest case -- no bytes to follow, just write the count */

-

-            CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);

+            Byte = ACPI_LOBYTE(PkgLen);

+            CgLocalWriteAmlData (Op, &Byte, 1);

         }

         else if (Op->Asl.AmlPkgLenBytes != 0)

         {

@@ -348,7 +345,7 @@ CgWriteAmlOpcode (

              */

             PkgLenFirstByte = (UINT8)

                 (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) |

-                (PkgLen.LenBytes[0] & 0x0F));

+                (PkgLen & 0x0F));

             CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);

@@ -356,39 +353,47 @@ CgWriteAmlOpcode (

              * Shift the length over by the 4 bits we just stuffed

              * in the first byte

              */

-            PkgLen.Len >>= 4;

+            PkgLen >>= 4;

             /*

              * Now we can write the remaining bytes -

              * either 1, 2, or 3 bytes

              */

-            for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++)

+            Byte = ACPI_LOBYTE(PkgLen);

+            CgLocalWriteAmlData (Op, &Byte, 1);

+            if (Op->Asl.AmlPkgLenBytes >= 3)

+            {

+                Byte = ACPI_HIBYTE(PkgLen);

+                CgLocalWriteAmlData (Op, &Byte, 1);

+            }

+            if (Op->Asl.AmlPkgLenBytes >= 4)

             {

-                CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1);

+                Byte = ACPI_LOBYTE(ACPI_HIWORD(PkgLen));

+                CgLocalWriteAmlData (Op, &Byte, 1);

             }

         }

     }

-    switch (Aml.Opcode)

+    switch (AmlOpcode)

     {

     case AML_BYTE_OP:

-

-        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1);

+        Byte = (UINT8) Op->Asl.Value.Integer;

+        CgLocalWriteAmlData (Op, &Byte, 1);

         break;

     case AML_WORD_OP:

-

-        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2);

+        ACPI_MOVE_64_TO_16(&Word, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &Word, 2);

        break;

     case AML_DWORD_OP:

-

-        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4);

+        ACPI_MOVE_64_TO_32(&DWord, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &DWord, 4);

         break;

     case AML_QWORD_OP:

-

-        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8);

+        ACPI_MOVE_64_TO_64(&QWord, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &QWord, 8);

         break;

     case AML_STRING_OP:

@@ -422,6 +427,7 @@ CgWriteTableHeader (

     ACPI_PARSE_OBJECT       *Op)

 {

     ACPI_PARSE_OBJECT       *Child;

+    UINT32                  DWord;

     UINT32                  CommentLength;

     ACPI_COMMENT_NODE       *Current;

@@ -475,7 +481,7 @@ CgWriteTableHeader (

     /* OEM Revision */

     Child = Child->Asl.Next;

-    TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer;

+    ACPI_MOVE_64_TO_32(&TableHeader.OemRevision, &Child->Asl.Value.Integer);

     /* Compiler ID */

@@ -483,12 +489,13 @@ CgWriteTableHeader (

     /* Compiler version */

-    TableHeader.AslCompilerRevision = ACPI_CA_VERSION;

+    DWord = ACPI_CA_VERSION;

+    ACPI_MOVE_32_TO_32(&TableHeader.AslCompilerRevision, &DWord);

     /* Table length. Checksum zero for now, will rewrite later */

-    TableHeader.Length = sizeof (ACPI_TABLE_HEADER) +

-        Op->Asl.AmlSubtreeLength;

+    DWord = sizeof (ACPI_TABLE_HEADER) + Op->Asl.AmlSubtreeLength;

+    ACPI_MOVE_32_TO_32(&TableHeader.Length, &DWord);

     /* Calculate the comment lengths for this definition block parseOp */

@@ -645,7 +652,10 @@ CgWriteNode (

     ACPI_PARSE_OBJECT       *Op)

 {

     ASL_RESOURCE_NODE       *Rnode;

-

+    UINT8                   Byte;

+    UINT16                  Word;

+    UINT32                  DWord;

+    UINT64                  QWord;

     /* Write all comments here. */

@@ -675,13 +685,24 @@ CgWriteNode (

     switch (Op->Asl.AmlOpcode)

     {

     case AML_RAW_DATA_BYTE:

+        Byte = (UINT8) Op->Asl.Value.Integer;

+        CgLocalWriteAmlData (Op, &Byte, 1);

+        return;

+

     case AML_RAW_DATA_WORD:

-    case AML_RAW_DATA_DWORD:

-    case AML_RAW_DATA_QWORD:

+        ACPI_MOVE_64_TO_16(&Word, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &Word, 2);

+        return;

-        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength);

+    case AML_RAW_DATA_DWORD:

+        ACPI_MOVE_64_TO_32(&DWord, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &DWord, 4);

         return;

+    case AML_RAW_DATA_QWORD:

+        ACPI_MOVE_64_TO_64(&QWord, &Op->Asl.Value.Integer);

+        CgLocalWriteAmlData (Op, &QWord, 8);

+        return;

     case AML_RAW_DATA_BUFFER:

Index: acpica-unix2-20180209/source/compiler/aslopcodes.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslopcodes.c

+++ acpica-unix2-20180209/source/compiler/aslopcodes.c

@@ -485,6 +485,7 @@ OpcDoUnicode (

     UINT32                  i;

     UINT8                   *AsciiString;

     UINT16                  *UnicodeString;

+    UINT16                  UChar;

     ACPI_PARSE_OBJECT       *BufferLengthOp;

@@ -511,7 +512,8 @@ OpcDoUnicode (

     for (i = 0; i < Count; i++)

     {

-        UnicodeString[i] = (UINT16) AsciiString[i];

+        UChar = (UINT16) AsciiString[i];

+        ACPI_MOVE_16_TO_16(&UnicodeString[i], &UChar);

     }

     /*

Index: acpica-unix2-20180209/source/compiler/aslrestype1.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslrestype1.c

+++ acpica-unix2-20180209/source/compiler/aslrestype1.c

@@ -142,6 +142,11 @@ RsDoMemory24Descriptor (

     ACPI_PARSE_OBJECT       *LengthOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  Minimum = 0;

+    UINT16                  Maximum = 0;

+    UINT16                  AddressLength = 0;

+    UINT16                  Alignment = 0;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -151,7 +156,8 @@ RsDoMemory24Descriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->Memory24.DescriptorType = ACPI_RESOURCE_NAME_MEMORY24;

-    Descriptor->Memory24.ResourceLength = 9;

+    ResourceLength = 9;

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory24.ResourceLength, &ResourceLength);

     /* Process all child initialization nodes */

@@ -168,7 +174,7 @@ RsDoMemory24Descriptor (

         case 1: /* Min Address */

-            Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;

+            Minimum = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));

             MinOp = InitializerOp;

@@ -176,7 +182,7 @@ RsDoMemory24Descriptor (

         case 2: /* Max Address */

-            Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;

+            Maximum = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));

             MaxOp = InitializerOp;

@@ -184,14 +190,14 @@ RsDoMemory24Descriptor (

         case 3: /* Alignment */

-            Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer;

+            Alignment = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));

             break;

         case 4: /* Length */

-            Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;

+            AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));

             LengthOp = InitializerOp;

@@ -214,12 +220,17 @@ RsDoMemory24Descriptor (

     /* Validate the Min/Max/Len/Align values (Alignment==0 means 64K) */

     RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY24,

-        Descriptor->Memory24.Minimum,

-        Descriptor->Memory24.Maximum,

-        Descriptor->Memory24.AddressLength,

-        Descriptor->Memory24.Alignment,

+        Minimum,

+        Maximum,

+        AddressLength,

+        Alignment,

         MinOp, MaxOp, LengthOp, NULL, Info->DescriptorTypeOp);

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Minimum, &Minimum);

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Maximum, &Maximum);

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory24.AddressLength, &AddressLength);

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Alignment, &Alignment);

+

     return (Rnode);

 }

@@ -248,6 +259,11 @@ RsDoMemory32Descriptor (

     ACPI_PARSE_OBJECT       *AlignOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT32                  Minimum = 0;

+    UINT32                  Maximum = 0;

+    UINT32                  AddressLength = 0;

+    UINT32                  Alignment = 0;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -257,7 +273,8 @@ RsDoMemory32Descriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->Memory32.DescriptorType = ACPI_RESOURCE_NAME_MEMORY32;

-    Descriptor->Memory32.ResourceLength = 17;

+    ResourceLength = 17;

+    ACPI_MOVE_16_TO_16(&Descriptor->Memory32.ResourceLength, &ResourceLength);

     /* Process all child initialization nodes */

@@ -274,7 +291,7 @@ RsDoMemory32Descriptor (

         case 1:  /* Min Address */

-            Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer;

+            Minimum = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));

             MinOp = InitializerOp;

@@ -282,7 +299,7 @@ RsDoMemory32Descriptor (

         case 2: /* Max Address */

-            Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer;

+            Maximum = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));

             MaxOp = InitializerOp;

@@ -290,7 +307,7 @@ RsDoMemory32Descriptor (

         case 3: /* Alignment */

-            Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer;

+            Alignment = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));

             AlignOp = InitializerOp;

@@ -298,7 +315,7 @@ RsDoMemory32Descriptor (

         case 4: /* Length */

-            Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;

+            AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));

             LengthOp = InitializerOp;

@@ -321,12 +338,17 @@ RsDoMemory32Descriptor (

     /* Validate the Min/Max/Len/Align values */

     RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY32,

-        Descriptor->Memory32.Minimum,

-        Descriptor->Memory32.Maximum,

-        Descriptor->Memory32.AddressLength,

-        Descriptor->Memory32.Alignment,

+        Minimum,

+        Maximum,

+        AddressLength,

+        Alignment,

         MinOp, MaxOp, LengthOp, AlignOp, Info->DescriptorTypeOp);

+    ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Minimum, &Minimum);

+    ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Maximum, &Maximum);

+    ACPI_MOVE_32_TO_32(&Descriptor->Memory32.AddressLength, &AddressLength);

+    ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Alignment, &Alignment);

+

     return (Rnode);

 }

@@ -351,6 +373,7 @@ RsDoMemory32FixedDescriptor (

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -360,7 +383,8 @@ RsDoMemory32FixedDescriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->FixedMemory32.DescriptorType = ACPI_RESOURCE_NAME_FIXED_MEMORY32;

-    Descriptor->FixedMemory32.ResourceLength = 9;

+    ResourceLength = 9;

+    ACPI_MOVE_16_TO_16(&Descriptor->FixedMemory32.ResourceLength, &ResourceLength);

     /* Process all child initialization nodes */

@@ -377,14 +401,16 @@ RsDoMemory32FixedDescriptor (

         case 1: /* Address */

-            Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer;

+            ACPI_MOVE_64_TO_32(&Descriptor->FixedMemory32.Address,

+                &InitializerOp->Asl.Value.Integer);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));

             break;

         case 2: /* Length */

-            Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;

+            ACPI_MOVE_64_TO_32(&Descriptor->FixedMemory32.AddressLength,

+                &InitializerOp->Asl.Value.Integer);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));

             break;

Index: acpica-unix2-20180209/source/compiler/aslrestype1i.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslrestype1i.c

+++ acpica-unix2-20180209/source/compiler/aslrestype1i.c

@@ -198,6 +198,8 @@ RsDoFixedDmaDescriptor (

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  RequestLines = 0;

+    UINT16                  Channels = 0;

     UINT32                  i;

@@ -217,14 +219,14 @@ RsDoFixedDmaDescriptor (

         {

         case 0: /* DMA Request Lines [WORD] (_DMA) */

-            Descriptor->FixedDma.RequestLines = (UINT16) InitializerOp->Asl.Value.Integer;

+            RequestLines = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_DMA,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.RequestLines));

             break;

         case 1: /* DMA Channel [WORD] (_TYP) */

-            Descriptor->FixedDma.Channels = (UINT16) InitializerOp->Asl.Value.Integer;

+            Channels = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_DMATYPE,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Channels));

             break;

@@ -249,6 +251,9 @@ RsDoFixedDmaDescriptor (

         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);

     }

+    ACPI_MOVE_16_TO_16(&Descriptor->FixedDma.RequestLines, &RequestLines);

+    ACPI_MOVE_16_TO_16(&Descriptor->FixedDma.Channels, &Channels);

+

     return (Rnode);

 }

@@ -274,6 +279,7 @@ RsDoFixedIoDescriptor (

     ACPI_PARSE_OBJECT       *AddressOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  Address = 0;

     UINT32                  i;

@@ -293,8 +299,7 @@ RsDoFixedIoDescriptor (

         {

         case 0: /* Base Address */

-            Descriptor->FixedIo.Address =

-                (UINT16) InitializerOp->Asl.Value.Integer;

+            Address = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address));

             AddressOp = InitializerOp;

@@ -324,11 +329,13 @@ RsDoFixedIoDescriptor (

     /* Error checks */

-    if (Descriptor->FixedIo.Address > 0x03FF)

+    if (Address > 0x03FF)

     {

         AslError (ASL_WARNING, ASL_MSG_ISA_ADDRESS, AddressOp, NULL);

     }

+    ACPI_MOVE_16_TO_16(&Descriptor->FixedIo.Address, &Address);

+

     return (Rnode);

 }

@@ -357,6 +364,8 @@ RsDoIoDescriptor (

     ACPI_PARSE_OBJECT       *AlignOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  Minimum = 0;

+    UINT16                  Maximum = 0;

     UINT32                  i;

@@ -383,8 +392,7 @@ RsDoIoDescriptor (

         case 1:  /* Min Address */

-            Descriptor->Io.Minimum =

-                (UINT16) InitializerOp->Asl.Value.Integer;

+            Minimum = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum));

             MinOp = InitializerOp;

@@ -392,8 +400,7 @@ RsDoIoDescriptor (

         case 2: /* Max Address */

-            Descriptor->Io.Maximum =

-                (UINT16) InitializerOp->Asl.Value.Integer;

+            Maximum = (UINT16) InitializerOp->Asl.Value.Integer;

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum));

             MaxOp = InitializerOp;

@@ -434,12 +441,15 @@ RsDoIoDescriptor (

     /* Validate the Min/Max/Len/Align values */

     RsSmallAddressCheck (ACPI_RESOURCE_NAME_IO,

-        Descriptor->Io.Minimum,

-        Descriptor->Io.Maximum,

+        Minimum,

+        Maximum,

         Descriptor->Io.AddressLength,

         Descriptor->Io.Alignment,

         MinOp, MaxOp, LengthOp, AlignOp, Info->DescriptorTypeOp);

+    ACPI_MOVE_16_TO_16(&Descriptor->Io.Minimum, &Minimum);

+    ACPI_MOVE_16_TO_16(&Descriptor->Io.Maximum, &Maximum);

+

     return (Rnode);

 }

@@ -559,9 +569,9 @@ RsDoIrqDescriptor (

         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);

     }

-    /* Now we can set the channel mask */

+    /* Now we can set the interrupt mask */

-    Descriptor->Irq.IrqMask = IrqMask;

+    ACPI_MOVE_16_TO_16(&Descriptor->Irq.IrqMask, &IrqMask);

     return (Rnode);

 }

@@ -660,6 +670,6 @@ RsDoIrqNoFlagsDescriptor (

     /* Now we can set the interrupt mask */

-    Descriptor->Irq.IrqMask = IrqMask;

+    ACPI_MOVE_16_TO_16(&Descriptor->Irq.IrqMask, &IrqMask);

     return (Rnode);

 }

Index: acpica-unix2-20180209/source/compiler/aslrestype2.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslrestype2.c

+++ acpica-unix2-20180209/source/compiler/aslrestype2.c

@@ -76,6 +76,7 @@ RsDoGeneralRegisterDescriptor (

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -85,7 +86,9 @@ RsDoGeneralRegisterDescriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER;

-    Descriptor->GenericReg.ResourceLength = 12;

+    ResourceLength = 12;

+    ACPI_MOVE_16_TO_16(&Descriptor->GenericReg.ResourceLength,

+		    &ResourceLength);

     /* Process all child initialization nodes */

@@ -95,35 +98,52 @@ RsDoGeneralRegisterDescriptor (

         {

         case 0: /* Address space */

+	    /*

             Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;

+	    */

+            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AddressSpaceId,

+			      &InitializerOp->Asl.Value.Integer);

             RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));

            break;

         case 1: /* Register Bit Width */

+	    /*

             Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;

+	    */

+            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitWidth,

+			      &InitializerOp->Asl.Value.Integer);

             RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));

             break;

         case 2: /* Register Bit Offset */

+	    /*

             Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;

+	    */

+            ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.BitOffset,

+			      &InitializerOp->Asl.Value.Integer);

             RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));

             break;

         case 3: /* Register Address */

-            Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;

+	    ACPI_MOVE_64_TO_64(&Descriptor->GenericReg.Address,

+			    &InitializerOp->Asl.Value.Integer);

             RsCreateQwordField (InitializerOp, ACPI_RESTAG_ADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));

             break;

         case 4: /* Access Size (ACPI 3.0) */

+	    /*

             Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;

+	    */

+	    ACPI_MOVE_64_TO_8(&Descriptor->GenericReg.AccessSize,

+			      &InitializerOp->Asl.Value.Integer);

             RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));

@@ -177,6 +197,7 @@ RsDoInterruptDescriptor (

     AML_RESOURCE            *Rover = NULL;

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  ResourceLength = 0;

     UINT16                  StringLength = 0;

     UINT32                  OptionIndex = 0;

     UINT32                  CurrentByteOffset;

@@ -225,7 +246,7 @@ RsDoInterruptDescriptor (

      * Initial descriptor length -- may be enlarged if there are

      * optional fields present

      */

-    Descriptor->ExtendedIrq.ResourceLength  = 2;  /* Flags and table length byte */

+    ResourceLength  = 2;  /* Flags and table length byte */

     Descriptor->ExtendedIrq.InterruptCount  = 0;

     Rover = ACPI_CAST_PTR (AML_RESOURCE,

@@ -333,10 +354,11 @@ RsDoInterruptDescriptor (

             /* Save the integer and move pointer to the next one */

-            Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer;

+            ACPI_MOVE_64_TO_32(&Rover->DwordItem,

+                &InitializerOp->Asl.Value.Integer);

             Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4);

             Descriptor->ExtendedIrq.InterruptCount++;

-            Descriptor->ExtendedIrq.ResourceLength += 4;

+            ResourceLength += 4;

             /* Case 7: First interrupt number in list */

@@ -372,7 +394,7 @@ RsDoInterruptDescriptor (

     {

         Rover->ByteItem = ResSourceIndex;

         Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1);

-        Descriptor->ExtendedIrq.ResourceLength += 1;

+        ResourceLength += 1;

     }

     /* Add optional ResSource string if present */

@@ -384,14 +406,15 @@ RsDoInterruptDescriptor (

         Rover = ACPI_ADD_PTR (

                     AML_RESOURCE, &(Rover->ByteItem), StringLength);

-        Descriptor->ExtendedIrq.ResourceLength = (UINT16)

-            (Descriptor->ExtendedIrq.ResourceLength + StringLength);

+        ResourceLength = (UINT16) (ResourceLength + StringLength);

     }

     Rnode->BufferLength =

         (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) -

         ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType))

         + OptionIndex + StringLength;

+    ACPI_MOVE_16_TO_16(&Descriptor->ExtendedIrq.ResourceLength,

+		    &ResourceLength);

     return (Rnode);

 }

@@ -439,7 +462,7 @@ RsDoVendorLargeDescriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->VendorLarge.DescriptorType = ACPI_RESOURCE_NAME_VENDOR_LARGE;

-    Descriptor->VendorLarge.ResourceLength = (UINT16) i;

+    ACPI_MOVE_32_TO_16(&Descriptor->VendorLarge.ResourceLength, &i);

     /* Point to end-of-descriptor for vendor data */

Index: acpica-unix2-20180209/source/compiler/aslrestype2d.c

===================================================================

--- acpica-unix2-20180209.orig/source/compiler/aslrestype2d.c

+++ acpica-unix2-20180209/source/compiler/aslrestype2d.c

@@ -79,7 +79,13 @@ RsDoDwordIoDescriptor (

     ACPI_PARSE_OBJECT       *GranOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

     UINT16                  StringLength = 0;

+    UINT16                  ResourceLength = 0;

     UINT32                  OptionIndex = 0;

+    UINT32                  Minimum = 0;

+    UINT32                  Maximum = 0;

+    UINT32                  AddressLength = 0;

+    UINT32                  Granularity = 0;

+    UINT32                  TranslationOffset = 0;

     UINT8                   *OptionalFields;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

@@ -102,8 +108,7 @@ RsDoDwordIoDescriptor (

      * optional fields present

      */

     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);

-    Descriptor->Address32.ResourceLength = (UINT16)

-        (sizeof (AML_RESOURCE_ADDRESS32) -

+    ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS32) -

          sizeof (AML_RESOURCE_LARGE_HEADER));

     /* Process all child initialization nodes */

@@ -147,8 +152,7 @@ RsDoDwordIoDescriptor (

         case 5: /* Address Granularity */

-            Descriptor->Address32.Granularity =

-                (UINT32) InitializerOp->Asl.Value.Integer;

+            Granularity = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));

             GranOp = InitializerOp;

@@ -156,8 +160,7 @@ RsDoDwordIoDescriptor (

         case 6: /* Address Min */

-            Descriptor->Address32.Minimum =

-                (UINT32) InitializerOp->Asl.Value.Integer;

+            Minimum = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));

             MinOp = InitializerOp;

@@ -165,8 +168,7 @@ RsDoDwordIoDescriptor (

         case 7: /* Address Max */

-            Descriptor->Address32.Maximum =

-                (UINT32) InitializerOp->Asl.Value.Integer;

+            Maximum = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));

             MaxOp = InitializerOp;

@@ -174,16 +176,14 @@ RsDoDwordIoDescriptor (

         case 8: /* Translation Offset */

-            Descriptor->Address32.TranslationOffset =

-                (UINT32) InitializerOp->Asl.Value.Integer;

+            TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));

             break;

         case 9: /* Address Length */

-            Descriptor->Address32.AddressLength =

-                (UINT32) InitializerOp->Asl.Value.Integer;

+            AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));

             LengthOp = InitializerOp;

@@ -197,7 +197,7 @@ RsDoDwordIoDescriptor (

                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;

                 OptionIndex++;

-                Descriptor->Address32.ResourceLength++;

+                ResourceLength++;

                 ResSourceIndex = TRUE;

             }

             break;

@@ -211,8 +211,7 @@ RsDoDwordIoDescriptor (

                 {

                     /* Found a valid ResourceSource */

-                    Descriptor->Address32.ResourceLength = (UINT16)

-                        (Descriptor->Address32.ResourceLength + StringLength);

+                    ResourceLength = (UINT16) (ResourceLength + StringLength);

                     strcpy ((char *)

                         &OptionalFields[OptionIndex],

@@ -272,13 +271,20 @@ RsDoDwordIoDescriptor (

     /* Validate the Min/Max/Len/Gran values */

     RsLargeAddressCheck (

-        (UINT64) Descriptor->Address32.Minimum,

-        (UINT64) Descriptor->Address32.Maximum,