1// Copyright 2014 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// A Disassembler object is used to disassemble a block of code instruction by
6// instruction. The default implementation of the NameConverter object can be
7// overriden to modify register names or to do symbol lookup on addresses.
8//
9// The example below will disassemble a block of code and print it to stdout.
10//
11//   NameConverter converter;
12//   Disassembler d(converter);
13//   for (byte* pc = begin; pc < end;) {
14//     v8::internal::EmbeddedVector<char, 256> buffer;
15//     byte* prev_pc = pc;
16//     pc += d.InstructionDecode(buffer, pc);
17//     printf("%p    %08x      %s\n",
18//            prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer);
19//   }
20//
21// The Disassembler class also has a convenience method to disassemble a block
22// of code into a FILE*, meaning that the above functionality could also be
23// achieved by just calling Disassembler::Disassemble(stdout, begin, end);
24
25#include <assert.h>
26#include <stdarg.h>
27#include <stdio.h>
28#include <string.h>
29
30#if V8_TARGET_ARCH_S390
31
32#include "src/base/platform/platform.h"
33#include "src/disasm.h"
34#include "src/macro-assembler.h"
35#include "src/s390/constants-s390.h"
36
37namespace v8 {
38namespace internal {
39
40const auto GetRegConfig = RegisterConfiguration::Crankshaft;
41
42//------------------------------------------------------------------------------
43
44// Decoder decodes and disassembles instructions into an output buffer.
45// It uses the converter to convert register names and call destinations into
46// more informative description.
47class Decoder {
48 public:
49  Decoder(const disasm::NameConverter& converter, Vector<char> out_buffer)
50      : converter_(converter), out_buffer_(out_buffer), out_buffer_pos_(0) {
51    out_buffer_[out_buffer_pos_] = '\0';
52  }
53
54  ~Decoder() {}
55
56  // Writes one disassembled instruction into 'buffer' (0-terminated).
57  // Returns the length of the disassembled machine instruction in bytes.
58  int InstructionDecode(byte* instruction);
59
60 private:
61  // Bottleneck functions to print into the out_buffer.
62  void PrintChar(const char ch);
63  void Print(const char* str);
64
65  // Printing of common values.
66  void PrintRegister(int reg);
67  void PrintDRegister(int reg);
68  void PrintSoftwareInterrupt(SoftwareInterruptCodes svc);
69
70  // Handle formatting of instructions and their options.
71  int FormatRegister(Instruction* instr, const char* option);
72  int FormatFloatingRegister(Instruction* instr, const char* option);
73  int FormatMask(Instruction* instr, const char* option);
74  int FormatDisplacement(Instruction* instr, const char* option);
75  int FormatImmediate(Instruction* instr, const char* option);
76  int FormatOption(Instruction* instr, const char* option);
77  void Format(Instruction* instr, const char* format);
78  void Unknown(Instruction* instr);
79  void UnknownFormat(Instruction* instr, const char* opcname);
80
81  bool DecodeTwoByte(Instruction* instr);
82  bool DecodeFourByte(Instruction* instr);
83  bool DecodeSixByte(Instruction* instr);
84
85  const disasm::NameConverter& converter_;
86  Vector<char> out_buffer_;
87  int out_buffer_pos_;
88
89  DISALLOW_COPY_AND_ASSIGN(Decoder);
90};
91
92// Support for assertions in the Decoder formatting functions.
93#define STRING_STARTS_WITH(string, compare_string) \
94  (strncmp(string, compare_string, strlen(compare_string)) == 0)
95
96// Append the ch to the output buffer.
97void Decoder::PrintChar(const char ch) { out_buffer_[out_buffer_pos_++] = ch; }
98
99// Append the str to the output buffer.
100void Decoder::Print(const char* str) {
101  char cur = *str++;
102  while (cur != '\0' && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
103    PrintChar(cur);
104    cur = *str++;
105  }
106  out_buffer_[out_buffer_pos_] = 0;
107}
108
109// Print the register name according to the active name converter.
110void Decoder::PrintRegister(int reg) {
111  Print(converter_.NameOfCPURegister(reg));
112}
113
114// Print the double FP register name according to the active name converter.
115void Decoder::PrintDRegister(int reg) {
116  Print(GetRegConfig()->GetDoubleRegisterName(reg));
117}
118
119// Print SoftwareInterrupt codes. Factoring this out reduces the complexity of
120// the FormatOption method.
121void Decoder::PrintSoftwareInterrupt(SoftwareInterruptCodes svc) {
122  switch (svc) {
123    case kCallRtRedirected:
124      Print("call rt redirected");
125      return;
126    case kBreakpoint:
127      Print("breakpoint");
128      return;
129    default:
130      if (svc >= kStopCode) {
131        out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d - 0x%x",
132                                    svc & kStopCodeMask, svc & kStopCodeMask);
133      } else {
134        out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", svc);
135      }
136      return;
137  }
138}
139
140// Handle all register based formatting in this function to reduce the
141// complexity of FormatOption.
142int Decoder::FormatRegister(Instruction* instr, const char* format) {
143  DCHECK(format[0] == 'r');
144
145  if (format[1] == '1') {  // 'r1: register resides in bit 8-11
146    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
147    int reg = rrinstr->R1Value();
148    PrintRegister(reg);
149    return 2;
150  } else if (format[1] == '2') {  // 'r2: register resides in bit 12-15
151    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
152    int reg = rrinstr->R2Value();
153    // indicating it is a r0 for displacement, in which case the offset
154    // should be 0.
155    if (format[2] == 'd') {
156      if (reg == 0) return 4;
157      PrintRegister(reg);
158      return 3;
159    } else {
160      PrintRegister(reg);
161      return 2;
162    }
163  } else if (format[1] == '3') {  // 'r3: register resides in bit 16-19
164    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
165    int reg = rsinstr->B2Value();
166    PrintRegister(reg);
167    return 2;
168  } else if (format[1] == '4') {  // 'r4: register resides in bit 20-23
169    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
170    int reg = rsinstr->B2Value();
171    PrintRegister(reg);
172    return 2;
173  } else if (format[1] == '5') {  // 'r5: register resides in bit 24-28
174    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
175    int reg = rreinstr->R1Value();
176    PrintRegister(reg);
177    return 2;
178  } else if (format[1] == '6') {  // 'r6: register resides in bit 29-32
179    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
180    int reg = rreinstr->R2Value();
181    PrintRegister(reg);
182    return 2;
183  } else if (format[1] == '7') {  // 'r6: register resides in bit 32-35
184    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
185    int reg = ssinstr->B2Value();
186    PrintRegister(reg);
187    return 2;
188  }
189
190  UNREACHABLE();
191  return -1;
192}
193
194int Decoder::FormatFloatingRegister(Instruction* instr, const char* format) {
195  DCHECK(format[0] == 'f');
196
197  // reuse 1, 5 and 6 because it is coresponding
198  if (format[1] == '1') {  // 'r1: register resides in bit 8-11
199    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
200    int reg = rrinstr->R1Value();
201    PrintDRegister(reg);
202    return 2;
203  } else if (format[1] == '2') {  // 'f2: register resides in bit 12-15
204    RRInstruction* rrinstr = reinterpret_cast<RRInstruction*>(instr);
205    int reg = rrinstr->R2Value();
206    PrintDRegister(reg);
207    return 2;
208  } else if (format[1] == '3') {  // 'f3: register resides in bit 16-19
209    RRDInstruction* rrdinstr = reinterpret_cast<RRDInstruction*>(instr);
210    int reg = rrdinstr->R1Value();
211    PrintDRegister(reg);
212    return 2;
213  } else if (format[1] == '5') {  // 'f5: register resides in bit 24-28
214    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
215    int reg = rreinstr->R1Value();
216    PrintDRegister(reg);
217    return 2;
218  } else if (format[1] == '6') {  // 'f6: register resides in bit 29-32
219    RREInstruction* rreinstr = reinterpret_cast<RREInstruction*>(instr);
220    int reg = rreinstr->R2Value();
221    PrintDRegister(reg);
222    return 2;
223  }
224  UNREACHABLE();
225  return -1;
226}
227
228// FormatOption takes a formatting string and interprets it based on
229// the current instructions. The format string points to the first
230// character of the option string (the option escape has already been
231// consumed by the caller.)  FormatOption returns the number of
232// characters that were consumed from the formatting string.
233int Decoder::FormatOption(Instruction* instr, const char* format) {
234  switch (format[0]) {
235    case 'o': {
236      if (instr->Bit(10) == 1) {
237        Print("o");
238      }
239      return 1;
240    }
241    case '.': {
242      if (instr->Bit(0) == 1) {
243        Print(".");
244      } else {
245        Print(" ");  // ensure consistent spacing
246      }
247      return 1;
248    }
249    case 'r': {
250      return FormatRegister(instr, format);
251    }
252    case 'f': {
253      return FormatFloatingRegister(instr, format);
254    }
255    case 'i': {  // int16
256      return FormatImmediate(instr, format);
257    }
258    case 'u': {  // uint16
259      int32_t value = instr->Bits(15, 0);
260      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
261      return 6;
262    }
263    case 'l': {
264      // Link (LK) Bit 0
265      if (instr->Bit(0) == 1) {
266        Print("l");
267      }
268      return 1;
269    }
270    case 'a': {
271      // Absolute Address Bit 1
272      if (instr->Bit(1) == 1) {
273        Print("a");
274      }
275      return 1;
276    }
277    case 't': {  // 'target: target of branch instructions
278      // target26 or target16
279      DCHECK(STRING_STARTS_WITH(format, "target"));
280      if ((format[6] == '2') && (format[7] == '6')) {
281        int off = ((instr->Bits(25, 2)) << 8) >> 6;
282        out_buffer_pos_ += SNPrintF(
283            out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
284            converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
285        return 8;
286      } else if ((format[6] == '1') && (format[7] == '6')) {
287        int off = ((instr->Bits(15, 2)) << 18) >> 16;
288        out_buffer_pos_ += SNPrintF(
289            out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
290            converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
291        return 8;
292      }
293      case 'm': {
294        return FormatMask(instr, format);
295      }
296    }
297    case 'd': {  // ds value for offset
298      return FormatDisplacement(instr, format);
299    }
300    default: {
301      UNREACHABLE();
302      break;
303    }
304  }
305
306  UNREACHABLE();
307  return -1;
308}
309
310int Decoder::FormatMask(Instruction* instr, const char* format) {
311  DCHECK(format[0] == 'm');
312  int32_t value = 0;
313  if ((format[1] == '1')) {  // prints the mask format in bits 8-12
314    value = reinterpret_cast<RRInstruction*>(instr)->R1Value();
315    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
316    return 2;
317  } else if (format[1] == '2') {  // mask format in bits 16-19
318    value = reinterpret_cast<RXInstruction*>(instr)->B2Value();
319    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
320    return 2;
321  } else if (format[1] == '3') {  // mask format in bits 20-23
322    value = reinterpret_cast<RRFInstruction*>(instr)->M4Value();
323    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "0x%x", value);
324    return 2;
325  }
326
327  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
328  return 2;
329}
330
331int Decoder::FormatDisplacement(Instruction* instr, const char* format) {
332  DCHECK(format[0] == 'd');
333
334  if (format[1] == '1') {  // displacement in 20-31
335    RSInstruction* rsinstr = reinterpret_cast<RSInstruction*>(instr);
336    uint16_t value = rsinstr->D2Value();
337    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
338
339    return 2;
340  } else if (format[1] == '2') {  // displacement in 20-39
341    RXYInstruction* rxyinstr = reinterpret_cast<RXYInstruction*>(instr);
342    int32_t value = rxyinstr->D2Value();
343    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
344    return 2;
345  } else if (format[1] == '4') {  // SS displacement 2 36-47
346    SSInstruction* ssInstr = reinterpret_cast<SSInstruction*>(instr);
347    uint16_t value = ssInstr->D2Value();
348    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
349    return 2;
350  } else if (format[1] == '3') {  // SS displacement 1 20 - 32
351    SSInstruction* ssInstr = reinterpret_cast<SSInstruction*>(instr);
352    uint16_t value = ssInstr->D1Value();
353    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
354    return 2;
355  } else {  // s390 specific
356    int32_t value = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
357    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
358    return 1;
359  }
360}
361
362int Decoder::FormatImmediate(Instruction* instr, const char* format) {
363  DCHECK(format[0] == 'i');
364
365  if (format[1] == '1') {  // immediate in 16-31
366    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
367    int16_t value = riinstr->I2Value();
368    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
369    return 2;
370  } else if (format[1] == '2') {  // immediate in 16-48
371    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
372    int32_t value = rilinstr->I2Value();
373    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
374    return 2;
375  } else if (format[1] == '3') {  // immediate in I format
376    IInstruction* iinstr = reinterpret_cast<IInstruction*>(instr);
377    int8_t value = iinstr->IValue();
378    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
379    return 2;
380  } else if (format[1] == '4') {  // immediate in 16-31, but outputs as offset
381    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
382    int16_t value = riinstr->I2Value() * 2;
383    if (value >= 0)
384      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
385    else
386      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");
387
388    out_buffer_pos_ += SNPrintF(
389        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
390        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
391    return 2;
392  } else if (format[1] == '5') {  // immediate in 16-31, but outputs as offset
393    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
394    int32_t value = rilinstr->I2Value() * 2;
395    if (value >= 0)
396      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
397    else
398      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");
399
400    out_buffer_pos_ += SNPrintF(
401        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
402        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
403    return 2;
404  } else if (format[1] == '6') {  // unsigned immediate in 16-31
405    RIInstruction* riinstr = reinterpret_cast<RIInstruction*>(instr);
406    uint16_t value = riinstr->I2UnsignedValue();
407    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
408    return 2;
409  } else if (format[1] == '7') {  // unsigned immediate in 16-47
410    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
411    uint32_t value = rilinstr->I2UnsignedValue();
412    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
413    return 2;
414  } else if (format[1] == '8') {  // unsigned immediate in 8-15
415    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
416    uint8_t value = ssinstr->Length();
417    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
418    return 2;
419  } else if (format[1] == '9') {  // unsigned immediate in 16-23
420    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
421    uint8_t value = rie_instr->I3Value();
422    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
423    return 2;
424  } else if (format[1] == 'a') {  // unsigned immediate in 24-31
425    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
426    uint8_t value = rie_instr->I4Value();
427    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
428    return 2;
429  } else if (format[1] == 'b') {  // unsigned immediate in 32-39
430    RIEInstruction* rie_instr = reinterpret_cast<RIEInstruction*>(instr);
431    uint8_t value = rie_instr->I5Value();
432    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
433    return 2;
434  } else if (format[1] == 'c') {  // signed immediate in 8-15
435    SSInstruction* ssinstr = reinterpret_cast<SSInstruction*>(instr);
436    int8_t value = ssinstr->Length();
437    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
438    return 2;
439  } else if (format[1] == 'd') {  // signed immediate in 32-47
440    SILInstruction* silinstr = reinterpret_cast<SILInstruction*>(instr);
441    int16_t value = silinstr->I2Value();
442    out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
443    return 2;
444  } else if (format[1] == 'e') {  // immediate in 16-47, but outputs as offset
445    RILInstruction* rilinstr = reinterpret_cast<RILInstruction*>(instr);
446    int32_t value = rilinstr->I2Value() * 2;
447    if (value >= 0)
448      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*+");
449    else
450      out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "*");
451
452    out_buffer_pos_ += SNPrintF(
453        out_buffer_ + out_buffer_pos_, "%d -> %s", value,
454        converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + value));
455    return 2;
456  }
457
458  UNREACHABLE();
459  return -1;
460}
461
462// Format takes a formatting string for a whole instruction and prints it into
463// the output buffer. All escaped options are handed to FormatOption to be
464// parsed further.
465void Decoder::Format(Instruction* instr, const char* format) {
466  char cur = *format++;
467  while ((cur != 0) && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
468    if (cur == '\'') {  // Single quote is used as the formatting escape.
469      format += FormatOption(instr, format);
470    } else {
471      out_buffer_[out_buffer_pos_++] = cur;
472    }
473    cur = *format++;
474  }
475  out_buffer_[out_buffer_pos_] = '\0';
476}
477
478// The disassembler may end up decoding data inlined in the code. We do not want
479// it to crash if the data does not ressemble any known instruction.
480#define VERIFY(condition) \
481  if (!(condition)) {     \
482    Unknown(instr);       \
483    return;               \
484  }
485
486// For currently unimplemented decodings the disassembler calls Unknown(instr)
487// which will just print "unknown" of the instruction bits.
488void Decoder::Unknown(Instruction* instr) { Format(instr, "unknown"); }
489
490// For currently unimplemented decodings the disassembler calls
491// UnknownFormat(instr) which will just print opcode name of the
492// instruction bits.
493void Decoder::UnknownFormat(Instruction* instr, const char* name) {
494  char buffer[100];
495  snprintf(buffer, sizeof(buffer), "%s (unknown-format)", name);
496  Format(instr, buffer);
497}
498
499// Disassembles Two Byte S390 Instructions
500// @return true if successfully decoded
501bool Decoder::DecodeTwoByte(Instruction* instr) {
502  // Print the Instruction bits.
503  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%04x           ",
504                              instr->InstructionBits<TwoByteInstr>());
505
506  Opcode opcode = instr->S390OpcodeValue();
507  switch (opcode) {
508    case AR:
509      Format(instr, "ar\t'r1,'r2");
510      break;
511    case SR:
512      Format(instr, "sr\t'r1,'r2");
513      break;
514    case MR:
515      Format(instr, "mr\t'r1,'r2");
516      break;
517    case DR:
518      Format(instr, "dr\t'r1,'r2");
519      break;
520    case OR:
521      Format(instr, "or\t'r1,'r2");
522      break;
523    case NR:
524      Format(instr, "nr\t'r1,'r2");
525      break;
526    case XR:
527      Format(instr, "xr\t'r1,'r2");
528      break;
529    case LR:
530      Format(instr, "lr\t'r1,'r2");
531      break;
532    case CR:
533      Format(instr, "cr\t'r1,'r2");
534      break;
535    case CLR:
536      Format(instr, "clr\t'r1,'r2");
537      break;
538    case BCR:
539      Format(instr, "bcr\t'm1,'r2");
540      break;
541    case LTR:
542      Format(instr, "ltr\t'r1,'r2");
543      break;
544    case ALR:
545      Format(instr, "alr\t'r1,'r2");
546      break;
547    case SLR:
548      Format(instr, "slr\t'r1,'r2");
549      break;
550    case LNR:
551      Format(instr, "lnr\t'r1,'r2");
552      break;
553    case LCR:
554      Format(instr, "lcr\t'r1,'r2");
555      break;
556    case BASR:
557      Format(instr, "basr\t'r1,'r2");
558      break;
559    case LDR:
560      Format(instr, "ldr\t'f1,'f2");
561      break;
562    case BKPT:
563      Format(instr, "bkpt");
564      break;
565    case LPR:
566      Format(instr, "lpr\t'r1, 'r2");
567      break;
568    default:
569      return false;
570  }
571  return true;
572}
573
574// Disassembles Four Byte S390 Instructions
575// @return true if successfully decoded
576bool Decoder::DecodeFourByte(Instruction* instr) {
577  // Print the Instruction bits.
578  out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%08x       ",
579                              instr->InstructionBits<FourByteInstr>());
580
581  Opcode opcode = instr->S390OpcodeValue();
582  switch (opcode) {
583    case AHI:
584      Format(instr, "ahi\t'r1,'i1");
585      break;
586    case AGHI:
587      Format(instr, "aghi\t'r1,'i1");
588      break;
589    case LHI:
590      Format(instr, "lhi\t'r1,'i1");
591      break;
592    case LGHI:
593      Format(instr, "lghi\t'r1,'i1");
594      break;
595    case MHI:
596      Format(instr, "mhi\t'r1,'i1");
597      break;
598    case MGHI:
599      Format(instr, "mghi\t'r1,'i1");
600      break;
601    case CHI:
602      Format(instr, "chi\t'r1,'i1");
603      break;
604    case CGHI:
605      Format(instr, "cghi\t'r1,'i1");
606      break;
607    case BRAS:
608      Format(instr, "bras\t'r1,'i1");
609      break;
610    case BRC:
611      Format(instr, "brc\t'm1,'i4");
612      break;
613    case BRCT:
614      Format(instr, "brct\t'r1,'i4");
615      break;
616    case BRCTG:
617      Format(instr, "brctg\t'r1,'i4");
618      break;
619    case IIHH:
620      Format(instr, "iihh\t'r1,'i1");
621      break;
622    case IIHL:
623      Format(instr, "iihl\t'r1,'i1");
624      break;
625    case IILH:
626      Format(instr, "iilh\t'r1,'i1");
627      break;
628    case IILL:
629      Format(instr, "iill\t'r1,'i1");
630      break;
631    case OILL:
632      Format(instr, "oill\t'r1,'i1");
633      break;
634    case TMLL:
635      Format(instr, "tmll\t'r1,'i1");
636      break;
637    case STM:
638      Format(instr, "stm\t'r1,'r2,'d1('r3)");
639      break;
640    case LM:
641      Format(instr, "lm\t'r1,'r2,'d1('r3)");
642      break;
643    case SLL:
644      Format(instr, "sll\t'r1,'d1('r3)");
645      break;
646    case SRL:
647      Format(instr, "srl\t'r1,'d1('r3)");
648      break;
649    case SLA:
650      Format(instr, "sla\t'r1,'d1('r3)");
651      break;
652    case SRA:
653      Format(instr, "sra\t'r1,'d1('r3)");
654      break;
655    case SLDL:
656      Format(instr, "sldl\t'r1,'d1('r3)");
657      break;
658    case AGR:
659      Format(instr, "agr\t'r5,'r6");
660      break;
661    case AGFR:
662      Format(instr, "agfr\t'r5,'r6");
663      break;
664    case ARK:
665      Format(instr, "ark\t'r5,'r6,'r3");
666      break;
667    case AGRK:
668      Format(instr, "agrk\t'r5,'r6,'r3");
669      break;
670    case SGR:
671      Format(instr, "sgr\t'r5,'r6");
672      break;
673    case SGFR:
674      Format(instr, "sgfr\t'r5,'r6");
675      break;
676    case SRK:
677      Format(instr, "srk\t'r5,'r6,'r3");
678      break;
679    case SGRK:
680      Format(instr, "sgrk\t'r5,'r6,'r3");
681      break;
682    case NGR:
683      Format(instr, "ngr\t'r5,'r6");
684      break;
685    case NRK:
686      Format(instr, "nrk\t'r5,'r6,'r3");
687      break;
688    case NGRK:
689      Format(instr, "ngrk\t'r5,'r6,'r3");
690      break;
691    case NILL:
692      Format(instr, "nill\t'r1,'i1");
693      break;
694    case NILH:
695      Format(instr, "nilh\t'r1,'i1");
696      break;
697    case OGR:
698      Format(instr, "ogr\t'r5,'r6");
699      break;
700    case ORK:
701      Format(instr, "ork\t'r5,'r6,'r3");
702      break;
703    case OGRK:
704      Format(instr, "ogrk\t'r5,'r6,'r3");
705      break;
706    case XGR:
707      Format(instr, "xgr\t'r5,'r6");
708      break;
709    case XRK:
710      Format(instr, "xrk\t'r5,'r6,'r3");
711      break;
712    case XGRK:
713      Format(instr, "xgrk\t'r5,'r6,'r3");
714      break;
715    case CGFR:
716      Format(instr, "cgfr\t'r5,'r6");
717      break;
718    case CGR:
719      Format(instr, "cgr\t'r5,'r6");
720      break;
721    case CLGR:
722      Format(instr, "clgr\t'r5,'r6");
723      break;
724    case LLGFR:
725      Format(instr, "llgfr\t'r5,'r6");
726      break;
727    case POPCNT_Z:
728      Format(instr, "popcnt\t'r5,'r6");
729      break;
730    case LLGCR:
731      Format(instr, "llgcr\t'r5,'r6");
732      break;
733    case LLCR:
734      Format(instr, "llcr\t'r5,'r6");
735      break;
736    case LBR:
737      Format(instr, "lbr\t'r5,'r6");
738      break;
739    case LEDBR:
740      Format(instr, "ledbr\t'f5,'f6");
741      break;
742    case LDEBR:
743      Format(instr, "ldebr\t'f5,'f6");
744      break;
745    case LTGR:
746      Format(instr, "ltgr\t'r5,'r6");
747      break;
748    case LTDBR:
749      Format(instr, "ltdbr\t'f5,'f6");
750      break;
751    case LTEBR:
752      Format(instr, "ltebr\t'f5,'f6");
753      break;
754    case LRVR:
755      Format(instr, "lrvr\t'r5,'r6");
756      break;
757    case LRVGR:
758      Format(instr, "lrvgr\t'r5,'r6");
759      break;
760    case LGR:
761      Format(instr, "lgr\t'r5,'r6");
762      break;
763    case LGDR:
764      Format(instr, "lgdr\t'r5,'f6");
765      break;
766    case LGFR:
767      Format(instr, "lgfr\t'r5,'r6");
768      break;
769    case LTGFR:
770      Format(instr, "ltgfr\t'r5,'r6");
771      break;
772    case LCGR:
773      Format(instr, "lcgr\t'r5,'r6");
774      break;
775    case MSR:
776      Format(instr, "msr\t'r5,'r6");
777      break;
778    case MSRKC:
779      Format(instr, "msrkc\t'r5,'r6,'r3");
780      break;
781    case LGBR:
782      Format(instr, "lgbr\t'r5,'r6");
783      break;
784    case LGHR:
785      Format(instr, "lghr\t'r5,'r6");
786      break;
787    case MSGR:
788      Format(instr, "msgr\t'r5,'r6");
789      break;
790    case MSGRKC:
791      Format(instr, "msgrkc\t'r5,'r6,'r3");
792      break;
793    case DSGR:
794      Format(instr, "dsgr\t'r5,'r6");
795      break;
796    case DSGFR:
797      Format(instr, "dsgfr\t'r5,'r6");
798      break;
799    case MSGFR:
800      Format(instr, "msgfr\t'r5,'r6");
801      break;
802    case LZDR:
803      Format(instr, "lzdr\t'f5");
804      break;
805    case MLR:
806      Format(instr, "mlr\t'r5,'r6");
807      break;
808    case MLGR:
809      Format(instr, "mlgr\t'r5,'r6");
810      break;
811    case ALCR:
812      Format(instr, "alcr\t'r5,'r6");
813      break;
814    case ALGR:
815      Format(instr, "algr\t'r5,'r6");
816      break;
817    case ALRK:
818      Format(instr, "alrk\t'r5,'r6,'r3");
819      break;
820    case ALGRK:
821      Format(instr, "algrk\t'r5,'r6,'r3");
822      break;
823    case SLGR:
824      Format(instr, "slgr\t'r5,'r6");
825      break;
826    case SLBR:
827      Format(instr, "slbr\t'r5,'r6");
828      break;
829    case DLR:
830      Format(instr, "dlr\t'r5,'r6");
831      break;
832    case DLGR:
833      Format(instr, "dlgr\t'r5,'r6");
834      break;
835    case SLRK:
836      Format(instr, "slrk\t'r5,'r6,'r3");
837      break;
838    case SLGRK:
839      Format(instr, "slgrk\t'r5,'r6,'r3");
840      break;
841    case LHR:
842      Format(instr, "lhr\t'r5,'r6");
843      break;
844    case LLHR:
845      Format(instr, "llhr\t'r5,'r6");
846      break;
847    case LLGHR:
848      Format(instr, "llghr\t'r5,'r6");
849      break;
850    case LOCR:
851      Format(instr, "locr\t'm1,'r5,'r6");
852      break;
853    case LOCGR:
854      Format(instr, "locgr\t'm1,'r5,'r6");
855      break;
856    case LNGR:
857      Format(instr, "lngr\t'r5,'r6");
858      break;
859    case A:
860      Format(instr, "a\t'r1,'d1('r2d,'r3)");
861      break;
862    case S:
863      Format(instr, "s\t'r1,'d1('r2d,'r3)");
864      break;
865    case M:
866      Format(instr, "m\t'r1,'d1('r2d,'r3)");
867      break;
868    case D:
869      Format(instr, "d\t'r1,'d1('r2d,'r3)");
870      break;
871    case O:
872      Format(instr, "o\t'r1,'d1('r2d,'r3)");
873      break;
874    case N:
875      Format(instr, "n\t'r1,'d1('r2d,'r3)");
876      break;
877    case L:
878      Format(instr, "l\t'r1,'d1('r2d,'r3)");
879      break;
880    case C:
881      Format(instr, "c\t'r1,'d1('r2d,'r3)");
882      break;
883    case AH:
884      Format(instr, "ah\t'r1,'d1('r2d,'r3)");
885      break;
886    case SH:
887      Format(instr, "sh\t'r1,'d1('r2d,'r3)");
888      break;
889    case MH:
890      Format(instr, "mh\t'r1,'d1('r2d,'r3)");
891      break;
892    case AL:
893      Format(instr, "al\t'r1,'d1('r2d,'r3)");
894      break;
895    case SL:
896      Format(instr, "sl\t'r1,'d1('r2d,'r3)");
897      break;
898    case LA:
899      Format(instr, "la\t'r1,'d1('r2d,'r3)");
900      break;
901    case CH:
902      Format(instr, "ch\t'r1,'d1('r2d,'r3)");
903      break;
904    case CL:
905      Format(instr, "cl\t'r1,'d1('r2d,'r3)");
906      break;
907    case CLI:
908      Format(instr, "cli\t'd1('r3),'i8");
909      break;
910    case TM:
911      Format(instr, "tm\t'd1('r3),'i8");
912      break;
913    case BC:
914      Format(instr, "bc\t'm1,'d1('r2d,'r3)");
915      break;
916    case BCT:
917      Format(instr, "bct\t'r1,'d1('r2d,'r3)");
918      break;
919    case ST:
920      Format(instr, "st\t'r1,'d1('r2d,'r3)");
921      break;
922    case STC:
923      Format(instr, "stc\t'r1,'d1('r2d,'r3)");
924      break;
925    case IC_z:
926      Format(instr, "ic\t'r1,'d1('r2d,'r3)");
927      break;
928    case LD:
929      Format(instr, "ld\t'f1,'d1('r2d,'r3)");
930      break;
931    case LE:
932      Format(instr, "le\t'f1,'d1('r2d,'r3)");
933      break;
934    case LDGR:
935      Format(instr, "ldgr\t'f5,'r6");
936      break;
937    case MS:
938      Format(instr, "ms\t'r1,'d1('r2d,'r3)");
939      break;
940    case STE:
941      Format(instr, "ste\t'f1,'d1('r2d,'r3)");
942      break;
943    case STD:
944      Format(instr, "std\t'f1,'d1('r2d,'r3)");
945      break;
946    case CFDBR:
947      Format(instr, "cfdbr\t'r5,'m2,'f6");
948      break;
949    case CDFBR:
950      Format(instr, "cdfbr\t'f5,'m2,'r6");
951      break;
952    case CFEBR:
953      Format(instr, "cfebr\t'r5,'m2,'f6");
954      break;
955    case CEFBR:
956      Format(instr, "cefbr\t'f5,'m2,'r6");
957      break;
958    case CELFBR:
959      Format(instr, "celfbr\t'f5,'m2,'r6");
960      break;
961    case CGEBR:
962      Format(instr, "cgebr\t'r5,'m2,'f6");
963      break;
964    case CGDBR:
965      Format(instr, "cgdbr\t'r5,'m2,'f6");
966      break;
967    case CEGBR:
968      Format(instr, "cegbr\t'f5,'m2,'r6");
969      break;
970    case CDGBR:
971      Format(instr, "cdgbr\t'f5,'m2,'r6");
972      break;
973    case CDLFBR:
974      Format(instr, "cdlfbr\t'f5,'m2,'r6");
975      break;
976    case CDLGBR:
977      Format(instr, "cdlgbr\t'f5,'m2,'r6");
978      break;
979    case CELGBR:
980      Format(instr, "celgbr\t'f5,'m2,'r6");
981      break;
982    case CLFDBR:
983      Format(instr, "clfdbr\t'r5,'m2,'f6");
984      break;
985    case CLFEBR:
986      Format(instr, "clfebr\t'r5,'m2,'f6");
987      break;
988    case CLGEBR:
989      Format(instr, "clgebr\t'r5,'m2,'f6");
990      break;
991    case CLGDBR:
992      Format(instr, "clgdbr\t'r5,'m2,'f6");
993      break;
994    case AEBR:
995      Format(instr, "aebr\t'f5,'f6");
996      break;
997    case SEBR:
998      Format(instr, "sebr\t'f5,'f6");
999      break;
1000    case MEEBR:
1001      Format(instr, "meebr\t'f5,'f6");
1002      break;
1003    case DEBR:
1004      Format(instr, "debr\t'f5,'f6");
1005      break;
1006    case ADBR:
1007      Format(instr, "adbr\t'f5,'f6");
1008      break;
1009    case SDBR:
1010      Format(instr, "sdbr\t'f5,'f6");
1011      break;
1012    case MDBR:
1013      Format(instr, "mdbr\t'f5,'f6");
1014      break;
1015    case DDBR:
1016      Format(instr, "ddbr\t'f5,'f6");
1017      break;
1018    case CDBR:
1019      Format(instr, "cdbr\t'f5,'f6");
1020      break;
1021    case CEBR:
1022      Format(instr, "cebr\t'f5,'f6");
1023      break;
1024    case SQDBR:
1025      Format(instr, "sqdbr\t'f5,'f6");
1026      break;
1027    case SQEBR:
1028      Format(instr, "sqebr\t'f5,'f6");
1029      break;
1030    case LCDBR:
1031      Format(instr, "lcdbr\t'f5,'f6");
1032      break;
1033    case LCEBR:
1034      Format(instr, "lcebr\t'f5,'f6");
1035      break;
1036    case STH:
1037      Format(instr, "sth\t'r1,'d1('r2d,'r3)");
1038      break;
1039    case SRDA:
1040      Format(instr, "srda\t'r1,'d1('r3)");
1041      break;
1042    case SRDL:
1043      Format(instr, "srdl\t'r1,'d1('r3)");
1044      break;
1045    case MADBR:
1046      Format(instr, "madbr\t'f3,'f5,'f6");
1047      break;
1048    case MSDBR:
1049      Format(instr, "msdbr\t'f3,'f5,'f6");
1050      break;
1051    case FLOGR:
1052      Format(instr, "flogr\t'r5,'r6");
1053      break;
1054    case FIEBRA:
1055      Format(instr, "fiebra\t'f5,'m2,'f6,'m3");
1056      break;
1057    case FIDBRA:
1058      Format(instr, "fidbra\t'f5,'m2,'f6,'m3");
1059      break;
1060    // TRAP4 is used in calling to native function. it will not be generated
1061    // in native code.
1062    case TRAP4: {
1063      Format(instr, "trap4");
1064      break;
1065    }
1066    case LPGR:
1067      Format(instr, "lpgr\t'r1, 'r2");
1068      break;
1069    case LPGFR:
1070      Format(instr, "lpgfr\t'r1,'r2");
1071      break;
1072    default:
1073      return false;
1074  }
1075  return true;
1076}
1077
1078// Disassembles Six Byte S390 Instructions
1079// @return true if successfully decoded
1080bool Decoder::DecodeSixByte(Instruction* instr) {
1081  // Print the Instruction bits.
1082  out_buffer_pos_ +=
1083      SNPrintF(out_buffer_ + out_buffer_pos_, "%012" PRIx64 "   ",
1084               instr->InstructionBits<SixByteInstr>());
1085
1086  Opcode opcode = instr->S390OpcodeValue();
1087  switch (opcode) {
1088    case DUMY:
1089      Format(instr, "dumy\t'r1, 'd2 ( 'r2d, 'r3 )");
1090      break;
1091#define DECODE_VRR_C_INSTRUCTIONS(name, opcode_name, opcode_value) \
1092  case opcode_name:                                                \
1093    Format(instr, #name "\t'f1,'f2,'f3");                          \
1094    break;
1095      S390_VRR_C_OPCODE_LIST(DECODE_VRR_C_INSTRUCTIONS)
1096#undef DECODE_VRR_C_INSTRUCTIONS
1097    case LLILF:
1098      Format(instr, "llilf\t'r1,'i7");
1099      break;
1100    case LLIHF:
1101      Format(instr, "llihf\t'r1,'i7");
1102      break;
1103    case AFI:
1104      Format(instr, "afi\t'r1,'i7");
1105      break;
1106    case AIH:
1107      Format(instr, "aih\t'r1,'i7");
1108      break;
1109    case ASI:
1110      Format(instr, "asi\t'd2('r3),'ic");
1111      break;
1112    case AGSI:
1113      Format(instr, "agsi\t'd2('r3),'ic");
1114      break;
1115    case ALFI:
1116      Format(instr, "alfi\t'r1,'i7");
1117      break;
1118    case AHIK:
1119      Format(instr, "ahik\t'r1,'r2,'i1");
1120      break;
1121    case AGHIK:
1122      Format(instr, "aghik\t'r1,'r2,'i1");
1123      break;
1124    case CLGFI:
1125      Format(instr, "clgfi\t'r1,'i7");
1126      break;
1127    case CLFI:
1128      Format(instr, "clfi\t'r1,'i7");
1129      break;
1130    case CLIH:
1131      Format(instr, "clih\t'r1,'i7");
1132      break;
1133    case CIH:
1134      Format(instr, "cih\t'r1,'i2");
1135      break;
1136    case CFI:
1137      Format(instr, "cfi\t'r1,'i2");
1138      break;
1139    case CGFI:
1140      Format(instr, "cgfi\t'r1,'i2");
1141      break;
1142    case BRASL:
1143      Format(instr, "brasl\t'r1,'ie");
1144      break;
1145    case BRCL:
1146      Format(instr, "brcl\t'm1,'i5");
1147      break;
1148    case IIHF:
1149      Format(instr, "iihf\t'r1,'i7");
1150      break;
1151    case LGFI:
1152      Format(instr, "lgfi\t'r1,'i7");
1153      break;
1154    case IILF:
1155      Format(instr, "iilf\t'r1,'i7");
1156      break;
1157    case XIHF:
1158      Format(instr, "xihf\t'r1,'i7");
1159      break;
1160    case XILF:
1161      Format(instr, "xilf\t'r1,'i7");
1162      break;
1163    case SLLK:
1164      Format(instr, "sllk\t'r1,'r2,'d2('r3)");
1165      break;
1166    case SLLG:
1167      Format(instr, "sllg\t'r1,'r2,'d2('r3)");
1168      break;
1169    case RLL:
1170      Format(instr, "rll\t'r1,'r2,'d2('r3)");
1171      break;
1172    case RLLG:
1173      Format(instr, "rllg\t'r1,'r2,'d2('r3)");
1174      break;
1175    case SRLK:
1176      Format(instr, "srlk\t'r1,'r2,'d2('r3)");
1177      break;
1178    case SRLG:
1179      Format(instr, "srlg\t'r1,'r2,'d2('r3)");
1180      break;
1181    case SLAK:
1182      Format(instr, "slak\t'r1,'r2,'d2('r3)");
1183      break;
1184    case SLAG:
1185      Format(instr, "slag\t'r1,'r2,'d2('r3)");
1186      break;
1187    case SRAK:
1188      Format(instr, "srak\t'r1,'r2,'d2('r3)");
1189      break;
1190    case SRAG:
1191      Format(instr, "srag\t'r1,'r2,'d2('r3)");
1192      break;
1193    case RISBG:
1194      Format(instr, "risbg\t'r1,'r2,'i9,'ia,'ib");
1195      break;
1196    case RISBGN:
1197      Format(instr, "risbgn\t'r1,'r2,'i9,'ia,'ib");
1198      break;
1199    case LOCG:
1200      Format(instr, "locg\t'm2,'r1,'d2('r3)");
1201      break;
1202    case LOC:
1203      Format(instr, "loc\t'm2,'r1,'d2('r3)");
1204      break;
1205    case LMY:
1206      Format(instr, "lmy\t'r1,'r2,'d2('r3)");
1207      break;
1208    case LMG:
1209      Format(instr, "lmg\t'r1,'r2,'d2('r3)");
1210      break;
1211    case STMY:
1212      Format(instr, "stmy\t'r1,'r2,'d2('r3)");
1213      break;
1214    case STMG:
1215      Format(instr, "stmg\t'r1,'r2,'d2('r3)");
1216      break;
1217    case LT:
1218      Format(instr, "lt\t'r1,'d2('r2d,'r3)");
1219      break;
1220    case LTG:
1221      Format(instr, "ltg\t'r1,'d2('r2d,'r3)");
1222      break;
1223    case ML:
1224      Format(instr, "ml\t'r1,'d2('r2d,'r3)");
1225      break;
1226    case AY:
1227      Format(instr, "ay\t'r1,'d2('r2d,'r3)");
1228      break;
1229    case SY:
1230      Format(instr, "sy\t'r1,'d2('r2d,'r3)");
1231      break;
1232    case NY:
1233      Format(instr, "ny\t'r1,'d2('r2d,'r3)");
1234      break;
1235    case OY:
1236      Format(instr, "oy\t'r1,'d2('r2d,'r3)");
1237      break;
1238    case XY:
1239      Format(instr, "xy\t'r1,'d2('r2d,'r3)");
1240      break;
1241    case CY:
1242      Format(instr, "cy\t'r1,'d2('r2d,'r3)");
1243      break;
1244    case AHY:
1245      Format(instr, "ahy\t'r1,'d2('r2d,'r3)");
1246      break;
1247    case SHY:
1248      Format(instr, "shy\t'r1,'d2('r2d,'r3)");
1249      break;
1250    case LGH:
1251      Format(instr, "lgh\t'r1,'d2('r2d,'r3)");
1252      break;
1253    case AG:
1254      Format(instr, "ag\t'r1,'d2('r2d,'r3)");
1255      break;
1256    case AGF:
1257      Format(instr, "agf\t'r1,'d2('r2d,'r3)");
1258      break;
1259    case SG:
1260      Format(instr, "sg\t'r1,'d2('r2d,'r3)");
1261      break;
1262    case NG:
1263      Format(instr, "ng\t'r1,'d2('r2d,'r3)");
1264      break;
1265    case OG:
1266      Format(instr, "og\t'r1,'d2('r2d,'r3)");
1267      break;
1268    case XG:
1269      Format(instr, "xg\t'r1,'d2('r2d,'r3)");
1270      break;
1271    case CG:
1272      Format(instr, "cg\t'r1,'d2('r2d,'r3)");
1273      break;
1274    case LB:
1275      Format(instr, "lb\t'r1,'d2('r2d,'r3)");
1276      break;
1277    case LRVH:
1278      Format(instr, "lrvh\t'r1,'d2('r2d,'r3)");
1279      break;
1280    case LRV:
1281      Format(instr, "lrv\t'r1,'d2('r2d,'r3)");
1282      break;
1283    case LRVG:
1284      Format(instr, "lrvg\t'r1,'d2('r2d,'r3)");
1285      break;
1286    case LG:
1287      Format(instr, "lg\t'r1,'d2('r2d,'r3)");
1288      break;
1289    case LGF:
1290      Format(instr, "lgf\t'r1,'d2('r2d,'r3)");
1291      break;
1292    case LLGF:
1293      Format(instr, "llgf\t'r1,'d2('r2d,'r3)");
1294      break;
1295    case LY:
1296      Format(instr, "ly\t'r1,'d2('r2d,'r3)");
1297      break;
1298    case ALY:
1299      Format(instr, "aly\t'r1,'d2('r2d,'r3)");
1300      break;
1301    case ALG:
1302      Format(instr, "alg\t'r1,'d2('r2d,'r3)");
1303      break;
1304    case SLG:
1305      Format(instr, "slg\t'r1,'d2('r2d,'r3)");
1306      break;
1307    case SGF:
1308      Format(instr, "sgf\t'r1,'d2('r2d,'r3)");
1309      break;
1310    case SLY:
1311      Format(instr, "sly\t'r1,'d2('r2d,'r3)");
1312      break;
1313    case LLH:
1314      Format(instr, "llh\t'r1,'d2('r2d,'r3)");
1315      break;
1316    case LLGH:
1317      Format(instr, "llgh\t'r1,'d2('r2d,'r3)");
1318      break;
1319    case LLC:
1320      Format(instr, "llc\t'r1,'d2('r2d,'r3)");
1321      break;
1322    case LLGC:
1323      Format(instr, "llgc\t'r1,'d2('r2d,'r3)");
1324      break;
1325    case LDEB:
1326      Format(instr, "ldeb\t'f1,'d2('r2d,'r3)");
1327      break;
1328    case LAY:
1329      Format(instr, "lay\t'r1,'d2('r2d,'r3)");
1330      break;
1331    case LARL:
1332      Format(instr, "larl\t'r1,'i5");
1333      break;
1334    case LGB:
1335      Format(instr, "lgb\t'r1,'d2('r2d,'r3)");
1336      break;
1337    case CHY:
1338      Format(instr, "chy\t'r1,'d2('r2d,'r3)");
1339      break;
1340    case CLY:
1341      Format(instr, "cly\t'r1,'d2('r2d,'r3)");
1342      break;
1343    case CLIY:
1344      Format(instr, "cliy\t'd2('r3),'i8");
1345      break;
1346    case TMY:
1347      Format(instr, "tmy\t'd2('r3),'i8");
1348      break;
1349    case CLG:
1350      Format(instr, "clg\t'r1,'d2('r2d,'r3)");
1351      break;
1352    case BCTG:
1353      Format(instr, "bctg\t'r1,'d2('r2d,'r3)");
1354      break;
1355    case STY:
1356      Format(instr, "sty\t'r1,'d2('r2d,'r3)");
1357      break;
1358    case STRVH:
1359      Format(instr, "strvh\t'r1,'d2('r2d,'r3)");
1360      break;
1361    case STRV:
1362      Format(instr, "strv\t'r1,'d2('r2d,'r3)");
1363      break;
1364    case STRVG:
1365      Format(instr, "strvg\t'r1,'d2('r2d,'r3)");
1366      break;
1367    case STG:
1368      Format(instr, "stg\t'r1,'d2('r2d,'r3)");
1369      break;
1370    case ICY:
1371      Format(instr, "icy\t'r1,'d2('r2d,'r3)");
1372      break;
1373    case MVC:
1374      Format(instr, "mvc\t'd3('i8,'r3),'d4('r7)");
1375      break;
1376    case MVHI:
1377      Format(instr, "mvhi\t'd3('r3),'id");
1378      break;
1379    case MVGHI:
1380      Format(instr, "mvghi\t'd3('r3),'id");
1381      break;
1382    case ALGFI:
1383      Format(instr, "algfi\t'r1,'i7");
1384      break;
1385    case SLGFI:
1386      Format(instr, "slgfi\t'r1,'i7");
1387      break;
1388    case SLFI:
1389      Format(instr, "slfi\t'r1,'i7");
1390      break;
1391    case NIHF:
1392      Format(instr, "nihf\t'r1,'i7");
1393      break;
1394    case NILF:
1395      Format(instr, "nilf\t'r1,'i7");
1396      break;
1397    case OIHF:
1398      Format(instr, "oihf\t'r1,'i7");
1399      break;
1400    case OILF:
1401      Format(instr, "oilf\t'r1,'i7");
1402      break;
1403    case MSFI:
1404      Format(instr, "msfi\t'r1,'i7");
1405      break;
1406    case MSGFI:
1407      Format(instr, "msgfi\t'r1,'i7");
1408      break;
1409    case LDY:
1410      Format(instr, "ldy\t'f1,'d2('r2d,'r3)");
1411      break;
1412    case LEY:
1413      Format(instr, "ley\t'f1,'d2('r2d,'r3)");
1414      break;
1415    case MSG:
1416      Format(instr, "msg\t'r1,'d2('r2d,'r3)");
1417      break;
1418    case DSG:
1419      Format(instr, "dsg\t'r1,'d2('r2d,'r3)");
1420      break;
1421    case DSGF:
1422      Format(instr, "dsgf\t'r1,'d2('r2d,'r3)");
1423      break;
1424    case MSGF:
1425      Format(instr, "msgf\t'r1,'d2('r2d,'r3)");
1426      break;
1427    case MSY:
1428      Format(instr, "msy\t'r1,'d2('r2d,'r3)");
1429      break;
1430    case STEY:
1431      Format(instr, "stey\t'f1,'d2('r2d,'r3)");
1432      break;
1433    case STDY:
1434      Format(instr, "stdy\t'f1,'d2('r2d,'r3)");
1435      break;
1436    case ADB:
1437      Format(instr, "adb\t'f1,'d1('r2d, 'r3)");
1438      break;
1439    case CDB:
1440      Format(instr, "cdb\t'f1,'d1('r2d, 'r3)");
1441      break;
1442    case CEB:
1443      Format(instr, "ceb\t'f1,'d1('r2d, 'r3)");
1444      break;
1445    case SDB:
1446      Format(instr, "sdb\t'r1,'d1('r2d, 'r3)");
1447      break;
1448    case MDB:
1449      Format(instr, "mdb\t'r1,'d1('r2d, 'r3)");
1450      break;
1451    case DDB:
1452      Format(instr, "ddb\t'r1,'d1('r2d, 'r3)");
1453      break;
1454    case SQDB:
1455      Format(instr, "sqdb\t'r1,'d1('r2d, 'r3)");
1456      break;
1457    case PFD:
1458      Format(instr, "pfd\t'm1,'d2('r2d,'r3)");
1459      break;
1460    default:
1461      return false;
1462  }
1463  return true;
1464}
1465
1466#undef VERIFIY
1467
1468// Disassemble the instruction at *instr_ptr into the output buffer.
1469int Decoder::InstructionDecode(byte* instr_ptr) {
1470  Instruction* instr = Instruction::At(instr_ptr);
1471  int instrLength = instr->InstructionLength();
1472
1473  if (2 == instrLength)
1474    DecodeTwoByte(instr);
1475  else if (4 == instrLength)
1476    DecodeFourByte(instr);
1477  else
1478    DecodeSixByte(instr);
1479
1480  return instrLength;
1481}
1482
1483}  // namespace internal
1484}  // namespace v8
1485
1486//------------------------------------------------------------------------------
1487
1488namespace disasm {
1489
1490const char* NameConverter::NameOfAddress(byte* addr) const {
1491  v8::internal::SNPrintF(tmp_buffer_, "%p", static_cast<void*>(addr));
1492  return tmp_buffer_.start();
1493}
1494
1495const char* NameConverter::NameOfConstant(byte* addr) const {
1496  return NameOfAddress(addr);
1497}
1498
1499const char* NameConverter::NameOfCPURegister(int reg) const {
1500  return v8::internal::GetRegConfig()->GetGeneralRegisterName(reg);
1501}
1502
1503const char* NameConverter::NameOfByteCPURegister(int reg) const {
1504  UNREACHABLE();  // S390 does not have the concept of a byte register
1505  return "nobytereg";
1506}
1507
1508const char* NameConverter::NameOfXMMRegister(int reg) const {
1509  // S390 does not have XMM register
1510  // TODO(joransiu): Consider update this for Vector Regs
1511  UNREACHABLE();
1512  return "noxmmreg";
1513}
1514
1515const char* NameConverter::NameInCode(byte* addr) const {
1516  // The default name converter is called for unknown code. So we will not try
1517  // to access any memory.
1518  return "";
1519}
1520
1521//------------------------------------------------------------------------------
1522
1523Disassembler::Disassembler(const NameConverter& converter)
1524    : converter_(converter) {}
1525
1526Disassembler::~Disassembler() {}
1527
1528int Disassembler::InstructionDecode(v8::internal::Vector<char> buffer,
1529                                    byte* instruction) {
1530  v8::internal::Decoder d(converter_, buffer);
1531  return d.InstructionDecode(instruction);
1532}
1533
1534// The S390 assembler does not currently use constant pools.
1535int Disassembler::ConstantPoolSizeAt(byte* instruction) { return -1; }
1536
1537void Disassembler::Disassemble(FILE* f, byte* begin, byte* end) {
1538  NameConverter converter;
1539  Disassembler d(converter);
1540  for (byte* pc = begin; pc < end;) {
1541    v8::internal::EmbeddedVector<char, 128> buffer;
1542    buffer[0] = '\0';
1543    byte* prev_pc = pc;
1544    pc += d.InstructionDecode(buffer, pc);
1545    v8::internal::PrintF(f, "%p    %08x      %s\n", static_cast<void*>(prev_pc),
1546                         *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
1547  }
1548}
1549
1550}  // namespace disasm
1551
1552#endif  // V8_TARGET_ARCH_S390
1553