diff options
13 files changed, 376 insertions, 374 deletions
diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/Makefile b/src/gallium/state_trackers/d3d1x/d3d1xshader/Makefile index 866762e1bb..4f67145b6f 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/Makefile +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/Makefile @@ -6,8 +6,8 @@ LIBS=libd3d1xshader.a include ../Makefile.inc -include/tpf_defs.h: $(wildcard defs/*.txt) +include/sm4_defs.h: $(wildcard defs/*.txt) ./gen-header.sh $^ > $@ -src/tpf_text.cpp: $(wildcard defs/*.txt) +src/sm4_text.cpp: $(wildcard defs/*.txt) ./gen-text.sh $^ > $@ diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-header.sh b/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-header.sh index 558794f1d2..fcda13f907 100755 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-header.sh +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-header.sh @@ -2,12 +2,12 @@ for i in "$@"; do n=$(basename "$i" .txt|sed -e 's/s$//') if test "$n" == "shortfile"; then continue; fi - echo "enum tpf_$n" + echo "enum sm4_$n" echo "{" while read j; do - echo $'\t'"TPF_${n}_$j", + echo $'\t'"SM4_${n}_$j", done < "$i" |tr '[a-z]' '[A-Z]'|tr ' ' '_' - echo $'\t'"TPF_${n}_COUNT"|tr '[a-z]' '[A-Z]' + echo $'\t'"SM4_${n}_COUNT"|tr '[a-z]' '[A-Z]' echo "};" echo done diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-text.sh b/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-text.sh index b31e16e19c..4663f635d4 100755 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-text.sh +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/gen-text.sh @@ -1,7 +1,7 @@ #!/bin/bash for i in "$@"; do n=$(basename "$i" .txt|sed -e 's/s$//') - echo "const char* tpf_${n}_names[] =" + echo "const char* sm4_${n}_names[] =" echo "{" while read j; do echo $'\t'"\"$j\"", diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/include/tpf.h b/src/gallium/state_trackers/d3d1x/d3d1xshader/include/sm4.h index 6ab9b820e8..07f84f0c73 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/include/tpf.h +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/include/sm4.h @@ -24,8 +24,10 @@ * **************************************************************************/ -#ifndef TPF_H_ -#define TPF_H_ +/* Header for Shader Model 4.0, 4.1 and 5.0 */ + +#ifndef SM4_H_ +#define SM4_H_ #include <stdint.h> #include <string.h> @@ -36,16 +38,16 @@ #include <iostream> #include "le32.h" -#include "tpf_defs.h" +#include "sm4_defs.h" -extern const char* tpf_opcode_names[]; -extern const char* tpf_file_names[]; -extern const char* tpf_file_ms_names[]; -extern const char* tpf_target_names[]; -extern const char* tpf_interpolation_names[]; -extern const char* tpf_sv_names[]; +extern const char* sm4_opcode_names[]; +extern const char* sm4_file_names[]; +extern const char* sm4_file_ms_names[]; +extern const char* sm4_target_names[]; +extern const char* sm4_interpolation_names[]; +extern const char* sm4_sv_names[]; -struct tpf_token_version +struct sm4_token_version { unsigned minor : 4; unsigned major : 4; @@ -53,7 +55,7 @@ struct tpf_token_version unsigned type : 16; }; -struct tpf_token_instruction +struct sm4_token_instruction { // we don't make it an union directly because unions can't be inherited from union @@ -155,7 +157,7 @@ struct tpf_token_instruction }; }; -union tpf_token_instruction_extended +union sm4_token_instruction_extended { struct { @@ -186,7 +188,7 @@ union tpf_token_instruction_extended } resource_return_type; }; -struct tpf_token_resource_return_type +struct sm4_token_resource_return_type { unsigned x : 4; unsigned y : 4; @@ -194,31 +196,31 @@ struct tpf_token_resource_return_type unsigned w : 4; }; -struct tpf_token_operand +struct sm4_token_operand { - unsigned comps_enum : 2; /* tpf_operands_comps */ - unsigned mode : 2; /* tpf_operand_mode */ + unsigned comps_enum : 2; /* sm4_operands_comps */ + unsigned mode : 2; /* sm4_operand_mode */ unsigned sel : 8; - unsigned file : 8; /* tpf_file */ + unsigned file : 8; /* sm4_file */ unsigned num_indices : 2; - unsigned index0_repr : 3; /* tpf_operand_index_repr */ - unsigned index1_repr : 3; /* tpf_operand_index_repr */ - unsigned index2_repr : 3; /* tpf_operand_index_repr */ + unsigned index0_repr : 3; /* sm4_operand_index_repr */ + unsigned index1_repr : 3; /* sm4_operand_index_repr */ + unsigned index2_repr : 3; /* sm4_operand_index_repr */ unsigned extended : 1; }; -#define TPF_OPERAND_SEL_MASK(sel) ((sel) & 0xf) -#define TPF_OPERAND_SEL_SWZ(sel, i) (((sel) >> ((i) * 2)) & 3) -#define TPF_OPERAND_SEL_SCALAR(sel) ((sel) & 3) +#define SM4_OPERAND_SEL_MASK(sel) ((sel) & 0xf) +#define SM4_OPERAND_SEL_SWZ(sel, i) (((sel) >> ((i) * 2)) & 3) +#define SM4_OPERAND_SEL_SCALAR(sel) ((sel) & 3) -struct tpf_token_operand_extended +struct sm4_token_operand_extended { unsigned type : 6; unsigned neg : 1; unsigned abs : 1; }; -union tpf_any +union sm4_any { double f64; float f32; @@ -228,30 +230,30 @@ union tpf_any int64_t u32; }; -struct tpf_op; -struct tpf_insn; -struct tpf_dcl; -struct tpf_program; -std::ostream& operator <<(std::ostream& out, const tpf_op& op); -std::ostream& operator <<(std::ostream& out, const tpf_insn& op); -std::ostream& operator <<(std::ostream& out, const tpf_dcl& op); -std::ostream& operator <<(std::ostream& out, const tpf_program& op); +struct sm4_op; +struct sm4_insn; +struct sm4_dcl; +struct sm4_program; +std::ostream& operator <<(std::ostream& out, const sm4_op& op); +std::ostream& operator <<(std::ostream& out, const sm4_insn& op); +std::ostream& operator <<(std::ostream& out, const sm4_dcl& op); +std::ostream& operator <<(std::ostream& out, const sm4_program& op); -struct tpf_op +struct sm4_op { uint8_t mode; uint8_t comps; uint8_t mask; uint8_t num_indices; uint8_t swizzle[4]; - tpf_file file; - tpf_any imm_values[4]; + sm4_file file; + sm4_any imm_values[4]; bool neg; bool abs; struct { int64_t disp; - std::auto_ptr<tpf_op> reg; + std::auto_ptr<sm4_op> reg; } indices[3]; bool is_index_simple(unsigned i) const @@ -264,7 +266,7 @@ struct tpf_op return num_indices == 1 && is_index_simple(0); } - tpf_op() + sm4_op() { memset(this, 0, sizeof(*this)); } @@ -272,14 +274,14 @@ struct tpf_op void dump(); private: - tpf_op(const tpf_op& op) + sm4_op(const sm4_op& op) {} }; /* for sample_d */ -#define TPF_MAX_OPS 6 +#define SM4_MAX_OPS 6 -struct tpf_insn : public tpf_token_instruction +struct sm4_insn : public sm4_token_instruction { int8_t sample_offset[3]; uint8_t resource_target; @@ -287,9 +289,9 @@ struct tpf_insn : public tpf_token_instruction unsigned num; unsigned num_ops; - std::auto_ptr<tpf_op> ops[TPF_MAX_OPS]; + std::auto_ptr<sm4_op> ops[SM4_MAX_OPS]; - tpf_insn() + sm4_insn() { memset(this, 0, sizeof(*this)); } @@ -297,18 +299,18 @@ struct tpf_insn : public tpf_token_instruction void dump(); private: - tpf_insn(const tpf_insn& op) + sm4_insn(const sm4_insn& op) {} }; -struct tpf_dcl : public tpf_token_instruction +struct sm4_dcl : public sm4_token_instruction { - std::auto_ptr<tpf_op> op; + std::auto_ptr<sm4_op> op; union { unsigned num; float f32; - tpf_sv sv; + sm4_sv sv; struct { unsigned id; @@ -317,7 +319,7 @@ struct tpf_dcl : public tpf_token_instruction unsigned array_length; } intf; unsigned thread_group_size[3]; - tpf_token_resource_return_type rrt; + sm4_token_resource_return_type rrt; struct { unsigned num; @@ -332,12 +334,12 @@ struct tpf_dcl : public tpf_token_instruction void* data; - tpf_dcl() + sm4_dcl() { memset(this, 0, sizeof(*this)); } - ~tpf_dcl() + ~sm4_dcl() { free(data); } @@ -345,15 +347,15 @@ struct tpf_dcl : public tpf_token_instruction void dump(); private: - tpf_dcl(const tpf_dcl& op) + sm4_dcl(const sm4_dcl& op) {} }; -struct tpf_program +struct sm4_program { - tpf_token_version version; - std::vector<tpf_dcl*> dcls; - std::vector<tpf_insn*> insns; + sm4_token_version version; + std::vector<sm4_dcl*> dcls; + std::vector<sm4_insn*> insns; /* for ifs, the insn number of the else or endif if there is no else * for elses, the insn number of the endif @@ -376,33 +378,33 @@ struct tpf_program bool labels_found; std::vector<int> label_to_insn_num; - tpf_program() + sm4_program() { memset(&version, 0, sizeof(version)); labels_found = false; resource_sampler_slots_assigned = false; } - ~tpf_program() + ~sm4_program() { - for(std::vector<tpf_dcl*>::iterator i = dcls.begin(), e = dcls.end(); i != e; ++i) + for(std::vector<sm4_dcl*>::iterator i = dcls.begin(), e = dcls.end(); i != e; ++i) delete *i; - for(std::vector<tpf_insn*>::iterator i = insns.begin(), e = insns.end(); i != e; ++i) + for(std::vector<sm4_insn*>::iterator i = insns.begin(), e = insns.end(); i != e; ++i) delete *i; } void dump(); private: - tpf_program(const tpf_dcl& op) + sm4_program(const sm4_dcl& op) {} }; -tpf_program* tpf_parse(void* tokens, int size); +sm4_program* sm4_parse(void* tokens, int size); -bool tpf_link_cf_insns(tpf_program& program); -bool tpf_find_labels(tpf_program& program); -bool tpf_allocate_resource_sampler_pairs(tpf_program& program); +bool sm4_link_cf_insns(sm4_program& program); +bool sm4_find_labels(sm4_program& program); +bool sm4_allocate_resource_sampler_pairs(sm4_program& program); -#endif /* TPF_H_ */ +#endif /* SM4_H_ */ diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_analyze.cpp b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_analyze.cpp index a381564ada..848db1bdbb 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_analyze.cpp +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_analyze.cpp @@ -26,11 +26,11 @@ #include <vector> #include <set> -#include "tpf.h" +#include "sm4.h" #define check(x) do {if(!(x)) return false;} while(0) -bool tpf_link_cf_insns(tpf_program& program) +bool sm4_link_cf_insns(sm4_program& program) { if(program.cf_insn_linked.size()) return true; @@ -44,42 +44,42 @@ bool tpf_link_cf_insns(tpf_program& program) unsigned v; switch(program.insns[insn_num]->opcode) { - case TPF_OPCODE_LOOP: + case SM4_OPCODE_LOOP: cf_stack.push_back(insn_num); break; - case TPF_OPCODE_ENDLOOP: + case SM4_OPCODE_ENDLOOP: check(!cf_stack.empty()); v = cf_stack.back(); - check(program.insns[v]->opcode == TPF_OPCODE_LOOP); + check(program.insns[v]->opcode == SM4_OPCODE_LOOP); cf_insn_linked[v] = insn_num; cf_insn_linked[insn_num] = v; cf_stack.pop_back(); break; - case TPF_OPCODE_IF: - case TPF_OPCODE_SWITCH: + case SM4_OPCODE_IF: + case SM4_OPCODE_SWITCH: cf_insn_linked[insn_num] = insn_num; // later changed cf_stack.push_back(insn_num); break; - case TPF_OPCODE_ELSE: - case TPF_OPCODE_CASE: + case SM4_OPCODE_ELSE: + case SM4_OPCODE_CASE: check(!cf_stack.empty()); v = cf_stack.back(); - if(program.insns[insn_num]->opcode == TPF_OPCODE_ELSE) - check(program.insns[v]->opcode == TPF_OPCODE_IF); + if(program.insns[insn_num]->opcode == SM4_OPCODE_ELSE) + check(program.insns[v]->opcode == SM4_OPCODE_IF); else - check(program.insns[v]->opcode == TPF_OPCODE_SWITCH || program.insns[v]->opcode == TPF_OPCODE_CASE); + check(program.insns[v]->opcode == SM4_OPCODE_SWITCH || program.insns[v]->opcode == SM4_OPCODE_CASE); cf_insn_linked[insn_num] = cf_insn_linked[v]; // later changed cf_insn_linked[v] = insn_num; cf_stack.back() = insn_num; break; - case TPF_OPCODE_ENDSWITCH: - case TPF_OPCODE_ENDIF: + case SM4_OPCODE_ENDSWITCH: + case SM4_OPCODE_ENDIF: check(!cf_stack.empty()); v = cf_stack.back(); - if(program.insns[insn_num]->opcode == TPF_OPCODE_ENDIF) - check(program.insns[v]->opcode == TPF_OPCODE_IF || program.insns[v]->opcode == TPF_OPCODE_ELSE); + if(program.insns[insn_num]->opcode == SM4_OPCODE_ENDIF) + check(program.insns[v]->opcode == SM4_OPCODE_IF || program.insns[v]->opcode == SM4_OPCODE_ELSE); else - check(program.insns[v]->opcode == TPF_OPCODE_SWITCH || program.insns[v]->opcode == TPF_OPCODE_CASE); + check(program.insns[v]->opcode == SM4_OPCODE_SWITCH || program.insns[v]->opcode == SM4_OPCODE_CASE); cf_insn_linked[insn_num] = cf_insn_linked[v]; cf_insn_linked[v] = insn_num; cf_stack.pop_back(); @@ -91,7 +91,7 @@ bool tpf_link_cf_insns(tpf_program& program) return true; } -bool tpf_find_labels(tpf_program& program) +bool sm4_find_labels(sm4_program& program) { if(program.labels_found) return true; @@ -101,11 +101,11 @@ bool tpf_find_labels(tpf_program& program) { switch(program.insns[insn_num]->opcode) { - case TPF_OPCODE_LABEL: + case SM4_OPCODE_LABEL: if(program.insns[insn_num]->num_ops > 0) { - tpf_op& op = *program.insns[insn_num]->ops[0]; - if(op.file == TPF_FILE_LABEL && op.has_simple_index()) + sm4_op& op = *program.insns[insn_num]->ops[0]; + if(op.file == SM4_FILE_LABEL && op.has_simple_index()) { unsigned idx = (unsigned)op.indices[0].disp; if(idx >= labels.size()) @@ -121,7 +121,7 @@ bool tpf_find_labels(tpf_program& program) return true; } -bool tpf_allocate_resource_sampler_pairs(tpf_program& program) +bool sm4_allocate_resource_sampler_pairs(sm4_program& program) { if(program.resource_sampler_slots_assigned) return true; @@ -135,16 +135,16 @@ bool tpf_allocate_resource_sampler_pairs(tpf_program& program) int sampler = -2; for(unsigned i = 0; i < program.insns[insn_num]->num_ops; ++i) { - tpf_op* op = program.insns[insn_num]->ops[i].get(); + sm4_op* op = program.insns[insn_num]->ops[i].get(); if(op) { - if(op->file == TPF_FILE_RESOURCE) + if(op->file == SM4_FILE_RESOURCE) { if(!op->has_simple_index() || resource >= 0) return false; resource = (int)op->indices[0].disp; } - if(op->file == TPF_FILE_SAMPLER) + if(op->file == SM4_FILE_SAMPLER) { if(!op->has_simple_index() || sampler >= 0) return false; @@ -154,11 +154,11 @@ bool tpf_allocate_resource_sampler_pairs(tpf_program& program) } unsigned opcode = program.insns[insn_num]->opcode; - if(opcode == TPF_OPCODE_LD || opcode == TPF_OPCODE_LD_MS) + if(opcode == SM4_OPCODE_LD || opcode == SM4_OPCODE_LD_MS) sampler = -1; if(sampler >= -1 && resource >= 0) pairs.insert(std::make_pair(resource, sampler)); - if(opcode == TPF_OPCODE_RESINFO) + if(opcode == SM4_OPCODE_RESINFO) resinfos.insert(resource); } diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_dump.cpp b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_dump.cpp index 2e6e0949a8..746d7c8927 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_dump.cpp +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_dump.cpp @@ -24,19 +24,19 @@ * **************************************************************************/ -#include "tpf.h" +#include "sm4.h" -// TODO: we should fix this to output the same syntax as fxc, if tpf_dump_ms_syntax is set +// TODO: we should fix this to output the same syntax as fxc, if sm4_dump_short_syntax is set -bool tpf_dump_ms_syntax = true; +bool sm4_dump_short_syntax = true; -std::ostream& operator <<(std::ostream& out, const tpf_op& op) +std::ostream& operator <<(std::ostream& out, const sm4_op& op) { if(op.neg) out << '-'; if(op.abs) out << '|'; - if(op.file == TPF_FILE_IMMEDIATE32) + if(op.file == SM4_FILE_IMMEDIATE32) { out << "l("; for(unsigned i = 0; i < op.comps; ++i) @@ -47,7 +47,7 @@ std::ostream& operator <<(std::ostream& out, const tpf_op& op) } out << ")"; } - else if(op.file == TPF_FILE_IMMEDIATE64) + else if(op.file == SM4_FILE_IMMEDIATE64) { out << "d("; for(unsigned i = 0; i < op.comps; ++i) @@ -62,17 +62,17 @@ std::ostream& operator <<(std::ostream& out, const tpf_op& op) else { bool naked = false; - if(tpf_dump_ms_syntax) + if(sm4_dump_short_syntax) { switch(op.file) { - case TPF_FILE_TEMP: - case TPF_FILE_INPUT: - case TPF_FILE_OUTPUT: - case TPF_FILE_CONSTANT_BUFFER: - case TPF_FILE_INDEXABLE_TEMP: - case TPF_FILE_UNORDERED_ACCESS_VIEW: - case TPF_FILE_THREAD_GROUP_SHARED_MEMORY: + case SM4_FILE_TEMP: + case SM4_FILE_INPUT: + case SM4_FILE_OUTPUT: + case SM4_FILE_CONSTANT_BUFFER: + case SM4_FILE_INDEXABLE_TEMP: + case SM4_FILE_UNORDERED_ACCESS_VIEW: + case SM4_FILE_THREAD_GROUP_SHARED_MEMORY: naked = true; break; default: @@ -81,7 +81,7 @@ std::ostream& operator <<(std::ostream& out, const tpf_op& op) } } - out << (tpf_dump_ms_syntax ? tpf_file_ms_names : tpf_file_names)[op.file]; + out << (sm4_dump_short_syntax ? sm4_shortfile_names : sm4_file_names)[op.file]; if(op.indices[0].reg.get()) naked = false; @@ -105,21 +105,21 @@ std::ostream& operator <<(std::ostream& out, const tpf_op& op) { switch(op.mode) { - case TPF_OPERAND_MODE_MASK: - out << (tpf_dump_ms_syntax ? '.' : '!'); + case SM4_OPERAND_MODE_MASK: + out << (sm4_dump_short_syntax ? '.' : '!'); for(unsigned i = 0; i < op.comps; ++i) { if(op.mask & (1 << i)) out << "xyzw"[i]; } break; - case TPF_OPERAND_MODE_SWIZZLE: + case SM4_OPERAND_MODE_SWIZZLE: out << '.'; for(unsigned i = 0; i < op.comps; ++i) out << "xyzw"[op.swizzle[i]]; break; - case TPF_OPERAND_MODE_SCALAR: - out << (tpf_dump_ms_syntax ? '.' : ':'); + case SM4_OPERAND_MODE_SCALAR: + out << (sm4_dump_short_syntax ? '.' : ':'); out << "xyzw"[op.swizzle[0]]; break; } @@ -130,12 +130,12 @@ std::ostream& operator <<(std::ostream& out, const tpf_op& op) return out; } -std::ostream& operator <<(std::ostream& out, const tpf_dcl& dcl) +std::ostream& operator <<(std::ostream& out, const sm4_dcl& dcl) { - out << tpf_opcode_names[dcl.opcode]; + out << sm4_opcode_names[dcl.opcode]; switch(dcl.opcode) { - case TPF_OPCODE_DCL_GLOBAL_FLAGS: + case SM4_OPCODE_DCL_GLOBAL_FLAGS: if(dcl.dcl_global_flags.allow_refactoring) out << " refactoringAllowed"; if(dcl.dcl_global_flags.early_depth_stencil) @@ -145,12 +145,12 @@ std::ostream& operator <<(std::ostream& out, const tpf_dcl& dcl) if(dcl.dcl_global_flags.enable_raw_and_structured_in_non_cs) out << " enableRawAndStructuredBuffers"; break; - case TPF_OPCODE_DCL_INPUT_PS: - case TPF_OPCODE_DCL_INPUT_PS_SIV: - case TPF_OPCODE_DCL_INPUT_PS_SGV: - out << ' ' << tpf_interpolation_names[dcl.dcl_input_ps.interpolation]; + case SM4_OPCODE_DCL_INPUT_PS: + case SM4_OPCODE_DCL_INPUT_PS_SIV: + case SM4_OPCODE_DCL_INPUT_PS_SGV: + out << ' ' << sm4_interpolation_names[dcl.dcl_input_ps.interpolation]; break; - case TPF_OPCODE_DCL_TEMPS: + case SM4_OPCODE_DCL_TEMPS: out << ' ' << dcl.num; break; default: @@ -160,25 +160,25 @@ std::ostream& operator <<(std::ostream& out, const tpf_dcl& dcl) out << ' ' << *dcl.op; switch(dcl.opcode) { - case TPF_OPCODE_DCL_CONSTANT_BUFFER: + case SM4_OPCODE_DCL_CONSTANT_BUFFER: out << ", " << (dcl.dcl_constant_buffer.dynamic ? "dynamicIndexed" : "immediateIndexed"); break; - case TPF_OPCODE_DCL_INPUT_SIV: - case TPF_OPCODE_DCL_INPUT_SGV: - case TPF_OPCODE_DCL_OUTPUT_SIV: - case TPF_OPCODE_DCL_OUTPUT_SGV: - case TPF_OPCODE_DCL_INPUT_PS_SIV: - case TPF_OPCODE_DCL_INPUT_PS_SGV: - out << ", " << tpf_sv_names[dcl.num]; + case SM4_OPCODE_DCL_INPUT_SIV: + case SM4_OPCODE_DCL_INPUT_SGV: + case SM4_OPCODE_DCL_OUTPUT_SIV: + case SM4_OPCODE_DCL_OUTPUT_SGV: + case SM4_OPCODE_DCL_INPUT_PS_SIV: + case SM4_OPCODE_DCL_INPUT_PS_SGV: + out << ", " << sm4_sv_names[dcl.num]; break; } return out; } -std::ostream& operator <<(std::ostream& out, const tpf_insn& insn) +std::ostream& operator <<(std::ostream& out, const sm4_insn& insn) { - out << tpf_opcode_names[insn.opcode]; + out << sm4_opcode_names[insn.opcode]; if(insn.insn.sat) out << "_sat"; for(unsigned i = 0; i < insn.num_ops; ++i) @@ -190,7 +190,7 @@ std::ostream& operator <<(std::ostream& out, const tpf_insn& insn) return out; } -std::ostream& operator <<(std::ostream& out, const tpf_program& program) +std::ostream& operator <<(std::ostream& out, const sm4_program& program) { out << "pvghdc"[program.version.type] << "s_" << program.version.major << "_" << program.version.minor << "\n"; for(unsigned i = 0; i < program.dcls.size(); ++i) @@ -201,22 +201,22 @@ std::ostream& operator <<(std::ostream& out, const tpf_program& program) return out; } -void tpf_op::dump() +void sm4_op::dump() { std::cout << *this; } -void tpf_insn::dump() +void sm4_insn::dump() { std::cout << *this; } -void tpf_dcl::dump() +void sm4_dcl::dump() { std::cout << *this; } -void tpf_program::dump() +void sm4_program::dump() { std::cout << *this; } diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_parse.cpp b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_parse.cpp index 2dfb88e5be..2c0f8269af 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/src/tpf_parse.cpp +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/src/sm4_parse.cpp @@ -24,7 +24,7 @@ * **************************************************************************/ -#include "tpf.h" +#include "sm4.h" #include "utils.h" #if 1 @@ -35,13 +35,13 @@ #define fail(x) throw(x) #endif -struct tpf_parser +struct sm4_parser { unsigned* tokens; unsigned* tokens_end; - tpf_program& program; + sm4_program& program; - tpf_parser(tpf_program& program, void* p_tokens, unsigned size) + sm4_parser(sm4_program& program, void* p_tokens, unsigned size) : program(program) { tokens = (unsigned*)p_tokens; @@ -73,12 +73,12 @@ struct tpf_parser tokens += toskip; } - void read_op(tpf_op* pop) + void read_op(sm4_op* pop) { - tpf_op& op = *pop; - tpf_token_operand optok; + sm4_op& op = *pop; + sm4_token_operand optok; read_token(&optok); - assert(optok.file < TPF_FILE_COUNT); + assert(optok.file < SM4_FILE_COUNT); op.swizzle[0] = 0; op.swizzle[1] = 1; op.swizzle[2] = 2; @@ -86,40 +86,40 @@ struct tpf_parser op.mask = 0xf; switch(optok.comps_enum) { - case TPF_OPERAND_COMPNUM_0: + case SM4_OPERAND_COMPNUM_0: op.comps = 0; break; - case TPF_OPERAND_COMPNUM_1: + case SM4_OPERAND_COMPNUM_1: op.comps = 1; break; - case TPF_OPERAND_COMPNUM_4: + case SM4_OPERAND_COMPNUM_4: op.comps = 4; op.mode = optok.mode; switch(optok.mode) { - case TPF_OPERAND_MODE_MASK: - op.mask = TPF_OPERAND_SEL_MASK(optok.sel); + case SM4_OPERAND_MODE_MASK: + op.mask = SM4_OPERAND_SEL_MASK(optok.sel); break; - case TPF_OPERAND_MODE_SWIZZLE: - op.swizzle[0] = TPF_OPERAND_SEL_SWZ(optok.sel, 0); - op.swizzle[1] = TPF_OPERAND_SEL_SWZ(optok.sel, 1); - op.swizzle[2] = TPF_OPERAND_SEL_SWZ(optok.sel, 2); - op.swizzle[3] = TPF_OPERAND_SEL_SWZ(optok.sel, 3); + case SM4_OPERAND_MODE_SWIZZLE: + op.swizzle[0] = SM4_OPERAND_SEL_SWZ(optok.sel, 0); + op.swizzle[1] = SM4_OPERAND_SEL_SWZ(optok.sel, 1); + op.swizzle[2] = SM4_OPERAND_SEL_SWZ(optok.sel, 2); + op.swizzle[3] = SM4_OPERAND_SEL_SWZ(optok.sel, 3); break; - case TPF_OPERAND_MODE_SCALAR: - op.swizzle[0] = op.swizzle[1] = op.swizzle[2] = op.swizzle[3] = TPF_OPERAND_SEL_SCALAR(optok.sel); + case SM4_OPERAND_MODE_SCALAR: + op.swizzle[0] = op.swizzle[1] = op.swizzle[2] = op.swizzle[3] = SM4_OPERAND_SEL_SCALAR(optok.sel); break; } break; - case TPF_OPERAND_COMPNUM_N: + case SM4_OPERAND_COMPNUM_N: fail("Unhandled operand component type"); } - op.file = (tpf_file)optok.file; + op.file = (sm4_file)optok.file; op.num_indices = optok.num_indices; if(optok.extended) { - tpf_token_operand_extended optokext; + sm4_token_operand_extended optokext; read_token(&optokext); if(optokext.type == 0) {} @@ -147,32 +147,32 @@ struct tpf_parser // TODO: is disp supposed to be signed here?? switch(repr) { - case TPF_OPERAND_INDEX_REPR_IMM32: + case SM4_OPERAND_INDEX_REPR_IMM32: op.indices[i].disp = (int32_t)read32(); break; - case TPF_OPERAND_INDEX_REPR_IMM64: + case SM4_OPERAND_INDEX_REPR_IMM64: op.indices[i].disp = read64(); break; - case TPF_OPERAND_INDEX_REPR_REG: + case SM4_OPERAND_INDEX_REPR_REG: relative: - op.indices[i].reg.reset(new tpf_op()); + op.indices[i].reg.reset(new sm4_op()); read_op(&*op.indices[0].reg); break; - case TPF_OPERAND_INDEX_REPR_REG_IMM32: + case SM4_OPERAND_INDEX_REPR_REG_IMM32: op.indices[i].disp = (int32_t)read32(); goto relative; - case TPF_OPERAND_INDEX_REPR_REG_IMM64: + case SM4_OPERAND_INDEX_REPR_REG_IMM64: op.indices[i].disp = read64(); goto relative; } } - if(op.file == TPF_FILE_IMMEDIATE32) + if(op.file == SM4_FILE_IMMEDIATE32) { for(unsigned i = 0; i < op.comps; ++i) op.imm_values[i].i32 = read32(); } - else if(op.file == TPF_FILE_IMMEDIATE64) + else if(op.file == SM4_FILE_IMMEDIATE64) { for(unsigned i = 0; i < op.comps; ++i) op.imm_values[i].i64 = read64(); @@ -188,114 +188,114 @@ relative: while(tokens != tokens_end) { - tpf_token_instruction insntok; + sm4_token_instruction insntok; read_token(&insntok); unsigned* insn_end = tokens - 1 + insntok.length; - tpf_opcode opcode = (tpf_opcode)insntok.opcode; - check(opcode < TPF_OPCODE_COUNT); + sm4_opcode opcode = (sm4_opcode)insntok.opcode; + check(opcode < SM4_OPCODE_COUNT); - if(opcode == TPF_OPCODE_CUSTOMDATA) + if(opcode == SM4_OPCODE_CUSTOMDATA) { unsigned customlen = read32() - 2; skip(customlen); continue; } - if((opcode >= TPF_OPCODE_DCL_RESOURCE && opcode <= TPF_OPCODE_DCL_GLOBAL_FLAGS) - || (opcode >= TPF_OPCODE_DCL_STREAM && opcode <= TPF_OPCODE_DCL_RESOURCE_STRUCTURED)) + if((opcode >= SM4_OPCODE_DCL_RESOURCE && opcode <= SM4_OPCODE_DCL_GLOBAL_FLAGS) + || (opcode >= SM4_OPCODE_DCL_STREAM && opcode <= SM4_OPCODE_DCL_RESOURCE_STRUCTURED)) { - tpf_dcl& dcl = *new tpf_dcl; + sm4_dcl& dcl = *new sm4_dcl; program.dcls.push_back(&dcl); - (tpf_token_instruction&)dcl = insntok; + (sm4_token_instruction&)dcl = insntok; - tpf_token_instruction_extended exttok; + sm4_token_instruction_extended exttok; memcpy(&exttok, &insntok, sizeof(exttok)); while(exttok.extended) { read_token(&exttok); } -#define READ_OP_ANY dcl.op.reset(new tpf_op()); read_op(&*dcl.op); +#define READ_OP_ANY dcl.op.reset(new sm4_op()); read_op(&*dcl.op); #define READ_OP(FILE) READ_OP_ANY - //check(dcl.op->file == TPF_FILE_##FILE); + //check(dcl.op->file == SM4_FILE_##FILE); switch(opcode) { - case TPF_OPCODE_DCL_GLOBAL_FLAGS: + case SM4_OPCODE_DCL_GLOBAL_FLAGS: break; - case TPF_OPCODE_DCL_RESOURCE: + case SM4_OPCODE_DCL_RESOURCE: READ_OP(RESOURCE); read_token(&dcl.rrt); break; - case TPF_OPCODE_DCL_SAMPLER: + case SM4_OPCODE_DCL_SAMPLER: READ_OP(SAMPLER); break; - case TPF_OPCODE_DCL_INPUT: - case TPF_OPCODE_DCL_INPUT_PS: + case SM4_OPCODE_DCL_INPUT: + case SM4_OPCODE_DCL_INPUT_PS: READ_OP(INPUT); break; - case TPF_OPCODE_DCL_INPUT_SIV: - case TPF_OPCODE_DCL_INPUT_SGV: - case TPF_OPCODE_DCL_INPUT_PS_SIV: - case TPF_OPCODE_DCL_INPUT_PS_SGV: + case SM4_OPCODE_DCL_INPUT_SIV: + case SM4_OPCODE_DCL_INPUT_SGV: + case SM4_OPCODE_DCL_INPUT_PS_SIV: + case SM4_OPCODE_DCL_INPUT_PS_SGV: READ_OP(INPUT); - dcl.sv = (tpf_sv)(uint16_t)read32(); + dcl.sv = (sm4_sv)(uint16_t)read32(); break; - case TPF_OPCODE_DCL_OUTPUT: + case SM4_OPCODE_DCL_OUTPUT: READ_OP(OUTPUT); break; - case TPF_OPCODE_DCL_OUTPUT_SIV: - case TPF_OPCODE_DCL_OUTPUT_SGV: + case SM4_OPCODE_DCL_OUTPUT_SIV: + case SM4_OPCODE_DCL_OUTPUT_SGV: READ_OP(OUTPUT); - dcl.sv = (tpf_sv)(uint16_t)read32(); + dcl.sv = (sm4_sv)(uint16_t)read32(); break; - case TPF_OPCODE_DCL_INDEX_RANGE: + case SM4_OPCODE_DCL_INDEX_RANGE: READ_OP_ANY; - check(dcl.op->file == TPF_FILE_INPUT || dcl.op->file == TPF_FILE_OUTPUT); + check(dcl.op->file == SM4_FILE_INPUT || dcl.op->file == SM4_FILE_OUTPUT); dcl.num = read32(); break; - case TPF_OPCODE_DCL_TEMPS: + case SM4_OPCODE_DCL_TEMPS: dcl.num = read32(); break; - case TPF_OPCODE_DCL_INDEXABLE_TEMP: + case SM4_OPCODE_DCL_INDEXABLE_TEMP: READ_OP(INDEXABLE_TEMP); dcl.indexable_temp.num = read32(); dcl.indexable_temp.comps = read32(); break; - case TPF_OPCODE_DCL_CONSTANT_BUFFER: + case SM4_OPCODE_DCL_CONSTANT_BUFFER: READ_OP(CONSTANT_BUFFER); break; - case TPF_OPCODE_DCL_GS_INPUT_PRIMITIVE: - case TPF_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY: + case SM4_OPCODE_DCL_GS_INPUT_PRIMITIVE: + case SM4_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY: break; - case TPF_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT: + case SM4_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT: dcl.num = read32(); break; - case TPF_OPCODE_DCL_GS_INSTANCE_COUNT: + case SM4_OPCODE_DCL_GS_INSTANCE_COUNT: dcl.num = read32(); break; - case TPF_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT: - case TPF_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT: - case TPF_OPCODE_DCL_TESS_DOMAIN: - case TPF_OPCODE_DCL_TESS_PARTITIONING: - case TPF_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE: + case SM4_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT: + case SM4_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT: + case SM4_OPCODE_DCL_TESS_DOMAIN: + case SM4_OPCODE_DCL_TESS_PARTITIONING: + case SM4_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE: break; - case TPF_OPCODE_DCL_HS_MAX_TESSFACTOR: + case SM4_OPCODE_DCL_HS_MAX_TESSFACTOR: dcl.f32 = read32(); break; - case TPF_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT: + case SM4_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT: dcl.num = read32(); break; - case TPF_OPCODE_DCL_FUNCTION_BODY: + case SM4_OPCODE_DCL_FUNCTION_BODY: dcl.num = read32(); break; - case TPF_OPCODE_DCL_FUNCTION_TABLE: + case SM4_OPCODE_DCL_FUNCTION_TABLE: dcl.num = read32(); dcl.data = malloc(dcl.num * sizeof(uint32_t)); for(unsigned i = 0; i < dcl.num; ++i) ((uint32_t*)dcl.data)[i] = read32(); break; - case TPF_OPCODE_DCL_INTERFACE: + case SM4_OPCODE_DCL_INTERFACE: dcl.intf.id = read32(); dcl.intf.expected_function_table_length = read32(); { @@ -307,39 +307,39 @@ relative: for(unsigned i = 0; i < dcl.intf.table_length; ++i) ((uint32_t*)dcl.data)[i] = read32(); break; - case TPF_OPCODE_DCL_THREAD_GROUP: + case SM4_OPCODE_DCL_THREAD_GROUP: dcl.thread_group_size[0] = read32(); dcl.thread_group_size[1] = read32(); dcl.thread_group_size[2] = read32(); break; - case TPF_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED: + case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED: READ_OP(UNORDERED_ACCESS_VIEW); read_token(&dcl.rrt); break; - case TPF_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW: + case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW: READ_OP(UNORDERED_ACCESS_VIEW); break; - case TPF_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED: + case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED: READ_OP(UNORDERED_ACCESS_VIEW); dcl.structured.stride = read32(); break; - case TPF_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW: + case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW: READ_OP(THREAD_GROUP_SHARED_MEMORY); dcl.num = read32(); break; - case TPF_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED: + case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED: READ_OP(THREAD_GROUP_SHARED_MEMORY); dcl.structured.stride = read32(); dcl.structured.count = read32(); break; - case TPF_OPCODE_DCL_RESOURCE_RAW: + case SM4_OPCODE_DCL_RESOURCE_RAW: READ_OP(RESOURCE); break; - case TPF_OPCODE_DCL_RESOURCE_STRUCTURED: + case SM4_OPCODE_DCL_RESOURCE_STRUCTURED: READ_OP(RESOURCE); dcl.structured.stride = read32(); break; - case TPF_OPCODE_DCL_STREAM: + case SM4_OPCODE_DCL_STREAM: /* TODO: dcl_stream is undocumented: what is it? */ fail("Unhandled dcl_stream since it's undocumented"); default: @@ -350,24 +350,24 @@ relative: } else { - tpf_insn& insn = *new tpf_insn; + sm4_insn& insn = *new sm4_insn; program.insns.push_back(&insn); - (tpf_token_instruction&)insn = insntok; + (sm4_token_instruction&)insn = insntok; - tpf_token_instruction_extended exttok; + sm4_token_instruction_extended exttok; memcpy(&exttok, &insntok, sizeof(exttok)); while(exttok.extended) { read_token(&exttok); - if(exttok.type == TPF_TOKEN_INSTRUCTION_EXTENDED_TYPE_SAMPLE_CONTROLS) + if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_SAMPLE_CONTROLS) { insn.sample_offset[0] = exttok.sample_controls.offset_u; insn.sample_offset[1] = exttok.sample_controls.offset_v; insn.sample_offset[2] = exttok.sample_controls.offset_w; } - else if(exttok.type == TPF_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_DIM) + else if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_DIM) insn.resource_target = exttok.resource_target.target; - else if(exttok.type == TPF_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_RETURN_TYPE) + else if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_RETURN_TYPE) { insn.resource_return_type[0] = exttok.resource_return_type.x; insn.resource_return_type[1] = exttok.resource_return_type.y; @@ -378,7 +378,7 @@ relative: switch(opcode) { - case TPF_OPCODE_INTERFACE_CALL: + case SM4_OPCODE_INTERFACE_CALL: insn.num = read32(); break; default: @@ -389,8 +389,8 @@ relative: while(tokens != insn_end) { check(tokens < insn_end); - check(op_num < TPF_MAX_OPS); - insn.ops[op_num].reset(new tpf_op); + check(op_num < SM4_MAX_OPS); + insn.ops[op_num].reset(new sm4_op); read_op(&*insn.ops[op_num]); ++op_num; } @@ -413,10 +413,10 @@ relative: } }; -tpf_program* tpf_parse(void* tokens, int size) +sm4_program* sm4_parse(void* tokens, int size) { - tpf_program* program = new tpf_program; - tpf_parser parser(*program, tokens, size); + sm4_program* program = new sm4_program; + sm4_parser parser(*program, tokens, size); if(!parser.parse()) return program; delete program; diff --git a/src/gallium/state_trackers/d3d1x/d3d1xshader/tools/fxdis.cpp b/src/gallium/state_trackers/d3d1x/d3d1xshader/tools/fxdis.cpp index 721f95fc8a..20a7cbd1c3 100644 --- a/src/gallium/state_trackers/d3d1x/d3d1xshader/tools/fxdis.cpp +++ b/src/gallium/state_trackers/d3d1x/d3d1xshader/tools/fxdis.cpp @@ -25,7 +25,7 @@ **************************************************************************/ #include "dxbc.h" -#include "tpf.h" +#include "sm4.h" #include <iostream> #include <fstream> @@ -60,14 +60,14 @@ int main(int argc, char** argv) if(dxbc) { std::cout << *dxbc; - dxbc_chunk_header* tpf_chunk = dxbc_find_shader_bytecode(&data[0], data.size()); - if(tpf_chunk) + dxbc_chunk_header* sm4_chunk = dxbc_find_shader_bytecode(&data[0], data.size()); + if(sm4_chunk) { - tpf_program* tpf = tpf_parse(tpf_chunk + 1, bswap_le32(tpf_chunk->size)); - if(tpf) + sm4_program* sm4 = sm4_parse(sm4_chunk + 1, bswap_le32(sm4_chunk->size)); + if(sm4) { - std::cout << *tpf; - delete tpf; + std::cout << *sm4; + delete sm4; } } delete dxbc; diff --git a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h index 50039e388d..0c8d3ed943 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h +++ b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h @@ -1172,17 +1172,17 @@ struct GalliumD3D11ScreenImpl : public GalliumD3D11Screen #endif ) { - dxbc_chunk_header* tpf_chunk = dxbc_find_shader_bytecode(pShaderBytecode, BytecodeLength); - if(!tpf_chunk) + dxbc_chunk_header* sm4_chunk = dxbc_find_shader_bytecode(pShaderBytecode, BytecodeLength); + if(!sm4_chunk) return 0; - std::auto_ptr<tpf_program> tpf(tpf_parse(tpf_chunk + 1, bswap_le32(tpf_chunk->size))); - if(!tpf.get()) + std::auto_ptr<sm4_program> sm4(sm4_parse(sm4_chunk + 1, bswap_le32(sm4_chunk->size))); + if(!sm4.get()) return 0; struct pipe_shader_state tgsi_shader; memset(&tgsi_shader, 0, sizeof(tgsi_shader)); - tgsi_shader.tokens = (const tgsi_token*)tpf_to_tgsi(*tpf); + tgsi_shader.tokens = (const tgsi_token*)sm4_to_tgsi(*sm4); if(!tgsi_shader.tokens) return 0; @@ -1211,8 +1211,8 @@ struct GalliumD3D11ScreenImpl : public GalliumD3D11Screen if(shader) { - shader->slot_to_resource = tpf->slot_to_resource; - shader->slot_to_sampler = tpf->slot_to_sampler; + shader->slot_to_resource = sm4->slot_to_resource; + shader->slot_to_sampler = sm4->slot_to_sampler; } free((void*)tgsi_shader.tokens); diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h index 6756b2112d..0274a1baf6 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h +++ b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h @@ -33,8 +33,8 @@ #include <float.h> #include "dxbc.h" -#include "tpf.h" -#include "tpf_to_tgsi.h" +#include "sm4.h" +#include "sm4_to_tgsi.h" #include "d3d1xstutil.h" diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.cpp b/src/gallium/state_trackers/d3d1x/gd3d1x/sm4_to_tgsi.cpp index 4d7c296bb6..995059e15b 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.cpp +++ b/src/gallium/state_trackers/d3d1x/gd3d1x/sm4_to_tgsi.cpp @@ -24,7 +24,7 @@ * **************************************************************************/ -#include "tpf.h" +#include "sm4.h" #include "tgsi/tgsi_ureg.h" #include <vector> @@ -36,7 +36,7 @@ #define fail(x) throw(x) #endif -static unsigned tpf_to_pipe_interpolation[] = +static unsigned sm4_to_pipe_interpolation[] = { TGSI_INTERPOLATE_PERSPECTIVE, /* UNDEFINED */ TGSI_INTERPOLATE_CONSTANT, @@ -50,7 +50,7 @@ static unsigned tpf_to_pipe_interpolation[] = TGSI_INTERPOLATE_LINEAR, /* LINEAR_NOPERSPECTIVE_SAMPLE */ }; -static int tpf_to_pipe_sv[] = +static int sm4_to_pipe_sv[] = { -1, TGSI_SEMANTIC_POSITION, @@ -65,7 +65,7 @@ static int tpf_to_pipe_sv[] = -1, /*TGSI_SEMANTIC_SAMPLE_INDEX*/ }; -struct tpf_to_tgsi_converter +struct sm4_to_tgsi_converter { struct ureg_program* ureg; std::vector<struct ureg_dst> temps; @@ -75,37 +75,37 @@ struct tpf_to_tgsi_converter std::vector<std::pair<unsigned, unsigned> > targets; // first is normal, second shadow/comparison std::vector<unsigned> sampler_modes; // 0 = normal, 1 = shadow/comparison std::vector<std::pair<unsigned, unsigned> > loops; - tpf_insn* insn; - struct tpf_program& program; - std::vector<unsigned> tpf_to_tgsi_insn_num; - std::vector<std::pair<unsigned, unsigned> > label_to_tpf_insn_num; + sm4_insn* insn; + struct sm4_program& program; + std::vector<unsigned> sm4_to_tgsi_insn_num; + std::vector<std::pair<unsigned, unsigned> > label_to_sm4_insn_num; bool in_sub; bool avoid_txf; bool avoid_int; - tpf_to_tgsi_converter(struct tpf_program& program) + sm4_to_tgsi_converter(struct sm4_program& program) : program(program) { avoid_txf = true; avoid_int = false; } - struct ureg_dst _reg(tpf_op& op) + struct ureg_dst _reg(sm4_op& op) { switch(op.file) { - case TPF_FILE_NULL: + case SM4_FILE_NULL: { struct ureg_dst d; memset(&d, 0, sizeof(d)); d.File = TGSI_FILE_NULL; return d; } - case TPF_FILE_TEMP: + case SM4_FILE_TEMP: check(op.has_simple_index()); check(op.indices[0].disp < temps.size()); return temps[op.indices[0].disp]; - case TPF_FILE_OUTPUT: + case SM4_FILE_OUTPUT: check(op.has_simple_index()); check(op.indices[0].disp < outputs.size()); return outputs[op.indices[0].disp]; @@ -118,8 +118,8 @@ struct tpf_to_tgsi_converter struct ureg_dst _dst(unsigned i = 0) { check(i < insn->num_ops); - tpf_op& op = *insn->ops[i]; - check(op.mode == TPF_OPERAND_MODE_MASK || op.mode == TPF_OPERAND_MODE_SCALAR); + sm4_op& op = *insn->ops[i]; + check(op.mode == SM4_OPERAND_MODE_MASK || op.mode == SM4_OPERAND_MODE_SCALAR); struct ureg_dst d = ureg_writemask(_reg(op), op.mask); if(insn->insn.sat) d = ureg_saturate(d); @@ -129,19 +129,19 @@ struct tpf_to_tgsi_converter struct ureg_src _src(unsigned i) { check(i < insn->num_ops); - tpf_op& op = *insn->ops[i]; + sm4_op& op = *insn->ops[i]; struct ureg_src s; switch(op.file) { - case TPF_FILE_IMMEDIATE32: + case SM4_FILE_IMMEDIATE32: s = ureg_imm4f(ureg, op.imm_values[0].f32, op.imm_values[1].f32, op.imm_values[2].f32, op.imm_values[3].f32); break; - case TPF_FILE_INPUT: + case SM4_FILE_INPUT: check(op.has_simple_index()); check(op.indices[0].disp < inputs.size()); s = inputs[op.indices[0].disp]; break; - case TPF_FILE_CONSTANT_BUFFER: + case SM4_FILE_CONSTANT_BUFFER: // TODO: indirect addressing check(op.num_indices == 2); check(op.is_index_simple(0)); @@ -154,12 +154,12 @@ struct tpf_to_tgsi_converter s = ureg_src(_reg(op)); break; } - if(op.mode == TPF_OPERAND_MODE_SWIZZLE || op.mode == TPF_OPERAND_MODE_SCALAR) + if(op.mode == SM4_OPERAND_MODE_SWIZZLE || op.mode == SM4_OPERAND_MODE_SCALAR) s = ureg_swizzle(s, op.swizzle[0], op.swizzle[1], op.swizzle[2], op.swizzle[3]); else { /* immediates are masked to show needed values */ - check(op.file == TPF_FILE_IMMEDIATE32 || op.file == TPF_FILE_IMMEDIATE64); + check(op.file == SM4_FILE_IMMEDIATE32 || op.file == SM4_FILE_IMMEDIATE64); } if(op.abs) s = ureg_abs(s); @@ -168,10 +168,10 @@ struct tpf_to_tgsi_converter return s; }; - int _idx(tpf_file file, unsigned i = 0) + int _idx(sm4_file file, unsigned i = 0) { check(i < insn->num_ops); - tpf_op& op = *insn->ops[i]; + sm4_op& op = *insn->ops[i]; check(op.file == file); check(op.has_simple_index()); return (int)op.indices[0].disp; @@ -180,7 +180,7 @@ struct tpf_to_tgsi_converter int _texslot(bool have_sampler = true) { std::map<std::pair<int, int>, int>::iterator i; - i = program.resource_sampler_to_slot.find(std::make_pair(_idx(TPF_FILE_RESOURCE, 2), have_sampler ? _idx(TPF_FILE_SAMPLER, 3) : -1)); + i = program.resource_sampler_to_slot.find(std::make_pair(_idx(SM4_FILE_RESOURCE, 2), have_sampler ? _idx(SM4_FILE_SAMPLER, 3) : -1)); check(i != program.resource_sampler_to_slot.end()); return i->second; } @@ -214,19 +214,19 @@ struct tpf_to_tgsi_converter return ureg_writemask(_tmp(), d.WriteMask); } -#define OP1_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1)); break -#define OP2_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2)); break -#define OP3_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2), _src(3)); break +#define OP1_(d, g) case SM4_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1)); break +#define OP2_(d, g) case SM4_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2)); break +#define OP3_(d, g) case SM4_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2), _src(3)); break #define OP1(n) OP1_(n, n) #define OP2(n) OP2_(n, n) #define OP3(n) OP3_(n, n) -#define OP_CF(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, &label); label_to_tpf_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num])); break; +#define OP_CF(d, g) case SM4_OPCODE_##d: ureg_##g(ureg, &label); label_to_sm4_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num])); break; void translate_insns(unsigned begin, unsigned end) { for(unsigned insn_num = begin; insn_num < end; ++insn_num) { - tpf_to_tgsi_insn_num[insn_num] = ureg_get_instruction_number(ureg); + sm4_to_tgsi_insn_num[insn_num] = ureg_get_instruction_number(ureg); unsigned label; insn = program.insns[insn_num]; bool ok; @@ -234,7 +234,7 @@ struct tpf_to_tgsi_converter switch(insn->opcode) { // trivial instructions - case TPF_OPCODE_NOP: + case SM4_OPCODE_NOP: break; OP1(MOV); @@ -279,26 +279,26 @@ struct tpf_to_tgsi_converter OP1_(DERIV_RTY, DDY); OP1_(DERIV_RTY_COARSE, DDY); OP1_(DERIV_RTY_FINE, DDY); - case TPF_OPCODE_EMIT: + case SM4_OPCODE_EMIT: ureg_EMIT(ureg); break; - case TPF_OPCODE_CUT: + case SM4_OPCODE_CUT: ureg_ENDPRIM(ureg); break; - case TPF_OPCODE_EMITTHENCUT: + case SM4_OPCODE_EMITTHENCUT: ureg_EMIT(ureg); ureg_ENDPRIM(ureg); break; // non-trivial instructions - case TPF_OPCODE_MOVC: + case SM4_OPCODE_MOVC: /* CMP checks for < 0, but MOVC checks for != 0 * but fortunately, x != 0 is equivalent to -abs(x) < 0 * XXX: can test_nz apply to this?! */ ureg_CMP(ureg, _dst(), ureg_negate(ureg_abs(_src(1))), _src(2), _src(3)); break; - case TPF_OPCODE_SQRT: + case SM4_OPCODE_SQRT: { struct ureg_dst d = _dst(); struct ureg_dst t = _tmp(d); @@ -306,7 +306,7 @@ struct tpf_to_tgsi_converter ureg_RCP(ureg, d, ureg_src(t)); break; } - case TPF_OPCODE_SINCOS: + case SM4_OPCODE_SINCOS: { struct ureg_dst s = _dst(0); struct ureg_dst c = _dst(1); @@ -319,45 +319,45 @@ struct tpf_to_tgsi_converter } // control flow - case TPF_OPCODE_DISCARD: + case SM4_OPCODE_DISCARD: ureg_KIL(ureg, _src(0)); break; OP_CF(LOOP, BGNLOOP); OP_CF(ENDLOOP, ENDLOOP); - case TPF_OPCODE_BREAK: + case SM4_OPCODE_BREAK: ureg_BRK(ureg); break; - case TPF_OPCODE_BREAKC: + case SM4_OPCODE_BREAKC: // XXX: can test_nz apply to this?! ureg_BREAKC(ureg, _src(0)); break; - case TPF_OPCODE_CONTINUE: + case SM4_OPCODE_CONTINUE: ureg_CONT(ureg); break; - case TPF_OPCODE_CONTINUEC: + case SM4_OPCODE_CONTINUEC: // XXX: can test_nz apply to this?! ureg_IF(ureg, _src(0), &label); ureg_CONT(ureg); ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg)); ureg_ENDIF(ureg); break; - case TPF_OPCODE_SWITCH: + case SM4_OPCODE_SWITCH: ureg_SWITCH(ureg, _src(0)); break; - case TPF_OPCODE_CASE: + case SM4_OPCODE_CASE: ureg_CASE(ureg, _src(0)); break; - case TPF_OPCODE_DEFAULT: + case SM4_OPCODE_DEFAULT: ureg_DEFAULT(ureg); break; - case TPF_OPCODE_ENDSWITCH: + case SM4_OPCODE_ENDSWITCH: ureg_ENDSWITCH(ureg); break; - case TPF_OPCODE_CALL: + case SM4_OPCODE_CALL: ureg_CAL(ureg, &label); - label_to_tpf_insn_num.push_back(std::make_pair(label, program.label_to_insn_num[_idx(TPF_FILE_LABEL)])); + label_to_sm4_insn_num.push_back(std::make_pair(label, program.label_to_insn_num[_idx(SM4_FILE_LABEL)])); break; - case TPF_OPCODE_LABEL: + case SM4_OPCODE_LABEL: if(in_sub) ureg_ENDSUB(ureg); else @@ -365,11 +365,11 @@ struct tpf_to_tgsi_converter ureg_BGNSUB(ureg); in_sub = true; break; - case TPF_OPCODE_RET: + case SM4_OPCODE_RET: if(in_sub || insn_num != (program.insns.size() - 1)) ureg_RET(ureg); break; - case TPF_OPCODE_RETC: + case SM4_OPCODE_RETC: ureg_IF(ureg, _src(0), &label); if(insn->insn.test_nz) ureg_RET(ureg); @@ -383,24 +383,24 @@ struct tpf_to_tgsi_converter ureg_ENDIF(ureg); break; OP_CF(ELSE, ELSE); - case TPF_OPCODE_ENDIF: + case SM4_OPCODE_ENDIF: ureg_ENDIF(ureg); break; - case TPF_OPCODE_IF: + case SM4_OPCODE_IF: if(insn->insn.test_nz) { ureg_IF(ureg, _src(0), &label); - label_to_tpf_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num])); + label_to_sm4_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num])); } else { unsigned linked = program.cf_insn_linked[insn_num]; - if(program.insns[linked]->opcode == TPF_OPCODE_ENDIF) + if(program.insns[linked]->opcode == SM4_OPCODE_ENDIF) { ureg_IF(ureg, _src(0), &label); ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg)); ureg_ELSE(ureg, &label); - label_to_tpf_insn_num.push_back(std::make_pair(label, linked)); + label_to_sm4_insn_num.push_back(std::make_pair(label, linked)); } else { @@ -410,13 +410,13 @@ struct tpf_to_tgsi_converter unsigned endif = program.cf_insn_linked[linked]; ureg_IF(ureg, _src(0), &label); - label_to_tpf_insn_num.push_back(std::make_pair(label, linked)); + label_to_sm4_insn_num.push_back(std::make_pair(label, linked)); translate_insns(linked + 1, endif); - tpf_to_tgsi_insn_num[linked] = ureg_get_instruction_number(ureg); + sm4_to_tgsi_insn_num[linked] = ureg_get_instruction_number(ureg); ureg_ELSE(ureg, &label); - label_to_tpf_insn_num.push_back(std::make_pair(label, endif)); + label_to_sm4_insn_num.push_back(std::make_pair(label, endif)); translate_insns(insn_num + 1, linked); @@ -425,10 +425,10 @@ struct tpf_to_tgsi_converter } } break; - case TPF_OPCODE_RESINFO: + case SM4_OPCODE_RESINFO: { std::map<int, int>::iterator i; - i = program.resource_to_slot.find(_idx(TPF_FILE_RESOURCE, 2)); + i = program.resource_to_slot.find(_idx(SM4_FILE_RESOURCE, 2)); check(i != program.resource_to_slot.end()); unsigned texslot = i->second; @@ -437,8 +437,8 @@ struct tpf_to_tgsi_converter break; }; // TODO: sample offset, sample index - case TPF_OPCODE_LD: // dst, coord_int, res; mipmap level in last coord_int arg (ouch) - case TPF_OPCODE_LD_MS: + case SM4_OPCODE_LD: // dst, coord_int, res; mipmap level in last coord_int arg (ouch) + case SM4_OPCODE_LD_MS: { unsigned texslot = _texslot(false); unsigned dim = 0; @@ -475,13 +475,13 @@ struct tpf_to_tgsi_converter ureg_TXF(ureg, _dst(), tex_target(texslot), ureg_swizzle(_src(1), 0, 1, 2, dim), samplers[texslot]); break; } - case TPF_OPCODE_SAMPLE: // dst, coord, res, samp + case SM4_OPCODE_SAMPLE: // dst, coord, res, samp { unsigned texslot = _texslot(); ureg_TEX(ureg, _dst(), tex_target(texslot), _src(1), samplers[texslot]); break; } - case TPF_OPCODE_SAMPLE_B: // dst, coord, res, samp, bias.x + case SM4_OPCODE_SAMPLE_B: // dst, coord, res, samp, bias.x { unsigned texslot = _texslot(); struct ureg_dst tmp = _tmp(); @@ -490,7 +490,7 @@ struct tpf_to_tgsi_converter ureg_TXB(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]); break; } - case TPF_OPCODE_SAMPLE_C: // dst, coord, res, samp, comp.x + case SM4_OPCODE_SAMPLE_C: // dst, coord, res, samp, comp.x { unsigned texslot = _texslot(); struct ureg_dst tmp = _tmp(); @@ -499,7 +499,7 @@ struct tpf_to_tgsi_converter ureg_TEX(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]); break; } - case TPF_OPCODE_SAMPLE_C_LZ: // dst, coord, res, samp, comp.x + case SM4_OPCODE_SAMPLE_C_LZ: // dst, coord, res, samp, comp.x { unsigned texslot = _texslot(); struct ureg_dst tmp = _tmp(); @@ -509,13 +509,13 @@ struct tpf_to_tgsi_converter ureg_TXL(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]); break; } - case TPF_OPCODE_SAMPLE_D: // dst, coord, res, samp, ddx, ddy + case SM4_OPCODE_SAMPLE_D: // dst, coord, res, samp, ddx, ddy { unsigned texslot = _texslot(); ureg_TXD(ureg, _dst(), tex_target(texslot), _src(1), samplers[texslot], _src(4), _src(5)); break; } - case TPF_OPCODE_SAMPLE_L: // dst, coord, res, samp, bias.x + case SM4_OPCODE_SAMPLE_L: // dst, coord, res, samp, bias.x { unsigned texslot = _texslot(); struct ureg_dst tmp = _tmp(); @@ -561,7 +561,7 @@ struct tpf_to_tgsi_converter OP2_(UGE, USGE); OP2(USHR); - case TPF_OPCODE_UDIV: + case SM4_OPCODE_UDIV: { struct ureg_dst q = _dst(0); struct ureg_dst r = _dst(1); @@ -583,8 +583,8 @@ struct tpf_to_tgsi_converter ok = true; switch(insn->opcode) { - case TPF_OPCODE_ITOF: - case TPF_OPCODE_UTOF: + case SM4_OPCODE_ITOF: + case SM4_OPCODE_UTOF: break; OP1_(FTOI, TRUNC); OP1_(FTOU, FLR); @@ -607,10 +607,10 @@ struct tpf_to_tgsi_converter OP2_(ULT, SLT); OP2_(UGE, SGE); - case TPF_OPCODE_INEG: + case SM4_OPCODE_INEG: ureg_MOV(ureg, _dst(), ureg_negate(_src(1))); break; - case TPF_OPCODE_ISHL: + case SM4_OPCODE_ISHL: { struct ureg_dst d = _dst(); struct ureg_dst t = _tmp(d); @@ -618,8 +618,8 @@ struct tpf_to_tgsi_converter ureg_MUL(ureg, d, ureg_src(t), _src(1)); break; } - case TPF_OPCODE_ISHR: - case TPF_OPCODE_USHR: + case SM4_OPCODE_ISHR: + case SM4_OPCODE_USHR: { struct ureg_dst d = _dst(); struct ureg_dst t = _tmp(d); @@ -628,7 +628,7 @@ struct tpf_to_tgsi_converter ureg_FLR(ureg, d, ureg_src(t)); break; } - case TPF_OPCODE_UDIV: + case SM4_OPCODE_UDIV: { struct ureg_dst q = _dst(0); struct ureg_dst r = _dst(1); @@ -681,11 +681,11 @@ next:; return 0; } - if(!tpf_link_cf_insns(program)) + if(!sm4_link_cf_insns(program)) fail("Malformed control flow"); - if(!tpf_find_labels(program)) + if(!sm4_find_labels(program)) fail("Failed to locate labels"); - if(!tpf_allocate_resource_sampler_pairs(program)) + if(!sm4_allocate_resource_sampler_pairs(program)) fail("Unsupported (indirect?) accesses to resources and/or samplers"); ureg = ureg_create(processor); @@ -695,22 +695,22 @@ next:; for(unsigned i = 0; i < program.slot_to_resource.size(); ++i) samplers.push_back(ureg_DECL_sampler(ureg, i)); - tpf_to_tgsi_insn_num.resize(program.insns.size()); + sm4_to_tgsi_insn_num.resize(program.insns.size()); for(unsigned insn_num = 0; insn_num < program.dcls.size(); ++insn_num) { - tpf_dcl& dcl = *program.dcls[insn_num]; + sm4_dcl& dcl = *program.dcls[insn_num]; int idx = -1; if(dcl.op.get() && dcl.op->has_simple_index()) idx = dcl.op->indices[0].disp; switch(dcl.opcode) { - case TPF_OPCODE_DCL_GLOBAL_FLAGS: + case SM4_OPCODE_DCL_GLOBAL_FLAGS: break; - case TPF_OPCODE_DCL_TEMPS: + case SM4_OPCODE_DCL_TEMPS: for(unsigned i = 0; i < dcl.num; ++i) temps.push_back(ureg_DECL_temporary(ureg)); break; - case TPF_OPCODE_DCL_INPUT: + case SM4_OPCODE_DCL_INPUT: check(idx >= 0); if(inputs.size() <= (unsigned)idx) inputs.resize(idx + 1); @@ -719,13 +719,13 @@ next:; else check(0); break; - case TPF_OPCODE_DCL_INPUT_PS: + case SM4_OPCODE_DCL_INPUT_PS: check(idx >= 0); if(inputs.size() <= (unsigned)idx) inputs.resize(idx + 1); - inputs[idx] = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_GENERIC, idx, tpf_to_pipe_interpolation[dcl.dcl_input_ps.interpolation]); + inputs[idx] = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_GENERIC, idx, sm4_to_pipe_interpolation[dcl.dcl_input_ps.interpolation]); break; - case TPF_OPCODE_DCL_OUTPUT: + case SM4_OPCODE_DCL_OUTPUT: check(idx >= 0); if(outputs.size() <= (unsigned)idx) outputs.resize(idx + 1); @@ -734,43 +734,43 @@ next:; else outputs[idx] = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, idx); break; - case TPF_OPCODE_DCL_INPUT_SIV: - case TPF_OPCODE_DCL_INPUT_SGV: - case TPF_OPCODE_DCL_INPUT_PS_SIV: - case TPF_OPCODE_DCL_INPUT_PS_SGV: + case SM4_OPCODE_DCL_INPUT_SIV: + case SM4_OPCODE_DCL_INPUT_SGV: + case SM4_OPCODE_DCL_INPUT_PS_SIV: + case SM4_OPCODE_DCL_INPUT_PS_SGV: check(idx >= 0); if(inputs.size() <= (unsigned)idx) inputs.resize(idx + 1); // TODO: is this correct? - inputs[idx] = ureg_DECL_system_value(ureg, idx, tpf_to_pipe_sv[dcl.sv], 0); + inputs[idx] = ureg_DECL_system_value(ureg, idx, sm4_to_pipe_sv[dcl.sv], 0); break; - case TPF_OPCODE_DCL_OUTPUT_SIV: - case TPF_OPCODE_DCL_OUTPUT_SGV: + case SM4_OPCODE_DCL_OUTPUT_SIV: + case SM4_OPCODE_DCL_OUTPUT_SGV: check(idx >= 0); if(outputs.size() <= (unsigned)idx) outputs.resize(idx + 1); - check(tpf_to_pipe_sv[dcl.sv] >= 0); - outputs[idx] = ureg_DECL_output(ureg, tpf_to_pipe_sv[dcl.sv], 0); + check(sm4_to_pipe_sv[dcl.sv] >= 0); + outputs[idx] = ureg_DECL_output(ureg, sm4_to_pipe_sv[dcl.sv], 0); break; - case TPF_OPCODE_DCL_RESOURCE: + case SM4_OPCODE_DCL_RESOURCE: check(idx >= 0); if(targets.size() <= (unsigned)idx) targets.resize(idx + 1); switch(dcl.dcl_resource.target) { - case TPF_TARGET_TEXTURE1D: + case SM4_TARGET_TEXTURE1D: targets[idx].first = TGSI_TEXTURE_1D; targets[idx].second = TGSI_TEXTURE_SHADOW1D; break; - case TPF_TARGET_TEXTURE2D: + case SM4_TARGET_TEXTURE2D: targets[idx].first = TGSI_TEXTURE_2D; targets[idx].second = TGSI_TEXTURE_SHADOW2D; break; - case TPF_TARGET_TEXTURE3D: + case SM4_TARGET_TEXTURE3D: targets[idx].first = TGSI_TEXTURE_3D; targets[idx].second = 0; break; - case TPF_TARGET_TEXTURECUBE: + case SM4_TARGET_TEXTURECUBE: targets[idx].first = TGSI_TEXTURE_CUBE; targets[idx].second = 0; break; @@ -778,14 +778,14 @@ next:; check(0); } break; - case TPF_OPCODE_DCL_SAMPLER: + case SM4_OPCODE_DCL_SAMPLER: check(idx >= 0); if(sampler_modes.size() <= (unsigned)idx) sampler_modes.resize(idx + 1); check(!dcl.dcl_sampler.mono); sampler_modes[idx] = dcl.dcl_sampler.shadow; break; - case TPF_OPCODE_DCL_CONSTANT_BUFFER: + case SM4_OPCODE_DCL_CONSTANT_BUFFER: check(dcl.op->num_indices == 2); check(dcl.op->is_index_simple(0)); check(dcl.op->is_index_simple(1)); @@ -798,14 +798,14 @@ next:; } translate_insns(0, program.insns.size()); - tpf_to_tgsi_insn_num.push_back(ureg_get_instruction_number(ureg)); + sm4_to_tgsi_insn_num.push_back(ureg_get_instruction_number(ureg)); if(in_sub) ureg_ENDSUB(ureg); else ureg_END(ureg); - for(unsigned i = 0; i < label_to_tpf_insn_num.size(); ++i) - ureg_fixup_label(ureg, label_to_tpf_insn_num[i].first, tpf_to_tgsi_insn_num[label_to_tpf_insn_num[i].second]); + for(unsigned i = 0; i < label_to_sm4_insn_num.size(); ++i) + ureg_fixup_label(ureg, label_to_sm4_insn_num[i].first, sm4_to_tgsi_insn_num[label_to_sm4_insn_num[i].second]); const struct tgsi_token * tokens = ureg_get_tokens(ureg, 0); ureg_destroy(ureg); @@ -825,8 +825,8 @@ next:; } }; -void* tpf_to_tgsi(struct tpf_program& program) +void* sm4_to_tgsi(struct sm4_program& program) { - tpf_to_tgsi_converter conv(program); + sm4_to_tgsi_converter conv(program); return conv.translate(); } diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.h b/src/gallium/state_trackers/d3d1x/gd3d1x/sm4_to_tgsi.h index 68a30d2d2e..5722b277fb 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.h +++ b/src/gallium/state_trackers/d3d1x/gd3d1x/sm4_to_tgsi.h @@ -24,11 +24,11 @@ * **************************************************************************/ -#ifndef TPF_TO_TGSI_H_ -#define TPF_TO_TGSI_H_ +#ifndef SM4_TO_TGSI_H_ +#define SM4_TO_TGSI_H_ -#include "tpf.h" +#include "sm4.h" -void* tpf_to_tgsi(struct tpf_program& program); +void* sm4_to_tgsi(struct sm4_program& program); -#endif /* TPF_TO_TGSI_H_ */ +#endif /* SM4_TO_TGSI_H_ */ diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp b/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp index 2e5062f2ca..d210f8acad 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp +++ b/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp @@ -25,8 +25,8 @@ **************************************************************************/ #include "dxbc.h" -#include "tpf.h" -#include "../tpf_to_tgsi.h" +#include "sm4.h" +#include "../sm4_to_tgsi.h" #include "tgsi/tgsi_dump.h" #include <iostream> #include <fstream> @@ -62,16 +62,16 @@ int main(int argc, char** argv) if(dxbc) { std::cout << *dxbc; - dxbc_chunk_header* tpf_chunk = dxbc_find_shader_bytecode(&data[0], data.size()); - if(tpf_chunk) + dxbc_chunk_header* sm4_chunk = dxbc_find_shader_bytecode(&data[0], data.size()); + if(sm4_chunk) { - tpf_program* tpf = tpf_parse(tpf_chunk + 1, bswap_le32(tpf_chunk->size)); - if(tpf) + sm4_program* sm4 = sm4_parse(sm4_chunk + 1, bswap_le32(sm4_chunk->size)); + if(sm4) { - const struct tgsi_token* tokens = (const struct tgsi_token*)tpf_to_tgsi(*tpf); + const struct tgsi_token* tokens = (const struct tgsi_token*)sm4_to_tgsi(*sm4); if(tokens) { - std::cout << *tpf; + std::cout << *sm4; std::cout << "\n# TGSI program: " << std::endl; tgsi_dump(tokens, 0); } |