Patch carried over from the prior iasl package and updated.  This allows

for builds on big endian systems and cleans up endianness.  Please see

http://lists.acpica.org/pipermail/devel/2010-July/000159.html.  Resolves

BZ#865013 and BZ#856856.

--

Support compiling DSDT tables on big endian architectures.

use the ACPI_MOVE_<N>_TO_<M> macros to swap the data written to the AML file on

big endian architectures (the macros themselves required a few fixes to work

correctly).

In some areas the use of temporary variables was necessary to be able to perform

sanity checks on the data before actually swapping the bytes.

Signed-off-by: Mattia Dongili <malattia@linux.it>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

---

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

 source/compiler/aslopcodes.c      |   4 +-

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

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

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

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

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

 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 |   7 +-

 12 file modificati, 541 inserzioni(+), 306 rimozioni(-)

diff --git a/source/compiler/aslcodegen.c b/source/compiler/aslcodegen.c

index 2252ab4..c3c3e06 100644

--- a/source/compiler/aslcodegen.c

+++ b/source/compiler/aslcodegen.c

@@ -238,16 +238,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 */

@@ -270,51 +266,52 @@

         /* 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;

     }

@@ -325,8 +321,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)

         {

@@ -336,7 +332,7 @@ CgWriteAmlOpcode (

              */

             PkgLenFirstByte = (UINT8)

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

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

+                (PkgLen & 0x0F));

             CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);

@@ -344,37 +340,44 @@ 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:

@@ -408,6 +409,7 @@ CgWriteTableHeader (

     ACPI_PARSE_OBJECT       *Op)

 {

     ACPI_PARSE_OBJECT       *Child;

+    UINT32 DWord;

     /* AML filename */

@@ -444,7 +446,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 */

@@ -452,11 +453,12 @@ CgWriteTableHeader (

     /* Compiler version */

-    TableHeader.AslCompilerRevision = ASL_REVISION;

+    DWord = ASL_REVISION;

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

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

-    TableHeader.Length   = Gbl_TableLength;

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

     TableHeader.Checksum = 0;

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

@@ -520,7 +523,10 @@ CgWriteNode (

     ACPI_PARSE_OBJECT       *Op)

 {

     ASL_RESOURCE_NODE       *Rnode;

-

+    UINT8                   Byte;

+    UINT16                  Word;

+    UINT32                  DWord;

+    UINT64                  QWord;

     /* Always check for DEFAULT_ARG and other "Noop" nodes */

     /* TBD: this may not be the best place for this check */

@@ -538,13 +544,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:

diff --git a/source/compiler/aslopcodes.c b/source/compiler/aslopcodes.c

index cddc945..6deddc9 100644

--- a/source/compiler/aslopcodes.c

+++ b/source/compiler/aslopcodes.c

@@ -476,6 +475,7 @@ OpcDoUnicode (

     UINT32                  i;

     UINT8                   *AsciiString;

     UINT16                  *UnicodeString;

+    UINT16                  UChar;

     ACPI_PARSE_OBJECT       *BufferLengthOp;

@@ -502,7 +502,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);

     }

     /*

diff --git a/source/compiler/aslrestype1.c b/source/compiler/aslrestype1.c

index 5b92151..b1fa5f5 100644

--- a/source/compiler/aslrestype1.c

+++ b/source/compiler/aslrestype1.c

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

     ACPI_PARSE_OBJECT       *MaxOp = NULL;

     ACPI_PARSE_OBJECT       *LengthOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  Minimum = 0;

+    UINT16                  Maximum = 0;

+    UINT16                  AddressLength = 0;

+    UINT16                  Alignment = 0;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -160,7 +165,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 */

@@ -177,7 +183,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;

@@ -185,7 +191,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;

@@ -193,14 +199,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;

@@ -223,12 +229,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, Op);

+    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);

 }

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

     ACPI_PARSE_OBJECT       *LengthOp = NULL;

     ACPI_PARSE_OBJECT       *AlignOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT32                  Minimum = 0;

+    UINT32                  Maximum = 0;

+    UINT32                  AddressLength = 0;

+    UINT32                  Alignment = 0;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -267,7 +283,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 */

@@ -284,7 +301,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;

@@ -292,7 +309,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;

@@ -300,7 +317,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;

@@ -308,7 +325,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;

@@ -331,12 +348,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, Op);

+    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);

 }

@@ -363,6 +385,7 @@ RsDoMemory32FixedDescriptor (

     AML_RESOURCE            *Descriptor;

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -371,7 +394,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 */

@@ -388,14 +412,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;

diff --git a/source/compiler/aslrestype1i.c b/source/compiler/aslrestype1i.c

index 8335e8f..097eb05 100644

--- a/source/compiler/aslrestype1i.c

+++ b/source/compiler/aslrestype1i.c

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

     AML_RESOURCE            *Descriptor;

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  RequestLines = 0;

+    UINT16                  Channels = 0;

     UINT32                  i;

@@ -220,14 +222,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;

@@ -252,6 +253,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);

 }

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

     ACPI_PARSE_OBJECT       *InitializerOp;

     ACPI_PARSE_OBJECT       *AddressOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  Address = 0;

     UINT32                  i;

@@ -297,8 +302,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;

@@ -328,11 +332,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);

 }

@@ -363,6 +369,8 @@ RsDoIoDescriptor (

     ACPI_PARSE_OBJECT       *LengthOp = NULL;

     ACPI_PARSE_OBJECT       *AlignOp = NULL;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  Minimum = 0;

+    UINT16                  Maximum = 0;

     UINT32                  i;

@@ -388,8 +396,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;

@@ -397,8 +404,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;

@@ -439,12 +445,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, Op);

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

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

+

     return (Rnode);

 }

@@ -565,9 +574,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);

 }

@@ -667,6 +676,6 @@ RsDoIrqNoFlagsDescriptor (

     /* Now we can set the interrupt mask */

-    Descriptor->Irq.IrqMask = IrqMask;

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

     return (Rnode);

 }

diff --git a/source/compiler/aslrestype2.c b/source/compiler/aslrestype2.c

index f0de854..b6d8d1d 100644

--- a/source/compiler/aslrestype2.c

+++ b/source/compiler/aslrestype2.c

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

     AML_RESOURCE            *Descriptor;

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  ResourceLength;

     UINT32                  i;

@@ -87,7 +88,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 */

@@ -118,7 +121,8 @@ RsDoGeneralRegisterDescriptor (

         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;

@@ -176,6 +180,7 @@ RsDoInterruptDescriptor (

     AML_RESOURCE            *Rover = NULL;

     ACPI_PARSE_OBJECT       *InitializerOp;

     ASL_RESOURCE_NODE       *Rnode;

+    UINT16                  ResourceLength = 0;

     UINT16                  StringLength = 0;

     UINT32                  OptionIndex = 0;

     UINT32                  i;

@@ -222,7 +227,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,

@@ -330,10 +335,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 */

@@ -369,7 +376,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 */

@@ -381,13 +387,14 @@ 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))