r600/sfn: add register remapping

Make use of the live range evaluation to merge registers. Since the
live ranges are evaluated for register indices, the algorithm is not
optimal, but for most piglits up to glsl-3.3 it does the job.

Signed-off-by: Gert Wollny <gert.wollny@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/merge_requests/3225>

12 files changed, 171 insertions, 0 deletions

diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_alu.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_alu.cpp
index dffc39b9164..4143b9c52d7 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_alu.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_alu.cpp
@@ -62,6 +62,11 @@ AluInstruction::AluInstruction(EAluOp opcode, PValue dest,
 
    if (alu_ops.at(opcode).nsrc == 3)
       m_flags.set(alu_op3);
+
+   for (auto &s: m_src)
+      add_remappable_src_value(&s);
+
+   add_remappable_dst_value(&m_dest);
 }
 
 AluInstruction::AluInstruction(EAluOp opcode, PValue dest, PValue src0,
@@ -106,6 +111,30 @@ bool AluInstruction::is_equal_to(const Instruction& lhs) const
    return (m_flags == oth.m_flags && m_cf_type == oth.m_cf_type);
 }
 
+void AluInstruction::replace_values(const ValueSet& candiates, PValue new_value)
+{
+   for (auto c: candiates) {
+      if (*c == *m_dest)
+         m_dest = new_value;
+
+      for (auto& s: m_src) {
+         if (*c == *s)
+            s = new_value;
+      }
+   }
+}
+
+PValue AluInstruction::remap_one_registers(PValue reg, std::vector<rename_reg_pair>& map,
+                                           ValueMap &values)
+{
+   auto new_index = map[reg->sel()];
+   if (new_index.valid)
+      reg = values.get_or_inject(new_index.new_reg, reg->chan());
+   map[reg->sel()].used = true;
+   return reg;
+}
+
+
 void AluInstruction::set_flag(AluModifiers flag)
 {
    m_flags.set(flag);
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_alu.h b/src/gallium/drivers/r600/sfn/sfn_instruction_alu.h
index 67b641511b7..ea95f72fb07 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_alu.h
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_alu.h
@@ -117,10 +117,14 @@ public:
    ECFAluOpCode cf_type() const {return m_cf_type;}
    void set_cf_type(ECFAluOpCode cf_type){ m_cf_type = cf_type; }
 
+   void replace_values(const ValueSet& candiates, PValue new_value) override;
+
 private:
 
    bool is_equal_to(const Instruction& lhs) const override;
    void do_print(std::ostream& os) const override;
+   PValue remap_one_registers(PValue reg, std::vector<rename_reg_pair>& map,
+                              ValueMap &values);
 
 
    EAluOp m_opcode;
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_base.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_base.cpp
index 4e4e28f1436..22dfa5739f5 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_base.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_base.cpp
@@ -118,6 +118,26 @@ void Instruction::remap_registers(ValueRemapper& map)
    sfn_log << SfnLog::merge << "TO    " << *this << "\n\n";
 }
 
+void Instruction::add_remappable_src_value(PValue *v)
+{
+   m_mappable_src_registers.push_back(v);
+}
+
+void Instruction::add_remappable_src_value(GPRVector *v)
+{
+   m_mappable_src_vectors.push_back(v);
+}
+
+void Instruction::add_remappable_dst_value(PValue *v)
+{
+   m_mappable_dst_registers.push_back(v);
+}
+
+void Instruction::add_remappable_dst_value(GPRVector *v)
+{
+   m_mappable_dst_vectors.push_back(v);
+}
+
 void Instruction::replace_values(UNUSED const ValueSet& candiates, UNUSED PValue new_value)
 {
 
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_base.h b/src/gallium/drivers/r600/sfn/sfn_instruction_base.h
index e44154ebe91..c655de96ed5 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_base.h
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_base.h
@@ -39,8 +39,31 @@
 namespace r600 {
 
 
+struct rename_reg_pair {
+   bool valid;
+   bool used;
+   int new_reg;
+};
 
 class LiverangeEvaluator;
+class ValueMap;
+
+
+class ValueRemapper {
+public:
+   ValueRemapper(std::vector<rename_reg_pair>& m,
+                 ValueMap& values);
+
+   void remap(PValue& v);
+   void remap(GPRVector& v);
+private:
+   PValue remap_one_registers(PValue& reg);
+
+   std::vector<rename_reg_pair>& m_map;
+   ValueMap& m_values;
+};
+
+
 using OutputRegisterMap = std::map<unsigned, const GPRVector *>;
 
 class Instruction {
@@ -80,8 +103,19 @@ public:
 
    void print(std::ostream& os) const;
 
+   virtual void replace_values(const ValueSet& candiates, PValue new_value);
+
    void evalue_liveness(LiverangeEvaluator& eval) const;
 
+   void remap_registers(ValueRemapper& map);
+
+protected:
+
+   void add_remappable_src_value(PValue *v);
+   void add_remappable_src_value(GPRVector *v);
+   void add_remappable_dst_value(PValue *v);
+   void add_remappable_dst_value(GPRVector *v);
+
 private:
 
    virtual void do_evalue_liveness(LiverangeEvaluator& eval) const;
@@ -92,6 +126,10 @@ private:
 
    virtual void do_print(std::ostream& os) const = 0;
 
+   std::vector<PValue*> m_mappable_src_registers;
+   std::vector<GPRVector*> m_mappable_src_vectors;
+   std::vector<PValue*> m_mappable_dst_registers;
+   std::vector<GPRVector*> m_mappable_dst_vectors;
 };
 
 using PInstruction=Instruction::Pointer;
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_cf.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_cf.cpp
index 82b0f47403a..0c10e162bee 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_cf.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_cf.cpp
@@ -45,6 +45,7 @@ IfInstruction::IfInstruction(AluInstruction *pred):
    m_pred(pred)
 {
    PValue *v = m_pred->psrc(0);
+   add_remappable_src_value(v);
 }
 
 void IfInstruction::do_evalue_liveness(LiverangeEvaluator& eval) const
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_export.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_export.cpp
index 14ae52f325e..d3a07713fa7 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_export.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_export.cpp
@@ -35,6 +35,28 @@ WriteoutInstruction::WriteoutInstruction(instr_type t, const GPRVector& value):
    Instruction(t),
    m_value(value)
 {
+   add_remappable_src_value(&m_value);
+}
+
+void WriteoutInstruction::replace_values(const ValueSet& candiates, PValue new_value)
+{
+   // I wonder whether we can actually end up here ...
+   for (auto c: candiates) {
+      if (*c == *m_value.reg_i(c->chan()))
+         m_value.set_reg_i(c->chan(), new_value);
+   }
+
+   replace_values_child(candiates, new_value);
+}
+
+void WriteoutInstruction::replace_values_child(UNUSED const ValueSet& candiates,
+                                               UNUSED PValue new_value)
+{
+}
+
+void WriteoutInstruction::remap_registers_child(UNUSED std::vector<rename_reg_pair>& map,
+                                                UNUSED ValueMap& values)
+{
 }
 
 ExportInstruction::ExportInstruction(unsigned loc, const GPRVector &value, ExportType type):
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_export.h b/src/gallium/drivers/r600/sfn/sfn_instruction_export.h
index 0ea493865af..1971e339135 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_export.h
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_export.h
@@ -33,10 +33,15 @@ namespace r600 {
 
 class WriteoutInstruction: public Instruction {
 public:
+   void replace_values(const ValueSet& candiates, PValue new_value) override;
    const GPRVector&  gpr() const {return m_value;}
    const GPRVector  *gpr_ptr() const {return &m_value;}
 protected:
    WriteoutInstruction(instr_type t, const GPRVector& value);
+private:
+   virtual void replace_values_child(const ValueSet& candiates, PValue new_value);
+   virtual void remap_registers_child(std::vector<rename_reg_pair>& map,
+                        ValueMap& values);
 
    GPRVector m_value;
 };
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.cpp
index 9bd23be809c..c41692639b9 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.cpp
@@ -69,6 +69,10 @@ FetchInstruction::FetchInstruction(EVFetchInstr op,
       m_num_format = vtx_nf_scaled;
    }
 
+   add_remappable_src_value(&m_src);
+   add_remappable_src_value(&m_buffer_offset);
+
+   add_remappable_dst_value(&m_dst);
 }
 
 /* Resource query */
@@ -115,6 +119,9 @@ FetchInstruction::FetchInstruction(EVFetchInstr vc_opcode,
    m_buffer_offset(buffer_offset),
    m_dest_swizzle(dest_swizzle)
 {
+   add_remappable_src_value(&m_src);
+   add_remappable_dst_value(&m_dst);
+   add_remappable_src_value(&m_buffer_offset);
 }
 
 FetchInstruction::FetchInstruction(GPRVector dst,
@@ -146,6 +153,10 @@ FetchInstruction::FetchInstruction(GPRVector dst,
    m_dest_swizzle({0,1,2,3})
 {
    m_flags.set(vtx_format_comp_signed);
+
+   add_remappable_src_value(&m_src);
+   add_remappable_dst_value(&m_dst);
+   add_remappable_src_value(&m_buffer_offset);
 }
 
 
@@ -177,6 +188,9 @@ FetchInstruction::FetchInstruction(GPRVector dst,
    m_dest_swizzle({0,1,2,3})
 {
    m_flags.set(vtx_format_comp_signed);
+   add_remappable_src_value(&m_src);
+   add_remappable_dst_value(&m_dst);
+   add_remappable_src_value(&m_buffer_offset);
 }
 
 FetchInstruction::FetchInstruction(GPRVector dst, PValue src, int scratch_size):
@@ -212,6 +226,23 @@ FetchInstruction::FetchInstruction(GPRVector dst, PValue src, int scratch_size):
       m_indexed = true;
       m_array_size = scratch_size - 1;
    }
+   add_remappable_src_value(&m_src);
+   add_remappable_dst_value(&m_dst);
+   add_remappable_src_value(&m_buffer_offset);
+}
+
+void FetchInstruction::replace_values(const ValueSet& candiates, PValue new_value)
+{
+   if (!m_src)
+      return;
+   for (auto c: candiates) {
+      for (int i = 0; i < 4; ++i) {
+         if (*c == *m_dst.reg_i(i))
+            m_dst.set_reg_i(i, new_value);
+      }
+      if (*m_src == *c)
+         m_src = new_value;
+   }
 }
 
 
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.h b/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.h
index 0ed41316235..369094edfa7 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.h
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_fetch.h
@@ -78,6 +78,7 @@ public:
 
    FetchInstruction(GPRVector dst, PValue src, int scratch_size);
 
+   void replace_values(const ValueSet& candiates, PValue new_value) override;
    EVFetchInstr vc_opcode() const { return m_vc_opcode;}
    EVFetchType fetch_type() const { return m_fetch_type;}
 
@@ -111,6 +112,7 @@ public:
 
    void set_buffer_offset(PValue buffer_offset) {
       m_buffer_offset = buffer_offset;
+      add_remappable_src_value(&m_buffer_offset);
    }
    PValue buffer_offset() const { return m_buffer_offset; }
 
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_tex.cpp b/src/gallium/drivers/r600/sfn/sfn_instruction_tex.cpp
index c0f37009f18..0e7b63db570 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_tex.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_tex.cpp
@@ -45,6 +45,10 @@ TexInstruction::TexInstruction(Opcode op, const GPRVector &dest, const GPRVector
 
 {
    memset(m_offset, 0, sizeof (m_offset));
+
+   add_remappable_src_value(&m_src);
+   add_remappable_src_value(&m_sampler_offset);
+   add_remappable_dst_value(&m_dst);
 }
 
 void TexInstruction::set_gather_comp(int cmp)
@@ -52,6 +56,17 @@ void TexInstruction::set_gather_comp(int cmp)
    m_inst_mode = cmp;
 }
 
+void TexInstruction::replace_values(const ValueSet& candiates, PValue new_value)
+{
+   // I wonder whether we can actually end up here ...
+   for (auto c: candiates) {
+      if (*c == *m_src.reg_i(c->chan()))
+         m_src.set_reg_i(c->chan(), new_value);
+      if (*c == *m_dst.reg_i(c->chan()))
+         m_dst.set_reg_i(c->chan(), new_value);
+   }
+}
+
 void TexInstruction::set_offset(unsigned index, int32_t val)
 {
    assert(index < 3);
diff --git a/src/gallium/drivers/r600/sfn/sfn_instruction_tex.h b/src/gallium/drivers/r600/sfn/sfn_instruction_tex.h
index ff5ef1ee1f2..d6f35302499 100644
--- a/src/gallium/drivers/r600/sfn/sfn_instruction_tex.h
+++ b/src/gallium/drivers/r600/sfn/sfn_instruction_tex.h
@@ -81,6 +81,8 @@ public:
    unsigned sampler_id() const {return m_sampler_id;}
    unsigned resource_id() const {return m_resource_id;}
 
+   void replace_values(const ValueSet& candiates, PValue new_value) override;
+
    void set_offset(unsigned index, int32_t val);
    int get_offset(unsigned index) const;
 
diff --git a/src/gallium/drivers/r600/sfn/sfn_shader_base.h b/src/gallium/drivers/r600/sfn/sfn_shader_base.h
index 0a12d1ca835..b9184fda2fb 100644
--- a/src/gallium/drivers/r600/sfn/sfn_shader_base.h
+++ b/src/gallium/drivers/r600/sfn/sfn_shader_base.h
@@ -71,6 +71,8 @@ public:
    void split_constants(nir_alu_instr* instr);
    void load_uniform(const nir_alu_src& src);
 
+   void remap_registers();
+
    const nir_variable *get_deref_location(const nir_src& src) const;
 protected: