From 14d220a34462e61fe69141c86f4c3cd2ae68c279 Mon Sep 17 00:00:00 2001

From: Al Stone <ahs3@redhat.com>

Date: Wed, 30 Sep 2020 18:59:57 -0600

Subject: [PATCH 43/45] Support DSDT/SSDT in a big-endian world.

NB: this is a very large diff.  The problem is that ResourceTemplates

are treated differently during compilation and disassembly so each of

the resource types had code that needed to be touched directly.

In general, however, just reading or writing individual AML opcodes

wasn't that much of a change, and most of it was on the codegen side.

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

---

 source/common/adwalk.c                     |   3 +-

 source/common/dmrestag.c                   |   2 +-

 source/common/dmtables.c                   |  17 +-

 source/common/dmtbdump.c                   |   3 +-

 source/common/dmtbdump3.c                  |   8 +-

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

 source/compiler/aslopcodes.c               |   3 +-

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

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

 source/compiler/aslrestype2.c              |  20 +-

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

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

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

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

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

 source/compiler/dttable2.c                 |   3 +-

 source/components/disassembler/dmbuffer.c  |  37 +++-

 source/components/disassembler/dmopcode.c  |  21 +-

 source/components/disassembler/dmresrc.c   |   2 +-

 source/components/disassembler/dmresrcl.c  |  43 +++--

 source/components/disassembler/dmresrcl2.c | 128 +++++++-----

 source/components/disassembler/dmresrcs.c  |  18 +-

 source/components/disassembler/dmwalk.c    |   2 +-

 source/components/namespace/nsaccess.c     |   2 +-

 source/components/namespace/nsnames.c      |   4 +-

 source/components/namespace/nsparse.c      |   6 +-

 source/components/namespace/nsutils.c      |   7 +-

 source/components/utilities/utresrc.c      |   2 +-

 28 files changed, 721 insertions(+), 341 deletions(-)

Index: acpica-unix2-20210604/source/common/adwalk.c

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

--- acpica-unix2-20210604.orig/source/common/adwalk.c

+++ acpica-unix2-20210604/source/common/adwalk.c

@@ -679,7 +679,8 @@ AcpiDmLoadDescendingOp (

         if (!Path && Op->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)

         {

-            *ACPI_CAST_PTR (UINT32, &FieldPath[0]) = Op->Named.Name;

+            AcpiUtWriteUint (FieldPath, ACPI_NAMESEG_SIZE,

+		             &Op->Named.Name, ACPI_NAMESEG_SIZE);

             FieldPath[4] = 0;

             Path = FieldPath;

         }

Index: acpica-unix2-20210604/source/common/dmrestag.c

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

--- acpica-unix2-20210604.orig/source/common/dmrestag.c

+++ acpica-unix2-20210604/source/common/dmrestag.c

@@ -1048,7 +1048,7 @@ AcpiDmAddResourcesToNamespace (

      * NextOp contains the Aml pointer and the Aml length

      */

     AcpiUtWalkAmlResources (NULL, (UINT8 *) NextOp->Named.Data,

-        (ACPI_SIZE) NextOp->Common.Value.Integer,

+        (ACPI_SIZE) NextOp->Common.Value.Size,

         AcpiDmAddResourceToNamespace, (void **) BufferNode);

 }

Index: acpica-unix2-20210604/source/common/dmtables.c

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

--- acpica-unix2-20210604.orig/source/common/dmtables.c

+++ acpica-unix2-20210604/source/common/dmtables.c

@@ -142,6 +142,10 @@ AdCreateTableHeader (

     ACPI_TABLE_HEADER       *Table)

 {

     UINT8                   Checksum;

+    UINT32                  TableLength = AcpiUtReadUint32 (&Table->Length);

+    UINT32                  OemRevision = AcpiUtReadUint32 (&Table->OemRevision);

+    UINT32                  CompilerRevision =

+                                AcpiUtReadUint32 (&Table->AslCompilerRevision);

     /* Reset globals for External statements */

@@ -156,7 +160,7 @@ AdCreateTableHeader (

     AcpiOsPrintf (" * Original Table Header:\n");

     AcpiOsPrintf (" *     Signature        \"%4.4s\"\n",    Table->Signature);

-    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", Table->Length, Table->Length);

+    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", TableLength, TableLength);

     /* Print and validate the revision */

@@ -188,7 +192,7 @@ AdCreateTableHeader (

     AcpiOsPrintf ("\n *     Checksum         0x%2.2X",        Table->Checksum);

-    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);

+    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), TableLength);

     if (Checksum)

     {

         AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",

@@ -198,9 +202,9 @@ AdCreateTableHeader (

     AcpiOsPrintf ("\n");

     AcpiOsPrintf (" *     OEM ID           \"%.6s\"\n",     Table->OemId);

     AcpiOsPrintf (" *     OEM Table ID     \"%.8s\"\n",     Table->OemTableId);

-    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision);

+    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", OemRevision, OemRevision);

     AcpiOsPrintf (" *     Compiler ID      \"%.4s\"\n",     Table->AslCompilerId);

-    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision);

+    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", CompilerRevision, CompilerRevision);

     AcpiOsPrintf (" */\n");

     /*

@@ -221,7 +225,7 @@ AdCreateTableHeader (

     AcpiOsPrintf (

         "DefinitionBlock (\"\", \"%4.4s\", %u, \"%.6s\", \"%.8s\", 0x%8.8X)\n",

         Table->Signature, Table->Revision,

-        Table->OemId, Table->OemTableId, Table->OemRevision);

+        Table->OemId, Table->OemTableId, OemRevision);

 }

@@ -396,7 +400,8 @@ AdParseTable (

     fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature);

-    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);

+    AmlLength = AcpiUtReadUint32 (&Table->Length);

+    AmlLength -= sizeof (ACPI_TABLE_HEADER);

     AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));

     AcpiUtSetIntegerWidth (Table->Revision);

Index: acpica-unix2-20210604/source/common/dmtbdump.c

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

--- acpica-unix2-20210604.orig/source/common/dmtbdump.c

+++ acpica-unix2-20210604/source/common/dmtbdump.c

@@ -338,8 +338,7 @@ AcpiDmDumpXsdt (

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

     {

         AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);

-        AcpiOsPrintf ("%8.8X%8.8X\n",

-                ACPI_FORMAT_UINT64 (AcpiUtReadUint64 (&Array[i])));

+        AcpiOsPrintf ("%16.16lX\n", AcpiUtReadUint64 (&Array[i]));

         Offset += sizeof (UINT64);

     }

 }

Index: acpica-unix2-20210604/source/common/dmtbdump3.c

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

--- acpica-unix2-20210604.orig/source/common/dmtbdump3.c

+++ acpica-unix2-20210604/source/common/dmtbdump3.c

@@ -736,13 +736,13 @@ AcpiDmDumpWpbt (

 {

     ACPI_STATUS             Status;

     ACPI_TABLE_WPBT         *Subtable;

-    UINT32                  Length = Table->Length;

+    UINT32                  TableLength = AcpiUtReadUint32 (&Table->Length);

     UINT16                  ArgumentsLength;

     /* Dump the main table */

-    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);

+    Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoWpbt);

     if (ACPI_FAILURE (Status))

     {

         return;

@@ -751,10 +751,10 @@ AcpiDmDumpWpbt (

     /* Extract the arguments buffer length from the main table */

     Subtable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);

-    ArgumentsLength = Subtable->ArgumentsLength;

+    ArgumentsLength = AcpiUtReadUint16 (&Subtable->ArgumentsLength);

     /* Dump the arguments buffer */

-    (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,

+    (void) AcpiDmDumpTable (TableLength, 0, Table, ArgumentsLength,

         AcpiDmTableInfoWpbt0);

 }

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

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

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

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

@@ -238,6 +238,10 @@ CgWriteAmlOpcode (

 {

     UINT8                   PkgLenFirstByte;

     UINT32                  i;

+    UINT8                   Tmp8;

+    UINT16                  Tmp16;

+    UINT32                  Tmp32;

+    UINT64                  Tmp64;

     union {

         UINT16                  Opcode;

         UINT8                   OpcodeBytes[2];

@@ -312,14 +316,15 @@ CgWriteAmlOpcode (

         /* Check for two-byte opcode */

+        Tmp16 = AcpiUtReadUint16 (&Aml.Opcode);

         if (Aml.Opcode > 0x00FF)

         {

             /* Write the high byte first */

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

+            CgLocalWriteAmlData (Op, ((UINT8 *) &Tmp16)+1, 1);

         }

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

+        CgLocalWriteAmlData (Op, (UINT8 *) &Tmp16, 1);

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

@@ -335,7 +340,8 @@ CgWriteAmlOpcode (

         {

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

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

+            Tmp8 = (UINT8) PkgLen.Len;

+            CgLocalWriteAmlData (Op, &Tmp8, 1);

         }

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

         {

@@ -343,9 +349,10 @@ CgWriteAmlOpcode (

              * Encode the "bytes to follow" in the first byte, top two bits.

              * The low-order nybble of the length is in the bottom 4 bits

              */

+            Tmp8 = (UINT8) PkgLen.Len;

             PkgLenFirstByte = (UINT8)

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

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

+                (Tmp8 & 0x0F));

             CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);

@@ -359,6 +366,9 @@ CgWriteAmlOpcode (

              * Now we can write the remaining bytes -

              * either 1, 2, or 3 bytes

              */

+            Tmp32 = PkgLen.Len;

+            AcpiUtWriteUint (&PkgLen.Len, Op->Asl.AmlPkgLenBytes,

+                &Tmp32, sizeof (UINT32));

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

             {

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

@@ -370,22 +380,30 @@ CgWriteAmlOpcode (

     {

     case AML_BYTE_OP:

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

+        Tmp64 = 0;

+        AcpiUtWriteUint (&Tmp64, 1, &Op->Asl.Value.Integer, 8);

+        CgLocalWriteAmlData (Op, &Tmp64, 1);

         break;

     case AML_WORD_OP:

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

-       break;

+        Tmp64 = 0;

+        AcpiUtWriteUint (&Tmp64, 2, &Op->Asl.Value.Integer, 8);

+        CgLocalWriteAmlData (Op, &Tmp64, 2);

+        break;

     case AML_DWORD_OP:

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

+        Tmp64 = 0;

+        AcpiUtWriteUint (&Tmp64, 4, &Op->Asl.Value.Integer, 8);

+        CgLocalWriteAmlData (Op, &Tmp64, 4);

         break;

     case AML_QWORD_OP:

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

+        Tmp64 = 0;

+        AcpiUtWriteUint (&Tmp64, 8, &Op->Asl.Value.Integer, 8);

+        CgLocalWriteAmlData (Op, &Tmp64, 8);

         break;

     case AML_STRING_OP:

@@ -423,6 +441,7 @@ CgWriteTableHeader (

     ACPI_PARSE_OBJECT       *Child;

     UINT32                  CommentLength;

     ACPI_COMMENT_NODE       *Current;

+    UINT32                  Tmp32;

     memset (&AslGbl_TableHeader, 0, sizeof (ACPI_TABLE_HEADER));

@@ -478,7 +497,9 @@ CgWriteTableHeader (

     /* OEM Revision */

     Child = Child->Asl.Next;

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

+    AcpiUtWriteUint (&Tmp32, sizeof (UINT32),

+           &Child->Asl.Value.Integer, sizeof (Child->Asl.Value.Integer));

+    AslGbl_TableHeader.OemRevision = Tmp32;

     /* Compiler ID */

@@ -486,7 +507,8 @@ CgWriteTableHeader (

     /* Compiler version */

-    AslGbl_TableHeader.AslCompilerRevision = ACPI_CA_VERSION;

+    Tmp32 = ACPI_CA_VERSION;

+    AslGbl_TableHeader.AslCompilerRevision = AcpiUtReadUint32 (&Tmp32);

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

@@ -541,6 +563,15 @@ CgWriteTableHeader (

     AslGbl_TableHeader.Checksum = 0;

     Op->Asl.FinalAmlOffset = ftell (AslGbl_Files[ASL_FILE_AML_OUTPUT].Handle);

+    /*

+     * Adjust the Table length; it will only change when big-endian

+     * but we have to wait until here in case there is arithmetic to

+     * be done on the length before this step in the function

+     */

+

+    Tmp32 = AslGbl_TableHeader.Length;

+    AslGbl_TableHeader.Length = AcpiUtReadUint32 (&Tmp32);

+

     /* Write entire header and clear the table header global */

     CgLocalWriteAmlData (Op, &AslGbl_TableHeader, sizeof (ACPI_TABLE_HEADER));

@@ -625,6 +656,7 @@ CgWriteNode (

     ACPI_PARSE_OBJECT       *Op)

 {

     ASL_RESOURCE_NODE       *Rnode;

+    UINT64                  Tmp64;

     /* Write all comments here. */

@@ -653,7 +685,10 @@ CgWriteNode (

     case AML_RAW_DATA_DWORD:

     case AML_RAW_DATA_QWORD:

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

+        Tmp64 = 0;

+        AcpiUtWriteUint (&Tmp64, Op->Asl.AmlLength,

+            &Op->Asl.Value.Integer, sizeof (UINT64));

+        CgLocalWriteAmlData (Op, &Tmp64, Op->Asl.AmlLength);

         return;

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

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

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

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

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

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

     {

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

+        AcpiUtWriteUint (&UnicodeString[i], sizeof (UINT16),

+                &AsciiString[i], sizeof (UINT8));

     }

     /*

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

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

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

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

@@ -143,6 +143,7 @@ RsDoMemory24Descriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

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

     Descriptor = Rnode->Buffer;

     Descriptor->Memory24.DescriptorType = ACPI_RESOURCE_NAME_MEMORY24;

-    Descriptor->Memory24.ResourceLength = 9;

+    Tmp16 = 9;

+    Descriptor->Memory24.ResourceLength = AcpiUtReadUint16 (&Tmp16);

     /* Process all child initialization nodes */

@@ -168,7 +170,8 @@ RsDoMemory24Descriptor (

         case 1: /* Min Address */

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

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

+            Descriptor->Memory24.Minimum = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));

             MinOp = InitializerOp;

@@ -176,7 +179,8 @@ RsDoMemory24Descriptor (

         case 2: /* Max Address */

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

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

+            Descriptor->Memory24.Maximum = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));

             MaxOp = InitializerOp;

@@ -184,14 +188,16 @@ RsDoMemory24Descriptor (

         case 3: /* Alignment */

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

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

+            Descriptor->Memory24.Alignment = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));

             break;

         case 4: /* Length */

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

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

+            Descriptor->Memory24.AddressLength = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));

             LengthOp = InitializerOp;

@@ -214,10 +220,10 @@ 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,

+        (UINT32) AcpiUtReadUint16 (&Descriptor->Memory24.Minimum),

+        (UINT32) AcpiUtReadUint16 (&Descriptor->Memory24.Maximum),

+        (UINT32) AcpiUtReadUint16 (&Descriptor->Memory24.AddressLength),

+        (UINT32) AcpiUtReadUint16 (&Descriptor->Memory24.Alignment),

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

     return (Rnode);

@@ -249,6 +255,8 @@ RsDoMemory32Descriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

+    UINT32                  Tmp32;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

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

     Descriptor = Rnode->Buffer;

     Descriptor->Memory32.DescriptorType = ACPI_RESOURCE_NAME_MEMORY32;

-    Descriptor->Memory32.ResourceLength = 17;

+    Tmp16 = 17;

+    Descriptor->Memory32.ResourceLength = AcpiUtReadUint16 (&Tmp16);

     /* Process all child initialization nodes */

@@ -274,7 +283,8 @@ RsDoMemory32Descriptor (

         case 1:  /* Min Address */

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

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

+            Descriptor->Memory32.Minimum = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));

             MinOp = InitializerOp;

@@ -282,7 +292,8 @@ RsDoMemory32Descriptor (

         case 2: /* Max Address */

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

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

+            Descriptor->Memory32.Maximum = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));

             MaxOp = InitializerOp;

@@ -290,7 +301,8 @@ RsDoMemory32Descriptor (

         case 3: /* Alignment */

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

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

+            Descriptor->Memory32.Alignment = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));

             AlignOp = InitializerOp;

@@ -298,7 +310,8 @@ RsDoMemory32Descriptor (

         case 4: /* Length */

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

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

+            Descriptor->Memory32.AddressLength = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));

             LengthOp = InitializerOp;

@@ -321,10 +334,10 @@ 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,

+        AcpiUtReadUint32 (&Descriptor->Memory32.Minimum),

+        AcpiUtReadUint32 (&Descriptor->Memory32.Maximum),

+        AcpiUtReadUint32 (&Descriptor->Memory32.AddressLength),

+        AcpiUtReadUint32 (&Descriptor->Memory32.Alignment),

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

     return (Rnode);

@@ -352,6 +365,8 @@ RsDoMemory32FixedDescriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

+    UINT32                  Tmp32;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

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

     Descriptor = Rnode->Buffer;

     Descriptor->FixedMemory32.DescriptorType = ACPI_RESOURCE_NAME_FIXED_MEMORY32;

-    Descriptor->FixedMemory32.ResourceLength = 9;

+    Tmp16 = 9;

+    Descriptor->FixedMemory32.ResourceLength = AcpiUtReadUint16 (&Tmp16);

     /* Process all child initialization nodes */

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

         case 1: /* Address */

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

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

+            Descriptor->FixedMemory32.Address = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));

             break;

         case 2: /* Length */

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

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

+            Descriptor->FixedMemory32.AddressLength = AcpiUtReadUint32 (&Tmp32);

             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));

             break;

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

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

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

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

@@ -199,6 +199,7 @@ RsDoFixedDmaDescriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

@@ -217,14 +218,16 @@ RsDoFixedDmaDescriptor (

         {

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

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

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

+            Descriptor->FixedDma.RequestLines = AcpiUtReadUint16 (&Tmp16);

             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;

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

+            Descriptor->FixedDma.Channels = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_DMATYPE,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Channels));

             break;

@@ -275,6 +278,7 @@ RsDoFixedIoDescriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

@@ -293,8 +297,8 @@ RsDoFixedIoDescriptor (

         {

         case 0: /* Base Address */

-            Descriptor->FixedIo.Address =

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

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

+            Descriptor->FixedIo.Address = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address));

             AddressOp = InitializerOp;

@@ -324,7 +328,7 @@ RsDoFixedIoDescriptor (

     /* Error checks */

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

+    if (AcpiUtReadUint16 (&Descriptor->FixedIo.Address) > 0x03FF)

     {

         AslError (ASL_WARNING, ASL_MSG_ISA_ADDRESS, AddressOp, NULL);

     }

@@ -358,6 +362,7 @@ RsDoIoDescriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

@@ -383,8 +388,8 @@ RsDoIoDescriptor (

         case 1:  /* Min Address */

-            Descriptor->Io.Minimum =

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

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

+            Descriptor->Io.Minimum = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum));

             MinOp = InitializerOp;

@@ -392,8 +397,8 @@ RsDoIoDescriptor (

         case 2: /* Max Address */

-            Descriptor->Io.Maximum =

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

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

+            Descriptor->Io.Maximum = AcpiUtReadUint16 (&Tmp16);

             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum));

             MaxOp = InitializerOp;

@@ -434,10 +439,10 @@ RsDoIoDescriptor (

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

     RsSmallAddressCheck (ACPI_RESOURCE_NAME_IO,

-        Descriptor->Io.Minimum,

-        Descriptor->Io.Maximum,

-        Descriptor->Io.AddressLength,

-        Descriptor->Io.Alignment,

+        (UINT32) (AcpiUtReadUint16 (&Descriptor->Io.Minimum)),

+        (UINT32) (AcpiUtReadUint16 (&Descriptor->Io.Maximum)),

+        (UINT32) Descriptor->Io.AddressLength,

+        (UINT32) Descriptor->Io.Alignment,

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

     return (Rnode);

@@ -561,7 +566,7 @@ RsDoIrqDescriptor (

     /* Now we can set the channel mask */

-    Descriptor->Irq.IrqMask = IrqMask;

+    Descriptor->Irq.IrqMask = AcpiUtReadUint16 (&IrqMask);

     return (Rnode);

 }

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

     /* Now we can set the interrupt mask */

-    Descriptor->Irq.IrqMask = IrqMask;

+    Descriptor->Irq.IrqMask = AcpiUtReadUint16(&IrqMask);

     return (Rnode);

 }

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

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

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

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

@@ -77,6 +77,8 @@ RsDoGeneralRegisterDescriptor (

     ASL_RESOURCE_NODE       *Rnode;

     UINT32                  CurrentByteOffset;

     UINT32                  i;

+    UINT16                  Tmp16;

+    UINT64                  Tmp64;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

@@ -85,7 +87,8 @@ RsDoGeneralRegisterDescriptor (

     Descriptor = Rnode->Buffer;

     Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER;

-    Descriptor->GenericReg.ResourceLength = 12;

+    Tmp16 = 12;

+    Descriptor->GenericReg.ResourceLength = AcpiUtReadUint16 (&Tmp16);

     /* Process all child initialization nodes */

@@ -116,7 +119,8 @@ RsDoGeneralRegisterDescriptor (

         case 3: /* Register Address */

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

+            Tmp64 = InitializerOp->Asl.Value.Integer;

+            Descriptor->GenericReg.Address = AcpiUtReadUint64 (&Tmp64);

             RsCreateQwordField (InitializerOp, ACPI_RESTAG_ADDRESS,

                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));

             break;

@@ -184,6 +188,8 @@ RsDoInterruptDescriptor (

     BOOLEAN                 HasResSourceIndex = FALSE;

     UINT8                   ResSourceIndex = 0;

     UINT8                   *ResSourceString = NULL;

+    UINT16                  Tmp16;

+    UINT32                  Tmp32;

     InitializerOp = Info->DescriptorTypeOp->Asl.Child;

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

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

      * optional fields present

      */

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

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