/
mojoshader.c
2684 lines (2214 loc) · 78.8 KB
1
/**
2
3
* MojoShader; generate shader programs from bytecode of compiled
* Direct3D shaders.
4
5
6
7
8
9
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
10
11
// !!! FIXME: I keep changing coding styles for symbols and typedefs.
12
13
14
// !!! FIXME: do DEF* and DCL_* opcodes have to come before instructions?
// !!! FIXME: my reading of the msdn spec suggests no.
15
16
17
// Shader bytecode format is described at MSDN:
// http://msdn2.microsoft.com/en-us/library/ms800307.aspx
18
#include <stdio.h>
19
#include <string.h>
20
#include <stdlib.h>
21
#include <stdint.h>
22
#include <stdarg.h>
23
#include <assert.h>
24
25
#include "mojoshader.h"
26
27
28
29
30
31
// This is the highest shader version we currently support.
#define MAX_SHADER_MAJOR 3
#define MAX_SHADER_MINOR 0
32
33
34
// You get all the profiles unless you go out of your way to disable them.
35
36
37
38
39
40
41
42
#ifndef SUPPORT_PROFILE_D3D
#define SUPPORT_PROFILE_D3D 1
#endif
#ifndef SUPPORT_PROFILE_GLSL
#define SUPPORT_PROFILE_GLSL 1
#endif
43
44
45
46
47
48
// Get basic wankery out of the way here...
typedef unsigned int uint; // this is a printf() helper. don't use for code.
typedef uint8_t uint8;
typedef uint32_t uint32;
49
typedef int32_t int32;
50
51
52
53
54
55
56
#ifdef __GNUC__
#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))
#else
#define ISPRINTF(x,y)
#endif
57
58
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
59
60
61
62
63
64
65
#ifdef _WINDOWS // !!! FIXME: bleh
const char *endline_str = "\r\n";
#else
const char *endline_str = "\n";
#endif
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// Byteswap magic...
#if ((defined __GNUC__) && (defined __POWERPC__))
static inline uint32 SWAP32(uint32 x)
{
__asm__ __volatile__("lwbrx %0,0,%1" : "=r" (x) : "r" (&x));
return x;
} // SWAP32
#elif defined(__POWERPC__)
static inline uint32 SWAP32(uint32 x)
{
return ( (((x) >> 24) & 0x000000FF) | (((x) >> 8) & 0x0000FF00) |
(((x) << 8) & 0x00FF0000) | (((x) << 24) & 0xFF000000) );
} // SWAP32
#else
# define SWAP32(x) (x)
#endif
85
86
// predeclare.
87
typedef struct Context Context;
88
89
// one emit function for each opcode in each profile.
90
typedef void (*emit_function)(Context *ctx);
91
92
// one emit function for comments in each profile.
93
typedef void (*emit_comment)(Context *ctx, const char *str);
94
95
// one emit function for starting output in each profile.
96
typedef void (*emit_start)(Context *ctx);
97
98
// one emit function for ending output in each profile.
99
typedef void (*emit_end)(Context *ctx);
100
101
102
103
// one args function for each possible sequence of opcode arguments.
typedef int (*args_function)(Context *ctx);
104
// one state function for each opcode where we have state machine updates.
105
typedef void (*state_function)(Context *ctx);
106
107
108
109
110
111
112
typedef struct
{
const char *name;
emit_start start_emitter;
emit_end end_emitter;
emit_comment comment_emitter;
113
} Profile;
114
115
typedef MOJOSHADER_shaderType ShaderType;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
typedef enum
{
REGISTER_TYPE_TEMP = 0,
REGISTER_TYPE_INPUT = 1,
REGISTER_TYPE_CONST = 2,
REGISTER_TYPE_ADDR = 3,
REGISTER_TYPE_TEXTURE = 3, // ALSO 3!
REGISTER_TYPE_RASTOUT = 4,
REGISTER_TYPE_ATTROUT = 5,
REGISTER_TYPE_TEXCRDOUT = 6,
REGISTER_TYPE_OUTPUT = 6, // ALSO 6!
REGISTER_TYPE_CONSTINT = 7,
REGISTER_TYPE_COLOROUT = 8,
REGISTER_TYPE_DEPTHOUT = 9,
REGISTER_TYPE_SAMPLER = 10,
REGISTER_TYPE_CONST2 = 11,
REGISTER_TYPE_CONST3 = 12,
REGISTER_TYPE_CONST4 = 13,
REGISTER_TYPE_CONSTBOOL = 14,
REGISTER_TYPE_LOOP = 15,
REGISTER_TYPE_TEMPFLOAT16 = 16,
REGISTER_TYPE_MISCTYPE = 17,
REGISTER_TYPE_LABEL = 18,
REGISTER_TYPE_PREDICATE = 19,
REGISTER_TYPE_MAX = 19
142
} RegisterType;
143
144
145
146
147
148
149
typedef enum
{
RASTOUT_TYPE_POSITION = 0,
RASTOUT_TYPE_FOG = 1,
RASTOUT_TYPE_POINT_SIZE = 2,
RASTOUT_TYPE_MAX = 2
150
} RastOutType;
151
152
153
154
155
156
typedef enum
{
MISCTYPE_TYPE_POSITION = 0,
MISCTYPE_TYPE_FACE = 1,
MISCTYPE_TYPE_MAX = 1
157
} MiscTypeType;
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
typedef enum
{
DECLUSAGE_POSITION = 0,
DECLUSAGE_BLENDWEIGHT = 1,
DECLUSAGE_BLENDINDICES = 2,
DECLUSAGE_NORMAL = 3,
DECLUSAGE_PSIZE = 4,
DECLUSAGE_TEXCOORD = 5,
DECLUSAGE_TANGENT = 6,
DECLUSAGE_BINORMAL = 7,
DECLUSAGE_TESSFACTOR = 8,
DECLUSAGE_POSITIONT = 9,
DECLUSAGE_COLOR = 10,
DECLUSAGE_FOG = 11,
DECLUSAGE_DEPTH = 12,
DECLUSAGE_SAMPLE = 13
175
} DeclUsageType;
176
177
178
179
180
181
typedef enum
{
TEXTURE_TYPE_2D = 2,
TEXTURE_TYPE_CUBE = 3,
TEXTURE_TYPE_VOLUME = 4,
182
} TextureType;
183
184
185
186
187
188
189
190
191
192
193
// A simple linked list of strings, so we can build the final output without
// realloc()ing for each new line, and easily insert lines into the middle
// of the output without much trouble.
typedef struct OutputList
{
char *str;
struct OutputList *next;
} OutputList;
194
195
196
197
198
199
// result modifiers.
#define MOD_SATURATE 0x01
#define MOD_PP 0x02
#define MOD_CENTROID 0x04
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
// source modifiers.
typedef enum
{
SRCMOD_NONE,
SRCMOD_NEGATE,
SRCMOD_BIAS,
SRCMOD_BIASNEGATE,
SRCMOD_SIGN,
SRCMOD_SIGNNEGATE,
SRCMOD_COMPLEMENT,
SRCMOD_X2,
SRCMOD_X2NEGATE,
SRCMOD_DZ,
SRCMOD_DW,
SRCMOD_ABS,
SRCMOD_ABSNEGATE,
SRCMOD_NOT,
SRCMOD_TOTAL
218
} SourceMod;
219
220
221
222
typedef struct
{
223
const uint32 *token; // this is the unmolested token in the stream.
224
225
int regnum;
int relative;
226
227
228
229
230
int writemask; // xyzw or rgba (all four, not split out).
int writemask0; // x or red
int writemask1; // y or green
int writemask2; // z or blue
int writemask3; // w or alpha
231
232
233
234
235
236
237
int result_mod;
int result_shift;
int regtype;
} DestArgInfo;
typedef struct
{
238
const uint32 *token; // this is the unmolested token in the stream.
239
240
int regnum;
int relative;
241
int swizzle; // xyzw (all four, not split out).
242
243
244
245
246
247
248
249
250
int swizzle_x;
int swizzle_y;
int swizzle_z;
int swizzle_w;
int src_mod;
int regtype;
} SourceArgInfo;
251
252
#define SCRATCH_BUFFER_SIZE 256
#define SCRATCH_BUFFERS 10
253
254
// Context...this is state that changes as we parse through a shader...
255
struct Context
256
{
257
258
MOJOSHADER_malloc malloc;
MOJOSHADER_free free;
259
260
const uint32 *tokens;
uint32 tokencount;
261
262
263
OutputList output;
OutputList *output_tail;
int output_len; // total strlen; prevents walking the list just to malloc.
264
int indent;
265
266
267
const char *endline;
int endline_len;
const char *failstr;
268
char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];
269
270
int scratchidx; // current scratch buffer.
int profileid;
271
272
const Profile *profile;
ShaderType shader_type;
273
274
uint8 major_ver;
uint8 minor_ver;
275
276
DestArgInfo dest_args[1];
SourceArgInfo source_args[4];
277
uint32 dwords[4];
278
int instruction_count;
279
uint32 instruction_controls;
280
281
282
};
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
// Shader model version magic.
static inline uint32 ver_ui32(const uint8 major, const uint8 minor)
{
return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 0 : (minor)) );
} // version_ui32
static int shader_version_supported(uint8 maj, uint8 min)
{
return (ver_ui32(maj,min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR));
} // shader_version_supported
static int shader_version_atleast(const Context *ctx, uint8 maj, uint8 min)
{
return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min));
} // shader_version_atleast
301
static inline char *get_scratch_buffer(Context *ctx)
302
{
303
ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS;
304
return ctx->scratch[ctx->scratchidx];
305
306
} // get_scratch_buffer
307
308
309
// Special-case return values from the parsing pipeline...
#define FAIL (-1)
310
311
#define NOFAIL (-2)
#define END_OF_STREAM (-3)
312
313
static inline int isfail(const Context *ctx)
314
315
316
317
318
{
return (ctx->failstr != NULL);
} // isfail
319
320
321
322
323
static MOJOSHADER_parseData out_of_mem_data = {
"Out of memory", 0, 0, 0, MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0
};
static const char *out_of_mem_str = "Out of memory";
324
325
326
static inline int out_of_memory(Context *ctx)
{
if (ctx->failstr == NULL)
327
ctx->failstr = out_of_mem_str; // fail() would call malloc().
328
329
330
331
332
333
return FAIL;
} // out_of_memory
static int failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int failf(Context *ctx, const char *fmt, ...)
334
{
335
336
if (ctx->failstr == NULL) // don't change existing error.
{
337
char *scratch = get_scratch_buffer(ctx);
338
339
va_list ap;
va_start(ap, fmt);
340
const int len = vsnprintf(scratch,SCRATCH_BUFFER_SIZE,fmt,ap);
341
342
va_end(ap);
343
344
345
346
347
348
char *failstr = (char *) ctx->malloc(len + 1);
if (failstr == NULL)
out_of_memory(ctx);
else
{
// see comments about scratch buffer overflow in output_line().
349
if (len < SCRATCH_BUFFER_SIZE)
350
351
352
353
354
355
356
357
358
strcpy(failstr, scratch); // copy it over.
else
{
va_start(ap, fmt);
vsnprintf(failstr, len + 1, fmt, ap); // rebuild it.
va_end(ap);
} // else
ctx->failstr = failstr;
} // else
359
360
361
362
363
364
} // if
return FAIL;
} // failf
365
static inline int fail(Context *ctx, const char *reason)
366
367
368
369
370
{
return failf(ctx, "%s", reason);
} // fail
371
372
static int output_line(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int output_line(Context *ctx, const char *fmt, ...)
373
{
374
if (isfail(ctx))
375
376
return FAIL; // we failed previously, don't go on...
377
378
379
380
381
OutputList *item = (OutputList *) ctx->malloc(sizeof (OutputList));
if (item == NULL)
return out_of_memory(ctx);
char *scratch = get_scratch_buffer(ctx);
382
383
const int indent = ctx->indent;
384
385
if (indent > 0)
memset(scratch, '\t', indent);
386
387
va_list ap;
va_start(ap, fmt);
388
const int len = vsnprintf(scratch+indent, SCRATCH_BUFFER_SIZE-indent, fmt, ap) + indent;
389
390
va_end(ap);
391
392
item->str = (char *) ctx->malloc(len + 1);
if (item->str == NULL)
393
{
394
395
free(item);
return out_of_memory(ctx);
396
397
} // if
398
399
400
// If we overflowed our scratch buffer, that's okay. We were going to
// allocate anyhow...the scratch buffer just lets us avoid a second
// run of vsnprintf().
401
if (len < SCRATCH_BUFFER_SIZE)
402
403
404
strcpy(item->str, scratch); // copy it over.
else
{
405
406
if (indent > 0)
memset(item->str, '\t', indent);
407
va_start(ap, fmt);
408
vsnprintf(item->str+indent, len + 1, fmt, ap); // rebuild it.
409
410
va_end(ap);
} // else
411
412
413
414
415
item->next = NULL;
ctx->output_tail->next = item;
ctx->output_tail = item;
ctx->output_len += len + ctx->endline_len;
416
417
418
419
return 0;
} // output_line
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
// !!! FIXME: this is sort of nasty.
static void floatstr(Context *ctx, char *buf, size_t bufsize, float f)
{
const size_t len = snprintf(buf, bufsize, "%f", f);
if (len >= bufsize)
fail(ctx, "BUG: internal buffer is too small");
else
{
char *end = buf + len;
char *ptr = strchr(buf, '.');
if (ptr == NULL)
return; // done.
while (--end != ptr)
{
if (*end != '0')
{
end++;
break;
} // if
} // while
*end = '\0'; // chop extra '0' or all decimal places off.
} // else
} // floatstr
445
446
// if SUPPORT_PROFILE_* isn't defined, we assume an implicit desire to support.
447
448
449
450
451
452
453
454
455
#define AT_LEAST_ONE_PROFILE 0
#if !SUPPORT_PROFILE_D3D
#define PROFILE_EMITTER_D3D(op)
#else
#undef AT_LEAST_ONE_PROFILE
#define AT_LEAST_ONE_PROFILE 1
#define PROFILE_EMITTER_D3D(op) emit_D3D_##op,
456
static const char *get_D3D_register_string(Context *ctx,
457
RegisterType regtype,
458
459
int regnum, char *regnum_str,
size_t regnum_size)
460
{
461
const char *retval = NULL;
462
int has_number = 1;
463
464
switch (regtype)
465
466
{
case REGISTER_TYPE_TEMP:
467
retval = "r";
468
469
470
break;
case REGISTER_TYPE_INPUT:
471
retval = "v";
472
473
474
break;
case REGISTER_TYPE_CONST:
475
476
477
retval = "c";
break;
478
case REGISTER_TYPE_CONST2:
479
480
481
482
retval = "c";
regnum += 2048;
break;
483
case REGISTER_TYPE_CONST3:
484
485
486
487
retval = "c";
regnum += 4096;
break;
488
case REGISTER_TYPE_CONST4:
489
retval = "c";
490
regnum += 6144;
491
492
493
break;
case REGISTER_TYPE_ADDR: // (or REGISTER_TYPE_TEXTURE, same value.)
494
retval = (ctx->shader_type == MOJOSHADER_TYPE_VERTEX) ? "a" : "t";
495
496
497
break;
case REGISTER_TYPE_RASTOUT:
498
switch ((RastOutType) regnum)
499
{
500
501
502
case RASTOUT_TYPE_POSITION: retval = "oPos"; break;
case RASTOUT_TYPE_FOG: retval = "oFog"; break;
case RASTOUT_TYPE_POINT_SIZE: retval = "oPts"; break;
503
} // switch
504
has_number = 0;
505
506
507
break;
case REGISTER_TYPE_ATTROUT:
508
retval = "oD";
509
510
511
break;
case REGISTER_TYPE_TEXCRDOUT: // (or REGISTER_TYPE_OUTPUT, same value.)
512
if ((ctx->shader_type==MOJOSHADER_TYPE_VERTEX) && (ctx->major_ver>=3))
513
retval = "o";
514
else
515
retval = "oT";
516
517
518
break;
case REGISTER_TYPE_CONSTINT:
519
retval = "i";
520
521
522
break;
case REGISTER_TYPE_COLOROUT:
523
retval = "oC";
524
525
526
break;
case REGISTER_TYPE_DEPTHOUT:
527
retval = "oDepth";
528
has_number = 0;
529
530
531
break;
case REGISTER_TYPE_SAMPLER:
532
retval = "s";
533
534
535
break;
case REGISTER_TYPE_CONSTBOOL:
536
retval = "b";
537
538
539
break;
case REGISTER_TYPE_LOOP:
540
retval = "aL";
541
has_number = 0;
542
543
544
break;
// !!! FIXME: don't know what the asm string is for this..
545
546
547
548
case REGISTER_TYPE_TEMPFLOAT16:
retval = "???";
has_number = 0;
break;
549
550
case REGISTER_TYPE_MISCTYPE:
551
switch ((MiscTypeType) regnum)
552
{
553
554
case MISCTYPE_TYPE_POSITION: retval = "vPos"; break;
case MISCTYPE_TYPE_FACE: retval = "vFace"; break;
555
} // switch
556
has_number = 0;
557
558
559
break;
case REGISTER_TYPE_LABEL:
560
retval = "l";
561
562
563
break;
case REGISTER_TYPE_PREDICATE:
564
retval = "p";
565
566
567
break;
} // switch
568
569
570
571
572
if (has_number)
snprintf(regnum_str, regnum_size, "%u", (uint) regnum);
else
regnum_str[0] = '\0';
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
return retval;
} // get_D3D_register_string
static char *make_D3D_destarg_string(Context *ctx, const int idx)
{
if (idx >= STATICARRAYLEN(ctx->dest_args))
{
fail(ctx, "Too many destination args");
return "";
} // if
const DestArgInfo *arg = &ctx->dest_args[idx];
const char *result_shift_str = "";
switch (arg->result_shift)
{
case 0x1: result_shift_str = "_x2"; break;
case 0x2: result_shift_str = "_x4"; break;
case 0x3: result_shift_str = "_x8"; break;
case 0xD: result_shift_str = "_d8"; break;
case 0xE: result_shift_str = "_d4"; break;
case 0xF: result_shift_str = "_d2"; break;
} // switch
const char *sat_str = (arg->result_mod & MOD_SATURATE) ? "_sat" : "";
const char *pp_str = (arg->result_mod & MOD_PP) ? "_pp" : "";
const char *cent_str = (arg->result_mod & MOD_CENTROID) ? "_centroid" : "";
char regnum_str[16];
const char *regtype_str = get_D3D_register_string(ctx,
604
(RegisterType) arg->regtype,
605
606
arg->regnum, regnum_str,
sizeof (regnum_str));
607
608
609
610
611
612
if (regtype_str == NULL)
{
fail(ctx, "Unknown destination register type.");
return "";
} // if
613
614
615
616
617
618
619
620
621
622
623
624
char writemask_str[6];
int i = 0;
if (arg->writemask != 0xF) // 0xF == 1111. No explicit mask.
{
writemask_str[i++] = '.';
if (arg->writemask0) writemask_str[i++] = 'x';
if (arg->writemask1) writemask_str[i++] = 'y';
if (arg->writemask2) writemask_str[i++] = 'z';
if (arg->writemask3) writemask_str[i++] = 'w';
} // if
writemask_str[i] = '\0';
assert(i < sizeof (writemask_str));
625
626
627
// may turn out something like "_x2_sat_pp_centroid r0.xyzw" ...
char *retval = get_scratch_buffer(ctx);
628
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s %s%s%s",
629
result_shift_str, sat_str, pp_str, cent_str,
630
regtype_str, regnum_str, writemask_str);
631
return retval;
632
} // make_D3D_destarg_string
633
634
635
static char *make_D3D_sourcearg_string(Context *ctx, const int idx)
636
{
637
638
639
if (idx >= STATICARRAYLEN(ctx->source_args))
{
fail(ctx, "Too many source args");
640
return "";
641
} // if
642
643
644
645
646
const SourceArgInfo *arg = &ctx->source_args[idx];
const char *premod_str = "";
const char *postmod_str = "";
647
switch ((SourceMod) arg->src_mod)
648
649
650
651
652
653
654
655
656
657
658
{
case SRCMOD_NEGATE:
premod_str = "-";
break;
case SRCMOD_BIASNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_BIAS:
postmod_str = "_bias";
break;
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
case SRCMOD_SIGNNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_SIGN:
postmod_str = "_bx2";
break;
case SRCMOD_COMPLEMENT:
premod_str = "1-";
break;
case SRCMOD_X2NEGATE:
premod_str = "-";
// fall through.
case SRCMOD_X2:
postmod_str = "_x2";
break;
case SRCMOD_DZ:
postmod_str = "_dz";
break;
case SRCMOD_DW:
postmod_str = "_dw";
break;
case SRCMOD_ABSNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_ABS:
postmod_str = "_abs";
break;
case SRCMOD_NOT:
premod_str = "!";
break;
696
697
698
699
case SRCMOD_NONE:
case SRCMOD_TOTAL:
break; // stop compiler whining.
700
701
702
703
704
} // switch
char regnum_str[16];
const char *regtype_str = get_D3D_register_string(ctx,
705
(RegisterType) arg->regtype,
706
707
708
709
710
711
712
713
714
715
716
arg->regnum, regnum_str,
sizeof (regnum_str));
if (regtype_str == NULL)
{
fail(ctx, "Unknown source register type.");
return "";
} // if
char swizzle_str[6];
int i = 0;
717
if (arg->swizzle != 0xE4) // 0xE4 == 11100100 ... 3 2 1 0. No swizzle.
718
719
720
{
static const char channel[] = { 'x', 'y', 'z', 'w' };
swizzle_str[i++] = '.';
721
722
723
724
725
726
727
728
swizzle_str[i++] = channel[arg->swizzle_x];
swizzle_str[i++] = channel[arg->swizzle_y];
swizzle_str[i++] = channel[arg->swizzle_z];
swizzle_str[i++] = channel[arg->swizzle_w];
// .xyzz is the same as .xyz, .z is the same as .zzzz, etc.
while (swizzle_str[i-1] == swizzle_str[i-2])
i--;
729
730
731
732
733
} // if
swizzle_str[i] = '\0';
assert(i < sizeof (swizzle_str));
char *retval = get_scratch_buffer(ctx);
734
735
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s%s",
premod_str, regtype_str, regnum_str, postmod_str, swizzle_str);
736
return retval;
737
} // make_D3D_sourcearg_string
738
739
740
static void emit_D3D_start(Context *ctx)
741
742
743
{
const uint major = (uint) ctx->major_ver;
const uint minor = (uint) ctx->minor_ver;
744
745
746
747
748
749
750
751
752
const char *shadertype_str = NULL;
char minor_str[16];
if (minor == 0xFF)
strcpy(minor_str, "sw");
else if (minor == 0x1) // apparently this is "vs_2_x". Weird.
strcpy(minor_str, "x");
else
snprintf(minor_str, sizeof (minor_str), "%u", (uint) minor);
753
754
if (ctx->shader_type == MOJOSHADER_TYPE_PIXEL)
755
shadertype_str = "ps";
756
else if (ctx->shader_type == MOJOSHADER_TYPE_VERTEX)
757
shadertype_str = "vs";
758
else
759
760
761
{
failf(ctx, "Shader type %u unsupported in this profile.",
(uint) ctx->shader_type);
762
return;
763
} // else
764
765
output_line(ctx, "%s_%u_%s", shadertype_str, major, minor_str);
766
767
} // emit_D3D_start
768
769
static void emit_D3D_end(Context *ctx)
770
{
771
output_line(ctx, "end");
772
} // emit_D3D_end
773
774
775
static void emit_D3D_comment(Context *ctx, const char *str)
776
{
777
778
output_line(ctx, "; %s", str);
} // emit_D3D_comment
779
780
781
static void emit_D3D_RESERVED(Context *ctx)
782
{
783
784
785
// do nothing; fails in the state machine.
} // emit_D3D_RESERVED
786
787
788
789
// Generic D3D opcode emitters. A list of macros generate all the entry points
// that call into these...
790
791
792
793
794
795
796
797
798
799
800
801
static char *lowercase(char *dst, const char *src)
{
int i = 0;
do
{
const char ch = src[i];
dst[i] = (((ch >= 'A') && (ch <= 'Z')) ? (ch - ('A' - 'a')) : ch);
} while (src[i++]);
return dst;
} // lowercase
802
static void emit_D3D_opcode_d(Context *ctx, const char *opcode)
803
{
804
const char *dst0 = make_D3D_destarg_string(ctx, 0);
805
opcode = lowercase(get_scratch_buffer(ctx), opcode);
806
output_line(ctx, "%s%s", opcode, dst0);
807
808
809
} // emit_D3D_opcode_d
810
static void emit_D3D_opcode_s(Context *ctx, const char *opcode)
811
{
812
const char *src0 = make_D3D_destarg_string(ctx, 0);
813
opcode = lowercase(get_scratch_buffer(ctx), opcode);
814
output_line(ctx, "%s %s", opcode, src0);
815
816
817
} // emit_D3D_opcode_s
818
static void emit_D3D_opcode_ss(Context *ctx, const char *opcode)
819
{
820
821
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
822
opcode = lowercase(get_scratch_buffer(ctx), opcode);
823
output_line(ctx, "%s %s, %s", opcode, src0, src1);
824
} // emit_D3D_opcode_ss
825
826
827
static void emit_D3D_opcode_ds(Context *ctx, const char *opcode)
828
{
829
830
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
831
opcode = lowercase(get_scratch_buffer(ctx), opcode);
832
output_line(ctx, "%s%s, %s", opcode, dst0, src0);
833
834
835
} // emit_D3D_opcode_ds
836
static void emit_D3D_opcode_dss(Context *ctx, const char *opcode)
837
{
838
839
840
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
841
opcode = lowercase(get_scratch_buffer(ctx), opcode);
842
output_line(ctx, "%s%s, %s, %s", opcode, dst0, src0, src1);
843
844
845
} // emit_D3D_opcode_dss
846
static void emit_D3D_opcode_dsss(Context *ctx, const char *opcode)
847
{
848
849
850
851
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
const char *src2 = make_D3D_sourcearg_string(ctx, 2);
852
opcode = lowercase(get_scratch_buffer(ctx), opcode);
853
output_line(ctx, "%s%s, %s, %s, %s", opcode, dst0, src0, src1, src2);
854
855
856
} // emit_D3D_opcode_dsss
857
static void emit_D3D_opcode_dssss(Context *ctx, const char *opcode)
858
{
859
860
861
862
863
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
const char *src2 = make_D3D_sourcearg_string(ctx, 2);
const char *src3 = make_D3D_sourcearg_string(ctx, 3);
864
opcode = lowercase(get_scratch_buffer(ctx), opcode);
865
output_line(ctx,"%s%s, %s, %s, %s, %s",opcode,dst0,src0,src1,src2,src3);
866
867
868
} // emit_D3D_opcode_dssss
869
870
871
872
873
874
875
static void emit_D3D_opcode(Context *ctx, const char *opcode)
{
opcode = lowercase(get_scratch_buffer(ctx), opcode);
output_line(ctx, "%s", opcode);
} // emit_D3D_opcode_dssss
876
#define EMIT_D3D_OPCODE_FUNC(op) \
877
static void emit_D3D_##op(Context *ctx) { \
878
emit_D3D_opcode(ctx, #op); \
879
880
}
#define EMIT_D3D_OPCODE_D_FUNC(op) \
881
static void emit_D3D_##op(Context *ctx) { \
882
883
884
emit_D3D_opcode_d(ctx, #op); \
}
#define EMIT_D3D_OPCODE_S_FUNC(op) \
885
static void emit_D3D_##op(Context *ctx) { \
886
887
888
emit_D3D_opcode_s(ctx, #op); \
}
#define EMIT_D3D_OPCODE_SS_FUNC(op) \
889
static void emit_D3D_##op(Context *ctx) { \
890
891
892
emit_D3D_opcode_ss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DS_FUNC(op) \
893
static void emit_D3D_##op(Context *ctx) { \
894
895
896
emit_D3D_opcode_ds(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSS_FUNC(op) \
897
static void emit_D3D_##op(Context *ctx) { \
898
899
900
emit_D3D_opcode_dss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSS_FUNC(op) \
901
static void emit_D3D_##op(Context *ctx) { \
902
903
904
emit_D3D_opcode_dsss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSSS_FUNC(op) \
905
static void emit_D3D_##op(Context *ctx) { \
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
emit_D3D_opcode_dssss(ctx, #op); \
}
EMIT_D3D_OPCODE_FUNC(NOP)
EMIT_D3D_OPCODE_DS_FUNC(MOV)
EMIT_D3D_OPCODE_DSS_FUNC(ADD)
EMIT_D3D_OPCODE_DSS_FUNC(SUB)
EMIT_D3D_OPCODE_DSSS_FUNC(MAD)
EMIT_D3D_OPCODE_DSS_FUNC(MUL)
EMIT_D3D_OPCODE_DS_FUNC(RCP)
EMIT_D3D_OPCODE_DS_FUNC(RSQ)
EMIT_D3D_OPCODE_DSS_FUNC(DP3)
EMIT_D3D_OPCODE_DSS_FUNC(DP4)
EMIT_D3D_OPCODE_DSS_FUNC(MIN)
EMIT_D3D_OPCODE_DSS_FUNC(MAX)
EMIT_D3D_OPCODE_DSS_FUNC(SLT)
EMIT_D3D_OPCODE_DSS_FUNC(SGE)
EMIT_D3D_OPCODE_DS_FUNC(EXP)
EMIT_D3D_OPCODE_DS_FUNC(LOG)
EMIT_D3D_OPCODE_DS_FUNC(LIT)
EMIT_D3D_OPCODE_DSS_FUNC(DST)
EMIT_D3D_OPCODE_DSSS_FUNC(LRP)
EMIT_D3D_OPCODE_DS_FUNC(FRC)
EMIT_D3D_OPCODE_DSS_FUNC(M4X4)
EMIT_D3D_OPCODE_DSS_FUNC(M4X3)
EMIT_D3D_OPCODE_DSS_FUNC(M3X4)
EMIT_D3D_OPCODE_DSS_FUNC(M3X3)
EMIT_D3D_OPCODE_DSS_FUNC(M3X2)
EMIT_D3D_OPCODE_S_FUNC(CALL)
EMIT_D3D_OPCODE_SS_FUNC(CALLNZ)
936
EMIT_D3D_OPCODE_SS_FUNC(LOOP)
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
EMIT_D3D_OPCODE_FUNC(RET)
EMIT_D3D_OPCODE_FUNC(ENDLOOP)
EMIT_D3D_OPCODE_S_FUNC(LABEL)
EMIT_D3D_OPCODE_DSS_FUNC(POW)
EMIT_D3D_OPCODE_DSS_FUNC(CRS)
EMIT_D3D_OPCODE_DSSS_FUNC(SGN)
EMIT_D3D_OPCODE_DS_FUNC(ABS)
EMIT_D3D_OPCODE_DS_FUNC(NRM)
EMIT_D3D_OPCODE_DS_FUNC(SINCOS)
EMIT_D3D_OPCODE_S_FUNC(REP)
EMIT_D3D_OPCODE_FUNC(ENDREP)
EMIT_D3D_OPCODE_S_FUNC(IF)
EMIT_D3D_OPCODE_FUNC(ELSE)
EMIT_D3D_OPCODE_FUNC(ENDIF)
EMIT_D3D_OPCODE_FUNC(BREAK)
EMIT_D3D_OPCODE_DS_FUNC(MOVA)
EMIT_D3D_OPCODE_D_FUNC(TEXKILL)
EMIT_D3D_OPCODE_DS_FUNC(TEXBEM)
EMIT_D3D_OPCODE_DS_FUNC(TEXBEML)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2AR)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2GB)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2PAD)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2TEX)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3PAD)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3TEX)
EMIT_D3D_OPCODE_DSS_FUNC(TEXM3X3SPEC)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3VSPEC)
EMIT_D3D_OPCODE_DS_FUNC(EXPP)
EMIT_D3D_OPCODE_DS_FUNC(LOGP)
EMIT_D3D_OPCODE_DSSS_FUNC(CND)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2RGB)
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3TEX)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2DEPTH)
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3)
EMIT_D3D_OPCODE_D_FUNC(TEXDEPTH)
EMIT_D3D_OPCODE_DSSS_FUNC(CMP)
EMIT_D3D_OPCODE_DSS_FUNC(BEM)
EMIT_D3D_OPCODE_DSSS_FUNC(DP2ADD)
EMIT_D3D_OPCODE_DS_FUNC(DSX)
EMIT_D3D_OPCODE_DS_FUNC(DSY)
EMIT_D3D_OPCODE_DSSSS_FUNC(TEXLDD)
EMIT_D3D_OPCODE_DSS_FUNC(TEXLDL)
980
EMIT_D3D_OPCODE_S_FUNC(BREAKP)
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// special cases for comparison opcodes...
static const char *get_D3D_comparison_string(Context *ctx)
{
static const char *comps[] = {
"", "_gt", "_eq", "_ge", "_lt", "_ne", "_le"
};
if (ctx->instruction_controls >= STATICARRAYLEN(comps))
{
fail(ctx, "unknown comparison control");
return "";
} // if
return comps[ctx->instruction_controls];
} // get_D3D_comparison_string
static void emit_D3D_BREAKC(Context *ctx)
{
char op[16];