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