src/amd/compiler/aco_print_asm.cpp

   1 #include <array>
   2 #include <iomanip>
   3 #include "aco_ir.h"
   4 #include "llvm-c/Disassembler.h"
   5 #include "ac_llvm_util.h"
   6
   7 #include <llvm/ADT/StringRef.h>
   8 #if LLVM_VERSION_MAJOR >= 11
   9 #include <llvm/MC/MCDisassembler/MCDisassembler.h>
  10 #endif
  11
  12 namespace aco {
  13
  14 /* LLVM disassembler only supports GFX8+, try to disassemble with CLRXdisasm
  15  * for GFX6-GFX7 if found on the system, this is better than nothing.
  16 */
  17 void print_asm_gfx6_gfx7(Program *program, std::vector<uint32_t>& binary,
  18                          std::ostream& out)
  19 {
  20    char path[] = "/tmp/fileXXXXXX";
  21    char line[2048], command[128];
  22    const char *gpu_type;
  23    FILE *p;
  24    int fd;
  25
  26    /* Dump the binary into a temporary file. */
  27    fd = mkstemp(path);
  28    if (fd < 0)
  29       return;
  30
  31    for (uint32_t w : binary)
  32    {
  33       if (write(fd, &w, sizeof(w)) == -1)
  34          goto fail;
  35    }
  36
  37    /* Determine the GPU type for CLRXdisasm. Use the family for GFX6 chips
  38     * because it doesn't allow to use gfx600 directly.
  39     */
  40    switch (program->chip_class) {
  41    case GFX6:
  42       switch (program->family) {
  43       case CHIP_TAHITI:
  44          gpu_type = "tahiti";
  45          break;
  46       case CHIP_PITCAIRN:
  47          gpu_type = "pitcairn";
  48          break;
  49       case CHIP_VERDE:
  50          gpu_type = "capeverde";
  51          break;
  52       case CHIP_OLAND:
  53          gpu_type = "oland";
  54          break;
  55       case CHIP_HAINAN:
  56          gpu_type = "hainan";
  57          break;
  58       default:
  59          unreachable("Invalid GFX6 family!");
  60       }
  61       break;
  62    case GFX7:
  63       gpu_type = "gfx700";
  64       break;
  65    default:
  66       unreachable("Invalid chip class!");
  67    }
  68
  69    sprintf(command, "clrxdisasm --gpuType=%s -r %s", gpu_type, path);
  70
  71    p = popen(command, "r");
  72    if (p) {
  73       if (!fgets(line, sizeof(line), p)) {
  74          out << "clrxdisasm not found\n";
  75          pclose(p);
  76          goto fail;
  77       }
  78
  79       do {
  80          out << line;
  81       } while (fgets(line, sizeof(line), p));
  82
  83       pclose(p);
  84    }
  85
  86 fail:
  87    close(fd);
  88    unlink(path);
  89 }
  90
  91 void print_asm(Program *program, std::vector<uint32_t>& binary,
  92                unsigned exec_size, std::ostream& out)
  93 {
  94    if (program->chip_class <= GFX7) {
  95       print_asm_gfx6_gfx7(program, binary, out);
  96       return;
  97    }
  98
  99    std::vector<bool> referenced_blocks(program->blocks.size());
 100    referenced_blocks[0] = true;
 101    for (Block& block : program->blocks) {
 102       for (unsigned succ : block.linear_succs)
 103          referenced_blocks[succ] = true;
 104    }
 105
 106    #if LLVM_VERSION_MAJOR >= 11
 107    std::vector<llvm::SymbolInfoTy> symbols;
 108    #else
 109    std::vector<std::tuple<uint64_t, llvm::StringRef, uint8_t>> symbols;
 110    #endif
 111    std::vector<std::array<char,16>> block_names;
 112    block_names.reserve(program->blocks.size());
 113    for (Block& block : program->blocks) {
 114       if (!referenced_blocks[block.index])
 115          continue;
 116       std::array<char, 16> name;
 117       sprintf(name.data(), "BB%u", block.index);
 118       block_names.push_back(name);
 119       symbols.emplace_back(block.offset * 4, llvm::StringRef(block_names[block_names.size() - 1].data()), 0);
 120    }
 121
 122    const char *features = "";
 123    if (program->chip_class >= GFX10 && program->wave_size == 64) {
 124       features = "+wavefrontsize64";
 125    }
 126
 127    LLVMDisasmContextRef disasm = LLVMCreateDisasmCPUFeatures("amdgcn-mesa-mesa3d",
 128                                                              ac_get_llvm_processor_name(program->family),
 129                                                              features,
 130                                                              &symbols, 0, NULL, NULL);
 131
 132    char outline[1024];
 133    size_t pos = 0;
 134    bool invalid = false;
 135    unsigned next_block = 0;
 136    while (pos < exec_size) {
 137       while (next_block < program->blocks.size() && pos == program->blocks[next_block].offset) {
 138          if (referenced_blocks[next_block])
 139             out << "BB" << std::dec << next_block << ":" << std::endl;
 140          next_block++;
 141       }
 142
 143       /* mask out src2 on v_writelane_b32 */
 144       if (((program->chip_class == GFX8 || program->chip_class == GFX9) && (binary[pos] & 0xffff8000) == 0xd28a0000) ||
 145           (program->chip_class >= GFX10 && (binary[pos] & 0xffff8000) == 0xd7610000)) {
 146          binary[pos+1] = binary[pos+1] & 0xF803FFFF;
 147       }
 148
 149       const int align_width = 60;
 150       out << std::left << std::setw(align_width) << std::setfill(' ');
 151
 152       size_t l = LLVMDisasmInstruction(disasm, (uint8_t *) &binary[pos],
 153                                        (exec_size - pos) * sizeof(uint32_t), pos * 4,
 154                                        outline, sizeof(outline));
 155
 156       size_t new_pos;
 157       if (!l &&
 158           ((program->chip_class >= GFX9 && (binary[pos] & 0xffff8000) == 0xd1348000) || /* v_add_u32_e64 + clamp */
 159            (program->chip_class >= GFX10 && (binary[pos] & 0xffff8000) == 0xd7038000) || /* v_add_u16_e64 + clamp */
 160            (program->chip_class <= GFX9 && (binary[pos] & 0xffff8000) == 0xd1268000)) /* v_add_u16_e64 + clamp */) {
 161          out << "\tinteger addition + clamp";
 162          bool has_literal = program->chip_class >= GFX10 &&
 163                             (((binary[pos+1] & 0x1ff) == 0xff) || (((binary[pos+1] >> 9) & 0x1ff) == 0xff));
 164          new_pos = pos + 2 + has_literal;
 165       } else if (program->chip_class >= GFX10 && l == 4 && ((binary[pos] & 0xfe0001ff) == 0x020000f9)) {
 166          out << "\tv_cndmask_b32 + sdwa";
 167          new_pos = pos + 2;
 168       } else if (!l) {
 169          out << "(invalid instruction)";
 170          new_pos = pos + 1;
 171          invalid = true;
 172       } else {
 173          out << outline;
 174          assert(l % 4 == 0);
 175          new_pos = pos + l / 4;
 176       }
 177       size_t size = new_pos - pos;
 178       out << std::right;
 179
 180       out << " ;";
 181       for (unsigned i = 0; i < size; i++)
 182          out << " " << std::setfill('0') << std::setw(8) << std::hex << binary[pos + i];
 183       out << std::endl;
 184
 185       size_t original_pos = pos;
 186       pos += size;
 187
 188       unsigned repeat_count = 0;
 189       while (pos + size <= exec_size && memcmp(&binary[pos], &binary[original_pos], size * 4) == 0) {
 190          repeat_count++;
 191          pos += size;
 192       }
 193       if (repeat_count)
 194          out << std::left << std::setw(0) << std::dec << std::setfill(' ') << "\t(then repeated " << repeat_count << " times)" << std::endl;
 195    }
 196    out << std::setfill(' ') << std::setw(0) << std::dec;
 197    assert(next_block == program->blocks.size());
 198
 199    LLVMDisasmDispose(disasm);
 200
 201    if (program->constant_data.size()) {
 202       out << std::endl << "/* constant data */" << std::endl;
 203       for (unsigned i = 0; i < program->constant_data.size(); i += 32) {
 204          out << '[' << std::setw(6) << std::setfill('0') << std::dec << i << ']';
 205          unsigned line_size = std::min<size_t>(program->constant_data.size() - i, 32);
 206          for (unsigned j = 0; j < line_size; j += 4) {
 207             unsigned size = std::min<size_t>(program->constant_data.size() - (i + j), 4);
 208             uint32_t v = 0;
 209             memcpy(&v, &program->constant_data[i + j], size);
 210             out << " " << std::setw(8) << std::setfill('0') << std::hex << v;
 211          }
 212          out << std::endl;
 213       }
 214    }
 215
 216    out << std::setfill(' ') << std::setw(0) << std::dec;
 217
 218    if (invalid) {
 219       /* Invalid instructions usually lead to GPU hangs, which can make
 220        * getting the actual invalid instruction hard. Abort here so that we
 221        * can find the problem.
 222        */
 223       abort();
 224    }
 225 }
 226
 227 }