ACPICA commit 
71299ec8b49054daace0df50268e8e055654ca37
This patch adds trace point at the following point:
 1. Begin/end of a control method execution;
 2. Begin/end of an opcode execution.
The trace point feature can be enabled by defining ACPI_DEBUG_OUTPUT
and specifying a debug level that includes ACPI_LV_TRACDE_POINT and the
debug layers that include ACPI_PARSER and ACPI_DISPACTCHER.
In order to make aml_op_name of union acpi_parse_object usable for tracer, it is
enabled for ACPI_DEBUG_OUTPUT in this patch. Lv Zheng.
Link: https://github.com/acpica/acpica/commit/71299ec8
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 
        union acpi_parse_object *arg;   /* arguments and contained ops */
 };
 
-#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)
 
        struct acpi_thread_state *thread;
        struct acpi_walk_state *next_walk_state;
        struct acpi_namespace_node *previous_method = NULL;
+       union acpi_operand_object *method_desc;
+       char *pathname = NULL;
 
        ACPI_FUNCTION_TRACE(ds_dump_method_stack);
 
        /* Walk list of linked walk states */
 
        while (next_walk_state) {
+               method_desc = next_walk_state->method_desc;
+               if (method_desc && method_desc->method.node) {
+                       pathname = acpi_ns_get_normalized_pathname((struct
+                                                                   acpi_namespace_node
+                                                                   *)
+                                                                  method_desc->
+                                                                  method.node,
+                                                                  TRUE);
+               }
+               if (pathname) {
+                       ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                         "End method [0x%p:%s] execution.\n",
+                                         method_desc->method.aml_start,
+                                         pathname));
+                       ACPI_FREE(pathname);
+                       pathname = NULL;
+               } else {
+                       ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                         "End method [0x%p] execution.\n",
+                                         method_desc->method.aml_start));
+               }
+
                ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
                                  "    Method [%4.4s] executing: ",
                                  acpi_ut_get_node_name(next_walk_state->
 
                               struct acpi_walk_state *walk_state)
 {
        acpi_status status = AE_OK;
+       char *pathname = NULL;
 
        ACPI_FUNCTION_TRACE_PTR(ds_begin_method_execution, method_node);
 
                return_ACPI_STATUS(AE_NULL_ENTRY);
        }
 
+       pathname = acpi_ns_get_normalized_pathname(method_node, TRUE);
+       if (pathname) {
+               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                 "Begin method [0x%p:%s] execution.\n",
+                                 obj_desc->method.aml_start, pathname));
+               ACPI_FREE(pathname);
+       } else {
+               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                 "Begin method [0x%p] execution.\n",
+                                 obj_desc->method.aml_start));
+       }
+
        /* Prevent wraparound of thread count */
 
        if (obj_desc->method.thread_count == ACPI_UINT8_MAX) {
 acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
                                 struct acpi_walk_state *walk_state)
 {
+       char *pathname = NULL;
 
        ACPI_FUNCTION_TRACE_PTR(ds_terminate_control_method, walk_state);
 
                }
        }
 
+       if (method_desc->method.node) {
+               pathname = acpi_ns_get_normalized_pathname((struct
+                                                           acpi_namespace_node
+                                                           *)method_desc->
+                                                          method.node, TRUE);
+       }
+       if (pathname) {
+               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                 "End method [0x%p:%s] execution.\n",
+                                 method_desc->method.aml_start, pathname));
+               ACPI_FREE(pathname);
+       } else {
+               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                 "End method [0x%p] execution.\n",
+                                 method_desc->method.aml_start));
+       }
+
        return_VOID;
 }
 
                                                  walk_state->op_info->name, op,
                                                  op->common.aml));
                        }
+
+                       if (walk_state->op_info) {
+                               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                                 "Begin opcode: %s[0x%p] Class=0x%02x, Type=0x%02x, Flags=0x%04x.\n",
+                                                 op->common.aml_op_name,
+                                                 op->common.aml,
+                                                 walk_state->op_info->class,
+                                                 walk_state->op_info->type,
+                                                 walk_state->op_info->flags));
+                       } else {
+                               ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                                                 "Begin opcode: %s[0x%p].\n",
+                                                 op->common.aml_op_name,
+                                                 op->common.aml));
+                       }
                }
 
                /*
 
                return_ACPI_STATUS(AE_OK);      /* OK for now */
        }
 
+       ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
+                         "End opcode: %s[0x%p].\n",
+                         op->common.aml_op_name, op->common.aml));
+
        /* Delete this op and the subtree below it if asked to */
 
        if (((walk_state->parse_flags & ACPI_PARSE_TREE_MASK) !=
 
 #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] */
 
 #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" */