src/s390/disasm-s390.cc

// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// A Disassembler object is used to disassemble a block of code instruction by
// instruction. The default implementation of the NameConverter object can be
// overriden to modify register names or to do symbol lookup on addresses.
//
// The example below will disassemble a block of code and print it to stdout.
//
//   NameConverter converter;
//   Disassembler d(converter);
//   for (byte* pc = begin; pc < end;) {
//     v8::internal::EmbeddedVector<char, 256> buffer;
//     byte* prev_pc = pc;
//     pc += d.InstructionDecode(buffer, pc);
//     printf("%p    %08x      %s\n",
//            prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer);
//   }
//
// The Disassembler class also has a convenience method to disassemble a block
// of code into a FILE*, meaning that the above functionality could also be
// achieved by just calling Disassembler::Disassemble(stdout, begin, end);

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#if V8_TARGET_ARCH_S390

#include "src/base/platform/platform.h"
#include "src/disasm.h"
#include "src/macro-assembler.h"
#include "src/s390/constants-s390.h"

namespace v8 {
namespace internal {

const auto GetRegConfig = RegisterConfiguration::Crankshaft;

//------------------------------------------------------------------------------

// Decoder decodes and disassembles instructions into an output buffer.
// It uses the converter to convert register names and call destinations into
// more informative description.
class Decoder {
 public:
  Decoder(const disasm::NameConverter& converter, Vector<char> out_buffer)
      : converter_(converter), out_buffer_(out_buffer), out_buffer_pos_(0) {
    out_buffer_[out_buffer_pos_] = '\0';
  }

  ~Decoder() {}

  // Writes one disassembled instruction into 'buffer' (0-terminated).
  // Returns the length of the disassembled machine instruction in bytes.
  int InstructionDecode(byte* instruction);

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

  // Printing of common values.
  void PrintRegister(int reg);
  void PrintDRegister(int reg);
  void PrintSoftwareInterrupt(SoftwareInterruptCodes svc);

  // Handle formatting of instructions and their options.
  int FormatRegister(Instruction* instr, const char* option);
  int FormatFloatingRegister(Instruction* instr, const char* option);
  int FormatMask(Instruction* instr, const char* option);
  int FormatDisplacement(Instruction* instr, const char* option);
  int FormatImmediate(Instruction* instr, const char* option);
  int FormatOption(Instruction* instr, const char* option);
  void Format(Instruction* instr, const char* format);
  void Unknown(Instruction* instr);
  void UnknownFormat(Instruction* instr, const char* opcname);

  bool DecodeTwoByte(Instruction* instr);
  bool DecodeFourByte(Instruction* instr);
  bool DecodeSixByte(Instruction* instr);

  const disasm::NameConverter& converter_;
  Vector<char> out_buffer_;
  int out_buffer_pos_;

  DISALLOW_COPY_AND_ASSIGN(Decoder);
};

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

// Append the ch to the output buffer.
void Decoder::PrintChar(const char ch) { out_buffer_[out_buffer_pos_++] = ch; }

// Append the str to the output buffer.
void Decoder::Print(const char* str) {
  char cur = *str++;
  while (cur != '\0' && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
    PrintChar(cur);
    cur = *str++;
  }
  out_buffer_[out_buffer_pos_] = 0;
}

// Print the register name according to the active name converter.
void Decoder::PrintRegister(int reg) {
  Print(converter_.NameOfCPURegister(reg));
}

// Print the double FP register name according to the active name converter.
void Decoder::PrintDRegister(int reg) {
  Print(GetRegConfig()->GetDoubleRegisterName(reg));
}

// Print SoftwareInterrupt codes. Factoring this out reduces the complexity of
// the FormatOption method.
void Decoder::PrintSoftwareInterrupt(SoftwareInterruptCodes svc) {
  switch (svc) {
    case kCallRtRedirected:
      Print("call rt redirected");
      return;
    case kBreakpoint:
      Print("breakpoint");
      return;
    default:
      if (svc >= kStopCode) {
        out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d - 0x%x",
                                    svc & kStopCodeMask, svc & kStopCodeMask);
      } else {
        out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", svc);
      }
      return;
  }
}

// Handle all register based formatting in this function to reduce the
// complexity of FormatOption.
int Decoder::FormatRegister(Instruction* instr, const char* format) {
  DCHECK(format[0] == 'r');

  if (format[1] == '1') {  // 'r1: register resides in bit 8-11
    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
    int reg = rrinstr->R1Value();
    PrintRegister(reg);
    return 2;
  } else if (format[1] == '2') {  // 'r2: register resides in bit 12-15
    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
    int reg = rrinstr->R2Value();
    // indicating it is a r0 for displacement, in which case the offset
    // should be 0.
    if (format[2] == 'd') {
      if (reg == 0) return 4;
      PrintRegister(reg);
      return 3;
    } else {
      PrintRegister(reg);
      return 2;
    }
  } else if (format[1] == '3') {  // 'r3: register resides in bit 16-19
    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
    int reg = rsinstr->B2Value();
    PrintRegister(reg);
    return 2;
  } else if (format[1] == '4') {  // 'r4: register resides in bit 20-23
    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
    int reg = rsinstr->B2Value();
    PrintRegister(reg);
    return 2;
  } else if (format[1] == '5') {  // 'r5: register resides in bit 24-28
    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
    int reg = rreinstr->R1Value();
    PrintRegister(reg);
    return 2;
  } else if (format[1] == '6') {  // 'r6: register resides in bit 29-32
    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
    int reg = rreinstr->R2Value();
    PrintRegister(reg);
    return 2;
  } else if (format[1] == '7') {  // 'r6: register resides in bit 32-35
    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
    int reg = ssinstr->B2Value();
    PrintRegister(reg);
    return 2;
  }

  UNREACHABLE();
  return -1;
}

int Decoder::FormatFloatingRegister(Instruction* instr, const char* format) {
  DCHECK(format[0] == 'f');

  // reuse 1, 5 and 6 because it is coresponding
  if (format[1] == '1') {  // 'r1: register resides in bit 8-11
    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
    int reg = rrinstr->R1Value();
    PrintDRegister(reg);
    return 2;
  } else if (format[1] == '2') {  // 'f2: register resides in bit 12-15
    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
    int reg = rrinstr->R2Value();
    PrintDRegister(reg);
    return 2;
  } else if (format[1] == '3') {  // 'f3: register resides in bit 16-19
    RRDInstruction* rrdinstr = reinterpret_cast<RRDInstruction*>(instr);
    int reg = rrdinstr->R1Value();
    PrintDRegister(reg);
    return 2;
  } else if (format[1] == '5') {  // 'f5: register resides in bit 24-28
    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
    int reg = rreinstr->R1Value();
    PrintDRegister(reg);
    return 2;
  } else if (format[1] == '6') {  // 'f6: register resides in bit 29-32
    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
    int reg = rreinstr->R2Value();
    PrintDRegister(reg);
    return 2;
  }
  UNREACHABLE();
  return -1;
}

// 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 Decoder::FormatOption(Instruction* instr, const char* format) {
  switch (format[0]) {
    case 'o': {
      if (instr->Bit(10) == 1) {
        Print("o");
      }
      return 1;
    }
    case '.': {
      if (instr->Bit(0) == 1) {
        Print(".");
      } else {
        Print(" ");  // ensure consistent spacing
      }
      return 1;
    }
    case 'r': {
      return FormatRegister(instr, format);
    }
    case 'f': {
      return FormatFloatingRegister(instr, format);
    }
    case 'i': {  // int16
      return FormatImmediate(instr, format);
    }
    case 'u': {  // uint16
      int32_t value = instr->Bits(15, 0);
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
      return 6;
    }
    case 'l': {
      // Link (LK) Bit 0
      if (instr->Bit(0) == 1) {
        Print("l");
      }
      return 1;
    }
    case 'a': {
      // Absolute Address Bit 1
      if (instr->Bit(1) == 1) {
        Print("a");
      }
      return 1;
    }
    case 't': {  // 'target: target of branch instructions
      // target26 or target16
      DCHECK(STRING_STARTS_WITH(format, "target"));
      if ((format[6] == '2') && (format[7] == '6')) {
        int off = ((instr->Bits(25, 2)) << 8) >> 6;
        out_buffer_pos_ += SNPrintF(
            out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
            converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
        return 8;
      } else if ((format[6] == '1') && (format[7] == '6')) {
        int off = ((instr->Bits(15, 2)) << 18) >> 16;
        out_buffer_pos_ += SNPrintF(
            out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
            converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
        return 8;
      }
      case 'm': {
        return FormatMask(instr, format);
      }
    }
    case 'd': {  // ds value for offset
      return FormatDisplacement(instr, format);
    }
    default: {
      UNREACHABLE();
      break;
    }
  }

  UNREACHABLE();
  return -1;
}

int Decoder::FormatMask(Instruction* instr, const char* format) {
  DCHECK(format[0] == 'm');
  int32_t value = 0;
  if ((format[1] == '1')) {  // prints the mask format in bits 8-12
    value = reinterpret_cast<RRInstruction*>(instr)->R1Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
    return 2;
  } else if (format[1] == '2') {  // mask format in bits 16-19
    value = reinterpret_cast<RXInstruction*>(instr)->B2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
    return 2;
  } else if (format[1] == '3') {  // mask format in bits 20-23
    value = reinterpret_cast<RRFInstruction*>(instr)->M4Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
    return 2;
  }

  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
  return 2;
}

int Decoder::FormatDisplacement(Instruction* instr, const char* format) {
  DCHECK(format[0] == 'd');

  if (format[1] == '1') {  // displacement in 20-31
    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
    uint16_t value = rsinstr->D2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);

    return 2;
  } else if (format[1] == '2') {  // displacement in 20-39
    RXYInstruction* rxyinstr = reinterpret_cast<RXYInstruction*>(instr);
    int32_t value = rxyinstr->D2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '4') {  // SS displacement 2 36-47
    SSInstruction* ssInstr = reinterpret_cast<SSInstruction*>(instr);
    uint16_t value = ssInstr->D2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '3') {  // SS displacement 1 20 - 32
    SSInstruction* ssInstr = reinterpret_cast<SSInstruction*>(instr);
    uint16_t value = ssInstr->D1Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else {  // s390 specific
    int32_t value = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 1;
  }
}

int Decoder::FormatImmediate(Instruction* instr, const char* format) {
  DCHECK(format[0] == 'i');

  if (format[1] == '1') {  // immediate in 16-31
    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
    int16_t value = riinstr->I2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '2') {  // immediate in 16-48
    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
    int32_t value = rilinstr->I2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '3') {  // immediate in I format
    IInstruction* iinstr = reinterpret_cast<IInstruction*>(instr);
    int8_t value = iinstr->IValue();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '4') {  // immediate in 16-31, but outputs as offset
    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
    int16_t value = riinstr->I2Value() * 2;
    if (value >= 0)
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
    else
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");

    out_buffer_pos_ += SNPrintF(
        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
    return 2;
  } else if (format[1] == '5') {  // immediate in 16-31, but outputs as offset
    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
    int32_t value = rilinstr->I2Value() * 2;
    if (value >= 0)
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
    else
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");

    out_buffer_pos_ += SNPrintF(
        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
    return 2;
  } else if (format[1] == '6') {  // unsigned immediate in 16-31
    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
    uint16_t value = riinstr->I2UnsignedValue();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '7') {  // unsigned immediate in 16-47
    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
    uint32_t value = rilinstr->I2UnsignedValue();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '8') {  // unsigned immediate in 8-15
    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
    uint8_t value = ssinstr->Length();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == '9') {  // unsigned immediate in 16-23
    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
    uint8_t value = rie_instr->I3Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == 'a') {  // unsigned immediate in 24-31
    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
    uint8_t value = rie_instr->I4Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == 'b') {  // unsigned immediate in 32-39
    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
    uint8_t value = rie_instr->I5Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == 'c') {  // signed immediate in 8-15
    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
    int8_t value = ssinstr->Length();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == 'd') {  // signed immediate in 32-47
    SILInstruction* silinstr = reinterpret_cast<SILInstruction*>(instr);
    int16_t value = silinstr->I2Value();
    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
    return 2;
  } else if (format[1] == 'e') {  // immediate in 16-47, but outputs as offset
    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
    int32_t value = rilinstr->I2Value() * 2;
    if (value >= 0)
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
    else
      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");

    out_buffer_pos_ += SNPrintF(
        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
    return 2;
  }

  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 Decoder::Format(Instruction* instr, const char* format) {
  char cur = *format++;
  while ((cur != 0) && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
    if (cur == '\'') {  // Single quote is used as the formatting escape.
      format += FormatOption(instr, format);
    } else {
      out_buffer_[out_buffer_pos_++] = cur;
    }
    cur = *format++;
  }
  out_buffer_[out_buffer_pos_] = '\0';
}

// The disassembler may end up decoding data inlined in the code. We do not want
// it to crash if the data does not ressemble any known instruction.
#define VERIFY(condition) \
  if (!(condition)) {     \
    Unknown(instr);       \
    return;               \
  }

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

// For currently unimplemented decodings the disassembler calls
// UnknownFormat(instr) which will just print opcode name of the
// instruction bits.
void Decoder::UnknownFormat(Instruction* instr, const char* name) {
  char buffer[100];
  snprintf(buffer, sizeof(buffer), "%s (unknown-format)", name);
  Format(instr, buffer);
}

// Disassembles Two Byte S390 Instructions
// @return true if successfully decoded
bool Decoder::DecodeTwoByte(Instruction* instr) {
  // Print the Instruction bits.
  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%04x           ",
                              instr->InstructionBits<TwoByteInstr>());

  Opcode opcode = instr->S390OpcodeValue();
  switch (opcode) {
    case AR:
      Format(instr, "ar\t'r1,'r2");
      break;
    case SR:
      Format(instr, "sr\t'r1,'r2");
      break;
    case MR:
      Format(instr, "mr\t'r1,'r2");
      break;
    case DR:
      Format(instr, "dr\t'r1,'r2");
      break;
    case OR:
      Format(instr, "or\t'r1,'r2");
      break;
    case NR:
      Format(instr, "nr\t'r1,'r2");
      break;
    case XR:
      Format(instr, "xr\t'r1,'r2");
      break;
    case LR:
      Format(instr, "lr\t'r1,'r2");
      break;
    case CR:
      Format(instr, "cr\t'r1,'r2");
      break;
    case CLR:
      Format(instr, "clr\t'r1,'r2");
      break;
    case BCR:
      Format(instr, "bcr\t'm1,'r2");
      break;
    case LTR:
      Format(instr, "ltr\t'r1,'r2");
      break;
    case ALR:
      Format(instr, "alr\t'r1,'r2");
      break;
    case SLR:
      Format(instr, "slr\t'r1,'r2");
      break;
    case LNR:
      Format(instr, "lnr\t'r1,'r2");
      break;
    case LCR:
      Format(instr, "lcr\t'r1,'r2");
      break;
    case BASR:
      Format(instr, "basr\t'r1,'r2");
      break;
    case LDR:
      Format(instr, "ldr\t'f1,'f2");
      break;
    case BKPT:
      Format(instr, "bkpt");
      break;
    default:
      return false;
  }
  return true;
}

// Disassembles Four Byte S390 Instructions
// @return true if successfully decoded
bool Decoder::DecodeFourByte(Instruction* instr) {
  // Print the Instruction bits.
  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%08x       ",
                              instr->InstructionBits<FourByteInstr>());

  Opcode opcode = instr->S390OpcodeValue();
  switch (opcode) {
    case AHI:
      Format(instr, "ahi\t'r1,'i1");
      break;
    case AGHI:
      Format(instr, "aghi\t'r1,'i1");
      break;
    case LHI:
      Format(instr, "lhi\t'r1,'i1");
      break;
    case LGHI:
      Format(instr, "lghi\t'r1,'i1");
      break;
    case MHI:
      Format(instr, "mhi\t'r1,'i1");
      break;
    case MGHI:
      Format(instr, "mghi\t'r1,'i1");
      break;
    case CHI:
      Format(instr, "chi\t'r1,'i1");
      break;
    case CGHI:
      Format(instr, "cghi\t'r1,'i1");
      break;
    case BRAS:
      Format(instr, "bras\t'r1,'i1");
      break;
    case BRC:
      Format(instr, "brc\t'm1,'i4");
      break;
    case BRCT:
      Format(instr, "brct\t'r1,'i4");
      break;
    case BRCTG:
      Format(instr, "brctg\t'r1,'i4");
      break;
    case IIHH:
      Format(instr, "iihh\t'r1,'i1");
      break;
    case IIHL:
      Format(instr, "iihl\t'r1,'i1");
      break;
    case IILH:
      Format(instr, "iilh\t'r1,'i1");
      break;
    case IILL:
      Format(instr, "iill\t'r1,'i1");
      break;
    case OILL:
      Format(instr, "oill\t'r1,'i1");
      break;
    case TMLL:
      Format(instr, "tmll\t'r1,'i1");
      break;
    case STM:
      Format(instr, "stm\t'r1,'r2,'d1('r3)");
      break;
    case LM:
      Format(instr, "lm\t'r1,'r2,'d1('r3)");
      break;
    case SLL:
      Format(instr, "sll\t'r1,'d1('r3)");
      break;
    case SRL:
      Format(instr, "srl\t'r1,'d1('r3)");
      break;
    case SLA:
      Format(instr, "sla\t'r1,'d1('r3)");
      break;
    case SRA:
      Format(instr, "sra\t'r1,'d1('r3)");
      break;
    case SLDL:
      Format(instr, "sldl\t'r1,'d1('r3)");
      break;
    case AGR:
      Format(instr, "agr\t'r5,'r6");
      break;
    case AGFR:
      Format(instr, "agfr\t'r5,'r6");
      break;
    case ARK:
      Format(instr, "ark\t'r5,'r6,'r3");
      break;
    case AGRK:
      Format(instr, "agrk\t'r5,'r6,'r3");
      break;
    case SGR:
      Format(instr, "sgr\t'r5,'r6");
      break;
    case SGFR:
      Format(instr, "sgfr\t'r5,'r6");
      break;
    case SRK:
      Format(instr, "srk\t'r5,'r6,'r3");
      break;
    case SGRK:
      Format(instr, "sgrk\t'r5,'r6,'r3");
      break;
    case NGR:
      Format(instr, "ngr\t'r5,'r6");
      break;
    case NRK:
      Format(instr, "nrk\t'r5,'r6,'r3");
      break;
    case NGRK:
      Format(instr, "ngrk\t'r5,'r6,'r3");
      break;
    case NILL:
      Format(instr, "nill\t'r1,'i1");
      break;
    case NILH:
      Format(instr, "nilh\t'r1,'i1");
      break;
    case OGR:
      Format(instr, "ogr\t'r5,'r6");
      break;
    case ORK:
      Format(instr, "ork\t'r5,'r6,'r3");
      break;
    case OGRK:
      Format(instr, "ogrk\t'r5,'r6,'r3");
      break;
    case XGR:
      Format(instr, "xgr\t'r5,'r6");
      break;
    case XRK:
      Format(instr, "xrk\t'r5,'r6,'r3");
      break;
    case XGRK:
      Format(instr, "xgrk\t'r5,'r6,'r3");
      break;
    case CGR:
      Format(instr, "cgr\t'r5,'r6");
      break;
    case CLGR:
      Format(instr, "clgr\t'r5,'r6");
      break;
    case LLGFR:
      Format(instr, "llgfr\t'r5,'r6");
      break;
    case LBR:
      Format(instr, "lbr\t'r5,'r6");
      break;
    case LEDBR:
      Format(instr, "ledbr\t'f5,'f6");
      break;
    case LDEBR:
      Format(instr, "ldebr\t'f5,'f6");
      break;
    case LTGR:
      Format(instr, "ltgr\t'r5,'r6");
      break;
    case LTDBR:
      Format(instr, "ltdbr\t'f5,'f6");
      break;
    case LTEBR:
      Format(instr, "ltebr\t'f5,'f6");
      break;
    case LGR:
      Format(instr, "lgr\t'r5,'r6");
      break;
    case LGDR:
      Format(instr, "lgdr\t'r5,'f6");
      break;
    case LGFR:
      Format(instr, "lgfr\t'r5,'r6");
      break;
    case LTGFR:
      Format(instr, "ltgfr\t'r5,'r6");
      break;
    case LCGR:
      Format(instr, "lcgr\t'r5,'r6");
      break;
    case MSR:
      Format(instr, "msr\t'r5,'r6");
      break;
    case LGBR:
      Format(instr, "lgbr\t'r5,'r6");
      break;
    case LGHR:
      Format(instr, "lghr\t'r5,'r6");
      break;
    case MSGR:
      Format(instr, "msgr\t'r5,'r6");
      break;
    case DSGR:
      Format(instr, "dsgr\t'r5,'r6");
      break;
    case LZDR:
      Format(instr, "lzdr\t'f5");
      break;
    case MLR:
      Format(instr, "mlr\t'r5,'r6");
      break;
    case MLGR:
      Format(instr, "mlgr\t'r5,'r6");
      break;
    case ALCR:
      Format(instr, "alcr\t'r5,'r6");
      break;
    case ALGR:
      Format(instr, "algr\t'r5,'r6");
      break;
    case ALRK:
      Format(instr, "alrk\t'r5,'r6,'r3");
      break;
    case ALGRK:
      Format(instr, "algrk\t'r5,'r6,'r3");
      break;
    case SLGR:
      Format(instr, "slgr\t'r5,'r6");
      break;
    case SLBR:
      Format(instr, "slbr\t'r5,'r6");
      break;
    case DLR:
      Format(instr, "dlr\t'r5,'r6");
      break;
    case DLGR:
      Format(instr, "dlgr\t'r5,'r6");
      break;
    case SLRK:
      Format(instr, "slrk\t'r5,'r6,'r3");
      break;
    case SLGRK:
      Format(instr, "slgrk\t'r5,'r6,'r3");
      break;
    case LHR:
      Format(instr, "lhr\t'r5,'r6");
      break;
    case LLHR:
      Format(instr, "llhr\t'r5,'r6");
      break;
    case LLGHR:
      Format(instr, "llghr\t'r5,'r6");
      break;
    case LNGR:
      Format(instr, "lngr\t'r5,'r6");
      break;
    case A:
      Format(instr, "a\t'r1,'d1('r2d,'r3)");
      break;
    case S:
      Format(instr, "s\t'r1,'d1('r2d,'r3)");
      break;
    case M:
      Format(instr, "m\t'r1,'d1('r2d,'r3)");
      break;
    case D:
      Format(instr, "d\t'r1,'d1('r2d,'r3)");
      break;
    case O:
      Format(instr, "o\t'r1,'d1('r2d,'r3)");
      break;
    case N:
      Format(instr, "n\t'r1,'d1('r2d,'r3)");
      break;
    case L:
      Format(instr, "l\t'r1,'d1('r2d,'r3)");
      break;
    case C:
      Format(instr, "c\t'r1,'d1('r2d,'r3)");
      break;
    case AH:
      Format(instr, "ah\t'r1,'d1('r2d,'r3)");
      break;
    case SH:
      Format(instr, "sh\t'r1,'d1('r2d,'r3)");
      break;
    case MH:
      Format(instr, "mh\t'r1,'d1('r2d,'r3)");
      break;
    case AL:
      Format(instr, "al\t'r1,'d1('r2d,'r3)");
      break;
    case SL:
      Format(instr, "sl\t'r1,'d1('r2d,'r3)");
      break;
    case LA:
      Format(instr, "la\t'r1,'d1('r2d,'r3)");
      break;
    case CH:
      Format(instr, "ch\t'r1,'d1('r2d,'r3)");
      break;
    case CL:
      Format(instr, "cl\t'r1,'d1('r2d,'r3)");
      break;
    case CLI:
      Format(instr, "cli\t'd1('r3),'i8");
      break;
    case TM:
      Format(instr, "tm\t'd1('r3),'i8");
      break;
    case BC:
      Format(instr, "bc\t'm1,'d1('r2d,'r3)");
      break;
    case BCT:
      Format(instr, "bct\t'r1,'d1('r2d,'r3)");
      break;
    case ST:
      Format(instr, "st\t'r1,'d1('r2d,'r3)");
      break;
    case STC:
      Format(instr, "stc\t'r1,'d1('r2d,'r3)");
      break;
    case IC_z:
      Format(instr, "ic\t'r1,'d1('r2d,'r3)");
      break;
    case LD:
      Format(instr, "ld\t'f1,'d1('r2d,'r3)");
      break;
    case LE:
      Format(instr, "le\t'f1,'d1('r2d,'r3)");
      break;
    case LDGR:
      Format(instr, "ldgr\t'f5,'r6");
      break;
    case STE:
      Format(instr, "ste\t'f1,'d1('r2d,'r3)");
      break;
    case STD:
      Format(instr, "std\t'f1,'d1('r2d,'r3)");
      break;
    case CFDBR:
      Format(instr, "cfdbr\t'r5,'m2,'f6");
      break;
    case CDFBR:
      Format(instr, "cdfbr\t'f5,'m2,'r6");
      break;
    case CFEBR:
      Format(instr, "cfebr\t'r5,'m2,'f6");
      break;
    case CEFBR:
      Format(instr, "cefbr\t'f5,'m2,'r6");
      break;
    case CGEBR:
      Format(instr, "cgebr\t'r5,'m2,'f6");
      break;
    case CGDBR:
      Format(instr, "cgdbr\t'r5,'m2,'f6");
      break;
    case CEGBR:
      Format(instr, "cegbr\t'f5,'m2,'r6");
      break;
    case CDGBR:
      Format(instr, "cdgbr\t'f5,'m2,'r6");
      break;
    case CDLFBR:
      Format(instr, "cdlfbr\t'f5,'m2,'r6");
      break;
    case CDLGBR:
      Format(instr, "cdlgbr\t'f5,'m2,'r6");
      break;
    case CELGBR:
      Format(instr, "celgbr\t'f5,'m2,'r6");
      break;
    case CLFDBR:
      Format(instr, "clfdbr\t'r5,'m2,'f6");
      break;
    case CLGDBR:
      Format(instr, "clgdbr\t'r5,'m2,'f6");
      break;
    case AEBR:
      Format(instr, "aebr\t'f5,'f6");
      break;
    case SEBR:
      Format(instr, "sebr\t'f5,'f6");
      break;
    case MEEBR:
      Format(instr, "meebr\t'f5,'f6");
      break;
    case DEBR:
      Format(instr, "debr\t'f5,'f6");
      break;
    case ADBR:
      Format(instr, "adbr\t'f5,'f6");
      break;
    case SDBR:
      Format(instr, "sdbr\t'f5,'f6");
      break;
    case MDBR:
      Format(instr, "mdbr\t'f5,'f6");
      break;
    case DDBR:
      Format(instr, "ddbr\t'f5,'f6");
      break;
    case CDBR:
      Format(instr, "cdbr\t'f5,'f6");
      break;
    case CEBR:
      Format(instr, "cebr\t'f5,'f6");
      break;
    case SQDBR:
      Format(instr, "sqdbr\t'f5,'f6");
      break;
    case SQEBR:
      Format(instr, "sqebr\t'f5,'f6");
      break;
    case LCDBR:
      Format(instr, "lcdbr\t'f5,'f6");
      break;
    case STH:
      Format(instr, "sth\t'r1,'d1('r2d,'r3)");
      break;
    case SRDA:
      Format(instr, "srda\t'r1,'d1('r3)");
      break;
    case SRDL:
      Format(instr, "srdl\t'r1,'d1('r3)");
      break;
    case MADBR:
      Format(instr, "madbr\t'f3,'f5,'f6");
      break;
    case MSDBR:
      Format(instr, "msdbr\t'f3,'f5,'f6");
      break;
    case FLOGR:
      Format(instr, "flogr\t'r5,'r6");
      break;
    case FIEBRA:
      Format(instr, "fiebra\t'f5,'m2,'f6,'m3");
      break;
    case FIDBRA:
      Format(instr, "fidbra\t'f5,'m2,'f6,'m3");
      break;
    // TRAP4 is used in calling to native function. it will not be generated
    // in native code.
    case TRAP4: {
      Format(instr, "trap4");
      break;
    }
    default:
      return false;
  }
  return true;
}

// Disassembles Six Byte S390 Instructions
// @return true if successfully decoded
bool Decoder::DecodeSixByte(Instruction* instr) {
  // Print the Instruction bits.
  out_buffer_pos_ +=
      SNPrintF(out_buffer_ + out_buffer_pos_, "%012" PRIx64 "   ",
               instr->InstructionBits<SixByteInstr>());

  Opcode opcode = instr->S390OpcodeValue();
  switch (opcode) {
    case LLILF:
      Format(instr, "llilf\t'r1,'i7");
      break;
    case LLIHF:
      Format(instr, "llihf\t'r1,'i7");
      break;
    case AFI:
      Format(instr, "afi\t'r1,'i7");
      break;
    case ASI:
      Format(instr, "asi\t'd2('r3),'ic");
      break;
    case AGSI:
      Format(instr, "agsi\t'd2('r3),'ic");
      break;
    case ALFI:
      Format(instr, "alfi\t'r1,'i7");
      break;
    case AHIK:
      Format(instr, "ahik\t'r1,'r2,'i1");
      break;
    case AGHIK:
      Format(instr, "aghik\t'r1,'r2,'i1");
      break;
    case CLGFI:
      Format(instr, "clgfi\t'r1,'i7");
      break;
    case CLFI:
      Format(instr, "clfi\t'r1,'i7");
      break;
    case CFI:
      Format(instr, "cfi\t'r1,'i2");
      break;
    case CGFI:
      Format(instr, "cgfi\t'r1,'i2");
      break;
    case BRASL:
      Format(instr, "brasl\t'r1,'ie");
      break;
    case BRCL:
      Format(instr, "brcl\t'm1,'i5");
      break;
    case IIHF:
      Format(instr, "iihf\t'r1,'i7");
      break;
    case IILF:
      Format(instr, "iilf\t'r1,'i7");
      break;
    case XIHF:
      Format(instr, "xihf\t'r1,'i7");
      break;
    case XILF:
      Format(instr, "xilf\t'r1,'i7");
      break;
    case SLLK:
      Format(instr, "sllk\t'r1,'r2,'d2('r3)");
      break;
    case SLLG:
      Format(instr, "sllg\t'r1,'r2,'d2('r3)");
      break;
    case RLL:
      Format(instr, "rll\t'r1,'r2,'d2('r3)");
      break;
    case RLLG:
      Format(instr, "rllg\t'r1,'r2,'d2('r3)");
      break;
    case SRLK:
      Format(instr, "srlk\t'r1,'r2,'d2('r3)");
      break;
    case SRLG:
      Format(instr, "srlg\t'r1,'r2,'d2('r3)");
      break;
    case SLAK:
      Format(instr, "slak\t'r1,'r2,'d2('r3)");
      break;
    case SLAG:
      Format(instr, "slag\t'r1,'r2,'d2('r3)");
      break;
    case SRAK:
      Format(instr, "srak\t'r1,'r2,'d2('r3)");
      break;
    case SRAG:
      Format(instr, "srag\t'r1,'r2,'d2('r3)");
      break;
    case RISBG:
      Format(instr, "risbg\t'r1,'r2,'i9,'ia,'ib");
      break;
    case RISBGN:
      Format(instr, "risbgn\t'r1,'r2,'i9,'ia,'ib");
      break;
    case LMY:
      Format(instr, "lmy\t'r1,'r2,'d2('r3)");
      break;
    case LMG:
      Format(instr, "lmg\t'r1,'r2,'d2('r3)");
      break;
    case STMY:
      Format(instr, "stmy\t'r1,'r2,'d2('r3)");
      break;
    case STMG:
      Format(instr, "stmg\t'r1,'r2,'d2('r3)");
      break;
    case LT:
      Format(instr, "lt\t'r1,'d2('r2d,'r3)");
      break;
    case LTG:
      Format(instr, "ltg\t'r1,'d2('r2d,'r3)");
      break;
    case ML:
      Format(instr, "ml\t'r1,'d2('r2d,'r3)");
      break;
    case AY:
      Format(instr, "ay\t'r1,'d2('r2d,'r3)");
      break;
    case SY:
      Format(instr, "sy\t'r1,'d2('r2d,'r3)");
      break;
    case NY:
      Format(instr, "ny\t'r1,'d2('r2d,'r3)");
      break;
    case OY:
      Format(instr, "oy\t'r1,'d2('r2d,'r3)");
      break;
    case XY:
      Format(instr, "xy\t'r1,'d2('r2d,'r3)");
      break;
    case CY:
      Format(instr, "cy\t'r1,'d2('r2d,'r3)");
      break;
    case AHY:
      Format(instr, "ahy\t'r1,'d2('r2d,'r3)");
      break;
    case SHY:
      Format(instr, "shy\t'r1,'d2('r2d,'r3)");
      break;
    case LGH:
      Format(instr, "lgh\t'r1,'d2('r2d,'r3)");
      break;
    case AG:
      Format(instr, "ag\t'r1,'d2('r2d,'r3)");
      break;
    case AGF:
      Format(instr, "agf\t'r1,'d2('r2d,'r3)");
      break;
    case SG:
      Format(instr, "sg\t'r1,'d2('r2d,'r3)");
      break;
    case NG:
      Format(instr, "ng\t'r1,'d2('r2d,'r3)");
      break;
    case OG:
      Format(instr, "og\t'r1,'d2('r2d,'r3)");
      break;
    case XG:
      Format(instr, "xg\t'r1,'d2('r2d,'r3)");
      break;
    case CG:
      Format(instr, "cg\t'r1,'d2('r2d,'r3)");
      break;
    case LB:
      Format(instr, "lb\t'r1,'d2('r2d,'r3)");
      break;
    case LG:
      Format(instr, "lg\t'r1,'d2('r2d,'r3)");
      break;
    case LGF:
      Format(instr, "lgf\t'r1,'d2('r2d,'r3)");
      break;
    case LLGF:
      Format(instr, "llgf\t'r1,'d2('r2d,'r3)");
      break;
    case LY:
      Format(instr, "ly\t'r1,'d2('r2d,'r3)");
      break;
    case ALY:
      Format(instr, "aly\t'r1,'d2('r2d,'r3)");
      break;
    case ALG:
      Format(instr, "alg\t'r1,'d2('r2d,'r3)");
      break;
    case SLG:
      Format(instr, "slg\t'r1,'d2('r2d,'r3)");
      break;
    case SGF:
      Format(instr, "sgf\t'r1,'d2('r2d,'r3)");
      break;
    case SLY:
      Format(instr, "sly\t'r1,'d2('r2d,'r3)");
      break;
    case LLH:
      Format(instr, "llh\t'r1,'d2('r2d,'r3)");
      break;
    case LLGH:
      Format(instr, "llgh\t'r1,'d2('r2d,'r3)");
      break;
    case LLC:
      Format(instr, "llc\t'r1,'d2('r2d,'r3)");
      break;
    case LLGC:
      Format(instr, "llgc\t'r1,'d2('r2d,'r3)");
      break;
    case LDEB:
      Format(instr, "ldeb\t'f1,'d2('r2d,'r3)");
      break;
    case LAY:
      Format(instr, "lay\t'r1,'d2('r2d,'r3)");
      break;
    case LARL:
      Format(instr, "larl\t'r1,'i5");
      break;
    case LGB:
      Format(instr, "lgb\t'r1,'d2('r2d,'r3)");
      break;
    case CHY:
      Format(instr, "chy\t'r1,'d2('r2d,'r3)");
      break;
    case CLY:
      Format(instr, "cly\t'r1,'d2('r2d,'r3)");
      break;
    case CLIY:
      Format(instr, "cliy\t'd2('r3),'i8");
      break;
    case TMY:
      Format(instr, "tmy\t'd2('r3),'i8");
      break;
    case CLG:
      Format(instr, "clg\t'r1,'d2('r2d,'r3)");
      break;
    case BCTG:
      Format(instr, "bctg\t'r1,'d2('r2d,'r3)");
      break;
    case STY:
      Format(instr, "sty\t'r1,'d2('r2d,'r3)");
      break;
    case STG:
      Format(instr, "stg\t'r1,'d2('r2d,'r3)");
      break;
    case ICY:
      Format(instr, "icy\t'r1,'d2('r2d,'r3)");
      break;
    case MVC:
      Format(instr, "mvc\t'd3('i8,'r3),'d4('r7)");
      break;
    case MVHI:
      Format(instr, "mvhi\t'd3('r3),'id");
      break;
    case MVGHI:
      Format(instr, "mvghi\t'd3('r3),'id");
      break;
    case ALGFI:
      Format(instr, "algfi\t'r1,'i7");
      break;
    case SLGFI:
      Format(instr, "slgfi\t'r1,'i7");
      break;
    case SLFI:
      Format(instr, "slfi\t'r1,'i7");
      break;
    case NIHF:
      Format(instr, "nihf\t'r1,'i7");
      break;
    case NILF:
      Format(instr, "nilf\t'r1,'i7");
      break;
    case OIHF:
      Format(instr, "oihf\t'r1,'i7");
      break;
    case OILF:
      Format(instr, "oilf\t'r1,'i7");
      break;
    case MSFI:
      Format(instr, "msfi\t'r1,'i7");
      break;
    case MSGFI:
      Format(instr, "msgfi\t'r1,'i7");
      break;
    case LDY:
      Format(instr, "ldy\t'f1,'d2('r2d,'r3)");
      break;
    case LEY:
      Format(instr, "ley\t'f1,'d2('r2d,'r3)");
      break;
    case STEY:
      Format(instr, "stey\t'f1,'d2('r2d,'r3)");
      break;
    case STDY:
      Format(instr, "stdy\t'f1,'d2('r2d,'r3)");
      break;
    case ADB:
      Format(instr, "adb\t'r1,'d1('r2d, 'r3)");
      break;
    case SDB:
      Format(instr, "sdb\t'r1,'d1('r2d, 'r3)");
      break;
    case MDB:
      Format(instr, "mdb\t'r1,'d1('r2d, 'r3)");
      break;
    case DDB:
      Format(instr, "ddb\t'r1,'d1('r2d, 'r3)");
      break;
    case SQDB:
      Format(instr, "sqdb\t'r1,'d1('r2d, 'r3)");
      break;
    default:
      return false;
  }
  return true;
}

#undef VERIFIY

// Disassemble the instruction at *instr_ptr into the output buffer.
int Decoder::InstructionDecode(byte* instr_ptr) {
  Instruction* instr = Instruction::At(instr_ptr);
  int instrLength = instr->InstructionLength();

  if (2 == instrLength)
    DecodeTwoByte(instr);
  else if (4 == instrLength)
    DecodeFourByte(instr);
  else
    DecodeSixByte(instr);

  return instrLength;
}

}  // namespace internal
}  // namespace v8

//------------------------------------------------------------------------------

namespace disasm {

const char* NameConverter::NameOfAddress(byte* addr) const {
  v8::internal::SNPrintF(tmp_buffer_, "%p", static_cast<void*>(addr));
  return tmp_buffer_.start();
}

const char* NameConverter::NameOfConstant(byte* addr) const {
  return NameOfAddress(addr);
}

const char* NameConverter::NameOfCPURegister(int reg) const {
  return v8::internal::GetRegConfig()->GetGeneralRegisterName(reg);
}

const char* NameConverter::NameOfByteCPURegister(int reg) const {
  UNREACHABLE();  // S390 does not have the concept of a byte register
  return "nobytereg";
}

const char* NameConverter::NameOfXMMRegister(int reg) const {
  // S390 does not have XMM register
  // TODO(joransiu): Consider update this for Vector Regs
  UNREACHABLE();
  return "noxmmreg";
}

const char* NameConverter::NameInCode(byte* addr) const {
  // The default name converter is called for unknown code. So we will not try
  // to access any memory.
  return "";
}

//------------------------------------------------------------------------------

Disassembler::Disassembler(const NameConverter& converter)
    : converter_(converter) {}

Disassembler::~Disassembler() {}

int Disassembler::InstructionDecode(v8::internal::Vector<char> buffer,
                                    byte* instruction) {
  v8::internal::Decoder d(converter_, buffer);
  return d.InstructionDecode(instruction);
}

// The S390 assembler does not currently use constant pools.
int Disassembler::ConstantPoolSizeAt(byte* instruction) { return -1; }

void Disassembler::Disassemble(FILE* f, byte* begin, byte* end) {
  NameConverter converter;
  Disassembler d(converter);
  for (byte* pc = begin; pc < end;) {
    v8::internal::EmbeddedVector<char, 128> buffer;
    buffer[0] = '\0';
    byte* prev_pc = pc;
    pc += d.InstructionDecode(buffer, pc);
    v8::internal::PrintF(f, "%p    %08x      %s\n", static_cast<void*>(prev_pc),
                         *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
  }
}

}  // namespace disasm

#endif  // V8_TARGET_ARCH_S390