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