vendor/acpica/20170831

16 files changed, 948 insertions, 425 deletions

diff --git a/source/components/debugger/dbconvert.c b/source/components/debugger/dbconvert.c
index e02ddb40067c..e06bc02673e9 100644
--- a/source/components/debugger/dbconvert.c
+++ b/source/components/debugger/dbconvert.c
@@ -429,9 +429,7 @@ AcpiDbConvertToObject (
     default:
 
         Object->Type = ACPI_TYPE_INTEGER;
-        Status = AcpiUtStrtoul64 (String,
-            (AcpiGbl_IntegerByteWidth | ACPI_STRTOUL_BASE16),
-            &Object->Integer.Value);
+        Status = AcpiUtStrtoul64 (String, &Object->Integer.Value);
         break;
     }
 
diff --git a/source/components/disassembler/dmresrc.c b/source/components/disassembler/dmresrc.c
index 3c24855f9771..c50c1c42d83c 100644
--- a/source/components/disassembler/dmresrc.c
+++ b/source/components/disassembler/dmresrc.c
@@ -540,6 +540,20 @@ AcpiDmIsResourceTemplate (
     BufferLength = NextOp->Common.Value.Size;
 
     /*
+     * Any buffer smaller than one byte cannot possibly be a resource
+     * template. Two bytes could possibly be a "NULL" resource template
+     * with a lone end tag descriptor (as generated via
+     * "ResourceTemplate(){}"), but this would be an extremely unusual
+     * case, as the template would be essentially useless. The disassembler
+     * therefore does not recognize any two-byte buffer as a resource
+     * template.
+     */
+    if (BufferLength <= 2)
+    {
+        return (AE_TYPE);
+    }
+
+    /*
      * Not a template if declared buffer length != actual length of the
      * intialization byte list. Because the resource macros will create
      * a buffer of the exact required length (buffer length will be equal
diff --git a/source/components/dispatcher/dswexec.c b/source/components/dispatcher/dswexec.c
index dfdfeaa03660..bbb9436a666a 100644
--- a/source/components/dispatcher/dswexec.c
+++ b/source/components/dispatcher/dswexec.c
@@ -253,7 +253,7 @@ AcpiDsGetPredicateValue (
      * object. Implicitly convert the argument if necessary.
      */
     Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc,
-        ACPI_STRTOUL_BASE16);
+        ACPI_IMPLICIT_CONVERSION);
     if (ACPI_FAILURE (Status))
     {
         goto Cleanup;
diff --git a/source/components/events/evgpe.c b/source/components/events/evgpe.c
index 13b3e049d0f0..a00dc3786296 100644
--- a/source/components/events/evgpe.c
+++ b/source/components/events/evgpe.c
@@ -551,8 +551,8 @@ AcpiEvGpeDetect (
     ACPI_GPE_HANDLER_INFO   *GpeHandlerInfo;
     UINT32                  IntStatus = ACPI_INTERRUPT_NOT_HANDLED;
     UINT8                   EnabledStatusByte;
-    UINT32                  StatusReg;
-    UINT32                  EnableReg;
+    UINT64                  StatusReg;
+    UINT64                  EnableReg;
     ACPI_CPU_FLAGS          Flags;
     UINT32                  i;
     UINT32                  j;
@@ -629,7 +629,7 @@ AcpiEvGpeDetect (
                 "RunEnable=%02X, WakeEnable=%02X\n",
                 GpeRegisterInfo->BaseGpeNumber,
                 GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
-                StatusReg, EnableReg,
+                (UINT32) StatusReg, (UINT32) EnableReg,
                 GpeRegisterInfo->EnableForRun,
                 GpeRegisterInfo->EnableForWake));
 
diff --git a/source/components/executer/exconcat.c b/source/components/executer/exconcat.c
index e5f077dbd989..67d592cd5495 100644
--- a/source/components/executer/exconcat.c
+++ b/source/components/executer/exconcat.c
@@ -274,7 +274,7 @@ AcpiExDoConcatenate (
     case ACPI_TYPE_INTEGER:
 
         Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1,
-            ACPI_STRTOUL_BASE16);
+            ACPI_IMPLICIT_CONVERSION);
         break;
 
     case ACPI_TYPE_BUFFER:
diff --git a/source/components/executer/exconvrt.c b/source/components/executer/exconvrt.c
index 8c0ae75c2a6d..8577a45e14ee 100644
--- a/source/components/executer/exconvrt.c
+++ b/source/components/executer/exconvrt.c
@@ -172,10 +172,10 @@ AcpiExConvertToAscii (
  *
  * FUNCTION:    AcpiExConvertToInteger
  *
- * PARAMETERS:  ObjDesc         - Object to be converted. Must be an
- *                                Integer, Buffer, or String
- *              ResultDesc      - Where the new Integer object is returned
- *              Flags           - Used for string conversion
+ * PARAMETERS:  ObjDesc             - Object to be converted. Must be an
+ *                                    Integer, Buffer, or String
+ *              ResultDesc          - Where the new Integer object is returned
+ *              ImplicitConversion  - Used for string conversion
  *
  * RETURN:      Status
  *
@@ -187,14 +187,13 @@ ACPI_STATUS
 AcpiExConvertToInteger (
     ACPI_OPERAND_OBJECT     *ObjDesc,
     ACPI_OPERAND_OBJECT     **ResultDesc,
-    UINT32                  Flags)
+    UINT32                  ImplicitConversion)
 {
     ACPI_OPERAND_OBJECT     *ReturnDesc;
     UINT8                   *Pointer;
     UINT64                  Result;
     UINT32                  i;
     UINT32                  Count;
-    ACPI_STATUS             Status;
 
 
     ACPI_FUNCTION_TRACE_PTR (ExConvertToInteger, ObjDesc);
@@ -244,12 +243,17 @@ AcpiExConvertToInteger (
          * hexadecimal as per the ACPI specification. The only exception (as
          * of ACPI 3.0) is that the ToInteger() operator allows both decimal
          * and hexadecimal strings (hex prefixed with "0x").
+         *
+         * Explicit conversion is used only by ToInteger.
+         * All other string-to-integer conversions are implicit conversions.
          */
-        Status = AcpiUtStrtoul64 (ACPI_CAST_PTR (char, Pointer),
-            (AcpiGbl_IntegerByteWidth | Flags), &Result);
-        if (ACPI_FAILURE (Status))
+        if (ImplicitConversion)
+        {
+            Result = AcpiUtImplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
+        }
+        else
         {
-            return_ACPI_STATUS (Status);
+            Result = AcpiUtExplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
         }
         break;
 
@@ -792,7 +796,7 @@ AcpiExConvertToTargetType (
              * a Buffer or a String to an Integer if necessary.
              */
             Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
-                ACPI_STRTOUL_BASE16);
+                ACPI_IMPLICIT_CONVERSION);
             break;
 
         case ACPI_TYPE_STRING:
diff --git a/source/components/executer/exmisc.c b/source/components/executer/exmisc.c
index dfa4421ac773..8e92f7a04f0f 100644
--- a/source/components/executer/exmisc.c
+++ b/source/components/executer/exmisc.c
@@ -472,7 +472,7 @@ AcpiExDoLogicalOp (
     case ACPI_TYPE_INTEGER:
 
         Status = AcpiExConvertToInteger (Operand1, &LocalOperand1,
-            ACPI_STRTOUL_BASE16);
+            ACPI_IMPLICIT_CONVERSION);
         break;
 
     case ACPI_TYPE_STRING:
diff --git a/source/components/executer/exresop.c b/source/components/executer/exresop.c
index 0cd216ceb255..e33608c2f712 100644
--- a/source/components/executer/exresop.c
+++ b/source/components/executer/exresop.c
@@ -541,7 +541,7 @@ AcpiExResolveOperands (
              * Known as "Implicit Source Operand Conversion"
              */
             Status = AcpiExConvertToInteger (ObjDesc, StackPtr,
-                ACPI_STRTOUL_BASE16);
+                ACPI_IMPLICIT_CONVERSION);
             if (ACPI_FAILURE (Status))
             {
                 if (Status == AE_TYPE)
diff --git a/source/components/hardware/hwgpe.c b/source/components/hardware/hwgpe.c
index 56ccb78d243b..636639be03e6 100644
--- a/source/components/hardware/hwgpe.c
+++ b/source/components/hardware/hwgpe.c
@@ -217,7 +217,7 @@ AcpiHwLowSetGpe (
 {
     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
     ACPI_STATUS             Status = AE_OK;
-    UINT32                  EnableMask;
+    UINT64                  EnableMask;
     UINT32                  RegisterBit;
 
 
@@ -342,7 +342,7 @@ AcpiHwGetGpeStatus (
     ACPI_GPE_EVENT_INFO     *GpeEventInfo,
     ACPI_EVENT_STATUS       *EventStatus)
 {
-    UINT32                  InByte;
+    UINT64                  InByte;
     UINT32                  RegisterBit;
     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
     ACPI_EVENT_STATUS       LocalEventStatus = 0;
diff --git a/source/components/hardware/hwregs.c b/source/components/hardware/hwregs.c
index b5b23831fe9d..cd8e774a97d7 100644
--- a/source/components/hardware/hwregs.c
+++ b/source/components/hardware/hwregs.c
@@ -355,9 +355,8 @@ AcpiHwValidateRegister (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Read from either memory or IO space. This is a 32-bit max
- *              version of AcpiRead, used internally since the overhead of
- *              64-bit values is not needed.
+ * DESCRIPTION: Read from either memory or IO space. This is a 64-bit max
+ *              version of AcpiRead.
  *
  * LIMITATIONS: <These limitations also apply to AcpiHwWrite>
  *      SpaceID must be SystemMemory or SystemIO.
@@ -366,7 +365,7 @@ AcpiHwValidateRegister (
 
 ACPI_STATUS
 AcpiHwRead (
-    UINT32                  *Value,
+    UINT64                  *Value,
     ACPI_GENERIC_ADDRESS    *Reg)
 {
     UINT64                  Address;
@@ -384,18 +383,18 @@ AcpiHwRead (
 
     /* Validate contents of the GAS register */
 
-    Status = AcpiHwValidateRegister (Reg, 32, &Address);
+    Status = AcpiHwValidateRegister (Reg, 64, &Address);
     if (ACPI_FAILURE (Status))
     {
         return (Status);
     }
 
     /*
-     * Initialize entire 32-bit return value to zero, convert AccessWidth
+     * Initialize entire 64-bit return value to zero, convert AccessWidth
      * into number of bits based
      */
     *Value = 0;
-    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
+    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
     BitWidth = Reg->BitOffset + Reg->BitWidth;
     BitOffset = Reg->BitOffset;
 
@@ -408,7 +407,7 @@ AcpiHwRead (
     {
         if (BitOffset >= AccessWidth)
         {
-            Value32 = 0;
+            Value64 = 0;
             BitOffset -= AccessWidth;
         }
         else
@@ -418,31 +417,31 @@ AcpiHwRead (
                 Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
                     Address + Index * ACPI_DIV_8 (AccessWidth),
                     &Value64, AccessWidth);
-                Value32 = (UINT32) Value64;
             }
             else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
             {
                 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
                     Address + Index * ACPI_DIV_8 (AccessWidth),
                     &Value32, AccessWidth);
+                Value64 = (UINT64) Value32;
             }
         }
 
         /*
          * Use offset style bit writes because "Index * AccessWidth" is
-         * ensured to be less than 32-bits by AcpiHwValidateRegister().
+         * ensured to be less than 64-bits by AcpiHwValidateRegister().
          */
         ACPI_SET_BITS (Value, Index * AccessWidth,
-            ACPI_MASK_BITS_ABOVE_32 (AccessWidth), Value32);
+            ACPI_MASK_BITS_ABOVE_64 (AccessWidth), Value64);
 
         BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
         Index++;
     }
 
     ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-        "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
-        *Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
-        AcpiUtGetRegionName (Reg->SpaceId)));
+        "Read:  %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
+        ACPI_FORMAT_UINT64 (*Value), AccessWidth,
+        ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
 
     return (Status);
 }
@@ -457,15 +456,14 @@ AcpiHwRead (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max
- *              version of AcpiWrite, used internally since the overhead of
- *              64-bit values is not needed.
+ * DESCRIPTION: Write to either memory or IO space. This is a 64-bit max
+ *              version of AcpiWrite.
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiHwWrite (
-    UINT32                  Value,
+    UINT64                  Value,
     ACPI_GENERIC_ADDRESS    *Reg)
 {
     UINT64                  Address;
@@ -473,7 +471,6 @@ AcpiHwWrite (
     UINT32                  BitWidth;
     UINT8                   BitOffset;
     UINT64                  Value64;
-    UINT32                  Value32;
     UINT8                   Index;
     ACPI_STATUS             Status;
 
@@ -483,7 +480,7 @@ AcpiHwWrite (
 
     /* Validate contents of the GAS register */
 
-    Status = AcpiHwValidateRegister (Reg, 32, &Address);
+    Status = AcpiHwValidateRegister (Reg, 64, &Address);
     if (ACPI_FAILURE (Status))
     {
         return (Status);
@@ -491,7 +488,7 @@ AcpiHwWrite (
 
     /* Convert AccessWidth into number of bits based */
 
-    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
+    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
     BitWidth = Reg->BitOffset + Reg->BitWidth;
     BitOffset = Reg->BitOffset;
 
@@ -504,10 +501,10 @@ AcpiHwWrite (
     {
         /*
          * Use offset style bit reads because "Index * AccessWidth" is
-         * ensured to be less than 32-bits by AcpiHwValidateRegister().
+         * ensured to be less than 64-bits by AcpiHwValidateRegister().
          */
-        Value32 = ACPI_GET_BITS (&Value, Index * AccessWidth,
-            ACPI_MASK_BITS_ABOVE_32 (AccessWidth));
+        Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,
+            ACPI_MASK_BITS_ABOVE_64 (AccessWidth));
 
         if (BitOffset >= AccessWidth)
         {
@@ -517,7 +514,6 @@ AcpiHwWrite (
         {
             if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
             {
-                Value64 = (UINT64) Value32;
                 Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
                     Address + Index * ACPI_DIV_8 (AccessWidth),
                     Value64, AccessWidth);
@@ -526,7 +522,7 @@ AcpiHwWrite (
             {
                 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
                     Address + Index * ACPI_DIV_8 (AccessWidth),
-                    Value32, AccessWidth);
+                    (UINT32) Value64, AccessWidth);
             }
         }
 
@@ -539,9 +535,9 @@ AcpiHwWrite (
     }
 
     ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-        "Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
-        Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
-        AcpiUtGetRegionName (Reg->SpaceId)));
+        "Wrote: %8.8X%8.8X width %2d   to %8.8X%8.8X (%s)\n",
+        ACPI_FORMAT_UINT64 (Value), AccessWidth,
+        ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
 
     return (Status);
 }
@@ -688,6 +684,7 @@ AcpiHwRegisterRead (
     UINT32                  *ReturnValue)
 {
     UINT32                  Value = 0;
+    UINT64                  Value64;
     ACPI_STATUS             Status;
 
 
@@ -726,12 +723,14 @@ AcpiHwRegisterRead (
 
     case ACPI_REGISTER_PM2_CONTROL:          /* 8-bit access */
 
-        Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock);
+        Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPm2ControlBlock);
+        Value = (UINT32) Value64;
         break;
 
     case ACPI_REGISTER_PM_TIMER:             /* 32-bit access */
 
-        Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock);
+        Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPmTimerBlock);
+        Value = (UINT32) Value64;
         break;
 
     case ACPI_REGISTER_SMI_COMMAND_BLOCK:    /* 8-bit access */
@@ -749,7 +748,7 @@ AcpiHwRegisterRead (
 
     if (ACPI_SUCCESS (Status))
     {
-        *ReturnValue = Value;
+        *ReturnValue = (UINT32) Value;
     }
 
     return_ACPI_STATUS (Status);
@@ -789,6 +788,7 @@ AcpiHwRegisterWrite (
 {
     ACPI_STATUS             Status;
     UINT32                  ReadValue;
+    UINT64                  ReadValue64;
 
 
     ACPI_FUNCTION_TRACE (HwRegisterWrite);
@@ -850,11 +850,12 @@ AcpiHwRegisterWrite (
          * For control registers, all reserved bits must be preserved,
          * as per the ACPI spec.
          */
-        Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock);
+        Status = AcpiHwRead (&ReadValue64, &AcpiGbl_FADT.XPm2ControlBlock);
         if (ACPI_FAILURE (Status))
         {
             goto Exit;
         }
+        ReadValue = (UINT32) ReadValue64;
 
         /* Insert the bits to be preserved */
 
@@ -910,26 +911,29 @@ AcpiHwReadMultiple (
 {
     UINT32                  ValueA = 0;
     UINT32                  ValueB = 0;
+    UINT64                  Value64;
     ACPI_STATUS             Status;
 
 
     /* The first register is always required */
 
-    Status = AcpiHwRead (&ValueA, RegisterA);
+    Status = AcpiHwRead (&Value64, RegisterA);
     if (ACPI_FAILURE (Status))
     {
         return (Status);
     }
+    ValueA = (UINT32) Value64;
 
     /* Second register is optional */
 
     if (RegisterB->Address)
     {
-        Status = AcpiHwRead (&ValueB, RegisterB);
+        Status = AcpiHwRead (&Value64, RegisterB);
         if (ACPI_FAILURE (Status))
         {
             return (Status);
         }
+        ValueB = (UINT32) Value64;
     }
 
     /*
diff --git a/source/components/hardware/hwtimer.c b/source/components/hardware/hwtimer.c
index 174769d56348..358164ee8a31 100644
--- a/source/components/hardware/hwtimer.c
+++ b/source/components/hardware/hwtimer.c
@@ -215,6 +215,7 @@ AcpiGetTimer (
     UINT32                  *Ticks)
 {
     ACPI_STATUS             Status;
+    UINT64                  TimerValue;
 
 
     ACPI_FUNCTION_TRACE (AcpiGetTimer);
@@ -232,7 +233,14 @@ AcpiGetTimer (
         return_ACPI_STATUS (AE_SUPPORT);
     }
 
-    Status = AcpiHwRead (Ticks, &AcpiGbl_FADT.XPmTimerBlock);
+    Status = AcpiHwRead (&TimerValue, &AcpiGbl_FADT.XPmTimerBlock);
+    if (ACPI_SUCCESS (Status))
+    {
+        /* ACPI PM Timer is defined to be 32 bits (PM_TMR_LEN) */
+
+        *Ticks = (UINT32) TimerValue;
+    }
+
     return_ACPI_STATUS (Status);
 }
 
diff --git a/source/components/hardware/hwxface.c b/source/components/hardware/hwxface.c
index 3627a9715cb2..49a19e458cde 100644
--- a/source/components/hardware/hwxface.c
+++ b/source/components/hardware/hwxface.c
@@ -247,84 +247,14 @@ AcpiRead (
     UINT64                  *ReturnValue,
     ACPI_GENERIC_ADDRESS    *Reg)
 {
-    UINT32                  ValueLo;
-    UINT32                  ValueHi;
-    UINT32                  Width;
-    UINT64                  Address;
     ACPI_STATUS             Status;
 
 
     ACPI_FUNCTION_NAME (AcpiRead);
 
 
-    if (!ReturnValue)
-    {
-        return (AE_BAD_PARAMETER);
-    }
-
-    /* Validate contents of the GAS register. Allow 64-bit transfers */
-
-    Status = AcpiHwValidateRegister (Reg, 64, &Address);
-    if (ACPI_FAILURE (Status))
-    {
-        return (Status);
-    }
-
-    /*
-     * Two address spaces supported: Memory or I/O. PCI_Config is
-     * not supported here because the GAS structure is insufficient
-     */
-    if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
-    {
-        Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
-            Address, ReturnValue, Reg->BitWidth);
-        if (ACPI_FAILURE (Status))
-        {
-            return (Status);
-        }
-    }
-    else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
-    {
-        ValueLo = 0;
-        ValueHi = 0;
-
-        Width = Reg->BitWidth;
-        if (Width == 64)
-        {
-            Width = 32; /* Break into two 32-bit transfers */
-        }
-
-        Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
-            Address, &ValueLo, Width);
-        if (ACPI_FAILURE (Status))
-        {
-            return (Status);
-        }
-
-        if (Reg->BitWidth == 64)
-        {
-            /* Read the top 32 bits */
-
-            Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
-                (Address + 4), &ValueHi, 32);
-            if (ACPI_FAILURE (Status))
-            {
-                return (Status);
-            }
-        }
-
-        /* Set the return value only if status is AE_OK */
-
-        *ReturnValue = (ValueLo | ((UINT64) ValueHi << 32));
-    }
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-        "Read:  %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
-        ACPI_FORMAT_UINT64 (*ReturnValue), Reg->BitWidth,
-        ACPI_FORMAT_UINT64 (Address),
-        AcpiUtGetRegionName (Reg->SpaceId)));
-
-    return (AE_OK);
+    Status = AcpiHwRead (ReturnValue, Reg);
+    return (Status);
 }
 
 ACPI_EXPORT_SYMBOL (AcpiRead)
@@ -348,67 +278,13 @@ AcpiWrite (
     UINT64                  Value,
     ACPI_GENERIC_ADDRESS    *Reg)
 {
-    UINT32                  Width;
-    UINT64                  Address;
     ACPI_STATUS             Status;
 
 
     ACPI_FUNCTION_NAME (AcpiWrite);
 
 
-    /* Validate contents of the GAS register. Allow 64-bit transfers */
-
-    Status = AcpiHwValidateRegister (Reg, 64, &Address);
-    if (ACPI_FAILURE (Status))
-    {
-        return (Status);
-    }
-
-    /*
-     * Two address spaces supported: Memory or IO. PCI_Config is
-     * not supported here because the GAS structure is insufficient
-     */
-    if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
-    {
-        Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
-            Address, Value, Reg->BitWidth);
-        if (ACPI_FAILURE (Status))
-        {
-            return (Status);
-        }
-    }
-    else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
-    {
-        Width = Reg->BitWidth;
-        if (Width == 64)
-        {
-            Width = 32; /* Break into two 32-bit transfers */
-        }
-
-        Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
-            Address, ACPI_LODWORD (Value), Width);
-        if (ACPI_FAILURE (Status))
-        {
-            return (Status);
-        }
-
-        if (Reg->BitWidth == 64)
-        {
-            Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
-                (Address + 4), ACPI_HIDWORD (Value), 32);
-            if (ACPI_FAILURE (Status))
-            {
-                return (Status);
-            }
-        }
-    }
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-        "Wrote: %8.8X%8.8X width %2d   to %8.8X%8.8X (%s)\n",
-        ACPI_FORMAT_UINT64 (Value), Reg->BitWidth,
-        ACPI_FORMAT_UINT64 (Address),
-        AcpiUtGetRegionName (Reg->SpaceId)));
-
+    Status = AcpiHwWrite (Value, Reg);
     return (Status);
 }
 
diff --git a/source/components/namespace/nsconvert.c b/source/components/namespace/nsconvert.c
index daf8f475dd5e..bb825895b47d 100644
--- a/source/components/namespace/nsconvert.c
+++ b/source/components/namespace/nsconvert.c
@@ -191,8 +191,7 @@ AcpiNsConvertToInteger (
 
         /* String-to-Integer conversion */
 
-        Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,
-            AcpiGbl_IntegerByteWidth, &Value);
+        Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer, &Value);
         if (ACPI_FAILURE (Status))
         {
             return (Status);
diff --git a/source/components/tables/tbxface.c b/source/components/tables/tbxface.c
index d8cb6b18c4a4..6393bdace249 100644
--- a/source/components/tables/tbxface.c
+++ b/source/components/tables/tbxface.c
@@ -300,10 +300,13 @@ AcpiReallocateRootTable (
 
 
     /*
-     * Only reallocate the root table if the host provided a static buffer
-     * for the table array in the call to AcpiInitializeTables.
+     * If there are tables unverified, it is required to reallocate the
+     * root table list to clean up invalid table entries. Otherwise only
+     * reallocate the root table list if the host provided a static buffer
+     * for the table array in the call to AcpiInitializeTables().
      */
-    if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
+    if ((AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) &&
+        AcpiGbl_EnableTableValidation)
     {
         return_ACPI_STATUS (AE_SUPPORT);
     }
diff --git a/source/components/utilities/utstrsuppt.c b/source/components/utilities/utstrsuppt.c
new file mode 100644
index 000000000000..9197a57a5fbe
--- /dev/null
+++ b/source/components/utilities/utstrsuppt.c
@@ -0,0 +1,613 @@
+/*******************************************************************************
+ *
+ * Module Name: utstrsuppt - Support functions for string-to-integer conversion
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp.
+ * All rights reserved.
+ *
+ * 2. License
+ *
+ * 2.1. This is your license from Intel Corp. under its intellectual property
+ * rights. You may have additional license terms from the party that provided
+ * you this software, covering your right to use that party's intellectual
+ * property rights.
+ *
+ * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
+ * copy of the source code appearing in this file ("Covered Code") an
+ * irrevocable, perpetual, worldwide license under Intel's copyrights in the
+ * base code distributed originally by Intel ("Original Intel Code") to copy,
+ * make derivatives, distribute, use and display any portion of the Covered
+ * Code in any form, with the right to sublicense such rights; and
+ *
+ * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
+ * license (with the right to sublicense), under only those claims of Intel
+ * patents that are infringed by the Original Intel Code, to make, use, sell,
+ * offer to sell, and import the Covered Code and derivative works thereof
+ * solely to the minimum extent necessary to exercise the above copyright
+ * license, and in no event shall the patent license extend to any additions
+ * to or modifications of the Original Intel Code. No other license or right
+ * is granted directly or by implication, estoppel or otherwise;
+ *
+ * The above copyright and patent license is granted only if the following
+ * conditions are met:
+ *
+ * 3. Conditions
+ *
+ * 3.1. Redistribution of Source with Rights to Further Distribute Source.
+ * Redistribution of source code of any substantial portion of the Covered
+ * Code or modification with rights to further distribute source must include
+ * the above Copyright Notice, the above License, this list of Conditions,
+ * and the following Disclaimer and Export Compliance provision. In addition,
+ * Licensee must cause all Covered Code to which Licensee contributes to
+ * contain a file documenting the changes Licensee made to create that Covered
+ * Code and the date of any change. Licensee must include in that file the
+ * documentation of any changes made by any predecessor Licensee. Licensee
+ * must include a prominent statement that the modification is derived,
+ * directly or indirectly, from Original Intel Code.
+ *
+ * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
+ * Redistribution of source code of any substantial portion of the Covered
+ * Code or modification without rights to further distribute source must
+ * include the following Disclaimer and Export Compliance provision in the
+ * documentation and/or other materials provided with distribution. In
+ * addition, Licensee may not authorize further sublicense of source of any
+ * portion of the Covered Code, and must include terms to the effect that the
+ * license from Licensee to its licensee is limited to the intellectual
+ * property embodied in the software Licensee provides to its licensee, and
+ * not to intellectual property embodied in modifications its licensee may
+ * make.
+ *
+ * 3.3. Redistribution of Executable. Redistribution in executable form of any
+ * substantial portion of the Covered Code or modification must reproduce the
+ * above Copyright Notice, and the following Disclaimer and Export Compliance
+ * provision in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3.4. Intel retains all right, title, and interest in and to the Original
+ * Intel Code.
+ *
+ * 3.5. Neither the name Intel nor any other trademark owned or controlled by
+ * Intel shall be used in advertising or otherwise to promote the sale, use or
+ * other dealings in products derived from or relating to the Covered Code
+ * without prior written authorization from Intel.
+ *
+ * 4. Disclaimer and Export Compliance
+ *
+ * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
+ * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
+ * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
+ * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
+ * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
+ * PARTICULAR PURPOSE.
+ *
+ * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
+ * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
+ * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
+ * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
+ * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
+ * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
+ * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
+ * LIMITED REMEDY.
+ *
+ * 4.3. Licensee shall not export, either directly or indirectly, any of this
+ * software or system incorporating such software without first obtaining any
+ * required license or other approval from the U. S. Department of Commerce or
+ * any other agency or department of the United States Government. In the
+ * event Licensee exports any such software from the United States or
+ * re-exports any such software from a foreign destination, Licensee shall
+ * ensure that the distribution and export/re-export of the software is in
+ * compliance with all laws, regulations, orders, or other restrictions of the
+ * U.S. Export Administration Regulations. Licensee agrees that neither it nor
+ * any of its subsidiaries will export/re-export any technical data, process,
+ * software, or service, directly or indirectly, to any country for which the
+ * United States government or any agency thereof requires an export license,
+ * other governmental approval, or letter of assurance, without first obtaining
+ * such license, approval or letter.
+ *
+ *****************************************************************************
+ *
+ * Alternatively, you may choose to be licensed under the terms of the
+ * following license:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, you may choose to be licensed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ *****************************************************************************/
+
+#include "acpi.h"
+#include "accommon.h"
+
+#define _COMPONENT          ACPI_UTILITIES
+        ACPI_MODULE_NAME    ("utstrsuppt")
+
+
+/* Local prototypes */
+
+static ACPI_STATUS
+AcpiUtInsertDigit (
+    UINT64                  *AccumulatedValue,
+    UINT32                  Base,
+    int                     AsciiDigit);
+
+static ACPI_STATUS
+AcpiUtStrtoulMultiply64 (
+    UINT64                  Multiplicand,
+    UINT64                  Multiplier,
+    UINT64                  *OutProduct);
+
+static ACPI_STATUS
+AcpiUtStrtoulAdd64 (
+    UINT64                  Addend1,
+    UINT64                  Addend2,
+    UINT64                  *OutSum);
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtConvertOctalString
+ *
+ * PARAMETERS:  String                  - Null terminated input string
+ *              ReturnValuePtr          - Where the converted value is returned
+ *
+ * RETURN:      Status and 64-bit converted integer
+ *
+ * DESCRIPTION: Performs a base 8 conversion of the input string to an
+ *              integer value, either 32 or 64 bits.
+ *
+ * NOTE:        Maximum 64-bit unsigned octal value is 01777777777777777777777
+ *              Maximum 32-bit unsigned octal value is 037777777777
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiUtConvertOctalString (
+    char                    *String,
+    UINT64                  *ReturnValuePtr)
+{
+    UINT64                  AccumulatedValue = 0;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    /* Convert each ASCII byte in the input string */
+
+    while (*String)
+    {
+        /* Character must be ASCII 0-7, otherwise terminate with no error */
+
+        if (!(ACPI_IS_OCTAL_DIGIT (*String)))
+        {
+            break;
+        }
+
+        /* Convert and insert this octal digit into the accumulator */
+
+        Status = AcpiUtInsertDigit (&AccumulatedValue, 8, *String);
+        if (ACPI_FAILURE (Status))
+        {
+            Status = AE_OCTAL_OVERFLOW;
+            break;
+        }
+
+        String++;
+    }
+
+    /* Always return the value that has been accumulated */
+
+    *ReturnValuePtr = AccumulatedValue;
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtConvertDecimalString
+ *
+ * PARAMETERS:  String                  - Null terminated input string
+ *              ReturnValuePtr          - Where the converted value is returned
+ *
+ * RETURN:      Status and 64-bit converted integer
+ *
+ * DESCRIPTION: Performs a base 10 conversion of the input string to an
+ *              integer value, either 32 or 64 bits.
+ *
+ * NOTE:        Maximum 64-bit unsigned decimal value is 18446744073709551615
+ *              Maximum 32-bit unsigned decimal value is 4294967295
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiUtConvertDecimalString (
+    char                    *String,
+    UINT64                  *ReturnValuePtr)
+{
+    UINT64                  AccumulatedValue = 0;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    /* Convert each ASCII byte in the input string */
+
+    while (*String)
+    {
+        /* Character must be ASCII 0-9, otherwise terminate with no error */
+
+        if (!isdigit (*String))
+        {
+           break;
+        }
+
+        /* Convert and insert this decimal digit into the accumulator */
+
+        Status = AcpiUtInsertDigit (&AccumulatedValue, 10, *String);
+        if (ACPI_FAILURE (Status))
+        {
+            Status = AE_DECIMAL_OVERFLOW;
+            break;
+        }
+
+        String++;
+    }
+
+    /* Always return the value that has been accumulated */
+
+    *ReturnValuePtr = AccumulatedValue;
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtConvertHexString
+ *
+ * PARAMETERS:  String                  - Null terminated input string
+ *              ReturnValuePtr          - Where the converted value is returned
+ *
+ * RETURN:      Status and 64-bit converted integer
+ *
+ * DESCRIPTION: Performs a base 16 conversion of the input string to an
+ *              integer value, either 32 or 64 bits.
+ *
+ * NOTE:        Maximum 64-bit unsigned hex value is 0xFFFFFFFFFFFFFFFF
+ *              Maximum 32-bit unsigned hex value is 0xFFFFFFFF
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiUtConvertHexString (
+    char                    *String,
+    UINT64                  *ReturnValuePtr)
+{
+    UINT64                  AccumulatedValue = 0;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    /* Convert each ASCII byte in the input string */
+
+    while (*String)
+    {
+        /* Must be ASCII A-F, a-f, or 0-9, otherwise terminate with no error */
+
+        if (!isxdigit (*String))
+        {
+            break;
+        }
+
+        /* Convert and insert this hex digit into the accumulator */
+
+        Status = AcpiUtInsertDigit (&AccumulatedValue, 16, *String);
+        if (ACPI_FAILURE (Status))
+        {
+            Status = AE_HEX_OVERFLOW;
+            break;
+        }
+
+        String++;
+    }
+
+    /* Always return the value that has been accumulated */
+
+    *ReturnValuePtr = AccumulatedValue;
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtRemoveLeadingZeros
+ *
+ * PARAMETERS:  String                  - Pointer to input ASCII string
+ *
+ * RETURN:      Next character after any leading zeros. This character may be
+ *              used by the caller to detect end-of-string.
+ *
+ * DESCRIPTION: Remove any leading zeros in the input string. Return the
+ *              next character after the final ASCII zero to enable the caller
+ *              to check for the end of the string (NULL terminator).
+ *
+ ******************************************************************************/
+
+char
+AcpiUtRemoveLeadingZeros (
+    char                    **String)
+{
+
+    while (**String == ACPI_ASCII_ZERO)
+    {
+        *String += 1;
+    }
+
+    return (**String);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtRemoveWhitespace
+ *
+ * PARAMETERS:  String                  - Pointer to input ASCII string
+ *
+ * RETURN:      Next character after any whitespace. This character may be
+ *              used by the caller to detect end-of-string.
+ *
+ * DESCRIPTION: Remove any leading whitespace in the input string. Return the
+ *              next character after the final ASCII zero to enable the caller
+ *              to check for the end of the string (NULL terminator).
+ *
+ ******************************************************************************/
+
+char
+AcpiUtRemoveWhitespace (
+    char                    **String)
+{
+
+    while (isspace ((UINT8) **String))
+    {
+        *String += 1;
+    }
+
+    return (**String);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtDetectHexPrefix
+ *
+ * PARAMETERS:  String                  - Pointer to input ASCII string
+ *
+ * RETURN:      TRUE if a "0x" prefix was found at the start of the string
+ *
+ * DESCRIPTION: Detect and remove a hex "0x" prefix
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AcpiUtDetectHexPrefix (
+    char                    **String)
+{
+
+    if ((**String == ACPI_ASCII_ZERO) &&
+        (tolower ((int) *(*String + 1)) == 'x'))
+    {
+        *String += 2;        /* Go past the leading 0x */
+        return (TRUE);
+    }
+
+    return (FALSE);     /* Not a hex string */
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtDetectOctalPrefix
+ *
+ * PARAMETERS:  String                  - Pointer to input ASCII string
+ *
+ * RETURN:      True if an octal "0" prefix was found at the start of the
+ *              string
+ *
+ * DESCRIPTION: Detect and remove an octal prefix (zero)
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AcpiUtDetectOctalPrefix (
+    char                    **String)
+{
+
+    if (**String == ACPI_ASCII_ZERO)
+    {
+        *String += 1;       /* Go past the leading 0 */
+        return (TRUE);
+    }
+
+    return (FALSE);     /* Not an octal string */
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtInsertDigit
+ *
+ * PARAMETERS:  AccumulatedValue        - Current value of the integer value
+ *                                        accumulator. The new value is
+ *                                        returned here.
+ *              Base                    - Radix, either 8/10/16
+ *              AsciiDigit              - ASCII single digit to be inserted
+ *
+ * RETURN:      Status and result of the convert/insert operation. The only
+ *              possible returned exception code is numeric overflow of
+ *              either the multiply or add conversion operations.
+ *
+ * DESCRIPTION: Generic conversion and insertion function for all bases:
+ *
+ *              1) Multiply the current accumulated/converted value by the
+ *              base in order to make room for the new character.
+ *
+ *              2) Convert the new character to binary and add it to the
+ *              current accumulated value.
+ *
+ *              Note: The only possible exception indicates an integer
+ *              overflow (AE_NUMERIC_OVERFLOW)
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AcpiUtInsertDigit (
+    UINT64                  *AccumulatedValue,
+    UINT32                  Base,
+    int                     AsciiDigit)
+{
+    ACPI_STATUS             Status;
+    UINT64                  Product;
+
+
+     /* Make room in the accumulated value for the incoming digit */
+
+    Status = AcpiUtStrtoulMultiply64 (*AccumulatedValue, Base, &Product);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Add in the new digit, and store the sum to the accumulated value */
+
+    Status = AcpiUtStrtoulAdd64 (Product, AcpiUtAsciiCharToHex (AsciiDigit),
+        AccumulatedValue);
+
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStrtoulMultiply64
+ *
+ * PARAMETERS:  Multiplicand            - Current accumulated converted integer
+ *              Multiplier              - Base/Radix
+ *              OutProduct              - Where the product is returned
+ *
+ * RETURN:      Status and 64-bit product
+ *
+ * DESCRIPTION: Multiply two 64-bit values, with checking for 64-bit overflow as
+ *              well as 32-bit overflow if necessary (if the current global
+ *              integer width is 32).
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AcpiUtStrtoulMultiply64 (
+    UINT64                  Multiplicand,
+    UINT64                  Multiplier,
+    UINT64                  *OutProduct)
+{
+    UINT64                  Product;
+
+
+    /* Exit if either operand is zero */
+
+    *OutProduct = 0;
+    if (!Multiplicand || !Multiplier)
+    {
+        return (AE_OK);
+    }
+
+    /* Check for 64-bit overflow before the actual multiplication */
+
+    if (Multiplicand > (ACPI_UINT64_MAX / Multiplier))
+    {
+        return (AE_NUMERIC_OVERFLOW);
+    }
+
+    Product = Multiplicand * Multiplier;
+
+    /* Check for 32-bit overflow if necessary */
+
+    if ((AcpiGbl_IntegerBitWidth == 32) && (Product > ACPI_UINT32_MAX))
+    {
+        return (AE_NUMERIC_OVERFLOW);
+    }
+
+    *OutProduct = Product;
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStrtoulAdd64
+ *
+ * PARAMETERS:  Addend1                 - Current accumulated converted integer
+ *              Addend2                 - New hex value/char
+ *              OutSum                  - Where sum is returned (Accumulator)
+ *
+ * RETURN:      Status and 64-bit sum
+ *
+ * DESCRIPTION: Add two 64-bit values, with checking for 64-bit overflow as
+ *              well as 32-bit overflow if necessary (if the current global
+ *              integer width is 32).
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AcpiUtStrtoulAdd64 (
+    UINT64                  Addend1,
+    UINT64                  Addend2,
+    UINT64                  *OutSum)
+{
+    UINT64                  Sum;
+
+
+    /* Check for 64-bit overflow before the actual addition */
+
+    if ((Addend1 > 0) && (Addend2 > (ACPI_UINT64_MAX - Addend1)))
+    {
+        return (AE_NUMERIC_OVERFLOW);
+    }
+
+    Sum = Addend1 + Addend2;
+
+    /* Check for 32-bit overflow if necessary */
+
+    if ((AcpiGbl_IntegerBitWidth == 32) && (Sum > ACPI_UINT32_MAX))
+    {
+        return (AE_NUMERIC_OVERFLOW);
+    }
+
+    *OutSum = Sum;
+    return (AE_OK);
+}
diff --git a/source/components/utilities/utstrtoul64.c b/source/components/utilities/utstrtoul64.c
index d91e9084264c..34cef95b50af 100644
--- a/source/components/utilities/utstrtoul64.c
+++ b/source/components/utilities/utstrtoul64.c
@@ -1,6 +1,7 @@
 /*******************************************************************************
  *
- * Module Name: utstrtoul64 - string to 64-bit integer support
+ * Module Name: utstrtoul64 - String-to-integer conversion support for both
+ *                            64-bit and 32-bit integers
  *
  ******************************************************************************/
 
@@ -152,84 +153,47 @@
 #include "acpi.h"
 #include "accommon.h"
 
-
-/*******************************************************************************
- *
- * The functions in this module satisfy the need for 64-bit string-to-integer
- * conversions on both 32-bit and 64-bit platforms.
- *
- ******************************************************************************/
-
 #define _COMPONENT          ACPI_UTILITIES
         ACPI_MODULE_NAME    ("utstrtoul64")
 
-/* Local prototypes */
-
-static UINT64
-AcpiUtStrtoulBase10 (
-    char                    *String,
-    UINT32                  Flags);
-
-static UINT64
-AcpiUtStrtoulBase16 (
-    char                    *String,
-    UINT32                  Flags);
-
 
 /*******************************************************************************
  *
- * String conversion rules as written in the ACPI specification. The error
- * conditions and behavior are different depending on the type of conversion.
- *
- *
- * Implicit data type conversion: string-to-integer
- * --------------------------------------------------
- *
- * Base is always 16. This is the ACPI_STRTOUL_BASE16 case.
- *
- * Example:
- *      Add ("BA98", Arg0, Local0)
- *
- * The integer is initialized to the value zero.
- * The ASCII string is interpreted as a hexadecimal constant.
- *
- *  1)  A "0x" prefix is not allowed. However, ACPICA allows this for
- *      compatibility with previous ACPICA. (NO ERROR)
- *
- *  2)  Terminates when the size of an integer is reached (32 or 64 bits).
- *      (NO ERROR)
- *
- *  3)  The first non-hex character terminates the conversion without error.
- *      (NO ERROR)
- *
- *  4)  Conversion of a null (zero-length) string to an integer is not
- *      allowed. However, ACPICA allows this for compatibility with previous
- *      ACPICA. This conversion returns the value 0. (NO ERROR)
+ * This module contains the top-level string to 64/32-bit unsigned integer
+ * conversion functions:
  *
+ *  1) A standard strtoul() function that supports 64-bit integers, base
+ *     8/10/16, with integer overflow support. This is used mainly by the
+ *     iASL compiler, which implements tighter constraints on integer
+ *     constants than the runtime (interpreter) integer-to-string conversions.
+ *  2) Runtime "Explicit conversion" as defined in the ACPI specification.
+ *  3) Runtime "Implicit conversion" as defined in the ACPI specification.
  *
- * Explicit data type conversion:  ToInteger() with string operand
- * ---------------------------------------------------------------
+ * Current users of this module:
  *
- * Base is either 10 (default) or 16 (with 0x prefix)
- *
- * Examples:
- *      ToInteger ("1000")
- *      ToInteger ("0xABCD")
- *
- *  1)  Can be (must be) either a decimal or hexadecimal numeric string.
- *      A hex value must be prefixed by "0x" or it is interpreted as a decimal.
+ *  iASL        - Preprocessor (constants and math expressions)
+ *  iASL        - Main parser, conversion of constants to integers
+ *  iASL        - Data Table Compiler parser (constants and math expressions)
+ *  Interpreter - Implicit and explicit conversions, GPE method names
+ *  Interpreter - Repair code for return values from predefined names
+ *  Debugger    - Command line input string conversion
+ *  AcpiDump    - ACPI table physical addresses
+ *  AcpiExec    - Support for namespace overrides
  *
- *  2)  The value must not exceed the maximum of an integer value. ACPI spec
- *      states the behavior is "unpredictable", so ACPICA matches the behavior
- *      of the implicit conversion case.(NO ERROR)
+ * Notes concerning users of these interfaces:
  *
- *  3)  Behavior on the first non-hex character is not specified by the ACPI
- *      spec, so ACPICA matches the behavior of the implicit conversion case
- *      and terminates. (NO ERROR)
+ * AcpiGbl_IntegerByteWidth is used to set the 32/64 bit limit for explicit
+ * and implicit conversions. This global must be set to the proper width.
+ * For the core ACPICA code, the width depends on the DSDT version. For the
+ * AcpiUtStrtoul64 interface, all conversions are 64 bits. This interface is
+ * used primarily for iASL, where the default width is 64 bits for all parsers,
+ * but error checking is performed later to flag cases where a 64-bit constant
+ * is wrongly defined in a 32-bit DSDT/SSDT.
  *
- *  4)  A null (zero-length) string is illegal.
- *      However, ACPICA allows this for compatibility with previous ACPICA.
- *      This conversion returns the value 0. (NO ERROR)
+ * In ACPI, the only place where octal numbers are supported is within
+ * the ASL language itself. This is implemented via the main AcpiUtStrtoul64
+ * interface. According the ACPI specification, there is no ACPI runtime
+ * support (explicit/implicit) for octal string conversions.
  *
  ******************************************************************************/
 
@@ -238,261 +202,301 @@ AcpiUtStrtoulBase16 (
  *
  * FUNCTION:    AcpiUtStrtoul64
  *
- * PARAMETERS:  String                  - Null terminated input string
- *              Flags                   - Conversion info, see below
+ * PARAMETERS:  String                  - Null terminated input string,
+ *                                        must be a valid pointer
  *              ReturnValue             - Where the converted integer is
- *                                        returned
- *
- * RETURN:      Status and Converted value
+ *                                        returned. Must be a valid pointer
  *
- * DESCRIPTION: Convert a string into an unsigned value. Performs either a
- *              32-bit or 64-bit conversion, depending on the input integer
- *              size in Flags (often the current mode of the interpreter).
+ * RETURN:      Status and converted integer. Returns an exception on a
+ *              64-bit numeric overflow
  *
- * Values for Flags:
- *      ACPI_STRTOUL_32BIT      - Max integer value is 32 bits
- *      ACPI_STRTOUL_64BIT      - Max integer value is 64 bits
- *      ACPI_STRTOUL_BASE16     - Input string is hexadecimal. Default
- *                                is 10/16 based on string prefix (0x).
+ * DESCRIPTION: Convert a string into an unsigned integer. Always performs a
+ *              full 64-bit conversion, regardless of the current global
+ *              integer width. Supports Decimal, Hex, and Octal strings.
  *
- * NOTES:
- *   Negative numbers are not supported, as they are not supported by ACPI.
+ * Current users of this function:
  *
- *   Supports only base 16 or base 10 strings/values. Does not
- *   support Octal strings, as these are not supported by ACPI.
- *
- * Current users of this support:
- *
- *  Interpreter - Implicit and explicit conversions, GPE method names
- *  Debugger    - Command line input string conversion
- *  iASL        - Main parser, conversion of constants to integers
- *  iASL        - Data Table Compiler parser (constant math expressions)
- *  iASL        - Preprocessor (constant math expressions)
- *  AcpiDump    - Input table addresses
- *  AcpiExec    - Testing of the AcpiUtStrtoul64 function
- *
- * Note concerning callers:
- *   AcpiGbl_IntegerByteWidth can be used to set the 32/64 limit. If used,
- *   this global should be set to the proper width. For the core ACPICA code,
- *   this width depends on the DSDT version. For iASL, the default byte
- *   width is always 8 for the parser, but error checking is performed later
- *   to flag cases where a 64-bit constant is defined in a 32-bit DSDT/SSDT.
+ *  iASL        - Preprocessor (constants and math expressions)
+ *  iASL        - Main ASL parser, conversion of ASL constants to integers
+ *  iASL        - Data Table Compiler parser (constants and math expressions)
+ *  Interpreter - Repair code for return values from predefined names
+ *  AcpiDump    - ACPI table physical addresses
+ *  AcpiExec    - Support for namespace overrides
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiUtStrtoul64 (
     char                    *String,
-    UINT32                  Flags,
     UINT64                  *ReturnValue)
 {
     ACPI_STATUS             Status = AE_OK;
-    UINT32                  Base;
+    UINT8                   OriginalBitWidth;
+    UINT32                  Base = 10;          /* Default is decimal */
 
 
     ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
 
 
-    /* Parameter validation */
-
-    if (!String || !ReturnValue)
-    {
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
-    }
-
     *ReturnValue = 0;
 
-    /* Check for zero-length string, returns 0 */
+    /* A NULL return string returns a value of zero */
 
     if (*String == 0)
     {
         return_ACPI_STATUS (AE_OK);
     }
 
-    /* Skip over any white space at start of string */
-
-    while (isspace ((int) *String))
-    {
-        String++;
-    }
-
-    /* End of string? return 0 */
-
-    if (*String == 0)
+    if (!AcpiUtRemoveWhitespace (&String))
     {
         return_ACPI_STATUS (AE_OK);
     }
 
     /*
-     * 1) The "0x" prefix indicates base 16. Per the ACPI specification,
-     * the "0x" prefix is only allowed for implicit (non-strict) conversions.
-     * However, we always allow it for compatibility with older ACPICA.
+     * 1) Check for a hex constant. A "0x" prefix indicates base 16.
      */
-    if ((*String == ACPI_ASCII_ZERO) &&
-        (tolower ((int) *(String + 1)) == 'x'))
+    if (AcpiUtDetectHexPrefix (&String))
     {
-        String += 2;    /* Go past the 0x */
-        if (*String == 0)
-        {
-            return_ACPI_STATUS (AE_OK);     /* Return value 0 */
-        }
-
         Base = 16;
     }
 
-    /* 2) Force to base 16 (implicit conversion case) */
-
-    else if (Flags & ACPI_STRTOUL_BASE16)
+    /*
+     * 2) Check for an octal constant, defined to be a leading zero
+     * followed by sequence of octal digits (0-7)
+     */
+    else if (AcpiUtDetectOctalPrefix (&String))
     {
-        Base = 16;
+        Base = 8;
     }
 
-    /* 3) Default fallback is to Base 10 */
-
-    else
+    if (!AcpiUtRemoveLeadingZeros (&String))
     {
-        Base = 10;
+        return_ACPI_STATUS (AE_OK);     /* Return value 0 */
     }
 
-    /* Skip all leading zeros */
+    /*
+     * Force a full 64-bit conversion. The caller (usually iASL) must
+     * check for a 32-bit overflow later as necessary (If current mode
+     * is 32-bit, meaning a 32-bit DSDT).
+     */
+    OriginalBitWidth = AcpiGbl_IntegerBitWidth;
+    AcpiGbl_IntegerBitWidth = 64;
 
-    while (*String == ACPI_ASCII_ZERO)
+    /*
+     * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow
+     * will return an exception (to allow iASL to flag the statement).
+     */
+    switch (Base)
     {
-        String++;
-        if (*String == 0)
-        {
-            return_ACPI_STATUS (AE_OK);     /* Return value 0 */
-        }
+    case 8:
+        Status = AcpiUtConvertOctalString (String, ReturnValue);
+        break;
+
+    case 10:
+        Status = AcpiUtConvertDecimalString (String, ReturnValue);
+        break;
+
+    case 16:
+    default:
+        Status = AcpiUtConvertHexString (String, ReturnValue);
+        break;
     }
 
-    /* Perform the base 16 or 10 conversion */
-
-    if (Base == 16)
-    {
-        *ReturnValue = AcpiUtStrtoulBase16 (String, Flags);
-    }
-    else
-    {
-        *ReturnValue = AcpiUtStrtoulBase10 (String, Flags);
-    }
+    /* Only possible exception from above is a 64-bit overflow */
 
+    AcpiGbl_IntegerBitWidth = OriginalBitWidth;
     return_ACPI_STATUS (Status);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiUtStrtoulBase10
+ * FUNCTION:    AcpiUtImplicitStrtoul64
+ *
+ * PARAMETERS:  String                  - Null terminated input string,
+ *                                        must be a valid pointer
+ *
+ * RETURN:      Converted integer
+ *
+ * DESCRIPTION: Perform a 64-bit conversion with restrictions placed upon
+ *              an "implicit conversion" by the ACPI specification. Used by
+ *              many ASL operators that require an integer operand, and support
+ *              an automatic (implicit) conversion from a string operand
+ *              to the final integer operand. The major restriction is that
+ *              only hex strings are supported.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Base is always 16, either with or without the 0x prefix. Decimal and
+ * Octal strings are not supported, as per the ACPI specification.
+ *
+ * Examples (both are hex values):
+ *      Add ("BA98", Arg0, Local0)
+ *      Subtract ("0x12345678", Arg1, Local1)
+ *
+ * Conversion rules as extracted from the ACPI specification:
+ *
+ *  The converted integer is initialized to the value zero.
+ *  The ASCII string is always interpreted as a hexadecimal constant.
+ *
+ *  1)  According to the ACPI specification, a "0x" prefix is not allowed.
+ *      However, ACPICA allows this as an ACPI extension on general
+ *      principle. (NO ERROR)
+ *
+ *  2)  The conversion terminates when the size of an integer is reached
+ *      (32 or 64 bits). There are no numeric overflow conditions. (NO ERROR)
+ *
+ *  3)  The first non-hex character terminates the conversion and returns
+ *      the current accumulated value of the converted integer (NO ERROR).
  *
- * PARAMETERS:  String                  - Null terminated input string
- *              Flags                   - Conversion info
+ *  4)  Conversion of a null (zero-length) string to an integer is
+ *      technically not allowed. However, ACPICA allows this as an ACPI
+ *      extension. The conversion returns the value 0. (NO ERROR)
  *
- * RETURN:      64-bit converted integer
+ * NOTE: There are no error conditions returned by this function. At
+ * the minimum, a value of zero is returned.
  *
- * DESCRIPTION: Performs a base 10 conversion of the input string to an
- *              integer value, either 32 or 64 bits.
- *              Note: String must be valid and non-null.
+ * Current users of this function:
+ *
+ *  Interpreter - All runtime implicit conversions, as per ACPI specification
+ *  iASL        - Data Table Compiler parser (constants and math expressions)
  *
  ******************************************************************************/
 
-static UINT64
-AcpiUtStrtoulBase10 (
-    char                    *String,
-    UINT32                  Flags)
+UINT64
+AcpiUtImplicitStrtoul64 (
+    char                    *String)
 {
-    int                     AsciiDigit;
-    UINT64                  NextValue;
-    UINT64                  ReturnValue = 0;
+    UINT64                  ConvertedInteger = 0;
 
 
-    /* Main loop: convert each ASCII byte in the input string */
-
-    while (*String)
-    {
-        AsciiDigit = *String;
-        if (!isdigit (AsciiDigit))
-        {
-            /* Not ASCII 0-9, terminate */
+    ACPI_FUNCTION_TRACE_STR (UtImplicitStrtoul64, String);
 
-            goto Exit;
-        }
 
-        /* Convert and insert (add) the decimal digit */
-
-        AcpiUtShortMultiply (ReturnValue, 10, &NextValue);
-        NextValue += (AsciiDigit - ACPI_ASCII_ZERO);
-
-        /* Check for overflow (32 or 64 bit) - return current converted value */
+    if (!AcpiUtRemoveWhitespace (&String))
+    {
+        return_VALUE (0);
+    }
 
-        if (((Flags & ACPI_STRTOUL_32BIT) && (NextValue > ACPI_UINT32_MAX)) ||
-            (NextValue < ReturnValue)) /* 64-bit overflow case */
-        {
-            goto Exit;
-        }
+    /*
+     * Per the ACPI specification, only hexadecimal is supported for
+     * implicit conversions, and the "0x" prefix is "not allowed".
+     * However, allow a "0x" prefix as an ACPI extension.
+     */
+    AcpiUtDetectHexPrefix (&String);
 
-        ReturnValue = NextValue;
-        String++;
+    if (!AcpiUtRemoveLeadingZeros (&String))
+    {
+        return_VALUE (0);
     }
 
-Exit:
-    return (ReturnValue);
+    /*
+     * Ignore overflow as per the ACPI specification. This is implemented by
+     * ignoring the return status from the conversion function called below.
+     * On overflow, the input string is simply truncated.
+     */
+    AcpiUtConvertHexString (String, &ConvertedInteger);
+    return_VALUE (ConvertedInteger);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiUtStrtoulBase16
+ * FUNCTION:    AcpiUtExplicitStrtoul64
+ *
+ * PARAMETERS:  String                  - Null terminated input string,
+ *                                        must be a valid pointer
  *
- * PARAMETERS:  String                  - Null terminated input string
- *              Flags                   - conversion info
+ * RETURN:      Converted integer
  *
- * RETURN:      64-bit converted integer
+ * DESCRIPTION: Perform a 64-bit conversion with the restrictions placed upon
+ *              an "explicit conversion" by the ACPI specification. The
+ *              main restriction is that only hex and decimal are supported.
  *
- * DESCRIPTION: Performs a base 16 conversion of the input string to an
- *              integer value, either 32 or 64 bits.
- *              Note: String must be valid and non-null.
+ * -----------------------------------------------------------------------------
+ *
+ * Base is either 10 (default) or 16 (with 0x prefix). Octal (base 8) strings
+ * are not supported, as per the ACPI specification.
+ *
+ * Examples:
+ *      ToInteger ("1000")      Decimal
+ *      ToInteger ("0xABCD")    Hex
+ *
+ * Conversion rules as extracted from the ACPI specification:
+ *
+ *  1)  The input string is either a decimal or hexadecimal numeric string.
+ *      A hex value must be prefixed by "0x" or it is interpreted as decimal.
+ *
+ *  2)  The value must not exceed the maximum of an integer value
+ *      (32 or 64 bits). The ACPI specification states the behavior is
+ *      "unpredictable", so ACPICA matches the behavior of the implicit
+ *      conversion case. There are no numeric overflow conditions. (NO ERROR)
+ *
+ *  3)  Behavior on the first non-hex character is not defined by the ACPI
+ *      specification (for the ToInteger operator), so ACPICA matches the
+ *      behavior of the implicit conversion case. It terminates the
+ *      conversion and returns the current accumulated value of the converted
+ *      integer. (NO ERROR)
+ *
+ *  4)  Conversion of a null (zero-length) string to an integer is
+ *      technically not allowed. However, ACPICA allows this as an ACPI
+ *      extension. The conversion returns the value 0. (NO ERROR)
+ *
+ * NOTE: There are no error conditions returned by this function. At the
+ * minimum, a value of zero is returned.
+ *
+ * Current users of this function:
+ *
+ *  Interpreter - Runtime ASL ToInteger operator, as per the ACPI specification
  *
  ******************************************************************************/
 
-static UINT64
-AcpiUtStrtoulBase16 (
-    char                    *String,
-    UINT32                  Flags)
+UINT64
+AcpiUtExplicitStrtoul64 (
+    char                    *String)
 {
-    int                     AsciiDigit;
-    UINT32                  ValidDigits = 1;
-    UINT64                  ReturnValue = 0;
-
+    UINT64                  ConvertedInteger = 0;
+    UINT32                  Base = 10;          /* Default is decimal */
 
-    /* Main loop: convert each ASCII byte in the input string */
 
-    while (*String)
-    {
-        /* Check for overflow (32 or 64 bit) - return current converted value */
+    ACPI_FUNCTION_TRACE_STR (UtExplicitStrtoul64, String);
 
-        if ((ValidDigits > 16) ||
-            ((ValidDigits > 8) && (Flags & ACPI_STRTOUL_32BIT)))
-        {
-            goto Exit;
-        }
 
-        AsciiDigit = *String;
-        if (!isxdigit (AsciiDigit))
-        {
-            /* Not Hex ASCII A-F, a-f, or 0-9, terminate */
-
-            goto Exit;
-        }
+    if (!AcpiUtRemoveWhitespace (&String))
+    {
+        return_VALUE (0);
+    }
 
-        /* Convert and insert the hex digit */
+    /*
+     * Only Hex and Decimal are supported, as per the ACPI specification.
+     * A "0x" prefix indicates hex; otherwise decimal is assumed.
+     */
+    if (AcpiUtDetectHexPrefix (&String))
+    {
+        Base = 16;
+    }
 
-        AcpiUtShortShiftLeft (ReturnValue, 4, &ReturnValue);
-        ReturnValue |= AcpiUtAsciiCharToHex (AsciiDigit);
+    if (!AcpiUtRemoveLeadingZeros (&String))
+    {
+        return_VALUE (0);
+    }
 
-        String++;
-        ValidDigits++;
+    /*
+     * Ignore overflow as per the ACPI specification. This is implemented by
+     * ignoring the return status from the conversion functions called below.
+     * On overflow, the input string is simply truncated.
+     */
+    switch (Base)
+    {
+    case 10:
+    default:
+        AcpiUtConvertDecimalString (String, &ConvertedInteger);
+        break;
+
+    case 16:
+        AcpiUtConvertHexString (String, &ConvertedInteger);
+        break;
     }
 
-Exit:
-    return (ReturnValue);
+    return_VALUE (ConvertedInteger);
 }