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 "MCTargetDesc/PPCMCExpr.h" 17 #include "llvm/ADT/SmallString.h" 18 #include "llvm/ADT/Twine.h" 19 #include "llvm/CodeGen/AsmPrinter.h" 20 #include "llvm/CodeGen/MachineFunction.h" 21 #include "llvm/CodeGen/MachineModuleInfoImpls.h" 22 #include "llvm/IR/GlobalValue.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/MC/MCExpr.h" 25 #include "llvm/MC/MCInst.h" 26 #include "llvm/Target/Mangler.h" 27 using namespace llvm; 28 29 static MachineModuleInfoMachO &getMachOMMI(AsmPrinter &AP) { 30 return AP.MMI->getObjFileInfo<MachineModuleInfoMachO>(); 31 } 32 33 34 static MCSymbol *GetSymbolFromOperand(const MachineOperand &MO, AsmPrinter &AP){ 35 MCContext &Ctx = AP.OutContext; 36 37 SmallString<128> Name; 38 if (!MO.isGlobal()) { 39 assert(MO.isSymbol() && "Isn't a symbol reference"); 40 AP.Mang->getNameWithPrefix(Name, MO.getSymbolName()); 41 } else { 42 const GlobalValue *GV = MO.getGlobal(); 43 bool isImplicitlyPrivate = false; 44 if (MO.getTargetFlags() == PPCII::MO_DARWIN_STUB || 45 (MO.getTargetFlags() & PPCII::MO_NLP_FLAG)) 46 isImplicitlyPrivate = true; 47 48 AP.Mang->getNameWithPrefix(Name, GV, isImplicitlyPrivate); 49 } 50 51 // If the target flags on the operand changes the name of the symbol, do that 52 // before we return the symbol. 53 if (MO.getTargetFlags() == PPCII::MO_DARWIN_STUB) { 54 Name += "$stub"; 55 const char *PGP = AP.MAI->getPrivateGlobalPrefix(); 56 const char *Prefix = ""; 57 if (!Name.startswith(PGP)) { 58 // http://llvm.org/bugs/show_bug.cgi?id=15763 59 // all stubs and lazy_ptrs should be local symbols, which need leading 'L' 60 Prefix = PGP; 61 } 62 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Twine(Prefix) + Twine(Name)); 63 MachineModuleInfoImpl::StubValueTy &StubSym = 64 getMachOMMI(AP).getFnStubEntry(Sym); 65 if (StubSym.getPointer()) 66 return Sym; 67 68 if (MO.isGlobal()) { 69 StubSym = 70 MachineModuleInfoImpl:: 71 StubValueTy(AP.getSymbol(MO.getGlobal()), 72 !MO.getGlobal()->hasInternalLinkage()); 73 } else { 74 Name.erase(Name.end()-5, Name.end()); 75 StubSym = 76 MachineModuleInfoImpl:: 77 StubValueTy(Ctx.GetOrCreateSymbol(Name.str()), false); 78 } 79 return Sym; 80 } 81 82 // If the symbol reference is actually to a non_lazy_ptr, not to the symbol, 83 // then add the suffix. 84 if (MO.getTargetFlags() & PPCII::MO_NLP_FLAG) { 85 Name += "$non_lazy_ptr"; 86 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str()); 87 88 MachineModuleInfoMachO &MachO = getMachOMMI(AP); 89 90 MachineModuleInfoImpl::StubValueTy &StubSym = 91 (MO.getTargetFlags() & PPCII::MO_NLP_HIDDEN_FLAG) ? 92 MachO.getHiddenGVStubEntry(Sym) : MachO.getGVStubEntry(Sym); 93 94 if (StubSym.getPointer() == 0) { 95 assert(MO.isGlobal() && "Extern symbol not handled yet"); 96 StubSym = MachineModuleInfoImpl:: 97 StubValueTy(AP.getSymbol(MO.getGlobal()), 98 !MO.getGlobal()->hasInternalLinkage()); 99 } 100 return Sym; 101 } 102 103 return Ctx.GetOrCreateSymbol(Name.str()); 104 } 105 106 static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol, 107 AsmPrinter &Printer, bool isDarwin) { 108 MCContext &Ctx = Printer.OutContext; 109 MCSymbolRefExpr::VariantKind RefKind = MCSymbolRefExpr::VK_None; 110 111 unsigned access = MO.getTargetFlags() & PPCII::MO_ACCESS_MASK; 112 113 switch (access) { 114 case PPCII::MO_TPREL_LO: 115 RefKind = MCSymbolRefExpr::VK_PPC_TPREL_LO; 116 break; 117 case PPCII::MO_TPREL_HA: 118 RefKind = MCSymbolRefExpr::VK_PPC_TPREL_HA; 119 break; 120 case PPCII::MO_DTPREL_LO: 121 RefKind = MCSymbolRefExpr::VK_PPC_DTPREL_LO; 122 break; 123 case PPCII::MO_TLSLD_LO: 124 RefKind = MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO; 125 break; 126 case PPCII::MO_TOC_LO: 127 RefKind = MCSymbolRefExpr::VK_PPC_TOC_LO; 128 break; 129 case PPCII::MO_TLS: 130 RefKind = MCSymbolRefExpr::VK_PPC_TLS; 131 break; 132 } 133 134 const MCExpr *Expr = MCSymbolRefExpr::Create(Symbol, RefKind, Ctx); 135 136 if (!MO.isJTI() && MO.getOffset()) 137 Expr = MCBinaryExpr::CreateAdd(Expr, 138 MCConstantExpr::Create(MO.getOffset(), Ctx), 139 Ctx); 140 141 // Subtract off the PIC base if required. 142 if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) { 143 const MachineFunction *MF = MO.getParent()->getParent()->getParent(); 144 145 const MCExpr *PB = MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx); 146 Expr = MCBinaryExpr::CreateSub(Expr, PB, Ctx); 147 } 148 149 // Add ha16() / lo16() markers if required. 150 switch (access) { 151 case PPCII::MO_LO: 152 Expr = PPCMCExpr::CreateLo(Expr, isDarwin, Ctx); 153 break; 154 case PPCII::MO_HA: 155 Expr = PPCMCExpr::CreateHa(Expr, isDarwin, Ctx); 156 break; 157 } 158 159 return MCOperand::CreateExpr(Expr); 160 } 161 162 void llvm::LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI, 163 AsmPrinter &AP, bool isDarwin) { 164 OutMI.setOpcode(MI->getOpcode()); 165 166 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 167 const MachineOperand &MO = MI->getOperand(i); 168 169 MCOperand MCOp; 170 switch (MO.getType()) { 171 default: 172 MI->dump(); 173 llvm_unreachable("unknown operand type"); 174 case MachineOperand::MO_Register: 175 assert(!MO.getSubReg() && "Subregs should be eliminated!"); 176 MCOp = MCOperand::CreateReg(MO.getReg()); 177 break; 178 case MachineOperand::MO_Immediate: 179 MCOp = MCOperand::CreateImm(MO.getImm()); 180 break; 181 case MachineOperand::MO_MachineBasicBlock: 182 MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create( 183 MO.getMBB()->getSymbol(), AP.OutContext)); 184 break; 185 case MachineOperand::MO_GlobalAddress: 186 case MachineOperand::MO_ExternalSymbol: 187 MCOp = GetSymbolRef(MO, GetSymbolFromOperand(MO, AP), AP, isDarwin); 188 break; 189 case MachineOperand::MO_JumpTableIndex: 190 MCOp = GetSymbolRef(MO, AP.GetJTISymbol(MO.getIndex()), AP, isDarwin); 191 break; 192 case MachineOperand::MO_ConstantPoolIndex: 193 MCOp = GetSymbolRef(MO, AP.GetCPISymbol(MO.getIndex()), AP, isDarwin); 194 break; 195 case MachineOperand::MO_BlockAddress: 196 MCOp = GetSymbolRef(MO,AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP, 197 isDarwin); 198 break; 199 case MachineOperand::MO_RegisterMask: 200 continue; 201 } 202 203 OutMI.addOperand(MCOp); 204 } 205 } 206