lima/ppir: do not assume single src for pipeline outputs
[mesa.git] / src / gallium / drivers / lima / ir / pp / ppir.h
index cac6fb88f73d3d40cf873e73fbcdfc0541004005..dc76bfdc38aa62c67f75f96333a58a4c59c78850 100644 (file)
@@ -27,6 +27,7 @@
 
 #include "util/u_math.h"
 #include "util/list.h"
+#include "util/set.h"
 
 #include "ir/lima_ir.h"
 
@@ -99,6 +100,7 @@ typedef enum {
    ppir_op_load_uniform,
    ppir_op_load_varying,
    ppir_op_load_coords,
+   ppir_op_load_coords_reg,
    ppir_op_load_fragcoord,
    ppir_op_load_pointcoord,
    ppir_op_load_frontface,
@@ -114,6 +116,7 @@ typedef enum {
    ppir_op_branch,
 
    ppir_op_undef,
+   ppir_op_dummy,
 
    ppir_op_num,
 } ppir_op;
@@ -136,8 +139,15 @@ typedef struct {
 
 extern const ppir_op_info ppir_op_infos[];
 
+typedef enum {
+   ppir_dep_src,
+   ppir_dep_write_after_read,
+   ppir_dep_sequence,
+} ppir_dep_type;
+
 typedef struct {
    void *pred, *succ;
+   ppir_dep_type type;
    struct list_head pred_link;
    struct list_head succ_link;
 } ppir_dep;
@@ -173,13 +183,11 @@ typedef struct ppir_reg {
    int index;
    int regalloc_index;
    int num_components;
+
    /* whether this reg has to start from the x component
     * of a full physical reg, this is true for reg used
-    * in load/store instr which has no swizzle field
-    */
+    * in load/store instr which has no swizzle field */
    bool is_head;
-   /* instr live range */
-   int live_in, live_out;
    bool spilled;
    bool undef;
 } ppir_reg;
@@ -262,9 +270,13 @@ typedef struct {
 typedef struct {
    ppir_node node;
    ppir_dest dest;
-   ppir_src src_coords; /* not to be used after lowering */
+   ppir_src src[2]; /* src[0] temporarily stores src_coords,
+                       not to be used after lowering */
+   int num_src;
    int sampler;
    int sampler_dim;
+   bool lod_bias_en;
+   bool explicit_lod;
 } ppir_load_texture_node;
 
 typedef struct {
@@ -288,6 +300,11 @@ enum ppir_instr_slot {
    PPIR_INSTR_SLOT_ALU_END = PPIR_INSTR_SLOT_ALU_COMBINE,
 };
 
+struct ppir_liveness {
+   ppir_reg *reg;
+   unsigned mask : 4;
+};
+
 typedef struct ppir_instr {
    struct list_head list;
    int index;
@@ -307,6 +324,16 @@ typedef struct ppir_instr {
    bool scheduled;
    int offset;
    int encode_size;
+
+   /* for liveness analysis */
+   struct ppir_liveness *live_in;
+   struct ppir_liveness *live_out;
+   /* live_internal is to mark registers only live within an
+    * instruction, without propagation */
+   struct ppir_liveness *live_internal;
+   struct set *live_in_set;
+   struct set *live_out_set;
+   struct set *live_internal_set;
 } ppir_instr;
 
 typedef struct ppir_block {
@@ -323,11 +350,11 @@ typedef struct ppir_block {
    int sched_instr_base;
    int index;
 
-   /*  for liveness analysis */
-   BITSET_WORD *def;
-   BITSET_WORD *use;
-   BITSET_WORD *live_in;
-   BITSET_WORD *live_out;
+   /* for liveness analysis */
+   struct ppir_liveness *live_in;
+   struct ppir_liveness *live_out;
+   struct set *live_in_set;
+   struct set *live_out_set;
 } ppir_block;
 
 typedef struct {
@@ -377,26 +404,28 @@ typedef struct ppir_compiler {
 } ppir_compiler;
 
 void *ppir_node_create(ppir_block *block, ppir_op op, int index, unsigned mask);
-void ppir_node_add_dep(ppir_node *succ, ppir_node *pred);
+void ppir_node_add_dep(ppir_node *succ, ppir_node *pred, ppir_dep_type type);
 void ppir_node_remove_dep(ppir_dep *dep);
 void ppir_node_delete(ppir_node *node);
 void ppir_node_print_prog(ppir_compiler *comp);
 void ppir_node_replace_child(ppir_node *parent, ppir_node *old_child, ppir_node *new_child);
 void ppir_node_replace_all_succ(ppir_node *dst, ppir_node *src);
 void ppir_node_replace_pred(ppir_dep *dep, ppir_node *new_pred);
+void ppir_delete_if_orphan(ppir_block *block, ppir_node *node);
 ppir_dep *ppir_dep_for_pred(ppir_node *node, ppir_node *pred);
 ppir_node *ppir_node_clone(ppir_block *block, ppir_node *node);
 /* Assumes that node successors are in the same block */
 ppir_node *ppir_node_insert_mov(ppir_node *node);
+ppir_node *ppir_node_insert_mov_all_blocks(ppir_node *node);
 
 static inline bool ppir_node_is_root(ppir_node *node)
 {
-   return list_empty(&node->succ_list);
+   return list_is_empty(&node->succ_list);
 }
 
 static inline bool ppir_node_is_leaf(ppir_node *node)
 {
-   return list_empty(&node->pred_list);
+   return list_is_empty(&node->pred_list);
 }
 
 static inline bool ppir_node_has_single_succ(ppir_node *node)
@@ -404,6 +433,8 @@ static inline bool ppir_node_has_single_succ(ppir_node *node)
    return list_is_singular(&node->succ_list);
 }
 
+bool ppir_node_has_single_src_succ(ppir_node *node);
+
 static inline ppir_node *ppir_node_first_succ(ppir_node *node)
 {
    return list_first_entry(&node->succ_list, ppir_dep, succ_link)->succ;
@@ -462,6 +493,7 @@ static inline int ppir_node_get_src_num(ppir_node *node)
    case ppir_node_type_load:
       return ppir_node_to_load(node)->num_src;
    case ppir_node_type_load_texture:
+      return ppir_node_to_load_texture(node)->num_src;
    case ppir_node_type_store:
       return 1;
    default:
@@ -482,7 +514,7 @@ static inline ppir_src *ppir_node_get_src(ppir_node *node, int idx)
    case ppir_node_type_branch:
       return &ppir_node_to_branch(node)->src[idx];
    case ppir_node_type_load_texture:
-      return &ppir_node_to_load_texture(node)->src_coords;
+      return &ppir_node_to_load_texture(node)->src[idx];
    case ppir_node_type_load:
       return &ppir_node_to_load(node)->src;
    case ppir_node_type_store:
@@ -518,17 +550,6 @@ static inline ppir_reg *ppir_dest_get_reg(ppir_dest *dest)
    }
 }
 
-static inline ppir_src *ppir_node_get_src_for_pred(ppir_node *node, ppir_node *pred)
-{
-   for (int i = 0; i < ppir_node_get_src_num(node); i++) {
-      ppir_src *src = ppir_node_get_src(node, i);
-      if (src && src->node == pred)
-         return src;
-   }
-
-   return NULL;
-}
-
 static inline void ppir_node_target_assign(ppir_src *src, ppir_node *node)
 {
    ppir_dest *dest = ppir_node_get_dest(node);
@@ -599,6 +620,17 @@ static inline int ppir_target_get_dest_reg_index(ppir_dest *dest)
    return -1;
 }
 
+static inline int ppir_src_get_mask(ppir_src *src)
+{
+   ppir_reg *reg = ppir_src_get_reg(src);
+   int mask = 0;
+
+   for (int i = 0; i < reg->num_components; i++)
+      mask |= (1 << src->swizzle[i]);
+
+   return mask;
+}
+
 static inline bool ppir_target_is_scaler(ppir_dest *dest)
 {
    switch (dest->type) {
@@ -643,12 +675,12 @@ void ppir_instr_insert_mul_node(ppir_node *add, ppir_node *mul);
 
 static inline bool ppir_instr_is_root(ppir_instr *instr)
 {
-   return list_empty(&instr->succ_list);
+   return list_is_empty(&instr->succ_list);
 }
 
 static inline bool ppir_instr_is_leaf(ppir_instr *instr)
 {
-   return list_empty(&instr->pred_list);
+   return list_is_empty(&instr->pred_list);
 }
 
 bool ppir_lower_prog(ppir_compiler *comp);