blob: 719e5af00be6b99c134b2232fe7adc950f03d80f [file] [log] [blame]
Jeremy Hayesb707aa52015-06-18 10:12:39 -06001/*
2 * Vulkan
3 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <iostream>
30#include <string>
31#include <sstream>
32#include <unordered_map>
33
Tobin Ehlis7a51d902015-07-03 10:34:49 -060034#include "vk_loader_platform.h"
Tobin Ehlis2d1d9702015-07-03 09:42:57 -060035#include "vk_layer.h"
Tobin Ehlis56d204a2015-07-03 10:15:26 -060036#include "vk_layer_config.h"
Jeremy Hayesb707aa52015-06-18 10:12:39 -060037#include "vk_enum_validate_helper.h"
38#include "vk_struct_validate_helper.h"
39//The following is #included again to catch certain OS-specific functions being used:
Tobin Ehlis7a51d902015-07-03 10:34:49 -060040#include "vk_loader_platform.h"
Jeremy Hayesb707aa52015-06-18 10:12:39 -060041
Tobin Ehlis56d204a2015-07-03 10:15:26 -060042#include "vk_layer_table.h"
43#include "vk_layer_data.h"
44#include "vk_layer_logging.h"
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -060045#include "vk_layer_extension_utils.h"
Jeremy Hayesb707aa52015-06-18 10:12:39 -060046
47typedef struct _layer_data {
48 debug_report_data *report_data;
49 VkDbgMsgCallback logging_callback;
Chris Forbesd7576302015-06-21 22:55:02 +120050 VkPhysicalDevice physicalDevice;
Jeremy Hayesb707aa52015-06-18 10:12:39 -060051} layer_data;
52
53static std::unordered_map<void*, layer_data*> layer_data_map;
54static device_table_map image_device_table_map;
55static instance_table_map image_instance_table_map;
56
57// "my device data"
Tony Barbour2a199c12015-07-09 17:31:46 -060058debug_report_data *mdd(const void* object)
Jeremy Hayesb707aa52015-06-18 10:12:39 -060059{
60 dispatch_key key = get_dispatch_key(object);
61 layer_data *data = get_my_data_ptr(key, layer_data_map);
62#if DISPATCH_MAP_DEBUG
63 fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
64#endif
Jeremy Hayesb707aa52015-06-18 10:12:39 -060065 return data->report_data;
66}
67
68// "my instance data"
69debug_report_data *mid(VkInstance object)
70{
71 dispatch_key key = get_dispatch_key(object);
Courtney Goeltzenleuchter07199212015-06-22 16:19:14 -060072 layer_data *data = get_my_data_ptr(key, layer_data_map);
Jeremy Hayesb707aa52015-06-18 10:12:39 -060073#if DISPATCH_MAP_DEBUG
74 fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
75#endif
Jeremy Hayesb707aa52015-06-18 10:12:39 -060076 return data->report_data;
77}
78
79static void InitImage(layer_data *data)
80{
81 uint32_t report_flags = getLayerOptionFlags("ImageReportFlags", 0);
82
83 uint32_t debug_action = 0;
84 getLayerOptionEnum("ImageDebugAction", (uint32_t *) &debug_action);
85 if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
86 {
87 FILE *log_output = NULL;
88 const char* option_str = getLayerOption("ImageLogFilename");
89 if(option_str)
90 {
91 log_output = fopen(option_str, "w");
92 }
93 if(log_output == NULL)
94 {
95 log_output = stdout;
96 }
97
98 layer_create_msg_callback(data->report_data, report_flags, log_callback, (void*)log_output, &data->logging_callback);
99 }
100}
101
102VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
103 VkInstance instance,
104 VkFlags msgFlags,
105 const PFN_vkDbgMsgCallback pfnMsgCallback,
106 void* pUserData,
107 VkDbgMsgCallback* pMsgCallback)
108{
109 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(image_instance_table_map, instance);
110 VkResult res = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
111 if (res == VK_SUCCESS) {
112 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
113
114 res = layer_create_msg_callback(data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
115 }
116 return res;
117}
118
119VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
120 VkInstance instance,
121 VkDbgMsgCallback msgCallback)
122{
123 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(image_instance_table_map, instance);
124 VkResult res = pTable->DbgDestroyMsgCallback(instance, msgCallback);
125
126 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
127 layer_destroy_msg_callback(data->report_data, msgCallback);
128
129 return res;
130}
131
132VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
133{
134 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(image_instance_table_map, *pInstance);
135 VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
136
137 if (result == VK_SUCCESS) {
138 layer_data *data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
139 data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->extensionCount,
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600140 pCreateInfo->ppEnabledExtensionNames);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600141
142 InitImage(data);
143 }
144
145 return result;
146}
147
148VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
149{
150 // Grab the key before the instance is destroyed.
151 dispatch_key key = get_dispatch_key(instance);
152 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(image_instance_table_map, instance);
153 VkResult result = pTable->DestroyInstance(instance);
154
155 // Clean up logging callback, if any
156 layer_data *data = get_my_data_ptr(key, layer_data_map);
157 if(data->logging_callback)
158 {
159 layer_destroy_msg_callback(data->report_data, data->logging_callback);
160 }
161
162 layer_debug_report_destroy_instance(mid(instance));
163 layer_data_map.erase(pTable);
164
165 image_instance_table_map.erase(key);
166 assert(image_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
167
168 return result;
169}
170
171VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
172{
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600173 VkLayerDispatchTable *pTable = get_dispatch_table(image_device_table_map, *pDevice);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600174 VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pDevice);
175 if(result == VK_SUCCESS)
176 {
177 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
178 layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
179 device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice);
Chris Forbesd7576302015-06-21 22:55:02 +1200180 device_data->physicalDevice = physicalDevice;
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600181 }
182
183 return result;
184}
185
186VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
187{
188 layer_debug_report_destroy_device(device);
189
190 dispatch_key key = get_dispatch_key(device);
191#if DISPATCH_MAP_DEBUG
192 fprintf(stderr, "Device: %p, key: %p\n", device, key);
193#endif
194
195 VkResult result = get_dispatch_table(image_device_table_map, device)->DestroyDevice(device);
196 image_device_table_map.erase(key);
197 assert(image_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
198
199 return result;
200}
201
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600202static const VkLayerProperties pc_global_layers[] = {
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600203 {
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600204 "Image",
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600205 VK_API_VERSION,
206 VK_MAKE_VERSION(0, 1, 0),
207 "Validation layer: Image ParamChecker",
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600208 }
209};
210
Tony Barbour426b9052015-06-24 16:06:58 -0600211VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600212 const char *pLayerName,
213 uint32_t *pCount,
214 VkExtensionProperties* pProperties)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600215{
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600216 /* ParamChecker does not have any global extensions */
217 return util_GetExtensionProperties(0, NULL, pCount, pProperties);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600218}
219
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600220VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalLayerProperties(
221 uint32_t *pCount,
222 VkLayerProperties* pProperties)
Tony Barbour426b9052015-06-24 16:06:58 -0600223{
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600224 return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers),
225 pc_global_layers,
226 pCount, pProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600227}
228
229VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600230 VkPhysicalDevice physicalDevice,
231 const char* pLayerName,
232 uint32_t* pCount,
233 VkExtensionProperties* pProperties)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600234{
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600235 /* ParamChecker does not have any physical device extensions */
236 return util_GetExtensionProperties(0, NULL, pCount, pProperties);
237}
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600238
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600239VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
240 VkPhysicalDevice physicalDevice,
241 uint32_t* pCount,
242 VkLayerProperties* pProperties)
243{
244 /* ParamChecker's physical device layers are the same as global */
245 return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers,
246 pCount, pProperties);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600247}
248
249VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
250{
251 if(pCreateInfo->format != VK_FORMAT_UNDEFINED)
252 {
Courtney Goeltzenleuchter07199212015-06-22 16:19:14 -0600253 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600254 VkFormatProperties properties;
Chris Forbesd7576302015-06-21 22:55:02 +1200255 VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatInfo(
256 device_data->physicalDevice, pCreateInfo->format, &properties);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600257 if(result != VK_SUCCESS)
258 {
259 char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, cannot be validated";
Tony Barbour2a199c12015-07-09 17:31:46 -0600260 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", str);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600261 }
262
263 if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
264 {
265 char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains unsupported format";
Tony Barbour2a199c12015-07-09 17:31:46 -0600266 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", str);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600267 }
268 }
269
270 VkResult result = get_dispatch_table(image_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
271
272 return result;
273}
274
275VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
276{
Chia-I Wuc278df82015-07-07 11:50:03 +0800277 for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600278 {
Chia-I Wuc278df82015-07-07 11:50:03 +0800279 if(pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600280 {
Courtney Goeltzenleuchter07199212015-06-22 16:19:14 -0600281 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600282 VkFormatProperties properties;
Chris Forbesd7576302015-06-21 22:55:02 +1200283 VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatInfo(
Chia-I Wuc278df82015-07-07 11:50:03 +0800284 device_data->physicalDevice, pCreateInfo->pAttachments[i].format, &properties);
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600285 if(result != VK_SUCCESS)
286 {
287 std::stringstream ss;
Chia-I Wuc278df82015-07-07 11:50:03 +0800288 ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], cannot be validated";
Tony Barbour2a199c12015-07-09 17:31:46 -0600289 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600290 continue;
291 }
292
293 if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
294 {
295 std::stringstream ss;
Chia-I Wuc278df82015-07-07 11:50:03 +0800296 ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format";
Tony Barbour2a199c12015-07-09 17:31:46 -0600297 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600298 }
299 }
300 }
301
Chia-I Wuc278df82015-07-07 11:50:03 +0800302 for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600303 {
Chia-I Wuc278df82015-07-07 11:50:03 +0800304 if(!validate_VkImageLayout(pCreateInfo->pAttachments[i].initialLayout) ||
305 !validate_VkImageLayout(pCreateInfo->pAttachments[i].finalLayout))
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600306 {
307 std::stringstream ss;
Chia-I Wuc278df82015-07-07 11:50:03 +0800308 ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized";
Tony Barbour2a199c12015-07-09 17:31:46 -0600309 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600310 }
311 }
312
Chia-I Wuc278df82015-07-07 11:50:03 +0800313 for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600314 {
Chia-I Wuc278df82015-07-07 11:50:03 +0800315 if(!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp))
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600316 {
317 std::stringstream ss;
Chia-I Wuc278df82015-07-07 11:50:03 +0800318 ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
Tony Barbour2a199c12015-07-09 17:31:46 -0600319 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600320 }
321 }
322
Chia-I Wuc278df82015-07-07 11:50:03 +0800323 for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600324 {
Chia-I Wuc278df82015-07-07 11:50:03 +0800325 if(!validate_VkAttachmentStoreOp(pCreateInfo->pAttachments[i].storeOp))
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600326 {
327 std::stringstream ss;
Chia-I Wuc278df82015-07-07 11:50:03 +0800328 ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
Tony Barbour2a199c12015-07-09 17:31:46 -0600329 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600330 }
331 }
332
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600333 VkResult result = get_dispatch_table(image_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
334
335 return result;
336}
337
338VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
339{
340 if (device == NULL) {
341 return NULL;
342 }
343
344 /* loader uses this to force layer initialization; device object is wrapped */
345 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
346 initDeviceTable(image_device_table_map, (const VkBaseLayerObject *) device);
347 return (void*) vkGetDeviceProcAddr;
348 }
349
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600350 if (!strcmp(funcName, "vkCreateDevice"))
351 return (void*) vkCreateDevice;
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600352 if (!strcmp(funcName, "vkDestroyDevice"))
353 return (void*) vkDestroyDevice;
354 if (!strcmp(funcName, "vkCreateImage"))
355 return (void*) vkCreateImage;
356 if (!strcmp(funcName, "vkCreateRenderPass"))
357 return (void*) vkCreateRenderPass;
358
359 {
360 if (get_dispatch_table(image_device_table_map, device)->GetDeviceProcAddr == NULL)
361 return NULL;
362 return get_dispatch_table(image_device_table_map, device)->GetDeviceProcAddr(device, funcName);
363 }
364}
365
366VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
367{
368 if (instance == NULL) {
369 return NULL;
370 }
371
372 /* loader uses this to force layer initialization; instance object is wrapped */
373 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
374 initInstanceTable(image_instance_table_map, (const VkBaseLayerObject *) instance);
375 return (void *) vkGetInstanceProcAddr;
376 }
377
378 if (!strcmp(funcName, "vkCreateInstance"))
379 return (void*) vkCreateInstance;
380 if (!strcmp(funcName, "vkDestroyInstance"))
381 return (void *) vkDestroyInstance;
Courtney Goeltzenleuchtereb1ddb02015-07-07 11:18:30 -0600382 if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
383 return (void*) vkGetGlobalLayerProperties;
384 if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
385 return (void*) vkGetGlobalExtensionProperties;
386 if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
387 return (void*) vkGetPhysicalDeviceLayerProperties;
Tony Barbour426b9052015-06-24 16:06:58 -0600388 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
389 return (void*) vkGetPhysicalDeviceExtensionProperties;
Jeremy Hayesb707aa52015-06-18 10:12:39 -0600390
391 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
392 void* fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
393 if(fptr)
394 return fptr;
395
396 {
397 if (get_dispatch_table(image_instance_table_map, instance)->GetInstanceProcAddr == NULL)
398 return NULL;
399 return get_dispatch_table(image_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
400 }
401}