init

src/gallium/drivers/r300/compiler/radeon_code.h

@@ -0,0 +1,282 @@
+/*
+ * Copyright 2009 Nicolai Hähnle <[email protected]>
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef RADEON_CODE_H
+#define RADEON_CODE_H
+
+#include <stdint.h>
+
+#define R300_PFS_MAX_ALU_INST     64
+#define R300_PFS_MAX_TEX_INST     32
+#define R300_PFS_MAX_TEX_INDIRECT 4
+#define R300_PFS_NUM_TEMP_REGS    32
+#define R300_PFS_NUM_CONST_REGS   32
+
+#define R400_PFS_MAX_ALU_INST 512
+#define R400_PFS_MAX_TEX_INST 512
+
+#define R500_PFS_MAX_INST                 512
+#define R500_PFS_NUM_TEMP_REGS            128
+#define R500_PFS_NUM_CONST_REGS           256
+#define R500_PFS_MAX_BRANCH_DEPTH_FULL    32
+#define R500_PFS_MAX_BRANCH_DEPTH_PARTIAL 4
+
+/* The r500 maximum depth is not just for loops, but any combination of loops
+ * and subroutine jumps. */
+#define R500_PVS_MAX_LOOP_DEPTH 8
+
+#define STATE_R300_WINDOW_DIMENSION (STATE_INTERNAL_DRIVER + 0)
+
+enum {
+   /**
+    * External constants are constants whose meaning is unknown to this
+    * compiler. For example, a Mesa gl_program's constants are turned
+    * into external constants.
+    */
+   RC_CONSTANT_EXTERNAL = 0,
+
+   RC_CONSTANT_IMMEDIATE,
+
+   /**
+    * Constant referring to state that is known by this compiler,
+    * see RC_STATE_xxx, i.e. *not* arbitrary Mesa (or other) state.
+    */
+   RC_CONSTANT_STATE
+};
+
+enum {
+   RC_STATE_SHADOW_AMBIENT = 0,
+
+   RC_STATE_R300_WINDOW_DIMENSION,
+   RC_STATE_R300_TEXRECT_FACTOR,
+   RC_STATE_R300_TEXSCALE_FACTOR,
+   RC_STATE_R300_VIEWPORT_SCALE,
+   RC_STATE_R300_VIEWPORT_OFFSET
+};
+
+struct rc_constant {
+   unsigned Type : 2; /**< RC_CONSTANT_xxx */
+   unsigned UseMask : 4;
+
+   union {
+      unsigned External;
+      float Immediate[4];
+      unsigned State[2];
+   } u;
+};
+
+struct rc_constant_list {
+   struct rc_constant *Constants;
+   unsigned Count;
+
+   unsigned _Reserved;
+};
+
+struct const_remap {
+   int index[4];
+   uint8_t swizzle[4];
+   uint8_t negate[4];
+};
+
+void rc_constants_init(struct rc_constant_list *c);
+void rc_constants_copy(struct rc_constant_list *dst, struct rc_constant_list *src);
+void rc_constants_destroy(struct rc_constant_list *c);
+unsigned rc_constants_add(struct rc_constant_list *c, struct rc_constant *constant);
+unsigned rc_constants_add_state(struct rc_constant_list *c, unsigned state1, unsigned state2);
+unsigned rc_constants_add_immediate_vec4(struct rc_constant_list *c, const float *data);
+unsigned rc_constants_add_immediate_scalar(struct rc_constant_list *c, float data,
+                                           unsigned *swizzle, unsigned *negate);
+void rc_constants_print(struct rc_constant_list *c, struct const_remap *r);
+
+/**
+ * Compare functions.
+ *
+ * \note By design, RC_COMPARE_FUNC_xxx + GL_NEVER gives you
+ * the correct GL compare function.
+ */
+typedef enum {
+   RC_COMPARE_FUNC_NEVER = 0,
+   RC_COMPARE_FUNC_LESS,
+   RC_COMPARE_FUNC_EQUAL,
+   RC_COMPARE_FUNC_LEQUAL,
+   RC_COMPARE_FUNC_GREATER,
+   RC_COMPARE_FUNC_NOTEQUAL,
+   RC_COMPARE_FUNC_GEQUAL,
+   RC_COMPARE_FUNC_ALWAYS
+} rc_compare_func;
+
+/**
+ * Coordinate wrapping modes.
+ *
+ * These are not quite the same as their GL counterparts yet.
+ */
+typedef enum {
+   RC_WRAP_NONE = 0,
+   RC_WRAP_REPEAT,
+   RC_WRAP_MIRRORED_REPEAT,
+   RC_WRAP_MIRRORED_CLAMP
+} rc_wrap_mode;
+
+/**
+ * Stores state that influences the compilation of a fragment program.
+ */
+struct r300_fragment_program_external_state {
+   struct {
+      /**
+       * This field contains swizzle for some lowering passes
+       * (shadow comparison, unorm->snorm conversion)
+       */
+      unsigned texture_swizzle : 12;
+
+      /**
+       * If the sampler is used as a shadow sampler,
+       * this field specifies the compare function.
+       *
+       * Otherwise, this field is \ref RC_COMPARE_FUNC_NEVER (aka 0).
+       * \sa rc_compare_func
+       */
+      unsigned texture_compare_func : 3;
+
+      /**
+       * No matter what the sampler type is,
+       * this field turns it into a shadow sampler.
+       */
+      unsigned compare_mode_enabled : 1;
+
+      /**
+       * This field specifies wrapping modes for the sampler.
+       *
+       * If this field is \ref RC_WRAP_NONE (aka 0), no wrapping maths
+       * will be performed on the coordinates.
+       */
+      unsigned wrap_mode : 3;
+
+      /**
+       * The coords are scaled after applying the wrap mode emulation
+       * and right before texture fetch. The scaling factor is given by
+       * RC_STATE_R300_TEXSCALE_FACTOR. */
+      unsigned clamp_and_scale_before_fetch : 1;
+   } unit[16];
+
+   unsigned alpha_to_one : 1;
+
+   int sampler_state_count;
+};
+
+struct r300_fragment_program_node {
+   int tex_offset; /**< first tex instruction */
+   int tex_end;    /**< last tex instruction, relative to tex_offset */
+   int alu_offset; /**< first ALU instruction */
+   int alu_end;    /**< last ALU instruction, relative to alu_offset */
+   int flags;
+};
+
+/**
+ * Stores an R300 fragment program in its compiled-to-hardware form.
+ */
+struct r300_fragment_program_code {
+   struct {
+      unsigned int length; /**< total # of texture instructions used */
+      uint32_t inst[R400_PFS_MAX_TEX_INST];
+   } tex;
+
+   struct {
+      unsigned int length; /**< total # of ALU instructions used */
+      struct {
+         uint32_t rgb_inst;
+         uint32_t rgb_addr;
+         uint32_t alpha_inst;
+         uint32_t alpha_addr;
+         uint32_t r400_ext_addr;
+      } inst[R400_PFS_MAX_ALU_INST];
+   } alu;
+
+   uint32_t config;               /* US_CONFIG */
+   uint32_t pixsize;              /* US_PIXSIZE */
+   uint32_t code_offset;          /* US_CODE_OFFSET */
+   uint32_t r400_code_offset_ext; /* US_CODE_EXT */
+   uint32_t code_addr[4];         /* US_CODE_ADDR */
+   /*US_CODE_BANK.R390_MODE: Enables 512 instructions and 64 temporaries
+    * for r400 cards */
+   unsigned int r390_mode : 1;
+};
+
+struct r500_fragment_program_code {
+   struct {
+      uint32_t inst0;
+      uint32_t inst1;
+      uint32_t inst2;
+      uint32_t inst3;
+      uint32_t inst4;
+      uint32_t inst5;
+   } inst[R500_PFS_MAX_INST];
+
+   int inst_end; /* Number of instructions - 1; also, last instruction to be executed */
+
+   int max_temp_idx;
+
+   uint32_t us_fc_ctrl;
+
+   uint32_t int_constants[32];
+   uint32_t int_constant_count;
+};
+
+struct rX00_fragment_program_code {
+   union {
+      struct r300_fragment_program_code r300;
+      struct r500_fragment_program_code r500;
+   } code;
+
+   unsigned writes_depth : 1;
+
+   struct rc_constant_list constants;
+   struct const_remap *constants_remap_table;
+};
+
+#define R300_VS_MAX_ALU        256
+#define R300_VS_MAX_ALU_DWORDS (R300_VS_MAX_ALU * 4)
+#define R500_VS_MAX_ALU        1024
+#define R500_VS_MAX_ALU_DWORDS (R500_VS_MAX_ALU * 4)
+#define R300_VS_MAX_TEMPS      32
+/* This is the max for all chipsets (r300-r500) */
+#define R300_VS_MAX_FC_OPS     16
+#define R300_VS_MAX_LOOP_DEPTH 1
+
+#define VSF_MAX_INPUTS  32
+#define VSF_MAX_OUTPUTS 32
+
+struct r300_vertex_program_code {
+   int length;
+   union {
+      uint32_t d[R500_VS_MAX_ALU_DWORDS];
+      float f[R500_VS_MAX_ALU_DWORDS];
+   } body;
+
+   int pos_end;
+   int num_temporaries; /* Number of temp vars used by program */
+   int inputs[VSF_MAX_INPUTS];
+   int outputs[VSF_MAX_OUTPUTS];
+   unsigned last_input_read;
+   unsigned last_pos_write;
+
+   struct rc_constant_list constants;
+   struct const_remap *constants_remap_table;
+
+   uint32_t InputsRead;
+   uint32_t OutputsWritten;
+
+   unsigned int num_fc_ops;
+   uint32_t fc_ops;
+   union {
+      uint32_t r300[R300_VS_MAX_FC_OPS];
+      struct {
+         uint32_t lw;
+         uint32_t uw;
+      } r500[R300_VS_MAX_FC_OPS];
+   } fc_op_addrs;
+   int32_t fc_loop_index[R300_VS_MAX_FC_OPS];
+};
+
+#endif /* RADEON_CODE_H */