lib/Target/SystemZ/SystemZMCInstLower.cpp

   1 //===-- SystemZMCInstLower.cpp - Lower MachineInstr to MCInst -------------===//
   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 "SystemZMCInstLower.h"
  11 #include "SystemZAsmPrinter.h"
  12 #include "llvm/MC/MCExpr.h"
  13 #include "llvm/MC/MCStreamer.h"
  14 #include "llvm/Target/Mangler.h"
  15
  16 using namespace llvm;
  17
  18 // If Opcode is an interprocedural reference that can be shortened,
  19 // return the short form, otherwise return 0.
  20 static unsigned getShortenedInstr(unsigned Opcode) {
  21   switch (Opcode) {
  22   case SystemZ::BRASL: return SystemZ::BRAS;
  23   }
  24   return Opcode;
  25 }
  26
  27 // Return the VK_* enumeration for MachineOperand target flags Flags.
  28 static MCSymbolRefExpr::VariantKind getVariantKind(unsigned Flags) {
  29   switch (Flags & SystemZII::MO_SYMBOL_MODIFIER) {
  30     case 0:
  31       return MCSymbolRefExpr::VK_None;
  32     case SystemZII::MO_GOT:
  33       return MCSymbolRefExpr::VK_GOT;
  34   }
  35   llvm_unreachable("Unrecognised MO_ACCESS_MODEL");
  36 }
  37
  38 SystemZMCInstLower::SystemZMCInstLower(Mangler *mang, MCContext &ctx,
  39                                        SystemZAsmPrinter &asmprinter)
  40   : Mang(mang), Ctx(ctx), AsmPrinter(asmprinter) {}
  41
  42 MCOperand SystemZMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
  43                                                  const MCSymbol *Symbol,
  44                                                  int64_t Offset) const {
  45   MCSymbolRefExpr::VariantKind Kind = getVariantKind(MO.getTargetFlags());
  46   const MCExpr *Expr = MCSymbolRefExpr::Create(Symbol, Kind, Ctx);
  47   if (Offset) {
  48     const MCExpr *OffsetExpr = MCConstantExpr::Create(Offset, Ctx);
  49     Expr = MCBinaryExpr::CreateAdd(Expr, OffsetExpr, Ctx);
  50   }
  51   return MCOperand::CreateExpr(Expr);
  52 }
  53
  54 MCOperand SystemZMCInstLower::lowerOperand(const MachineOperand &MO) const {
  55   switch (MO.getType()) {
  56   default:
  57     llvm_unreachable("unknown operand type");
  58
  59   case MachineOperand::MO_Register:
  60     // Ignore all implicit register operands.
  61     if (MO.isImplicit())
  62       return MCOperand();
  63     return MCOperand::CreateReg(MO.getReg());
  64
  65   case MachineOperand::MO_Immediate:
  66     return MCOperand::CreateImm(MO.getImm());
  67
  68   case MachineOperand::MO_MachineBasicBlock:
  69     return lowerSymbolOperand(MO, MO.getMBB()->getSymbol(),
  70                               /* MO has no offset field */0);
  71
  72   case MachineOperand::MO_GlobalAddress:
  73     return lowerSymbolOperand(MO, Mang->getSymbol(MO.getGlobal()),
  74                               MO.getOffset());
  75
  76   case MachineOperand::MO_ExternalSymbol: {
  77     StringRef Name = MO.getSymbolName();
  78     return lowerSymbolOperand(MO, AsmPrinter.GetExternalSymbolSymbol(Name),
  79                               MO.getOffset());
  80   }
  81
  82   case MachineOperand::MO_JumpTableIndex:
  83     return lowerSymbolOperand(MO, AsmPrinter.GetJTISymbol(MO.getIndex()),
  84                               /* MO has no offset field */0);
  85
  86   case MachineOperand::MO_ConstantPoolIndex:
  87     return lowerSymbolOperand(MO, AsmPrinter.GetCPISymbol(MO.getIndex()),
  88                               MO.getOffset());
  89
  90   case MachineOperand::MO_BlockAddress: {
  91     const BlockAddress *BA = MO.getBlockAddress();
  92     return lowerSymbolOperand(MO, AsmPrinter.GetBlockAddressSymbol(BA),
  93                               MO.getOffset());
  94   }
  95   }
  96 }
  97
  98 void SystemZMCInstLower::lower(const MachineInstr *MI, MCInst &OutMI) const {
  99   unsigned Opcode = MI->getOpcode();
 100   // When emitting binary code, start with the shortest form of an instruction
 101   // and then relax it where necessary.
 102   if (!AsmPrinter.OutStreamer.hasRawTextSupport())
 103     Opcode = getShortenedInstr(Opcode);
 104   OutMI.setOpcode(Opcode);
 105   for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
 106     const MachineOperand &MO = MI->getOperand(I);
 107     MCOperand MCOp = lowerOperand(MO);
 108     if (MCOp.isValid())
 109       OutMI.addOperand(MCOp);
 110   }
 111 }