PPCTargetMachine.cpp revision 193323
1254721Semaste//===-- PPCTargetMachine.cpp - Define TargetMachine for PowerPC -----------===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste// 10254721Semaste// Top-level implementation for the PowerPC target. 11254721Semaste// 12254721Semaste//===----------------------------------------------------------------------===// 13254721Semaste 14254721Semaste#include "PPC.h" 15254721Semaste#include "PPCTargetAsmInfo.h" 16254721Semaste#include "PPCTargetMachine.h" 17254721Semaste#include "llvm/Module.h" 18254721Semaste#include "llvm/PassManager.h" 19254721Semaste#include "llvm/Target/TargetMachineRegistry.h" 20254721Semaste#include "llvm/Target/TargetOptions.h" 21254721Semaste#include "llvm/Support/raw_ostream.h" 22254721Semasteusing namespace llvm; 23254721Semaste 24254721Semaste/// PowerPCTargetMachineModule - Note that this is used on hosts that 25254721Semaste/// cannot link in a library unless there are references into the 26254721Semaste/// library. In particular, it seems that it is not possible to get 27254721Semaste/// things to work on Win32 without this. Though it is unused, do not 28254721Semaste/// remove it. 29254721Semasteextern "C" int PowerPCTargetMachineModule; 30254721Semasteint PowerPCTargetMachineModule = 0; 31254721Semaste 32254721Semaste// Register the targets 33254721Semastestatic RegisterTarget<PPC32TargetMachine> 34254721SemasteX("ppc32", "PowerPC 32"); 35254721Semastestatic RegisterTarget<PPC64TargetMachine> 36254721SemasteY("ppc64", "PowerPC 64"); 37254721Semaste 38254721Semaste// No assembler printer by default 39254721SemastePPCTargetMachine::AsmPrinterCtorFn PPCTargetMachine::AsmPrinterCtor = 0; 40254721Semaste 41254721Semasteconst TargetAsmInfo *PPCTargetMachine::createTargetAsmInfo() const { 42254721Semaste if (Subtarget.isDarwin()) 43254721Semaste return new PPCDarwinTargetAsmInfo(*this); 44254721Semaste else 45254721Semaste return new PPCLinuxTargetAsmInfo(*this); 46254721Semaste} 47254721Semaste 48254721Semasteunsigned PPC32TargetMachine::getJITMatchQuality() { 49254721Semaste#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) 50254721Semaste if (sizeof(void*) == 4) 51254721Semaste return 10; 52254721Semaste#endif 53254721Semaste return 0; 54254721Semaste} 55254721Semasteunsigned PPC64TargetMachine::getJITMatchQuality() { 56254721Semaste#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) 57254721Semaste if (sizeof(void*) == 8) 58254721Semaste return 10; 59254721Semaste#endif 60254721Semaste return 0; 61254721Semaste} 62254721Semaste 63254721Semasteunsigned PPC32TargetMachine::getModuleMatchQuality(const Module &M) { 64254721Semaste // We strongly match "powerpc-*". 65254721Semaste std::string TT = M.getTargetTriple(); 66254721Semaste if (TT.size() >= 8 && std::string(TT.begin(), TT.begin()+8) == "powerpc-") 67254721Semaste return 20; 68254721Semaste 69254721Semaste // If the target triple is something non-powerpc, we don't match. 70254721Semaste if (!TT.empty()) return 0; 71254721Semaste 72254721Semaste if (M.getEndianness() == Module::BigEndian && 73254721Semaste M.getPointerSize() == Module::Pointer32) 74254721Semaste return 10; // Weak match 75254721Semaste else if (M.getEndianness() != Module::AnyEndianness || 76254721Semaste M.getPointerSize() != Module::AnyPointerSize) 77254721Semaste return 0; // Match for some other target 78254721Semaste 79254721Semaste return getJITMatchQuality()/2; 80254721Semaste} 81254721Semaste 82254721Semasteunsigned PPC64TargetMachine::getModuleMatchQuality(const Module &M) { 83254721Semaste // We strongly match "powerpc64-*". 84254721Semaste std::string TT = M.getTargetTriple(); 85254721Semaste if (TT.size() >= 10 && std::string(TT.begin(), TT.begin()+10) == "powerpc64-") 86254721Semaste return 20; 87254721Semaste 88254721Semaste if (M.getEndianness() == Module::BigEndian && 89254721Semaste M.getPointerSize() == Module::Pointer64) 90254721Semaste return 10; // Weak match 91254721Semaste else if (M.getEndianness() != Module::AnyEndianness || 92254721Semaste M.getPointerSize() != Module::AnyPointerSize) 93254721Semaste return 0; // Match for some other target 94254721Semaste 95254721Semaste return getJITMatchQuality()/2; 96254721Semaste} 97254721Semaste 98254721Semaste 99254721SemastePPCTargetMachine::PPCTargetMachine(const Module &M, const std::string &FS, 100254721Semaste bool is64Bit) 101254721Semaste : Subtarget(*this, M, FS, is64Bit), 102254721Semaste DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), 103254721Semaste FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this), 104254721Semaste InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) { 105254721Semaste 106254721Semaste if (getRelocationModel() == Reloc::Default) { 107254721Semaste if (Subtarget.isDarwin()) 108254721Semaste setRelocationModel(Reloc::DynamicNoPIC); 109254721Semaste else 110254721Semaste setRelocationModel(Reloc::Static); 111254721Semaste } 112254721Semaste} 113254721Semaste 114254721Semaste/// Override this for PowerPC. Tail merging happily breaks up instruction issue 115254721Semaste/// groups, which typically degrades performance. 116254721Semastebool PPCTargetMachine::getEnableTailMergeDefault() const { return false; } 117254721Semaste 118254721SemastePPC32TargetMachine::PPC32TargetMachine(const Module &M, const std::string &FS) 119276479Sdim : PPCTargetMachine(M, FS, false) { 120280031Sdim} 121280031Sdim 122254721Semaste 123254721SemastePPC64TargetMachine::PPC64TargetMachine(const Module &M, const std::string &FS) 124254721Semaste : PPCTargetMachine(M, FS, true) { 125254721Semaste} 126254721Semaste 127254721Semaste 128254721Semaste//===----------------------------------------------------------------------===// 129254721Semaste// Pass Pipeline Configuration 130254721Semaste//===----------------------------------------------------------------------===// 131254721Semaste 132254721Semastebool PPCTargetMachine::addInstSelector(PassManagerBase &PM, 133254721Semaste CodeGenOpt::Level OptLevel) { 134276479Sdim // Install an instruction selector. 135280031Sdim PM.add(createPPCISelDag(*this)); 136280031Sdim return false; 137254721Semaste} 138254721Semaste 139254721Semastebool PPCTargetMachine::addPreEmitPass(PassManagerBase &PM, 140254721Semaste CodeGenOpt::Level OptLevel) { 141254721Semaste // Must run branch selection immediately preceding the asm printer. 142254721Semaste PM.add(createPPCBranchSelectionPass()); 143254721Semaste return false; 144254721Semaste} 145254721Semaste 146254721Semastebool PPCTargetMachine::addAssemblyEmitter(PassManagerBase &PM, 147254721Semaste CodeGenOpt::Level OptLevel, 148254721Semaste bool Verbose, 149254721Semaste raw_ostream &Out) { 150254721Semaste assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 151254721Semaste if (AsmPrinterCtor) 152254721Semaste PM.add(AsmPrinterCtor(Out, *this, OptLevel, Verbose)); 153254721Semaste 154254721Semaste return false; 155254721Semaste} 156254721Semaste 157254721Semastebool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM, 158254721Semaste CodeGenOpt::Level OptLevel, 159254721Semaste bool DumpAsm, MachineCodeEmitter &MCE) { 160254721Semaste // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64. 161254721Semaste // FIXME: This should be moved to TargetJITInfo!! 162254721Semaste if (Subtarget.isPPC64()) { 163254721Semaste // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many 164254721Semaste // instructions to materialize arbitrary global variable + function + 165254721Semaste // constant pool addresses. 166254721Semaste setRelocationModel(Reloc::PIC_); 167254721Semaste // Temporary workaround for the inability of PPC64 JIT to handle jump 168254721Semaste // tables. 169254721Semaste DisableJumpTables = true; 170254721Semaste } else { 171254721Semaste setRelocationModel(Reloc::Static); 172254721Semaste } 173254721Semaste 174254721Semaste // Inform the subtarget that we are in JIT mode. FIXME: does this break macho 175254721Semaste // writing? 176254721Semaste Subtarget.SetJITMode(); 177254721Semaste 178254721Semaste // Machine code emitter pass for PowerPC. 179254721Semaste PM.add(createPPCCodeEmitterPass(*this, MCE)); 180254721Semaste if (DumpAsm) { 181254721Semaste assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 182254721Semaste if (AsmPrinterCtor) 183254721Semaste PM.add(AsmPrinterCtor(errs(), *this, OptLevel, true)); 184254721Semaste } 185254721Semaste 186254721Semaste return false; 187254721Semaste} 188254721Semaste 189254721Semastebool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM, 190254721Semaste CodeGenOpt::Level OptLevel, 191254721Semaste bool DumpAsm, JITCodeEmitter &JCE) { 192254721Semaste // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64. 193254721Semaste // FIXME: This should be moved to TargetJITInfo!! 194254721Semaste if (Subtarget.isPPC64()) { 195254721Semaste // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many 196254721Semaste // instructions to materialize arbitrary global variable + function + 197254721Semaste // constant pool addresses. 198254721Semaste setRelocationModel(Reloc::PIC_); 199254721Semaste // Temporary workaround for the inability of PPC64 JIT to handle jump 200254721Semaste // tables. 201254721Semaste DisableJumpTables = true; 202254721Semaste } else { 203254721Semaste setRelocationModel(Reloc::Static); 204254721Semaste } 205254721Semaste 206254721Semaste // Inform the subtarget that we are in JIT mode. FIXME: does this break macho 207254721Semaste // writing? 208254721Semaste Subtarget.SetJITMode(); 209254721Semaste 210254721Semaste // Machine code emitter pass for PowerPC. 211254721Semaste PM.add(createPPCJITCodeEmitterPass(*this, JCE)); 212254721Semaste if (DumpAsm) { 213254721Semaste assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 214254721Semaste if (AsmPrinterCtor) 215254721Semaste PM.add(AsmPrinterCtor(errs(), *this, OptLevel, true)); 216254721Semaste } 217254721Semaste 218254721Semaste return false; 219254721Semaste} 220254721Semaste 221254721Semastebool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, 222254721Semaste CodeGenOpt::Level OptLevel, 223254721Semaste bool DumpAsm, 224254721Semaste MachineCodeEmitter &MCE) { 225254721Semaste // Machine code emitter pass for PowerPC. 226254721Semaste PM.add(createPPCCodeEmitterPass(*this, MCE)); 227254721Semaste if (DumpAsm) { 228254721Semaste assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 229254721Semaste if (AsmPrinterCtor) 230254721Semaste PM.add(AsmPrinterCtor(errs(), *this, OptLevel, true)); 231254721Semaste } 232254721Semaste 233254721Semaste return false; 234254721Semaste} 235254721Semaste 236254721Semastebool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, 237254721Semaste CodeGenOpt::Level OptLevel, 238254721Semaste bool DumpAsm, 239254721Semaste JITCodeEmitter &JCE) { 240254721Semaste // Machine code emitter pass for PowerPC. 241254721Semaste PM.add(createPPCJITCodeEmitterPass(*this, JCE)); 242254721Semaste if (DumpAsm) { 243254721Semaste assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 244254721Semaste if (AsmPrinterCtor) 245254721Semaste PM.add(AsmPrinterCtor(errs(), *this, OptLevel, true)); 246254721Semaste } 247254721Semaste 248254721Semaste return false; 249254721Semaste} 250254721Semaste 251254721Semaste