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 #if 0
  79   switch (MO.getTargetFlags()) {
  80     default: llvm_unreachable("Unknown target flag on GV operand");
  81   }
  82 #endif
  83
  84   // Create a symbol for the name.
  85   return Ctx.GetOrCreateSymbol(Name.str());
  86 }
  87
  88 MCSymbol *ARMMCInstLower::
  89 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
  90   SmallString<256> Name;
  91   raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "CPI"
  92     << Printer.getFunctionNumber() << '_' << MO.getIndex();
  93
  94 #if 0
  95   switch (MO.getTargetFlags()) {
  96   default: llvm_unreachable("Unknown target flag on GV operand");
  97   }
  98 #endif
  99
 100   // Create a symbol for the name.
 101   return Ctx.GetOrCreateSymbol(Name.str());
 102 }
 103
 104 MCOperand ARMMCInstLower::
 105 LowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const {
 106   // FIXME: We would like an efficient form for this, so we don't have to do a
 107   // lot of extra uniquing.
 108   const MCExpr *Expr = MCSymbolRefExpr::Create(Sym, Ctx);
 109
 110 #if 0
 111   switch (MO.getTargetFlags()) {
 112   default: llvm_unreachable("Unknown target flag on GV operand");
 113   }
 114 #endif
 115
 116   if (!MO.isJTI() && MO.getOffset())
 117     Expr = MCBinaryExpr::CreateAdd(Expr,
 118                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 119                                    Ctx);
 120   return MCOperand::CreateExpr(Expr);
 121 }
 122
 123 MCOperand ARMMCInstLower::
 124 LowerSymbolRefOperand(const MachineOperand &MO,
 125                       const MCSymbolRefExpr *Sym) const {
 126   const MCExpr *Expr = Sym;
 127   if (!MO.isJTI() && MO.getOffset())
 128     Expr = MCBinaryExpr::CreateAdd(Expr,
 129                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 130                                    Ctx);
 131   return MCOperand::CreateExpr(Expr);
 132 }
 133
 134
 135 void ARMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 136   OutMI.setOpcode(MI->getOpcode());
 137
 138   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 139     const MachineOperand &MO = MI->getOperand(i);
 140
 141     MCOperand MCOp;
 142     switch (MO.getType()) {
 143     default:
 144       MI->dump();
 145       assert(0 && "unknown operand type");
 146     case MachineOperand::MO_Register:
 147       // Ignore all non-CPSR implicit register operands.
 148       if (MO.isImplicit() && MO.getReg() != ARM::CPSR) continue;
 149       assert(!MO.getSubReg() && "Subregs should be eliminated!");
 150       MCOp = MCOperand::CreateReg(MO.getReg());
 151       break;
 152     case MachineOperand::MO_Immediate:
 153       MCOp = MCOperand::CreateImm(MO.getImm());
 154       break;
 155     case MachineOperand::MO_MachineBasicBlock:
 156       MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 157                        MO.getMBB()->getSymbol(), Ctx));
 158       break;
 159     case MachineOperand::MO_GlobalAddress:
 160       MCOp = LowerSymbolRefOperand(MO, GetSymbolRef(MO));
 161       break;
 162     case MachineOperand::MO_ExternalSymbol:
 163       MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
 164       break;
 165     case MachineOperand::MO_JumpTableIndex:
 166       MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
 167       break;
 168     case MachineOperand::MO_ConstantPoolIndex:
 169       MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
 170       break;
 171     case MachineOperand::MO_BlockAddress:
 172       MCOp = LowerSymbolOperand(MO, Printer.GetBlockAddressSymbol(
 173                                               MO.getBlockAddress()));
 174       break;
 175     case MachineOperand::MO_FPImmediate:
 176       APFloat Val = MO.getFPImm()->getValueAPF();
 177       bool ignored;
 178       Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
 179       MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
 180       break;
 181     }
 182
 183     OutMI.addOperand(MCOp);
 184   }
 185
 186 }