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