layers: Rename DebugReport flags

Conflicts:
	layers/mem_tracker.cpp

Conflicts:
	layers/draw_state.cpp

2 files changed, 72 insertions, 72 deletions

diff --git a/loader/debug_report.c b/loader/debug_report.c
index 98fd3b46..5d3a376d 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -225,26 +225,26 @@ static void print_msg_flags(VkFlags msgFlags, char *msg_flags)
     bool separator = false;
 
     msg_flags[0] = 0;
-    if (msgFlags & VK_DBG_REPORT_DEBUG_BIT) {
+    if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT) {
         strcat(msg_flags, "DEBUG");
         separator = true;
     }
-    if (msgFlags & VK_DBG_REPORT_INFO_BIT) {
+    if (msgFlags & VK_DEBUG_REPORT_INFO_BIT) {
         if (separator) strcat(msg_flags, ",");
         strcat(msg_flags, "INFO");
         separator = true;
     }
-    if (msgFlags & VK_DBG_REPORT_WARN_BIT) {
+    if (msgFlags & VK_DEBUG_REPORT_WARN_BIT) {
         if (separator) strcat(msg_flags, ",");
         strcat(msg_flags, "WARN");
         separator = true;
     }
-    if (msgFlags & VK_DBG_REPORT_PERF_WARN_BIT) {
+    if (msgFlags & VK_DEBUG_REPORT_PERF_WARN_BIT) {
         if (separator) strcat(msg_flags, ",");
         strcat(msg_flags, "PERF");
         separator = true;
     }
-    if (msgFlags & VK_DBG_REPORT_ERROR_BIT) {
+    if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT) {
         if (separator) strcat(msg_flags, ",");
         strcat(msg_flags, "ERROR");
     }
diff --git a/loader/loader.c b/loader/loader.c
index 0b0e1306..5673be41 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -291,7 +291,7 @@ static char *loader_get_registry_files(const struct loader_instance *inst, char
                     total_size *= 2;
                 }
                 if (out == NULL) {
-                    loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory, failed loader_get_registry_files");
+                    loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory, failed loader_get_registry_files");
                     return NULL;
                 }
                 if (strlen(out) == 0)
@@ -467,7 +467,7 @@ static struct loader_layer_properties *loader_get_next_layer_property(
                                   sizeof(struct loader_layer_properties) * 64,
                                   VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list");
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list");
             return NULL;
         }
         memset(layer_list->list, 0, sizeof(struct loader_layer_properties) * 64);
@@ -482,7 +482,7 @@ static struct loader_layer_properties *loader_get_next_layer_property(
                                             layer_list->capacity * 2,
                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                             "realloc failed for layer list");
         }
         layer_list->capacity *= 2;
@@ -543,7 +543,7 @@ static void loader_add_global_extensions(
 
     res = fp_get_props(NULL, &count, NULL);
     if (res != VK_SUCCESS) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Error getting global extension count from %s", lib_name);
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Error getting global extension count from %s", lib_name);
         return;
     }
 
@@ -556,7 +556,7 @@ static void loader_add_global_extensions(
 
     res = fp_get_props(NULL, &count, ext_props);
     if (res != VK_SUCCESS) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Error getting global extensions from %s", lib_name);
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Error getting global extensions from %s", lib_name);
         return;
     }
 
@@ -567,7 +567,7 @@ static void loader_add_global_extensions(
                  VK_MAJOR(ext_props[i].specVersion),
                  VK_MINOR(ext_props[i].specVersion),
                  VK_PATCH(ext_props[i].specVersion));
-        loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                    "Global Extension: %s (%s) version %s",
                    ext_props[i].extensionName, lib_name, spec_version);
         loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
@@ -602,7 +602,7 @@ static VkResult loader_init_physical_device_extensions(
                 VK_MAJOR(ext_props[i].specVersion),
                 VK_MINOR(ext_props[i].specVersion),
                 VK_PATCH(ext_props[i].specVersion));
-        loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                 "PhysicalDevice Extension: %s (%s) version %s",
                 ext_props[i].extensionName, phys_dev->this_icd->this_icd_lib->lib_name, spec_version);
         res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
@@ -638,7 +638,7 @@ static VkResult loader_add_physical_device_extensions(
                     VK_MAJOR(ext_props[i].specVersion),
                     VK_MINOR(ext_props[i].specVersion),
                     VK_PATCH(ext_props[i].specVersion));
-            loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                     "PhysicalDevice Extension: %s (%s) version %s",
                     ext_props[i].extensionName, lib_name, spec_version);
             res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
@@ -646,7 +646,7 @@ static VkResult loader_add_physical_device_extensions(
                 return res;
         }
     } else {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Error getting physical device extension info count from library %s", lib_name);
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Error getting physical device extension info count from library %s", lib_name);
         return res;
     }
 
@@ -809,7 +809,7 @@ static VkResult loader_add_layer_names_to_list(
         const char *search_target = names[i];
         layer_prop = loader_get_layer_property(search_target, search_list);
         if (!layer_prop) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Unable to find layer %s", search_target);
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Unable to find layer %s", search_target);
             err = VK_ERROR_LAYER_NOT_PRESENT;
             continue;
         }
@@ -1020,7 +1020,7 @@ static void loader_find_layer_name_add_list(
         }
     }
     if (!found) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Warning, couldn't find layer name %s to activate", name);
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Warning, couldn't find layer name %s to activate", name);
     }
 }
 
@@ -1070,7 +1070,7 @@ void loader_get_icd_loader_instance_extensions(
                                         struct loader_extension_list *inst_exts)
 {
     struct loader_extension_list icd_exts;
-    loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Build ICD instance extension list");
+    loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Build ICD instance extension list");
     // traverse scanned icd list adding non-duplicate extensions to the list
     for (uint32_t i = 0; i < icd_libs->count; i++) {
         loader_init_generic_list(inst, (struct loader_generic_list *) &icd_exts,
@@ -1139,7 +1139,7 @@ static struct loader_device *loader_add_logical_device(
 
     new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
     if (!new_dev) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device");
         return NULL;
     }
 
@@ -1266,14 +1266,14 @@ static void loader_scanned_icd_add(
     // Used to call: dlopen(filename, RTLD_LAZY);
     handle = loader_platform_open_library(filename);
     if (!handle) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, loader_platform_open_library_error(filename));
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, loader_platform_open_library_error(filename));
         return;
     }
 
 #define LOOKUP_LD(func_ptr, func) do {                            \
     func_ptr = (PFN_vk ##func) loader_platform_get_proc_address(handle, "vk" #func); \
     if (!func_ptr) {                                           \
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, loader_platform_get_proc_address_error("vk" #func)); \
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, loader_platform_get_proc_address_error("vk" #func)); \
         return;                                                \
     }                                                          \
 } while (0)
@@ -1307,7 +1307,7 @@ static void loader_scanned_icd_add(
                                             strlen(filename) + 1,
                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!new_node->lib_name) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Out of memory can't add icd");
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Out of memory can't add icd");
         return;
     }
     strcpy(new_node->lib_name, filename);
@@ -1323,7 +1323,7 @@ static bool loader_icd_init_entrys(struct loader_icd *icd,
     #define LOOKUP_GIPA(func, required) do {                       \
     icd->func = (PFN_vk ##func) fp_gipa(inst, "vk" #func);         \
     if (!icd->func && required) {                                  \
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0,                      \
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0,                      \
               loader_platform_get_proc_address_error("vk" #func)); \
         return false;                                              \
     }                                                              \
@@ -1385,19 +1385,19 @@ static void loader_debug_init(void)
                 g_loader_log_msgs = ~0u;
             } else if (strncmp(env, "warn", len) == 0) {
                 g_loader_debug |= LOADER_WARN_BIT;
-                g_loader_log_msgs |= VK_DBG_REPORT_WARN_BIT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_WARN_BIT;
             } else if (strncmp(env, "info", len) == 0) {
                 g_loader_debug |= LOADER_INFO_BIT;
-                g_loader_log_msgs |= VK_DBG_REPORT_INFO_BIT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_INFO_BIT;
             } else if (strncmp(env, "perf", len) == 0) {
                 g_loader_debug |= LOADER_PERF_BIT;
-                g_loader_log_msgs |= VK_DBG_REPORT_PERF_WARN_BIT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_PERF_WARN_BIT;
             } else if (strncmp(env, "error", len) == 0) {
                 g_loader_debug |= LOADER_ERROR_BIT;
-                g_loader_log_msgs |= VK_DBG_REPORT_ERROR_BIT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_ERROR_BIT;
             } else if (strncmp(env, "debug", len) == 0) {
                 g_loader_debug |= LOADER_DEBUG_BIT;
-                g_loader_log_msgs |= VK_DBG_REPORT_DEBUG_BIT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_DEBUG_BIT;
             }
         }
 
@@ -1527,7 +1527,7 @@ static cJSON *loader_get_json(const char *filename)
     uint64_t len;
     file = fopen(filename,"rb");
     if (!file) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Couldn't open JSON file %s", filename);
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Couldn't open JSON file %s", filename);
         return NULL;
     }
     fseek(file, 0, SEEK_END);
@@ -1535,12 +1535,12 @@ static cJSON *loader_get_json(const char *filename)
     fseek(file, 0, SEEK_SET);
     json_buf = (char*) loader_stack_alloc(len+1);
     if (json_buf == NULL) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get JSON file");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get JSON file");
         fclose(file);
         return NULL;
     }
     if (fread(json_buf, sizeof(char), len, file) != len) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "fread failed can't get JSON file");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "fread failed can't get JSON file");
         fclose(file);
         return NULL;
     }
@@ -1550,7 +1550,7 @@ static cJSON *loader_get_json(const char *filename)
     //parse text from file
     json = cJSON_Parse(json_buf);
     if (json == NULL)
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Can't parse JSON file %s", filename);
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Can't parse JSON file %s", filename);
     return json;
 }
 
@@ -1645,15 +1645,15 @@ static void loader_add_layer_properties(const struct loader_instance *inst,
         return;
     }
     char *file_vers = cJSON_PrintUnformatted(item);
-    loader_log(VK_DBG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s",
+    loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s",
                filename, file_vers);
     if (strcmp(file_vers, "\"1.0.0\"") != 0)
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors");
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors");
     loader_tls_heap_free(file_vers);
 
     layer_node = cJSON_GetObjectItem(json, "layer");
     if (layer_node == NULL) {
-        loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"layer\" object in manifest JSON file, skipping");
+        loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"layer\" object in manifest JSON file, skipping");
         return;
     }
 
@@ -1936,7 +1936,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
     }
 
     if (location == NULL) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
             "Can't get manifest files with NULL location, env_override=%s",
             env_override);
         return;
@@ -1952,14 +1952,14 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
     if (override == NULL) {
         loc = loader_stack_alloc(strlen(location) + 1);
         if (loc == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
             return;
         }
         strcpy(loc, location);
 #if defined(_WIN32)
         loc = loader_get_registry_files(inst, loc);
         if (loc == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Registry lookup failed can't get manifest files");
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Registry lookup failed can't get manifest files");
             return;
         }
 #endif
@@ -1967,14 +1967,14 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
     else {
         loc = loader_stack_alloc(strlen(override) + 1);
         if (loc == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
             return;
         }
         strcpy(loc, override);
     }
 
     // Print out the paths being searched if debugging is enabled
-    loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Searching the following paths for manifest files: %s\n", loc);
+    loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Searching the following paths for manifest files: %s\n", loc);
 
     file = loc;
     while (*file) {
@@ -2000,7 +2000,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
             // make a copy of location so it isn't modified
             dir = loader_stack_alloc(strlen(loc) + 1);
             if (dir == NULL) {
-                loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
+                loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
                 return;
             }
             strcpy(dir, loc);
@@ -2029,7 +2029,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
                         alloced_count *= 2;
                     }
                     if (out_files->filename_list == NULL) {
-                        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't alloc manifest file list");
+                        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't alloc manifest file list");
                         return;
                     }
                     out_files->filename_list[out_files->count] = loader_heap_alloc(
@@ -2037,13 +2037,13 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
                                                 strlen(name) + 1,
                                                 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
                     if (out_files->filename_list[out_files->count] == NULL) {
-                        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
+                        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
                         return;
                     }
                     strcpy(out_files->filename_list[out_files->count], name);
                     out_files->count++;
                 } else if (!list_is_dirs) {
-                    loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Skipping manifest file %s, file name must end in .json", name);
+                    loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Skipping manifest file %s, file name must end in .json", name);
                 }
                 if (list_is_dirs) {
                     dent = readdir(sysdir);
@@ -2114,10 +2114,10 @@ void loader_icd_scan(
             return;
         }
         char *file_vers = cJSON_Print(item);
-        loader_log(VK_DBG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s",
+        loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s",
                    file_str, file_vers);
         if (strcmp(file_vers, "\"1.0.0\"") != 0)
-            loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors");
+            loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors");
         loader_tls_heap_free(file_vers);
         itemICD = cJSON_GetObjectItem(json, "ICD");
         if (itemICD != NULL) {
@@ -2125,7 +2125,7 @@ void loader_icd_scan(
             if (item != NULL) {
                 char *temp= cJSON_Print(item);
                 if (!temp || strlen(temp) == 0) {
-                    loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str);
+                    loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str);
                     loader_tls_heap_free(temp);
                     loader_heap_free(inst, file_str);
                     cJSON_Delete(json);
@@ -2137,14 +2137,14 @@ void loader_icd_scan(
                 strcpy(library_path, &temp[1]);
                 loader_tls_heap_free(temp);
                 if (!library_path || strlen(library_path) == 0) {
-                    loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str);
+                    loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str);
                     loader_heap_free(inst, file_str);
                     cJSON_Delete(json);
                     continue;
                 }
                 char fullpath[MAX_STRING_SIZE];
                 // Print out the paths being searched if debugging is enabled
-                loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Searching for ICD drivers named %s default dir %s\n", library_path, DEFAULT_VK_DRIVERS_PATH);
+                loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Searching for ICD drivers named %s default dir %s\n", library_path, DEFAULT_VK_DRIVERS_PATH);
                 if (loader_platform_is_path(library_path)) {
                     // a relative or absolute path
                     char *name_copy = loader_stack_alloc(strlen(file_str) + 1);
@@ -2167,10 +2167,10 @@ void loader_icd_scan(
                 loader_scanned_icd_add(inst, icds, fullpath, vers);
             }
             else
-                loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" object in ICD JSON file %s, skipping", file_str);
+                loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" object in ICD JSON file %s, skipping", file_str);
         }
         else
-            loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"ICD\" object in ICD JSON file %s, skipping", file_str);
+            loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"ICD\" object in ICD JSON file %s, skipping", file_str);
 
         loader_heap_free(inst, file_str);
         cJSON_Delete(json);
@@ -2204,7 +2204,7 @@ void loader_layer_scan(
      * used to check for global and physicaldevice layer properties.
      */
     if (!loader_init_layer_library_list(&loader.scanned_layer_libraries)) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                    "Alloc for layer list failed: %s line: %d", __FILE__, __LINE__);
         return;
     }
@@ -2361,7 +2361,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst,
                                          strlen(funcName) + 1,
                                          VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (inst->disp_hash[idx].func_name == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                        "loader_add_dev_ext_table() can't allocate memory for func_name");
             return false;
         }
@@ -2374,7 +2374,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst,
         list->index = loader_heap_alloc(inst, 8 * sizeof(*(list->index)),
                                         VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                        "loader_add_dev_ext_table() can't allocate list memory");
             return false;
         }
@@ -2384,7 +2384,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst,
                             list->capacity * 2,
                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                        "loader_add_dev_ext_table() can't reallocate list memory");
             return false;
         }
@@ -2400,7 +2400,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst,
                                             strlen(funcName) + 1,
                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (inst->disp_hash[i].func_name == NULL) {
-                loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+                loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                        "loader_add_dev_ext_table() can't rallocate func_name memory");
                 return false;
             }
@@ -2413,7 +2413,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst,
         i = (i + 1) % MAX_NUM_DEV_EXTS;
     } while (i != idx);
 
-    loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+    loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                "loader_add_dev_ext_table() couldn't insert into hash table; is it full?");
     return false;
 }
@@ -2517,7 +2517,7 @@ static loader_platform_dl_handle loader_add_layer_lib(
         if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_name) == 0) {
             /* Have already loaded this library, just increment ref count */
             loader.loaded_layer_lib_list[i].ref_count++;
-            loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                        "%s Chain: Increment layer reference count for layer library %s",
                        chain_type, layer_prop->lib_name);
             return loader.loaded_layer_lib_list[i].lib_handle;
@@ -2539,7 +2539,7 @@ static loader_platform_dl_handle loader_add_layer_lib(
                                             new_alloc_size,
                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (!new_layer_lib_list) {
-            loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib");
+            loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib");
             return NULL;
         }
         loader.loaded_layer_lib_capacity = new_alloc_size;
@@ -2553,11 +2553,11 @@ static loader_platform_dl_handle loader_add_layer_lib(
     my_lib->lib_handle = NULL;
 
     if ((my_lib->lib_handle = loader_platform_open_library(my_lib->lib_name)) == NULL) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                    loader_platform_open_library_error(my_lib->lib_name));
         return NULL;
     } else {
-        loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                    "Chain: %s: Loading layer library %s",
                    chain_type, layer_prop->lib_name);
     }
@@ -2587,13 +2587,13 @@ static void loader_remove_layer_lib(
     if (my_lib) {
         my_lib->ref_count--;
         if (my_lib->ref_count > 0) {
-            loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+            loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                        "Decrement reference count for layer library %s", layer_prop->lib_name);
             return;
         }
     }
     loader_platform_close_library(my_lib->lib_handle);
-    loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
+    loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0,
                "Unloading layer library %s", layer_prop->lib_name);
 
     /* Need to remove unused library from list */
@@ -2601,7 +2601,7 @@ static void loader_remove_layer_lib(
                                            loader.loaded_layer_lib_capacity,
                                            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!new_layer_lib_list) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library");
         return;
     }
 
@@ -2703,7 +2703,7 @@ VkResult loader_enable_instance_layers(
     assert(inst && "Cannot have null instance");
 
     if (!loader_init_layer_list(inst, &inst->activated_layer_list)) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance activated layer list");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance activated layer list");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
@@ -2756,7 +2756,7 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst)
     wrappedInstance = loader_stack_alloc(sizeof(VkBaseLayerObject)
                                    * inst->activated_layer_list.count);
     if (!wrappedInstance) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance objects for layer");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance objects for layer");
         return 0;
     }
 
@@ -2796,14 +2796,14 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst)
             } else
                 nextGPA = (PFN_vkGetInstanceProcAddr) loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gipa);
             if (!nextGPA) {
-                loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_name);
+                loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_name);
 
                 /* TODO: Should we return nextObj, nextGPA to previous? or decrement layer_list count*/
                 continue;
             }
         }
 
-        loader_log(VK_DBG_REPORT_INFO_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_INFO_BIT, 0,
                    "Insert instance layer %s (%s)",
                    layer_prop->info.layerName,
                    layer_prop->lib_name);
@@ -2841,7 +2841,7 @@ static VkResult loader_enable_device_layers(
     }
 
     if (dev->activated_layer_list.list == NULL) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc device activated layer list");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc device activated layer list");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
@@ -2925,7 +2925,7 @@ static uint32_t loader_activate_device_layers(
                     sizeof (VkBaseLayerObject) * dev->activated_layer_list.count,
                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!wrappedGpus) {
-        loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer");
+        loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer");
         return 0;
     }
 
@@ -2948,12 +2948,12 @@ static uint32_t loader_activate_device_layers(
             } else
                 nextGPA = (PFN_vkGetDeviceProcAddr) loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gdpa);
             if (!nextGPA) {
-                loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetDeviceProcAddr in layer %s", layer_prop->lib_name);
+                loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to find vkGetDeviceProcAddr in layer %s", layer_prop->lib_name);
                 continue;
             }
         }
 
-        loader_log(VK_DBG_REPORT_INFO_BIT, 0,
+        loader_log(VK_DEBUG_REPORT_INFO_BIT, 0,
                    "Insert device layer library %s (%s)",
                    layer_prop->info.layerName,
                    layer_prop->lib_name);
@@ -3134,7 +3134,7 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateInstance(
                 ptr_instance->icds = ptr_instance->icds->next;
                 loader_icd_destroy(ptr_instance, icd);
                 icd->instance = VK_NULL_HANDLE;
-                loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+                loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0,
                         "ICD ignored: failed to CreateInstance and find entrypoints with ICD");
             }
         }