PPCTargetMachine.cpp revision 92adc19be95347225f713db8cc1b5e22ac08bb5e
1//===-- PPCTargetMachine.cpp - Define TargetMachine for PowerPC -----------===// 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// Top-level implementation for the PowerPC target. 11// 12//===----------------------------------------------------------------------===// 13 14#include "PPC.h" 15#include "PPCTargetAsmInfo.h" 16#include "PPCTargetMachine.h" 17#include "llvm/Module.h" 18#include "llvm/PassManager.h" 19#include "llvm/Target/TargetMachineRegistry.h" 20#include "llvm/Target/TargetOptions.h" 21#include "llvm/Support/raw_ostream.h" 22using namespace llvm; 23 24/// PowerPCTargetMachineModule - Note that this is used on hosts that 25/// cannot link in a library unless there are references into the 26/// library. In particular, it seems that it is not possible to get 27/// things to work on Win32 without this. Though it is unused, do not 28/// remove it. 29extern "C" int PowerPCTargetMachineModule; 30int PowerPCTargetMachineModule = 0; 31 32// Register the targets 33static RegisterTarget<PPC32TargetMachine> 34X("ppc32", "PowerPC 32"); 35static RegisterTarget<PPC64TargetMachine> 36Y("ppc64", "PowerPC 64"); 37 38// No assembler printer by default 39PPCTargetMachine::AsmPrinterCtorFn PPCTargetMachine::AsmPrinterCtor = 0; 40 41const TargetAsmInfo *PPCTargetMachine::createTargetAsmInfo() const { 42 if (Subtarget.isDarwin()) 43 return new PPCDarwinTargetAsmInfo(*this); 44 else 45 return new PPCLinuxTargetAsmInfo(*this); 46} 47 48unsigned PPC32TargetMachine::getJITMatchQuality() { 49#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) 50 if (sizeof(void*) == 4) 51 return 10; 52#endif 53 return 0; 54} 55unsigned PPC64TargetMachine::getJITMatchQuality() { 56#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) 57 if (sizeof(void*) == 8) 58 return 10; 59#endif 60 return 0; 61} 62 63unsigned PPC32TargetMachine::getModuleMatchQuality(const Module &M) { 64 // We strongly match "powerpc-*". 65 std::string TT = M.getTargetTriple(); 66 if (TT.size() >= 8 && std::string(TT.begin(), TT.begin()+8) == "powerpc-") 67 return 20; 68 69 // If the target triple is something non-powerpc, we don't match. 70 if (!TT.empty()) return 0; 71 72 if (M.getEndianness() == Module::BigEndian && 73 M.getPointerSize() == Module::Pointer32) 74 return 10; // Weak match 75 else if (M.getEndianness() != Module::AnyEndianness || 76 M.getPointerSize() != Module::AnyPointerSize) 77 return 0; // Match for some other target 78 79 return getJITMatchQuality()/2; 80} 81 82unsigned PPC64TargetMachine::getModuleMatchQuality(const Module &M) { 83 // We strongly match "powerpc64-*". 84 std::string TT = M.getTargetTriple(); 85 if (TT.size() >= 10 && std::string(TT.begin(), TT.begin()+10) == "powerpc64-") 86 return 20; 87 88 if (M.getEndianness() == Module::BigEndian && 89 M.getPointerSize() == Module::Pointer64) 90 return 10; // Weak match 91 else if (M.getEndianness() != Module::AnyEndianness || 92 M.getPointerSize() != Module::AnyPointerSize) 93 return 0; // Match for some other target 94 95 return getJITMatchQuality()/2; 96} 97 98 99PPCTargetMachine::PPCTargetMachine(const Module &M, const std::string &FS, 100 bool is64Bit) 101 : Subtarget(*this, M, FS, is64Bit), 102 DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), 103 FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this), 104 InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) { 105 106 if (getRelocationModel() == Reloc::Default) { 107 if (Subtarget.isDarwin()) 108 setRelocationModel(Reloc::DynamicNoPIC); 109 else 110 setRelocationModel(Reloc::Static); 111 } 112} 113 114/// Override this for PowerPC. Tail merging happily breaks up instruction issue 115/// groups, which typically degrades performance. 116bool PPCTargetMachine::getEnableTailMergeDefault() const { return false; } 117 118PPC32TargetMachine::PPC32TargetMachine(const Module &M, const std::string &FS) 119 : PPCTargetMachine(M, FS, false) { 120} 121 122 123PPC64TargetMachine::PPC64TargetMachine(const Module &M, const std::string &FS) 124 : PPCTargetMachine(M, FS, true) { 125} 126 127 128//===----------------------------------------------------------------------===// 129// Pass Pipeline Configuration 130//===----------------------------------------------------------------------===// 131 132bool PPCTargetMachine::addInstSelector(PassManagerBase &PM, bool Fast) { 133 // Install an instruction selector. 134 PM.add(createPPCISelDag(*this)); 135 return false; 136} 137 138bool PPCTargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) { 139 140 // Must run branch selection immediately preceding the asm printer. 141 PM.add(createPPCBranchSelectionPass()); 142 return false; 143} 144 145bool PPCTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast, 146 raw_ostream &Out) { 147 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 148 if (AsmPrinterCtor) 149 PM.add(AsmPrinterCtor(Out, *this)); 150 151 return false; 152} 153 154bool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM, bool Fast, 155 bool DumpAsm, MachineCodeEmitter &MCE) { 156 // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64. 157 // FIXME: This should be moved to TargetJITInfo!! 158 if (Subtarget.isPPC64()) { 159 // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many 160 // instructions to materialize arbitrary global variable + function + 161 // constant pool addresses. 162 setRelocationModel(Reloc::PIC_); 163 // Temporary workaround for the inability of PPC64 JIT to handle jump 164 // tables. 165 DisableJumpTables = true; 166 } else { 167 setRelocationModel(Reloc::Static); 168 } 169 170 // Inform the subtarget that we are in JIT mode. FIXME: does this break macho 171 // writing? 172 Subtarget.SetJITMode(); 173 174 // Machine code emitter pass for PowerPC. 175 PM.add(createPPCCodeEmitterPass(*this, MCE)); 176 if (DumpAsm) { 177 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 178 if (AsmPrinterCtor) 179 PM.add(AsmPrinterCtor(errs(), *this)); 180 } 181 182 return false; 183} 184 185bool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, bool Fast, 186 bool DumpAsm, MachineCodeEmitter &MCE) { 187 // Machine code emitter pass for PowerPC. 188 PM.add(createPPCCodeEmitterPass(*this, MCE)); 189 if (DumpAsm) { 190 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 191 if (AsmPrinterCtor) 192 PM.add(AsmPrinterCtor(errs(), *this)); 193 } 194 195 return false; 196} 197