Import ACPICA 20150717.vendor/acpica/20150717

101 files changed, 3047 insertions, 1481 deletions

diff --git a/source/common/adisasm.c b/source/common/adisasm.c
index 1fe6e06837ac..839bafecab30 100644
--- a/source/common/adisasm.c
+++ b/source/common/adisasm.c
@@ -187,6 +187,7 @@ AdInitialize (
     AcpiGbl_RootTableList.CurrentTableCount = 0;
     AcpiGbl_RootTableList.Tables = LocalTables;
 
+    AcpiGbl_PreviousOp = NULL;
     return (Status);
 }
 
@@ -796,8 +797,8 @@ AdStoreTable (
 
     AcpiTbInitTableDescriptor (TableDesc, ACPI_PTR_TO_PHYSADDR (Table),
         ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table);
-    AcpiTbValidateTable (TableDesc);
-    return (AE_OK);
+    Status = AcpiTbValidateTable (TableDesc);
+    return (Status);
 }
 
 
@@ -892,7 +893,7 @@ AdParseTable (
 
     /* Create the root object */
 
-    AcpiGbl_ParseOpRoot = AcpiPsCreateScopeOp ();
+    AcpiGbl_ParseOpRoot = AcpiPsCreateScopeOp (AmlStart);
     if (!AcpiGbl_ParseOpRoot)
     {
         return (AE_NO_MEMORY);
diff --git a/source/common/dmrestag.c b/source/common/dmrestag.c
index c10c364200f0..de81db569646 100644
--- a/source/common/dmrestag.c
+++ b/source/common/dmrestag.c
@@ -650,7 +650,7 @@ AcpiGetTagPathname (
 
     /* Get the full pathname to the parent buffer */
 
-    RequiredSize = AcpiNsGetPathnameLength (BufferNode);
+    RequiredSize = AcpiNsBuildNormalizedPath (BufferNode, NULL, 0, FALSE);
     if (!RequiredSize)
     {
         return (NULL);
@@ -662,12 +662,8 @@ AcpiGetTagPathname (
         return (NULL);
     }
 
-    Status = AcpiNsBuildExternalPath (BufferNode, RequiredSize, Pathname);
-    if (ACPI_FAILURE (Status))
-    {
-        ACPI_FREE (Pathname);
-        return (NULL);
-    }
+    (void) AcpiNsBuildNormalizedPath (BufferNode, Pathname,
+            RequiredSize, FALSE);
 
     /*
      * Create the full path to the resource and tag by: remove the buffer name,
diff --git a/source/common/dmtable.c b/source/common/dmtable.c
index 91fd6be87da7..9845ddeb219f 100644
--- a/source/common/dmtable.c
+++ b/source/common/dmtable.c
@@ -368,7 +368,7 @@ const ACPI_DMTABLE_DATA     AcpiDmTableData[] =
     {ACPI_SIG_SPMI, AcpiDmTableInfoSpmi,    NULL,           NULL,           TemplateSpmi},
     {ACPI_SIG_SRAT, NULL,                   AcpiDmDumpSrat, DtCompileSrat,  TemplateSrat},
     {ACPI_SIG_STAO, NULL,                   AcpiDmDumpStao, DtCompileStao,  TemplateStao},
-    {ACPI_SIG_TCPA, AcpiDmTableInfoTcpa,    NULL,           NULL,           TemplateTcpa},
+    {ACPI_SIG_TCPA, NULL,                   AcpiDmDumpTcpa, DtCompileTcpa,  TemplateTcpa},
     {ACPI_SIG_TPM2, AcpiDmTableInfoTpm2,    NULL,           NULL,           TemplateTpm2},
     {ACPI_SIG_UEFI, AcpiDmTableInfoUefi,    NULL,           DtCompileUefi,  TemplateUefi},
     {ACPI_SIG_VRTC, AcpiDmTableInfoVrtc,    AcpiDmDumpVrtc, DtCompileVrtc,  TemplateVrtc},
@@ -500,7 +500,11 @@ AcpiDmDumpDataTable (
     if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS))
     {
         Length = Table->Length;
-        AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
+        Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
     }
     else if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
     {
@@ -561,7 +565,11 @@ AcpiDmDumpDataTable (
         {
             /* Simple table, just walk the info table */
 
-            AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo);
+            Status = AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
         }
     }
 
@@ -720,6 +728,7 @@ AcpiDmDumpTable (
     const AH_TABLE          *TableData;
     const char              *Name;
     BOOLEAN                 LastOutputBlankLine = FALSE;
+    ACPI_STATUS             Status;
     char                    RepairedName[8];
 
 
@@ -1114,8 +1123,13 @@ AcpiDmDumpTable (
             /* Generic Address Structure */
 
             AcpiOsPrintf (STRING_FORMAT, "Generic Address Structure");
-            AcpiDmDumpTable (TableLength, CurrentOffset, Target,
+            Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
                 sizeof (ACPI_GENERIC_ADDRESS), AcpiDmTableInfoGas);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+
             AcpiOsPrintf ("\n");
             LastOutputBlankLine = TRUE;
             break;
@@ -1250,8 +1264,13 @@ AcpiDmDumpTable (
             AcpiOsPrintf (STRING_FORMAT,
                 "Hardware Error Notification Structure");
 
-            AcpiDmDumpTable (TableLength, CurrentOffset, Target,
+            Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
                 sizeof (ACPI_HEST_NOTIFY), AcpiDmTableInfoHestNotify);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+
             AcpiOsPrintf ("\n");
             LastOutputBlankLine = TRUE;
             break;
@@ -1275,8 +1294,13 @@ AcpiDmDumpTable (
             AcpiOsPrintf (STRING_FORMAT,
                 "IORT Memory Access Properties");
 
-            AcpiDmDumpTable (TableLength, CurrentOffset, Target,
+            Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
                 sizeof (ACPI_IORT_MEMORY_ACCESS), AcpiDmTableInfoIortAcc);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+
             LastOutputBlankLine = TRUE;
             break;
 
diff --git a/source/common/dmtbdump.c b/source/common/dmtbdump.c
index 4711b687ab0f..7ec19bc96026 100644
--- a/source/common/dmtbdump.c
+++ b/source/common/dmtbdump.c
@@ -208,11 +208,16 @@ AcpiDmDumpRsdp (
     ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
     UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
     UINT8                   Checksum;
+    ACPI_STATUS             Status;
 
 
     /* Dump the common ACPI 1.0 portion */
 
-    AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
+    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Length);
+    }
 
     /* Validate the first checksum */
 
@@ -229,7 +234,11 @@ AcpiDmDumpRsdp (
     if (Rsdp->Revision > 0)
     {
         Length = Rsdp->Length;
-        AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
+        Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Length);
+        }
 
         /* Validate the extended checksum over entire RSDP */
 
@@ -347,37 +356,59 @@ void
 AcpiDmDumpFadt (
     ACPI_TABLE_HEADER       *Table)
 {
+    ACPI_STATUS             Status;
+
 
     /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
 
-    AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
+    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
+    if (ACPI_FAILURE (Status))
+    {
+        return;
+    }
 
     /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
 
     if ((Table->Length > ACPI_FADT_V1_SIZE) &&
         (Table->Length <= ACPI_FADT_V2_SIZE))
     {
-        AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
+        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
     }
 
     /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
 
     else if (Table->Length > ACPI_FADT_V2_SIZE)
     {
-        AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
+        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
 
         /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
 
         if (Table->Length > ACPI_FADT_V3_SIZE)
         {
-            AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5);
+            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
         }
 
         /* Check for FADT revision 6 fields and up (ACPI 6.0+) */
 
         if (Table->Length > ACPI_FADT_V3_SIZE)
         {
-            AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt6);
+            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt6);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
         }
     }
 
@@ -1136,7 +1167,7 @@ AcpiDmDumpDrtm (
                 AcpiDmTableInfoDrtm1);
     if (ACPI_FAILURE (Status))
     {
-            return;
+        return;
     }
 
     Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
@@ -1164,13 +1195,9 @@ AcpiDmDumpDrtm (
 
     DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
     AcpiOsPrintf ("\n");
-    Status = AcpiDmDumpTable (Table->Length, Offset,
+    (void) AcpiDmDumpTable (Table->Length, Offset,
                 DrtmDps, sizeof (ACPI_DRTM_DPS_ID),
                 AcpiDmTableInfoDrtm2);
-    if (ACPI_FAILURE (Status))
-    {
-        return;
-    }
 }
 
 
@@ -1794,6 +1821,10 @@ AcpiDmDumpIort (
                 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
                             ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
                             Length, AcpiDmTableInfoIort3a);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
 
                 NodeOffset = IortSmmu->ContextInterruptOffset;
                 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
@@ -1801,6 +1832,10 @@ AcpiDmDumpIort (
                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
                                 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
                                 8, AcpiDmTableInfoIort3b);
+                    if (ACPI_FAILURE (Status))
+                    {
+                        return;
+                    }
                     NodeOffset += 8;
                 }
 
@@ -1810,6 +1845,10 @@ AcpiDmDumpIort (
                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
                                 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
                                 8, AcpiDmTableInfoIort3c);
+                    if (ACPI_FAILURE (Status))
+                    {
+                        return;
+                    }
                     NodeOffset += 8;
                 }
             }
@@ -1830,6 +1869,10 @@ AcpiDmDumpIort (
             Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
                         ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
                         Length, AcpiDmTableInfoIortMap);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
             NodeOffset += Length;
         }
 
@@ -2004,6 +2047,10 @@ AcpiDmDumpIvrs (
 
                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
                             DeviceEntry, EntryLength, InfoTable);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
 
                 EntryOffset += EntryLength;
                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
@@ -2687,6 +2734,11 @@ AcpiDmDumpNfit (
                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
                             &Interleave->LineOffset[i],
                             sizeof (UINT32), AcpiDmTableInfoNfit2a);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
+
                 FieldOffset += sizeof (UINT32);
             }
             break;
@@ -2715,6 +2767,11 @@ AcpiDmDumpNfit (
                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
                             &Hint->HintAddress[i],
                             sizeof (UINT64), AcpiDmTableInfoNfit6a);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
+
                 FieldOffset += sizeof (UINT64);
             }
             break;
@@ -3126,7 +3183,7 @@ void
 AcpiDmDumpSlic (
     ACPI_TABLE_HEADER       *Table)
 {
-    AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
+    (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
                 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
 }
 
@@ -3358,6 +3415,77 @@ AcpiDmDumpStao (
 
 /*******************************************************************************
  *
+ * FUNCTION:    AcpiDmDumpTcpa
+ *
+ * PARAMETERS:  Table               - A TCPA table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Format the contents of a TCPA.
+ *
+ * NOTE:        There are two versions of the table with the same signature:
+ *              the client version and the server version. The common
+ *              PlatformClass field is used to differentiate the two types of
+ *              tables.
+ *
+ ******************************************************************************/
+
+void
+AcpiDmDumpTcpa (
+    ACPI_TABLE_HEADER       *Table)
+{
+    UINT32                  Offset = sizeof (ACPI_TABLE_TCPA_HDR);
+    ACPI_TABLE_TCPA_HDR     *CommonHeader = ACPI_CAST_PTR (
+                                ACPI_TABLE_TCPA_HDR, Table);
+    ACPI_TABLE_TCPA_HDR     *SubTable = ACPI_ADD_PTR (
+                                ACPI_TABLE_TCPA_HDR, Table, Offset);
+    ACPI_STATUS             Status;
+
+
+    /* Main table */
+
+    Status = AcpiDmDumpTable (Table->Length, 0, Table,
+        0, AcpiDmTableInfoTcpaHdr);
+    if (ACPI_FAILURE (Status))
+    {
+        return;
+    }
+
+    /*
+     * Examine the PlatformClass field to determine the table type.
+     * Either a client or server table. Only one.
+     */
+    switch (CommonHeader->PlatformClass)
+    {
+    case ACPI_TCPA_CLIENT_TABLE:
+
+        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
+            Table->Length - Offset, AcpiDmTableInfoTcpaClient);
+        break;
+
+    case ACPI_TCPA_SERVER_TABLE:
+
+        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
+            Table->Length - Offset, AcpiDmTableInfoTcpaServer);
+        break;
+
+    default:
+
+        AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
+            CommonHeader->PlatformClass);
+        Status = AE_ERROR;
+        break;
+    }
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
+    }
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    AcpiDmDumpVrtc
  *
  * PARAMETERS:  Table               - A VRTC table
@@ -3497,10 +3625,6 @@ AcpiDmDumpWpbt (
 
     /* Dump the arguments buffer */
 
-    AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
+    (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
         AcpiDmTableInfoWpbt0);
-    if (ACPI_FAILURE (Status))
-    {
-        return;
-    }
 }
diff --git a/source/common/dmtbinfo.c b/source/common/dmtbinfo.c
index 50a1ee07106b..3a0256619f75 100644
--- a/source/common/dmtbinfo.c
+++ b/source/common/dmtbinfo.c
@@ -113,7 +113,7 @@
 #define ACPI_SPMI_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_SPMI,f)
 #define ACPI_SRAT_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_SRAT,f)
 #define ACPI_STAO_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_STAO,f)
-#define ACPI_TCPA_CLIENT_OFFSET(f)      (UINT16) ACPI_OFFSET (ACPI_TABLE_TCPA_CLIENT,f)
+#define ACPI_TCPA_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_TCPA_HDR,f)
 #define ACPI_TPM2_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_TPM2,f)
 #define ACPI_UEFI_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_UEFI,f)
 #define ACPI_WAET_OFFSET(f)             (UINT16) ACPI_OFFSET (ACPI_TABLE_WAET,f)
@@ -230,6 +230,8 @@
 #define ACPI_SRAT1_OFFSET(f)            (UINT16) ACPI_OFFSET (ACPI_SRAT_MEM_AFFINITY,f)
 #define ACPI_SRAT2_OFFSET(f)            (UINT16) ACPI_OFFSET (ACPI_SRAT_X2APIC_CPU_AFFINITY,f)
 #define ACPI_SRAT3_OFFSET(f)            (UINT16) ACPI_OFFSET (ACPI_SRAT_GICC_AFFINITY,f)
+#define ACPI_TCPA_CLIENT_OFFSET(f)      (UINT16) ACPI_OFFSET (ACPI_TABLE_TCPA_CLIENT,f)
+#define ACPI_TCPA_SERVER_OFFSET(f)      (UINT16) ACPI_OFFSET (ACPI_TABLE_TCPA_SERVER,f)
 #define ACPI_VRTC0_OFFSET(f)            (UINT16) ACPI_OFFSET (ACPI_VRTC_ENTRY,f)
 #define ACPI_WDAT0_OFFSET(f)            (UINT16) ACPI_OFFSET (ACPI_WDAT_ENTRY,f)
 
@@ -2613,16 +2615,53 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoStaoStr[] =
  *
  * TCPA - Trusted Computing Platform Alliance table (Client)
  *
+ * NOTE: There are two versions of the table with the same signature --
+ * the client version and the server version. The common PlatformClass
+ * field is used to differentiate the two types of tables.
+ *
  ******************************************************************************/
 
-ACPI_DMTABLE_INFO           AcpiDmTableInfoTcpa[] =
+ACPI_DMTABLE_INFO           AcpiDmTableInfoTcpaHdr[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_TCPA_OFFSET (PlatformClass),           "Platform Class", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoTcpaClient[] =
 {
-    {ACPI_DMT_UINT16,   ACPI_TCPA_CLIENT_OFFSET (PlatformClass),    "Platform Class", 0},
     {ACPI_DMT_UINT32,   ACPI_TCPA_CLIENT_OFFSET (MinimumLogLength), "Min Event Log Length", 0},
     {ACPI_DMT_UINT64,   ACPI_TCPA_CLIENT_OFFSET (LogAddress),       "Event Log Address", 0},
     ACPI_DMT_TERMINATOR
 };
 
+ACPI_DMTABLE_INFO           AcpiDmTableInfoTcpaServer[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_TCPA_SERVER_OFFSET (Reserved),         "Reserved", 0},
+    {ACPI_DMT_UINT64,   ACPI_TCPA_SERVER_OFFSET (MinimumLogLength), "Min Event Log Length", 0},
+    {ACPI_DMT_UINT64,   ACPI_TCPA_SERVER_OFFSET (LogAddress),       "Event Log Address", 0},
+    {ACPI_DMT_UINT16,   ACPI_TCPA_SERVER_OFFSET (SpecRevision),     "Specification Revision", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (DeviceFlags),      "Device Flags (decoded below)", DT_FLAG},
+    {ACPI_DMT_FLAG0,    ACPI_TCPA_SERVER_OFFSET (DeviceFlags),      "Pci Device", 0},
+    {ACPI_DMT_FLAG1,    ACPI_TCPA_SERVER_OFFSET (DeviceFlags),      "Bus is Pnp", 0},
+    {ACPI_DMT_FLAG2,    ACPI_TCPA_SERVER_OFFSET (DeviceFlags),      "Address Valid", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (InterruptFlags),   "Interrupt Flags (decoded below)", DT_FLAG},
+    {ACPI_DMT_FLAG0,    ACPI_TCPA_SERVER_OFFSET (InterruptFlags),   "Mode", 0},
+    {ACPI_DMT_FLAG1,    ACPI_TCPA_SERVER_OFFSET (InterruptFlags),   "Polarity", 0},
+    {ACPI_DMT_FLAG2,    ACPI_TCPA_SERVER_OFFSET (InterruptFlags),   "GPE SCI Triggered", 0},
+    {ACPI_DMT_FLAG3,    ACPI_TCPA_SERVER_OFFSET (InterruptFlags),   "Global System Interrupt", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (GpeNumber),        "Gpe Number", 0},
+    {ACPI_DMT_UINT24,   ACPI_TCPA_SERVER_OFFSET (Reserved2[0]),     "Reserved", 0},
+    {ACPI_DMT_UINT32,   ACPI_TCPA_SERVER_OFFSET (GlobalInterrupt),  "Global Interrupt", 0},
+    {ACPI_DMT_GAS,      ACPI_TCPA_SERVER_OFFSET (Address),          "Address", 0},
+    {ACPI_DMT_UINT32,   ACPI_TCPA_SERVER_OFFSET (Reserved3),        "Reserved", 0},
+    {ACPI_DMT_GAS,      ACPI_TCPA_SERVER_OFFSET (ConfigAddress),    "Configuration Address", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (Group),            "Pci Group", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (Bus),              "Pci Bus", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (Device),           "Pci Device", 0},
+    {ACPI_DMT_UINT8,    ACPI_TCPA_SERVER_OFFSET (Function),         "Pci Function", 0},
+    ACPI_DMT_TERMINATOR
+};
+
 
 /*******************************************************************************
  *
diff --git a/source/compiler/aslascii.c b/source/compiler/aslascii.c
index 7ff1c4a653c7..f164e98f5edf 100644
--- a/source/compiler/aslascii.c
+++ b/source/compiler/aslascii.c
@@ -177,6 +177,11 @@ FlCheckForAscii (
     /* Open file in text mode so file offset is always accurate */
 
     Handle = fopen (Filename, "rb");
+    if (!Handle)
+    {
+        perror ("Could not open input file");
+        return (AE_ERROR);
+    }
 
     Status.Line = 1;
     Status.Offset = 0;
diff --git a/source/compiler/aslcompile.c b/source/compiler/aslcompile.c
index afc004d7deee..9e5b53a51274 100644
--- a/source/compiler/aslcompile.c
+++ b/source/compiler/aslcompile.c
@@ -100,6 +100,10 @@ CmDoCompile (
     Event = UtBeginEvent ("Preprocess input file");
     if (Gbl_PreprocessFlag)
     {
+        /* Enter compiler name as a #define */
+
+        PrAddDefine (ASL_DEFINE, "", FALSE);
+
         /* Preprocessor */
 
         PrDoPreprocess ();
diff --git a/source/compiler/asldefine.h b/source/compiler/asldefine.h
index 0b5f614a6481..9e42ddf8b248 100644
--- a/source/compiler/asldefine.h
+++ b/source/compiler/asldefine.h
@@ -52,6 +52,7 @@
 #define AML_DISASSEMBLER_NAME       "AML/ASL+ Disassembler"
 #define ASL_INVOCATION_NAME         "iasl"
 #define ASL_CREATOR_ID              "INTL"
+#define ASL_DEFINE                  "__IASL__"
 
 #define ASL_COMPLIANCE              "Supports ACPI Specification Revision 6.0"
 
@@ -155,12 +156,6 @@
 #define ACPI_COMPILER_RESERVED_NAME     (ACPI_UINT32_MAX - 3)
 
 
-/* String to Integer conversion */
-
-#define NEGATIVE                    1
-#define POSITIVE                    0
-
-
 /* Helper macros for resource tag creation */
 
 #define RsCreateMultiBitField \
diff --git a/source/compiler/aslfiles.c b/source/compiler/aslfiles.c
index 2ad62ecc18a4..1b738ccf15d8 100644
--- a/source/compiler/aslfiles.c
+++ b/source/compiler/aslfiles.c
@@ -546,6 +546,26 @@ FlOpenMiscOutputFiles (
     char                    *Filename;
 
 
+     /* Create/Open a map file if requested */
+
+    if (Gbl_MapfileFlag)
+    {
+        Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_MAP);
+        if (!Filename)
+        {
+            AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
+                0, 0, 0, 0, NULL, NULL);
+            return (AE_ERROR);
+        }
+
+        /* Open the hex file, text mode (closed at compiler exit) */
+
+        FlOpenFile (ASL_FILE_MAP_OUTPUT, Filename, "w+t");
+
+        AslCompilerSignon (ASL_FILE_MAP_OUTPUT);
+        AslCompilerFileHeader (ASL_FILE_MAP_OUTPUT);
+    }
+
     /* All done for disassembler */
 
     if (Gbl_FileType == ASL_INPUT_TYPE_ACPI_TABLE)
@@ -812,26 +832,6 @@ FlOpenMiscOutputFiles (
         AslCompilerFileHeader (ASL_FILE_NAMESPACE_OUTPUT);
     }
 
-    /* Create/Open a map file if requested */
-
-    if (Gbl_MapfileFlag)
-    {
-        Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_MAP);
-        if (!Filename)
-        {
-            AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
-                0, 0, 0, 0, NULL, NULL);
-            return (AE_ERROR);
-        }
-
-        /* Open the hex file, text mode (closed at compiler exit) */
-
-        FlOpenFile (ASL_FILE_MAP_OUTPUT, Filename, "w+t");
-
-        AslCompilerSignon (ASL_FILE_MAP_OUTPUT);
-        AslCompilerFileHeader (ASL_FILE_MAP_OUTPUT);
-    }
-
     return (AE_OK);
 }
 
diff --git a/source/compiler/asllookup.c b/source/compiler/asllookup.c
index 61148225ffd6..49b4901b8a91 100644
--- a/source/compiler/asllookup.c
+++ b/source/compiler/asllookup.c
@@ -119,8 +119,73 @@ LkIsObjectUsed (
 {
     ACPI_NAMESPACE_NODE     *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
     ACPI_NAMESPACE_NODE     *Next;
+    ASL_METHOD_LOCAL        *MethodLocals;
+    ASL_METHOD_LOCAL        *MethodArgs;
+    UINT32                  i;
 
 
+    if (Node->Type == ACPI_TYPE_METHOD)
+    {
+        if (!Node->Op || !Node->MethodLocals)
+        {
+            return (AE_OK);
+        }
+
+        MethodLocals = (ASL_METHOD_LOCAL *) Node->MethodLocals;
+        MethodArgs = (ASL_METHOD_LOCAL *) Node->MethodArgs;
+
+        /*
+         * Analysis of LocalX variables
+         */
+        for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++)
+        {
+            /* Warn for Locals that are set but never referenced */
+
+            if ((MethodLocals[i].Flags & ASL_LOCAL_INITIALIZED) &&
+                (!(MethodLocals[i].Flags & ASL_LOCAL_REFERENCED)))
+            {
+                sprintf (MsgBuffer, "Local%u", i);
+                AslError (ASL_WARNING, ASL_MSG_LOCAL_NOT_USED,
+                    MethodLocals[i].Op, MsgBuffer);
+            }
+        }
+
+        /*
+         * Analysis of ArgX variables (standard method arguments,
+         * and remaining unused ArgX can also be used as locals)
+         */
+        for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++)
+        {
+            if (MethodArgs[i].Flags & ASL_ARG_IS_LOCAL)
+            {
+                /* Warn if ArgX is being used as a local, but not referenced */
+
+                if ((MethodArgs[i].Flags & ASL_ARG_INITIALIZED) &&
+                    (!(MethodArgs[i].Flags & ASL_ARG_REFERENCED)))
+                {
+                    sprintf (MsgBuffer, "Arg%u", i);
+                    AslError (ASL_WARNING, ASL_MSG_ARG_AS_LOCAL_NOT_USED,
+                        MethodArgs[i].Op, MsgBuffer);
+                }
+            }
+            else
+            {
+                /*
+                 * Remark if a normal method ArgX is not referenced.
+                 * We ignore the predefined methods since often, not
+                 * all arguments are needed or used.
+                 */
+                if ((Node->Name.Ascii[0] != '_') &&
+                    (!(MethodArgs[i].Flags & ASL_ARG_REFERENCED)))
+                {
+                    sprintf (MsgBuffer, "Arg%u", i);
+                    AslError (ASL_REMARK, ASL_MSG_ARG_NOT_USED,
+                        MethodArgs[i].Op, MsgBuffer);
+                }
+            }
+        }
+    }
+
     /* Referenced flag is set during the namespace xref */
 
     if (Node->Flags & ANOBJ_IS_REFERENCED)
diff --git a/source/compiler/aslmessages.c b/source/compiler/aslmessages.c
index 520ebe0760fe..bd693110e0a5 100644
--- a/source/compiler/aslmessages.c
+++ b/source/compiler/aslmessages.c
@@ -235,7 +235,11 @@ const char                      *AslCompilerMsgs [] =
 /*    ASL_MSG_BUFFER_ALLOCATION */          "Could not allocate line buffer",
 /*    ASL_MSG_MISSING_DEPENDENCY */         "Missing dependency",
 /*    ASL_MSG_ILLEGAL_FORWARD_REF */        "Illegal forward reference within a method",
-/*    ASL_MSG_ILLEGAL_METHOD_REF */         "Illegal reference across two methods"
+/*    ASL_MSG_ILLEGAL_METHOD_REF */         "Illegal reference across two methods",
+/*    ASL_MSG_LOCAL_NOT_USED */             "Method Local is set but never used",
+/*    ASL_MSG_ARG_AS_LOCAL_NOT_USED */      "Method Argument (as a local) is set but never used",
+/*    ASL_MSG_ARG_NOT_USED */               "Method Argument is never used"
+
 };
 
 /* Table compiler */
diff --git a/source/compiler/aslmessages.h b/source/compiler/aslmessages.h
index 9837d540698f..d7e3dd06e8b6 100644
--- a/source/compiler/aslmessages.h
+++ b/source/compiler/aslmessages.h
@@ -238,6 +238,9 @@ typedef enum
     ASL_MSG_MISSING_DEPENDENCY,
     ASL_MSG_ILLEGAL_FORWARD_REF,
     ASL_MSG_ILLEGAL_METHOD_REF,
+    ASL_MSG_LOCAL_NOT_USED,
+    ASL_MSG_ARG_AS_LOCAL_NOT_USED,
+    ASL_MSG_ARG_NOT_USED,
 
     /* These messages are used by the Data Table compiler only */
 
diff --git a/source/compiler/aslmethod.c b/source/compiler/aslmethod.c
index 6d53cec5555d..40ed971e0712 100644
--- a/source/compiler/aslmethod.c
+++ b/source/compiler/aslmethod.c
@@ -255,7 +255,7 @@ MtMethodAnalysisWalkBegin (
             return (AE_ERROR);
         }
 
-        RegisterNumber = (Op->Asl.AmlOpcode & 0x000F);
+        RegisterNumber = (Op->Asl.AmlOpcode & 0x0007);
 
         /*
          * If the local is being used as a target, mark the local
diff --git a/source/compiler/aslnamesp.c b/source/compiler/aslnamesp.c
index c35ebfd6b4ac..e2dea6fff5f6 100644
--- a/source/compiler/aslnamesp.c
+++ b/source/compiler/aslnamesp.c
@@ -409,7 +409,7 @@ NsDoOnePathname (
 
 
     TargetPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (Node, &TargetPath);
+    Status = AcpiNsHandleToPathname (Node, &TargetPath, FALSE);
     if (ACPI_FAILURE (Status))
     {
         return (Status);
diff --git a/source/compiler/asloffset.c b/source/compiler/asloffset.c
index baf436ef8dc4..b1e6f5ac146f 100644
--- a/source/compiler/asloffset.c
+++ b/source/compiler/asloffset.c
@@ -363,7 +363,7 @@ LsEmitOffsetTableEntry (
     /* Get the full pathname to the namespace node */
 
     TargetPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (Node, &TargetPath);
+    Status = AcpiNsHandleToPathname (Node, &TargetPath, FALSE);
     if (ACPI_FAILURE (Status))
     {
         return;
diff --git a/source/compiler/aslopcodes.c b/source/compiler/aslopcodes.c
index fa3d1fca0e11..a7f14de6d3b8 100644
--- a/source/compiler/aslopcodes.c
+++ b/source/compiler/aslopcodes.c
@@ -791,43 +791,6 @@ OpcEncodePldBuffer (
 
 /*******************************************************************************
  *
- * FUNCTION:    OpcStrupr (strupr)
- *
- * PARAMETERS:  SrcString           - The source string to convert
- *
- * RETURN:      None
- *
- * DESCRIPTION: Convert string to uppercase
- *
- * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
- *
- ******************************************************************************/
-
-static void
-OpcStrupr (
-    char                    *SrcString)
-{
-    char                    *String;
-
-
-    if (!SrcString)
-    {
-        return;
-    }
-
-    /* Walk entire string, uppercasing the letters */
-
-    for (String = SrcString; *String; String++)
-    {
-        *String = (char) toupper ((int) *String);
-    }
-
-    return;
-}
-
-
-/*******************************************************************************
- *
  * FUNCTION:    OpcFindName
  *
  * PARAMETERS:  List                - Array of char strings to be searched
@@ -851,7 +814,7 @@ OpcFindName (
     UINT32                   i;
 
 
-    OpcStrupr (Name);
+    AcpiUtStrupr (Name);
 
     for (i = 0, Str = List[0]; Str; i++, Str = List[i])
     {
@@ -900,13 +863,6 @@ OpcDoPld (
         return;
     }
 
-    Buffer = UtLocalCalloc (ACPI_PLD_BUFFER_SIZE);
-    if (!Buffer)
-    {
-        AslError(ASL_ERROR, ASL_MSG_BUFFER_ALLOCATION, Op, NULL);
-        return;
-    }
-
     memset (&PldInfo, 0, sizeof (ACPI_PLD_INFO));
 
     Node = Op->Asl.Child;
diff --git a/source/compiler/aslopt.c b/source/compiler/aslopt.c
index 7770f3eb4bb1..e41e22f087b0 100644
--- a/source/compiler/aslopt.c
+++ b/source/compiler/aslopt.c
@@ -655,7 +655,7 @@ OptOptimizeNamePath (
      * format -- something we can easily manipulate
      */
     TargetPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (TargetNode, &TargetPath);
+    Status = AcpiNsHandleToPathname (TargetNode, &TargetPath, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AslCoreSubsystemError (Op, Status, "Getting Target NamePath",
@@ -667,7 +667,7 @@ OptOptimizeNamePath (
     /* CurrentPath is the path to this scope (where we are in the namespace) */
 
     CurrentPath.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (CurrentNode, &CurrentPath);
+    Status = AcpiNsHandleToPathname (CurrentNode, &CurrentPath, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AslCoreSubsystemError (Op, Status, "Getting Current NamePath",
diff --git a/source/compiler/asloptions.c b/source/compiler/asloptions.c
index 57bb12b03f8e..69c83257a550 100644
--- a/source/compiler/asloptions.c
+++ b/source/compiler/asloptions.c
@@ -286,6 +286,11 @@ AslDoOptions (
             AcpiGbl_CstyleDisassembly = FALSE;
             break;
 
+        case 'v':
+
+            AcpiGbl_DbOpt_Verbose = TRUE;
+            break;
+
         default:
 
             printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
diff --git a/source/compiler/aslstartup.c b/source/compiler/aslstartup.c
index 1ec9a351e2cd..0e05da401c0b 100644
--- a/source/compiler/aslstartup.c
+++ b/source/compiler/aslstartup.c
@@ -246,6 +246,11 @@ AslDoDisassembly (
         return (Status);
     }
 
+    /* Handle additional output files for disassembler */
+
+    Gbl_FileType = ASL_INPUT_TYPE_ACPI_TABLE;
+    Status = FlOpenMiscOutputFiles (Gbl_OutputFilenamePrefix);
+
     /* This is where the disassembly happens */
 
     AcpiGbl_DbOpt_Disasm = TRUE;
@@ -261,13 +266,6 @@ AslDoDisassembly (
 
     AcpiDmUnresolvedWarning (0);
 
-#if 0
-    /* TBD: Handle additional output files for disassembler */
-
-    Status = FlOpenMiscOutputFiles (Gbl_OutputFilenamePrefix);
-    NsDisplayNamespace ();
-#endif
-
     /* Shutdown compiler and ACPICA subsystem */
 
     AeClearErrorLog ();
diff --git a/source/compiler/aslstubs.c b/source/compiler/aslstubs.c
index d624fc43cd29..26f607fbbe9c 100644
--- a/source/compiler/aslstubs.c
+++ b/source/compiler/aslstubs.c
@@ -165,15 +165,6 @@ AcpiEvInitializeRegion (
     return (AE_OK);
 }
 
-void
-AcpiExDoDebugObject (
-    ACPI_OPERAND_OBJECT     *SourceDesc,
-    UINT32                  Level,
-    UINT32                  Index)
-{
-    return;
-}
-
 ACPI_STATUS
 AcpiExReadDataFromField (
     ACPI_WALK_STATE         *WalkState,
@@ -216,6 +207,60 @@ AcpiExLoadOp (
     return (AE_SUPPORT);
 }
 
+void
+AcpiExDoDebugObject (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    UINT32                  Level,
+    UINT32                  Index)
+{
+    return;
+}
+
+void
+AcpiExStartTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStopTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStartTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStopTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+
+{
+    return;
+}
+
+void
+AcpiExTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname)
+{
+    return;
+}
+
 ACPI_STATUS
 AcpiTbFindTable (
     char                    *Signature,
diff --git a/source/compiler/asltypes.h b/source/compiler/asltypes.h
index 343c364c49ff..ce2f75888ff5 100644
--- a/source/compiler/asltypes.h
+++ b/source/compiler/asltypes.h
@@ -302,5 +302,19 @@ typedef struct acpi_serial_info
 
 } ACPI_SERIAL_INFO;
 
+typedef struct asl_method_local
+{
+    ACPI_PARSE_OBJECT       *Op;
+    UINT8                   Flags;
+
+} ASL_METHOD_LOCAL;
+
+/* Values for Flags field above */
+
+#define ASL_LOCAL_INITIALIZED   (1)
+#define ASL_LOCAL_REFERENCED    (1<<1)
+#define ASL_ARG_IS_LOCAL        (1<<2)
+#define ASL_ARG_INITIALIZED     (1<<3)
+#define ASL_ARG_REFERENCED      (1<<4)
 
 #endif  /* __ASLTYPES_H */
diff --git a/source/compiler/aslutils.c b/source/compiler/aslutils.c
index 8b77c8e1f4fa..9ea4c19c48a0 100644
--- a/source/compiler/aslutils.c
+++ b/source/compiler/aslutils.c
@@ -1008,17 +1008,17 @@ stroul64 (
      */
     if (*String == '-')
     {
-        Sign = NEGATIVE;
+        Sign = ACPI_SIGN_NEGATIVE;
         ++String;
     }
     else if (*String == '+')
     {
         ++String;
-        Sign = POSITIVE;
+        Sign = ACPI_SIGN_POSITIVE;
     }
     else
     {
-        Sign = POSITIVE;
+        Sign = ACPI_SIGN_POSITIVE;
     }
 
     /*
@@ -1106,7 +1106,7 @@ stroul64 (
 
     /* If a minus sign was present, then "the conversion is negated": */
 
-    if (Sign == NEGATIVE)
+    if (Sign == ACPI_SIGN_NEGATIVE)
     {
         ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
     }
diff --git a/source/compiler/aslxref.c b/source/compiler/aslxref.c
index 8ffe5ad6a1d1..6b65bb1699bf 100644
--- a/source/compiler/aslxref.c
+++ b/source/compiler/aslxref.c
@@ -66,6 +66,10 @@ XfNamespaceLocateEnd (
     UINT32                  Level,
     void                    *Context);
 
+static ACPI_PARSE_OBJECT *
+XfGetParentMethod (
+    ACPI_PARSE_OBJECT       *Op);
+
 static BOOLEAN
 XfObjectExists (
     char                    *Name);
@@ -280,59 +284,16 @@ XfCheckFieldRange (
 }
 
 
-#ifdef __UNDER_DEVELOPMENT
-/*******************************************************************************
- *
- * FUNCTION:    XfIsObjectParental
- *
- * PARAMETERS:  ChildOp                 - Op to be checked
- *              PossibleParentOp        - Determine if this op is in the family
- *
- * RETURN:      TRUE if ChildOp is a descendent of PossibleParentOp
- *
- * DESCRIPTION: Determine if an Op is a descendent of another Op. Used to
- *              detect if a method is declared within another method.
- *
- ******************************************************************************/
-
-static BOOLEAN
-XfIsObjectParental (
-    ACPI_PARSE_OBJECT       *ChildOp,
-    ACPI_PARSE_OBJECT       *PossibleParentOp)
-{
-    ACPI_PARSE_OBJECT       *ParentOp;
-
-
-    /* Search upwards through the tree for possible parent */
-
-    ParentOp = ChildOp;
-    while (ParentOp)
-    {
-        if (ParentOp == PossibleParentOp)
-        {
-            return (TRUE);
-        }
-
-        ParentOp = ParentOp->Asl.Parent;
-    }
-
-    return (FALSE);
-}
-
-
 /*******************************************************************************
  *
  * FUNCTION:    XfGetParentMethod
  *
- * PARAMETERS:  Op                      - Op to be checked
- *
- * RETURN:      Op for parent method. NULL if object is not within a method.
+ * PARAMETERS:  Op                      - Parse Op to be checked
  *
- * DESCRIPTION: Determine if an object is within a control method. Used to
- *              implement special rules for named references from within a
- *              control method.
+ * RETURN:      Control method Op if found. NULL otherwise
  *
- * NOTE: It would be better to have the parser set a flag in the Op if possible.
+ * DESCRIPTION: Find the control method parent of a parse op. Returns NULL if
+ *              the input Op is not within a control method.
  *
  ******************************************************************************/
 
@@ -340,120 +301,22 @@ static ACPI_PARSE_OBJECT *
 XfGetParentMethod (
     ACPI_PARSE_OBJECT       *Op)
 {
-    ACPI_PARSE_OBJECT       *ParentOp;
-
-
-    if (!Op)
-    {
-        return (NULL);
-    }
-
-    if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
-    {
-        return (NULL);
-    }
-
-    /* Walk upwards through the parse tree, up to the root if necessary */
-
-    ParentOp = Op;
-    while (ParentOp)
-    {
-        if (ParentOp->Asl.ParseOpcode == PARSEOP_METHOD)
-        {
-            return (ParentOp);
-        }
-
-        ParentOp = ParentOp->Asl.Parent;
-    }
-
-    /* Object is not within a method */
-
-    return (NULL);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    XfCheckIllegalReference
- *
- * PARAMETERS:  Op                      - Op referring to the target
- *              TargetNode              - Target of the reference
- *
- * RETURN:      None. Emits error message for an illegal reference
- *
- * DESCRIPTION: Determine if a named reference is legal. A "named" reference
- *              is something like: Store(ABCD, ...), where ABCD is an AML
- *              Nameseg or Namepath.
- *
- * NOTE: Caller must ensure that the name Op is in fact a reference, and not
- *       an actual name declaration (creation of a named object).
- *
- ******************************************************************************/
-
-static void
-XfCheckIllegalReference (
-    ACPI_PARSE_OBJECT       *Op,
-    ACPI_NAMESPACE_NODE     *TargetNode)
-{
-    ACPI_PARSE_OBJECT       *MethodOp1;
-    ACPI_PARSE_OBJECT       *MethodOp2;
-    ACPI_PARSE_OBJECT       *TargetOp;
-
-
-    /*
-     * Check for an illegal reference to a named object:
-     *
-     * 1) References from one control method to another, non-parent
-     *    method are not allowed, they will fail at runtime.
-     *
-     * 2) Forward references within a control method are not allowed.
-     *    AML interpreters use a one-pass parse of control methods
-     *    so these forward references will fail at runtime.
-     */
-    TargetOp = TargetNode->Op;
-
-    MethodOp1 = XfGetParentMethod (Op);
-    MethodOp2 = XfGetParentMethod (TargetOp);
-
-    /* Are both objects within control method(s)? */
-
-    if (!MethodOp1 || !MethodOp2)
-    {
-        return;
-    }
+    ACPI_PARSE_OBJECT       *NextOp;
 
-    /* Objects not in the same method? */
 
-    if (MethodOp1 != MethodOp2)
+    NextOp = Op->Asl.Parent;
+    while (NextOp)
     {
-        /*
-         * 1) Cross-method named reference
-         *
-         * This is OK if and only if the target reference is within in a
-         * method that is a parent of current method
-         */
-        if (!XfIsObjectParental (MethodOp1, MethodOp2))
+        if (NextOp->Asl.AmlOpcode == AML_METHOD_OP)
         {
-            AslError (ASL_ERROR, ASL_MSG_ILLEGAL_METHOD_REF, Op,
-                Op->Asl.ExternalName);
+            return (NextOp);
         }
-    }
 
-    /*
-     * 2) Both reference and target are in the same method. Check if this is
-     * an (illegal) forward reference by examining the exact source code
-     * location of each (the referenced object and the object declaration).
-     * This is a bit nasty, yet effective.
-     */
-    else if (Op->Asl.LogicalByteOffset < TargetOp->Asl.LogicalByteOffset)
-    {
-        AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
-            Op->Asl.ExternalName);
+        NextOp = NextOp->Asl.Parent;
     }
 
+    return (NULL); /* No parent method found */
 }
-#endif
-
 
 /*******************************************************************************
  *
@@ -496,10 +359,67 @@ XfNamespaceLocateBegin (
     UINT8                   Message = 0;
     const ACPI_OPCODE_INFO  *OpInfo;
     UINT32                  Flags;
+    ASL_METHOD_LOCAL        *MethodLocals = NULL;
+    ASL_METHOD_LOCAL        *MethodArgs = NULL;
+    int                     RegisterNumber;
+    UINT32                  i;
 
 
     ACPI_FUNCTION_TRACE_PTR (XfNamespaceLocateBegin, Op);
 
+
+    if ((Op->Asl.AmlOpcode == AML_METHOD_OP) && Op->Asl.Node)
+    {
+        Node = Op->Asl.Node;
+
+        /* Support for method LocalX/ArgX analysis */
+
+        if (!Node->MethodLocals)
+        {
+            /* Create local/arg info blocks */
+
+            MethodLocals = UtLocalCalloc (
+                sizeof (ASL_METHOD_LOCAL) * ACPI_METHOD_NUM_LOCALS);
+            Node->MethodLocals = MethodLocals;
+
+            MethodArgs = UtLocalCalloc (
+                sizeof (ASL_METHOD_LOCAL) * ACPI_METHOD_NUM_ARGS);
+            Node->MethodArgs = MethodArgs;
+
+            /*
+             * Get the method argument count
+             * First, get the name node
+             */
+            NextOp = Op->Asl.Child;
+
+            /* Get the NumArguments node */
+
+            NextOp = NextOp->Asl.Next;
+            Node->ArgCount = (UINT8)
+                (((UINT8) NextOp->Asl.Value.Integer) & 0x07);
+
+            /* We will track all posible ArgXs */
+
+            for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++)
+            {
+                if (i < Node->ArgCount)
+                {
+                    /* Real Args are always "initialized" */
+
+                    MethodArgs[i].Flags = ASL_ARG_INITIALIZED;
+                }
+                else
+                {
+                    /* Other ArgXs can be used as locals */
+
+                    MethodArgs[i].Flags = ASL_ARG_IS_LOCAL;
+                }
+
+                MethodArgs[i].Op = Op;
+            }
+        }
+    }
+
     /*
      * If this node is the actual declaration of a name
      * [such as the XXXX name in "Method (XXXX)"],
@@ -512,10 +432,88 @@ XfNamespaceLocateBegin (
         return_ACPI_STATUS (AE_OK);
     }
 
-    /* We are only interested in opcodes that have an associated name */
-
     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 
+    /* Check method LocalX variables */
+
+    if (OpInfo->Type == AML_TYPE_LOCAL_VARIABLE)
+    {
+        /* Find parent method Op */
+
+        NextOp = XfGetParentMethod (Op);
+        if (!NextOp)
+        {
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Get method node */
+
+        Node = NextOp->Asl.Node;
+
+        RegisterNumber = Op->Asl.AmlOpcode & 0x0007; /* 0x60 through 0x67 */
+        MethodLocals = Node->MethodLocals;
+
+        if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+        {
+            /* Local is being initialized */
+
+            MethodLocals[RegisterNumber].Flags |= ASL_LOCAL_INITIALIZED;
+            MethodLocals[RegisterNumber].Op = Op;
+
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Mark this Local as referenced */
+
+        MethodLocals[RegisterNumber].Flags |= ASL_LOCAL_REFERENCED;
+        MethodLocals[RegisterNumber].Op = Op;
+
+        return_ACPI_STATUS (AE_OK);
+    }
+
+    /* Check method ArgX variables */
+
+    if (OpInfo->Type == AML_TYPE_METHOD_ARGUMENT)
+    {
+        /* Find parent method Op */
+
+        NextOp = XfGetParentMethod (Op);
+        if (!NextOp)
+        {
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Get method node */
+
+        Node = NextOp->Asl.Node;
+
+        /* Get Arg # */
+
+        RegisterNumber = Op->Asl.AmlOpcode - AML_ARG0; /* 0x68 through 0x6F */
+        MethodArgs = Node->MethodArgs;
+
+        if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+        {
+            /* Arg is being initialized */
+
+            MethodArgs[RegisterNumber].Flags |= ASL_ARG_INITIALIZED;
+            MethodArgs[RegisterNumber].Op = Op;
+
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Mark this Arg as referenced */
+
+        MethodArgs[RegisterNumber].Flags |= ASL_ARG_REFERENCED;
+        MethodArgs[RegisterNumber].Op = Op;
+
+        return_ACPI_STATUS (AE_OK);
+    }
+
+    /*
+     * After method ArgX and LocalX, we are only interested in opcodes
+     * that have an associated name
+     */
     if ((!(OpInfo->Flags & AML_NAMED)) &&
         (!(OpInfo->Flags & AML_CREATE)) &&
         (Op->Asl.ParseOpcode != PARSEOP_NAMESTRING) &&
@@ -1094,3 +1092,178 @@ XfNamespaceLocateEnd (
 
     return_ACPI_STATUS (AE_OK);
 }
+
+
+#ifdef __UNDER_DEVELOPMENT
+/*******************************************************************************
+ *
+ * FUNCTION:    XfIsObjectParental
+ *
+ * PARAMETERS:  ChildOp                 - Op to be checked
+ *              PossibleParentOp        - Determine if this op is in the family
+ *
+ * RETURN:      TRUE if ChildOp is a descendent of PossibleParentOp
+ *
+ * DESCRIPTION: Determine if an Op is a descendent of another Op. Used to
+ *              detect if a method is declared within another method.
+ *
+ ******************************************************************************/
+
+static BOOLEAN
+XfIsObjectParental (
+    ACPI_PARSE_OBJECT       *ChildOp,
+    ACPI_PARSE_OBJECT       *PossibleParentOp)
+{
+    ACPI_PARSE_OBJECT       *ParentOp;
+
+
+    /* Search upwards through the tree for possible parent */
+
+    ParentOp = ChildOp;
+    while (ParentOp)
+    {
+        if (ParentOp == PossibleParentOp)
+        {
+            return (TRUE);
+        }
+
+        ParentOp = ParentOp->Asl.Parent;
+    }
+
+    return (FALSE);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    XfGetParentMethod
+ *
+ * PARAMETERS:  Op                      - Op to be checked
+ *
+ * RETURN:      Op for parent method. NULL if object is not within a method.
+ *
+ * DESCRIPTION: Determine if an object is within a control method. Used to
+ *              implement special rules for named references from within a
+ *              control method.
+ *
+ * NOTE: It would be better to have the parser set a flag in the Op if possible.
+ *
+ ******************************************************************************/
+
+static ACPI_PARSE_OBJECT *
+XfGetParentMethod (
+    ACPI_PARSE_OBJECT       *Op)
+{
+    ACPI_PARSE_OBJECT       *ParentOp;
+
+
+    if (!Op)
+    {
+        return (NULL);
+    }
+
+    if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
+    {
+        return (NULL);
+    }
+
+    /* Walk upwards through the parse tree, up to the root if necessary */
+
+    ParentOp = Op;
+    while (ParentOp)
+    {
+        if (ParentOp->Asl.ParseOpcode == PARSEOP_METHOD)
+        {
+            return (ParentOp);
+        }
+
+        ParentOp = ParentOp->Asl.Parent;
+    }
+
+    /* Object is not within a method */
+
+    return (NULL);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    XfCheckIllegalReference
+ *
+ * PARAMETERS:  Op                      - Op referring to the target
+ *              TargetNode              - Target of the reference
+ *
+ * RETURN:      None. Emits error message for an illegal reference
+ *
+ * DESCRIPTION: Determine if a named reference is legal. A "named" reference
+ *              is something like: Store(ABCD, ...), where ABCD is an AML
+ *              Nameseg or Namepath.
+ *
+ * NOTE: Caller must ensure that the name Op is in fact a reference, and not
+ *       an actual name declaration (creation of a named object).
+ *
+ ******************************************************************************/
+
+static void
+XfCheckIllegalReference (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_NAMESPACE_NODE     *TargetNode)
+{
+    ACPI_PARSE_OBJECT       *MethodOp1;
+    ACPI_PARSE_OBJECT       *MethodOp2;
+    ACPI_PARSE_OBJECT       *TargetOp;
+
+
+    /*
+     * Check for an illegal reference to a named object:
+     *
+     * 1) References from one control method to another, non-parent
+     *    method are not allowed, they will fail at runtime.
+     *
+     * 2) Forward references within a control method are not allowed.
+     *    AML interpreters use a one-pass parse of control methods
+     *    so these forward references will fail at runtime.
+     */
+    TargetOp = TargetNode->Op;
+
+    MethodOp1 = XfGetParentMethod (Op);
+    MethodOp2 = XfGetParentMethod (TargetOp);
+
+    /* Are both objects within control method(s)? */
+
+    if (!MethodOp1 || !MethodOp2)
+    {
+        return;
+    }
+
+    /* Objects not in the same method? */
+
+    if (MethodOp1 != MethodOp2)
+    {
+        /*
+         * 1) Cross-method named reference
+         *
+         * This is OK if and only if the target reference is within in a
+         * method that is a parent of current method
+         */
+        if (!XfIsObjectParental (MethodOp1, MethodOp2))
+        {
+            AslError (ASL_ERROR, ASL_MSG_ILLEGAL_METHOD_REF, Op,
+                Op->Asl.ExternalName);
+        }
+    }
+
+    /*
+     * 2) Both reference and target are in the same method. Check if this is
+     * an (illegal) forward reference by examining the exact source code
+     * location of each (the referenced object and the object declaration).
+     * This is a bit nasty, yet effective.
+     */
+    else if (Op->Asl.LogicalByteOffset < TargetOp->Asl.LogicalByteOffset)
+    {
+        AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
+            Op->Asl.ExternalName);
+    }
+
+}
+#endif
diff --git a/source/compiler/dtcompiler.h b/source/compiler/dtcompiler.h
index 44fc56de812b..55d7c1285225 100644
--- a/source/compiler/dtcompiler.h
+++ b/source/compiler/dtcompiler.h
@@ -537,6 +537,10 @@ DtCompileStao (
     void                    **PFieldList);
 
 ACPI_STATUS
+DtCompileTcpa (
+    void                    **PFieldList);
+
+ACPI_STATUS
 DtCompileUefi (
     void                    **PFieldList);
 
diff --git a/source/compiler/dttable.c b/source/compiler/dttable.c
index 22b4c9c4c165..c5b2ef9f6f2e 100644
--- a/source/compiler/dttable.c
+++ b/source/compiler/dttable.c
@@ -3122,6 +3122,77 @@ DtCompileStao (
 
 /******************************************************************************
  *
+ * FUNCTION:    DtCompileTcpa
+ *
+ * PARAMETERS:  PFieldList          - Current field list pointer
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Compile TCPA.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+DtCompileTcpa (
+    void                    **List)
+{
+    DT_FIELD                **PFieldList = (DT_FIELD **) List;
+    DT_SUBTABLE             *Subtable;
+    ACPI_TABLE_TCPA_HDR     *TcpaHeader;
+    DT_SUBTABLE             *ParentTable;
+    ACPI_STATUS             Status;
+
+
+    /* Compile the main table */
+
+    Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
+            &Subtable, TRUE);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    ParentTable = DtPeekSubtable ();
+    DtInsertSubtable (ParentTable, Subtable);
+
+    /*
+     * Examine the PlatformClass field to determine the table type.
+     * Either a client or server table. Only one.
+     */
+    TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
+
+    switch (TcpaHeader->PlatformClass)
+    {
+    case ACPI_TCPA_CLIENT_TABLE:
+
+        Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
+                &Subtable, TRUE);
+        break;
+
+    case ACPI_TCPA_SERVER_TABLE:
+
+        Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
+                &Subtable, TRUE);
+        break;
+
+    default:
+
+        AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
+            TcpaHeader->PlatformClass);
+        Status = AE_ERROR;
+        break;
+    }
+
+
+        ParentTable = DtPeekSubtable ();
+        DtInsertSubtable (ParentTable, Subtable);
+
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
  * FUNCTION:    DtGetGenericTableInfo
  *
  * PARAMETERS:  Name                - Generic type name
diff --git a/source/compiler/dttemplate.h b/source/compiler/dttemplate.h
index 6d76f4d64b9c..6f3ed6407012 100644
--- a/source/compiler/dttemplate.h
+++ b/source/compiler/dttemplate.h
@@ -1144,13 +1144,19 @@ const unsigned char TemplateStao[] =
 
 const unsigned char TemplateTcpa[] =
 {
-    0x54,0x43,0x50,0x41,0x32,0x00,0x00,0x00,  /* 00000000    "TCPA2..." */
-    0x01,0x67,0x49,0x4E,0x54,0x45,0x4C,0x20,  /* 00000008    ".gINTEL " */
-    0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45,  /* 00000010    "TEMPLATE" */
+    0x54,0x43,0x50,0x41,0x64,0x00,0x00,0x00,  /* 00000000    "TCPAd..." */
+    0x02,0xFF,0x49,0x4E,0x54,0x45,0x4C,0x20,  /* 00000008    "..INTEL " */
+    0x54,0x65,0x6D,0x70,0x6C,0x61,0x74,0x65,  /* 00000010    "Template" */
     0x80,0x31,0x00,0x00,0x49,0x4E,0x54,0x4C,  /* 00000018    ".1..INTL" */
-    0x28,0x05,0x10,0x20,0x00,0x00,0x00,0x00,  /* 00000020    "(.. ...." */
-    0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,  /* 00000028    "........" */
-    0x00,0x00                                 /* 00000030    ".."       */
+    0x19,0x06,0x15,0x20,0x01,0x00,0x00,0x00,  /* 00000020    "... ...." */
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  /* 00000028    "........" */
+    0x11,0x00,0xFF,0xEE,0xDD,0xCC,0xBB,0xAA,  /* 00000030    "........" */
+    0x02,0x01,0x00,0x00,0x01,0x00,0x00,0x00,  /* 00000038    "........" */
+    0x00,0x00,0x00,0x00,0x01,0x20,0x00,0x03,  /* 00000040    "..... .." */
+    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  /* 00000048    "........" */
+    0x00,0x00,0x00,0x00,0x01,0x20,0x00,0x03,  /* 00000050    "..... .." */
+    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  /* 00000058    "........" */
+    0x01,0x01,0x01,0x01                       /* 00000060    "...."     */
 };
 
 const unsigned char TemplateTpm2[] =
diff --git a/source/compiler/prparser.l b/source/compiler/prparser.l
index 10bd130487f5..3ef0f453fe46 100644
--- a/source/compiler/prparser.l
+++ b/source/compiler/prparser.l
@@ -50,14 +50,22 @@
 #define STRING_SETUP    strcpy (StringBuffer, PrParsertext);\
     PrParserlval.str = StringBuffer
 
-#define YY_NO_INPUT     /* No file input, we use strings only */
-
 #define _COMPONENT          ACPI_COMPILER
         ACPI_MODULE_NAME    ("prscanner")
+
+
+/* Local prototypes */
+
+static char
+PrDoCommentType1 (
+    void);
+
+static char
+PrDoCommentType2 (
+    void);
 %}
 
 %option noyywrap
-%option nounput
 
 Number          [0-9a-fA-F]+
 HexNumber       0[xX][0-9a-fA-F]+
@@ -66,6 +74,8 @@ NewLine         [\n]
 Identifier      [a-zA-Z][0-9a-zA-Z]*
 
 %%
+"/*"            { if (!PrDoCommentType1 ()) {yyterminate ();} }
+"//"            { if (!PrDoCommentType2 ()) {yyterminate ();} }
 
 \(              return (EXPOP_PAREN_OPEN);
 \)              return (EXPOP_PAREN_CLOSE);
@@ -151,3 +161,76 @@ PrTerminateLexer (
 
     yy_delete_buffer (LexBuffer);
 }
+
+
+/********************************************************************************
+ *
+ * FUNCTION:    PrDoCommentType1
+ *
+ * PARAMETERS:  none
+ *
+ * RETURN:      none
+ *
+ * DESCRIPTION: Process a new legacy comment. Just toss it.
+ *
+ ******************************************************************************/
+
+static char
+PrDoCommentType1 (
+    void)
+{
+    int                 c;
+
+
+Loop:
+    while (((c = input ()) != '*') && (c != EOF))
+    {
+    }
+    if (c == EOF)
+    {
+        return (FALSE);
+    }
+
+    if (((c = input ()) != '/') && (c != EOF))
+    {
+        unput (c);
+        goto Loop;
+    }
+    if (c == EOF)
+    {
+        return (FALSE);
+    }
+
+    return (TRUE);
+}
+
+
+/********************************************************************************
+ *
+ * FUNCTION:    PrDoCommentType2
+ *
+ * PARAMETERS:  none
+ *
+ * RETURN:      none
+ *
+ * DESCRIPTION: Process a new "//" comment. Just toss it.
+ *
+ ******************************************************************************/
+
+static char
+PrDoCommentType2 (
+    void)
+{
+    int                 c;
+
+
+    while (((c = input ()) != '\n') && (c != EOF))
+    {
+    }
+    if (c == EOF)
+    {
+        return (FALSE);
+    }
+
+    return (TRUE);
+}
diff --git a/source/compiler/prparser.y b/source/compiler/prparser.y
index 67587331a119..5ed30f53bc15 100644
--- a/source/compiler/prparser.y
+++ b/source/compiler/prparser.y
@@ -213,8 +213,11 @@ void
 PrParsererror (
     char const              *Message)
 {
+
+    sprintf (StringBuffer, "Preprocessor Parser : %s (near line %u)",
+        Message, Gbl_CurrentLineNumber);
     DtError (ASL_ERROR, ASL_MSG_SYNTAX,
-        NULL, (char *) Message);
+        NULL, (char *) StringBuffer);
 }
 
 
diff --git a/source/compiler/prscan.c b/source/compiler/prscan.c
index 393d80149fb1..27eb6be85318 100644
--- a/source/compiler/prscan.c
+++ b/source/compiler/prscan.c
@@ -120,7 +120,6 @@ static const PR_DIRECTIVE_INFO      Gbl_DirectiveInfo[] =
     {"include",         0}, /* Argument is not standard format, so just use 0 here */
     {"includebuffer",   0}, /* Argument is not standard format, so just use 0 here */
     {"line",            1},
-    {"loadbuffer",      0},
     {"pragma",          1},
     {"undef",           1},
     {"warning",         1},
@@ -144,7 +143,7 @@ enum Gbl_DirectiveIndexes
     PR_DIRECTIVE_LINE,
     PR_DIRECTIVE_PRAGMA,
     PR_DIRECTIVE_UNDEF,
-    PR_DIRECTIVE_WARNING,
+    PR_DIRECTIVE_WARNING
 };
 
 #define ASL_DIRECTIVE_NOT_FOUND     -1
@@ -328,7 +327,7 @@ PrPreprocessInputFile (
 
     PrGetNextLineInit ();
 
-    /* Scan line-by-line. Comments and blank lines are skipped by this function */
+    /* Scan source line-by-line and process directives. Then write the .i file */
 
     while ((Status = PrGetNextLine (Gbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
     {
@@ -479,6 +478,16 @@ PrDoDirective (
     }
 
     /*
+     * Emit a line directive into the preprocessor file (.pre) after
+     * every matched directive. This is passed through to the compiler
+     * so that error/warning messages are kept in sync with the
+     * original source file.
+     */
+    FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
+        Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename,
+        Gbl_DirectiveInfo[Directive].Name);
+
+    /*
      * If we are currently ignoring this block and we encounter a #else or
      * #elif, we must ignore their blocks also if the parent block is also
      * being ignored.
@@ -825,6 +834,9 @@ PrDoDirective (
 
         PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
             THIS_TOKEN_OFFSET (Token));
+
+        Gbl_SourceLine = 0;
+        Gbl_NextError = Gbl_ErrorLog;
         break;
 
     default:
@@ -863,7 +875,9 @@ SyntaxError:
  ******************************************************************************/
 
 #define PR_NORMAL_TEXT          0
-#define PR_WITHIN_COMMENT       1
+#define PR_MULTI_LINE_COMMENT   1
+#define PR_SINGLE_LINE_COMMENT  2
+#define PR_QUOTED_STRING        3
 
 static UINT8                    AcpiGbl_LineScanState = PR_NORMAL_TEXT;
 
@@ -904,22 +918,55 @@ PrGetNextLine (
             return (ASL_EOF);
         }
 
-        /* We need to worry about multi-line slash-asterisk comments */
-
-        /* Check for comment open */
+        /* Update state machine as necessary */
 
-        if ((AcpiGbl_LineScanState == PR_NORMAL_TEXT) &&
-            (PreviousChar == '/') && (c == '*'))
+        switch (AcpiGbl_LineScanState)
         {
-            AcpiGbl_LineScanState = PR_WITHIN_COMMENT;
-        }
+        case PR_NORMAL_TEXT:
 
-        /* Check for comment close */
+            /* Check for multi-line comment start */
 
-        if ((AcpiGbl_LineScanState == PR_WITHIN_COMMENT) &&
-            (PreviousChar == '*') && (c == '/'))
-        {
-            AcpiGbl_LineScanState = PR_NORMAL_TEXT;
+            if ((PreviousChar == '/') && (c == '*'))
+            {
+                AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
+            }
+
+            /* Check for single-line comment start */
+
+            else if ((PreviousChar == '/') && (c == '/'))
+            {
+                AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
+            }
+
+            /* Check for quoted string start */
+
+            else if (PreviousChar == '"')
+            {
+                AcpiGbl_LineScanState = PR_QUOTED_STRING;
+            }
+            break;
+
+        case PR_QUOTED_STRING:
+
+            if (PreviousChar == '"')
+            {
+                AcpiGbl_LineScanState = PR_NORMAL_TEXT;
+            }
+            break;
+
+        case PR_MULTI_LINE_COMMENT:
+
+            /* Check for multi-line comment end */
+
+            if ((PreviousChar == '*') && (c == '/'))
+            {
+                AcpiGbl_LineScanState = PR_NORMAL_TEXT;
+            }
+            break;
+
+        case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
+        default:
+            break;
         }
 
         /* Always copy the character into line buffer */
@@ -933,10 +980,21 @@ PrGetNextLine (
         {
             /* Handle multi-line comments */
 
-            if (AcpiGbl_LineScanState == PR_WITHIN_COMMENT)
+            if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
             {
                 return (ASL_WITHIN_COMMENT);
             }
+
+            /* End of single-line comment */
+
+            if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
+            {
+                AcpiGbl_LineScanState = PR_NORMAL_TEXT;
+                return (AE_OK);
+            }
+
+            /* Blank line */
+
             if (i == 1)
             {
                 return (ASL_BLANK_LINE);
diff --git a/source/components/debugger/dbcmds.c b/source/components/debugger/dbcmds.c
index 4a2c4e850107..d22bf4ca79e2 100644
--- a/source/components/debugger/dbcmds.c
+++ b/source/components/debugger/dbcmds.c
@@ -86,6 +86,8 @@ AcpiDbDoOneSleepState (
     UINT8                   SleepState);
 
 
+static char                 *AcpiDbTraceMethodName = NULL;
+
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDbConvertToNode
@@ -1226,4 +1228,88 @@ AcpiDbGenerateSci (
 
 #endif /* !ACPI_REDUCED_HARDWARE */
 
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbTrace
+ *
+ * PARAMETERS:  EnableArg           - ENABLE/AML to enable tracer
+ *                                    DISABLE to disable tracer
+ *              MethodArg           - Method to trace
+ *              OnceArg             - Whether trace once
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Control method tracing facility
+ *
+ ******************************************************************************/
+
+void
+AcpiDbTrace (
+    char                    *EnableArg,
+    char                    *MethodArg,
+    char                    *OnceArg)
+{
+    UINT32                  DebugLevel = 0;
+    UINT32                  DebugLayer = 0;
+    UINT32                  Flags = 0;
+
+
+    if (EnableArg)
+    {
+        AcpiUtStrupr (EnableArg);
+    }
+    if (OnceArg)
+    {
+        AcpiUtStrupr (OnceArg);
+    }
+    if (MethodArg)
+    {
+        if (AcpiDbTraceMethodName)
+        {
+            ACPI_FREE (AcpiDbTraceMethodName);
+            AcpiDbTraceMethodName = NULL;
+        }
+        AcpiDbTraceMethodName = ACPI_ALLOCATE (strlen (MethodArg) + 1);
+        if (!AcpiDbTraceMethodName)
+        {
+            AcpiOsPrintf ("Failed to allocate method name (%s)\n", MethodArg);
+            return;
+        }
+        strcpy (AcpiDbTraceMethodName, MethodArg);
+    }
+    if (!strcmp (EnableArg, "ENABLE") ||
+        !strcmp (EnableArg, "METHOD") ||
+        !strcmp (EnableArg, "OPCODE"))
+    {
+        if (!strcmp (EnableArg, "ENABLE"))
+        {
+            /* Inherit current console settings */
+
+            DebugLevel = AcpiGbl_DbConsoleDebugLevel;
+            DebugLayer = AcpiDbgLayer;
+        }
+        else
+        {
+            /* Restrict console output to trace points only */
+
+            DebugLevel = ACPI_LV_TRACE_POINT;
+            DebugLayer = ACPI_EXECUTER;
+        }
+
+        Flags = ACPI_TRACE_ENABLED;
+        if (!strcmp (EnableArg, "OPCODE"))
+        {
+            Flags |= ACPI_TRACE_OPCODE;
+        }
+        if (OnceArg && !strcmp (OnceArg, "ONCE"))
+        {
+            Flags |= ACPI_TRACE_ONESHOT;
+        }
+    }
+
+    (void) AcpiDebugTrace (AcpiDbTraceMethodName,
+                DebugLevel, DebugLayer, Flags);
+}
+
 #endif /* ACPI_DEBUGGER */
diff --git a/source/components/debugger/dbdisply.c b/source/components/debugger/dbdisply.c
index aedc8bfb8258..10821a2f4a0d 100644
--- a/source/components/debugger/dbdisply.c
+++ b/source/components/debugger/dbdisply.c
@@ -49,7 +49,6 @@
 #include "acparser.h"
 #include "acinterp.h"
 #include "acdebug.h"
-#include "acdisasm.h"
 
 
 #ifdef ACPI_DEBUGGER
@@ -513,7 +512,7 @@ AcpiDbDisplayLocals (
         return;
     }
 
-    AcpiDmDisplayLocals (WalkState);
+    AcpiDbDecodeLocals (WalkState);
 }
 
 
@@ -543,7 +542,7 @@ AcpiDbDisplayArguments (
         return;
     }
 
-    AcpiDmDisplayArguments (WalkState);
+    AcpiDbDecodeArguments (WalkState);
 }
 
 
@@ -599,7 +598,7 @@ AcpiDbDisplayResults (
     {
         ObjDesc = Frame->Results.ObjDesc[Index];
         AcpiOsPrintf ("Result%u: ", i);
-        AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
         if (Index == 0)
         {
             Frame = Frame->Results.Next;
@@ -763,7 +762,7 @@ AcpiDbDisplayResultObject (
     }
 
     AcpiOsPrintf ("ResultObj: ");
-    AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+    AcpiDbDisplayInternalObject (ObjDesc, WalkState);
     AcpiOsPrintf ("\n");
 }
 
@@ -793,7 +792,7 @@ AcpiDbDisplayArgumentObject (
     }
 
     AcpiOsPrintf ("ArgObj:    ");
-    AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+    AcpiDbDisplayInternalObject (ObjDesc, WalkState);
 }
 
 
diff --git a/source/components/debugger/dbinput.c b/source/components/debugger/dbinput.c
index e588167dd03e..15dfb4b3a70c 100644
--- a/source/components/debugger/dbinput.c
+++ b/source/components/debugger/dbinput.c
@@ -218,7 +218,7 @@ static const ACPI_DB_COMMAND_INFO   AcpiGbl_DbCommands[] =
     {"TABLES",       0},
     {"TEMPLATE",     1},
     {"TERMINATE",    0},
-    {"TEST",        1},
+    {"TEST",         1},
     {"THREADS",      3},
     {"TRACE",        1},
     {"TREE",         0},
@@ -270,7 +270,7 @@ static const ACPI_DB_COMMAND_HELP   AcpiGbl_DbCommandHelp[] =
     {1, "  Owner <OwnerId> [Depth]",           "Display loaded namespace by object owner\n"},
     {1, "  Paths",                             "Display full pathnames of namespace objects\n"},
     {1, "  Predefined",                        "Check all predefined names\n"},
-    {1, "  Prefix [<NamePath>]",               "Set or Get current execution prefix\n"},
+    {1, "  Prefix [<Namepath>]",               "Set or Get current execution prefix\n"},
     {1, "  References <Addr>",                 "Find all references to object at addr\n"},
     {1, "  Resources [DeviceName]",            "Display Device resources (no arg = all devices)\n"},
     {1, "  Set N <NamedObject> <Value>",       "Set value for named integer\n"},
@@ -297,8 +297,12 @@ static const ACPI_DB_COMMAND_HELP   AcpiGbl_DbCommandHelp[] =
     {1, "  Results",                           "Display method result stack\n"},
     {1, "  Set <A|L> <#> <Value>",             "Set method data (Arguments/Locals)\n"},
     {1, "  Stop",                              "Terminate control method\n"},
-    {1, "  Thread <Threads><Loops><NamePath>", "Spawn threads to execute method(s)\n"},
-    {1, "  Trace <method name>",               "Trace method execution\n"},
+    {1, "  Thread <Threads><Loops><Namepath>", "Spawn threads to execute method(s)\n"},
+    {5, "  Trace <State> [<Namepath>] [Once]", "Trace control method execution\n"},
+    {1, "     Enable",                         "Enable all messages\n"},
+    {1, "     Disable",                        "Disable tracing\n"},
+    {1, "     Method",                         "Enable method execution messages\n"},
+    {1, "     Opcode",                         "Enable opcode execution messages\n"},
     {1, "  Tree",                              "Display control method calling tree\n"},
     {1, "  <Enter>",                           "Single step next AML opcode (over calls)\n"},
 
@@ -749,15 +753,22 @@ AcpiDbCommandDispatch (
         return (AE_CTRL_TERMINATE);
     }
 
-
-    /* Add all commands that come here to the history buffer */
-
-    AcpiDbAddToHistory (InputBuffer);
+    /* Find command and add to the history buffer */
 
     ParamCount = AcpiDbGetLine (InputBuffer);
     CommandIndex = AcpiDbMatchCommand (AcpiGbl_DbArgs[0]);
     Temp = 0;
 
+    /*
+     * We don't want to add the !! command to the history buffer. It
+     * would cause an infinite loop because it would always be the
+     * previous command.
+     */
+    if (CommandIndex != CMD_HISTORY_LAST)
+    {
+        AcpiDbAddToHistory (InputBuffer);
+    }
+
     /* Verify that we have the minimum number of params */
 
     if (ParamCount < AcpiGbl_DbCommands[CommandIndex].MinArgs)
@@ -1110,7 +1121,7 @@ AcpiDbCommandDispatch (
 
     case CMD_TRACE:
 
-        (void) AcpiDebugTrace (AcpiGbl_DbArgs[1],0,0,1);
+        AcpiDbTrace (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2], AcpiGbl_DbArgs[3]);
         break;
 
     case CMD_TREE:
diff --git a/source/components/debugger/dbmethod.c b/source/components/debugger/dbmethod.c
index 2b03d359f3c7..f42496a399b7 100644
--- a/source/components/debugger/dbmethod.c
+++ b/source/components/debugger/dbmethod.c
@@ -46,7 +46,9 @@
 #include "acdispat.h"
 #include "acnamesp.h"
 #include "acdebug.h"
+#ifdef ACPI_DISASSEMBLER
 #include "acdisasm.h"
+#endif
 #include "acparser.h"
 #include "acpredef.h"
 
@@ -79,6 +81,7 @@ AcpiDbSetMethodBreakpoint (
     ACPI_PARSE_OBJECT       *Op)
 {
     UINT32                  Address;
+    UINT32                  AmlOffset;
 
 
     if (!Op)
@@ -90,10 +93,12 @@ AcpiDbSetMethodBreakpoint (
     /* Get and verify the breakpoint address */
 
     Address = strtoul (Location, NULL, 16);
-    if (Address <= Op->Common.AmlOffset)
+    AmlOffset = (UINT32) ACPI_PTR_DIFF (Op->Common.Aml,
+                    WalkState->ParserState.AmlStart);
+    if (Address <= AmlOffset)
     {
         AcpiOsPrintf ("Breakpoint %X is beyond current address %X\n",
-            Address, Op->Common.AmlOffset);
+            Address, AmlOffset);
     }
 
     /* Save breakpoint in current walk */
@@ -238,7 +243,7 @@ AcpiDbSetMethodData (
         ObjDesc = WalkState->Arguments[Index].Object;
 
         AcpiOsPrintf ("Arg%u: ", Index);
-        AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
         break;
 
     case 'L':
@@ -261,7 +266,7 @@ AcpiDbSetMethodData (
         ObjDesc = WalkState->LocalVariables[Index].Object;
 
         AcpiOsPrintf ("Local%u: ", Index);
-        AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
         break;
 
     default:
@@ -307,7 +312,9 @@ AcpiDbDisassembleAml (
         NumStatements = strtoul (Statements, NULL, 0);
     }
 
+#ifdef ACPI_DISASSEMBLER
     AcpiDmDisassemble (NULL, Op, NumStatements);
+#endif
 }
 
 
@@ -350,7 +357,7 @@ AcpiDbDisassembleMethod (
 
     ObjDesc = Method->Object;
 
-    Op = AcpiPsCreateScopeOp ();
+    Op = AcpiPsCreateScopeOp (ObjDesc->Method.AmlStart);
     if (!Op)
     {
         return (AE_NO_MEMORY);
@@ -390,6 +397,8 @@ AcpiDbDisassembleMethod (
     WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
 
     Status = AcpiPsParseAml (WalkState);
+
+#ifdef ACPI_DISASSEMBER
     (void) AcpiDmParseDeferredOps (Op);
 
     /* Now we can disassemble the method */
@@ -397,6 +406,7 @@ AcpiDbDisassembleMethod (
     AcpiGbl_DbOpt_Verbose = FALSE;
     AcpiDmDisassemble (NULL, Op, 0);
     AcpiGbl_DbOpt_Verbose = TRUE;
+#endif
 
     AcpiPsDeleteParseTree (Op);
 
diff --git a/source/components/debugger/dbnames.c b/source/components/debugger/dbnames.c
index 0b56f076bf7f..716fd3ce5cb6 100644
--- a/source/components/debugger/dbnames.c
+++ b/source/components/debugger/dbnames.c
@@ -385,7 +385,7 @@ AcpiDbWalkAndMatchName (
     /* Get the full pathname to this object */
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
+    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
@@ -582,7 +582,7 @@ AcpiDbWalkForSpecificObjects (
     /* Get and display the full pathname to this object */
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
+    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
@@ -886,7 +886,7 @@ AcpiDbBusWalk (
     /* Get the full path to this device object */
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
+    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
diff --git a/source/components/disassembler/dmobject.c b/source/components/debugger/dbobject.c
index 6023c786b1e7..c7447af6d9d8 100644
--- a/source/components/disassembler/dmobject.c
+++ b/source/components/debugger/dbobject.c
@@ -1,6 +1,6 @@
 /*******************************************************************************
  *
- * Module Name: dmobject - ACPI object decode and display
+ * Module Name: dbobject - ACPI object decode and display
  *
  ******************************************************************************/
 
@@ -44,28 +44,30 @@
 #include "acpi.h"
 #include "accommon.h"
 #include "acnamesp.h"
+#include "acdebug.h"
+#ifdef ACPI_DISASSEMBLER
 #include "acdisasm.h"
+#endif
 
 
-#ifdef ACPI_DISASSEMBLER
+#ifdef ACPI_DEBUGGER
 
 #define _COMPONENT          ACPI_CA_DEBUGGER
-        ACPI_MODULE_NAME    ("dmnames")
+        ACPI_MODULE_NAME    ("dbobject")
 
 /* Local prototypes */
 
 static void
-AcpiDmDecodeNode (
+AcpiDbDecodeNode (
     ACPI_NAMESPACE_NODE     *Node);
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDumpMethodInfo
+ * FUNCTION:    AcpiDbDumpMethodInfo
  *
  * PARAMETERS:  Status          - Method execution status
  *              WalkState       - Current state of the parse tree walk
- *              Op              - Executing parse op
  *
  * RETURN:      None
  *
@@ -76,15 +78,11 @@ AcpiDmDecodeNode (
  ******************************************************************************/
 
 void
-AcpiDmDumpMethodInfo (
+AcpiDbDumpMethodInfo (
     ACPI_STATUS             Status,
-    ACPI_WALK_STATE         *WalkState,
-    ACPI_PARSE_OBJECT       *Op)
+    ACPI_WALK_STATE         *WalkState)
 {
-    ACPI_PARSE_OBJECT       *Next;
     ACPI_THREAD_STATE       *Thread;
-    ACPI_WALK_STATE         *NextWalkState;
-    ACPI_NAMESPACE_NODE     *PreviousMethod = NULL;
 
 
     /* Ignore control codes, they are not errors */
@@ -113,68 +111,19 @@ AcpiDmDumpMethodInfo (
         return;
     }
 
-    /* Display exception and method name */
-
-    AcpiOsPrintf ("\n**** Exception %s during execution of method ",
-        AcpiFormatException (Status));
-    AcpiNsPrintNodePathname (WalkState->MethodNode, NULL);
-
-    /* Display stack of executing methods */
-
-    AcpiOsPrintf ("\n\nMethod Execution Stack:\n");
-    NextWalkState = Thread->WalkStateList;
-
-    /* Walk list of linked walk states */
-
-    while (NextWalkState)
-    {
-        AcpiOsPrintf ("    Method [%4.4s] executing: ",
-                AcpiUtGetNodeName (NextWalkState->MethodNode));
-
-        /* First method is the currently executing method */
-
-        if (NextWalkState == WalkState)
-        {
-            if (Op)
-            {
-                /* Display currently executing ASL statement */
-
-                Next = Op->Common.Next;
-                Op->Common.Next = NULL;
-
-                AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);
-                Op->Common.Next = Next;
-            }
-        }
-        else
-        {
-            /*
-             * This method has called another method
-             * NOTE: the method call parse subtree is already deleted at this
-             * point, so we cannot disassemble the method invocation.
-             */
-            AcpiOsPrintf ("Call to method ");
-            AcpiNsPrintNodePathname (PreviousMethod, NULL);
-        }
-
-        PreviousMethod = NextWalkState->MethodNode;
-        NextWalkState = NextWalkState->Next;
-        AcpiOsPrintf ("\n");
-    }
-
     /* Display the method locals and arguments */
 
     AcpiOsPrintf ("\n");
-    AcpiDmDisplayLocals (WalkState);
+    AcpiDbDecodeLocals (WalkState);
     AcpiOsPrintf ("\n");
-    AcpiDmDisplayArguments (WalkState);
+    AcpiDbDecodeArguments (WalkState);
     AcpiOsPrintf ("\n");
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDecodeInternalObject
+ * FUNCTION:    AcpiDbDecodeInternalObject
  *
  * PARAMETERS:  ObjDesc         - Object to be displayed
  *
@@ -185,7 +134,7 @@ AcpiDmDumpMethodInfo (
  ******************************************************************************/
 
 void
-AcpiDmDecodeInternalObject (
+AcpiDbDecodeInternalObject (
     ACPI_OPERAND_OBJECT     *ObjDesc)
 {
     UINT32                  i;
@@ -247,7 +196,7 @@ AcpiDmDecodeInternalObject (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDecodeNode
+ * FUNCTION:    AcpiDbDecodeNode
  *
  * PARAMETERS:  Node        - Object to be displayed
  *
@@ -258,7 +207,7 @@ AcpiDmDecodeInternalObject (
  ******************************************************************************/
 
 static void
-AcpiDmDecodeNode (
+AcpiDbDecodeNode (
     ACPI_NAMESPACE_NODE     *Node)
 {
 
@@ -290,7 +239,7 @@ AcpiDmDecodeNode (
 
     default:
 
-        AcpiDmDecodeInternalObject (AcpiNsGetAttachedObject (Node));
+        AcpiDbDecodeInternalObject (AcpiNsGetAttachedObject (Node));
         break;
     }
 }
@@ -298,7 +247,7 @@ AcpiDmDecodeNode (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDisplayInternalObject
+ * FUNCTION:    AcpiDbDisplayInternalObject
  *
  * PARAMETERS:  ObjDesc         - Object to be displayed
  *              WalkState       - Current walk state
@@ -310,7 +259,7 @@ AcpiDmDecodeNode (
  ******************************************************************************/
 
 void
-AcpiDmDisplayInternalObject (
+AcpiDbDisplayInternalObject (
     ACPI_OPERAND_OBJECT     *ObjDesc,
     ACPI_WALK_STATE         *WalkState)
 {
@@ -336,7 +285,7 @@ AcpiDmDisplayInternalObject (
 
     case ACPI_DESC_TYPE_NAMED:
 
-        AcpiDmDecodeNode ((ACPI_NAMESPACE_NODE *) ObjDesc);
+        AcpiDbDecodeNode ((ACPI_NAMESPACE_NODE *) ObjDesc);
         break;
 
     case ACPI_DESC_TYPE_OPERAND:
@@ -368,7 +317,7 @@ AcpiDmDisplayInternalObject (
                     ObjDesc = WalkState->LocalVariables
                                 [ObjDesc->Reference.Value].Object;
                     AcpiOsPrintf ("%p", ObjDesc);
-                    AcpiDmDecodeInternalObject (ObjDesc);
+                    AcpiDbDecodeInternalObject (ObjDesc);
                 }
                 break;
 
@@ -380,7 +329,7 @@ AcpiDmDisplayInternalObject (
                     ObjDesc = WalkState->Arguments
                                 [ObjDesc->Reference.Value].Object;
                     AcpiOsPrintf ("%p", ObjDesc);
-                    AcpiDmDecodeInternalObject (ObjDesc);
+                    AcpiDbDecodeInternalObject (ObjDesc);
                 }
                 break;
 
@@ -391,7 +340,7 @@ AcpiDmDisplayInternalObject (
                 case ACPI_TYPE_BUFFER_FIELD:
 
                     AcpiOsPrintf ("%p", ObjDesc->Reference.Object);
-                    AcpiDmDecodeInternalObject (ObjDesc->Reference.Object);
+                    AcpiDbDecodeInternalObject (ObjDesc->Reference.Object);
                     break;
 
                 case ACPI_TYPE_PACKAGE:
@@ -403,7 +352,7 @@ AcpiDmDisplayInternalObject (
                     }
                     else
                     {
-                        AcpiDmDecodeInternalObject (
+                        AcpiDbDecodeInternalObject (
                             *(ObjDesc->Reference.Where));
                     }
                     break;
@@ -428,11 +377,11 @@ AcpiDmDisplayInternalObject (
                 switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc->Reference.Object))
                 {
                 case ACPI_DESC_TYPE_NAMED:
-                    AcpiDmDecodeNode (ObjDesc->Reference.Object);
+                    AcpiDbDecodeNode (ObjDesc->Reference.Object);
                     break;
 
                 case ACPI_DESC_TYPE_OPERAND:
-                    AcpiDmDecodeInternalObject (ObjDesc->Reference.Object);
+                    AcpiDbDecodeInternalObject (ObjDesc->Reference.Object);
                     break;
 
                 default:
@@ -442,7 +391,7 @@ AcpiDmDisplayInternalObject (
 
             case ACPI_REFCLASS_NAME:
 
-                AcpiDmDecodeNode (ObjDesc->Reference.Node);
+                AcpiDbDecodeNode (ObjDesc->Reference.Node);
                 break;
 
             case ACPI_REFCLASS_DEBUG:
@@ -461,7 +410,7 @@ AcpiDmDisplayInternalObject (
         default:
 
             AcpiOsPrintf ("<Obj>            ");
-            AcpiDmDecodeInternalObject (ObjDesc);
+            AcpiDbDecodeInternalObject (ObjDesc);
             break;
         }
         break;
@@ -479,7 +428,7 @@ AcpiDmDisplayInternalObject (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDisplayLocals
+ * FUNCTION:    AcpiDbDecodeLocals
  *
  * PARAMETERS:  WalkState       - State for current method
  *
@@ -490,7 +439,7 @@ AcpiDmDisplayInternalObject (
  ******************************************************************************/
 
 void
-AcpiDmDisplayLocals (
+AcpiDbDecodeLocals (
     ACPI_WALK_STATE         *WalkState)
 {
     UINT32                  i;
@@ -520,14 +469,14 @@ AcpiDmDisplayLocals (
     {
         ObjDesc = WalkState->LocalVariables[i].Object;
         AcpiOsPrintf ("    Local%X: ", i);
-        AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
     }
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDisplayArguments
+ * FUNCTION:    AcpiDbDecodeArguments
  *
  * PARAMETERS:  WalkState       - State for current method
  *
@@ -538,7 +487,7 @@ AcpiDmDisplayLocals (
  ******************************************************************************/
 
 void
-AcpiDmDisplayArguments (
+AcpiDbDecodeArguments (
     ACPI_WALK_STATE         *WalkState)
 {
     UINT32                  i;
@@ -569,7 +518,7 @@ AcpiDmDisplayArguments (
     {
         ObjDesc = WalkState->Arguments[i].Object;
         AcpiOsPrintf ("    Arg%u:   ", i);
-        AcpiDmDisplayInternalObject (ObjDesc, WalkState);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
     }
 }
 
diff --git a/source/components/debugger/dbutils.c b/source/components/debugger/dbutils.c
index a089344e2297..4a7cf4144208 100644
--- a/source/components/debugger/dbutils.c
+++ b/source/components/debugger/dbutils.c
@@ -45,7 +45,6 @@
 #include "accommon.h"
 #include "acnamesp.h"
 #include "acdebug.h"
-#include "acdisasm.h"
 
 
 #ifdef ACPI_DEBUGGER
@@ -223,7 +222,7 @@ AcpiDbDumpExternalObject (
     case ACPI_TYPE_LOCAL_REFERENCE:
 
         AcpiOsPrintf ("[Object Reference] = ");
-        AcpiDmDisplayInternalObject (ObjDesc->Reference.Handle, NULL);
+        AcpiDbDisplayInternalObject (ObjDesc->Reference.Handle, NULL);
         break;
 
     case ACPI_TYPE_PROCESSOR:
diff --git a/source/components/debugger/dbxface.c b/source/components/debugger/dbxface.c
index 33d5e363b649..6dcf1e54c8d0 100644
--- a/source/components/debugger/dbxface.c
+++ b/source/components/debugger/dbxface.c
@@ -45,7 +45,9 @@
 #include "accommon.h"
 #include "amlcode.h"
 #include "acdebug.h"
+#ifdef ACPI_DISASSEMBLER
 #include "acdisasm.h"
+#endif
 
 
 #ifdef ACPI_DEBUGGER
@@ -179,6 +181,7 @@ AcpiDbSingleStep (
     UINT32                  OriginalDebugLevel;
     ACPI_PARSE_OBJECT       *DisplayOp;
     ACPI_PARSE_OBJECT       *ParentOp;
+    UINT32                  AmlOffset;
 
 
     ACPI_FUNCTION_ENTRY ();
@@ -192,15 +195,18 @@ AcpiDbSingleStep (
         return (AE_ABORT_METHOD);
     }
 
+    AmlOffset = (UINT32) ACPI_PTR_DIFF (Op->Common.Aml,
+                    WalkState->ParserState.AmlStart);
+
     /* Check for single-step breakpoint */
 
     if (WalkState->MethodBreakpoint &&
-       (WalkState->MethodBreakpoint <= Op->Common.AmlOffset))
+       (WalkState->MethodBreakpoint <= AmlOffset))
     {
         /* Check if the breakpoint has been reached or passed */
         /* Hit the breakpoint, resume single step, reset breakpoint */
 
-        AcpiOsPrintf ("***Break*** at AML offset %X\n", Op->Common.AmlOffset);
+        AcpiOsPrintf ("***Break*** at AML offset %X\n", AmlOffset);
         AcpiGbl_CmSingleStep = TRUE;
         AcpiGbl_StepToNextCall = FALSE;
         WalkState->MethodBreakpoint = 0;
@@ -209,10 +215,10 @@ AcpiDbSingleStep (
     /* Check for user breakpoint (Must be on exact Aml offset) */
 
     else if (WalkState->UserBreakpoint &&
-            (WalkState->UserBreakpoint == Op->Common.AmlOffset))
+            (WalkState->UserBreakpoint == AmlOffset))
     {
         AcpiOsPrintf ("***UserBreakpoint*** at AML offset %X\n",
-            Op->Common.AmlOffset);
+            AmlOffset);
         AcpiGbl_CmSingleStep = TRUE;
         AcpiGbl_StepToNextCall = FALSE;
         WalkState->MethodBreakpoint = 0;
@@ -308,7 +314,9 @@ AcpiDbSingleStep (
 
         /* Now we can display it */
 
+#ifdef ACPI_DISASSEMBLER
         AcpiDmDisassemble (WalkState, DisplayOp, ACPI_UINT32_MAX);
+#endif
 
         if ((Op->Common.AmlOpcode == AML_IF_OP) ||
             (Op->Common.AmlOpcode == AML_WHILE_OP))
diff --git a/source/components/disassembler/dmdeferred.c b/source/components/disassembler/dmdeferred.c
index 1b4ef2057edd..35d5650f82ee 100644
--- a/source/components/disassembler/dmdeferred.c
+++ b/source/components/disassembler/dmdeferred.c
@@ -165,7 +165,6 @@ AcpiDmDeferredParse (
     ACPI_STATUS             Status;
     ACPI_PARSE_OBJECT       *SearchOp;
     ACPI_PARSE_OBJECT       *StartOp;
-    UINT32                  BaseAmlOffset;
     ACPI_PARSE_OBJECT       *NewRootOp;
     ACPI_PARSE_OBJECT       *ExtraOp;
 
@@ -202,19 +201,10 @@ AcpiDmDeferredParse (
     WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
     Status = AcpiPsParseAml (WalkState);
 
-    /*
-     * We need to update all of the AML offsets, since the parser thought
-     * that the method began at offset zero. In reality, it began somewhere
-     * within the ACPI table, at the BaseAmlOffset. Walk the entire tree that
-     * was just created and update the AmlOffset in each Op.
-     */
-    BaseAmlOffset = (Op->Common.Value.Arg)->Common.AmlOffset + 1;
     StartOp = (Op->Common.Value.Arg)->Common.Next;
     SearchOp = StartOp;
-
     while (SearchOp)
     {
-        SearchOp->Common.AmlOffset += BaseAmlOffset;
         SearchOp = AcpiPsGetDepthNext (StartOp, SearchOp);
     }
 
diff --git a/source/components/disassembler/dmnames.c b/source/components/disassembler/dmnames.c
index f942aead0f72..fc6a2cc6c381 100644
--- a/source/components/disassembler/dmnames.c
+++ b/source/components/disassembler/dmnames.c
@@ -179,7 +179,7 @@ AcpiPsDisplayObjectPathname (
     /* Convert NamedDesc/handle to a full pathname */
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (Node, &Buffer);
+    Status = AcpiNsHandleToPathname (Node, &Buffer, FALSE);
     if (ACPI_FAILURE (Status))
     {
         AcpiOsPrintf ("****Could not get pathname****)");
diff --git a/source/components/disassembler/dmopcode.c b/source/components/disassembler/dmopcode.c
index 60345fcaa599..35f9eef8251d 100644
--- a/source/components/disassembler/dmopcode.c
+++ b/source/components/disassembler/dmopcode.c
@@ -48,6 +48,7 @@
 #include "acdisasm.h"
 #include "acinterp.h"
 #include "acnamesp.h"
+#include "acdebug.h"
 
 #ifdef ACPI_DISASSEMBLER
 
@@ -967,7 +968,7 @@ AcpiDmDisassembleOneOp (
             (WalkState->Results) &&
             (WalkState->ResultCount))
         {
-            AcpiDmDecodeInternalObject (
+            AcpiDbDecodeInternalObject (
                 WalkState->Results->Results.ObjDesc [
                     (WalkState->ResultCount - 1) %
                         ACPI_RESULTS_FRAME_OBJ_NUM]);
diff --git a/source/components/disassembler/dmwalk.c b/source/components/disassembler/dmwalk.c
index 6a8c505439f4..8ae0dc8d86d2 100644
--- a/source/components/disassembler/dmwalk.c
+++ b/source/components/disassembler/dmwalk.c
@@ -313,6 +313,8 @@ AcpiDmBlockType (
             return (BLOCK_NONE);
         }
 
+        /*lint -fallthrough */
+
     default:
 
         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
@@ -410,7 +412,23 @@ AcpiDmDescendingOp (
     const ACPI_OPCODE_INFO  *OpInfo;
     UINT32                  Name;
     ACPI_PARSE_OBJECT       *NextOp;
+    UINT32                  AmlOffset;
+
+
+    if (AcpiGbl_DbOpt_Verbose && AcpiGbl_PreviousOp)
+    {
+        /* Dump the entire statement in AML byte code */
 
+        if (Op->Common.Aml > AcpiGbl_PreviousOp->Common.Aml)
+        {
+            AcpiOsPrintf ("\n");
+            AcpiUtDumpBuffer (AcpiGbl_PreviousOp->Common.Aml,
+                (Op->Common.Aml - AcpiGbl_PreviousOp->Common.Aml),
+                DB_BYTE_DISPLAY, 0);
+            AcpiDmIndent (Level);
+        }
+    }
+    AcpiGbl_PreviousOp = Op;
 
     if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
     {
@@ -427,10 +445,12 @@ AcpiDmDescendingOp (
 
         if (Info->WalkState)
         {
+            AmlOffset = (UINT32) ACPI_PTR_DIFF (Op->Common.Aml,
+                            Info->WalkState->ParserState.AmlStart);
             VERBOSE_PRINT ((DB_FULL_OP_INFO,
                 (Info->WalkState->MethodNode ?
                     Info->WalkState->MethodNode->Name.Ascii : "   "),
-                Op->Common.AmlOffset, (UINT32) Op->Common.AmlOpcode));
+                AmlOffset, (UINT32) Op->Common.AmlOpcode));
         }
 
         if (Op->Common.AmlOpcode == AML_SCOPE_OP)
diff --git a/source/components/dispatcher/dsargs.c b/source/components/dispatcher/dsargs.c
index c9a1709a64aa..5d2d5f5684ad 100644
--- a/source/components/dispatcher/dsargs.c
+++ b/source/components/dispatcher/dsargs.c
@@ -94,7 +94,7 @@ AcpiDsExecuteArguments (
 
     /* Allocate a new parser op to be the root of the parsed tree */
 
-    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
+    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP, AmlStart);
     if (!Op)
     {
         return_ACPI_STATUS (AE_NO_MEMORY);
@@ -141,7 +141,7 @@ AcpiDsExecuteArguments (
 
     /* Evaluate the deferred arguments */
 
-    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
+    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP, AmlStart);
     if (!Op)
     {
         return_ACPI_STATUS (AE_NO_MEMORY);
diff --git a/source/components/dispatcher/dsdebug.c b/source/components/dispatcher/dsdebug.c
new file mode 100644
index 000000000000..527bbf7461d2
--- /dev/null
+++ b/source/components/dispatcher/dsdebug.c
@@ -0,0 +1,249 @@
+/******************************************************************************
+ *
+ * Module Name: dsdebug - Parser/Interpreter interface - debugging
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, Intel Corp.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ */
+
+#include "acpi.h"
+#include "accommon.h"
+#include "acdispat.h"
+#include "acnamesp.h"
+#include "acdisasm.h"
+#include "acinterp.h"
+
+
+#define _COMPONENT          ACPI_DISPATCHER
+        ACPI_MODULE_NAME    ("dsdebug")
+
+
+#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
+
+/* Local prototypes */
+
+static void
+AcpiDsPrintNodePathname (
+    ACPI_NAMESPACE_NODE     *Node,
+    const char              *Message);
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDsPrintNodePathname
+ *
+ * PARAMETERS:  Node            - Object
+ *              Message         - Prefix message
+ *
+ * DESCRIPTION: Print an object's full namespace pathname
+ *              Manages allocation/freeing of a pathname buffer
+ *
+ ******************************************************************************/
+
+static void
+AcpiDsPrintNodePathname (
+    ACPI_NAMESPACE_NODE     *Node,
+    const char              *Message)
+{
+    ACPI_BUFFER             Buffer;
+    ACPI_STATUS             Status;
+
+
+    ACPI_FUNCTION_TRACE (DsPrintNodePathname);
+
+    if (!Node)
+    {
+        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH, "[NULL NAME]"));
+        return_VOID;
+    }
+
+    /* Convert handle to full pathname and print it (with supplied message) */
+
+    Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
+
+    Status = AcpiNsHandleToPathname (Node, &Buffer, FALSE);
+    if (ACPI_SUCCESS (Status))
+    {
+        if (Message)
+        {
+            ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH, "%s ", Message));
+        }
+
+        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH, "[%s] (Node %p)",
+            (char *) Buffer.Pointer, Node));
+        ACPI_FREE (Buffer.Pointer);
+    }
+
+    return_VOID;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDsDumpMethodStack
+ *
+ * PARAMETERS:  Status          - Method execution status
+ *              WalkState       - Current state of the parse tree walk
+ *              Op              - Executing parse op
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Called when a method has been aborted because of an error.
+ *              Dumps the method execution stack.
+ *
+ ******************************************************************************/
+
+void
+AcpiDsDumpMethodStack (
+    ACPI_STATUS             Status,
+    ACPI_WALK_STATE         *WalkState,
+    ACPI_PARSE_OBJECT       *Op)
+{
+    ACPI_PARSE_OBJECT       *Next;
+    ACPI_THREAD_STATE       *Thread;
+    ACPI_WALK_STATE         *NextWalkState;
+    ACPI_NAMESPACE_NODE     *PreviousMethod = NULL;
+    ACPI_OPERAND_OBJECT     *MethodDesc;
+
+
+    ACPI_FUNCTION_TRACE (DsDumpMethodStack);
+
+    /* Ignore control codes, they are not errors */
+
+    if ((Status & AE_CODE_MASK) == AE_CODE_CONTROL)
+    {
+        return_VOID;
+    }
+
+    /* We may be executing a deferred opcode */
+
+    if (WalkState->DeferredNode)
+    {
+        ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
+            "Executing subtree for Buffer/Package/Region\n"));
+        return_VOID;
+    }
+
+    /*
+     * If there is no Thread, we are not actually executing a method.
+     * This can happen when the iASL compiler calls the interpreter
+     * to perform constant folding.
+     */
+    Thread = WalkState->Thread;
+    if (!Thread)
+    {
+        return_VOID;
+    }
+
+    /* Display exception and method name */
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
+        "\n**** Exception %s during execution of method ",
+        AcpiFormatException (Status)));
+    AcpiDsPrintNodePathname (WalkState->MethodNode, NULL);
+
+    /* Display stack of executing methods */
+
+    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH,
+        "\n\nMethod Execution Stack:\n"));
+    NextWalkState = Thread->WalkStateList;
+
+    /* Walk list of linked walk states */
+
+    while (NextWalkState)
+    {
+        MethodDesc = NextWalkState->MethodDesc;
+        if (MethodDesc)
+        {
+            AcpiExStopTraceMethod (
+                    (ACPI_NAMESPACE_NODE *) MethodDesc->Method.Node,
+                    MethodDesc, WalkState);
+        }
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
+            "    Method [%4.4s] executing: ",
+            AcpiUtGetNodeName (NextWalkState->MethodNode)));
+
+        /* First method is the currently executing method */
+
+        if (NextWalkState == WalkState)
+        {
+            if (Op)
+            {
+                /* Display currently executing ASL statement */
+
+                Next = Op->Common.Next;
+                Op->Common.Next = NULL;
+
+#ifdef ACPI_DISASSEMBLER
+                AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);
+#endif
+                Op->Common.Next = Next;
+            }
+        }
+        else
+        {
+            /*
+             * This method has called another method
+             * NOTE: the method call parse subtree is already deleted at this
+             * point, so we cannot disassemble the method invocation.
+             */
+            ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH, "Call to method "));
+            AcpiDsPrintNodePathname (PreviousMethod, NULL);
+        }
+
+        PreviousMethod = NextWalkState->MethodNode;
+        NextWalkState = NextWalkState->Next;
+        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DISPATCH, "\n"));
+    }
+
+    return_VOID;
+}
+
+#else
+
+void
+AcpiDsDumpMethodStack (
+    ACPI_STATUS             Status,
+    ACPI_WALK_STATE         *WalkState,
+    ACPI_PARSE_OBJECT       *Op)
+{
+    return;
+}
+
+#endif
diff --git a/source/components/dispatcher/dsmethod.c b/source/components/dispatcher/dsmethod.c
index f1c3be8b1953..95e0cb3f2a00 100644
--- a/source/components/dispatcher/dsmethod.c
+++ b/source/components/dispatcher/dsmethod.c
@@ -46,9 +46,9 @@
 #include "acdispat.h"
 #include "acinterp.h"
 #include "acnamesp.h"
-#include "acdisasm.h"
 #include "acparser.h"
 #include "amlcode.h"
+#include "acdebug.h"
 
 
 #define _COMPONENT          ACPI_DISPATCHER
@@ -109,7 +109,7 @@ AcpiDsAutoSerializeMethod (
 
     /* Create/Init a root op for the method parse tree */
 
-    Op = AcpiPsAllocOp (AML_METHOD_OP);
+    Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart);
     if (!Op)
     {
         return_ACPI_STATUS (AE_NO_MEMORY);
@@ -213,7 +213,7 @@ AcpiDsDetectNamedOpcodes (
  * RETURN:      Status
  *
  * DESCRIPTION: Called on method error. Invoke the global exception handler if
- *              present, dump the method data if the disassembler is configured
+ *              present, dump the method data if the debugger is configured
  *
  *              Note: Allows the exception handler to change the status code
  *
@@ -224,6 +224,9 @@ AcpiDsMethodError (
     ACPI_STATUS             Status,
     ACPI_WALK_STATE         *WalkState)
 {
+    UINT32                  AmlOffset;
+
+
     ACPI_FUNCTION_ENTRY ();
 
 
@@ -247,23 +250,28 @@ AcpiDsMethodError (
          * Handler can map the exception code to anything it wants, including
          * AE_OK, in which case the executing method will not be aborted.
          */
+        AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->Aml,
+                        WalkState->ParserState.AmlStart);
+
         Status = AcpiGbl_ExceptionHandler (Status,
                     WalkState->MethodNode ?
                         WalkState->MethodNode->Name.Integer : 0,
-                    WalkState->Opcode, WalkState->AmlOffset, NULL);
+                    WalkState->Opcode, AmlOffset, NULL);
         AcpiExEnterInterpreter ();
     }
 
     AcpiDsClearImplicitReturn (WalkState);
 
-#ifdef ACPI_DISASSEMBLER
     if (ACPI_FAILURE (Status))
     {
-        /* Display method locals/args if disassembler is present */
+        AcpiDsDumpMethodStack (Status, WalkState, WalkState->Op);
 
-        AcpiDmDumpMethodInfo (Status, WalkState, WalkState->Op);
-    }
+        /* Display method locals/args if debugger is present */
+
+#ifdef ACPI_DEBUGGER
+        AcpiDbDumpMethodInfo (Status, WalkState);
 #endif
+    }
 
     return (Status);
 }
@@ -349,6 +357,8 @@ AcpiDsBeginMethodExecution (
         return_ACPI_STATUS (AE_NULL_ENTRY);
     }
 
+    AcpiExStartTraceMethod (MethodNode, ObjDesc, WalkState);
+
     /* Prevent wraparound of thread count */
 
     if (ObjDesc->Method.ThreadCount == ACPI_UINT8_MAX)
@@ -610,10 +620,7 @@ Cleanup:
     /* On error, we must terminate the method properly */
 
     AcpiDsTerminateControlMethod (ObjDesc, NextWalkState);
-    if (NextWalkState)
-    {
-        AcpiDsDeleteWalkState (NextWalkState);
-    }
+    AcpiDsDeleteWalkState (NextWalkState);
 
     return_ACPI_STATUS (Status);
 }
@@ -870,5 +877,8 @@ AcpiDsTerminateControlMethod (
         }
     }
 
+    AcpiExStopTraceMethod ((ACPI_NAMESPACE_NODE *) MethodDesc->Method.Node,
+            MethodDesc, WalkState);
+
     return_VOID;
 }
diff --git a/source/components/dispatcher/dswload.c b/source/components/dispatcher/dswload.c
index 37b7b39cbccc..bcc786801154 100644
--- a/source/components/dispatcher/dswload.c
+++ b/source/components/dispatcher/dswload.c
@@ -398,7 +398,7 @@ AcpiDsLoad1BeginOp (
     {
         /* Create a new op */
 
-        Op = AcpiPsAllocOp (WalkState->Opcode);
+        Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml);
         if (!Op)
         {
             return_ACPI_STATUS (AE_NO_MEMORY);
diff --git a/source/components/dispatcher/dswload2.c b/source/components/dispatcher/dswload2.c
index f7d43fe19e8a..f6095d971900 100644
--- a/source/components/dispatcher/dswload2.c
+++ b/source/components/dispatcher/dswload2.c
@@ -344,7 +344,7 @@ AcpiDsLoad2BeginOp (
     {
         /* Create a new op */
 
-        Op = AcpiPsAllocOp (WalkState->Opcode);
+        Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml);
         if (!Op)
         {
             return_ACPI_STATUS (AE_NO_MEMORY);
diff --git a/source/components/executer/excreate.c b/source/components/executer/excreate.c
index c7f945b048e6..9a002b88b657 100644
--- a/source/components/executer/excreate.c
+++ b/source/components/executer/excreate.c
@@ -526,6 +526,7 @@ AcpiExCreateMethod (
 
     ObjDesc->Method.AmlStart = AmlStart;
     ObjDesc->Method.AmlLength = AmlLength;
+    ObjDesc->Method.Node = Operand[0];
 
     /*
      * Disassemble the method flags. Split off the ArgCount, Serialized
diff --git a/source/components/executer/exdebug.c b/source/components/executer/exdebug.c
index 6ca866c01b04..f50d07b17945 100644
--- a/source/components/executer/exdebug.c
+++ b/source/components/executer/exdebug.c
@@ -43,13 +43,26 @@
 
 #include "acpi.h"
 #include "accommon.h"
+#include "acnamesp.h"
 #include "acinterp.h"
+#include "acparser.h"
 
 
 #define _COMPONENT          ACPI_EXECUTER
         ACPI_MODULE_NAME    ("exdebug")
 
 
+static ACPI_OPERAND_OBJECT  *AcpiGbl_TraceMethodObject = NULL;
+
+/* Local prototypes */
+
+#ifdef ACPI_DEBUG_OUTPUT
+static const char *
+AcpiExGetTraceEventName (
+    ACPI_TRACE_EVENT_TYPE   Type);
+#endif
+
+
 #ifndef ACPI_NO_ERROR_MESSAGES
 /*******************************************************************************
  *
@@ -314,3 +327,362 @@ AcpiExDoDebugObject (
     return_VOID;
 }
 #endif
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExInterpreterTraceEnabled
+ *
+ * PARAMETERS:  Name                - Whether method name should be matched,
+ *                                    this should be checked before starting
+ *                                    the tracer
+ *
+ * RETURN:      TRUE if interpreter trace is enabled.
+ *
+ * DESCRIPTION: Check whether interpreter trace is enabled
+ *
+ ******************************************************************************/
+
+static BOOLEAN
+AcpiExInterpreterTraceEnabled (
+    char                    *Name)
+{
+
+    /* Check if tracing is enabled */
+
+    if (!(AcpiGbl_TraceFlags & ACPI_TRACE_ENABLED))
+    {
+        return (FALSE);
+    }
+
+    /*
+     * Check if tracing is filtered:
+     *
+     * 1. If the tracer is started, AcpiGbl_TraceMethodObject should have
+     *    been filled by the trace starter
+     * 2. If the tracer is not started, AcpiGbl_TraceMethodName should be
+     *    matched if it is specified
+     * 3. If the tracer is oneshot style, AcpiGbl_TraceMethodName should
+     *    not be cleared by the trace stopper during the first match
+     */
+    if (AcpiGbl_TraceMethodObject)
+    {
+        return (TRUE);
+    }
+    if (Name &&
+        (AcpiGbl_TraceMethodName &&
+         strcmp (AcpiGbl_TraceMethodName, Name)))
+    {
+        return (FALSE);
+    }
+    if ((AcpiGbl_TraceFlags & ACPI_TRACE_ONESHOT) &&
+        !AcpiGbl_TraceMethodName)
+    {
+        return (FALSE);
+    }
+
+    return (TRUE);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExGetTraceEventName
+ *
+ * PARAMETERS:  Type            - Trace event type
+ *
+ * RETURN:      Trace event name.
+ *
+ * DESCRIPTION: Used to obtain the full trace event name.
+ *
+ ******************************************************************************/
+
+#ifdef ACPI_DEBUG_OUTPUT
+
+static const char *
+AcpiExGetTraceEventName (
+    ACPI_TRACE_EVENT_TYPE   Type)
+{
+    switch (Type)
+    {
+    case ACPI_TRACE_AML_METHOD:
+
+        return "Method";
+
+    case ACPI_TRACE_AML_OPCODE:
+
+        return "Opcode";
+
+    case ACPI_TRACE_AML_REGION:
+
+        return "Region";
+
+    default:
+
+        return "";
+    }
+}
+
+#endif
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExTracePoint
+ *
+ * PARAMETERS:  Type                - Trace event type
+ *              Begin               - TRUE if before execution
+ *              Aml                 - Executed AML address
+ *              Pathname            - Object path
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Internal interpreter execution trace.
+ *
+ ******************************************************************************/
+
+void
+AcpiExTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname)
+{
+
+    ACPI_FUNCTION_NAME (ExTracePoint);
+
+
+    if (Pathname)
+    {
+        ACPI_DEBUG_PRINT ((ACPI_DB_TRACE_POINT,
+                "%s %s [0x%p:%s] execution.\n",
+                AcpiExGetTraceEventName (Type), Begin ? "Begin" : "End",
+                Aml, Pathname));
+    }
+    else
+    {
+        ACPI_DEBUG_PRINT ((ACPI_DB_TRACE_POINT,
+                "%s %s [0x%p] execution.\n",
+                AcpiExGetTraceEventName (Type), Begin ? "Begin" : "End",
+                Aml));
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExStartTraceMethod
+ *
+ * PARAMETERS:  MethodNode          - Node of the method
+ *              ObjDesc             - The method object
+ *              WalkState           - current state, NULL if not yet executing
+ *                                    a method.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Start control method execution trace
+ *
+ ******************************************************************************/
+
+void
+AcpiExStartTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status;
+    char                    *Pathname = NULL;
+    BOOLEAN                 Enabled = FALSE;
+
+
+    ACPI_FUNCTION_NAME (ExStartTraceMethod);
+
+
+    if (MethodNode)
+    {
+        Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
+    }
+
+    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
+    if (ACPI_FAILURE (Status))
+    {
+        goto Exit;
+    }
+
+    Enabled = AcpiExInterpreterTraceEnabled (Pathname);
+    if (Enabled && !AcpiGbl_TraceMethodObject)
+    {
+        AcpiGbl_TraceMethodObject = ObjDesc;
+        AcpiGbl_OriginalDbgLevel = AcpiDbgLevel;
+        AcpiGbl_OriginalDbgLayer = AcpiDbgLayer;
+        AcpiDbgLevel = ACPI_TRACE_LEVEL_ALL;
+        AcpiDbgLayer = ACPI_TRACE_LAYER_ALL;
+
+        if (AcpiGbl_TraceDbgLevel)
+        {
+            AcpiDbgLevel = AcpiGbl_TraceDbgLevel;
+        }
+        if (AcpiGbl_TraceDbgLayer)
+        {
+            AcpiDbgLayer = AcpiGbl_TraceDbgLayer;
+        }
+    }
+    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
+
+Exit:
+    if (Enabled)
+    {
+        ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, TRUE,
+                ObjDesc ? ObjDesc->Method.AmlStart : NULL, Pathname);
+    }
+    if (Pathname)
+    {
+        ACPI_FREE (Pathname);
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExStopTraceMethod
+ *
+ * PARAMETERS:  MethodNode          - Node of the method
+ *              ObjDesc             - The method object
+ *              WalkState           - current state, NULL if not yet executing
+ *                                    a method.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Stop control method execution trace
+ *
+ ******************************************************************************/
+
+void
+AcpiExStopTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status;
+    char                    *Pathname = NULL;
+    BOOLEAN                 Enabled;
+
+
+    ACPI_FUNCTION_NAME (ExStopTraceMethod);
+
+
+    if (MethodNode)
+    {
+        Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
+    }
+
+    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
+    if (ACPI_FAILURE (Status))
+    {
+        goto ExitPath;
+    }
+
+    Enabled = AcpiExInterpreterTraceEnabled (NULL);
+
+    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
+
+    if (Enabled)
+    {
+        ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, FALSE,
+                ObjDesc ? ObjDesc->Method.AmlStart : NULL, Pathname);
+    }
+
+    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
+    if (ACPI_FAILURE (Status))
+    {
+        goto ExitPath;
+    }
+
+    /* Check whether the tracer should be stopped */
+
+    if (AcpiGbl_TraceMethodObject == ObjDesc)
+    {
+        /* Disable further tracing if type is one-shot */
+
+        if (AcpiGbl_TraceFlags & ACPI_TRACE_ONESHOT)
+        {
+            AcpiGbl_TraceMethodName = NULL;
+        }
+
+        AcpiDbgLevel = AcpiGbl_OriginalDbgLevel;
+        AcpiDbgLayer = AcpiGbl_OriginalDbgLayer;
+        AcpiGbl_TraceMethodObject = NULL;
+    }
+
+    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
+
+ExitPath:
+    if (Pathname)
+    {
+        ACPI_FREE (Pathname);
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExStartTraceOpcode
+ *
+ * PARAMETERS:  Op                  - The parser opcode object
+ *              WalkState           - current state, NULL if not yet executing
+ *                                    a method.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Start opcode execution trace
+ *
+ ******************************************************************************/
+
+void
+AcpiExStartTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+{
+
+    ACPI_FUNCTION_NAME (ExStartTraceOpcode);
+
+
+    if (AcpiExInterpreterTraceEnabled (NULL) &&
+        (AcpiGbl_TraceFlags & ACPI_TRACE_OPCODE))
+    {
+        ACPI_TRACE_POINT (ACPI_TRACE_AML_OPCODE, TRUE,
+                Op->Common.Aml, Op->Common.AmlOpName);
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExStopTraceOpcode
+ *
+ * PARAMETERS:  Op                  - The parser opcode object
+ *              WalkState           - current state, NULL if not yet executing
+ *                                    a method.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Stop opcode execution trace
+ *
+ ******************************************************************************/
+
+void
+AcpiExStopTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+{
+
+    ACPI_FUNCTION_NAME (ExStopTraceOpcode);
+
+
+    if (AcpiExInterpreterTraceEnabled (NULL) &&
+        (AcpiGbl_TraceFlags & ACPI_TRACE_OPCODE))
+    {
+        ACPI_TRACE_POINT (ACPI_TRACE_AML_OPCODE, FALSE,
+                Op->Common.Aml, Op->Common.AmlOpName);
+    }
+}
diff --git a/source/components/executer/exdump.c b/source/components/executer/exdump.c
index 299a1a0928ed..3142e62c088b 100644
--- a/source/components/executer/exdump.c
+++ b/source/components/executer/exdump.c
@@ -1039,7 +1039,8 @@ AcpiExDumpReferenceObj (
     {
         AcpiOsPrintf (" %p ", ObjDesc->Reference.Node);
 
-        Status = AcpiNsHandleToPathname (ObjDesc->Reference.Node, &RetBuf);
+        Status = AcpiNsHandleToPathname (ObjDesc->Reference.Node,
+                    &RetBuf, FALSE);
         if (ACPI_FAILURE (Status))
         {
             AcpiOsPrintf (" Could not convert name to pathname\n");
diff --git a/source/components/namespace/nsnames.c b/source/components/namespace/nsnames.c
index 22e697b592b7..ea10930d1e4b 100644
--- a/source/components/namespace/nsnames.c
+++ b/source/components/namespace/nsnames.c
@@ -53,82 +53,6 @@
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiNsBuildExternalPath
- *
- * PARAMETERS:  Node            - NS node whose pathname is needed
- *              Size            - Size of the pathname
- *              *NameBuffer     - Where to return the pathname
- *
- * RETURN:      Status
- *              Places the pathname into the NameBuffer, in external format
- *              (name segments separated by path separators)
- *
- * DESCRIPTION: Generate a full pathaname
- *
- ******************************************************************************/
-
-ACPI_STATUS
-AcpiNsBuildExternalPath (
-    ACPI_NAMESPACE_NODE     *Node,
-    ACPI_SIZE               Size,
-    char                    *NameBuffer)
-{
-    ACPI_SIZE               Index;
-    ACPI_NAMESPACE_NODE     *ParentNode;
-
-
-    ACPI_FUNCTION_ENTRY ();
-
-
-    /* Special case for root */
-
-    Index = Size - 1;
-    if (Index < ACPI_NAME_SIZE)
-    {
-        NameBuffer[0] = AML_ROOT_PREFIX;
-        NameBuffer[1] = 0;
-        return (AE_OK);
-    }
-
-    /* Store terminator byte, then build name backwards */
-
-    ParentNode = Node;
-    NameBuffer[Index] = 0;
-
-    while ((Index > ACPI_NAME_SIZE) && (ParentNode != AcpiGbl_RootNode))
-    {
-        Index -= ACPI_NAME_SIZE;
-
-        /* Put the name into the buffer */
-
-        ACPI_MOVE_32_TO_32 ((NameBuffer + Index), &ParentNode->Name);
-        ParentNode = ParentNode->Parent;
-
-        /* Prefix name with the path separator */
-
-        Index--;
-        NameBuffer[Index] = ACPI_PATH_SEPARATOR;
-    }
-
-    /* Overwrite final separator with the root prefix character */
-
-    NameBuffer[Index] = AML_ROOT_PREFIX;
-
-    if (Index != 0)
-    {
-        ACPI_ERROR ((AE_INFO,
-            "Could not construct external pathname; index=%u, size=%u, Path=%s",
-            (UINT32) Index, (UINT32) Size, &NameBuffer[Size]));
-
-        return (AE_BAD_PARAMETER);
-    }
-
-    return (AE_OK);
-}
-
-
-/*******************************************************************************
- *
  * FUNCTION:    AcpiNsGetExternalPathname
  *
  * PARAMETERS:  Node            - Namespace node whose pathname is needed
@@ -146,39 +70,13 @@ char *
 AcpiNsGetExternalPathname (
     ACPI_NAMESPACE_NODE     *Node)
 {
-    ACPI_STATUS             Status;
     char                    *NameBuffer;
-    ACPI_SIZE               Size;
 
 
     ACPI_FUNCTION_TRACE_PTR (NsGetExternalPathname, Node);
 
 
-    /* Calculate required buffer size based on depth below root */
-
-    Size = AcpiNsGetPathnameLength (Node);
-    if (!Size)
-    {
-        return_PTR (NULL);
-    }
-
-    /* Allocate a buffer to be returned to caller */
-
-    NameBuffer = ACPI_ALLOCATE_ZEROED (Size);
-    if (!NameBuffer)
-    {
-        ACPI_ERROR ((AE_INFO, "Could not allocate %u bytes", (UINT32) Size));
-        return_PTR (NULL);
-    }
-
-    /* Build the path in the allocated buffer */
-
-    Status = AcpiNsBuildExternalPath (Node, Size, NameBuffer);
-    if (ACPI_FAILURE (Status))
-    {
-        ACPI_FREE (NameBuffer);
-        return_PTR (NULL);
-    }
+    NameBuffer = AcpiNsGetNormalizedPathname (Node, FALSE);
 
     return_PTR (NameBuffer);
 }
@@ -201,38 +99,14 @@ AcpiNsGetPathnameLength (
     ACPI_NAMESPACE_NODE     *Node)
 {
     ACPI_SIZE               Size;
-    ACPI_NAMESPACE_NODE     *NextNode;
 
 
     ACPI_FUNCTION_ENTRY ();
 
 
-    /*
-     * Compute length of pathname as 5 * number of name segments.
-     * Go back up the parent tree to the root
-     */
-    Size = 0;
-    NextNode = Node;
+    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, FALSE);
 
-    while (NextNode && (NextNode != AcpiGbl_RootNode))
-    {
-        if (ACPI_GET_DESCRIPTOR_TYPE (NextNode) != ACPI_DESC_TYPE_NAMED)
-        {
-            ACPI_ERROR ((AE_INFO,
-                "Invalid Namespace Node (%p) while traversing namespace",
-                NextNode));
-            return (0);
-        }
-        Size += ACPI_PATH_SEGMENT_LENGTH;
-        NextNode = NextNode->Parent;
-    }
-
-    if (!Size)
-    {
-        Size = 1; /* Root node case */
-    }
-
-    return (Size + 1);  /* +1 for null string terminator */
+    return (Size);
 }
 
 
@@ -243,6 +117,8 @@ AcpiNsGetPathnameLength (
  * PARAMETERS:  TargetHandle            - Handle of named object whose name is
  *                                        to be found
  *              Buffer                  - Where the pathname is returned
+ *              NoTrailing              - Remove trailing '_' for each name
+ *                                        segment
  *
  * RETURN:      Status, Buffer is filled with pathname if status is AE_OK
  *
@@ -253,7 +129,8 @@ AcpiNsGetPathnameLength (
 ACPI_STATUS
 AcpiNsHandleToPathname (
     ACPI_HANDLE             TargetHandle,
-    ACPI_BUFFER             *Buffer)
+    ACPI_BUFFER             *Buffer,
+    BOOLEAN                 NoTrailing)
 {
     ACPI_STATUS             Status;
     ACPI_NAMESPACE_NODE     *Node;
@@ -271,7 +148,7 @@ AcpiNsHandleToPathname (
 
     /* Determine size required for the caller buffer */
 
-    RequiredSize = AcpiNsGetPathnameLength (Node);
+    RequiredSize = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);
     if (!RequiredSize)
     {
         return_ACPI_STATUS (AE_BAD_PARAMETER);
@@ -287,7 +164,8 @@ AcpiNsHandleToPathname (
 
     /* Build the path in the caller buffer */
 
-    Status = AcpiNsBuildExternalPath (Node, RequiredSize, Buffer->Pointer);
+    (void) AcpiNsBuildNormalizedPath (Node, Buffer->Pointer,
+            RequiredSize, NoTrailing);
     if (ACPI_FAILURE (Status))
     {
         return_ACPI_STATUS (Status);
@@ -297,3 +175,169 @@ AcpiNsHandleToPathname (
         (char *) Buffer->Pointer, (UINT32) RequiredSize));
     return_ACPI_STATUS (AE_OK);
 }
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiNsBuildNormalizedPath
+ *
+ * PARAMETERS:  Node        - Namespace node
+ *              FullPath    - Where the path name is returned
+ *              PathSize    - Size of returned path name buffer
+ *              NoTrailing  - Remove trailing '_' from each name segment
+ *
+ * RETURN:      Return 1 if the AML path is empty, otherwise returning (length
+ *              of pathname + 1) which means the 'FullPath' contains a trailing
+ *              null.
+ *
+ * DESCRIPTION: Build and return a full namespace pathname.
+ *              Note that if the size of 'FullPath' isn't large enough to
+ *              contain the namespace node's path name, the actual required
+ *              buffer length is returned, and it should be greater than
+ *              'PathSize'. So callers are able to check the returning value
+ *              to determine the buffer size of 'FullPath'.
+ *
+ ******************************************************************************/
+
+UINT32
+AcpiNsBuildNormalizedPath (
+    ACPI_NAMESPACE_NODE     *Node,
+    char                    *FullPath,
+    UINT32                  PathSize,
+    BOOLEAN                 NoTrailing)
+{
+    UINT32                  Length = 0, i;
+    char                    Name[ACPI_NAME_SIZE];
+    BOOLEAN                 DoNoTrailing;
+    char                    c, *Left, *Right;
+    ACPI_NAMESPACE_NODE     *NextNode;
+
+
+    ACPI_FUNCTION_TRACE_PTR (NsBuildNormalizedPath, Node);
+
+
+#define ACPI_PATH_PUT8(Path, Size, Byte, Length)    \
+    do {                                            \
+        if ((Length) < (Size))                      \
+        {                                           \
+            (Path)[(Length)] = (Byte);              \
+        }                                           \
+        (Length)++;                                 \
+    } while (0)
+
+    /*
+     * Make sure the PathSize is correct, so that we don't need to
+     * validate both FullPath and PathSize.
+     */
+    if (!FullPath)
+    {
+        PathSize = 0;
+    }
+
+    if (!Node)
+    {
+        goto BuildTrailingNull;
+    }
+
+    NextNode = Node;
+    while (NextNode && NextNode != AcpiGbl_RootNode)
+    {
+        if (NextNode != Node)
+        {
+            ACPI_PATH_PUT8(FullPath, PathSize, AML_DUAL_NAME_PREFIX, Length);
+        }
+        ACPI_MOVE_32_TO_32 (Name, &NextNode->Name);
+        DoNoTrailing = NoTrailing;
+        for (i = 0; i < 4; i++)
+        {
+            c = Name[4-i-1];
+            if (DoNoTrailing && c != '_')
+            {
+                DoNoTrailing = FALSE;
+            }
+            if (!DoNoTrailing)
+            {
+                ACPI_PATH_PUT8(FullPath, PathSize, c, Length);
+            }
+        }
+        NextNode = NextNode->Parent;
+    }
+    ACPI_PATH_PUT8(FullPath, PathSize, AML_ROOT_PREFIX, Length);
+
+    /* Reverse the path string */
+
+    if (Length <= PathSize)
+    {
+        Left = FullPath;
+        Right = FullPath+Length-1;
+        while (Left < Right)
+        {
+            c = *Left;
+            *Left++ = *Right;
+            *Right-- = c;
+        }
+    }
+
+    /* Append the trailing null */
+
+BuildTrailingNull:
+    ACPI_PATH_PUT8(FullPath, PathSize, '\0', Length);
+
+#undef ACPI_PATH_PUT8
+
+    return_UINT32 (Length);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiNsGetNormalizedPathname
+ *
+ * PARAMETERS:  Node            - Namespace node whose pathname is needed
+ *              NoTrailing      - Remove trailing '_' from each name segment
+ *
+ * RETURN:      Pointer to storage containing the fully qualified name of
+ *              the node, In external format (name segments separated by path
+ *              separators.)
+ *
+ * DESCRIPTION: Used to obtain the full pathname to a namespace node, usually
+ *              for error and debug statements. All trailing '_' will be
+ *              removed from the full pathname if 'NoTrailing' is specified..
+ *
+ ******************************************************************************/
+
+char *
+AcpiNsGetNormalizedPathname (
+    ACPI_NAMESPACE_NODE     *Node,
+    BOOLEAN                 NoTrailing)
+{
+    char                    *NameBuffer;
+    ACPI_SIZE               Size;
+
+
+    ACPI_FUNCTION_TRACE_PTR (NsGetNormalizedPathname, Node);
+
+
+    /* Calculate required buffer size based on depth below root */
+
+    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);
+    if (!Size)
+    {
+        return_PTR (NULL);
+    }
+
+    /* Allocate a buffer to be returned to caller */
+
+    NameBuffer = ACPI_ALLOCATE_ZEROED (Size);
+    if (!NameBuffer)
+    {
+        ACPI_ERROR ((AE_INFO, "Could not allocate %u bytes", (UINT32) Size));
+        return_PTR (NULL);
+    }
+
+    /* Build the path in the allocated buffer */
+
+    (void) AcpiNsBuildNormalizedPath (Node, NameBuffer, Size, NoTrailing);
+
+    return_PTR (NameBuffer);
+}
diff --git a/source/components/namespace/nsparse.c b/source/components/namespace/nsparse.c
index bfc5615ade68..996db01747fb 100644
--- a/source/components/namespace/nsparse.c
+++ b/source/components/namespace/nsparse.c
@@ -84,6 +84,22 @@ AcpiNsOneCompleteParse (
     ACPI_FUNCTION_TRACE (NsOneCompleteParse);
 
 
+    Status = AcpiGetTableByIndex (TableIndex, &Table);
+    if (ACPI_FAILURE (Status))
+    {
+        return_ACPI_STATUS (Status);
+    }
+
+    /* Table must consist of at least a complete header */
+
+    if (Table->Length < sizeof (ACPI_TABLE_HEADER))
+    {
+        return_ACPI_STATUS (AE_BAD_HEADER);
+    }
+
+    AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);
+    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
+
     Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);
     if (ACPI_FAILURE (Status))
     {
@@ -92,7 +108,7 @@ AcpiNsOneCompleteParse (
 
     /* Create and init a Root Node */
 
-    ParseRoot = AcpiPsCreateScopeOp ();
+    ParseRoot = AcpiPsCreateScopeOp (AmlStart);
     if (!ParseRoot)
     {
         return_ACPI_STATUS (AE_NO_MEMORY);
@@ -107,26 +123,12 @@ AcpiNsOneCompleteParse (
         return_ACPI_STATUS (AE_NO_MEMORY);
     }
 
-    Status = AcpiGetTableByIndex (TableIndex, &Table);
+    Status = AcpiDsInitAmlWalk (WalkState, ParseRoot, NULL,
+                AmlStart, AmlLength, NULL, (UINT8) PassNumber);
     if (ACPI_FAILURE (Status))
     {
         AcpiDsDeleteWalkState (WalkState);
-        AcpiPsFreeOp (ParseRoot);
-        return_ACPI_STATUS (Status);
-    }
-
-    /* Table must consist of at least a complete header */
-
-    if (Table->Length < sizeof (ACPI_TABLE_HEADER))
-    {
-        Status = AE_BAD_HEADER;
-    }
-    else
-    {
-        AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);
-        AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
-        Status = AcpiDsInitAmlWalk (WalkState, ParseRoot, NULL,
-                    AmlStart, AmlLength, NULL, (UINT8) PassNumber);
+        goto Cleanup;
     }
 
     /* Found OSDT table, enable the namespace override feature */
@@ -137,12 +139,6 @@ AcpiNsOneCompleteParse (
         WalkState->NamespaceOverride = TRUE;
     }
 
-    if (ACPI_FAILURE (Status))
-    {
-        AcpiDsDeleteWalkState (WalkState);
-        goto Cleanup;
-    }
-
     /* StartNode is the default location to load the table  */
 
     if (StartNode && StartNode != AcpiGbl_RootNode)
diff --git a/source/components/namespace/nsutils.c b/source/components/namespace/nsutils.c
index 5335810c6028..83d75d0207ed 100644
--- a/source/components/namespace/nsutils.c
+++ b/source/components/namespace/nsutils.c
@@ -90,7 +90,7 @@ AcpiNsPrintNodePathname (
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 
-    Status = AcpiNsHandleToPathname (Node, &Buffer);
+    Status = AcpiNsHandleToPathname (Node, &Buffer, FALSE);
     if (ACPI_SUCCESS (Status))
     {
         if (Message)
diff --git a/source/components/namespace/nsxfname.c b/source/components/namespace/nsxfname.c
index 7f92201843aa..311431b2de84 100644
--- a/source/components/namespace/nsxfname.c
+++ b/source/components/namespace/nsxfname.c
@@ -193,11 +193,13 @@ AcpiGetName (
         return (Status);
     }
 
-    if (NameType == ACPI_FULL_PATHNAME)
+    if (NameType == ACPI_FULL_PATHNAME ||
+        NameType == ACPI_FULL_PATHNAME_NO_TRAILING)
     {
         /* Get the full pathname (From the namespace root) */
 
-        Status = AcpiNsHandleToPathname (Handle, Buffer);
+        Status = AcpiNsHandleToPathname (Handle, Buffer,
+                    NameType == ACPI_FULL_PATHNAME ? FALSE : TRUE);
         return (Status);
     }
 
diff --git a/source/components/parser/psargs.c b/source/components/parser/psargs.c
index ae6807304a8d..538b73eebd1f 100644
--- a/source/components/parser/psargs.c
+++ b/source/components/parser/psargs.c
@@ -316,7 +316,7 @@ AcpiPsGetNextNamepath (
         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
             "Control Method - %p Desc %p Path=%p\n", Node, MethodDesc, Path));
 
-        NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
+        NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
         if (!NameOp)
         {
             return_ACPI_STATUS (AE_NO_MEMORY);
@@ -524,7 +524,7 @@ static ACPI_PARSE_OBJECT *
 AcpiPsGetNextField (
     ACPI_PARSE_STATE        *ParserState)
 {
-    UINT32                  AmlOffset;
+    UINT8                   *Aml;
     ACPI_PARSE_OBJECT       *Field;
     ACPI_PARSE_OBJECT       *Arg = NULL;
     UINT16                  Opcode;
@@ -540,8 +540,7 @@ AcpiPsGetNextField (
     ACPI_FUNCTION_TRACE (PsGetNextField);
 
 
-    AmlOffset = (UINT32) ACPI_PTR_DIFF (
-        ParserState->Aml, ParserState->AmlStart);
+    Aml = ParserState->Aml;
 
     /* Determine field type */
 
@@ -579,14 +578,12 @@ AcpiPsGetNextField (
 
     /* Allocate a new field op */
 
-    Field = AcpiPsAllocOp (Opcode);
+    Field = AcpiPsAllocOp (Opcode, Aml);
     if (!Field)
     {
         return_PTR (NULL);
     }
 
-    Field->Common.AmlOffset = AmlOffset;
-
     /* Decode the field type */
 
     switch (Opcode)
@@ -650,6 +647,7 @@ AcpiPsGetNextField (
          * Argument for Connection operator can be either a Buffer
          * (resource descriptor), or a NameString.
          */
+        Aml = ParserState->Aml;
         if (ACPI_GET8 (ParserState->Aml) == AML_BUFFER_OP)
         {
             ParserState->Aml++;
@@ -662,7 +660,7 @@ AcpiPsGetNextField (
             {
                 /* Non-empty list */
 
-                Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP);
+                Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP, Aml);
                 if (!Arg)
                 {
                     AcpiPsFreeOp (Field);
@@ -712,7 +710,7 @@ AcpiPsGetNextField (
         }
         else
         {
-            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
+            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Aml);
             if (!Arg)
             {
                 AcpiPsFreeOp (Field);
@@ -784,7 +782,7 @@ AcpiPsGetNextArg (
 
         /* Constants, strings, and namestrings are all the same size */
 
-        Arg = AcpiPsAllocOp (AML_BYTE_OP);
+        Arg = AcpiPsAllocOp (AML_BYTE_OP, ParserState->Aml);
         if (!Arg)
         {
             return_ACPI_STATUS (AE_NO_MEMORY);
@@ -836,7 +834,8 @@ AcpiPsGetNextArg (
         {
             /* Non-empty list */
 
-            Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP);
+            Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP,
+                    ParserState->Aml);
             if (!Arg)
             {
                 return_ACPI_STATUS (AE_NO_MEMORY);
@@ -866,7 +865,7 @@ AcpiPsGetNextArg (
         {
             /* NullName or NameString */
 
-            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
+            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
             if (!Arg)
             {
                 return_ACPI_STATUS (AE_NO_MEMORY);
diff --git a/source/components/parser/psloop.c b/source/components/parser/psloop.c
index 4e1eb29b6978..7c079444bb11 100644
--- a/source/components/parser/psloop.c
+++ b/source/components/parser/psloop.c
@@ -51,6 +51,7 @@
 
 #include "acpi.h"
 #include "accommon.h"
+#include "acinterp.h"
 #include "acparser.h"
 #include "acdispat.h"
 #include "amlcode.h"
@@ -134,8 +135,7 @@ AcpiPsGetArguments (
          */
         while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) && !WalkState->ArgCount)
         {
-            WalkState->AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->ParserState.Aml,
-                WalkState->ParserState.AmlStart);
+            WalkState->Aml = WalkState->ParserState.Aml;
 
             Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
                         GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
@@ -146,7 +146,6 @@ AcpiPsGetArguments (
 
             if (Arg)
             {
-                Arg->Common.AmlOffset = WalkState->AmlOffset;
                 AcpiPsAppendArg (Op, Arg);
             }
 
@@ -502,15 +501,7 @@ AcpiPsParseLoop (
                 continue;
             }
 
-            Op->Common.AmlOffset = WalkState->AmlOffset;
-
-            if (WalkState->OpInfo)
-            {
-                ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
-                    "Opcode %4.4X [%s] Op %p Aml %p AmlOffset %5.5X\n",
-                     (UINT32) Op->Common.AmlOpcode, WalkState->OpInfo->Name,
-                     Op, ParserState->Aml, Op->Common.AmlOffset));
-            }
+            AcpiExStartTraceOpcode (Op, WalkState);
         }
 
 
diff --git a/source/components/parser/psobject.c b/source/components/parser/psobject.c
index ed65495d9322..b9d8e8ce69bb 100644
--- a/source/components/parser/psobject.c
+++ b/source/components/parser/psobject.c
@@ -73,12 +73,13 @@ static ACPI_STATUS
 AcpiPsGetAmlOpcode (
     ACPI_WALK_STATE         *WalkState)
 {
+    UINT32                  AmlOffset;
+
 
     ACPI_FUNCTION_TRACE_PTR (PsGetAmlOpcode, WalkState);
 
 
-    WalkState->AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->ParserState.Aml,
-                                WalkState->ParserState.AmlStart);
+    WalkState->Aml = WalkState->ParserState.Aml;
     WalkState->Opcode = AcpiPsPeekOpcode (&(WalkState->ParserState));
 
     /*
@@ -107,10 +108,13 @@ AcpiPsGetAmlOpcode (
 
         if (WalkState->PassNumber == 2)
         {
+            AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->Aml,
+                            WalkState->ParserState.AmlStart);
+
             ACPI_ERROR ((AE_INFO,
                 "Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring",
                 WalkState->Opcode,
-                (UINT32) (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER))));
+                (UINT32) (AmlOffset + sizeof (ACPI_TABLE_HEADER))));
 
             ACPI_DUMP_BUFFER ((WalkState->ParserState.Aml - 16), 48);
 
@@ -122,13 +126,13 @@ AcpiPsGetAmlOpcode (
             AcpiOsPrintf (
                 "/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n",
                 WalkState->Opcode,
-                (UINT32) (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER)));
+                (UINT32) (AmlOffset + sizeof (ACPI_TABLE_HEADER)));
 
             /* Dump the context surrounding the invalid opcode */
 
             AcpiUtDumpBuffer (((UINT8 *) WalkState->ParserState.Aml - 16),
                 48, DB_BYTE_DISPLAY,
-                (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER) - 16));
+                (AmlOffset + sizeof (ACPI_TABLE_HEADER) - 16));
             AcpiOsPrintf (" */\n");
 #endif
         }
@@ -313,7 +317,7 @@ AcpiPsCreateOp (
     /* Create Op structure and append to parent's argument list */
 
     WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
-    Op = AcpiPsAllocOp (WalkState->Opcode);
+    Op = AcpiPsAllocOp (WalkState->Opcode, AmlOpStart);
     if (!Op)
     {
         return_ACPI_STATUS (AE_NO_MEMORY);
diff --git a/source/components/parser/psparse.c b/source/components/parser/psparse.c
index 39520db3dfd4..49ab6313a1ac 100644
--- a/source/components/parser/psparse.c
+++ b/source/components/parser/psparse.c
@@ -161,6 +161,8 @@ AcpiPsCompleteThisOp (
         return_ACPI_STATUS (AE_OK);  /* OK for now */
     }
 
+    AcpiExStopTraceOpcode (Op, WalkState);
+
     /* Delete this op and the subtree below it if asked to */
 
     if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) != ACPI_PARSE_DELETE_TREE) ||
@@ -198,7 +200,8 @@ AcpiPsCompleteThisOp (
              * These opcodes contain TermArg operands. The current
              * op must be replaced by a placeholder return op
              */
-            ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP);
+            ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP,
+                                Op->Common.Aml);
             if (!ReplacementOp)
             {
                 Status = AE_NO_MEMORY;
@@ -217,7 +220,8 @@ AcpiPsCompleteThisOp (
                 (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP)   ||
                 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
             {
-                ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP);
+                ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP,
+                                    Op->Common.Aml);
                 if (!ReplacementOp)
                 {
                     Status = AE_NO_MEMORY;
@@ -230,7 +234,8 @@ AcpiPsCompleteThisOp (
                     (Op->Common.AmlOpcode == AML_PACKAGE_OP) ||
                     (Op->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
                 {
-                    ReplacementOp = AcpiPsAllocOp (Op->Common.AmlOpcode);
+                    ReplacementOp = AcpiPsAllocOp (Op->Common.AmlOpcode,
+                                        Op->Common.Aml);
                     if (!ReplacementOp)
                     {
                         Status = AE_NO_MEMORY;
@@ -246,7 +251,8 @@ AcpiPsCompleteThisOp (
 
         default:
 
-            ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP);
+            ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP,
+                                Op->Common.Aml);
             if (!ReplacementOp)
             {
                 Status = AE_NO_MEMORY;
diff --git a/source/components/parser/psutils.c b/source/components/parser/psutils.c
index 55bf2ccff1b0..ec0d20c8e082 100644
--- a/source/components/parser/psutils.c
+++ b/source/components/parser/psutils.c
@@ -64,12 +64,12 @@
 
 ACPI_PARSE_OBJECT *
 AcpiPsCreateScopeOp (
-    void)
+    UINT8                   *Aml)
 {
     ACPI_PARSE_OBJECT       *ScopeOp;
 
 
-    ScopeOp = AcpiPsAllocOp (AML_SCOPE_OP);
+    ScopeOp = AcpiPsAllocOp (AML_SCOPE_OP, Aml);
     if (!ScopeOp)
     {
         return (NULL);
@@ -115,6 +115,7 @@ AcpiPsInitOp (
  * FUNCTION:    AcpiPsAllocOp
  *
  * PARAMETERS:  Opcode          - Opcode that will be stored in the new Op
+ *              Aml             - Address of the opcode
  *
  * RETURN:      Pointer to the new Op, null on failure
  *
@@ -126,7 +127,8 @@ AcpiPsInitOp (
 
 ACPI_PARSE_OBJECT*
 AcpiPsAllocOp (
-    UINT16                  Opcode)
+    UINT16                  Opcode,
+    UINT8                   *Aml)
 {
     ACPI_PARSE_OBJECT       *Op;
     const ACPI_OPCODE_INFO  *OpInfo;
@@ -173,6 +175,7 @@ AcpiPsAllocOp (
     if (Op)
     {
         AcpiPsInitOp (Op, Opcode);
+        Op->Common.Aml = Aml;
         Op->Common.Flags = Flags;
     }
 
diff --git a/source/components/parser/psxface.c b/source/components/parser/psxface.c
index 85eea33bb9be..ae072b7dce7b 100644
--- a/source/components/parser/psxface.c
+++ b/source/components/parser/psxface.c
@@ -47,6 +47,7 @@
 #include "acdispat.h"
 #include "acinterp.h"
 #include "actables.h"
+#include "acnamesp.h"
 
 
 #define _COMPONENT          ACPI_PARSER
@@ -55,14 +56,6 @@
 /* Local Prototypes */
 
 static void
-AcpiPsStartTrace (
-    ACPI_EVALUATE_INFO      *Info);
-
-static void
-AcpiPsStopTrace (
-    ACPI_EVALUATE_INFO      *Info);
-
-static void
 AcpiPsUpdateParameterList (
     ACPI_EVALUATE_INFO      *Info,
     UINT16                  Action);
@@ -86,7 +79,7 @@ AcpiPsUpdateParameterList (
 
 ACPI_STATUS
 AcpiDebugTrace (
-    char                    *Name,
+    const char              *Name,
     UINT32                  DebugLevel,
     UINT32                  DebugLayer,
     UINT32                  Flags)
@@ -100,128 +93,14 @@ AcpiDebugTrace (
         return (Status);
     }
 
-    /* TBDs: Validate name, allow full path or just nameseg */
-
-    AcpiGbl_TraceMethodName = *ACPI_CAST_PTR (UINT32, Name);
+    AcpiGbl_TraceMethodName = Name;
     AcpiGbl_TraceFlags = Flags;
-
-    if (DebugLevel)
-    {
-        AcpiGbl_TraceDbgLevel = DebugLevel;
-    }
-    if (DebugLayer)
-    {
-        AcpiGbl_TraceDbgLayer = DebugLayer;
-    }
+    AcpiGbl_TraceDbgLevel = DebugLevel;
+    AcpiGbl_TraceDbgLayer = DebugLayer;
+    Status = AE_OK;
 
     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
-    return (AE_OK);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiPsStartTrace
- *
- * PARAMETERS:  Info        - Method info struct
- *
- * RETURN:      None
- *
- * DESCRIPTION: Start control method execution trace
- *
- ******************************************************************************/
-
-static void
-AcpiPsStartTrace (
-    ACPI_EVALUATE_INFO      *Info)
-{
-    ACPI_STATUS             Status;
-
-
-    ACPI_FUNCTION_ENTRY ();
-
-
-    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
-    if (ACPI_FAILURE (Status))
-    {
-        return;
-    }
-
-    if ((!AcpiGbl_TraceMethodName) ||
-        (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
-    {
-        goto Exit;
-    }
-
-    AcpiGbl_OriginalDbgLevel = AcpiDbgLevel;
-    AcpiGbl_OriginalDbgLayer = AcpiDbgLayer;
-
-    AcpiDbgLevel = 0x00FFFFFF;
-    AcpiDbgLayer = ACPI_UINT32_MAX;
-
-    if (AcpiGbl_TraceDbgLevel)
-    {
-        AcpiDbgLevel = AcpiGbl_TraceDbgLevel;
-    }
-    if (AcpiGbl_TraceDbgLayer)
-    {
-        AcpiDbgLayer = AcpiGbl_TraceDbgLayer;
-    }
-
-
-Exit:
-    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiPsStopTrace
- *
- * PARAMETERS:  Info        - Method info struct
- *
- * RETURN:      None
- *
- * DESCRIPTION: Stop control method execution trace
- *
- ******************************************************************************/
-
-static void
-AcpiPsStopTrace (
-    ACPI_EVALUATE_INFO      *Info)
-{
-    ACPI_STATUS             Status;
-
-
-    ACPI_FUNCTION_ENTRY ();
-
-
-    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
-    if (ACPI_FAILURE (Status))
-    {
-        return;
-    }
-
-    if ((!AcpiGbl_TraceMethodName) ||
-        (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
-    {
-        goto Exit;
-    }
-
-    /* Disable further tracing if type is one-shot */
-
-    if (AcpiGbl_TraceFlags & 1)
-    {
-        AcpiGbl_TraceMethodName = 0;
-        AcpiGbl_TraceDbgLevel = 0;
-        AcpiGbl_TraceDbgLayer = 0;
-    }
-
-    AcpiDbgLevel = AcpiGbl_OriginalDbgLevel;
-    AcpiDbgLayer = AcpiGbl_OriginalDbgLayer;
-
-Exit:
-    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
+    return (Status);
 }
 
 
@@ -284,10 +163,6 @@ AcpiPsExecuteMethod (
      */
     AcpiPsUpdateParameterList (Info, REF_INCREMENT);
 
-    /* Begin tracing if requested */
-
-    AcpiPsStartTrace (Info);
-
     /*
      * Execute the method. Performs parse simultaneously
      */
@@ -297,7 +172,7 @@ AcpiPsExecuteMethod (
 
     /* Create and init a Root Node */
 
-    Op = AcpiPsCreateScopeOp ();
+    Op = AcpiPsCreateScopeOp (Info->ObjDesc->Method.AmlStart);
     if (!Op)
     {
         Status = AE_NO_MEMORY;
@@ -370,10 +245,6 @@ AcpiPsExecuteMethod (
 Cleanup:
     AcpiPsDeleteParseTree (Op);
 
-    /* End optional tracing */
-
-    AcpiPsStopTrace (Info);
-
     /* Take away the extra reference that we gave the parameters above */
 
     AcpiPsUpdateParameterList (Info, REF_DECREMENT);
diff --git a/source/components/resources/rscreate.c b/source/components/resources/rscreate.c
index 551f59a6534c..926d79b768c8 100644
--- a/source/components/resources/rscreate.c
+++ b/source/components/resources/rscreate.c
@@ -370,7 +370,8 @@ AcpiRsCreatePciRoutingTable (
                                     (UINT8 *) OutputBuffer->Pointer);
                 PathBuffer.Pointer = UserPrt->Source;
 
-                Status = AcpiNsHandleToPathname ((ACPI_HANDLE) Node, &PathBuffer);
+                Status = AcpiNsHandleToPathname ((ACPI_HANDLE) Node,
+                            &PathBuffer, FALSE);
 
                 /* +1 to include null terminator */
 
diff --git a/source/components/utilities/utclib.c b/source/components/utilities/utclib.c
index a93ed867a4d8..76956d69f374 100644
--- a/source/components/utilities/utclib.c
+++ b/source/components/utilities/utclib.c
@@ -93,9 +93,6 @@
 
 #ifndef ACPI_USE_SYSTEM_CLIBRARY    /* Entire module */
 
-#define NEGATIVE    1
-#define POSITIVE    0
-
 
 /*******************************************************************************
  *
@@ -584,17 +581,17 @@ strtoul (
      */
     if (*String == '-')
     {
-        sign = NEGATIVE;
+        sign = ACPI_SIGN_NEGATIVE;
         ++String;
     }
     else if (*String == '+')
     {
         ++String;
-        sign = POSITIVE;
+        sign = ACPI_SIGN_POSITIVE;
     }
     else
     {
-        sign = POSITIVE;
+        sign = ACPI_SIGN_POSITIVE;
     }
 
     /*
@@ -717,7 +714,7 @@ done:
     /*
      * If a minus sign was present, then "the conversion is negated":
      */
-    if (sign == NEGATIVE)
+    if (sign == ACPI_SIGN_NEGATIVE)
     {
         ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
     }
diff --git a/source/components/utilities/utdebug.c b/source/components/utilities/utdebug.c
index 2aefacbd6a99..d88692a2d41c 100644
--- a/source/components/utilities/utdebug.c
+++ b/source/components/utilities/utdebug.c
@@ -45,6 +45,7 @@
 
 #include "acpi.h"
 #include "accommon.h"
+#include "acinterp.h"
 
 #define _COMPONENT          ACPI_UTILITIES
         ACPI_MODULE_NAME    ("utdebug")
@@ -634,6 +635,42 @@ AcpiUtPtrExit (
     }
 }
 
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTracePoint
+ *
+ * PARAMETERS:  Type                - Trace event type
+ *              Begin               - TRUE if before execution
+ *              Aml                 - Executed AML address
+ *              Pathname            - Object path
+ *              Pointer             - Pointer to the related object
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Interpreter execution trace.
+ *
+ ******************************************************************************/
+
+void
+AcpiTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname)
+{
+
+    ACPI_FUNCTION_ENTRY ();
+
+    AcpiExTracePoint (Type, Begin, Aml, Pathname);
+
+#ifdef ACPI_USE_SYSTEM_TRACER
+    AcpiOsTracePoint (Type, Begin, Aml, Pathname);
+#endif
+}
+
+ACPI_EXPORT_SYMBOL (AcpiTracePoint)
+
 #endif
 
 
diff --git a/source/components/utilities/utdelete.c b/source/components/utilities/utdelete.c
index 264b45de8e5d..17ccacb6e2a2 100644
--- a/source/components/utilities/utdelete.c
+++ b/source/components/utilities/utdelete.c
@@ -220,6 +220,10 @@ AcpiUtDeleteInternalObj (
             AcpiUtDeleteObjectDesc (Object->Method.Mutex);
             Object->Method.Mutex = NULL;
         }
+        if (Object->Method.Node)
+        {
+            Object->Method.Node = NULL;
+        }
         break;
 
     case ACPI_TYPE_REGION:
diff --git a/source/components/utilities/utinit.c b/source/components/utilities/utinit.c
index d69599d4d1c0..5ac47bec03cf 100644
--- a/source/components/utilities/utinit.c
+++ b/source/components/utilities/utinit.c
@@ -224,8 +224,6 @@ AcpiUtInitGlobals (
     AcpiGbl_AcpiHardwarePresent         = TRUE;
     AcpiGbl_LastOwnerIdIndex            = 0;
     AcpiGbl_NextOwnerIdOffset           = 0;
-    AcpiGbl_TraceDbgLevel               = 0;
-    AcpiGbl_TraceDbgLayer               = 0;
     AcpiGbl_DebuggerConfiguration       = DEBUGGER_THREADING;
     AcpiGbl_OsiMutex                    = NULL;
     AcpiGbl_RegMethodsExecuted          = FALSE;
diff --git a/source/components/utilities/utmisc.c b/source/components/utilities/utmisc.c
index 8ac133a2c21a..a171aef2ec70 100644
--- a/source/components/utilities/utmisc.c
+++ b/source/components/utilities/utmisc.c
@@ -418,7 +418,7 @@ AcpiUtDisplayInitPathname (
     /* Get the full pathname to the node */
 
     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
-    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
+    Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, FALSE);
     if (ACPI_FAILURE (Status))
     {
         return;
diff --git a/source/components/utilities/utnonansi.c b/source/components/utilities/utnonansi.c
new file mode 100644
index 000000000000..3c64eaa1f5f1
--- /dev/null
+++ b/source/components/utilities/utnonansi.c
@@ -0,0 +1,453 @@
+/*******************************************************************************
+ *
+ * Module Name: utnonansi - Non-ansi C library functions
+ *
+ ******************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, Intel Corp.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ */
+
+#include "acpi.h"
+#include "accommon.h"
+
+
+#define _COMPONENT          ACPI_UTILITIES
+        ACPI_MODULE_NAME    ("utnonansi")
+
+
+/*
+ * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit
+ * version of strtoul.
+ */
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStrlwr (strlwr)
+ *
+ * PARAMETERS:  SrcString       - The source string to convert
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Convert a string to lowercase
+ *
+ ******************************************************************************/
+
+void
+AcpiUtStrlwr (
+    char                    *SrcString)
+{
+    char                    *String;
+
+
+    ACPI_FUNCTION_ENTRY ();
+
+
+    if (!SrcString)
+    {
+        return;
+    }
+
+    /* Walk entire string, lowercasing the letters */
+
+    for (String = SrcString; *String; String++)
+    {
+        *String = (char) tolower ((int) *String);
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStrupr (strupr)
+ *
+ * PARAMETERS:  SrcString       - The source string to convert
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Convert a string to uppercase
+ *
+ ******************************************************************************/
+
+void
+AcpiUtStrupr (
+    char                    *SrcString)
+{
+    char                    *String;
+
+
+    ACPI_FUNCTION_ENTRY ();
+
+
+    if (!SrcString)
+    {
+        return;
+    }
+
+    /* Walk entire string, uppercasing the letters */
+
+    for (String = SrcString; *String; String++)
+    {
+        *String = (char) toupper ((int) *String);
+    }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStricmp (stricmp)
+ *
+ * PARAMETERS:  String1             - first string to compare
+ *              String2             - second string to compare
+ *
+ * RETURN:      int that signifies string relationship. Zero means strings
+ *              are equal.
+ *
+ * DESCRIPTION: Case-insensitive string compare. Implementation of the
+ *              non-ANSI stricmp function.
+ *
+ ******************************************************************************/
+
+int
+AcpiUtStricmp (
+    char                    *String1,
+    char                    *String2)
+{
+    int                     c1;
+    int                     c2;
+
+
+    do
+    {
+        c1 = tolower ((int) *String1);
+        c2 = tolower ((int) *String2);
+
+        String1++;
+        String2++;
+    }
+    while ((c1 == c2) && (c1));
+
+    return (c1 - c2);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtStrtoul64
+ *
+ * PARAMETERS:  String          - Null terminated string
+ *              Base            - Radix of the string: 16 or ACPI_ANY_BASE;
+ *                                ACPI_ANY_BASE means 'in behalf of ToInteger'
+ *              RetInteger      - Where the converted integer is returned
+ *
+ * RETURN:      Status and Converted value
+ *
+ * DESCRIPTION: Convert a string into an unsigned value. Performs either a
+ *              32-bit or 64-bit conversion, depending on the current mode
+ *              of the interpreter.
+ *
+ * NOTE:        Does not support Octal strings, not needed.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiUtStrtoul64 (
+    char                    *String,
+    UINT32                  Base,
+    UINT64                  *RetInteger)
+{
+    UINT32                  ThisDigit = 0;
+    UINT64                  ReturnValue = 0;
+    UINT64                  Quotient;
+    UINT64                  Dividend;
+    UINT32                  ToIntegerOp = (Base == ACPI_ANY_BASE);
+    UINT32                  Mode32 = (AcpiGbl_IntegerByteWidth == 4);
+    UINT8                   ValidDigits = 0;
+    UINT8                   SignOf0x = 0;
+    UINT8                   Term = 0;
+
+
+    ACPI_FUNCTION_TRACE_STR (UtStroul64, String);
+
+
+    switch (Base)
+    {
+    case ACPI_ANY_BASE:
+    case 16:
+
+        break;
+
+    default:
+
+        /* Invalid Base */
+
+        return_ACPI_STATUS (AE_BAD_PARAMETER);
+    }
+
+    if (!String)
+    {
+        goto ErrorExit;
+    }
+
+    /* Skip over any white space in the buffer */
+
+    while ((*String) && (isspace ((int) *String) || *String == '\t'))
+    {
+        String++;
+    }
+
+    if (ToIntegerOp)
+    {
+        /*
+         * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'.
+         * We need to determine if it is decimal or hexadecimal.
+         */
+        if ((*String == '0') && (tolower ((int) *(String + 1)) == 'x'))
+        {
+            SignOf0x = 1;
+            Base = 16;
+
+            /* Skip over the leading '0x' */
+            String += 2;
+        }
+        else
+        {
+            Base = 10;
+        }
+    }
+
+    /* Any string left? Check that '0x' is not followed by white space. */
+
+    if (!(*String) || isspace ((int) *String) || *String == '\t')
+    {
+        if (ToIntegerOp)
+        {
+            goto ErrorExit;
+        }
+        else
+        {
+            goto AllDone;
+        }
+    }
+
+    /*
+     * Perform a 32-bit or 64-bit conversion, depending upon the current
+     * execution mode of the interpreter
+     */
+    Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;
+
+    /* Main loop: convert the string to a 32- or 64-bit integer */
+
+    while (*String)
+    {
+        if (isdigit ((int) *String))
+        {
+            /* Convert ASCII 0-9 to Decimal value */
+
+            ThisDigit = ((UINT8) *String) - '0';
+        }
+        else if (Base == 10)
+        {
+            /* Digit is out of range; possible in ToInteger case only */
+
+            Term = 1;
+        }
+        else
+        {
+            ThisDigit = (UINT8) toupper ((int) *String);
+            if (isxdigit ((int) ThisDigit))
+            {
+                /* Convert ASCII Hex char to value */
+
+                ThisDigit = ThisDigit - 'A' + 10;
+            }
+            else
+            {
+                Term = 1;
+            }
+        }
+
+        if (Term)
+        {
+            if (ToIntegerOp)
+            {
+                goto ErrorExit;
+            }
+            else
+            {
+                break;
+            }
+        }
+        else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x)
+        {
+            /* Skip zeros */
+            String++;
+            continue;
+        }
+
+        ValidDigits++;
+
+        if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32)))
+        {
+            /*
+             * This is ToInteger operation case.
+             * No any restrictions for string-to-integer conversion,
+             * see ACPI spec.
+             */
+            goto ErrorExit;
+        }
+
+        /* Divide the digit into the correct position */
+
+        (void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit),
+                    Base, &Quotient, NULL);
+
+        if (ReturnValue > Quotient)
+        {
+            if (ToIntegerOp)
+            {
+                goto ErrorExit;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        ReturnValue *= Base;
+        ReturnValue += ThisDigit;
+        String++;
+    }
+
+    /* All done, normal exit */
+
+AllDone:
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
+        ACPI_FORMAT_UINT64 (ReturnValue)));
+
+    *RetInteger = ReturnValue;
+    return_ACPI_STATUS (AE_OK);
+
+
+ErrorExit:
+    /* Base was set/validated above */
+
+    if (Base == 10)
+    {
+        return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
+    }
+    else
+    {
+        return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
+    }
+}
+
+
+#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiUtSafeStrcpy, AcpiUtSafeStrcat, AcpiUtSafeStrncat
+ *
+ * PARAMETERS:  Adds a "DestSize" parameter to each of the standard string
+ *              functions. This is the size of the Destination buffer.
+ *
+ * RETURN:      TRUE if the operation would overflow the destination buffer.
+ *
+ * DESCRIPTION: Safe versions of standard Clib string functions. Ensure that
+ *              the result of the operation will not overflow the output string
+ *              buffer.
+ *
+ * NOTE:        These functions are typically only helpful for processing
+ *              user input and command lines. For most ACPICA code, the
+ *              required buffer length is precisely calculated before buffer
+ *              allocation, so the use of these functions is unnecessary.
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AcpiUtSafeStrcpy (
+    char                    *Dest,
+    ACPI_SIZE               DestSize,
+    char                    *Source)
+{
+
+    if (strlen (Source) >= DestSize)
+    {
+        return (TRUE);
+    }
+
+    strcpy (Dest, Source);
+    return (FALSE);
+}
+
+BOOLEAN
+AcpiUtSafeStrcat (
+    char                    *Dest,
+    ACPI_SIZE               DestSize,
+    char                    *Source)
+{
+
+    if ((strlen (Dest) + strlen (Source)) >= DestSize)
+    {
+        return (TRUE);
+    }
+
+    strcat (Dest, Source);
+    return (FALSE);
+}
+
+BOOLEAN
+AcpiUtSafeStrncat (
+    char                    *Dest,
+    ACPI_SIZE               DestSize,
+    char                    *Source,
+    ACPI_SIZE               MaxTransferLength)
+{
+    ACPI_SIZE               ActualTransferLength;
+
+
+    ActualTransferLength = ACPI_MIN (MaxTransferLength, strlen (Source));
+
+    if ((strlen (Dest) + ActualTransferLength) >= DestSize)
+    {
+        return (TRUE);
+    }
+
+    strncat (Dest, Source, MaxTransferLength);
+    return (FALSE);
+}
+#endif
diff --git a/source/components/utilities/utstring.c b/source/components/utilities/utstring.c
index 33060f063fec..af7b4af761da 100644
--- a/source/components/utilities/utstring.c
+++ b/source/components/utilities/utstring.c
@@ -50,343 +50,6 @@
         ACPI_MODULE_NAME    ("utstring")
 
 
-/*
- * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit
- * version of strtoul.
- */
-
-#ifdef ACPI_ASL_COMPILER
-/*******************************************************************************
- *
- * FUNCTION:    AcpiUtStrlwr (strlwr)
- *
- * PARAMETERS:  SrcString       - The source string to convert
- *
- * RETURN:      None
- *
- * DESCRIPTION: Convert string to lowercase
- *
- * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
- *
- ******************************************************************************/
-
-void
-AcpiUtStrlwr (
-    char                    *SrcString)
-{
-    char                    *String;
-
-
-    ACPI_FUNCTION_ENTRY ();
-
-
-    if (!SrcString)
-    {
-        return;
-    }
-
-    /* Walk entire string, lowercasing the letters */
-
-    for (String = SrcString; *String; String++)
-    {
-        *String = (char) tolower ((int) *String);
-    }
-
-    return;
-}
-
-
-/******************************************************************************
- *
- * FUNCTION:    AcpiUtStricmp (stricmp)
- *
- * PARAMETERS:  String1             - first string to compare
- *              String2             - second string to compare
- *
- * RETURN:      int that signifies string relationship. Zero means strings
- *              are equal.
- *
- * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare
- *              strings with no case sensitivity)
- *
- ******************************************************************************/
-
-int
-AcpiUtStricmp (
-    char                    *String1,
-    char                    *String2)
-{
-    int                     c1;
-    int                     c2;
-
-
-    do
-    {
-        c1 = tolower ((int) *String1);
-        c2 = tolower ((int) *String2);
-
-        String1++;
-        String2++;
-    }
-    while ((c1 == c2) && (c1));
-
-    return (c1 - c2);
-}
-#endif
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiUtStrupr (strupr)
- *
- * PARAMETERS:  SrcString       - The source string to convert
- *
- * RETURN:      None
- *
- * DESCRIPTION: Convert string to uppercase
- *
- * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
- *
- ******************************************************************************/
-
-void
-AcpiUtStrupr (
-    char                    *SrcString)
-{
-    char                    *String;
-
-
-    ACPI_FUNCTION_ENTRY ();
-
-
-    if (!SrcString)
-    {
-        return;
-    }
-
-    /* Walk entire string, uppercasing the letters */
-
-    for (String = SrcString; *String; String++)
-    {
-        *String = (char) toupper ((int) *String);
-    }
-
-    return;
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiUtStrtoul64
- *
- * PARAMETERS:  String          - Null terminated string
- *              Base            - Radix of the string: 16 or ACPI_ANY_BASE;
- *                                ACPI_ANY_BASE means 'in behalf of ToInteger'
- *              RetInteger      - Where the converted integer is returned
- *
- * RETURN:      Status and Converted value
- *
- * DESCRIPTION: Convert a string into an unsigned value. Performs either a
- *              32-bit or 64-bit conversion, depending on the current mode
- *              of the interpreter.
- *              NOTE: Does not support Octal strings, not needed.
- *
- ******************************************************************************/
-
-ACPI_STATUS
-AcpiUtStrtoul64 (
-    char                    *String,
-    UINT32                  Base,
-    UINT64                  *RetInteger)
-{
-    UINT32                  ThisDigit = 0;
-    UINT64                  ReturnValue = 0;
-    UINT64                  Quotient;
-    UINT64                  Dividend;
-    UINT32                  ToIntegerOp = (Base == ACPI_ANY_BASE);
-    UINT32                  Mode32 = (AcpiGbl_IntegerByteWidth == 4);
-    UINT8                   ValidDigits = 0;
-    UINT8                   SignOf0x = 0;
-    UINT8                   Term = 0;
-
-
-    ACPI_FUNCTION_TRACE_STR (UtStroul64, String);
-
-
-    switch (Base)
-    {
-    case ACPI_ANY_BASE:
-    case 16:
-
-        break;
-
-    default:
-
-        /* Invalid Base */
-
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
-    }
-
-    if (!String)
-    {
-        goto ErrorExit;
-    }
-
-    /* Skip over any white space in the buffer */
-
-    while ((*String) && (isspace ((int) *String) || *String == '\t'))
-    {
-        String++;
-    }
-
-    if (ToIntegerOp)
-    {
-        /*
-         * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'.
-         * We need to determine if it is decimal or hexadecimal.
-         */
-        if ((*String == '0') && (tolower ((int) *(String + 1)) == 'x'))
-        {
-            SignOf0x = 1;
-            Base = 16;
-
-            /* Skip over the leading '0x' */
-            String += 2;
-        }
-        else
-        {
-            Base = 10;
-        }
-    }
-
-    /* Any string left? Check that '0x' is not followed by white space. */
-
-    if (!(*String) || isspace ((int) *String) || *String == '\t')
-    {
-        if (ToIntegerOp)
-        {
-            goto ErrorExit;
-        }
-        else
-        {
-            goto AllDone;
-        }
-    }
-
-    /*
-     * Perform a 32-bit or 64-bit conversion, depending upon the current
-     * execution mode of the interpreter
-     */
-    Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;
-
-    /* Main loop: convert the string to a 32- or 64-bit integer */
-
-    while (*String)
-    {
-        if (isdigit ((int) *String))
-        {
-            /* Convert ASCII 0-9 to Decimal value */
-
-            ThisDigit = ((UINT8) *String) - '0';
-        }
-        else if (Base == 10)
-        {
-            /* Digit is out of range; possible in ToInteger case only */
-
-            Term = 1;
-        }
-        else
-        {
-            ThisDigit = (UINT8) toupper ((int) *String);
-            if (isxdigit ((int) ThisDigit))
-            {
-                /* Convert ASCII Hex char to value */
-
-                ThisDigit = ThisDigit - 'A' + 10;
-            }
-            else
-            {
-                Term = 1;
-            }
-        }
-
-        if (Term)
-        {
-            if (ToIntegerOp)
-            {
-                goto ErrorExit;
-            }
-            else
-            {
-                break;
-            }
-        }
-        else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x)
-        {
-            /* Skip zeros */
-            String++;
-            continue;
-        }
-
-        ValidDigits++;
-
-        if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32)))
-        {
-            /*
-             * This is ToInteger operation case.
-             * No any restrictions for string-to-integer conversion,
-             * see ACPI spec.
-             */
-            goto ErrorExit;
-        }
-
-        /* Divide the digit into the correct position */
-
-        (void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit),
-                    Base, &Quotient, NULL);
-
-        if (ReturnValue > Quotient)
-        {
-            if (ToIntegerOp)
-            {
-                goto ErrorExit;
-            }
-            else
-            {
-                break;
-            }
-        }
-
-        ReturnValue *= Base;
-        ReturnValue += ThisDigit;
-        String++;
-    }
-
-    /* All done, normal exit */
-
-AllDone:
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
-        ACPI_FORMAT_UINT64 (ReturnValue)));
-
-    *RetInteger = ReturnValue;
-    return_ACPI_STATUS (AE_OK);
-
-
-ErrorExit:
-    /* Base was set/validated above */
-
-    if (Base == 10)
-    {
-        return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
-    }
-    else
-    {
-        return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
-    }
-}
-
-
 /*******************************************************************************
  *
  * FUNCTION:    AcpiUtPrintString
@@ -682,78 +345,3 @@ UtConvertBackslashes (
     }
 }
 #endif
-
-#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
-/*******************************************************************************
- *
- * FUNCTION:    AcpiUtSafeStrcpy, AcpiUtSafeStrcat, AcpiUtSafeStrncat
- *
- * PARAMETERS:  Adds a "DestSize" parameter to each of the standard string
- *              functions. This is the size of the Destination buffer.
- *
- * RETURN:      TRUE if the operation would overflow the destination buffer.
- *
- * DESCRIPTION: Safe versions of standard Clib string functions. Ensure that
- *              the result of the operation will not overflow the output string
- *              buffer.
- *
- * NOTE:        These functions are typically only helpful for processing
- *              user input and command lines. For most ACPICA code, the
- *              required buffer length is precisely calculated before buffer
- *              allocation, so the use of these functions is unnecessary.
- *
- ******************************************************************************/
-
-BOOLEAN
-AcpiUtSafeStrcpy (
-    char                    *Dest,
-    ACPI_SIZE               DestSize,
-    char                    *Source)
-{
-
-    if (strlen (Source) >= DestSize)
-    {
-        return (TRUE);
-    }
-
-    strcpy (Dest, Source);
-    return (FALSE);
-}
-
-BOOLEAN
-AcpiUtSafeStrcat (
-    char                    *Dest,
-    ACPI_SIZE               DestSize,
-    char                    *Source)
-{
-
-    if ((strlen (Dest) + strlen (Source)) >= DestSize)
-    {
-        return (TRUE);
-    }
-
-    strcat (Dest, Source);
-    return (FALSE);
-}
-
-BOOLEAN
-AcpiUtSafeStrncat (
-    char                    *Dest,
-    ACPI_SIZE               DestSize,
-    char                    *Source,
-    ACPI_SIZE               MaxTransferLength)
-{
-    ACPI_SIZE               ActualTransferLength;
-
-
-    ActualTransferLength = ACPI_MIN (MaxTransferLength, strlen (Source));
-
-    if ((strlen (Dest) + ActualTransferLength) >= DestSize)
-    {
-        return (TRUE);
-    }
-
-    strncat (Dest, Source, MaxTransferLength);
-    return (FALSE);
-}
-#endif
diff --git a/source/include/acdebug.h b/source/include/acdebug.h
index 11cf02ee6433..8b6ac8956ad4 100644
--- a/source/include/acdebug.h
+++ b/source/include/acdebug.h
@@ -137,6 +137,12 @@ AcpiDbSleep (
     char                    *ObjectArg);
 
 void
+AcpiDbTrace (
+    char                    *EnableArg,
+    char                    *MethodArg,
+    char                    *OnceArg);
+
+void
 AcpiDbDisplayLocks (
     void);
 
@@ -425,6 +431,32 @@ AcpiDbGetNextToken (
 
 
 /*
+ * dbobject
+ */
+void
+AcpiDbDecodeInternalObject (
+    ACPI_OPERAND_OBJECT     *ObjDesc);
+
+void
+AcpiDbDisplayInternalObject (
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiDbDecodeArguments (
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiDbDecodeLocals (
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiDbDumpMethodInfo (
+    ACPI_STATUS             Status,
+    ACPI_WALK_STATE         *WalkState);
+
+
+/*
  * dbstats - Generation and display of ACPI table statistics
  */
 void
diff --git a/source/include/acdisasm.h b/source/include/acdisasm.h
index 966ec93fde38..180f8e64ddf0 100644
--- a/source/include/acdisasm.h
+++ b/source/include/acdisasm.h
@@ -399,7 +399,9 @@ extern ACPI_DMTABLE_INFO        AcpiDmTableInfoSrat2[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoSrat3[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoStao[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoStaoStr[];
-extern ACPI_DMTABLE_INFO        AcpiDmTableInfoTcpa[];
+extern ACPI_DMTABLE_INFO        AcpiDmTableInfoTcpaHdr[];
+extern ACPI_DMTABLE_INFO        AcpiDmTableInfoTcpaClient[];
+extern ACPI_DMTABLE_INFO        AcpiDmTableInfoTcpaServer[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoTpm2[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoUefi[];
 extern ACPI_DMTABLE_INFO        AcpiDmTableInfoVrtc[];
@@ -595,6 +597,10 @@ AcpiDmDumpStao (
     ACPI_TABLE_HEADER       *Table);
 
 void
+AcpiDmDumpTcpa (
+    ACPI_TABLE_HEADER       *Table);
+
+void
 AcpiDmDumpVrtc (
     ACPI_TABLE_HEADER       *Table);
 
@@ -637,10 +643,6 @@ AcpiDmDisassembleOneOp (
     ACPI_OP_WALK_INFO       *Info,
     ACPI_PARSE_OBJECT       *Op);
 
-void
-AcpiDmDecodeInternalObject (
-    ACPI_OPERAND_OBJECT     *ObjDesc);
-
 UINT32
 AcpiDmListType (
     ACPI_PARSE_OBJECT       *Op);
@@ -700,29 +702,6 @@ AcpiDmNamestring (
 
 
 /*
- * dmobject
- */
-void
-AcpiDmDisplayInternalObject (
-    ACPI_OPERAND_OBJECT     *ObjDesc,
-    ACPI_WALK_STATE         *WalkState);
-
-void
-AcpiDmDisplayArguments (
-    ACPI_WALK_STATE         *WalkState);
-
-void
-AcpiDmDisplayLocals (
-    ACPI_WALK_STATE         *WalkState);
-
-void
-AcpiDmDumpMethodInfo (
-    ACPI_STATUS             Status,
-    ACPI_WALK_STATE         *WalkState,
-    ACPI_PARSE_OBJECT       *Op);
-
-
-/*
  * dmbuffer
  */
 void
diff --git a/source/include/acdispat.h b/source/include/acdispat.h
index 9364fe398444..0a1b1ac4f64c 100644
--- a/source/include/acdispat.h
+++ b/source/include/acdispat.h
@@ -461,4 +461,14 @@ AcpiDsResultPush (
     ACPI_OPERAND_OBJECT     *Object,
     ACPI_WALK_STATE         *WalkState);
 
+
+/*
+ * dsdebug - parser debugging routines
+ */
+void
+AcpiDsDumpMethodStack (
+    ACPI_STATUS             Status,
+    ACPI_WALK_STATE         *WalkState,
+    ACPI_PARSE_OBJECT       *Op);
+
 #endif /* _ACDISPAT_H_ */
diff --git a/source/include/acglobal.h b/source/include/acglobal.h
index 9e7da94ccf3a..eaa364d4e45c 100644
--- a/source/include/acglobal.h
+++ b/source/include/acglobal.h
@@ -293,8 +293,6 @@ ACPI_GLOBAL (UINT32,                    AcpiFixedEventCount[ACPI_NUM_FIXED_EVENT
 
 ACPI_GLOBAL (UINT32,                    AcpiGbl_OriginalDbgLevel);
 ACPI_GLOBAL (UINT32,                    AcpiGbl_OriginalDbgLayer);
-ACPI_GLOBAL (UINT32,                    AcpiGbl_TraceDbgLevel);
-ACPI_GLOBAL (UINT32,                    AcpiGbl_TraceDbgLayer);
 
 
 /*****************************************************************************
@@ -313,6 +311,7 @@ ACPI_INIT_GLOBAL (UINT8,                AcpiGbl_NoResourceDisassembly, FALSE);
 ACPI_INIT_GLOBAL (BOOLEAN,              AcpiGbl_IgnoreNoopOperator, FALSE);
 ACPI_INIT_GLOBAL (BOOLEAN,              AcpiGbl_CstyleDisassembly, TRUE);
 ACPI_INIT_GLOBAL (BOOLEAN,              AcpiGbl_ForceAmlDisassembly, FALSE);
+ACPI_INIT_GLOBAL (ACPI_PARSE_OBJECT *,  AcpiGbl_PreviousOp, NULL);
 
 ACPI_GLOBAL (BOOLEAN,                   AcpiGbl_DbOpt_Disasm);
 ACPI_GLOBAL (BOOLEAN,                   AcpiGbl_DbOpt_Verbose);
diff --git a/source/include/acinterp.h b/source/include/acinterp.h
index 00eb8f0d2545..f53e6c58f849 100644
--- a/source/include/acinterp.h
+++ b/source/include/acinterp.h
@@ -143,6 +143,35 @@ AcpiExDoDebugObject (
     UINT32                  Level,
     UINT32                  Index);
 
+void
+AcpiExStartTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiExStopTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiExStartTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiExStopTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState);
+
+void
+AcpiExTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname);
+
 
 /*
  * exfield - ACPI AML (p-code) execution - field manipulation
diff --git a/source/include/aclocal.h b/source/include/aclocal.h
index dc1afffde35a..7f62cc8d1c09 100644
--- a/source/include/aclocal.h
+++ b/source/include/aclocal.h
@@ -193,8 +193,12 @@ typedef struct acpi_namespace_node
      */
 #ifdef ACPI_LARGE_NAMESPACE_NODE
     union acpi_parse_object         *Op;
+    void                            *MethodLocals;
+    void                            *MethodArgs;
     UINT32                          Value;
     UINT32                          Length;
+    UINT8                           ArgCount;
+
 #endif
 
 } ACPI_NAMESPACE_NODE;
@@ -864,7 +868,7 @@ typedef union acpi_parse_value
 } ACPI_PARSE_VALUE;
 
 
-#ifdef ACPI_DISASSEMBLER
+#if defined(ACPI_DISASSEMBLER) || defined(ACPI_DEBUG_OUTPUT)
 #define ACPI_DISASM_ONLY_MEMBERS(a)     a;
 #else
 #define ACPI_DISASM_ONLY_MEMBERS(a)
@@ -875,7 +879,7 @@ typedef union acpi_parse_value
     UINT8                           DescriptorType; /* To differentiate various internal objs */\
     UINT8                           Flags;          /* Type of Op */\
     UINT16                          AmlOpcode;      /* AML opcode */\
-    UINT32                          AmlOffset;      /* Offset of declaration in AML */\
+    UINT8                           *Aml;           /* Address of declaration in AML */\
     union acpi_parse_object         *Next;          /* Next op */\
     ACPI_NAMESPACE_NODE             *Node;          /* For use by interpreter */\
     ACPI_PARSE_VALUE                Value;          /* Value or args associated with the opcode */\
@@ -1291,7 +1295,9 @@ typedef struct acpi_db_method_info
      *   Index of current thread inside all them created.
      */
     char                            InitArgs;
+#ifdef ACPI_DEBUGGER
     ACPI_OBJECT_TYPE                ArgTypes[4];
+#endif
     char                            *Arguments[4];
     char                            NumThreadsStr[11];
     char                            IdOfThreadStr[11];
diff --git a/source/include/acmacros.h b/source/include/acmacros.h
index 35d53f660780..48620fb470a6 100644
--- a/source/include/acmacros.h
+++ b/source/include/acmacros.h
@@ -223,6 +223,16 @@
 #define ACPI_MUL_32(a)                  _ACPI_MUL(a, 5)
 #define ACPI_MOD_32(a)                  _ACPI_MOD(a, 32)
 
+/* Test for ASCII character */
+
+#define ACPI_IS_ASCII(c)                ((c) < 0x80)
+
+/* Signed integers */
+
+#define ACPI_SIGN_POSITIVE              0
+#define ACPI_SIGN_NEGATIVE              1
+
+
 /*
  * Rounding macros (Power of two boundaries only)
  */
diff --git a/source/include/acnamesp.h b/source/include/acnamesp.h
index 786fd293688f..bea4ebf0ad7c 100644
--- a/source/include/acnamesp.h
+++ b/source/include/acnamesp.h
@@ -350,16 +350,22 @@ UINT32
 AcpiNsOpensScope (
     ACPI_OBJECT_TYPE        Type);
 
-ACPI_STATUS
-AcpiNsBuildExternalPath (
-    ACPI_NAMESPACE_NODE     *Node,
-    ACPI_SIZE               Size,
-    char                    *NameBuffer);
-
 char *
 AcpiNsGetExternalPathname (
     ACPI_NAMESPACE_NODE     *Node);
 
+UINT32
+AcpiNsBuildNormalizedPath (
+    ACPI_NAMESPACE_NODE     *Node,
+    char                    *FullPath,
+    UINT32                  PathSize,
+    BOOLEAN                 NoTrailing);
+
+char *
+AcpiNsGetNormalizedPathname (
+    ACPI_NAMESPACE_NODE     *Node,
+    BOOLEAN                 NoTrailing);
+
 char *
 AcpiNsNameOfCurrentScope (
     ACPI_WALK_STATE         *WalkState);
@@ -367,7 +373,8 @@ AcpiNsNameOfCurrentScope (
 ACPI_STATUS
 AcpiNsHandleToPathname (
     ACPI_HANDLE             TargetHandle,
-    ACPI_BUFFER             *Buffer);
+    ACPI_BUFFER             *Buffer,
+    BOOLEAN                 NoTrailing);
 
 BOOLEAN
 AcpiNsPatternMatch (
diff --git a/source/include/acobject.h b/source/include/acobject.h
index 481eb449bbd3..adeb41403412 100644
--- a/source/include/acobject.h
+++ b/source/include/acobject.h
@@ -213,6 +213,7 @@ typedef struct acpi_object_method
     UINT8                           ParamCount;
     UINT8                           SyncLevel;
     union acpi_operand_object       *Mutex;
+    union acpi_operand_object       *Node;
     UINT8                           *AmlStart;
     union
     {
diff --git a/source/include/acoutput.h b/source/include/acoutput.h
index 0ef98eb4494d..197f28b068d8 100644
--- a/source/include/acoutput.h
+++ b/source/include/acoutput.h
@@ -89,7 +89,8 @@
 #define ACPI_LV_DEBUG_OBJECT        0x00000002
 #define ACPI_LV_INFO                0x00000004
 #define ACPI_LV_REPAIR              0x00000008
-#define ACPI_LV_ALL_EXCEPTIONS      0x0000000F
+#define ACPI_LV_TRACE_POINT         0x00000010
+#define ACPI_LV_ALL_EXCEPTIONS      0x0000001F
 
 /* Trace verbosity level 1 [Standard Trace Level] */
 
@@ -149,6 +150,7 @@
 #define ACPI_DB_DEBUG_OBJECT        ACPI_DEBUG_LEVEL (ACPI_LV_DEBUG_OBJECT)
 #define ACPI_DB_INFO                ACPI_DEBUG_LEVEL (ACPI_LV_INFO)
 #define ACPI_DB_REPAIR              ACPI_DEBUG_LEVEL (ACPI_LV_REPAIR)
+#define ACPI_DB_TRACE_POINT         ACPI_DEBUG_LEVEL (ACPI_LV_TRACE_POINT)
 #define ACPI_DB_ALL_EXCEPTIONS      ACPI_DEBUG_LEVEL (ACPI_LV_ALL_EXCEPTIONS)
 
 /* Trace level -- also used in the global "DebugLevel" */
@@ -185,6 +187,21 @@
 #define ACPI_DEBUG_ALL              (ACPI_LV_AML_DISASSEMBLE | ACPI_LV_ALL_EXCEPTIONS | ACPI_LV_ALL)
 
 
+/*
+ * Global trace flags
+ */
+#define ACPI_TRACE_ENABLED          ((UINT32) 4)
+#define ACPI_TRACE_ONESHOT          ((UINT32) 2)
+#define ACPI_TRACE_OPCODE           ((UINT32) 1)
+
+/* Defaults for trace debugging level/layer */
+
+#define ACPI_TRACE_LEVEL_ALL        ACPI_LV_ALL
+#define ACPI_TRACE_LAYER_ALL        0x000001FF
+#define ACPI_TRACE_LEVEL_DEFAULT    ACPI_LV_TRACE_POINT
+#define ACPI_TRACE_LAYER_DEFAULT    ACPI_EXECUTER
+
+
 #if defined (ACPI_DEBUG_OUTPUT) || !defined (ACPI_NO_ERROR_MESSAGES)
 /*
  * The module name is used primarily for error and debug messages.
@@ -439,6 +456,8 @@
 #define ACPI_DUMP_PATHNAME(a, b, c, d)  AcpiNsDumpPathname(a, b, c, d)
 #define ACPI_DUMP_BUFFER(a, b)          AcpiUtDebugDumpBuffer((UINT8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT)
 
+#define ACPI_TRACE_POINT(a, b, c, d)    AcpiTracePoint (a, b, c, d)
+
 #else /* ACPI_DEBUG_OUTPUT */
 /*
  * This is the non-debug case -- make everything go away,
@@ -460,6 +479,7 @@
 #define ACPI_DUMP_PATHNAME(a, b, c, d)
 #define ACPI_DUMP_BUFFER(a, b)
 #define ACPI_IS_DEBUG_ENABLED(Level, Component) 0
+#define ACPI_TRACE_POINT(a, b, c, d)
 
 /* Return macros must have a return statement at the minimum */
 
diff --git a/source/include/acparser.h b/source/include/acparser.h
index a3c766610415..a89c5c4c4635 100644
--- a/source/include/acparser.h
+++ b/source/include/acparser.h
@@ -306,7 +306,7 @@ AcpiPsDeleteParseTree (
  */
 ACPI_PARSE_OBJECT *
 AcpiPsCreateScopeOp (
-    void);
+    UINT8                   *Aml);
 
 void
 AcpiPsInitOp (
@@ -315,7 +315,8 @@ AcpiPsInitOp (
 
 ACPI_PARSE_OBJECT *
 AcpiPsAllocOp (
-    UINT16                  opcode);
+    UINT16                  Opcode,
+    UINT8                   *Aml);
 
 void
 AcpiPsFreeOp (
diff --git a/source/include/acpiosxf.h b/source/include/acpiosxf.h
index 6062fdaf5b24..f894abefb10f 100644
--- a/source/include/acpiosxf.h
+++ b/source/include/acpiosxf.h
@@ -599,5 +599,14 @@ AcpiOsSetFileOffset (
     UINT8                   From);
 #endif
 
+#ifndef ACPI_USE_ALTERNATE_PROTOTYPE_AcpiOsTracePoint
+void
+AcpiOsTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname);
+#endif
+
 
 #endif /* __ACPIOSXF_H__ */
diff --git a/source/include/acpixf.h b/source/include/acpixf.h
index 9177fbdbb19f..7eb0cb7b3fd1 100644
--- a/source/include/acpixf.h
+++ b/source/include/acpixf.h
@@ -46,7 +46,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20150619
+#define ACPI_CA_VERSION                 0x20150717
 
 #include "acconfig.h"
 #include "actypes.h"
@@ -253,7 +253,9 @@ ACPI_INIT_GLOBAL (BOOLEAN,          AcpiGbl_ReducedHardware, FALSE);
  * traced each time it is executed.
  */
 ACPI_INIT_GLOBAL (UINT32,           AcpiGbl_TraceFlags, 0);
-ACPI_INIT_GLOBAL (ACPI_NAME,        AcpiGbl_TraceMethodName, 0);
+ACPI_INIT_GLOBAL (const char *,     AcpiGbl_TraceMethodName, NULL);
+ACPI_INIT_GLOBAL (UINT32,           AcpiGbl_TraceDbgLevel, ACPI_TRACE_LEVEL_DEFAULT);
+ACPI_INIT_GLOBAL (UINT32,           AcpiGbl_TraceDbgLayer, ACPI_TRACE_LAYER_DEFAULT);
 
 /*
  * Runtime configuration of debug output control masks. We want the debug
@@ -610,7 +612,7 @@ AcpiGetData (
 ACPI_EXTERNAL_RETURN_STATUS (
 ACPI_STATUS
 AcpiDebugTrace (
-    char                    *Name,
+    const char              *Name,
     UINT32                  DebugLevel,
     UINT32                  DebugLayer,
     UINT32                  Flags))
@@ -1191,6 +1193,14 @@ AcpiDebugPrintRaw (
     const char              *Format,
     ...))
 
+ACPI_DBG_DEPENDENT_RETURN_VOID (
+void
+AcpiTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname))
+
 ACPI_APP_DEPENDENT_RETURN_VOID (
 ACPI_PRINTF_LIKE(1)
 void ACPI_INTERNAL_VAR_XFACE
diff --git a/source/include/acstruct.h b/source/include/acstruct.h
index 3a6faa6bf06b..10dc371ed9ac 100644
--- a/source/include/acstruct.h
+++ b/source/include/acstruct.h
@@ -88,7 +88,7 @@ typedef struct acpi_walk_state
     BOOLEAN                         NamespaceOverride;  /* Override existing objects */
     UINT8                           ResultSize;         /* Total elements for the result stack */
     UINT8                           ResultCount;        /* Current number of occupied elements of result stack */
-    UINT32                          AmlOffset;
+    UINT8                           *Aml;
     UINT32                          ArgTypes;
     UINT32                          MethodBreakpoint;   /* For single stepping */
     UINT32                          UserBreakpoint;     /* User AML breakpoint */
diff --git a/source/include/actbl2.h b/source/include/actbl2.h
index 02a3cb0dceff..86b59bf7b951 100644
--- a/source/include/actbl2.h
+++ b/source/include/actbl2.h
@@ -1375,14 +1375,28 @@ enum AcpiSpmiInterfaceTypes
  * December 19, 2014
  *
  * NOTE: There are two versions of the table with the same signature --
- * the client version and the server version.
+ * the client version and the server version. The common PlatformClass
+ * field is used to differentiate the two types of tables.
  *
  ******************************************************************************/
 
-typedef struct acpi_table_tcpa_client
+typedef struct acpi_table_tcpa_hdr
 {
     ACPI_TABLE_HEADER       Header;             /* Common ACPI table header */
     UINT16                  PlatformClass;
+
+} ACPI_TABLE_TCPA_HDR;
+
+/*
+ * Values for PlatformClass above.
+ * This is how the client and server subtables are differentiated
+ */
+#define ACPI_TCPA_CLIENT_TABLE          0
+#define ACPI_TCPA_SERVER_TABLE          1
+
+
+typedef struct acpi_table_tcpa_client
+{
     UINT32                  MinimumLogLength;   /* Minimum length for the event log area */
     UINT64                  LogAddress;         /* Address of the event log area */
 
@@ -1390,8 +1404,6 @@ typedef struct acpi_table_tcpa_client
 
 typedef struct acpi_table_tcpa_server
 {
-    ACPI_TABLE_HEADER       Header;             /* Common ACPI table header */
-    UINT16                  PlatformClass;
     UINT16                  Reserved;
     UINT64                  MinimumLogLength;   /* Minimum length for the event log area */
     UINT64                  LogAddress;         /* Address of the event log area */
diff --git a/source/include/actypes.h b/source/include/actypes.h
index 837c784d6da2..dbc8e3a7c95b 100644
--- a/source/include/actypes.h
+++ b/source/include/actypes.h
@@ -1022,7 +1022,8 @@ typedef struct acpi_buffer
  */
 #define ACPI_FULL_PATHNAME              0
 #define ACPI_SINGLE_NAME                1
-#define ACPI_NAME_TYPE_MAX              1
+#define ACPI_FULL_PATHNAME_NO_TRAILING  2
+#define ACPI_NAME_TYPE_MAX              2
 
 
 /*
@@ -1345,6 +1346,17 @@ typedef struct acpi_memory_list
 } ACPI_MEMORY_LIST;
 
 
+/* Definitions of trace event types */
+
+typedef enum
+{
+    ACPI_TRACE_AML_METHOD,
+    ACPI_TRACE_AML_OPCODE,
+    ACPI_TRACE_AML_REGION
+
+} ACPI_TRACE_EVENT_TYPE;
+
+
 /* Definitions of _OSI support */
 
 #define ACPI_VENDOR_STRINGS                 0x01
diff --git a/source/include/acutils.h b/source/include/acutils.h
index 94f8591214c3..9a05b381d1ec 100644
--- a/source/include/acutils.h
+++ b/source/include/acutils.h
@@ -173,6 +173,30 @@ typedef struct acpi_pkg_info
 #define DB_DWORD_DISPLAY    4
 #define DB_QWORD_DISPLAY    8
 
+
+/*
+ * utnonansi - Non-ANSI C library functions
+ */
+void
+AcpiUtStrupr (
+    char                    *SrcString);
+
+void
+AcpiUtStrlwr (
+    char                    *SrcString);
+
+int
+AcpiUtStricmp (
+    char                    *String1,
+    char                    *String2);
+
+ACPI_STATUS
+AcpiUtStrtoul64 (
+    char                    *String,
+    UINT32                  Base,
+    UINT64                  *RetInteger);
+
+
 /*
  * utglobal - Global data structures and procedures
  */
@@ -246,8 +270,6 @@ AcpiUtSubsystemShutdown (
     void);
 
 
-#define ACPI_IS_ASCII(c)  ((c) < 0x80)
-
 /*
  * utcopy - Object construction and conversion interfaces
  */
@@ -407,6 +429,7 @@ AcpiUtReportWarning (
     char                    *ModuleName,
     UINT32                  LineNumber);
 
+
 /*
  * utdelete - Object deletion and reference counts
  */
@@ -732,11 +755,11 @@ AcpiUtWalkPackageTree (
     ACPI_PKG_CALLBACK       WalkCallback,
     void                    *Context);
 
-
 /* Values for Base above (16=Hex, 10=Decimal) */
 
 #define ACPI_ANY_BASE        0
 
+
 UINT32
 AcpiUtDwordByteSwap (
     UINT32                  Value);
@@ -809,27 +832,6 @@ AcpiUtGetResourceEndTag (
  * utstring - String and character utilities
  */
 void
-AcpiUtStrupr (
-    char                    *SrcString);
-
-#ifdef ACPI_ASL_COMPILER
-void
-AcpiUtStrlwr (
-    char                    *SrcString);
-
-int
-AcpiUtStricmp (
-    char                    *String1,
-    char                    *String2);
-#endif
-
-ACPI_STATUS
-AcpiUtStrtoul64 (
-    char                    *String,
-    UINT32                  Base,
-    UINT64                  *RetInteger);
-
-void
 AcpiUtPrintString (
     char                    *String,
     UINT16                  MaxLength);
@@ -954,6 +956,7 @@ AcpiUtCreateList (
 
 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */
 
+
 /*
  * utaddress - address range check
  */
@@ -980,6 +983,7 @@ void
 AcpiUtDeleteAddressLists (
     void);
 
+
 /*
  * utxferror - various error/warning output functions
  */
@@ -1026,6 +1030,7 @@ AcpiUtMethodError (
     const char              *Path,
     ACPI_STATUS             LookupStatus);
 
+
 /*
  * Utility functions for ACPI names and IDs
  */
@@ -1041,6 +1046,7 @@ const char *
 AcpiAhMatchUuid (
     UINT8                   *Data);
 
+
 /*
  * utprint - printf/vprintf output functions
  */
@@ -1082,6 +1088,7 @@ AcpiUtFilePrintf (
     ...);
 #endif
 
+
 /*
  * utuuid -- UUID support functions
  */
diff --git a/source/include/platform/acenvex.h b/source/include/platform/acenvex.h
index c799fd8adbbe..12fec1279bf4 100644
--- a/source/include/platform/acenvex.h
+++ b/source/include/platform/acenvex.h
@@ -56,6 +56,9 @@
 #if defined(_LINUX) || defined(__linux__)
 #include "aclinuxex.h"
 
+#elif defined(WIN32)
+#include "acwinex.h"
+
 #elif defined(_AED_EFI)
 #include "acefiex.h"
 
diff --git a/source/include/platform/acmsvc.h b/source/include/platform/acmsvc.h
index da9df8905354..c507170b7c72 100644
--- a/source/include/platform/acmsvc.h
+++ b/source/include/platform/acmsvc.h
@@ -57,7 +57,6 @@
 #define stat            _stat
 #define fstat           _fstat
 #define mkdir           _mkdir
-#define strlwr          _strlwr
 #define O_RDONLY        _O_RDONLY
 #define O_BINARY        _O_BINARY
 #define O_CREAT         _O_CREAT
@@ -148,12 +147,9 @@
 #endif
 
 
-/* Debug support. Must be last in this file, do not move. */
+/* Debug support. */
 
 #ifdef _DEBUG
-#define _CRTDBG_MAP_ALLOC /* Enables specific file/lineno for leaks */
-
-#include <crtdbg.h>
 
 /*
  * Debugging memory corruption issues with windows:
diff --git a/source/include/platform/acmsvcex.h b/source/include/platform/acmsvcex.h
new file mode 100644
index 000000000000..bc42e6a20b82
--- /dev/null
+++ b/source/include/platform/acmsvcex.h
@@ -0,0 +1,54 @@
+/******************************************************************************
+ *
+ * Name: acmsvcex.h - Extra VC specific defines, etc.
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, Intel Corp.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ */
+
+#ifndef __ACMSVCEX_H__
+#define __ACMSVCEX_H__
+
+/* Debug support. */
+
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC /* Enables specific file/lineno for leaks */
+#include <crtdbg.h>
+#endif
+
+#endif /* __ACMSVCEX_H__ */
diff --git a/source/include/platform/acwinex.h b/source/include/platform/acwinex.h
new file mode 100644
index 000000000000..5bc85d54463d
--- /dev/null
+++ b/source/include/platform/acwinex.h
@@ -0,0 +1,52 @@
+/******************************************************************************
+ *
+ * Name: acwinex.h - Extra OS specific defines, etc.
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, Intel Corp.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ */
+
+#ifndef __ACWINEX_H__
+#define __ACWINEX_H__
+
+/* Windows uses VC */
+#ifdef _MSC_VER
+#include "acmsvcex.h"
+#endif
+
+#endif /* __ACWINEX_H__ */
diff --git a/source/tools/acpiexec/aetables.c b/source/tools/acpiexec/aetables.c
index 14452db5eda8..ebb6aeb0e8d6 100644
--- a/source/tools/acpiexec/aetables.c
+++ b/source/tools/acpiexec/aetables.c
@@ -329,6 +329,8 @@ AeBuildLocalTables (
      * 2) A "hardware reduced" local FADT
      * 3) A fully featured local FADT
      */
+    memset (&LocalFADT, 0, sizeof (ACPI_TABLE_FADT));
+
     if (ExternalFadt)
     {
         /*
@@ -361,7 +363,7 @@ AeBuildLocalTables (
     }
     else if (AcpiGbl_UseHwReducedFadt)
     {
-        memcpy (&LocalFADT, HwReducedFadtCode, sizeof (ACPI_TABLE_FADT));
+        memcpy (&LocalFADT, HwReducedFadtCode, ACPI_FADT_V5_SIZE);
         LocalFADT.Dsdt = (UINT32) DsdtAddress;
         LocalFADT.XDsdt = DsdtAddress;
 
@@ -374,7 +376,6 @@ AeBuildLocalTables (
         /*
          * Build a local FADT so we can test the hardware/event init
          */
-        memset (&LocalFADT, 0, sizeof (ACPI_TABLE_FADT));
         LocalFADT.Header.Revision = 5;
         AeInitializeTableHeader ((void *) &LocalFADT, ACPI_SIG_FADT, sizeof (ACPI_TABLE_FADT));
 
diff --git a/source/tools/acpihelp/acpihelp.h b/source/tools/acpihelp/acpihelp.h
index e1b061dde611..251cd9de0b06 100644
--- a/source/tools/acpihelp/acpihelp.h
+++ b/source/tools/acpihelp/acpihelp.h
@@ -115,7 +115,7 @@ typedef struct ah_asl_keyword
 typedef struct ah_directive_info
 {
     char            *Name;
-    char            *Operands;
+    char            *Description;
 
 } AH_DIRECTIVE_INFO;
 
@@ -128,10 +128,6 @@ extern const AH_TABLE               AcpiSupportedTables[];
 extern BOOLEAN                      AhDisplayAll;
 
 void
-AhStrupr (
-    char                    *SrcString);
-
-void
 AhFindAmlOpcode (
     char                    *Name);
 
diff --git a/source/tools/acpihelp/ahaslkey.c b/source/tools/acpihelp/ahaslkey.c
index e15d47cd62c6..30318736332d 100644
--- a/source/tools/acpihelp/ahaslkey.c
+++ b/source/tools/acpihelp/ahaslkey.c
@@ -153,26 +153,40 @@ const AH_ASL_KEYWORD        AslKeywordInfo[] =
 
 const AH_DIRECTIVE_INFO      PreprocessorDirectives[] =
 {
-    {"#define",         "OriginalName, DefinedName"},
-    {"#elif",           "Expression"},
-    {"#else",           ""},
-    {"#endif",          ""},
-    {"#error",          "Message"},
-    {"#if",             "Expression"},
-    {"#ifdef",          "DefinedName"},
-    {"#ifndef",         "DefinedName"},
-    {"#include",        "\"Filename\""},
-    {"#include",        "<Filename>"},
-    {"#includebuffer",  "\"Filename\""},
-    {"#includebuffer",  "<Filename>"},
-    {"#line",           ""},
-    {"#pragma",         "Disable error-number"},
-    {"#pragma",         "Message"},
-    {"#undef",          "DefinedName"},
-    {"#warning",        ""},
-    {"__DATE__",        "Returns current date"},
-    {"__FILE__",        "Returns name of current ASL file"},
-    {"__LINE__",        "Returns line number in ASL file"},
-    {"__PATH__",        "Returns full pathname of current ASL file"},
-    {NULL,              0}
+    {"#include \"Filename\"",               "Standard include of an ASCII ASL source code file"},
+    {"#include <Filename>",                 "Alternate syntax for #include, alternate search path"},
+    {"#includebuffer \"Filename\" <Name>",  "Include a binary file to create AML Buffer with ASL namepath"},
+    {"#includebuffer <Filename> <Name>",    "Alternate syntax for #includebuffer, alternate search path"},
+
+    {"",  ""},
+    {"#define <Name>, <Defined name>",      "Simple macro definition (full macros not supported at this time)"},
+    {"#define <Expression>, <Defined name>","Simple macro definition (full macros not supported at this time)"},
+    {"#undef <Defined name>",               "Delete a previous #define"},
+
+    {"",  ""},
+    {"#if <Expression>",                    "Evaluate <Expression> and test return value"},
+    {"#ifdef <Defined name>",               "Test existence of the <Defined Name>"},
+    {"#ifndef <Defined name>",              "Test non-existence of the <Defined Name>"},
+    {"#elif <Expression>",                  "Else-If contraction - evaluate #if <Expression>, test return value"},
+    {"#else",                               "Execute alternate case for a previous #if, #ifdef or #ifndef block"},
+    {"#endif",                              "Close a previous #if, #ifdef or #ifndef block"},
+
+    {"",   ""},
+    {"#line <LineNumber> [Filename]",       "Set the current ASL source code line number, optional filename"},
+
+    {"",   ""},
+    {"#error \"String\"",                   "Emit error message and abort compilation"},
+    {"#warning \"String\"",                 "Emit an iASL warning at this location in the ASL source"},
+
+    {"",  ""},
+    {"#pragma disable (Error number)",      "Disable an iASL error or warning number"},
+    {"#pragma message \"String\"",          "Emit an informational message to the output file(s)"},
+
+    {"",  ""},
+    {"__FILE__",                            "Return the simple filename of the current ASL file"},
+    {"__PATH__",                            "Return the full pathname of the current ASL file"},
+    {"__LINE__",                            "Return the current line number within the current ASL file"},
+    {"__DATE__",                            "Return the current date"},
+    {"__IASL__",                            "Permanently defined for the iASL compiler"},
+    {NULL,                                   NULL}
 };
diff --git a/source/tools/acpihelp/ahdecode.c b/source/tools/acpihelp/ahdecode.c
index 95ea29ebf1c0..7e6d7c8b7427 100644
--- a/source/tools/acpihelp/ahdecode.c
+++ b/source/tools/acpihelp/ahdecode.c
@@ -100,6 +100,18 @@ AhPrintOneField (
     const char              *Field);
 
 
+/*******************************************************************************
+ *
+ * FUNCTION:    AhDisplayDirectives
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Display all iASL preprocessor directives.
+ *
+ ******************************************************************************/
+
 void
 AhDisplayDirectives (
     void)
@@ -107,11 +119,11 @@ AhDisplayDirectives (
     const AH_DIRECTIVE_INFO *Info;
 
 
-    printf ("iASL Preprocessor directives:\n\n");
+    printf ("iASL Preprocessor Directives\n\n");
 
     for (Info = PreprocessorDirectives; Info->Name; Info++)
     {
-        printf ("%16s : %s\n", Info->Name, Info->Operands);
+        printf ("  %-36s : %s\n", Info->Name, Info->Description);
     }
 }
 
@@ -148,7 +160,7 @@ AhFindPredefinedNames (
 
     /* Contruct a local name or name prefix */
 
-    AhStrupr (NamePrefix);
+    AcpiUtStrupr (NamePrefix);
     if (*NamePrefix == '_')
     {
         NamePrefix++;
@@ -333,7 +345,7 @@ AhFindAmlOpcode (
     BOOLEAN                 Found = FALSE;
 
 
-    AhStrupr (Name);
+    AcpiUtStrupr (Name);
 
     /* Find/display all opcode names that match the input name prefix */
 
@@ -354,7 +366,7 @@ AhFindAmlOpcode (
         /* Upper case the opcode name before substring compare */
 
         strcpy (Gbl_Buffer, Op->OpcodeName);
-        AhStrupr (Gbl_Buffer);
+        AcpiUtStrupr (Gbl_Buffer);
 
         if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
         {
@@ -511,7 +523,7 @@ AhFindAslKeywords (
     BOOLEAN                 Found = FALSE;
 
 
-    AhStrupr (Name);
+    AcpiUtStrupr (Name);
 
     for (Keyword = AslKeywordInfo; Keyword->Name; Keyword++)
     {
@@ -525,7 +537,7 @@ AhFindAslKeywords (
         /* Upper case the operator name before substring compare */
 
         strcpy (Gbl_Buffer, Keyword->Name);
-        AhStrupr (Gbl_Buffer);
+        AcpiUtStrupr (Gbl_Buffer);
 
         if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
         {
@@ -626,7 +638,7 @@ AhFindAslOperators (
     BOOLEAN                 MatchCount = 0;
 
 
-    AhStrupr (Name);
+    AcpiUtStrupr (Name);
 
     /* Find/display all names that match the input name prefix */
 
@@ -642,7 +654,7 @@ AhFindAslOperators (
         /* Upper case the operator name before substring compare */
 
         strcpy (Gbl_Buffer, Operator->Name);
-        AhStrupr (Gbl_Buffer);
+        AcpiUtStrupr (Gbl_Buffer);
 
         if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
         {
@@ -866,7 +878,7 @@ AhDisplayDeviceIds (
 
     /* Find/display all names that match the input name prefix */
 
-    AhStrupr (Name);
+    AcpiUtStrupr (Name);
     for (Info = AslDeviceIds; Info->Name; Info++)
     {
         Matched = TRUE;
diff --git a/source/tools/acpihelp/ahmain.c b/source/tools/acpihelp/ahmain.c
index 0416eec74e3e..5ce37086d9f8 100644
--- a/source/tools/acpihelp/ahmain.c
+++ b/source/tools/acpihelp/ahmain.c
@@ -278,40 +278,3 @@ main (
 
     return (0);
 }
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AhStrupr (strupr)
- *
- * PARAMETERS:  SrcString           - The source string to convert
- *
- * RETURN:      None
- *
- * DESCRIPTION: Convert string to uppercase
- *
- * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
- *
- ******************************************************************************/
-
-void
-AhStrupr (
-    char                    *SrcString)
-{
-    char                    *String;
-
-
-    if (!SrcString)
-    {
-        return;
-    }
-
-    /* Walk entire string, uppercasing the letters */
-
-    for (String = SrcString; *String; String++)
-    {
-        *String = (char) toupper ((int) *String);
-    }
-
-    return;
-}
diff --git a/source/tools/acpinames/anstubs.c b/source/tools/acpinames/anstubs.c
index 7d2fdcc0aebd..f8b1d2d6ae82 100644
--- a/source/tools/acpinames/anstubs.c
+++ b/source/tools/acpinames/anstubs.c
@@ -164,6 +164,60 @@ AcpiNsExecModuleCodeList (
 {
 }
 
+void
+AcpiExDoDebugObject (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    UINT32                  Level,
+    UINT32                  Index)
+{
+    return;
+}
+
+void
+AcpiExStartTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStopTraceMethod (
+    ACPI_NAMESPACE_NODE     *MethodNode,
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStartTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+{
+    return;
+}
+
+void
+AcpiExStopTraceOpcode (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_WALK_STATE         *WalkState)
+
+{
+    return;
+}
+
+void
+AcpiExTracePoint (
+    ACPI_TRACE_EVENT_TYPE   Type,
+    BOOLEAN                 Begin,
+    UINT8                   *Aml,
+    char                    *Pathname)
+{
+    return;
+}
+
 
 /* Dispatcher */
 
diff --git a/source/tools/acpisrc/acpisrc.h b/source/tools/acpisrc/acpisrc.h
index d5dc9f81d31e..17acac3a352d 100644
--- a/source/tools/acpisrc/acpisrc.h
+++ b/source/tools/acpisrc/acpisrc.h
@@ -426,7 +426,3 @@ AsInsertCarriageReturns (
 void
 AsConvertToLineFeeds (
     char                    *Buffer);
-
-void
-AsStrlwr (
-    char                    *SrcString);
diff --git a/source/tools/acpisrc/asconvrt.c b/source/tools/acpisrc/asconvrt.c
index 5b0f5f461596..5a82167c13af 100644
--- a/source/tools/acpisrc/asconvrt.c
+++ b/source/tools/acpisrc/asconvrt.c
@@ -1487,7 +1487,7 @@ AsInsertPrefix (
     }
 
     strcpy (LowerKeyword, Keyword);
-    AsStrlwr (LowerKeyword);
+    AcpiUtStrlwr (LowerKeyword);
 
     SubBuffer = Buffer;
     SubString = Buffer;
diff --git a/source/tools/acpisrc/asfile.c b/source/tools/acpisrc/asfile.c
index 1e686cff1a71..cd1843057085 100644
--- a/source/tools/acpisrc/asfile.c
+++ b/source/tools/acpisrc/asfile.c
@@ -180,7 +180,7 @@ AsProcessTree (
     {
         if (ConversionTable->Flags & FLG_LOWERCASE_DIRNAMES)
         {
-            AsStrlwr (TargetPath);
+            AcpiUtStrlwr (TargetPath);
         }
 
         VERBOSE_PRINT (("Creating Directory \"%s\"\n", TargetPath));
diff --git a/source/tools/acpisrc/asmain.c b/source/tools/acpisrc/asmain.c
index 95f8beed129d..4da3cdd5c5a3 100644
--- a/source/tools/acpisrc/asmain.c
+++ b/source/tools/acpisrc/asmain.c
@@ -47,11 +47,6 @@
 /* Local prototypes */
 
 int
-AsStricmp (
-    char                    *String1,
-    char                    *String2);
-
-int
 AsExaminePaths (
     ACPI_CONVERSION_TABLE   *ConversionTable,
     char                    *Source,
@@ -104,38 +99,6 @@ BOOLEAN                 Gbl_IgnoreTranslationEscapes = FALSE;
 
 /******************************************************************************
  *
- * FUNCTION:    AsStricmp
- *
- * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare
- *              strings with no case sensitivity)
- *
- ******************************************************************************/
-
-int
-AsStricmp (
-    char                    *String1,
-    char                    *String2)
-{
-    int                     c1;
-    int                     c2;
-
-
-    do
-    {
-        c1 = tolower ((int) *String1);
-        c2 = tolower ((int) *String2);
-
-        String1++;
-        String2++;
-    }
-    while ((c1 == c2) && (c1));
-
-    return (c1 - c2);
-}
-
-
-/******************************************************************************
- *
  * FUNCTION:    AsExaminePaths
  *
  * DESCRIPTION: Source and Target pathname verification and handling
@@ -177,7 +140,7 @@ AsExaminePaths (
         return (0);
     }
 
-    if (!AsStricmp (Source, Target))
+    if (!AcpiUtStricmp (Source, Target))
     {
         printf ("Target path is the same as the source path, overwrite?\n");
         Response = getchar ();
diff --git a/source/tools/acpisrc/astable.c b/source/tools/acpisrc/astable.c
index a10681ef0915..6cc27131dda3 100644
--- a/source/tools/acpisrc/astable.c
+++ b/source/tools/acpisrc/astable.c
@@ -264,6 +264,7 @@ ACPI_TYPED_IDENTIFIER_TABLE           AcpiIdentifiers[] = {
     {"ACPI_MEM_SPACE_CONTEXT",              SRC_TYPE_STRUCT},
     {"ACPI_MEMORY_ATTRIBUTE",               SRC_TYPE_STRUCT},
     {"ACPI_MEMORY_LIST",                    SRC_TYPE_STRUCT},
+    {"ACPI_METHOD_LOCAL",                   SRC_TYPE_STRUCT},
     {"ACPI_MTMR_ENTRY",                     SRC_TYPE_STRUCT},
     {"ACPI_MUTEX",                          SRC_TYPE_SIMPLE},
     {"ACPI_MUTEX_HANDLE",                   SRC_TYPE_SIMPLE},
@@ -418,6 +419,7 @@ ACPI_TYPED_IDENTIFIER_TABLE           AcpiIdentifiers[] = {
     {"ACPI_TAG_INFO",                       SRC_TYPE_STRUCT},
     {"ACPI_THREAD_ID",                      SRC_TYPE_SIMPLE},
     {"ACPI_THREAD_STATE",                   SRC_TYPE_STRUCT},
+    {"ACPI_TRACE_EVENT_TYPE",               SRC_TYPE_SIMPLE},
     {"ACPI_TYPED_IDENTIFIER_TABLE",         SRC_TYPE_STRUCT},
     {"ACPI_UINTPTR_T",                      SRC_TYPE_SIMPLE},
     {"ACPI_UPDATE_STATE",                   SRC_TYPE_STRUCT},
@@ -491,6 +493,7 @@ ACPI_TYPED_IDENTIFIER_TABLE           AcpiIdentifiers[] = {
     {"ASL_LISTING_NODE",                    SRC_TYPE_STRUCT},
     {"ASL_MAPPING_ENTRY",                   SRC_TYPE_STRUCT},
     {"ASL_METHOD_INFO",                     SRC_TYPE_STRUCT},
+    {"ASL_METHOD_LOCAL",                    SRC_TYPE_STRUCT},
     {"ASL_RESERVED_INFO",                   SRC_TYPE_STRUCT},
     {"ASL_RESOURCE_INFO",                   SRC_TYPE_STRUCT},
     {"ASL_RESOURCE_NODE",                   SRC_TYPE_STRUCT},
@@ -667,6 +670,8 @@ ACPI_TYPED_IDENTIFIER_TABLE           AcpiIdentifiers[] = {
     {"ACPI_SRAT_MEM_AFFINITY",              SRC_TYPE_STRUCT},
     {"ACPI_SRAT_X2APIC_CPU_AFFINITY",       SRC_TYPE_STRUCT},
     {"ACPI_SRAT_GICC_AFFINITY",             SRC_TYPE_STRUCT},
+    {"ACPI_TABLE_TCPA_CLIENT",              SRC_TYPE_STRUCT},
+    {"ACPI_TABLE_TCPA_SERVER",              SRC_TYPE_STRUCT},
     {"ACPI_TPM2_CONTROL",                   SRC_TYPE_STRUCT},
     {"ACPI_WDAT_ENTRY",                     SRC_TYPE_STRUCT},
 
diff --git a/source/tools/acpisrc/asutils.c b/source/tools/acpisrc/asutils.c
index 31103a09fbda..7621fd692505 100644
--- a/source/tools/acpisrc/asutils.c
+++ b/source/tools/acpisrc/asutils.c
@@ -44,40 +44,6 @@
 #include "acpisrc.h"
 
 
-/*******************************************************************************
- *
- * FUNCTION:    AsStrlwr (strlwr)
- *
- * PARAMETERS:  SrcString       - The source string to convert
- *
- * RETURN:      None
- *
- * DESCRIPTION: Convert string to lowercase
- *
- * NOTE: This is not a POSIX function, so it appears here so that we don't have
- * header file issues with the various hosts/compilers/clibs.
- *
- ******************************************************************************/
-
-void
-AsStrlwr (
-    char                    *SrcString)
-{
-    char                    *String;
-
-
-    /* Walk entire string, lowercasing the letters */
-
-    if (SrcString)
-    {
-        for (String = SrcString; *String; String++)
-        {
-            *String = (char) tolower ((int) *String);
-        }
-    }
-}
-
-
 /******************************************************************************
  *
  * FUNCTION:    AsSkipUntilChar
diff --git a/source/tools/acpixtract/acpixtract.c b/source/tools/acpixtract/acpixtract.c
index d005919f8265..373c9cd95bc7 100644
--- a/source/tools/acpixtract/acpixtract.c
+++ b/source/tools/acpixtract/acpixtract.c
@@ -53,10 +53,6 @@
 /* Local prototypes */
 
 static void
-AxStrlwr (
-    char                    *String);
-
-static void
 AxCheckAscii (
     char                    *Name,
     int                     Count);
@@ -129,31 +125,6 @@ static char                 InstanceBuffer[AX_LINE_BUFFER_SIZE];
 
 /*******************************************************************************
  *
- * FUNCTION:    AxStrlwr
- *
- * PARAMETERS:  String              - Ascii string
- *
- * RETURN:      None
- *
- * DESCRIPTION: String lowercase function.
- *
- ******************************************************************************/
-
-static void
-AxStrlwr (
-    char                    *String)
-{
-
-    while (*String)
-    {
-        *String = (char) tolower ((int) *String);
-        String++;
-    }
-}
-
-
-/*******************************************************************************
- *
  * FUNCTION:    AxCheckAscii
  *
  * PARAMETERS:  Name                - Ascii string, at least as long as Count
@@ -594,7 +565,7 @@ AxExtractTables (
                 sprintf (Filename, "%4.4s.dat", ThisSignature);
             }
 
-            AxStrlwr (Filename);
+            AcpiUtStrlwr (Filename);
             OutputFile = fopen (Filename, "w+b");
             if (!OutputFile)
             {
@@ -695,7 +666,7 @@ AxListTables (
     FILE                    *InputFile;
     size_t                  HeaderSize;
     unsigned char           Header[48];
-    int                     TableCount = 0;
+    unsigned int            TableCount = 0;
     ACPI_TABLE_HEADER       *TableHeader = (ACPI_TABLE_HEADER *) (void *) Header;