acpi_adr_space_type space_id)
 {
        acpi_status status;
+       struct acpi_reg_walk_info info;
 
        ACPI_FUNCTION_TRACE(ev_execute_reg_methods);
 
+       info.space_id = space_id;
+       info.reg_run_count = 0;
+
+       ACPI_DEBUG_PRINT_RAW((ACPI_DB_NAMES,
+                             "    Running _REG methods for SpaceId %s\n",
+                             acpi_ut_get_region_name(info.space_id)));
+
        /*
         * Run all _REG methods for all Operation Regions for this space ID. This
         * is a separate walk in order to handle any interdependencies between
         */
        status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, node, ACPI_UINT32_MAX,
                                        ACPI_NS_WALK_UNLOCK, acpi_ev_reg_run,
-                                       NULL, &space_id, NULL);
+                                       NULL, &info, NULL);
 
        /* Special case for EC: handle "orphan" _REG methods with no region */
 
                acpi_ev_orphan_ec_reg_method(node);
        }
 
+       ACPI_DEBUG_PRINT_RAW((ACPI_DB_NAMES,
+                             "    Executed %u _REG methods for SpaceId %s\n",
+                             info.reg_run_count,
+                             acpi_ut_get_region_name(info.space_id)));
+
        return_ACPI_STATUS(status);
 }
 
 {
        union acpi_operand_object *obj_desc;
        struct acpi_namespace_node *node;
-       acpi_adr_space_type space_id;
        acpi_status status;
+       struct acpi_reg_walk_info *info;
 
-       space_id = *ACPI_CAST_PTR(acpi_adr_space_type, context);
+       info = ACPI_CAST_PTR(struct acpi_reg_walk_info, context);
 
        /* Convert and validate the device handle */
 
 
        /* Object is a Region */
 
-       if (obj_desc->region.space_id != space_id) {
+       if (obj_desc->region.space_id != info->space_id) {
 
                /* This region is for a different address space, just ignore it */
 
                return (AE_OK);
        }
 
+       info->reg_run_count++;
        status = acpi_ev_execute_reg_method(obj_desc, ACPI_REG_CONNECT);
        return (status);
 }
 
 
        status = acpi_ns_evaluate(info);
 
-       ACPI_DEBUG_PRINT((ACPI_DB_INIT, "Executed module-level code at %p\n",
+       ACPI_DEBUG_PRINT((ACPI_DB_INIT_NAMES,
+                         "Executed module-level code at %p\n",
                          method_obj->method.aml_start));
 
        /* Delete a possible implicit return value (in slack mode) */
 
 
        ACPI_FUNCTION_TRACE(ns_terminate);
 
+#ifdef ACPI_EXEC_APP
+       {
+               union acpi_operand_object *prev;
+               union acpi_operand_object *next;
+
+               /* Delete any module-level code blocks */
+
+               next = acpi_gbl_module_code_list;
+               while (next) {
+                       prev = next;
+                       next = next->method.mutex;
+                       prev->method.mutex = NULL;      /* Clear the Mutex (cheated) field */
+                       acpi_ut_remove_reference(prev);
+               }
+       }
+#endif
+
        /*
         * Free the entire namespace -- all nodes and all objects
         * attached to the nodes
 
        union acpi_operand_object *method_obj;
        struct acpi_namespace_node *parent_node;
 
+       ACPI_FUNCTION_TRACE(ps_link_module_code);
+
        /* Get the tail of the list */
 
        prev = next = acpi_gbl_module_code_list;
 
                method_obj = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
                if (!method_obj) {
-                       return;
+                       return_VOID;
                }
 
+               ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
+                                 "Create/Link new code block: %p\n",
+                                 method_obj));
+
                if (parent_op->common.node) {
                        parent_node = parent_op->common.node;
                } else {
                        prev->method.mutex = method_obj;
                }
        } else {
+               ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
+                                 "Appending to existing code block: %p\n",
+                                 prev));
+
                prev->method.aml_length += aml_length;
        }
+
+       return_VOID;
 }
 
 /*******************************************************************************