// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#include "vm/disassembler.h"

#include "vm/globals.h"  // Needed here to get TARGET_ARCH_MIPS.
#if defined(TARGET_ARCH_MIPS)
#include "platform/assert.h"

namespace dart {

class MIPSDecoder : public ValueObject {
 public:
  MIPSDecoder(char* buffer, size_t buffer_size)
      : buffer_(buffer),
        buffer_size_(buffer_size),
        buffer_pos_(0) {
    buffer_[buffer_pos_] = '\0';
  }

  ~MIPSDecoder() {}

  // Writes one disassembled instruction into 'buffer' (0-terminated).
  // Returns true if the instruction was successfully decoded, false otherwise.
  void InstructionDecode(Instr* instr);

 private:
  // Bottleneck functions to print into the out_buffer.
  void Print(const char* str);

  // Printing of common values.
  void PrintRegister(Register reg);
  void PrintFRegister(FRegister reg);
  void PrintFormat(Instr* instr);

  int FormatRegister(Instr* instr, const char* format);
  int FormatFRegister(Instr* instr, const char* format);
  int FormatOption(Instr* instr, const char* format);
  void Format(Instr* instr, const char* format);
  void Unknown(Instr* instr);

  void DecodeSpecial(Instr* instr);
  void DecodeSpecial2(Instr* instr);
  void DecodeRegImm(Instr* instr);
  void DecodeCop1(Instr* instr);

  // Convenience functions.
  char* get_buffer() const { return buffer_; }
  char* current_position_in_buffer() { return buffer_ + buffer_pos_; }
  size_t remaining_size_in_buffer() { return buffer_size_ - buffer_pos_; }

  char* buffer_;  // Decode instructions into this buffer.
  size_t buffer_size_;  // The size of the character buffer.
  size_t buffer_pos_;  // Current character position in buffer.

  DISALLOW_ALLOCATION();
  DISALLOW_COPY_AND_ASSIGN(MIPSDecoder);
};


// Support for assertions in the MIPSDecoder formatting functions.
#define STRING_STARTS_WITH(string, compare_string) \
  (strncmp(string, compare_string, strlen(compare_string)) == 0)


// Append the str to the output buffer.
void MIPSDecoder::Print(const char* str) {
  char cur = *str++;
  while (cur != '\0' && (buffer_pos_ < (buffer_size_ - 1))) {
    buffer_[buffer_pos_++] = cur;
    cur = *str++;
  }
  buffer_[buffer_pos_] = '\0';
}


static const char* reg_names[kNumberOfCpuRegisters] = {
  "r0" , "r1" , "r2" , "r3" , "r4" , "r5" , "r6" , "r7" ,
  "r8" , "r9" , "r10", "r11", "r12", "r13", "r14", "r15",
  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
};


static const char* freg_names[kNumberOfFRegisters] = {
  "f0" , "f1" , "f2" , "f3" , "f4" , "f5" , "f6" , "f7" ,
  "f8" , "f9" , "f10", "f11", "f12", "f13", "f14", "f15",
  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
};


void MIPSDecoder::PrintRegister(Register reg) {
  ASSERT(0 <= reg);
  ASSERT(reg < kNumberOfCpuRegisters);
  Print(reg_names[reg]);
}


void MIPSDecoder::PrintFRegister(FRegister reg) {
  ASSERT(0 <= reg);
  ASSERT(reg < kNumberOfFRegisters);
  Print(freg_names[reg]);
}


// Handle all register based formatting in these functions to reduce the
// complexity of FormatOption.
int MIPSDecoder::FormatRegister(Instr* instr, const char* format) {
  ASSERT(format[0] == 'r');
  switch (format[1]) {
    case 's': {  // 'rs: Rs register
      PrintRegister(instr->RsField());
      return 2;
    }
    case 't': {  // 'rt: Rt register
      PrintRegister(instr->RtField());
      return 2;
    }
    case 'd': {  // 'rd: Rd register
      PrintRegister(instr->RdField());
      return 2;
    }
  }
  UNREACHABLE();
  return -1;
}


int MIPSDecoder::FormatFRegister(Instr* instr, const char* format) {
  ASSERT(format[0] == 'f');
  switch (format[1]) {
    case 's': {  // 'fs: Fs register
      PrintFRegister(instr->FsField());
      return 2;
    }
    case 't': {  // 'ft: Ft register
      PrintFRegister(instr->FtField());
      return 2;
    }
    case 'd': {  // 'fd: Fd register
      PrintFRegister(instr->FdField());
      return 2;
    }
  }
  UNREACHABLE();
  return -1;
}


void MIPSDecoder::PrintFormat(Instr *instr) {
  switch (instr->FormatField()) {
    case FMT_S: {
      Print("s");
      break;
    }
    case FMT_D: {
      Print("d");
      break;
    }
    case FMT_W: {
      Print("w");
      break;
    }
    case FMT_L: {
      Print("l");
      break;
    }
    case FMT_PS: {
      Print("ps");
      break;
    }
    default: {
      Print("unknown");
      break;
    }
  }
}


// FormatOption takes a formatting string and interprets it based on
// the current instructions. The format string points to the first
// character of the option string (the option escape has already been
// consumed by the caller.)  FormatOption returns the number of
// characters that were consumed from the formatting string.
int MIPSDecoder::FormatOption(Instr* instr, const char* format) {
  switch (format[0]) {
    case 'c': {
      ASSERT(STRING_STARTS_WITH(format, "code"));
      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                remaining_size_in_buffer(),
                                "%d", instr->BreakCodeField());
      return 4;
    }
    case 'h': {
      ASSERT(STRING_STARTS_WITH(format, "hint"));
      if (instr->SaField() == 0x10) {
        // The high bit of the SA field is the only one that means something for
        // JALR and JR. TODO(zra): Fill in the other cases for PREF if needed.
        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                   remaining_size_in_buffer(),
                                   ".hb");
      } else if (instr->SaField() != 0) {
        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                           remaining_size_in_buffer(),
                           ".unknown");
      }
      return 4;
    }
    case 'd': {
      ASSERT(STRING_STARTS_WITH(format, "dest"));
      int off = instr->SImmField() << 2;
      uword destination =
          reinterpret_cast<uword>(instr) + off + Instr::kInstrSize;
      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                 remaining_size_in_buffer(),
                                 "%#" Px "",
                                 destination);
      return 4;
    }
    case 'i': {
      ASSERT(STRING_STARTS_WITH(format, "imm"));
      if (format[3] == 'u') {
        int32_t imm = instr->UImmField();
        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                   remaining_size_in_buffer(),
                                   "0x%x",
                                   imm);
      } else {
        ASSERT(STRING_STARTS_WITH(format, "imms"));
        int32_t imm = instr->SImmField();
        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                   remaining_size_in_buffer(),
                                   "%d",
                                   imm);
      }
      return 4;
    }
    case 'r': {
      return FormatRegister(instr, format);
    }
    case 'f': {
      if (format[1] == 'm') {
        ASSERT(STRING_STARTS_WITH(format, "fmt"));
        PrintFormat(instr);
        return 3;
      } else {
        return FormatFRegister(instr, format);
      }
    }
    case 's': {
      ASSERT(STRING_STARTS_WITH(format, "sa"));
      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                 remaining_size_in_buffer(),
                                 "%d",
                                 instr->SaField());
      return 2;
    }
    default: {
      UNREACHABLE();
    }
  }
  UNREACHABLE();
  return -1;
}


// Format takes a formatting string for a whole instruction and prints it into
// the output buffer. All escaped options are handed to FormatOption to be
// parsed further.
void MIPSDecoder::Format(Instr* instr, const char* format) {
  char cur = *format++;
  while ((cur != 0) && (buffer_pos_ < (buffer_size_ - 1))) {
    if (cur == '\'') {  // Single quote is used as the formatting escape.
      format += FormatOption(instr, format);
    } else {
      buffer_[buffer_pos_++] = cur;
    }
    cur = *format++;
  }
  buffer_[buffer_pos_]  = '\0';
}


// For currently unimplemented decodings the disassembler calls Unknown(instr)
// which will just print "unknown" of the instruction bits.
void MIPSDecoder::Unknown(Instr* instr) {
  Format(instr, "unknown");
}


void MIPSDecoder::DecodeSpecial(Instr* instr) {
  ASSERT(instr->OpcodeField() == SPECIAL);
  switch (instr->FunctionField()) {
    case ADDU: {
      Format(instr, "addu 'rd, 'rs, 'rt");
      break;
    }
    case AND: {
      Format(instr, "and 'rd, 'rs, 'rt");
      break;
    }
    case BREAK: {
      Format(instr, "break 'code");
      break;
    }
    case DIV: {
      Format(instr, "div 'rs, 'rt");
      break;
    }
    case DIVU: {
      Format(instr, "divu 'rs, 'rt");
      break;
    }
    case JALR: {
      Format(instr, "jalr'hint 'rd, 'rs");
      break;
    }
    case JR: {
      Format(instr, "jr'hint 'rs");
      break;
    }
    case MFHI: {
      Format(instr, "mfhi 'rd");
      break;
    }
    case MFLO: {
      Format(instr, "mflo 'rd");
      break;
    }
    case MOVCI: {
      if (instr->Bit(16)) {
        Format(instr, "movt 'rd, 'rs");
      } else {
        Format(instr, "movf 'rd, 'rs");
      }
      break;
    }
    case MOVN: {
      Format(instr, "movn 'rd, 'rs, 'rt");
      break;
    }
    case MOVZ: {
      Format(instr, "movz 'rd, 'rs, 'rt");
      break;
    }
    case MTHI: {
      Format(instr, "mthi 'rs");
      break;
    }
    case MTLO: {
      Format(instr, "mtlo 'rs");
      break;
    }
    case MULT: {
      Format(instr, "mult 'rs, 'rt");
      break;
    }
    case MULTU: {
      Format(instr, "multu 'rs, 'rt");
      break;
    }
    case NOR: {
      Format(instr, "nor 'rd, 'rs, 'rt");
      break;
    }
    case OR: {
      if (instr->RsField() == 0 && instr->RtField() == 0) {
        Format(instr, "mov 'rd, 0");
      } else if (instr->RsField() == R0) {
        Format(instr, "mov 'rd, 'rt");
      } else if (instr->RtField() == R0) {
        Format(instr, "mov 'rd, 'rs");
      } else {
        Format(instr, "or 'rd, 'rs, 'rt");
      }
      break;
    }
    case SLL: {
      if ((instr->RdField() == R0) &&
          (instr->RtField() == R0) &&
          (instr->SaField() == 0)) {
        Format(instr, "nop");
      } else {
        Format(instr, "sll 'rd, 'rt, 'sa");
      }
      break;
    }
    case SLLV: {
      Format(instr, "sllv 'rd, 'rt, 'rs");
      break;
    }
    case SLT: {
      Format(instr, "slt 'rd, 'rs, 'rt");
      break;
    }
    case SLTU: {
      Format(instr, "sltu 'rd, 'rs, 'rt");
      break;
    }
    case SRA: {
      if (instr->RsField() == 0) {
        Format(instr, "sra 'rd, 'rt, 'sa");
      } else {
        Unknown(instr);
      }
      break;
    }
    case SRAV: {
      Format(instr, "srav 'rd, 'rt, 'rs");
      break;
    }
    case SRL: {
      if (instr->RsField() == 0) {
        Format(instr, "srl 'rd, 'rt, 'sa");
      } else {
        Unknown(instr);
      }
      break;
    }
    case SRLV: {
      if (instr->SaField() == 0) {
        Format(instr, "srlv 'rd, 'rt, 'rs");
      } else {
        Unknown(instr);
      }
      break;
    }
    case SUBU: {
      Format(instr, "subu 'rd, 'rs, 'rt");
      break;
    }
    case XOR: {
      Format(instr, "xor 'rd, 'rs, 'rt");
      break;
    }
    default: {
      Unknown(instr);
      break;
    }
  }
}


void MIPSDecoder::DecodeSpecial2(Instr* instr) {
  ASSERT(instr->OpcodeField() == SPECIAL2);
  switch (instr->FunctionField()) {
    case MADD: {
      Format(instr, "madd 'rs, 'rt");
      break;
    }
    case MADDU: {
      Format(instr, "maddu 'rs, 'rt");
      break;
    }
    case CLO: {
      Format(instr, "clo 'rd, 'rs");
      break;
    }
    case CLZ: {
      Format(instr, "clz 'rd, 'rs");
      break;
    }
    default: {
      Unknown(instr);
      break;
    }
  }
}


void MIPSDecoder::DecodeRegImm(Instr* instr) {
  ASSERT(instr->OpcodeField() == REGIMM);
  switch (instr->RegImmFnField()) {
    case BGEZ: {
      Format(instr, "bgez 'rs, 'dest");
      break;
    }
    case BGEZAL: {
      Format(instr, "bgezal 'rs, 'dest");
      break;
    }
    case BLTZAL: {
      Format(instr, "bltzal 'rs, 'dest");
      break;
    }
    case BGEZL: {
      Format(instr, "bgezl 'rs, 'dest");
      break;
    }
    case BLTZ: {
      Format(instr, "bltz 'rs, 'dest");
      break;
    }
    case BLTZL: {
      Format(instr, "bltzl 'rs, 'dest");
      break;
    }
    default: {
      Unknown(instr);
      break;
    }
  }
}

void MIPSDecoder::DecodeCop1(Instr* instr) {
  ASSERT(instr->OpcodeField() == COP1);
  if (instr->HasFormat()) {
    // If the rs field is a valid format, then the function field identifies
    // the instruction.
    switch (instr->Cop1FunctionField()) {
      case COP1_ADD: {
        Format(instr, "add.'fmt 'fd, 'fs, 'ft");
        break;
      }
      case COP1_SUB: {
        Format(instr, "sub.'fmt 'fd, 'fs, 'ft");
        break;
      }
      case COP1_MUL: {
        Format(instr, "mul.'fmt 'fd, 'fs, 'ft");
        break;
      }
      case COP1_DIV: {
        Format(instr, "div.'fmt 'fd, 'fs, 'ft");
        break;
      }
      case COP1_SQRT: {
        Format(instr, "sqrt.'fmt 'fd, 'fs");
        break;
      }
      case COP1_MOV: {
        Format(instr, "mov.'fmt 'fd, 'fs");
        break;
      }
      case COP1_C_F: {
        Format(instr, "c.f.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_UN: {
        Format(instr, "c.un.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_EQ: {
        Format(instr, "c.eq.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_UEQ: {
        Format(instr, "c.ueq.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_OLT: {
        Format(instr, "c.olt.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_ULT: {
        Format(instr, "c.ult.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_OLE: {
        Format(instr, "c.ole.'fmt 'fs, 'ft");
        break;
      }
      case COP1_C_ULE: {
        Format(instr, "c.ule.'fmt 'fs, 'ft");
        break;
      }
      case COP1_CVT_D: {
        Format(instr, "cvt.d.'fmt 'fd, 'fs");
        break;
      }
      case COP1_CVT_W: {
        Format(instr, "cvt.w.'fmt 'fd, 'fs");
        break;
      }
      default: {
        Unknown(instr);
        break;
      }
    }
  } else {
    // If the rs field isn't a valid format, then it must be a sub-opcode.
    switch (instr->Cop1SubField()) {
      case COP1_MF: {
        if (instr->Bits(0, 11) != 0) {
          Unknown(instr);
        } else {
          Format(instr, "mfc1 'rt, 'fs");
        }
        break;
      }
      case COP1_MT: {
        if (instr->Bits(0, 11) != 0) {
          Unknown(instr);
        } else {
          Format(instr, "mtc1 'rt, 'fs");
        }
        break;
      }
      case COP1_BC: {
        ASSERT(instr->Bit(17) == 0);
        if (instr->Bit(16) == 1) {  // Branch on true.
          Format(instr, "bc1t 'dest");
        } else {  // Branch on false.
          Format(instr, "bc1f 'dest");
        }
        break;
      }
      default: {
        Unknown(instr);
        break;
      }
    }
  }
}

void MIPSDecoder::InstructionDecode(Instr* instr) {
  switch (instr->OpcodeField()) {
    case SPECIAL: {
      DecodeSpecial(instr);
      break;
    }
    case SPECIAL2: {
      DecodeSpecial2(instr);
      break;
    }
    case REGIMM: {
      DecodeRegImm(instr);
      break;
    }
    case COP1: {
      DecodeCop1(instr);
      break;
    }
    case ADDIU: {
      Format(instr, "addiu 'rt, 'rs, 'imms");
      break;
    }
    case ANDI: {
      Format(instr, "andi 'rt, 'rs, 'immu");
      break;
    }
    case BEQ: {
      Format(instr, "beq 'rs, 'rt, 'dest");
      break;
    }
    case BEQL: {
      Format(instr, "beql 'rs, 'rt, 'dest");
      break;
    }
    case BGTZ: {
      Format(instr, "bgtz 'rs, 'dest");
      break;
    }
    case BGTZL: {
      Format(instr, "bgtzl 'rs, 'dest");
      break;
    }
    case BLEZ: {
      Format(instr, "blez 'rs, 'dest");
      break;
    }
    case BLEZL: {
      Format(instr, "blezl 'rs, 'dest");
      break;
    }
    case BNE: {
      Format(instr, "bne 'rs, 'rt, 'dest");
      break;
    }
    case BNEL: {
      Format(instr, "bnel 'rs, 'rt, 'dest");
      break;
    }
    case LB: {
      Format(instr, "lb 'rt, 'imms('rs)");
      break;
    }
    case LBU: {
      Format(instr, "lbu 'rt, 'imms('rs)");
      break;
    }
    case LDC1: {
      Format(instr, "ldc1 'ft, 'imms('rs)");
      break;
    }
    case LH: {
      Format(instr, "lh 'rt, 'imms('rs)");
      break;
    }
    case LHU: {
      Format(instr, "lhu 'rt, 'imms('rs)");
      break;
    }
    case LUI: {
      Format(instr, "lui 'rt, 'immu");
      break;
    }
    case LW: {
      Format(instr, "lw 'rt, 'imms('rs)");
      break;
    }
    case LWC1: {
      Format(instr, "lwc1 'ft, 'imms('rs)");
      break;
    }
    case ORI: {
      Format(instr, "ori 'rt, 'rs, 'immu");
      break;
    }
    case SB: {
      Format(instr, "sb 'rt, 'imms('rs)");
      break;
    }
    case SLTI: {
      Format(instr, "slti 'rt, 'rs, 'imms");
      break;
    }
    case SLTIU: {
      Format(instr, "sltu 'rt, 'rs, 'immu");
      break;
    }
    case SH: {
      Format(instr, "sh 'rt, 'imms('rs)");
      break;
    }
    case SDC1: {
      Format(instr, "sdc1 'ft, 'imms('rs)");
      break;
    }
    case SW: {
      Format(instr, "sw 'rt, 'imms('rs)");
      break;
    }
    case SWC1: {
      Format(instr, "swc1 'ft, 'imms('rs)");
      break;
    }
    case XORI: {
      Format(instr, "xori 'rt, 'rs, 'immu");
      break;
    }
    default: {
      Unknown(instr);
      break;
    }
  }
}


void Disassembler::DecodeInstruction(char* hex_buffer, intptr_t hex_size,
                                     char* human_buffer, intptr_t human_size,
                                     int* out_instr_len, uword pc) {
  MIPSDecoder decoder(human_buffer, human_size);
  Instr* instr = Instr::At(pc);
  decoder.InstructionDecode(instr);
  OS::SNPrint(hex_buffer, hex_size, "%08x", instr->InstructionBits());
  if (out_instr_len) {
    *out_instr_len = Instr::kInstrSize;
  }
}


void Disassembler::Disassemble(uword start,
                               uword end,
                               DisassemblyFormatter* formatter,
                               const Code::Comments& comments) {
  ASSERT(formatter != NULL);
  char hex_buffer[kHexadecimalBufferSize];  // Instruction in hexadecimal form.
  char human_buffer[kUserReadableBufferSize];  // Human-readable instruction.
  uword pc = start;
  intptr_t comment_finger = 0;
  while (pc < end) {
    const intptr_t offset = pc - start;
    while (comment_finger < comments.Length() &&
           comments.PCOffsetAt(comment_finger) <= offset) {
      formatter->Print(
          "        ;; %s\n",
          String::Handle(comments.CommentAt(comment_finger)).ToCString());
      comment_finger++;
    }
    int instruction_length;
    DecodeInstruction(hex_buffer, sizeof(hex_buffer),
                      human_buffer, sizeof(human_buffer),
                      &instruction_length, pc);

    formatter->ConsumeInstruction(hex_buffer,
                                  sizeof(hex_buffer),
                                  human_buffer,
                                  sizeof(human_buffer),
                                  pc);
    pc += instruction_length;
  }

  return;
}

}  // namespace dart

#endif  // defined TARGET_ARCH_MIPS