nir/lower_indirect_derefs: Add a threshold

[mesa.git] / src / amd / compiler / aco_print_asm.cpp

diff --git a/src/amd/compiler/aco_print_asm.cpp b/src/amd/compiler/aco_print_asm.cpp
index fead382c7cf1a6d6e895f534b2d8e2b29901aca8..ce12aacf9e407cd2fb50d633e9756e463fdbeb5b 100644 (file)
--- a/src/amd/compiler/aco_print_asm.cpp
+++ b/src/amd/compiler/aco_print_asm.cpp
@@ -5,6 +5,9 @@
 #include "ac_llvm_util.h"
 
 #include <llvm/ADT/StringRef.h>
+#if LLVM_VERSION_MAJOR >= 11
+#include <llvm/MC/MCDisassembler/MCDisassembler.h>
+#endif
 
 namespace aco {
 
@@ -67,8 +70,16 @@ void print_asm_gfx6_gfx7(Program *program, std::vector<uint32_t>& binary,
 
    p = popen(command, "r");
    if (p) {
-      while (fgets(line, sizeof(line), p))
+      if (!fgets(line, sizeof(line), p)) {
+         out << "clrxdisasm not found\n";
+         pclose(p);
+         goto fail;
+      }
+
+      do {
          out << line;
+      } while (fgets(line, sizeof(line), p));
+
       pclose(p);
    }
 
@@ -92,7 +103,11 @@ void print_asm(Program *program, std::vector<uint32_t>& binary,
          referenced_blocks[succ] = true;
    }
 
+   #if LLVM_VERSION_MAJOR >= 11
+   std::vector<llvm::SymbolInfoTy> symbols;
+   #else
    std::vector<std::tuple<uint64_t, llvm::StringRef, uint8_t>> symbols;
+   #endif
    std::vector<std::array<char,16>> block_names;
    block_names.reserve(program->blocks.size());
    for (Block& block : program->blocks) {
@@ -127,34 +142,56 @@ void print_asm(Program *program, std::vector<uint32_t>& binary,
 
       /* mask out src2 on v_writelane_b32 */
       if (((program->chip_class == GFX8 || program->chip_class == GFX9) && (binary[pos] & 0xffff8000) == 0xd28a0000) ||
-          (program->chip_class == GFX10 && (binary[pos] & 0xffff8000) == 0xd7610000)) {
+          (program->chip_class >= GFX10 && (binary[pos] & 0xffff8000) == 0xd7610000)) {
          binary[pos+1] = binary[pos+1] & 0xF803FFFF;
       }
 
+      const int align_width = 60;
+      out << std::left << std::setw(align_width) << std::setfill(' ');
+
       size_t l = LLVMDisasmInstruction(disasm, (uint8_t *) &binary[pos],
                                        (exec_size - pos) * sizeof(uint32_t), pos * 4,
                                        outline, sizeof(outline));
 
       size_t new_pos;
-      const int align_width = 60;
-      if (!l && program->chip_class == GFX9 && ((binary[pos] & 0xffff8000) == 0xd1348000)) { /* not actually an invalid instruction */
-         out << std::left << std::setw(align_width) << std::setfill(' ') << "\tv_add_u32_e64 + clamp";
+      if (!l &&
+          ((program->chip_class >= GFX9 && (binary[pos] & 0xffff8000) == 0xd1348000) || /* v_add_u32_e64 + clamp */
+           (program->chip_class >= GFX10 && (binary[pos] & 0xffff8000) == 0xd7038000) || /* v_add_u16_e64 + clamp */
+           (program->chip_class <= GFX9 && (binary[pos] & 0xffff8000) == 0xd1268000)) /* v_add_u16_e64 + clamp */) {
+         out << "\tinteger addition + clamp";
+         bool has_literal = program->chip_class >= GFX10 &&
+                            (((binary[pos+1] & 0x1ff) == 0xff) || (((binary[pos+1] >> 9) & 0x1ff) == 0xff));
+         new_pos = pos + 2 + has_literal;
+      } else if (program->chip_class >= GFX10 && l == 4 && ((binary[pos] & 0xfe0001ff) == 0x020000f9)) {
+         out << "\tv_cndmask_b32 + sdwa";
          new_pos = pos + 2;
       } else if (!l) {
-         out << std::left << std::setw(align_width) << std::setfill(' ') << "(invalid instruction)";
+         out << "(invalid instruction)";
          new_pos = pos + 1;
          invalid = true;
       } else {
-         out << std::left << std::setw(align_width) << std::setfill(' ') << outline;
+         out << outline;
          assert(l % 4 == 0);
          new_pos = pos + l / 4;
       }
+      size_t size = new_pos - pos;
       out << std::right;
 
       out << " ;";
-      for (; pos < new_pos; pos++)
-         out << " " << std::setfill('0') << std::setw(8) << std::hex << binary[pos];
+      for (unsigned i = 0; i < size; i++)
+         out << " " << std::setfill('0') << std::setw(8) << std::hex << binary[pos + i];
       out << std::endl;
+
+      size_t original_pos = pos;
+      pos += size;
+
+      unsigned repeat_count = 0;
+      while (pos + size <= exec_size && memcmp(&binary[pos], &binary[original_pos], size * 4) == 0) {
+         repeat_count++;
+         pos += size;
+      }
+      if (repeat_count)
+         out << std::left << std::setw(0) << std::dec << std::setfill(' ') << "\t(then repeated " << repeat_count << " times)" << std::endl;
    }
    out << std::setfill(' ') << std::setw(0) << std::dec;
    assert(next_block == program->blocks.size());