/
mojoshader_assembler.c
1853 lines (1547 loc) · 53.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
/**
* MojoShader; generate shader 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.
*/
#define __MOJOSHADER_INTERNAL__ 1
#include "mojoshader_internal.h"
13
14
15
16
17
18
19
#if DEBUG_ASSEMBLY_PARSER
#define print_debug_token(token, len, val) \
MOJOSHADER_print_debug_token("ASSEMBLER", token, len, val)
#else
#define print_debug_token(token, len, val)
#endif
20
21
22
23
// Simple linked list to cache source filenames, so we don't have to copy
// the same string over and over for each opcode.
typedef struct FilenameCache
24
{
25
26
27
char *filename;
struct FilenameCache *next;
} FilenameCache;
28
29
30
31
32
33
34
35
typedef struct SourcePos
{
const char *filename;
uint32 line;
} SourcePos;
36
37
// Context...this is state that changes as we assemble a shader...
38
typedef struct Context
39
{
40
41
int isfail;
int out_of_memory;
42
43
44
MOJOSHADER_malloc malloc;
MOJOSHADER_free free;
void *malloc_data;
45
46
int error_count;
ErrorList *errors;
47
Preprocessor *preprocessor;
48
MOJOSHADER_parsePhase parse_phase;
49
50
51
MOJOSHADER_shaderType shader_type;
uint8 major_ver;
uint8 minor_ver;
52
53
54
55
56
57
58
int pushedback;
const char *token; // assembler token!
unsigned int tokenlen; // assembler token!
Token tokenval; // assembler token!
uint32 version_token; // bytecode token!
uint32 tokenbuf[16]; // bytecode tokens!
int tokenbufpos; // bytecode tokens!
59
DestArgInfo dest_arg;
60
uint32 *output;
61
SourcePos *token_to_source;
62
63
64
uint8 *ctab;
uint32 ctab_len;
uint32 ctab_allocation;
65
66
size_t output_len;
size_t output_allocation;
67
FilenameCache *filename_cache;
68
} Context;
69
70
71
72
// Convenience functions for allocators...
73
static inline void out_of_memory(Context *ctx)
74
{
75
ctx->isfail = ctx->out_of_memory = 1;
76
77
78
79
80
81
82
83
84
85
} // out_of_memory
static inline void *Malloc(Context *ctx, const size_t len)
{
void *retval = ctx->malloc((int) len, ctx->malloc_data);
if (retval == NULL)
out_of_memory(ctx);
return retval;
} // Malloc
86
87
88
static inline char *StrDup(Context *ctx, const char *str)
{
char *retval = (char *) Malloc(ctx, strlen(str) + 1);
89
if (retval != NULL)
90
91
92
93
strcpy(retval, str);
return retval;
} // StrDup
94
95
96
97
98
99
static inline void Free(Context *ctx, void *ptr)
{
if (ptr != NULL) // check for NULL in case of dumb free() impl.
ctx->free(ptr, ctx->malloc_data);
} // Free
100
101
static void failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static void failf(Context *ctx, const char *fmt, ...)
102
{
103
104
105
106
const char *fname = NULL;
unsigned int linenum = 0;
int error_position = 0;
107
108
ctx->isfail = 1;
109
110
111
112
113
114
switch (ctx->parse_phase)
{
case MOJOSHADER_PARSEPHASE_NOTSTARTED:
error_position = -2;
break;
case MOJOSHADER_PARSEPHASE_WORKING:
115
116
fname = preprocessor_sourcepos(ctx->preprocessor, &linenum);
error_position = (int) linenum;
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
break;
case MOJOSHADER_PARSEPHASE_DONE:
error_position = -1;
break;
default:
assert(0 && "Unexpected value");
return;
} // switch
ErrorList *error = (ErrorList *) Malloc(ctx, sizeof (ErrorList));
if (error == NULL)
return;
char scratch = 0;
va_list ap;
va_start(ap, fmt);
const int len = vsnprintf(&scratch, sizeof (scratch), fmt, ap);
va_end(ap);
char *failstr = (char *) Malloc(ctx, len + 1);
if (failstr == NULL)
Free(ctx, error);
else
140
141
{
va_start(ap, fmt);
142
vsnprintf(failstr, len + 1, fmt, ap); // rebuild it.
143
144
va_end(ap);
145
146
147
error->error.error = failstr;
error->error.filename = fname ? StrDup(ctx, fname) : NULL;
error->error.error_position = error_position;
148
error->next = NULL;
149
150
ErrorList *prev = NULL;
151
152
ErrorList *item = ctx->errors;
while (item != NULL)
153
{
154
prev = item;
155
item = item->next;
156
157
} // while
158
if (prev == NULL)
159
ctx->errors = error;
160
161
else
prev->next = error;
162
163
164
ctx->error_count++;
} // else
165
166
} // failf
167
static inline void fail(Context *ctx, const char *reason)
168
{
169
failf(ctx, "%s", reason);
170
171
172
173
} // fail
static inline int isfail(const Context *ctx)
{
174
return ctx->isfail;
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
} // isfail
// 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 inline int shader_version_atleast(const Context *ctx, const uint8 maj,
const uint8 min)
{
return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min));
} // shader_version_atleast
static inline int shader_is_pixel(const Context *ctx)
{
return (ctx->shader_type == MOJOSHADER_TYPE_PIXEL);
} // shader_is_pixel
static inline int shader_is_vertex(const Context *ctx)
{
return (ctx->shader_type == MOJOSHADER_TYPE_VERTEX);
} // shader_is_vertex
201
202
static inline void pushback(Context *ctx)
{
203
204
205
#if DEBUG_ASSEMBLY_PARSER
printf("ASSEMBLER PUSHBACK\n");
#endif
206
207
208
209
210
211
assert(!ctx->pushedback);
ctx->pushedback = 1;
} // pushback
static Token _nexttoken(Context *ctx)
{
212
while (1)
213
{
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
ctx->token = preprocessor_nexttoken(ctx->preprocessor, &ctx->tokenlen,
&ctx->tokenval);
if (preprocessor_outofmemory(ctx->preprocessor))
{
out_of_memory(ctx);
ctx->tokenval = TOKEN_EOI;
ctx->token = NULL;
ctx->tokenlen = 0;
break;
} // if
if (ctx->tokenval == TOKEN_PREPROCESSING_ERROR)
{
fail(ctx, ctx->token);
continue;
} // else
break;
} // while
234
235
236
237
238
239
240
241
242
return ctx->tokenval;
} // _nexttoken
static Token nexttoken(Context *ctx)
{
if (ctx->pushedback)
{
243
print_debug_token(ctx->token, ctx->tokenlen, ctx->tokenval);
244
245
246
247
248
ctx->pushedback = 0;
return ctx->tokenval;
} // if
Token token = _nexttoken(ctx);
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
while (token == ((Token) '\n'))
token = _nexttoken(ctx); // skip endlines.
if (token == ((Token) ';')) // single line comment in assembler.
{
do
{
token = _nexttoken(ctx);
} while ((token != ((Token) '\n')) && (token != TOKEN_EOI));
while (token == ((Token) '\n'))
token = _nexttoken(ctx); // skip endlines.
} // if
264
print_debug_token(ctx->token, ctx->tokenlen, ctx->tokenval);
265
266
267
268
269
return token;
} // nexttoken
static const char *cache_filename(Context *ctx, const char *fname)
270
{
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
if (fname == NULL)
return NULL;
// !!! FIXME: this could be optimized into a hash table, but oh well.
FilenameCache *item = ctx->filename_cache;
while (item != NULL)
{
if (strcmp(item->filename, fname) == 0)
return item->filename;
item = item->next;
} // while
// new cache item.
item = (FilenameCache *) Malloc(ctx, sizeof (FilenameCache));
if (item == NULL)
return NULL;
item->filename = (char *) Malloc(ctx, strlen(fname) + 1);
if (item->filename == NULL)
{
Free(ctx, item);
return NULL;
} // if
strcpy(item->filename, fname);
item->next = ctx->filename_cache;
ctx->filename_cache = item;
return item->filename;
} // cache_filename
static void free_filename_cache(Context *ctx)
{
FilenameCache *item = ctx->filename_cache;
while (item != NULL)
{
FilenameCache *next = item->next;
Free(ctx, item->filename);
Free(ctx, item);
item = next;
} // while
} // free_filename_cache
314
315
316
317
static inline void add_token_sourcepos(Context *ctx, const size_t idx)
{
318
319
320
321
unsigned int pos = 0;
const char *fname = preprocessor_sourcepos(ctx->preprocessor, &pos);
ctx->token_to_source[idx].line = pos;
ctx->token_to_source[idx].filename = cache_filename(ctx, fname);
322
323
324
} // add_token_sourcepos
325
326
327
328
329
static void output_token_noswap(Context *ctx, const uint32 token)
{
if (isfail(ctx))
return;
330
331
332
333
if (ctx->output_len >= ctx->output_allocation)
{
const size_t output_alloc_bump = 1024; // that's tokens, not bytes.
const size_t newsize = ctx->output_allocation + output_alloc_bump;
334
335
336
void *ptr;
ptr = Malloc(ctx, newsize * sizeof (uint32));
337
338
339
340
341
342
if (ptr == NULL)
return;
if (ctx->output_len > 0)
memcpy(ptr, ctx->output, ctx->output_len * sizeof (uint32));
Free(ctx, ctx->output);
ctx->output = (uint32 *) ptr;
343
344
ptr = Malloc(ctx, newsize * sizeof (SourcePos));
345
346
347
if (ptr == NULL)
return;
if (ctx->output_len > 0)
348
349
350
memcpy(ptr, ctx->token_to_source, ctx->output_len * sizeof (SourcePos));
Free(ctx, ctx->token_to_source);
ctx->token_to_source = (SourcePos *) ptr;
351
352
ctx->output_allocation = newsize;
353
354
} // if
355
ctx->output[ctx->output_len] = token;
356
add_token_sourcepos(ctx, ctx->output_len);
357
ctx->output_len++;
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
} // output_token_noswap
static inline void output_token(Context *ctx, const uint32 token)
{
output_token_noswap(ctx, SWAP32(token));
} // output_token
static void output_comment_bytes(Context *ctx, const uint8 *buf, size_t len)
{
if (len > (0xFFFF * 4)) // length is stored as token count, in 16 bits.
fail(ctx, "Comment field is too big");
else if (!isfail(ctx))
{
const uint32 tokencount = (len / 4) + ((len % 4) ? 1 : 0);
output_token(ctx, 0xFFFE | (tokencount << 16));
while (len >= 4)
{
output_token_noswap(ctx, *((const uint32 *) buf));
len -= 4;
buf += 4;
} // while
if (len > 0) // handle spillover...
{
union { uint8 ui8[4]; uint32 ui32; } overflow;
overflow.ui32 = 0;
memcpy(overflow.ui8, buf, len);
output_token_noswap(ctx, overflow.ui32);
} // if
} // else if
} // output_comment_bytes
static inline void output_comment_string(Context *ctx, const char *str)
{
output_comment_bytes(ctx, (const uint8 *) str, strlen(str));
} // output_comment_string
399
static int require_comma(Context *ctx)
400
{
401
402
const Token token = nexttoken(ctx);
if (token != ((Token) ','))
403
{
404
405
fail(ctx, "Comma expected");
return 0;
406
} // if
407
408
return 1;
} // require_comma
409
410
411
static int check_token_segment(Context *ctx, const char *str)
412
{
413
414
415
416
417
418
419
420
// !!! FIXME: these are case-insensitive, right?
const size_t len = strlen(str);
if ( (ctx->tokenlen < len) || (strncasecmp(ctx->token, str, len) != 0) )
return 0;
ctx->token += len;
ctx->tokenlen -= len;
return 1;
} // check_token_segment
421
422
423
static int check_token(Context *ctx, const char *str)
424
{
425
426
const size_t len = strlen(str);
if ( (ctx->tokenlen != len) || (strncasecmp(ctx->token, str, len) != 0) )
427
return 0;
428
429
ctx->token += len;
ctx->tokenlen = 0;
430
return 1;
431
} // check_token
432
433
434
static int ui32fromtoken(Context *ctx, uint32 *_val)
435
{
436
437
438
439
440
441
int i;
for (i = 0; i < ctx->tokenlen; i++)
{
if ((ctx->token[i] < '0') || (ctx->token[i] > '9'))
break;
} // for
442
443
if (i == 0)
444
{
445
446
*_val = 0;
return 0;
447
448
} // if
449
450
451
452
const int len = i;
uint32 val = 0;
uint32 mult = 1;
while (i--)
453
{
454
455
456
val += ((uint32) (ctx->token[i] - '0')) * mult;
mult *= 10;
} // while
457
458
459
ctx->token += len;
ctx->tokenlen -= len;
460
461
*_val = val;
462
return 1;
463
} // ui32fromtoken
464
465
466
467
static int parse_register_name(Context *ctx, RegisterType *rtype, int *rnum)
{
468
469
470
if (nexttoken(ctx) != TOKEN_IDENTIFIER)
{
fail(ctx, "Expected register");
471
return 0;
472
} // if
473
474
475
476
int neednum = 1;
int regnum = 0;
RegisterType regtype = REG_TYPE_TEMP;
477
478
479
480
// Watch out for substrings! oDepth must be checked before oD, since
// the latter will match either case.
if (check_token_segment(ctx, "oDepth"))
481
482
483
484
{
regtype = REG_TYPE_DEPTHOUT;
neednum = 0;
} // else if
485
else if (check_token_segment(ctx, "vFace"))
486
{
487
488
regtype = REG_TYPE_MISCTYPE;
regnum = (int) MISCTYPE_TYPE_FACE;
489
490
neednum = 0;
} // else if
491
else if (check_token_segment(ctx, "vPos"))
492
493
494
495
496
{
regtype = REG_TYPE_MISCTYPE;
regnum = (int) MISCTYPE_TYPE_POSITION;
neednum = 0;
} // else if
497
else if (check_token_segment(ctx, "oPos"))
498
499
500
501
502
{
regtype = REG_TYPE_RASTOUT;
regnum = (int) RASTOUT_TYPE_POSITION;
neednum = 0;
} // else if
503
else if (check_token_segment(ctx, "oFog"))
504
505
506
507
508
{
regtype = REG_TYPE_RASTOUT;
regnum = (int) RASTOUT_TYPE_FOG;
neednum = 0;
} // else if
509
else if (check_token_segment(ctx, "oPts"))
510
511
512
513
514
{
regtype = REG_TYPE_RASTOUT;
regnum = (int) RASTOUT_TYPE_POINT_SIZE;
neednum = 0;
} // else if
515
516
517
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
else if (check_token_segment(ctx, "aL"))
{
regtype = REG_TYPE_LOOP;
neednum = 0;
} // else if
else if (check_token_segment(ctx, "oC"))
regtype = REG_TYPE_COLOROUT;
else if (check_token_segment(ctx, "oT"))
regtype = REG_TYPE_OUTPUT;
else if (check_token_segment(ctx, "oD"))
regtype = REG_TYPE_ATTROUT;
else if (check_token_segment(ctx, "r"))
regtype = REG_TYPE_TEMP;
else if (check_token_segment(ctx, "v"))
regtype = REG_TYPE_INPUT;
else if (check_token_segment(ctx, "c"))
regtype = REG_TYPE_CONST;
else if (check_token_segment(ctx, "i"))
regtype = REG_TYPE_CONSTINT;
else if (check_token_segment(ctx, "b"))
regtype = REG_TYPE_CONSTBOOL;
else if (check_token_segment(ctx, "s"))
regtype = REG_TYPE_SAMPLER;
else if (check_token_segment(ctx, "l"))
regtype = REG_TYPE_LABEL;
else if (check_token_segment(ctx, "p"))
regtype = REG_TYPE_PREDICATE;
else if (check_token_segment(ctx, "o"))
regtype = REG_TYPE_OUTPUT;
else if (check_token_segment(ctx, "a"))
regtype = REG_TYPE_ADDRESS;
else if (check_token_segment(ctx, "t"))
regtype = REG_TYPE_ADDRESS;
548
549
550
551
552
//case REG_TYPE_TEMPFLOAT16: // !!! FIXME: don't know this asm string
else
{
553
554
555
556
fail(ctx, "expected register type");
regtype = REG_TYPE_CONST;
regnum = 0;
neednum = 0;
557
558
} // else
559
560
// "c[5]" is the same as "c5", so if the token is done, see if next is '['.
if ((neednum) && (ctx->tokenlen == 0))
561
{
562
if (nexttoken(ctx) == ((Token) '['))
563
neednum = 0; // don't need a number on register name itself.
564
pushback(ctx);
565
566
} // if
567
568
if (neednum)
{
569
uint32 ui32 = 0;
570
if (!ui32fromtoken(ctx, &ui32))
571
fail(ctx, "Invalid register index");
572
regnum = (int) ui32;
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
} // if
// split up REG_TYPE_CONST
if (regtype == REG_TYPE_CONST)
{
if (regnum < 2048)
{
regtype = REG_TYPE_CONST;
regnum -= 0;
} // if
else if (regnum < 4096)
{
regtype = REG_TYPE_CONST2;
regnum -= 2048;
} // if
else if (regnum < 6144)
{
regtype = REG_TYPE_CONST3;
regnum -= 4096;
} // if
else if (regnum < 8192)
{
regtype = REG_TYPE_CONST4;
regnum -= 6144;
} // if
else
{
600
fail(ctx, "Invalid const register index");
601
602
603
604
605
606
} // else
} // if
*rtype = regtype;
*rnum = regnum;
607
return 1;
608
609
610
} // parse_register_name
611
static void set_result_shift(Context *ctx, DestArgInfo *info, const int val)
612
{
613
if (info->result_shift != 0)
614
fail(ctx, "Multiple result shift modifiers");
615
616
info->result_shift = val;
} // set_result_shift
617
618
619
static int parse_destination_token(Context *ctx)
620
{
621
DestArgInfo *info = &ctx->dest_arg;
622
memset(info, '\0', sizeof (DestArgInfo));
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
// parse_instruction_token() sets ctx->token to the end of the instruction
// so we can see if there are destination modifiers on the instruction
// itself...
int invalid_modifier = 0;
while ((ctx->tokenlen > 0) && (!invalid_modifier))
{
if (check_token_segment(ctx, "_x2"))
set_result_shift(ctx, info, 0x1);
else if (check_token_segment(ctx, "_x4"))
set_result_shift(ctx, info, 0x2);
else if (check_token_segment(ctx, "_x8"))
set_result_shift(ctx, info, 0x3);
else if (check_token_segment(ctx, "_d8"))
set_result_shift(ctx, info, 0xD);
else if (check_token_segment(ctx, "_d4"))
set_result_shift(ctx, info, 0xE);
else if (check_token_segment(ctx, "_d2"))
set_result_shift(ctx, info, 0xF);
else if (check_token_segment(ctx, "_sat"))
645
info->result_mod |= MOD_SATURATE;
646
else if (check_token_segment(ctx, "_pp"))
647
info->result_mod |= MOD_PP;
648
else if (check_token_segment(ctx, "_centroid"))
649
650
info->result_mod |= MOD_CENTROID;
else
651
invalid_modifier = 1;
652
653
} // while
654
655
if (invalid_modifier)
fail(ctx, "Invalid destination modifier");
656
657
// !!! FIXME: predicates.
658
if (nexttoken(ctx) == ((Token) '('))
659
660
fail(ctx, "Predicates unsupported at this time"); // !!! FIXME: ...
661
662
pushback(ctx); // parse_register_name calls nexttoken().
663
parse_register_name(ctx, &info->regtype, &info->regnum);
664
665
666
// parse_register_name() can't check this: dest regs might have modifiers.
if (ctx->tokenlen > 0)
fail(ctx, "invalid register name");
667
668
669
// !!! FIXME: can dest registers do relative addressing?
670
int invalid_writemask = 0;
671
int implicit_writemask = 0;
672
if (nexttoken(ctx) != ((Token) '.'))
673
{
674
implicit_writemask = 1;
675
676
677
678
info->writemask = 0xF;
info->writemask0 = info->writemask1 = info->writemask2 = info->writemask3 = 1;
pushback(ctx); // no explicit writemask; do full mask.
} // if
679
680
681
682
// !!! FIXME: Cg generates code with oDepth.z ... this is a bug, I think.
//else if (scalar_register(ctx->shader_type, info->regtype, info->regnum))
else if ( (scalar_register(ctx->shader_type, info->regtype, info->regnum)) && (info->regtype != REG_TYPE_DEPTHOUT) )
683
fail(ctx, "Writemask specified for scalar register");
684
else if (nexttoken(ctx) != TOKEN_IDENTIFIER)
685
invalid_writemask = 1;
686
687
else
{
688
689
690
691
692
693
// !!! FIXME: is out-of-order okay (yxzw instead of xyzw?)
char tokenbytes[5] = { '\0', '\0', '\0', '\0', '\0' };
const unsigned int tokenlen = ctx->tokenlen;
memcpy(tokenbytes, ctx->token, ((tokenlen < 4) ? tokenlen : 4));
char *ptr = tokenbytes;
694
info->writemask0 = info->writemask1 = info->writemask2 = info->writemask3 = 0;
695
696
697
698
if (*ptr == 'x') { info->writemask0 = 1; ptr++; }
if (*ptr == 'y') { info->writemask1 = 1; ptr++; }
if (*ptr == 'z') { info->writemask2 = 1; ptr++; }
if (*ptr == 'w') { info->writemask3 = 1; ptr++; }
699
if ((ptr == ctx->token) && (shader_is_pixel(ctx)))
700
{
701
702
703
704
if (*ptr == 'r') { info->writemask0 = 1; ptr++; }
if (*ptr == 'g') { info->writemask1 = 1; ptr++; }
if (*ptr == 'b') { info->writemask2 = 1; ptr++; }
if (*ptr == 'a') { info->writemask3 = 1; ptr++; }
705
706
707
} // if
if (*ptr != '\0')
708
invalid_writemask = 1;
709
710
711
712
713
714
715
info->writemask = ( ((info->writemask0 & 0x1) << 0) |
((info->writemask1 & 0x1) << 1) |
((info->writemask2 & 0x1) << 2) |
((info->writemask3 & 0x1) << 3) );
} // else
716
717
718
if (invalid_writemask)
fail(ctx, "Invalid writemask");
719
720
721
722
723
// !!! FIXME: Cg generates code with oDepth.z ... this is a bug, I think.
if (info->regtype == REG_TYPE_DEPTHOUT)
{
if ( (!implicit_writemask) && ((info->writemask0 + info->writemask1 +
info->writemask2 + info->writemask3) > 1) )
724
fail(ctx, "Writemask specified for scalar register");
725
726
} // if
727
728
729
info->orig_writemask = info->writemask;
if (ctx->tokenbufpos >= STATICARRAYLEN(ctx->tokenbuf))
730
731
732
733
{
fail(ctx, "Too many tokens");
return 1;
} // if
734
735
ctx->tokenbuf[ctx->tokenbufpos++] =
736
( ((((uint32) 1)) << 31) |
737
738
739
740
((((uint32) info->regnum) & 0x7ff) << 0) |
((((uint32) info->relative) & 0x1) << 13) |
((((uint32) info->result_mod) & 0xF) << 20) |
((((uint32) info->result_shift) & 0xF) << 24) |
741
((((uint32) info->writemask) & 0xF) << 16) |
742
743
744
745
746
747
748
((((uint32) info->regtype) & 0x7) << 28) |
((((uint32) info->regtype) & 0x18) << 8) );
return 1;
} // parse_destination_token
749
750
751
static void set_source_mod(Context *ctx, const int negate,
const SourceMod norm, const SourceMod negated,
SourceMod *srcmod)
752
{
753
754
755
756
757
if ( (*srcmod != SRCMOD_NONE) || (negate && (negated == SRCMOD_NONE)) )
fail(ctx, "Incompatible source modifiers");
else
*srcmod = ((negate) ? negated : norm);
} // set_source_mod
758
759
760
static int parse_source_token_maybe_relative(Context *ctx, const int relok)
761
{
762
763
764
int retval = 1;
if (ctx->tokenbufpos >= STATICARRAYLEN(ctx->tokenbuf))
765
766
767
768
{
fail(ctx, "Too many tokens");
return 0;
} // if
769
770
// mark this now, so optional relative addressing token is placed second.
771
772
uint32 *outtoken = &ctx->tokenbuf[ctx->tokenbufpos++];
*outtoken = 0;
773
774
775
SourceMod srcmod = SRCMOD_NONE;
int negate = 0;
776
777
778
779
780
781
782
Token token = nexttoken(ctx);
if (token == ((Token) '!'))
srcmod = SRCMOD_NOT;
else if (token == ((Token) '-'))
negate = 1;
else if ( (token == TOKEN_INT_LITERAL) && (check_token(ctx, "1")) )
783
{
784
785
if (nexttoken(ctx) != ((Token) '-'))
fail(ctx, "Unexpected token");
786
787
788
789
else
srcmod = SRCMOD_COMPLEMENT;
} // else
else
790
{
791
pushback(ctx);
792
} // else
793
794
795
RegisterType regtype;
int regnum;
796
parse_register_name(ctx, ®type, ®num);
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
if (ctx->tokenlen > 0)
{
if (check_token_segment(ctx, "_bias"))
set_source_mod(ctx, negate, SRCMOD_BIAS, SRCMOD_BIASNEGATE, &srcmod);
else if (check_token_segment(ctx, "_bx2"))
set_source_mod(ctx, negate, SRCMOD_SIGN, SRCMOD_SIGNNEGATE, &srcmod);
else if (check_token_segment(ctx, "_x2"))
set_source_mod(ctx, negate, SRCMOD_X2, SRCMOD_X2NEGATE, &srcmod);
else if (check_token_segment(ctx, "_dz"))
set_source_mod(ctx, negate, SRCMOD_DZ, SRCMOD_NONE, &srcmod);
else if (check_token_segment(ctx, "_dw"))
set_source_mod(ctx, negate, SRCMOD_DW, SRCMOD_NONE, &srcmod);
else if (check_token_segment(ctx, "_abs"))
set_source_mod(ctx, negate, SRCMOD_ABS, SRCMOD_ABSNEGATE, &srcmod);
else
fail(ctx, "Invalid source modifier");
} // if
815
816
uint32 relative = 0;
817
if (nexttoken(ctx) != ((Token) '['))
818
819
820
pushback(ctx); // not relative addressing?
else
{
821
822
823
824
825
826
if (!relok)
fail(ctx, "Relative addressing not permitted here.");
else
retval++;
parse_source_token_maybe_relative(ctx, 0);
827
relative = 1;
828
829
if (nexttoken(ctx) != ((Token) '+'))
830
831
832
pushback(ctx);
else
{
833
834
// !!! FIXME: maybe c3[a0.x + 5] is legal and becomes c[a0.x + 8] ?
if (regnum != 0)
835
fail(ctx, "Relative addressing with explicit register number.");
836
837
uint32 ui32 = 0;
838
839
840
841
if ( (nexttoken(ctx) != TOKEN_INT_LITERAL) ||
(!ui32fromtoken(ctx, &ui32)) ||
(ctx->tokenlen != 0) )
{
842
fail(ctx, "Invalid relative addressing offset");
843
} // if
844
845
846
regnum += (int) ui32;
} // else
847
if (nexttoken(ctx) != ((Token) ']'))
848
fail(ctx, "Expected ']'");
849
} // else
850
851
int invalid_swizzle = 0;
852
uint32 swizzle = 0;
853
if (nexttoken(ctx) != ((Token) '.'))
854
855
856
857
{
swizzle = 0xE4; // 0xE4 == 11100100 ... 0 1 2 3. No swizzle.
pushback(ctx); // no explicit writemask; do full mask.
} // if
858
else if (scalar_register(ctx->shader_type, regtype, regnum))
859
fail(ctx, "Swizzle specified for scalar register");
860
else if (nexttoken(ctx) != TOKEN_IDENTIFIER)
861
invalid_swizzle = 1;
862
863
else
{
864
865
866
867
char tokenbytes[5] = { '\0', '\0', '\0', '\0', '\0' };
const unsigned int tokenlen = ctx->tokenlen;
memcpy(tokenbytes, ctx->token, ((tokenlen < 4) ? tokenlen : 4));
868
// deal with shortened form (.x = .xxxx, etc).
869
870
871
872
873
874
875
if (tokenlen == 1)
tokenbytes[1] = tokenbytes[2] = tokenbytes[3] = tokenbytes[0];
else if (tokenlen == 2)
tokenbytes[2] = tokenbytes[3] = tokenbytes[1];
else if (tokenlen == 3)
tokenbytes[3] = tokenbytes[2];
else if (tokenlen != 4)
876
invalid_swizzle = 1;
877
tokenbytes[4] = '\0';
878
879
uint32 val = 0;
880
881
int saw_xyzw = 0;
int saw_rgba = 0;
882
int i;
883
884
for (i = 0; i < 4; i++)
{
885
const int component = (int) tokenbytes[i];
886
887
888
889
890
891
892
893
894
895
switch (component)
{
case 'x': val = 0; saw_xyzw = 1; break;
case 'y': val = 1; saw_xyzw = 1; break;
case 'z': val = 2; saw_xyzw = 1; break;
case 'w': val = 3; saw_xyzw = 1; break;
case 'r': val = 0; saw_rgba = 1; break;
case 'g': val = 1; saw_rgba = 1; break;
case 'b': val = 2; saw_rgba = 1; break;
case 'a': val = 3; saw_rgba = 1; break;
896
default: invalid_swizzle = 1; break;
897
898
899
} // switch
swizzle |= (val << (i * 2));
} // for
900
901
if (saw_xyzw && saw_rgba)
902
invalid_swizzle = 1;
903
904
else if (saw_rgba && !shader_is_pixel(ctx))
invalid_swizzle = 1;
905
} // else
906
907
908
909
if (invalid_swizzle)
fail(ctx, "Invalid swizzle");
910
911
912
913
914
915
916
*outtoken = ( ((((uint32) 1)) << 31) |
((((uint32) regnum) & 0x7ff) << 0) |
((((uint32) relative) & 0x1) << 13) |
((((uint32) swizzle) & 0xFF) << 16) |
((((uint32) srcmod) & 0xF) << 24) |
((((uint32) regtype) & 0x7) << 28) |
((((uint32) regtype) & 0x18) << 8) );
917
918
919
return retval;
} // parse_source_token_maybe_relative
920
921
922
static inline int parse_source_token(Context *ctx)
923
{
924
925
return parse_source_token_maybe_relative(ctx, 1);
} // parse_source_token
926
927
928
929
static int parse_args_NULL(Context *ctx)
{
930
return 1;
931
} // parse_args_NULL
932
933
934
static int parse_num(Context *ctx, const int floatok, uint32 *value)
935
936
{
union { float f; int32 si32; uint32 ui32; } cvt;
937
938
939
940
941
942
943
944
int negative = 0;
Token token = nexttoken(ctx);
if (token == ((Token) '-'))
{
negative = 1;
token = nexttoken(ctx);
} // if
945
946
if (token == TOKEN_INT_LITERAL)
947
{
948
949
int d = 0;
sscanf(ctx->token, "%d", &d);
950
951
952
953
if (floatok)
cvt.f = (float) ((negative) ? -d : d);
else
cvt.si32 = (int32) ((negative) ? -d : d);
954
955
} // if
else if (token == TOKEN_FLOAT_LITERAL)
956
{
957
if (!floatok)
958
{
959
960
961
fail(ctx, "Expected whole number");
*value = 0;
return 0;
962
} // if
963
sscanf(ctx->token, "%f", &cvt.f);
964
965
if (negative)
cvt.f = -cvt.f;
966
967
968
969
970
971
} // if
else
{
fail(ctx, "Expected number");
*value = 0;
return 0;
972
} // else
973
974
*value = cvt.ui32;
975
return 1;
976
977
978
979
980
} // parse_num
static int parse_args_DEFx(Context *ctx, const int isflt)
{
981
982
983
984
985
986
987
988
989
parse_destination_token(ctx);
require_comma(ctx);
parse_num(ctx, isflt, &ctx->tokenbuf[ctx->tokenbufpos++]);
require_comma(ctx);
parse_num(ctx, isflt, &ctx->tokenbuf[ctx->tokenbufpos++]);
require_comma(ctx);
parse_num(ctx, isflt, &ctx->tokenbuf[ctx->tokenbufpos++]);
require_comma(ctx);
parse_num(ctx, isflt, &ctx->tokenbuf[ctx->tokenbufpos++]);
990
991
return 6;
} // parse_args_DEFx
992
993
994
995
996
997
static int parse_args_DEF(Context *ctx)
{
return parse_args_DEFx(ctx, 1);
} // parse_args_DEF
998
999
1000
static int parse_args_DEFI(Context *ctx)