class dst_reg;
-/**
- * Common helper for constructing swizzles. When only a subset of
- * channels of a vec4 are used, we don't want to reference the other
- * channels, as that will tell optimization passes that those other
- * channels are used.
- */
-static int
-swizzle_for_size(int size)
-{
- int size_swizzles[4] = {
- BRW_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X),
- BRW_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y),
- BRW_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z),
- BRW_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W),
- };
-
- assert((size >= 1) && (size <= 4));
- return size_swizzles[size - 1];
-}
+unsigned
+swizzle_for_size(int size);
enum register_file {
ARF = BRW_ARCHITECTURE_REGISTER_FILE,
int reg_offset;
/** Register type. BRW_REGISTER_TYPE_* */
int type;
- bool sechalf;
struct brw_reg fixed_hw_reg;
- int smear; /* -1, or a channel of the reg to smear to all channels. */
/** Value for file == BRW_IMMMEDIATE_FILE */
union {
return node;
}
- void init()
- {
- memset(this, 0, sizeof(*this));
+ void init();
- this->file = BAD_FILE;
- }
+ src_reg(register_file file, int reg, const glsl_type *type);
+ src_reg();
+ src_reg(float f);
+ src_reg(uint32_t u);
+ src_reg(int32_t i);
- src_reg(register_file file, int reg, const glsl_type *type)
- {
- init();
-
- this->file = file;
- this->reg = reg;
- if (type && (type->is_scalar() || type->is_vector() || type->is_matrix()))
- this->swizzle = swizzle_for_size(type->vector_elements);
- else
- this->swizzle = SWIZZLE_XYZW;
- }
-
- /** Generic unset register constructor. */
- src_reg()
- {
- init();
- }
-
- src_reg(float f)
- {
- init();
-
- this->file = IMM;
- this->type = BRW_REGISTER_TYPE_F;
- this->imm.f = f;
- }
-
- src_reg(uint32_t u)
- {
- init();
-
- this->file = IMM;
- this->type = BRW_REGISTER_TYPE_UD;
- this->imm.f = u;
- }
-
- src_reg(int32_t i)
- {
- init();
-
- this->file = IMM;
- this->type = BRW_REGISTER_TYPE_D;
- this->imm.i = i;
- }
+ bool equals(src_reg *r);
+ bool is_zero() const;
+ bool is_one() const;
src_reg(class vec4_visitor *v, const struct glsl_type *type);
return node;
}
- void init()
- {
- memset(this, 0, sizeof(*this));
- this->file = BAD_FILE;
- this->writemask = WRITEMASK_XYZW;
- }
-
- dst_reg()
- {
- init();
- }
-
- dst_reg(register_file file, int reg)
- {
- init();
-
- this->file = file;
- this->reg = reg;
- }
-
- dst_reg(struct brw_reg reg)
- {
- init();
-
- this->file = HW_REG;
- this->fixed_hw_reg = reg;
- }
+ void init();
+ dst_reg();
+ dst_reg(register_file file, int reg);
+ dst_reg(register_file file, int reg, const glsl_type *type, int writemask);
+ dst_reg(struct brw_reg reg);
dst_reg(class vec4_visitor *v, const struct glsl_type *type);
explicit dst_reg(src_reg reg);
int conditional_mod; /**< BRW_CONDITIONAL_* */
int sampler;
+ uint32_t texture_offset; /**< Texture Offset bitfield */
int target; /**< MRT target. */
bool shadow_compare;
*/
ir_instruction *ir;
const char *annotation;
+
+ bool is_tex();
+ bool is_math();
};
class vec4_visitor : public ir_visitor
return dst_reg(retype(brw_null_reg(), BRW_REGISTER_TYPE_D));
}
- dst_reg dst_null_cmp()
- {
- if (intel->gen > 4)
- return dst_null_d();
- else
- return dst_null_f();
- }
-
struct brw_context *brw;
const struct gl_vertex_program *vp;
struct intel_context *intel;
int virtual_grf_count;
int virtual_grf_array_size;
int first_non_payload_grf;
+ unsigned int max_grf;
int *virtual_grf_def;
int *virtual_grf_use;
+ dst_reg userplane[MAX_CLIP_PLANES];
+
+ /**
+ * This is the size to be used for an array with an element per
+ * reg_offset
+ */
+ int virtual_grf_reg_count;
+ /** Per-virtual-grf indices into an array of size virtual_grf_reg_count */
+ int *virtual_grf_reg_map;
+
bool live_intervals_valid;
dst_reg *variable_storage(ir_variable *var);
/* Regs for vertex results. Generated at ir_variable visiting time
* for the ir->location's used.
*/
- dst_reg output_reg[VERT_RESULT_MAX];
+ dst_reg output_reg[BRW_VERT_RESULT_MAX];
+ const char *output_reg_annotation[BRW_VERT_RESULT_MAX];
int uniform_size[MAX_UNIFORMS];
+ int uniform_vector_size[MAX_UNIFORMS];
int uniforms;
struct hash_table *variable_ht;
void fail(const char *msg, ...);
int virtual_grf_alloc(int size);
+ void setup_uniform_clipplane_values();
int setup_uniform_values(int loc, const glsl_type *type);
void setup_builtin_uniform_values(ir_variable *ir);
int setup_attributes(int payload_reg);
int setup_uniforms(int payload_reg);
void setup_payload();
- void reg_allocate_trivial();
- void reg_allocate();
+ bool reg_allocate_trivial();
+ bool reg_allocate();
+ void evaluate_spill_costs(float *spill_costs, bool *no_spill);
+ int choose_spill_reg(struct ra_graph *g);
+ void spill_reg(int spill_reg);
void move_grf_array_access_to_scratch();
+ void move_uniform_array_access_to_pull_constants();
+ void move_push_constants_to_pull_constants();
+ void split_uniform_registers();
+ void pack_uniform_registers();
void calculate_live_intervals();
+ void split_virtual_grfs();
bool dead_code_eliminate();
bool virtual_grf_interferes(int a, int b);
+ bool opt_copy_propagation();
+ bool opt_algebraic();
+ bool opt_compute_to_mrf();
vec4_instruction *emit(vec4_instruction *inst);
vec4_instruction *emit(enum opcode opcode, dst_reg dst,
src_reg src0, src_reg src1, src_reg src2);
+ vec4_instruction *emit_before(vec4_instruction *inst,
+ vec4_instruction *new_inst);
+
+ vec4_instruction *MOV(dst_reg dst, src_reg src0);
+ vec4_instruction *NOT(dst_reg dst, src_reg src0);
+ vec4_instruction *RNDD(dst_reg dst, src_reg src0);
+ vec4_instruction *RNDE(dst_reg dst, src_reg src0);
+ vec4_instruction *RNDZ(dst_reg dst, src_reg src0);
+ vec4_instruction *FRC(dst_reg dst, src_reg src0);
+ vec4_instruction *ADD(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *MUL(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *MACH(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *MAC(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *AND(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *OR(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *XOR(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *DP3(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *DP4(dst_reg dst, src_reg src0, src_reg src1);
+ vec4_instruction *CMP(dst_reg dst, src_reg src0, src_reg src1,
+ uint32_t condition);
+ vec4_instruction *IF(src_reg src0, src_reg src1, uint32_t condition);
+ vec4_instruction *IF(uint32_t predicate);
+ vec4_instruction *PULL_CONSTANT_LOAD(dst_reg dst, src_reg index);
+ vec4_instruction *SCRATCH_READ(dst_reg dst, src_reg index);
+ vec4_instruction *SCRATCH_WRITE(dst_reg dst, src_reg src, src_reg index);
+
+ int implied_mrf_writes(vec4_instruction *inst);
+
bool try_rewrite_rhs_to_dst(ir_assignment *ir,
dst_reg dst,
src_reg src,
/** Walks an exec_list of ir_instruction and sends it through this visitor. */
void visit_instructions(const exec_list *list);
- void emit_bool_to_cond_code(ir_rvalue *ir);
+ void emit_bool_to_cond_code(ir_rvalue *ir, uint32_t *predicate);
void emit_bool_comparison(unsigned int op, dst_reg dst, src_reg src0, src_reg src1);
void emit_if_gen6(ir_if *ir);
void emit_block_move(dst_reg *dst, src_reg *src,
- const struct glsl_type *type, bool predicated);
+ const struct glsl_type *type, uint32_t predicate);
void emit_constant_values(dst_reg *dst, ir_constant *value);
void emit_math2_gen4(enum opcode opcode, dst_reg dst, src_reg src0, src_reg src1);
void emit_math(enum opcode opcode, dst_reg dst, src_reg src0, src_reg src1);
- int emit_vue_header_gen6(int header_mrf);
- int emit_vue_header_gen4(int header_mrf);
+ void swizzle_result(ir_texture *ir, src_reg orig_val, int sampler);
+
+ void emit_ndc_computation();
+ void emit_psiz_and_flags(struct brw_reg reg);
+ void emit_clip_distances(struct brw_reg reg, int offset);
+ void emit_generic_urb_slot(dst_reg reg, int vert_result);
+ void emit_urb_slot(int mrf, int vert_result);
void emit_urb_writes(void);
src_reg get_scratch_offset(vec4_instruction *inst,
src_reg *reladdr, int reg_offset);
+ src_reg get_pull_constant_offset(vec4_instruction *inst,
+ src_reg *reladdr, int reg_offset);
void emit_scratch_read(vec4_instruction *inst,
dst_reg dst,
src_reg orig_src,
src_reg temp,
dst_reg orig_dst,
int base_offset);
+ void emit_pull_constant_load(vec4_instruction *inst,
+ dst_reg dst,
+ src_reg orig_src,
+ int base_offset);
- GLboolean try_emit_sat(ir_expression *ir);
+ bool try_emit_sat(ir_expression *ir);
+ void resolve_ud_negate(src_reg *reg);
bool process_move_condition(ir_rvalue *ir);
struct brw_reg dst,
struct brw_reg src0,
struct brw_reg src1);
+ void generate_math2_gen7(vec4_instruction *inst,
+ struct brw_reg dst,
+ struct brw_reg src0,
+ struct brw_reg src1);
+
+ void generate_tex(vec4_instruction *inst,
+ struct brw_reg dst,
+ struct brw_reg src);
void generate_urb_write(vec4_instruction *inst);
void generate_oword_dual_block_offsets(struct brw_reg m1,
void generate_scratch_read(vec4_instruction *inst,
struct brw_reg dst,
struct brw_reg index);
+ void generate_pull_constant_load(vec4_instruction *inst,
+ struct brw_reg dst,
+ struct brw_reg index,
+ struct brw_reg offset);
+
+ void dump_instruction(vec4_instruction *inst);
+ void dump_instructions();
};
} /* namespace brw */
projects / mesa.git / blobdiff