dlls/d3dcompiler_43/compiler.c

   1 /*
   2  * Copyright 2009 Matteo Bruni
   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
  20 #define COBJMACROS
  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"
  27 #include "wine/wpp.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
  30
  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
  42 static struct mem_file_desc current_shader;
  43 static ID3DInclude *current_include;
  44 static const char *initial_filename;
  45
  46 #define INCLUDES_INITIAL_CAPACITY 4
  47
  48 struct loaded_include
  49 {
  50     const char *name;
  51     const char *data;
  52 };
  53
  54 static struct loaded_include *includes;
  55 static int includes_capacity, includes_size;
  56 static const char *parent_include;
  57
  58 static char *wpp_output;
  59 static int wpp_output_capacity, wpp_output_size;
  60
  61 static char *wpp_messages;
  62 static int wpp_messages_capacity, wpp_messages_size;
  63
  64 /* Mutex used to guarantee a single invocation
  65    of the D3DXAssembleShader function (or its variants) at a time.
  66    This is needed as wpp isn't thread-safe */
  67 static CRITICAL_SECTION wpp_mutex;
  68 static CRITICAL_SECTION_DEBUG wpp_mutex_debug =
  69 {
  70     0, 0, &wpp_mutex,
  71     { &wpp_mutex_debug.ProcessLocksList,
  72       &wpp_mutex_debug.ProcessLocksList },
  73       0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") }
  74 };
  75 static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 };
  76
  77 /* Preprocessor error reporting functions */
  78 static void wpp_write_message(const char *fmt, va_list args)
  79 {
  80     char* newbuffer;
  81     int rc, newsize;
  82
  83     if(wpp_messages_capacity == 0)
  84     {
  85         wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE);
  86         if(wpp_messages == NULL)
  87             return;
  88
  89         wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE;
  90     }
  91
  92     while(1)
  93     {
  94         rc = vsnprintf(wpp_messages + wpp_messages_size,
  95                        wpp_messages_capacity - wpp_messages_size, fmt, args);
  96
  97         if (rc < 0 ||                                           /* C89 */
  98             rc >= wpp_messages_capacity - wpp_messages_size) {  /* C99 */
  99             /* Resize the buffer */
 100             newsize = wpp_messages_capacity * 2;
 101             newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize);
 102             if(newbuffer == NULL)
 103             {
 104                 ERR("Error reallocating memory for parser messages\n");
 105                 return;
 106             }
 107             wpp_messages = newbuffer;
 108             wpp_messages_capacity = newsize;
 109         }
 110         else
 111         {
 112             wpp_messages_size += rc;
 113             return;
 114         }
 115     }
 116 }
 117
 118 static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...)
 119 {
 120     va_list args;
 121
 122     va_start(args, fmt);
 123     wpp_write_message(fmt, args);
 124     va_end(args);
 125 }
 126
 127 static void wpp_error(const char *file, int line, int col, const char *near,
 128                       const char *msg, va_list ap)
 129 {
 130     wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
 131                           line, col, "Error");
 132     wpp_write_message(msg, ap);
 133     wpp_write_message_var("\n");
 134 }
 135
 136 static void wpp_warning(const char *file, int line, int col, const char *near,
 137                         const char *msg, va_list ap)
 138 {
 139     wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
 140                           line, col, "Warning");
 141     wpp_write_message(msg, ap);
 142     wpp_write_message_var("\n");
 143 }
 144
 145 static char *wpp_lookup_mem(const char *filename, int type, const char *parent_name,
 146                             char **include_path, int include_path_count)
 147 {
 148     /* We don't check for file existence here. We will potentially fail on
 149      * the following wpp_open_mem(). */
 150     char *path;
 151     int i;
 152
 153     TRACE("Looking for include %s, parent %s.\n", debugstr_a(filename), debugstr_a(parent_name));
 154
 155     parent_include = NULL;
 156     if (strcmp(parent_name, initial_filename))
 157     {
 158         for(i = 0; i < includes_size; i++)
 159         {
 160             if(!strcmp(parent_name, includes[i].name))
 161             {
 162                 parent_include = includes[i].data;
 163                 break;
 164             }
 165         }
 166         if(parent_include == NULL)
 167         {
 168             ERR("Parent include %s missing.\n", debugstr_a(parent_name));
 169             return NULL;
 170         }
 171     }
 172
 173     path = malloc(strlen(filename) + 1);
 174     if(path)
 175         memcpy(path, filename, strlen(filename) + 1);
 176     return path;
 177 }
 178
 179 static void *wpp_open_mem(const char *filename, int type)
 180 {
 181     struct mem_file_desc *desc;
 182     HRESULT hr;
 183
 184     TRACE("Opening include %s.\n", debugstr_a(filename));
 185
 186     if(!strcmp(filename, initial_filename))
 187     {
 188         current_shader.pos = 0;
 189         return &current_shader;
 190     }
 191
 192     if(current_include == NULL) return NULL;
 193     desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
 194     if(!desc)
 195         return NULL;
 196
 197     if (FAILED(hr = ID3DInclude_Open(current_include, type ? D3D_INCLUDE_LOCAL : D3D_INCLUDE_SYSTEM,
 198             filename, parent_include, (const void **)&desc->buffer, &desc->size)))
 199     {
 200         HeapFree(GetProcessHeap(), 0, desc);
 201         return NULL;
 202     }
 203
 204     if(includes_capacity == includes_size)
 205     {
 206         if(includes_capacity == 0)
 207         {
 208             includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes));
 209             if(includes == NULL)
 210             {
 211                 ERR("Error allocating memory for the loaded includes structure\n");
 212                 goto error;
 213             }
 214             includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes);
 215         }
 216         else
 217         {
 218             int newcapacity = includes_capacity * 2;
 219             struct loaded_include *newincludes =
 220                 HeapReAlloc(GetProcessHeap(), 0, includes, newcapacity);
 221             if(newincludes == NULL)
 222             {
 223                 ERR("Error reallocating memory for the loaded includes structure\n");
 224                 goto error;
 225             }
 226             includes = newincludes;
 227             includes_capacity = newcapacity;
 228         }
 229     }
 230     includes[includes_size].name = filename;
 231     includes[includes_size++].data = desc->buffer;
 232
 233     desc->pos = 0;
 234     return desc;
 235
 236 error:
 237     ID3DInclude_Close(current_include, desc->buffer);
 238     HeapFree(GetProcessHeap(), 0, desc);
 239     return NULL;
 240 }
 241
 242 static void wpp_close_mem(void *file)
 243 {
 244     struct mem_file_desc *desc = file;
 245
 246     if(desc != &current_shader)
 247     {
 248         if(current_include)
 249             ID3DInclude_Close(current_include, desc->buffer);
 250         else
 251             ERR("current_include == NULL, desc == %p, buffer = %s\n",
 252                 desc, desc->buffer);
 253
 254         HeapFree(GetProcessHeap(), 0, desc);
 255     }
 256 }
 257
 258 static int wpp_read_mem(void *file, char *buffer, unsigned int len)
 259 {
 260     struct mem_file_desc *desc = file;
 261
 262     len = min(len, desc->size - desc->pos);
 263     memcpy(buffer, desc->buffer + desc->pos, len);
 264     desc->pos += len;
 265     return len;
 266 }
 267
 268 static void wpp_write_mem(const char *buffer, unsigned int len)
 269 {
 270     char *new_wpp_output;
 271
 272     if(wpp_output_capacity == 0)
 273     {
 274         wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY);
 275         if(!wpp_output)
 276             return;
 277
 278         wpp_output_capacity = BUFFER_INITIAL_CAPACITY;
 279     }
 280     if(len > wpp_output_capacity - wpp_output_size)
 281     {
 282         while(len > wpp_output_capacity - wpp_output_size)
 283         {
 284             wpp_output_capacity *= 2;
 285         }
 286         new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
 287                                      wpp_output_capacity);
 288         if(!new_wpp_output)
 289         {
 290             ERR("Error allocating memory\n");
 291             return;
 292         }
 293         wpp_output = new_wpp_output;
 294     }
 295     memcpy(wpp_output + wpp_output_size, buffer, len);
 296     wpp_output_size += len;
 297 }
 298
 299 static int wpp_close_output(void)
 300 {
 301     char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
 302                                        wpp_output_size + 1);
 303     if(!new_wpp_output) return 0;
 304     wpp_output = new_wpp_output;
 305     wpp_output[wpp_output_size]='\0';
 306     wpp_output_size++;
 307     return 1;
 308 }
 309
 310 static HRESULT preprocess_shader(const void *data, SIZE_T data_size, const char *filename,
 311         const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **error_messages)
 312 {
 313     int ret;
 314     HRESULT hr = S_OK;
 315     const D3D_SHADER_MACRO *def = defines;
 316
 317     static const struct wpp_callbacks wpp_callbacks =
 318     {
 319         wpp_lookup_mem,
 320         wpp_open_mem,
 321         wpp_close_mem,
 322         wpp_read_mem,
 323         wpp_write_mem,
 324         wpp_error,
 325         wpp_warning,
 326     };
 327
 328     if (def != NULL)
 329     {
 330         while (def->Name != NULL)
 331         {
 332             wpp_add_define(def->Name, def->Definition);
 333             def++;
 334         }
 335     }
 336     current_include = include;
 337     includes_size = 0;
 338
 339     wpp_output_size = wpp_output_capacity = 0;
 340     wpp_output = NULL;
 341
 342     wpp_set_callbacks(&wpp_callbacks);
 343     wpp_messages_size = wpp_messages_capacity = 0;
 344     wpp_messages = NULL;
 345     current_shader.buffer = data;
 346     current_shader.size = data_size;
 347     initial_filename = filename ? filename : "";
 348
 349     ret = wpp_parse(initial_filename, NULL);
 350     if (!wpp_close_output())
 351         ret = 1;
 352     if (ret)
 353     {
 354         TRACE("Error during shader preprocessing\n");
 355         if (wpp_messages)
 356         {
 357             int size;
 358             ID3DBlob *buffer;
 359
 360             TRACE("Preprocessor messages:\n%s\n", debugstr_a(wpp_messages));
 361
 362             if (error_messages)
 363             {
 364                 size = strlen(wpp_messages) + 1;
 365                 hr = D3DCreateBlob(size, &buffer);
 366                 if (FAILED(hr))
 367                     goto cleanup;
 368                 CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_messages, size);
 369                 *error_messages = buffer;
 370             }
 371         }
 372         if (data)
 373             TRACE("Shader source:\n%s\n", debugstr_an(data, data_size));
 374         hr = E_FAIL;
 375     }
 376
 377 cleanup:
 378     /* Remove the previously added defines */
 379     if (defines != NULL)
 380     {
 381         while (defines->Name != NULL)
 382         {
 383             wpp_del_define(defines->Name);
 384             defines++;
 385         }
 386     }
 387     HeapFree(GetProcessHeap(), 0, wpp_messages);
 388     return hr;
 389 }
 390
 391 static HRESULT assemble_shader(const char *preproc_shader,
 392         ID3DBlob **shader_blob, ID3DBlob **error_messages)
 393 {
 394     struct bwriter_shader *shader;
 395     char *messages = NULL;
 396     HRESULT hr;
 397     DWORD *res, size;
 398     ID3DBlob *buffer;
 399     char *pos;
 400
 401     shader = SlAssembleShader(preproc_shader, &messages);
 402
 403     if (messages)
 404     {
 405         TRACE("Assembler messages:\n");
 406         TRACE("%s\n", debugstr_a(messages));
 407
 408         TRACE("Shader source:\n");
 409         TRACE("%s\n", debugstr_a(preproc_shader));
 410
 411         if (error_messages)
 412         {
 413             const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 414
 415             size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
 416             hr = D3DCreateBlob(size, &buffer);
 417             if (FAILED(hr))
 418             {
 419                 HeapFree(GetProcessHeap(), 0, messages);
 420                 if (shader) SlDeleteShader(shader);
 421                 return hr;
 422             }
 423             pos = ID3D10Blob_GetBufferPointer(buffer);
 424             if (preproc_messages)
 425             {
 426                 CopyMemory(pos, preproc_messages, strlen(preproc_messages) + 1);
 427                 pos += strlen(preproc_messages);
 428             }
 429             CopyMemory(pos, messages, strlen(messages) + 1);
 430
 431             if (*error_messages) ID3D10Blob_Release(*error_messages);
 432             *error_messages = buffer;
 433         }
 434         HeapFree(GetProcessHeap(), 0, messages);
 435     }
 436
 437     if (shader == NULL)
 438     {
 439         ERR("Asm reading failed\n");
 440         return D3DXERR_INVALIDDATA;
 441     }
 442
 443     hr = SlWriteBytecode(shader, 9, &res, &size);
 444     SlDeleteShader(shader);
 445     if (FAILED(hr))
 446     {
 447         ERR("SlWriteBytecode failed with 0x%08x\n", hr);
 448         return D3DXERR_INVALIDDATA;
 449     }
 450
 451     if (shader_blob)
 452     {
 453         hr = D3DCreateBlob(size, &buffer);
 454         if (FAILED(hr))
 455         {
 456             HeapFree(GetProcessHeap(), 0, res);
 457             return hr;
 458         }
 459         CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size);
 460         *shader_blob = buffer;
 461     }
 462
 463     HeapFree(GetProcessHeap(), 0, res);
 464
 465     return S_OK;
 466 }
 467
 468 HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename,
 469         const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags,
 470         ID3DBlob **shader, ID3DBlob **error_messages)
 471 {
 472     HRESULT hr;
 473
 474     TRACE("data %p, datasize %lu, filename %s, defines %p, include %p, sflags %#x,\n"
 475             "shader %p, error_messages %p\n",
 476             data, datasize, debugstr_a(filename), defines, include, flags, shader, error_messages);
 477
 478     EnterCriticalSection(&wpp_mutex);
 479
 480     /* TODO: flags */
 481     if (flags) FIXME("flags %x\n", flags);
 482
 483     if (shader) *shader = NULL;
 484     if (error_messages) *error_messages = NULL;
 485
 486     hr = preprocess_shader(data, datasize, filename, defines, include, error_messages);
 487     if (SUCCEEDED(hr))
 488         hr = assemble_shader(wpp_output, shader, error_messages);
 489
 490     HeapFree(GetProcessHeap(), 0, wpp_output);
 491     LeaveCriticalSection(&wpp_mutex);
 492     return hr;
 493 }
 494
 495 struct target_info {
 496     const char *name;
 497     enum shader_type type;
 498     DWORD sm_major;
 499     DWORD sm_minor;
 500     DWORD level_major;
 501     DWORD level_minor;
 502     BOOL sw;
 503     BOOL support;
 504 };
 505
 506 /* Must be kept sorted for binary search */
 507 static const struct target_info targets_info[] = {
 508     { "cs_4_0",            ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
 509     { "cs_4_1",            ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
 510     { "cs_5_0",            ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
 511     { "ds_5_0",            ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
 512     { "fx_2_0",            ST_UNKNOWN, 2, 0, 0, 0, FALSE, FALSE },
 513     { "fx_4_0",            ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
 514     { "fx_4_1",            ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
 515     { "fx_5_0",            ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
 516     { "gs_4_0",            ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
 517     { "gs_4_1",            ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
 518     { "gs_5_0",            ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
 519     { "hs_5_0",            ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
 520     { "ps.1.0",            ST_PIXEL,   1, 0, 0, 0, FALSE, TRUE  },
 521     { "ps.1.1",            ST_PIXEL,   1, 1, 0, 0, FALSE, FALSE },
 522     { "ps.1.2",            ST_PIXEL,   1, 2, 0, 0, FALSE, FALSE },
 523     { "ps.1.3",            ST_PIXEL,   1, 3, 0, 0, FALSE, FALSE },
 524     { "ps.1.4",            ST_PIXEL,   1, 4, 0, 0, FALSE, FALSE },
 525     { "ps.2.0",            ST_PIXEL,   2, 0, 0, 0, FALSE, TRUE  },
 526     { "ps.2.a",            ST_PIXEL,   2, 1, 0, 0, FALSE, FALSE },
 527     { "ps.2.b",            ST_PIXEL,   2, 2, 0, 0, FALSE, FALSE },
 528     { "ps.2.sw",           ST_PIXEL,   2, 0, 0, 0, TRUE,  FALSE },
 529     { "ps.3.0",            ST_PIXEL,   3, 0, 0, 0, FALSE, TRUE  },
 530     { "ps_1_0",            ST_PIXEL,   1, 0, 0, 0, FALSE, TRUE  },
 531     { "ps_1_1",            ST_PIXEL,   1, 1, 0, 0, FALSE, FALSE },
 532     { "ps_1_2",            ST_PIXEL,   1, 2, 0, 0, FALSE, FALSE },
 533     { "ps_1_3",            ST_PIXEL,   1, 3, 0, 0, FALSE, FALSE },
 534     { "ps_1_4",            ST_PIXEL,   1, 4, 0, 0, FALSE, FALSE },
 535     { "ps_2_0",            ST_PIXEL,   2, 0, 0, 0, FALSE, TRUE  },
 536     { "ps_2_a",            ST_PIXEL,   2, 1, 0, 0, FALSE, FALSE },
 537     { "ps_2_b",            ST_PIXEL,   2, 2, 0, 0, FALSE, FALSE },
 538     { "ps_2_sw",           ST_PIXEL,   2, 0, 0, 0, TRUE,  FALSE },
 539     { "ps_3_0",            ST_PIXEL,   3, 0, 0, 0, FALSE, TRUE  },
 540     { "ps_3_sw",           ST_PIXEL,   3, 0, 0, 0, TRUE,  FALSE },
 541     { "ps_4_0",            ST_PIXEL,   4, 0, 0, 0, FALSE, TRUE  },
 542     { "ps_4_0_level_9_0",  ST_PIXEL,   4, 0, 9, 0, FALSE, FALSE },
 543     { "ps_4_0_level_9_1",  ST_PIXEL,   4, 0, 9, 1, FALSE, FALSE },
 544     { "ps_4_0_level_9_3",  ST_PIXEL,   4, 0, 9, 3, FALSE, FALSE },
 545     { "ps_4_1",            ST_PIXEL,   4, 1, 0, 0, FALSE, TRUE  },
 546     { "ps_5_0",            ST_PIXEL,   5, 0, 0, 0, FALSE, TRUE  },
 547     { "tx_1_0",            ST_UNKNOWN, 1, 0, 0, 0, FALSE, FALSE },
 548     { "vs.1.0",            ST_VERTEX,  1, 0, 0, 0, FALSE, TRUE  },
 549     { "vs.1.1",            ST_VERTEX,  1, 1, 0, 0, FALSE, TRUE  },
 550     { "vs.2.0",            ST_VERTEX,  2, 0, 0, 0, FALSE, TRUE  },
 551     { "vs.2.a",            ST_VERTEX,  2, 1, 0, 0, FALSE, FALSE },
 552     { "vs.2.sw",           ST_VERTEX,  2, 0, 0, 0, TRUE,  FALSE },
 553     { "vs.3.0",            ST_VERTEX,  3, 0, 0, 0, FALSE, TRUE  },
 554     { "vs.3.sw",           ST_VERTEX,  3, 0, 0, 0, TRUE,  FALSE },
 555     { "vs_1_0",            ST_VERTEX,  1, 0, 0, 0, FALSE, TRUE  },
 556     { "vs_1_1",            ST_VERTEX,  1, 1, 0, 0, FALSE, TRUE  },
 557     { "vs_2_0",            ST_VERTEX,  2, 0, 0, 0, FALSE, TRUE  },
 558     { "vs_2_a",            ST_VERTEX,  2, 1, 0, 0, FALSE, FALSE },
 559     { "vs_2_sw",           ST_VERTEX,  2, 0, 0, 0, TRUE,  FALSE },
 560     { "vs_3_0",            ST_VERTEX,  3, 0, 0, 0, FALSE, TRUE  },
 561     { "vs_3_sw",           ST_VERTEX,  3, 0, 0, 0, TRUE,  FALSE },
 562     { "vs_4_0",            ST_VERTEX,  4, 0, 0, 0, FALSE, TRUE  },
 563     { "vs_4_0_level_9_0",  ST_VERTEX,  4, 0, 9, 0, FALSE, FALSE },
 564     { "vs_4_0_level_9_1",  ST_VERTEX,  4, 0, 9, 1, FALSE, FALSE },
 565     { "vs_4_0_level_9_3",  ST_VERTEX,  4, 0, 9, 3, FALSE, FALSE },
 566     { "vs_4_1",            ST_VERTEX,  4, 1, 0, 0, FALSE, TRUE  },
 567     { "vs_5_0",            ST_VERTEX,  5, 0, 0, 0, FALSE, TRUE  },
 568 };
 569
 570 static const struct target_info * get_target_info(const char *target)
 571 {
 572     LONG min = 0;
 573     LONG max = sizeof(targets_info) / sizeof(targets_info[0]) - 1;
 574     LONG cur;
 575     int res;
 576
 577     while (min <= max)
 578     {
 579         cur = (min + max) / 2;
 580         res = strcmp(target, targets_info[cur].name);
 581         if (res < 0)
 582             max = cur - 1;
 583         else if (res > 0)
 584             min = cur + 1;
 585         else
 586             return &targets_info[cur];
 587     }
 588
 589     return NULL;
 590 }
 591
 592 static HRESULT compile_shader(const char *preproc_shader, const char *target, const char *entrypoint,
 593         ID3DBlob **shader_blob, ID3DBlob **error_messages)
 594 {
 595     struct bwriter_shader *shader;
 596     char *messages = NULL;
 597     HRESULT hr;
 598     DWORD *res, size, major, minor;
 599     ID3DBlob *buffer;
 600     char *pos;
 601     enum shader_type shader_type;
 602     const struct target_info *info;
 603
 604     TRACE("Preprocessed shader source: %s\n", debugstr_a(preproc_shader));
 605
 606     TRACE("Checking compilation target %s\n", debugstr_a(target));
 607     info = get_target_info(target);
 608     if (!info)
 609     {
 610         FIXME("Unknown compilation target %s\n", debugstr_a(target));
 611         return D3DERR_INVALIDCALL;
 612     }
 613     else
 614     {
 615         if (!info->support)
 616         {
 617             FIXME("Compilation target %s not yet supported\n", debugstr_a(target));
 618             return D3DERR_INVALIDCALL;
 619         }
 620         else
 621         {
 622             shader_type = info->type;
 623             major = info->sm_major;
 624             minor = info->sm_minor;
 625         }
 626     }
 627
 628     shader = parse_hlsl_shader(preproc_shader, shader_type, major, minor, entrypoint, &messages);
 629
 630     if (messages)
 631     {
 632         TRACE("Compiler messages:\n");
 633         TRACE("%s\n", debugstr_a(messages));
 634
 635         TRACE("Shader source:\n");
 636         TRACE("%s\n", debugstr_a(preproc_shader));
 637
 638         if (error_messages)
 639         {
 640             const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 641
 642             size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
 643             hr = D3DCreateBlob(size, &buffer);
 644             if (FAILED(hr))
 645             {
 646                 HeapFree(GetProcessHeap(), 0, messages);
 647                 if (shader) SlDeleteShader(shader);
 648                 return hr;
 649             }
 650             pos = ID3D10Blob_GetBufferPointer(buffer);
 651             if (preproc_messages)
 652             {
 653                 memcpy(pos, preproc_messages, strlen(preproc_messages) + 1);
 654                 pos += strlen(preproc_messages);
 655             }
 656             memcpy(pos, messages, strlen(messages) + 1);
 657
 658             if (*error_messages) ID3D10Blob_Release(*error_messages);
 659             *error_messages = buffer;
 660         }
 661         HeapFree(GetProcessHeap(), 0, messages);
 662     }
 663
 664     if (!shader)
 665     {
 666         ERR("HLSL shader parsing failed.\n");
 667         return D3DXERR_INVALIDDATA;
 668     }
 669
 670     hr = SlWriteBytecode(shader, 9, &res, &size);
 671     SlDeleteShader(shader);
 672     if (FAILED(hr))
 673     {
 674         ERR("SlWriteBytecode failed with error 0x%08x.\n", hr);
 675         return D3DXERR_INVALIDDATA;
 676     }
 677
 678     if (shader_blob)
 679     {
 680         hr = D3DCreateBlob(size, &buffer);
 681         if (FAILED(hr))
 682         {
 683             HeapFree(GetProcessHeap(), 0, res);
 684             return hr;
 685         }
 686         memcpy(ID3D10Blob_GetBufferPointer(buffer), res, size);
 687         *shader_blob = buffer;
 688     }
 689
 690     HeapFree(GetProcessHeap(), 0, res);
 691
 692     return S_OK;
 693 }
 694
 695 HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
 696         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
 697         const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
 698 {
 699     HRESULT hr;
 700
 701     TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s,\n"
 702             "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p\n",
 703             data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
 704             debugstr_a(target), sflags, eflags, shader, error_messages);
 705
 706     if (shader) *shader = NULL;
 707     if (error_messages) *error_messages = NULL;
 708
 709     EnterCriticalSection(&wpp_mutex);
 710
 711     hr = preprocess_shader(data, data_size, filename, defines, include, error_messages);
 712     if (SUCCEEDED(hr))
 713         hr = compile_shader(wpp_output, target, entrypoint, shader, error_messages);
 714
 715     HeapFree(GetProcessHeap(), 0, wpp_output);
 716     LeaveCriticalSection(&wpp_mutex);
 717     return hr;
 718 }
 719
 720 HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
 721         const D3D_SHADER_MACRO *defines, ID3DInclude *include,
 722         ID3DBlob **shader, ID3DBlob **error_messages)
 723 {
 724     HRESULT hr;
 725     ID3DBlob *buffer;
 726
 727     TRACE("data %p, size %lu, filename %s, defines %p, include %p, shader %p, error_messages %p\n",
 728           data, size, debugstr_a(filename), defines, include, shader, error_messages);
 729
 730     if (!data)
 731         return E_INVALIDARG;
 732
 733     EnterCriticalSection(&wpp_mutex);
 734
 735     if (shader) *shader = NULL;
 736     if (error_messages) *error_messages = NULL;
 737
 738     hr = preprocess_shader(data, size, filename, defines, include, error_messages);
 739
 740     if (SUCCEEDED(hr))
 741     {
 742         if (shader)
 743         {
 744             hr = D3DCreateBlob(wpp_output_size, &buffer);
 745             if (FAILED(hr))
 746                 goto cleanup;
 747             CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size);
 748             *shader = buffer;
 749         }
 750         else
 751             hr = E_INVALIDARG;
 752     }
 753
 754 cleanup:
 755     HeapFree(GetProcessHeap(), 0, wpp_output);
 756     LeaveCriticalSection(&wpp_mutex);
 757     return hr;
 758 }
 759
 760 HRESULT WINAPI D3DDisassemble(const void *data, SIZE_T size, UINT flags, const char *comments, ID3DBlob **disassembly)
 761 {
 762     FIXME("data %p, size %lu, flags %#x, comments %p, disassembly %p stub!\n",
 763             data, size, flags, comments, disassembly);
 764     return E_NOTIMPL;
 765 }