lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp

   1 //===-- SystemZDisassembler.cpp - Disassembler for SystemZ ------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "SystemZ.h"
  11 #include "llvm/MC/MCDisassembler.h"
  12 #include "llvm/MC/MCFixedLenDisassembler.h"
  13 #include "llvm/MC/MCInst.h"
  14 #include "llvm/MC/MCSubtargetInfo.h"
  15 #include "llvm/Support/TargetRegistry.h"
  16
  17 using namespace llvm;
  18
  19 #define DEBUG_TYPE "systemz-disassembler"
  20
  21 typedef MCDisassembler::DecodeStatus DecodeStatus;
  22
  23 namespace {
  24 class SystemZDisassembler : public MCDisassembler {
  25 public:
  26   SystemZDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
  27     : MCDisassembler(STI, Ctx) {}
  28   ~SystemZDisassembler() override {}
  29
  30   DecodeStatus getInstruction(MCInst &instr, uint64_t &Size,
  31                               ArrayRef<uint8_t> Bytes, uint64_t Address,
  32                               raw_ostream &VStream,
  33                               raw_ostream &CStream) const override;
  34 };
  35 } // end anonymous namespace
  36
  37 static MCDisassembler *createSystemZDisassembler(const Target &T,
  38                                                  const MCSubtargetInfo &STI,
  39                                                  MCContext &Ctx) {
  40   return new SystemZDisassembler(STI, Ctx);
  41 }
  42
  43 extern "C" void LLVMInitializeSystemZDisassembler() {
  44   // Register the disassembler.
  45   TargetRegistry::RegisterMCDisassembler(TheSystemZTarget,
  46                                          createSystemZDisassembler);
  47 }
  48
  49 static DecodeStatus decodeRegisterClass(MCInst &Inst, uint64_t RegNo,
  50                                         const unsigned *Regs, unsigned Size) {
  51   assert(RegNo < Size && "Invalid register");
  52   RegNo = Regs[RegNo];
  53   if (RegNo == 0)
  54     return MCDisassembler::Fail;
  55   Inst.addOperand(MCOperand::createReg(RegNo));
  56   return MCDisassembler::Success;
  57 }
  58
  59 static DecodeStatus DecodeGR32BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  60                                                uint64_t Address,
  61                                                const void *Decoder) {
  62   return decodeRegisterClass(Inst, RegNo, SystemZMC::GR32Regs, 16);
  63 }
  64
  65 static DecodeStatus DecodeGRH32BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  66                                                 uint64_t Address,
  67                                                 const void *Decoder) {
  68   return decodeRegisterClass(Inst, RegNo, SystemZMC::GRH32Regs, 16);
  69 }
  70
  71 static DecodeStatus DecodeGR64BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  72                                                uint64_t Address,
  73                                                const void *Decoder) {
  74   return decodeRegisterClass(Inst, RegNo, SystemZMC::GR64Regs, 16);
  75 }
  76
  77 static DecodeStatus DecodeGR128BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  78                                                 uint64_t Address,
  79                                                 const void *Decoder) {
  80   return decodeRegisterClass(Inst, RegNo, SystemZMC::GR128Regs, 16);
  81 }
  82
  83 static DecodeStatus DecodeADDR64BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  84                                                  uint64_t Address,
  85                                                  const void *Decoder) {
  86   return decodeRegisterClass(Inst, RegNo, SystemZMC::GR64Regs, 16);
  87 }
  88
  89 static DecodeStatus DecodeFP32BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  90                                                uint64_t Address,
  91                                                const void *Decoder) {
  92   return decodeRegisterClass(Inst, RegNo, SystemZMC::FP32Regs, 16);
  93 }
  94
  95 static DecodeStatus DecodeFP64BitRegisterClass(MCInst &Inst, uint64_t RegNo,
  96                                                uint64_t Address,
  97                                                const void *Decoder) {
  98   return decodeRegisterClass(Inst, RegNo, SystemZMC::FP64Regs, 16);
  99 }
 100
 101 static DecodeStatus DecodeFP128BitRegisterClass(MCInst &Inst, uint64_t RegNo,
 102                                                 uint64_t Address,
 103                                                 const void *Decoder) {
 104   return decodeRegisterClass(Inst, RegNo, SystemZMC::FP128Regs, 16);
 105 }
 106
 107 static DecodeStatus DecodeVR32BitRegisterClass(MCInst &Inst, uint64_t RegNo,
 108                                                uint64_t Address,
 109                                                const void *Decoder) {
 110   return decodeRegisterClass(Inst, RegNo, SystemZMC::VR32Regs, 32);
 111 }
 112
 113 static DecodeStatus DecodeVR64BitRegisterClass(MCInst &Inst, uint64_t RegNo,
 114                                                uint64_t Address,
 115                                                const void *Decoder) {
 116   return decodeRegisterClass(Inst, RegNo, SystemZMC::VR64Regs, 32);
 117 }
 118
 119 static DecodeStatus DecodeVR128BitRegisterClass(MCInst &Inst, uint64_t RegNo,
 120                                                 uint64_t Address,
 121                                                 const void *Decoder) {
 122   return decodeRegisterClass(Inst, RegNo, SystemZMC::VR128Regs, 32);
 123 }
 124
 125 template<unsigned N>
 126 static DecodeStatus decodeUImmOperand(MCInst &Inst, uint64_t Imm) {
 127   if (!isUInt<N>(Imm))
 128     return MCDisassembler::Fail;
 129   Inst.addOperand(MCOperand::createImm(Imm));
 130   return MCDisassembler::Success;
 131 }
 132
 133 template<unsigned N>
 134 static DecodeStatus decodeSImmOperand(MCInst &Inst, uint64_t Imm) {
 135   if (!isUInt<N>(Imm))
 136     return MCDisassembler::Fail;
 137   Inst.addOperand(MCOperand::createImm(SignExtend64<N>(Imm)));
 138   return MCDisassembler::Success;
 139 }
 140
 141 static DecodeStatus decodeAccessRegOperand(MCInst &Inst, uint64_t Imm,
 142                                            uint64_t Address,
 143                                            const void *Decoder) {
 144   return decodeUImmOperand<4>(Inst, Imm);
 145 }
 146
 147 static DecodeStatus decodeU1ImmOperand(MCInst &Inst, uint64_t Imm,
 148                                        uint64_t Address, const void *Decoder) {
 149   return decodeUImmOperand<1>(Inst, Imm);
 150 }
 151
 152 static DecodeStatus decodeU2ImmOperand(MCInst &Inst, uint64_t Imm,
 153                                        uint64_t Address, const void *Decoder) {
 154   return decodeUImmOperand<2>(Inst, Imm);
 155 }
 156
 157 static DecodeStatus decodeU3ImmOperand(MCInst &Inst, uint64_t Imm,
 158                                        uint64_t Address, const void *Decoder) {
 159   return decodeUImmOperand<3>(Inst, Imm);
 160 }
 161
 162 static DecodeStatus decodeU4ImmOperand(MCInst &Inst, uint64_t Imm,
 163                                        uint64_t Address, const void *Decoder) {
 164   return decodeUImmOperand<4>(Inst, Imm);
 165 }
 166
 167 static DecodeStatus decodeU6ImmOperand(MCInst &Inst, uint64_t Imm,
 168                                        uint64_t Address, const void *Decoder) {
 169   return decodeUImmOperand<6>(Inst, Imm);
 170 }
 171
 172 static DecodeStatus decodeU8ImmOperand(MCInst &Inst, uint64_t Imm,
 173                                        uint64_t Address, const void *Decoder) {
 174   return decodeUImmOperand<8>(Inst, Imm);
 175 }
 176
 177 static DecodeStatus decodeU12ImmOperand(MCInst &Inst, uint64_t Imm,
 178                                         uint64_t Address, const void *Decoder) {
 179   return decodeUImmOperand<12>(Inst, Imm);
 180 }
 181
 182 static DecodeStatus decodeU16ImmOperand(MCInst &Inst, uint64_t Imm,
 183                                         uint64_t Address, const void *Decoder) {
 184   return decodeUImmOperand<16>(Inst, Imm);
 185 }
 186
 187 static DecodeStatus decodeU32ImmOperand(MCInst &Inst, uint64_t Imm,
 188                                         uint64_t Address, const void *Decoder) {
 189   return decodeUImmOperand<32>(Inst, Imm);
 190 }
 191
 192 static DecodeStatus decodeS8ImmOperand(MCInst &Inst, uint64_t Imm,
 193                                        uint64_t Address, const void *Decoder) {
 194   return decodeSImmOperand<8>(Inst, Imm);
 195 }
 196
 197 static DecodeStatus decodeS16ImmOperand(MCInst &Inst, uint64_t Imm,
 198                                         uint64_t Address, const void *Decoder) {
 199   return decodeSImmOperand<16>(Inst, Imm);
 200 }
 201
 202 static DecodeStatus decodeS32ImmOperand(MCInst &Inst, uint64_t Imm,
 203                                         uint64_t Address, const void *Decoder) {
 204   return decodeSImmOperand<32>(Inst, Imm);
 205 }
 206
 207 template<unsigned N>
 208 static DecodeStatus decodePCDBLOperand(MCInst &Inst, uint64_t Imm,
 209                                        uint64_t Address) {
 210   assert(isUInt<N>(Imm) && "Invalid PC-relative offset");
 211   Inst.addOperand(MCOperand::createImm(SignExtend64<N>(Imm) * 2 + Address));
 212   return MCDisassembler::Success;
 213 }
 214
 215 static DecodeStatus decodePC16DBLOperand(MCInst &Inst, uint64_t Imm,
 216                                          uint64_t Address,
 217                                          const void *Decoder) {
 218   return decodePCDBLOperand<16>(Inst, Imm, Address);
 219 }
 220
 221 static DecodeStatus decodePC32DBLOperand(MCInst &Inst, uint64_t Imm,
 222                                          uint64_t Address,
 223                                          const void *Decoder) {
 224   return decodePCDBLOperand<32>(Inst, Imm, Address);
 225 }
 226
 227 static DecodeStatus decodeBDAddr12Operand(MCInst &Inst, uint64_t Field,
 228                                           const unsigned *Regs) {
 229   uint64_t Base = Field >> 12;
 230   uint64_t Disp = Field & 0xfff;
 231   assert(Base < 16 && "Invalid BDAddr12");
 232   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 233   Inst.addOperand(MCOperand::createImm(Disp));
 234   return MCDisassembler::Success;
 235 }
 236
 237 static DecodeStatus decodeBDAddr20Operand(MCInst &Inst, uint64_t Field,
 238                                           const unsigned *Regs) {
 239   uint64_t Base = Field >> 20;
 240   uint64_t Disp = ((Field << 12) & 0xff000) | ((Field >> 8) & 0xfff);
 241   assert(Base < 16 && "Invalid BDAddr20");
 242   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 243   Inst.addOperand(MCOperand::createImm(SignExtend64<20>(Disp)));
 244   return MCDisassembler::Success;
 245 }
 246
 247 static DecodeStatus decodeBDXAddr12Operand(MCInst &Inst, uint64_t Field,
 248                                            const unsigned *Regs) {
 249   uint64_t Index = Field >> 16;
 250   uint64_t Base = (Field >> 12) & 0xf;
 251   uint64_t Disp = Field & 0xfff;
 252   assert(Index < 16 && "Invalid BDXAddr12");
 253   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 254   Inst.addOperand(MCOperand::createImm(Disp));
 255   Inst.addOperand(MCOperand::createReg(Index == 0 ? 0 : Regs[Index]));
 256   return MCDisassembler::Success;
 257 }
 258
 259 static DecodeStatus decodeBDXAddr20Operand(MCInst &Inst, uint64_t Field,
 260                                            const unsigned *Regs) {
 261   uint64_t Index = Field >> 24;
 262   uint64_t Base = (Field >> 20) & 0xf;
 263   uint64_t Disp = ((Field & 0xfff00) >> 8) | ((Field & 0xff) << 12);
 264   assert(Index < 16 && "Invalid BDXAddr20");
 265   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 266   Inst.addOperand(MCOperand::createImm(SignExtend64<20>(Disp)));
 267   Inst.addOperand(MCOperand::createReg(Index == 0 ? 0 : Regs[Index]));
 268   return MCDisassembler::Success;
 269 }
 270
 271 static DecodeStatus decodeBDLAddr12Len8Operand(MCInst &Inst, uint64_t Field,
 272                                                const unsigned *Regs) {
 273   uint64_t Length = Field >> 16;
 274   uint64_t Base = (Field >> 12) & 0xf;
 275   uint64_t Disp = Field & 0xfff;
 276   assert(Length < 256 && "Invalid BDLAddr12Len8");
 277   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 278   Inst.addOperand(MCOperand::createImm(Disp));
 279   Inst.addOperand(MCOperand::createImm(Length + 1));
 280   return MCDisassembler::Success;
 281 }
 282
 283 static DecodeStatus decodeBDVAddr12Operand(MCInst &Inst, uint64_t Field,
 284                                            const unsigned *Regs) {
 285   uint64_t Index = Field >> 16;
 286   uint64_t Base = (Field >> 12) & 0xf;
 287   uint64_t Disp = Field & 0xfff;
 288   assert(Index < 32 && "Invalid BDVAddr12");
 289   Inst.addOperand(MCOperand::createReg(Base == 0 ? 0 : Regs[Base]));
 290   Inst.addOperand(MCOperand::createImm(Disp));
 291   Inst.addOperand(MCOperand::createReg(SystemZMC::VR128Regs[Index]));
 292   return MCDisassembler::Success;
 293 }
 294
 295 static DecodeStatus decodeBDAddr32Disp12Operand(MCInst &Inst, uint64_t Field,
 296                                                 uint64_t Address,
 297                                                 const void *Decoder) {
 298   return decodeBDAddr12Operand(Inst, Field, SystemZMC::GR32Regs);
 299 }
 300
 301 static DecodeStatus decodeBDAddr32Disp20Operand(MCInst &Inst, uint64_t Field,
 302                                                 uint64_t Address,
 303                                                 const void *Decoder) {
 304   return decodeBDAddr20Operand(Inst, Field, SystemZMC::GR32Regs);
 305 }
 306
 307 static DecodeStatus decodeBDAddr64Disp12Operand(MCInst &Inst, uint64_t Field,
 308                                                 uint64_t Address,
 309                                                 const void *Decoder) {
 310   return decodeBDAddr12Operand(Inst, Field, SystemZMC::GR64Regs);
 311 }
 312
 313 static DecodeStatus decodeBDAddr64Disp20Operand(MCInst &Inst, uint64_t Field,
 314                                                 uint64_t Address,
 315                                                 const void *Decoder) {
 316   return decodeBDAddr20Operand(Inst, Field, SystemZMC::GR64Regs);
 317 }
 318
 319 static DecodeStatus decodeBDXAddr64Disp12Operand(MCInst &Inst, uint64_t Field,
 320                                                  uint64_t Address,
 321                                                  const void *Decoder) {
 322   return decodeBDXAddr12Operand(Inst, Field, SystemZMC::GR64Regs);
 323 }
 324
 325 static DecodeStatus decodeBDXAddr64Disp20Operand(MCInst &Inst, uint64_t Field,
 326                                                  uint64_t Address,
 327                                                  const void *Decoder) {
 328   return decodeBDXAddr20Operand(Inst, Field, SystemZMC::GR64Regs);
 329 }
 330
 331 static DecodeStatus decodeBDLAddr64Disp12Len8Operand(MCInst &Inst,
 332                                                      uint64_t Field,
 333                                                      uint64_t Address,
 334                                                      const void *Decoder) {
 335   return decodeBDLAddr12Len8Operand(Inst, Field, SystemZMC::GR64Regs);
 336 }
 337
 338 static DecodeStatus decodeBDVAddr64Disp12Operand(MCInst &Inst, uint64_t Field,
 339                                                  uint64_t Address,
 340                                                  const void *Decoder) {
 341   return decodeBDVAddr12Operand(Inst, Field, SystemZMC::GR64Regs);
 342 }
 343
 344 #include "SystemZGenDisassemblerTables.inc"
 345
 346 DecodeStatus SystemZDisassembler::getInstruction(MCInst &MI, uint64_t &Size,
 347                                                  ArrayRef<uint8_t> Bytes,
 348                                                  uint64_t Address,
 349                                                  raw_ostream &OS,
 350                                                  raw_ostream &CS) const {
 351   // Get the first two bytes of the instruction.
 352   Size = 0;
 353   if (Bytes.size() < 2)
 354     return MCDisassembler::Fail;
 355
 356   // The top 2 bits of the first byte specify the size.
 357   const uint8_t *Table;
 358   if (Bytes[0] < 0x40) {
 359     Size = 2;
 360     Table = DecoderTable16;
 361   } else if (Bytes[0] < 0xc0) {
 362     Size = 4;
 363     Table = DecoderTable32;
 364   } else {
 365     Size = 6;
 366     Table = DecoderTable48;
 367   }
 368
 369   // Read any remaining bytes.
 370   if (Bytes.size() < Size)
 371     return MCDisassembler::Fail;
 372
 373   // Construct the instruction.
 374   uint64_t Inst = 0;
 375   for (uint64_t I = 0; I < Size; ++I)
 376     Inst = (Inst << 8) | Bytes[I];
 377
 378   return decodeInstruction(Table, MI, Inst, Address, this, STI);
 379 }