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 "ARMMCInstLower.h"
  16 #include "ARM.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
  37   const MCSymbolRefExpr *SymRef;
  38   const MCSymbol *Symbol = GetGlobalAddressSymbol(MO.getGlobal());
  39
  40   switch (MO.getTargetFlags()) {
  41   default: assert(0 && "Unknown target flag on GV operand");
  42   case 0:
  43     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_None, Ctx);
  44     break;
  45   case ARMII::MO_LO16:
  46     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_LO16, Ctx);
  47     break;
  48   case ARMII::MO_HI16:
  49     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_HI16, Ctx);
  50     break;
  51   case ARMII::MO_PLT:
  52     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_PLT, Ctx);
  53     break;
  54   }
  55
  56   return SymRef;
  57 }
  58
  59 const MCSymbolRefExpr *ARMMCInstLower::
  60 GetExternalSymbolSymbol(const MachineOperand &MO) const {
  61   const MCSymbolRefExpr *SymRef;
  62   const MCSymbol *Symbol = Printer.GetExternalSymbolSymbol(MO.getSymbolName());
  63
  64   switch (MO.getTargetFlags()) {
  65   default: assert(0 && "Unknown target flag on external symbol operand");
  66   case 0:
  67     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_None, Ctx);
  68     break;
  69   case ARMII::MO_LO16:
  70     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_LO16, Ctx);
  71     break;
  72   case ARMII::MO_HI16:
  73     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_HI16, Ctx);
  74     break;
  75   case ARMII::MO_PLT:
  76     SymRef = MCSymbolRefExpr::Create(Symbol, MCSymbolRefExpr::VK_ARM_PLT, Ctx);
  77     break;
  78   }
  79
  80   return SymRef;
  81 }
  82
  83
  84
  85 const MCSymbolRefExpr *ARMMCInstLower::
  86 GetJumpTableSymbol(const MachineOperand &MO) const {
  87   SmallString<256> Name;
  88   raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "JTI"
  89     << Printer.getFunctionNumber() << '_' << MO.getIndex();
  90
  91   switch (MO.getTargetFlags()) {
  92   default: assert(0 && "Unknown target flag on jump table operand");
  93   case 0: break;
  94   }
  95
  96   // Create a symbol for the name.
  97   return MCSymbolRefExpr::Create(Ctx.GetOrCreateSymbol(Name.str()), Ctx);
  98 }
  99
 100 const MCSymbolRefExpr *ARMMCInstLower::
 101 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
 102   SmallString<256> Name;
 103   raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "CPI"
 104     << Printer.getFunctionNumber() << '_' << MO.getIndex();
 105
 106   switch (MO.getTargetFlags()) {
 107   default: assert(0 && "Unknown target flag on CPI operand");
 108   case 0: break;
 109   }
 110
 111   // Create a symbol for the name.
 112   return MCSymbolRefExpr::Create(Ctx.GetOrCreateSymbol(Name.str()), Ctx);
 113 }
 114
 115 MCOperand ARMMCInstLower::
 116 LowerSymbolRefOperand(const MachineOperand &MO,
 117                       const MCSymbolRefExpr *Sym) const {
 118   const MCExpr *Expr = Sym;
 119   if (!MO.isJTI() && MO.getOffset())
 120     Expr = MCBinaryExpr::CreateAdd(Expr,
 121                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 122                                    Ctx);
 123   return MCOperand::CreateExpr(Expr);
 124 }
 125
 126
 127 void ARMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 128   OutMI.setOpcode(MI->getOpcode());
 129
 130   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 131     const MachineOperand &MO = MI->getOperand(i);
 132
 133     MCOperand MCOp;
 134     switch (MO.getType()) {
 135     default:
 136       MI->dump();
 137       assert(0 && "unknown operand type");
 138     case MachineOperand::MO_Register:
 139       // Ignore all non-CPSR implicit register operands.
 140       if (MO.isImplicit() && MO.getReg() != ARM::CPSR) continue;
 141       assert(!MO.getSubReg() && "Subregs should be eliminated!");
 142       MCOp = MCOperand::CreateReg(MO.getReg());
 143       break;
 144     case MachineOperand::MO_Immediate:
 145       MCOp = MCOperand::CreateImm(MO.getImm());
 146       break;
 147     case MachineOperand::MO_MachineBasicBlock:
 148       MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 149                        MO.getMBB()->getSymbol(), Ctx));
 150       break;
 151     case MachineOperand::MO_GlobalAddress:
 152       MCOp = LowerSymbolRefOperand(MO, GetSymbolRef(MO));
 153       break;
 154     case MachineOperand::MO_ExternalSymbol:
 155       MCOp = LowerSymbolRefOperand(MO, GetExternalSymbolSymbol(MO));
 156       break;
 157     case MachineOperand::MO_JumpTableIndex:
 158       MCOp = LowerSymbolRefOperand(MO, GetJumpTableSymbol(MO));
 159       break;
 160     case MachineOperand::MO_ConstantPoolIndex:
 161       MCOp = LowerSymbolRefOperand(MO, GetConstantPoolIndexSymbol(MO));
 162       break;
 163     case MachineOperand::MO_BlockAddress:
 164       MCOp = LowerSymbolRefOperand(MO,
 165                     MCSymbolRefExpr::Create(Printer.GetBlockAddressSymbol(
 166                                               MO.getBlockAddress()), Ctx));
 167       break;
 168     case MachineOperand::MO_FPImmediate:
 169       APFloat Val = MO.getFPImm()->getValueAPF();
 170       bool ignored;
 171       Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
 172       MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
 173       break;
 174     }
 175
 176     OutMI.addOperand(MCOp);
 177   }
 178
 179 }