git.oblomov.eu Git - wine/blob - 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
  45 #define INCLUDES_INITIAL_CAPACITY 4
  46
  47 struct loaded_include
  48 {
  49     const char *name;
  50     const char *data;
  51 };
  52
  53 static struct loaded_include *includes;
  54 static int includes_capacity, includes_size;
  55 static const char *parent_include;
  56
  57 static char *wpp_output;
  58 static int wpp_output_capacity, wpp_output_size;
  59
  60 static char *wpp_messages;
  61 static int wpp_messages_capacity, wpp_messages_size;
  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 &current_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         {
 209             includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes));
 210             if(includes == NULL)
 211             {
 212                 ERR("Error allocating memory for the loaded includes structure\n");
 213                 goto error;
 214             }
 215             includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes);
 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 != &current_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';
 309     wpp_output_size++;
 310     return 1;
 311 }
 312
 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", debugstr_a(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
 393 static HRESULT assemble_shader(const char *preproc_shader,
 394         ID3DBlob **shader_blob, ID3DBlob **error_messages)
 395 {
 396     struct bwriter_shader *shader;
 397     char *messages = NULL;
 398     HRESULT hr;
 399     DWORD *res, size;
 400     ID3DBlob *buffer;
 401     char *pos;
 402
 403     shader = SlAssembleShader(preproc_shader, &messages);
 404
 405     if (messages)
 406     {
 407         TRACE("Assembler messages:\n");
 408         TRACE("%s", messages);
 409
 410         TRACE("Shader source:\n");
 411         TRACE("%s\n", debugstr_a(preproc_shader));
 412
 413         if (error_messages)
 414         {
 415             const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 416
 417             size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
 418             hr = D3DCreateBlob(size, &buffer);
 419             if (FAILED(hr))
 420             {
 421                 HeapFree(GetProcessHeap(), 0, messages);
 422                 if (shader) SlDeleteShader(shader);
 423                 return hr;
 424             }
 425             pos = ID3D10Blob_GetBufferPointer(buffer);
 426             if (preproc_messages)
 427             {
 428                 CopyMemory(pos, preproc_messages, strlen(preproc_messages) + 1);
 429                 pos += strlen(preproc_messages);
 430             }
 431             CopyMemory(pos, messages, strlen(messages) + 1);
 432
 433             if (*error_messages) ID3D10Blob_Release(*error_messages);
 434             *error_messages = buffer;
 435         }
 436         HeapFree(GetProcessHeap(), 0, messages);
 437     }
 438
 439     if (shader == NULL)
 440     {
 441         ERR("Asm reading failed\n");
 442         return D3DXERR_INVALIDDATA;
 443     }
 444
 445     hr = SlWriteBytecode(shader, 9, &res, &size);
 446     SlDeleteShader(shader);
 447     if (FAILED(hr))
 448     {
 449         ERR("SlWriteBytecode failed with 0x%08x\n", hr);
 450         return D3DXERR_INVALIDDATA;
 451     }
 452
 453     if (shader_blob)
 454     {
 455         hr = D3DCreateBlob(size, &buffer);
 456         if (FAILED(hr))
 457         {
 458             HeapFree(GetProcessHeap(), 0, res);
 459             return hr;
 460         }
 461         CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size);
 462         *shader_blob = buffer;
 463     }
 464
 465     HeapFree(GetProcessHeap(), 0, res);
 466
 467     return S_OK;
 468 }
 469
 470 HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename,
 471         const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags,
 472         ID3DBlob **shader, ID3DBlob **error_messages)
 473 {
 474     HRESULT hr;
 475
 476     EnterCriticalSection(&wpp_mutex);
 477
 478     /* TODO: flags */
 479     if (flags) FIXME("flags %x\n", flags);
 480
 481     if (shader) *shader = NULL;
 482     if (error_messages) *error_messages = NULL;
 483
 484     hr = preprocess_shader(data, datasize, defines, include, error_messages);
 485     if (SUCCEEDED(hr))
 486         hr = assemble_shader(wpp_output, shader, error_messages);
 487
 488     HeapFree(GetProcessHeap(), 0, wpp_output);
 489     LeaveCriticalSection(&wpp_mutex);
 490     return hr;
 491 }
 492
 493 static HRESULT compile_shader(const char *preproc_shader, const char *target, const char *entrypoint,
 494         ID3DBlob **shader_blob, ID3DBlob **error_messages)
 495 {
 496     struct bwriter_shader *shader;
 497     char *messages = NULL;
 498     HRESULT hr;
 499     DWORD *res, size;
 500     ID3DBlob *buffer;
 501     char *pos;
 502
 503     FIXME("Parse compilation target.\n");
 504     shader = parse_hlsl_shader(preproc_shader, ST_VERTEX, 2, entrypoint, &messages);
 505
 506     if (messages)
 507     {
 508         TRACE("Compiler messages:\n");
 509         TRACE("%s", messages);
 510
 511         TRACE("Shader source:\n");
 512         TRACE("%s\n", debugstr_a(preproc_shader));
 513
 514         if (error_messages)
 515         {
 516             const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 517
 518             size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
 519             hr = D3DCreateBlob(size, &buffer);
 520             if (FAILED(hr))
 521             {
 522                 HeapFree(GetProcessHeap(), 0, messages);
 523                 if (shader) SlDeleteShader(shader);
 524                 return hr;
 525             }
 526             pos = ID3D10Blob_GetBufferPointer(buffer);
 527             if (preproc_messages)
 528             {
 529                 memcpy(pos, preproc_messages, strlen(preproc_messages) + 1);
 530                 pos += strlen(preproc_messages);
 531             }
 532             memcpy(pos, messages, strlen(messages) + 1);
 533
 534             if (*error_messages) ID3D10Blob_Release(*error_messages);
 535             *error_messages = buffer;
 536         }
 537         HeapFree(GetProcessHeap(), 0, messages);
 538     }
 539
 540     if (!shader)
 541     {
 542         ERR("HLSL shader parsing failed.\n");
 543         return D3DXERR_INVALIDDATA;
 544     }
 545
 546     hr = SlWriteBytecode(shader, 9, &res, &size);
 547     SlDeleteShader(shader);
 548     if (FAILED(hr))
 549     {
 550         ERR("SlWriteBytecode failed with error 0x%08x.\n", hr);
 551         return D3DXERR_INVALIDDATA;
 552     }
 553
 554     if (shader_blob)
 555     {
 556         hr = D3DCreateBlob(size, &buffer);
 557         if (FAILED(hr))
 558         {
 559             HeapFree(GetProcessHeap(), 0, res);
 560             return hr;
 561         }
 562         memcpy(ID3D10Blob_GetBufferPointer(buffer), res, size);
 563         *shader_blob = buffer;
 564     }
 565
 566     HeapFree(GetProcessHeap(), 0, res);
 567
 568     return S_OK;
 569 }
 570
 571 HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
 572         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
 573         const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
 574 {
 575     HRESULT hr;
 576
 577     FIXME("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s,\n"
 578             "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p stub!\n",
 579             data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
 580             debugstr_a(target), sflags, eflags, shader, error_messages);
 581
 582     if (shader) *shader = NULL;
 583     if (error_messages) *error_messages = NULL;
 584
 585     EnterCriticalSection(&wpp_mutex);
 586
 587     hr = preprocess_shader(data, data_size, defines, include, error_messages);
 588     if (SUCCEEDED(hr))
 589         hr = compile_shader(wpp_output, target, entrypoint, shader, error_messages);
 590
 591     HeapFree(GetProcessHeap(), 0, wpp_output);
 592     LeaveCriticalSection(&wpp_mutex);
 593     return hr;
 594 }
 595
 596 HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
 597         const D3D_SHADER_MACRO *defines, ID3DInclude *include,
 598         ID3DBlob **shader, ID3DBlob **error_messages)
 599 {
 600     HRESULT hr;
 601     ID3DBlob *buffer;
 602
 603     if (!data)
 604         return E_INVALIDARG;
 605
 606     EnterCriticalSection(&wpp_mutex);
 607
 608     if (shader) *shader = NULL;
 609     if (error_messages) *error_messages = NULL;
 610
 611     hr = preprocess_shader(data, size, defines, include, error_messages);
 612
 613     if (SUCCEEDED(hr))
 614     {
 615         if (shader)
 616         {
 617             hr = D3DCreateBlob(wpp_output_size, &buffer);
 618             if (FAILED(hr))
 619                 goto cleanup;
 620             CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size);
 621             *shader = buffer;
 622         }
 623         else
 624             hr = E_INVALIDARG;
 625     }
 626
 627 cleanup:
 628     HeapFree(GetProcessHeap(), 0, wpp_output);
 629     LeaveCriticalSection(&wpp_mutex);
 630     return hr;
 631 }