lib/Target/ARM/AsmPrinter/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 "llvm/CodeGen/MachineModuleInfoImpls.h"
  17 #include "llvm/CodeGen/MachineInstr.h"
  18 #include "llvm/MC/MCAsmInfo.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCExpr.h"
  21 #include "llvm/MC/MCInst.h"
  22 //#include "llvm/MC/MCStreamer.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/Support/Mangler.h"
  25 #include "llvm/ADT/SmallString.h"
  26 using namespace llvm;
  27
  28
  29 #if 0
  30 const ARMSubtarget &ARMMCInstLower::getSubtarget() const {
  31   return AsmPrinter.getSubtarget();
  32 }
  33
  34 MachineModuleInfoMachO &ARMMCInstLower::getMachOMMI() const {
  35   assert(getSubtarget().isTargetDarwin() &&"Can only get MachO info on darwin");
  36   return AsmPrinter.MMI->getObjFileInfo<MachineModuleInfoMachO>();
  37 }
  38 #endif
  39
  40 MCSymbol *ARMMCInstLower::
  41 GetGlobalAddressSymbol(const MachineOperand &MO) const {
  42   const GlobalValue *GV = MO.getGlobal();
  43
  44   SmallString<128> Name;
  45   Mang.getNameWithPrefix(Name, GV, false);
  46
  47   // FIXME: HANDLE PLT references how??
  48   switch (MO.getTargetFlags()) {
  49   default: assert(0 && "Unknown target flag on GV operand");
  50   case 0: break;
  51   }
  52
  53   return Ctx.GetOrCreateSymbol(Name.str());
  54 }
  55
  56
  57 MCSymbol *ARMMCInstLower::
  58 GetJumpTableSymbol(const MachineOperand &MO) const {
  59   SmallString<256> Name;
  60   raw_svector_ostream(Name) << MAI.getPrivateGlobalPrefix() << "JTI"
  61     << CurFunctionNumber << '_' << MO.getIndex();
  62
  63 #if 0
  64   switch (MO.getTargetFlags()) {
  65     default: llvm_unreachable("Unknown target flag on GV operand");
  66   }
  67 #endif
  68
  69   // Create a symbol for the name.
  70   return Ctx.GetOrCreateSymbol(Name.str());
  71 }
  72
  73 MCSymbol *ARMMCInstLower::
  74 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
  75   SmallString<256> Name;
  76   raw_svector_ostream(Name) << MAI.getPrivateGlobalPrefix() << "CPI"
  77     << CurFunctionNumber << '_' << MO.getIndex();
  78
  79 #if 0
  80   switch (MO.getTargetFlags()) {
  81   default: llvm_unreachable("Unknown target flag on GV operand");
  82   }
  83 #endif
  84
  85   // Create a symbol for the name.
  86   return Ctx.GetOrCreateSymbol(Name.str());
  87 }
  88
  89 MCOperand ARMMCInstLower::
  90 LowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const {
  91   // FIXME: We would like an efficient form for this, so we don't have to do a
  92   // lot of extra uniquing.
  93   const MCExpr *Expr = MCSymbolRefExpr::Create(Sym, Ctx);
  94
  95 #if 0
  96   switch (MO.getTargetFlags()) {
  97   default: llvm_unreachable("Unknown target flag on GV operand");
  98   }
  99 #endif
 100
 101   if (!MO.isJTI() && MO.getOffset())
 102     Expr = MCBinaryExpr::CreateAdd(Expr,
 103                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 104                                    Ctx);
 105   return MCOperand::CreateExpr(Expr);
 106 }
 107
 108
 109 void ARMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 110   OutMI.setOpcode(MI->getOpcode());
 111
 112   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 113     const MachineOperand &MO = MI->getOperand(i);
 114
 115     MCOperand MCOp;
 116     switch (MO.getType()) {
 117     default:
 118       MI->dump();
 119       assert(0 && "unknown operand type");
 120     case MachineOperand::MO_Register:
 121       MCOp = MCOperand::CreateReg(MO.getReg());
 122       break;
 123     case MachineOperand::MO_Immediate:
 124       MCOp = MCOperand::CreateImm(MO.getImm());
 125       break;
 126 #if 0
 127     case MachineOperand::MO_MachineBasicBlock:
 128       MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 129                        AsmPrinter.GetMBBSymbol(MO.getMBB()->getNumber()), Ctx));
 130       break;
 131 #endif
 132     case MachineOperand::MO_GlobalAddress:
 133       MCOp = LowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
 134       break;
 135 #if 0
 136     case MachineOperand::MO_ExternalSymbol:
 137       MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
 138       break;
 139 #endif
 140     case MachineOperand::MO_JumpTableIndex:
 141       MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
 142       break;
 143     case MachineOperand::MO_ConstantPoolIndex:
 144       MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
 145       break;
 146     }
 147
 148     OutMI.addOperand(MCOp);
 149   }
 150
 151 }