Commit | Line | Data |
---|---|---|
7aa026cc | 1 | /* |
5dcb2e4b | 2 | * Copyright 2009 Matteo Bruni |
7aa026cc MB |
3 | * Copyright 2010 Matteo Bruni for CodeWeavers |
4 | * | |
5 | * This library is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU Lesser General Public | |
7 | * License as published by the Free Software Foundation; either | |
8 | * version 2.1 of the License, or (at your option) any later version. | |
9 | * | |
10 | * This library is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | * Lesser General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU Lesser General Public | |
16 | * License along with this library; if not, write to the Free Software | |
17 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
18 | */ | |
19 | ||
5dcb2e4b | 20 | #define COBJMACROS |
7aa026cc MB |
21 | #include "config.h" |
22 | #include "wine/port.h" | |
23 | #include "wine/debug.h" | |
24 | #include "wine/unicode.h" | |
25 | ||
26 | #include "d3dcompiler_private.h" | |
5dcb2e4b | 27 | #include "wine/wpp.h" |
7aa026cc MB |
28 | |
29 | WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler); | |
30 | ||
5dcb2e4b MB |
31 | #define D3DXERR_INVALIDDATA 0x88760b59 |
32 | ||
33 | #define BUFFER_INITIAL_CAPACITY 256 | |
34 | ||
35 | struct mem_file_desc | |
36 | { | |
37 | const char *buffer; | |
38 | unsigned int size; | |
39 | unsigned int pos; | |
40 | }; | |
41 | ||
3db5163f HV |
42 | static struct mem_file_desc current_shader; |
43 | static ID3DInclude *current_include; | |
5dcb2e4b MB |
44 | |
45 | #define INCLUDES_INITIAL_CAPACITY 4 | |
46 | ||
47 | struct loaded_include | |
48 | { | |
49 | const char *name; | |
50 | const char *data; | |
51 | }; | |
52 | ||
3db5163f HV |
53 | static struct loaded_include *includes; |
54 | static int includes_capacity, includes_size; | |
55 | static const char *parent_include; | |
5dcb2e4b | 56 | |
3db5163f HV |
57 | static char *wpp_output; |
58 | static int wpp_output_capacity, wpp_output_size; | |
5dcb2e4b | 59 | |
3db5163f HV |
60 | static char *wpp_messages; |
61 | static int wpp_messages_capacity, wpp_messages_size; | |
5dcb2e4b MB |
62 | |
63 | /* Mutex used to guarantee a single invocation | |
64 | of the D3DXAssembleShader function (or its variants) at a time. | |
65 | This is needed as wpp isn't thread-safe */ | |
66 | static CRITICAL_SECTION wpp_mutex; | |
67 | static CRITICAL_SECTION_DEBUG wpp_mutex_debug = | |
68 | { | |
69 | 0, 0, &wpp_mutex, | |
70 | { &wpp_mutex_debug.ProcessLocksList, | |
71 | &wpp_mutex_debug.ProcessLocksList }, | |
72 | 0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") } | |
73 | }; | |
74 | static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 }; | |
75 | ||
76 | /* Preprocessor error reporting functions */ | |
77 | static void wpp_write_message(const char *fmt, va_list args) | |
78 | { | |
79 | char* newbuffer; | |
80 | int rc, newsize; | |
81 | ||
82 | if(wpp_messages_capacity == 0) | |
83 | { | |
84 | wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE); | |
85 | if(wpp_messages == NULL) | |
86 | { | |
87 | ERR("Error allocating memory for parser messages\n"); | |
88 | return; | |
89 | } | |
90 | wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE; | |
91 | } | |
92 | ||
93 | while(1) | |
94 | { | |
95 | rc = vsnprintf(wpp_messages + wpp_messages_size, | |
96 | wpp_messages_capacity - wpp_messages_size, fmt, args); | |
97 | ||
98 | if (rc < 0 || /* C89 */ | |
99 | rc >= wpp_messages_capacity - wpp_messages_size) { /* C99 */ | |
100 | /* Resize the buffer */ | |
101 | newsize = wpp_messages_capacity * 2; | |
102 | newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize); | |
103 | if(newbuffer == NULL) | |
104 | { | |
105 | ERR("Error reallocating memory for parser messages\n"); | |
106 | return; | |
107 | } | |
108 | wpp_messages = newbuffer; | |
109 | wpp_messages_capacity = newsize; | |
110 | } | |
111 | else | |
112 | { | |
113 | wpp_messages_size += rc; | |
114 | return; | |
115 | } | |
116 | } | |
117 | } | |
118 | ||
119 | static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...) | |
120 | { | |
121 | va_list args; | |
122 | ||
123 | va_start(args, fmt); | |
124 | wpp_write_message(fmt, args); | |
125 | va_end(args); | |
126 | } | |
127 | ||
128 | static void wpp_error(const char *file, int line, int col, const char *near, | |
129 | const char *msg, va_list ap) | |
130 | { | |
131 | wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'", | |
132 | line, col, "Error"); | |
133 | wpp_write_message(msg, ap); | |
134 | wpp_write_message_var("\n"); | |
135 | } | |
136 | ||
137 | static void wpp_warning(const char *file, int line, int col, const char *near, | |
138 | const char *msg, va_list ap) | |
139 | { | |
140 | wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'", | |
141 | line, col, "Warning"); | |
142 | wpp_write_message(msg, ap); | |
143 | wpp_write_message_var("\n"); | |
144 | } | |
145 | ||
146 | static char *wpp_lookup_mem(const char *filename, const char *parent_name, | |
147 | char **include_path, int include_path_count) | |
148 | { | |
149 | /* Here we return always ok. We will maybe fail on the next wpp_open_mem */ | |
150 | char *path; | |
151 | int i; | |
152 | ||
153 | parent_include = NULL; | |
154 | if(parent_name[0] != '\0') | |
155 | { | |
156 | for(i = 0; i < includes_size; i++) | |
157 | { | |
158 | if(!strcmp(parent_name, includes[i].name)) | |
159 | { | |
160 | parent_include = includes[i].data; | |
161 | break; | |
162 | } | |
163 | } | |
164 | if(parent_include == NULL) | |
165 | { | |
166 | ERR("Parent include file missing\n"); | |
167 | return NULL; | |
168 | } | |
169 | } | |
170 | ||
171 | path = malloc(strlen(filename) + 1); | |
172 | if(path) | |
173 | memcpy(path, filename, strlen(filename) + 1); | |
174 | return path; | |
175 | } | |
176 | ||
177 | static void *wpp_open_mem(const char *filename, int type) | |
178 | { | |
179 | struct mem_file_desc *desc; | |
180 | HRESULT hr; | |
181 | ||
182 | if(filename[0] == '\0') /* "" means to load the initial shader */ | |
183 | { | |
184 | current_shader.pos = 0; | |
185 | return ¤t_shader; | |
186 | } | |
187 | ||
188 | if(current_include == NULL) return NULL; | |
189 | desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc)); | |
190 | if(!desc) | |
191 | { | |
192 | ERR("Error allocating memory\n"); | |
193 | return NULL; | |
194 | } | |
195 | hr = ID3DInclude_Open(current_include, | |
196 | type ? D3D_INCLUDE_SYSTEM : D3D_INCLUDE_LOCAL, | |
197 | filename, parent_include, (LPCVOID *)&desc->buffer, | |
198 | &desc->size); | |
199 | if(FAILED(hr)) | |
200 | { | |
201 | HeapFree(GetProcessHeap(), 0, desc); | |
202 | return NULL; | |
203 | } | |
204 | ||
205 | if(includes_capacity == includes_size) | |
206 | { | |
207 | if(includes_capacity == 0) | |
208 | { | |
00591095 | 209 | includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes)); |
5dcb2e4b MB |
210 | if(includes == NULL) |
211 | { | |
212 | ERR("Error allocating memory for the loaded includes structure\n"); | |
213 | goto error; | |
214 | } | |
00591095 | 215 | includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes); |
5dcb2e4b MB |
216 | } |
217 | else | |
218 | { | |
219 | int newcapacity = includes_capacity * 2; | |
220 | struct loaded_include *newincludes = | |
221 | HeapReAlloc(GetProcessHeap(), 0, includes, newcapacity); | |
222 | if(newincludes == NULL) | |
223 | { | |
224 | ERR("Error reallocating memory for the loaded includes structure\n"); | |
225 | goto error; | |
226 | } | |
227 | includes = newincludes; | |
228 | includes_capacity = newcapacity; | |
229 | } | |
230 | } | |
231 | includes[includes_size].name = filename; | |
232 | includes[includes_size++].data = desc->buffer; | |
233 | ||
234 | desc->pos = 0; | |
235 | return desc; | |
236 | ||
237 | error: | |
238 | ID3DInclude_Close(current_include, desc->buffer); | |
239 | HeapFree(GetProcessHeap(), 0, desc); | |
240 | return NULL; | |
241 | } | |
242 | ||
243 | static void wpp_close_mem(void *file) | |
244 | { | |
245 | struct mem_file_desc *desc = file; | |
246 | ||
247 | if(desc != ¤t_shader) | |
248 | { | |
249 | if(current_include) | |
250 | ID3DInclude_Close(current_include, desc->buffer); | |
251 | else | |
252 | ERR("current_include == NULL, desc == %p, buffer = %s\n", | |
253 | desc, desc->buffer); | |
254 | ||
255 | HeapFree(GetProcessHeap(), 0, desc); | |
256 | } | |
257 | } | |
258 | ||
259 | static int wpp_read_mem(void *file, char *buffer, unsigned int len) | |
260 | { | |
261 | struct mem_file_desc *desc = file; | |
262 | ||
263 | len = min(len, desc->size - desc->pos); | |
264 | memcpy(buffer, desc->buffer + desc->pos, len); | |
265 | desc->pos += len; | |
266 | return len; | |
267 | } | |
268 | ||
269 | static void wpp_write_mem(const char *buffer, unsigned int len) | |
270 | { | |
271 | char *new_wpp_output; | |
272 | ||
273 | if(wpp_output_capacity == 0) | |
274 | { | |
275 | wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY); | |
276 | if(!wpp_output) | |
277 | { | |
278 | ERR("Error allocating memory\n"); | |
279 | return; | |
280 | } | |
281 | wpp_output_capacity = BUFFER_INITIAL_CAPACITY; | |
282 | } | |
283 | if(len > wpp_output_capacity - wpp_output_size) | |
284 | { | |
285 | while(len > wpp_output_capacity - wpp_output_size) | |
286 | { | |
287 | wpp_output_capacity *= 2; | |
288 | } | |
289 | new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output, | |
290 | wpp_output_capacity); | |
291 | if(!new_wpp_output) | |
292 | { | |
293 | ERR("Error allocating memory\n"); | |
294 | return; | |
295 | } | |
296 | wpp_output = new_wpp_output; | |
297 | } | |
298 | memcpy(wpp_output + wpp_output_size, buffer, len); | |
299 | wpp_output_size += len; | |
300 | } | |
301 | ||
302 | static int wpp_close_output(void) | |
303 | { | |
304 | char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output, | |
305 | wpp_output_size + 1); | |
306 | if(!new_wpp_output) return 0; | |
307 | wpp_output = new_wpp_output; | |
308 | wpp_output[wpp_output_size]='\0'; | |
dbc8c9c2 | 309 | wpp_output_size++; |
5dcb2e4b MB |
310 | return 1; |
311 | } | |
312 | ||
55043956 MB |
313 | static HRESULT preprocess_shader(const void *data, SIZE_T data_size, |
314 | const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **error_messages) | |
315 | { | |
316 | int ret; | |
317 | HRESULT hr = S_OK; | |
318 | const D3D_SHADER_MACRO *def = defines; | |
319 | ||
320 | static const struct wpp_callbacks wpp_callbacks = | |
321 | { | |
322 | wpp_lookup_mem, | |
323 | wpp_open_mem, | |
324 | wpp_close_mem, | |
325 | wpp_read_mem, | |
326 | wpp_write_mem, | |
327 | wpp_error, | |
328 | wpp_warning, | |
329 | }; | |
330 | ||
331 | if (def != NULL) | |
332 | { | |
333 | while (def->Name != NULL) | |
334 | { | |
335 | wpp_add_define(def->Name, def->Definition); | |
336 | def++; | |
337 | } | |
338 | } | |
339 | current_include = include; | |
340 | includes_size = 0; | |
341 | ||
342 | wpp_output_size = wpp_output_capacity = 0; | |
343 | wpp_output = NULL; | |
344 | ||
345 | wpp_set_callbacks(&wpp_callbacks); | |
346 | wpp_messages_size = wpp_messages_capacity = 0; | |
347 | wpp_messages = NULL; | |
348 | current_shader.buffer = data; | |
349 | current_shader.size = data_size; | |
350 | ||
351 | ret = wpp_parse("", NULL); | |
352 | if (!wpp_close_output()) | |
353 | ret = 1; | |
354 | if (ret) | |
355 | { | |
356 | TRACE("Error during shader preprocessing\n"); | |
357 | if (wpp_messages) | |
358 | { | |
359 | int size; | |
360 | ID3DBlob *buffer; | |
361 | ||
362 | TRACE("Preprocessor messages:\n%s", wpp_messages); | |
363 | ||
364 | if (error_messages) | |
365 | { | |
366 | size = strlen(wpp_messages) + 1; | |
367 | hr = D3DCreateBlob(size, &buffer); | |
368 | if (FAILED(hr)) | |
369 | goto cleanup; | |
370 | CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_messages, size); | |
371 | *error_messages = buffer; | |
372 | } | |
373 | } | |
374 | if (data) | |
375 | TRACE("Shader source:\n%s\n", debugstr_an(data, data_size)); | |
376 | hr = E_FAIL; | |
377 | } | |
378 | ||
379 | cleanup: | |
380 | /* Remove the previously added defines */ | |
381 | if (defines != NULL) | |
382 | { | |
383 | while (defines->Name != NULL) | |
384 | { | |
385 | wpp_del_define(defines->Name); | |
386 | defines++; | |
387 | } | |
388 | } | |
389 | HeapFree(GetProcessHeap(), 0, wpp_messages); | |
390 | return hr; | |
391 | } | |
392 | ||
5dcb2e4b MB |
393 | static HRESULT assemble_shader(const char *preprocShader, const char *preprocMessages, |
394 | LPD3DBLOB* ppShader, LPD3DBLOB* ppErrorMsgs) | |
395 | { | |
396 | struct bwriter_shader *shader; | |
397 | char *messages = NULL; | |
398 | HRESULT hr; | |
399 | DWORD *res; | |
400 | LPD3DBLOB buffer; | |
401 | int size; | |
402 | char *pos; | |
403 | ||
404 | shader = SlAssembleShader(preprocShader, &messages); | |
405 | ||
406 | if(messages || preprocMessages) | |
407 | { | |
408 | if(preprocMessages) | |
409 | { | |
410 | TRACE("Preprocessor messages:\n"); | |
411 | TRACE("%s", preprocMessages); | |
412 | } | |
413 | if(messages) | |
414 | { | |
415 | TRACE("Assembler messages:\n"); | |
416 | TRACE("%s", messages); | |
417 | } | |
418 | ||
419 | TRACE("Shader source:\n"); | |
420 | TRACE("%s\n", debugstr_a(preprocShader)); | |
421 | ||
422 | if(ppErrorMsgs) | |
423 | { | |
424 | size = (messages ? strlen(messages) : 0) + | |
425 | (preprocMessages ? strlen(preprocMessages) : 0) + 1; | |
426 | hr = D3DCreateBlob(size, &buffer); | |
427 | if(FAILED(hr)) | |
428 | { | |
429 | HeapFree(GetProcessHeap(), 0, messages); | |
430 | if(shader) SlDeleteShader(shader); | |
431 | return hr; | |
432 | } | |
433 | pos = ID3D10Blob_GetBufferPointer(buffer); | |
434 | if(preprocMessages) | |
435 | { | |
436 | CopyMemory(pos, preprocMessages, strlen(preprocMessages) + 1); | |
437 | pos += strlen(preprocMessages); | |
438 | } | |
439 | if(messages) | |
440 | CopyMemory(pos, messages, strlen(messages) + 1); | |
441 | ||
442 | *ppErrorMsgs = buffer; | |
443 | } | |
444 | ||
445 | HeapFree(GetProcessHeap(), 0, messages); | |
446 | } | |
447 | ||
448 | if(shader == NULL) | |
449 | { | |
450 | ERR("Asm reading failed\n"); | |
451 | return D3DXERR_INVALIDDATA; | |
452 | } | |
453 | ||
454 | hr = SlWriteBytecode(shader, 9, &res); | |
455 | SlDeleteShader(shader); | |
456 | if(FAILED(hr)) | |
457 | { | |
458 | ERR("SlWriteBytecode failed with 0x%08x\n", hr); | |
459 | return D3DXERR_INVALIDDATA; | |
460 | } | |
461 | ||
462 | if(ppShader) | |
463 | { | |
464 | size = HeapSize(GetProcessHeap(), 0, res); | |
465 | hr = D3DCreateBlob(size, &buffer); | |
466 | if(FAILED(hr)) | |
467 | { | |
468 | HeapFree(GetProcessHeap(), 0, res); | |
469 | return hr; | |
470 | } | |
471 | CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size); | |
472 | *ppShader = buffer; | |
473 | } | |
474 | ||
475 | HeapFree(GetProcessHeap(), 0, res); | |
476 | ||
477 | return S_OK; | |
478 | } | |
479 | ||
55043956 MB |
480 | HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename, |
481 | const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags, | |
482 | ID3DBlob **shader, ID3DBlob **error_messages) | |
483 | { | |
5dcb2e4b | 484 | HRESULT hr; |
5dcb2e4b MB |
485 | |
486 | EnterCriticalSection(&wpp_mutex); | |
487 | ||
488 | /* TODO: flags */ | |
55043956 | 489 | if (flags) FIXME("flags %x\n", flags); |
5dcb2e4b | 490 | |
55043956 MB |
491 | if (shader) *shader = NULL; |
492 | if (error_messages) *error_messages = NULL; | |
5dcb2e4b | 493 | |
55043956 MB |
494 | hr = preprocess_shader(data, datasize, defines, include, error_messages); |
495 | if (SUCCEEDED(hr)) | |
496 | hr = assemble_shader(wpp_output, wpp_messages, shader, error_messages); | |
5dcb2e4b | 497 | |
5dcb2e4b MB |
498 | HeapFree(GetProcessHeap(), 0, wpp_output); |
499 | LeaveCriticalSection(&wpp_mutex); | |
500 | return hr; | |
7aa026cc | 501 | } |
390b4803 MB |
502 | |
503 | HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename, | |
504 | const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, | |
505 | const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages) | |
506 | { | |
507 | FIXME("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s,\n" | |
508 | "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p stub!\n", | |
509 | data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint), | |
510 | debugstr_a(target), sflags, eflags, shader, error_messages); | |
511 | ||
512 | TRACE("Shader source:\n%s\n", debugstr_an(data, data_size)); | |
513 | ||
514 | if (error_messages) | |
515 | D3DCreateBlob(1, error_messages); /* zero fill used as string end */ | |
516 | ||
517 | return D3DERR_INVALIDCALL; | |
518 | } | |
55043956 MB |
519 | |
520 | HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename, | |
521 | const D3D_SHADER_MACRO *defines, ID3DInclude *include, | |
522 | ID3DBlob **shader, ID3DBlob **error_messages) | |
523 | { | |
524 | HRESULT hr; | |
525 | ID3DBlob *buffer; | |
526 | ||
527 | if (!data) | |
528 | return E_INVALIDARG; | |
529 | ||
530 | EnterCriticalSection(&wpp_mutex); | |
531 | ||
532 | if (shader) *shader = NULL; | |
533 | if (error_messages) *error_messages = NULL; | |
534 | ||
535 | hr = preprocess_shader(data, size, defines, include, error_messages); | |
536 | ||
537 | if (SUCCEEDED(hr)) | |
538 | { | |
539 | if (shader) | |
540 | { | |
541 | hr = D3DCreateBlob(wpp_output_size, &buffer); | |
542 | if (FAILED(hr)) | |
543 | goto cleanup; | |
544 | CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size); | |
545 | *shader = buffer; | |
546 | } | |
547 | else | |
548 | hr = E_INVALIDARG; | |
549 | } | |
550 | ||
551 | cleanup: | |
552 | HeapFree(GetProcessHeap(), 0, wpp_output); | |
553 | LeaveCriticalSection(&wpp_mutex); | |
554 | return hr; | |
555 | } |