lib/Target/ARM/ARMMCInstLower.cpp

   1 //===-- ARMMCInstLower.cpp - Convert ARM MachineInstr to an 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 // This file contains code to lower ARM MachineInstrs to their corresponding
  11 // MCInst records.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "ARM.h"
  16 #include "ARMMCInstLower.h"
  17 #include "llvm/CodeGen/AsmPrinter.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/CodeGen/MachineBasicBlock.h"
  20 #include "llvm/MC/MCAsmInfo.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCInst.h"
  24 #include "llvm/Target/Mangler.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "llvm/ADT/SmallString.h"
  27 using namespace llvm;
  28
  29 MCSymbol *ARMMCInstLower::GetGlobalAddressSymbol(const GlobalValue *GV) const {
  30   return Printer.Mang->getSymbol(GV);
  31 }
  32
  33 const MCSymbolRefExpr *ARMMCInstLower::
  34 GetSymbolRef(const MachineOperand &MO) const {
  35   assert(MO.isGlobal() && "Isn't a global address reference?");
  36   // FIXME: HANDLE PLT references how??
  37
  38   const MCSymbolRefExpr *SymRef;
  39   const MCSymbol *Symbol = GetGlobalAddressSymbol(MO.getGlobal());
  40
  41   switch (MO.getTargetFlags()) {
  42   default: assert(0 && "Unknown target flag on GV operand");
  43   case 0:
  44     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_None, Ctx);
  45     break;
  46   case ARMII::MO_LO16:
  47     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_LO16, Ctx);
  48     break;
  49   case ARMII::MO_HI16:
  50     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_HI16, Ctx);
  51     break;
  52   }
  53
  54   return SymRef;
  55 }
  56
  57 MCSymbol *ARMMCInstLower::
  58 GetExternalSymbolSymbol(const MachineOperand &MO) const {
  59   // FIXME: HANDLE PLT references how??
  60   // FIXME: This probably needs to be merged with the above SymbolRef stuff
  61   // to handle :lower16: and :upper16: (?)
  62   switch (MO.getTargetFlags()) {
  63   default: assert(0 && "Unknown target flag on GV operand");
  64   case 0: break;
  65   }
  66
  67   return Printer.GetExternalSymbolSymbol(MO.getSymbolName());
  68 }
  69
  70
  71
  72 MCSymbol *ARMMCInstLower::
  73 GetJumpTableSymbol(const MachineOperand &MO) const {
  74   SmallString<256> Name;
  75   raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "JTI"
  76     << Printer.getFunctionNumber() << '_' << MO.getIndex();
  77
  78   switch (MO.getTargetFlags()) {
  79   default: assert(0 && "Unknown target flag on jump table operand");
  80   case 0: break;
  81   }
  82
  83   // Create a symbol for the name.
  84   return Ctx.GetOrCreateSymbol(Name.str());
  85 }
  86
  87 MCSymbol *ARMMCInstLower::
  88 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
  89   SmallString<256> Name;
  90   raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "CPI"
  91     << Printer.getFunctionNumber() << '_' << MO.getIndex();
  92
  93   switch (MO.getTargetFlags()) {
  94   default: assert(0 && "Unknown target flag on CPI operand");
  95   case 0: break;
  96   }
  97
  98   // Create a symbol for the name.
  99   return Ctx.GetOrCreateSymbol(Name.str());
 100 }
 101
 102 MCOperand ARMMCInstLower::
 103 LowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const {
 104   // FIXME: We would like an efficient form for this, so we don't have to do a
 105   // lot of extra uniquing.
 106   const MCExpr *Expr = MCSymbolRefExpr::Create(Sym, Ctx);
 107
 108   switch (MO.getTargetFlags()) {
 109   default: assert(0 && "Unknown target flag on Symbol operand");
 110   case 0: break;
 111   }
 112
 113   if (!MO.isJTI() && MO.getOffset())
 114     Expr = MCBinaryExpr::CreateAdd(Expr,
 115                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 116                                    Ctx);
 117   return MCOperand::CreateExpr(Expr);
 118 }
 119
 120 MCOperand ARMMCInstLower::
 121 LowerSymbolRefOperand(const MachineOperand &MO,
 122                       const MCSymbolRefExpr *Sym) const {
 123   const MCExpr *Expr = Sym;
 124   if (!MO.isJTI() && MO.getOffset())
 125     Expr = MCBinaryExpr::CreateAdd(Expr,
 126                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 127                                    Ctx);
 128   return MCOperand::CreateExpr(Expr);
 129 }
 130
 131
 132 void ARMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 133   OutMI.setOpcode(MI->getOpcode());
 134
 135   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 136     const MachineOperand &MO = MI->getOperand(i);
 137
 138     MCOperand MCOp;
 139     switch (MO.getType()) {
 140     default:
 141       MI->dump();
 142       assert(0 && "unknown operand type");
 143     case MachineOperand::MO_Register:
 144       // Ignore all non-CPSR implicit register operands.
 145       if (MO.isImplicit() && MO.getReg() != ARM::CPSR) continue;
 146       assert(!MO.getSubReg() && "Subregs should be eliminated!");
 147       MCOp = MCOperand::CreateReg(MO.getReg());
 148       break;
 149     case MachineOperand::MO_Immediate:
 150       MCOp = MCOperand::CreateImm(MO.getImm());
 151       break;
 152     case MachineOperand::MO_MachineBasicBlock:
 153       MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 154                        MO.getMBB()->getSymbol(), Ctx));
 155       break;
 156     case MachineOperand::MO_GlobalAddress:
 157       MCOp = LowerSymbolRefOperand(MO, GetSymbolRef(MO));
 158       break;
 159     case MachineOperand::MO_ExternalSymbol:
 160       MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
 161       break;
 162     case MachineOperand::MO_JumpTableIndex:
 163       MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
 164       break;
 165     case MachineOperand::MO_ConstantPoolIndex:
 166       MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
 167       break;
 168     case MachineOperand::MO_BlockAddress:
 169       MCOp = LowerSymbolOperand(MO, Printer.GetBlockAddressSymbol(
 170                                               MO.getBlockAddress()));
 171       break;
 172     case MachineOperand::MO_FPImmediate:
 173       APFloat Val = MO.getFPImm()->getValueAPF();
 174       bool ignored;
 175       Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
 176       MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
 177       break;
 178     }
 179
 180     OutMI.addOperand(MCOp);
 181   }
 182
 183 }