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" 24 using namespace llvm; 25 26 static MachineModuleInfoMachO &getMachOMMI(AsmPrinter &AP) { 27 return AP.MMI->getObjFileInfo<MachineModuleInfoMachO>(); 28 } 29 30 31 static 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 97 static 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 case PPCII::MO_GOT_TPREL16_DS: 118 RefKind = MCSymbolRefExpr::VK_PPC_GOT_TPREL16_DS; 119 break; 120 case PPCII::MO_TLS: 121 RefKind = MCSymbolRefExpr::VK_PPC_TLS; 122 break; 123 } 124 125 // FIXME: This isn't right, but we don't have a good way to express this in 126 // the MC Level, see below. 127 if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) 128 RefKind = MCSymbolRefExpr::VK_None; 129 130 const MCExpr *Expr = MCSymbolRefExpr::Create(Symbol, RefKind, Ctx); 131 132 if (!MO.isJTI() && MO.getOffset()) 133 Expr = MCBinaryExpr::CreateAdd(Expr, 134 MCConstantExpr::Create(MO.getOffset(), Ctx), 135 Ctx); 136 137 // Subtract off the PIC base if required. 138 if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) { 139 const MachineFunction *MF = MO.getParent()->getParent()->getParent(); 140 141 const MCExpr *PB = MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx); 142 Expr = MCBinaryExpr::CreateSub(Expr, PB, Ctx); 143 // FIXME: We have no way to make the result be VK_PPC_LO16/VK_PPC_HA16, 144 // since it is not a symbol! 145 } 146 147 return MCOperand::CreateExpr(Expr); 148 } 149 150 void llvm::LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI, 151 AsmPrinter &AP, bool isDarwin) { 152 OutMI.setOpcode(MI->getOpcode()); 153 154 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 155 const MachineOperand &MO = MI->getOperand(i); 156 157 MCOperand MCOp; 158 switch (MO.getType()) { 159 default: 160 MI->dump(); 161 llvm_unreachable("unknown operand type"); 162 case MachineOperand::MO_Register: 163 assert(!MO.getSubReg() && "Subregs should be eliminated!"); 164 MCOp = MCOperand::CreateReg(MO.getReg()); 165 break; 166 case MachineOperand::MO_Immediate: 167 MCOp = MCOperand::CreateImm(MO.getImm()); 168 break; 169 case MachineOperand::MO_MachineBasicBlock: 170 MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create( 171 MO.getMBB()->getSymbol(), AP.OutContext)); 172 break; 173 case MachineOperand::MO_GlobalAddress: 174 case MachineOperand::MO_ExternalSymbol: 175 MCOp = GetSymbolRef(MO, GetSymbolFromOperand(MO, AP), AP, isDarwin); 176 break; 177 case MachineOperand::MO_JumpTableIndex: 178 MCOp = GetSymbolRef(MO, AP.GetJTISymbol(MO.getIndex()), AP, isDarwin); 179 break; 180 case MachineOperand::MO_ConstantPoolIndex: 181 MCOp = GetSymbolRef(MO, AP.GetCPISymbol(MO.getIndex()), AP, isDarwin); 182 break; 183 case MachineOperand::MO_BlockAddress: 184 MCOp = GetSymbolRef(MO,AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP, 185 isDarwin); 186 break; 187 case MachineOperand::MO_RegisterMask: 188 continue; 189 } 190 191 OutMI.addOperand(MCOp); 192 } 193 } 194