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