PPCMCInstLower.cpp revision 59d580c8d664448f01ea5652ea51b90e0b7e84f6
1//===-- PPCMCInstLower.cpp - Convert PPC 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 PPC MachineInstrs to their corresponding 11// MCInst records. 12// 13//===----------------------------------------------------------------------===// 14 15#include "PPC.h" 16#include "llvm/ADT/SmallString.h" 17#include "llvm/CodeGen/AsmPrinter.h" 18#include "llvm/CodeGen/MachineFunction.h" 19#include "llvm/CodeGen/MachineModuleInfoImpls.h" 20#include "llvm/IR/GlobalValue.h" 21#include "llvm/MC/MCAsmInfo.h" 22#include "llvm/MC/MCExpr.h" 23#include "llvm/MC/MCInst.h" 24#include "llvm/Target/Mangler.h" 25using namespace llvm; 26 27static MachineModuleInfoMachO &getMachOMMI(AsmPrinter &AP) { 28 return AP.MMI->getObjFileInfo<MachineModuleInfoMachO>(); 29} 30 31 32static MCSymbol *GetSymbolFromOperand(const MachineOperand &MO, AsmPrinter &AP){ 33 MCContext &Ctx = AP.OutContext; 34 35 SmallString<128> Name; 36 if (!MO.isGlobal()) { 37 assert(MO.isSymbol() && "Isn't a symbol reference"); 38 Name += AP.MAI->getGlobalPrefix(); 39 Name += MO.getSymbolName(); 40 } else { 41 const GlobalValue *GV = MO.getGlobal(); 42 bool isImplicitlyPrivate = false; 43 if (MO.getTargetFlags() == PPCII::MO_DARWIN_STUB || 44 (MO.getTargetFlags() & PPCII::MO_NLP_FLAG)) 45 isImplicitlyPrivate = true; 46 47 AP.Mang->getNameWithPrefix(Name, GV, isImplicitlyPrivate); 48 } 49 50 // If the target flags on the operand changes the name of the symbol, do that 51 // before we return the symbol. 52 if (MO.getTargetFlags() == PPCII::MO_DARWIN_STUB) { 53 Name += "$stub"; 54 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str()); 55 MachineModuleInfoImpl::StubValueTy &StubSym = 56 getMachOMMI(AP).getFnStubEntry(Sym); 57 if (StubSym.getPointer()) 58 return Sym; 59 60 if (MO.isGlobal()) { 61 StubSym = 62 MachineModuleInfoImpl:: 63 StubValueTy(AP.Mang->getSymbol(MO.getGlobal()), 64 !MO.getGlobal()->hasInternalLinkage()); 65 } else { 66 Name.erase(Name.end()-5, Name.end()); 67 StubSym = 68 MachineModuleInfoImpl:: 69 StubValueTy(Ctx.GetOrCreateSymbol(Name.str()), false); 70 } 71 return Sym; 72 } 73 74 // If the symbol reference is actually to a non_lazy_ptr, not to the symbol, 75 // then add the suffix. 76 if (MO.getTargetFlags() & PPCII::MO_NLP_FLAG) { 77 Name += "$non_lazy_ptr"; 78 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str()); 79 80 MachineModuleInfoMachO &MachO = getMachOMMI(AP); 81 82 MachineModuleInfoImpl::StubValueTy &StubSym = 83 (MO.getTargetFlags() & PPCII::MO_NLP_HIDDEN_FLAG) ? 84 MachO.getHiddenGVStubEntry(Sym) : MachO.getGVStubEntry(Sym); 85 86 if (StubSym.getPointer() == 0) { 87 assert(MO.isGlobal() && "Extern symbol not handled yet"); 88 StubSym = MachineModuleInfoImpl:: 89 StubValueTy(AP.Mang->getSymbol(MO.getGlobal()), 90 !MO.getGlobal()->hasInternalLinkage()); 91 } 92 return Sym; 93 } 94 95 return Ctx.GetOrCreateSymbol(Name.str()); 96} 97 98static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol, 99 AsmPrinter &Printer, bool isDarwin) { 100 MCContext &Ctx = Printer.OutContext; 101 MCSymbolRefExpr::VariantKind RefKind = MCSymbolRefExpr::VK_None; 102 103 unsigned access = MO.getTargetFlags() & PPCII::MO_ACCESS_MASK; 104 105 switch (access) { 106 case PPCII::MO_HA16: RefKind = isDarwin ? 107 MCSymbolRefExpr::VK_PPC_DARWIN_HA16 : 108 MCSymbolRefExpr::VK_PPC_GAS_HA16; 109 break; 110 case PPCII::MO_LO16: RefKind = isDarwin ? 111 MCSymbolRefExpr::VK_PPC_DARWIN_LO16 : 112 MCSymbolRefExpr::VK_PPC_GAS_LO16; 113 break; 114 case PPCII::MO_TPREL16_HA: RefKind = MCSymbolRefExpr::VK_PPC_TPREL16_HA; 115 break; 116 case PPCII::MO_TPREL16_LO: RefKind = MCSymbolRefExpr::VK_PPC_TPREL16_LO; 117 break; 118 } 119 120 // FIXME: This isn't right, but we don't have a good way to express this in 121 // the MC Level, see below. 122 if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) 123 RefKind = MCSymbolRefExpr::VK_None; 124 125 const MCExpr *Expr = MCSymbolRefExpr::Create(Symbol, RefKind, Ctx); 126 127 if (!MO.isJTI() && MO.getOffset()) 128 Expr = MCBinaryExpr::CreateAdd(Expr, 129 MCConstantExpr::Create(MO.getOffset(), Ctx), 130 Ctx); 131 132 // Subtract off the PIC base if required. 133 if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) { 134 const MachineFunction *MF = MO.getParent()->getParent()->getParent(); 135 136 const MCExpr *PB = MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx); 137 Expr = MCBinaryExpr::CreateSub(Expr, PB, Ctx); 138 // FIXME: We have no way to make the result be VK_PPC_LO16/VK_PPC_HA16, 139 // since it is not a symbol! 140 } 141 142 return MCOperand::CreateExpr(Expr); 143} 144 145void llvm::LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI, 146 AsmPrinter &AP, bool isDarwin) { 147 OutMI.setOpcode(MI->getOpcode()); 148 149 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 150 const MachineOperand &MO = MI->getOperand(i); 151 152 MCOperand MCOp; 153 switch (MO.getType()) { 154 default: 155 MI->dump(); 156 llvm_unreachable("unknown operand type"); 157 case MachineOperand::MO_Register: 158 assert(!MO.getSubReg() && "Subregs should be eliminated!"); 159 MCOp = MCOperand::CreateReg(MO.getReg()); 160 break; 161 case MachineOperand::MO_Immediate: 162 MCOp = MCOperand::CreateImm(MO.getImm()); 163 break; 164 case MachineOperand::MO_MachineBasicBlock: 165 MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create( 166 MO.getMBB()->getSymbol(), AP.OutContext)); 167 break; 168 case MachineOperand::MO_GlobalAddress: 169 case MachineOperand::MO_ExternalSymbol: 170 MCOp = GetSymbolRef(MO, GetSymbolFromOperand(MO, AP), AP, isDarwin); 171 break; 172 case MachineOperand::MO_JumpTableIndex: 173 MCOp = GetSymbolRef(MO, AP.GetJTISymbol(MO.getIndex()), AP, isDarwin); 174 break; 175 case MachineOperand::MO_ConstantPoolIndex: 176 MCOp = GetSymbolRef(MO, AP.GetCPISymbol(MO.getIndex()), AP, isDarwin); 177 break; 178 case MachineOperand::MO_BlockAddress: 179 MCOp = GetSymbolRef(MO,AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP, 180 isDarwin); 181 break; 182 case MachineOperand::MO_RegisterMask: 183 continue; 184 } 185 186 OutMI.addOperand(MCOp); 187 } 188} 189