1 //===-- X86TargetMachine.cpp - Define TargetMachine for the X86 -----------===// 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 defines the X86 specific subclass of TargetMachine. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "X86TargetAsmInfo.h" 15 #include "X86TargetMachine.h" 16 #include "X86.h" 17 #include "llvm/Module.h" 18 #include "llvm/PassManager.h" 19 #include "llvm/CodeGen/MachineFunction.h" 20 #include "llvm/CodeGen/Passes.h" 21 #include "llvm/Support/raw_ostream.h" 22 #include "llvm/Target/TargetOptions.h" 23 #include "llvm/Target/TargetMachineRegistry.h" 24 using namespace llvm; 25 26 /// X86TargetMachineModule - Note that this is used on hosts that cannot link 27 /// in a library unless there are references into the library. In particular, 28 /// it seems that it is not possible to get things to work on Win32 without 29 /// this. Though it is unused, do not remove it. 30 extern "C" int X86TargetMachineModule; 31 int X86TargetMachineModule = 0; 32 33 // Register the target. 34 static RegisterTarget<X86_32TargetMachine> 35 X("x86", "32-bit X86: Pentium-Pro and above"); 36 static RegisterTarget<X86_64TargetMachine> 37 Y("x86-64", "64-bit X86: EM64T and AMD64"); 38 39 // Force static initialization. 40 extern "C" void LLVMInitializeX86Target() { } 41 42 // No assembler printer by default 43 X86TargetMachine::AsmPrinterCtorFn X86TargetMachine::AsmPrinterCtor = 0; 44 45 const TargetAsmInfo *X86TargetMachine::createTargetAsmInfo() const { 46 if (Subtarget.isFlavorIntel()) 47 return new X86WinTargetAsmInfo(*this); 48 else 49 switch (Subtarget.TargetType) { 50 case X86Subtarget::isDarwin: 51 return new X86DarwinTargetAsmInfo(*this); 52 case X86Subtarget::isELF: 53 return new X86ELFTargetAsmInfo(*this); 54 case X86Subtarget::isMingw: 55 case X86Subtarget::isCygwin: 56 return new X86COFFTargetAsmInfo(*this); 57 case X86Subtarget::isWindows: 58 return new X86WinTargetAsmInfo(*this); 59 default: 60 return new X86GenericTargetAsmInfo(*this); 61 } 62 } 63 64 unsigned X86_32TargetMachine::getJITMatchQuality() { 65 #if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86) 66 return 10; 67 #endif 68 return 0; 69 } 70 71 unsigned X86_64TargetMachine::getJITMatchQuality() { 72 #if defined(__x86_64__) || defined(_M_AMD64) 73 return 10; 74 #endif 75 return 0; 76 } 77 78 unsigned X86_32TargetMachine::getModuleMatchQuality(const Module &M) { 79 // We strongly match "i[3-9]86-*". 80 std::string TT = M.getTargetTriple(); 81 if (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' && 82 TT[4] == '-' && TT[1] - '3' < 6) 83 return 20; 84 // If the target triple is something non-X86, we don't match. 85 if (!TT.empty()) return 0; 86 87 if (M.getEndianness() == Module::LittleEndian && 88 M.getPointerSize() == Module::Pointer32) 89 return 10; // Weak match 90 else if (M.getEndianness() != Module::AnyEndianness || 91 M.getPointerSize() != Module::AnyPointerSize) 92 return 0; // Match for some other target 93 94 return getJITMatchQuality()/2; 95 } 96 97 unsigned X86_64TargetMachine::getModuleMatchQuality(const Module &M) { 98 // We strongly match "x86_64-*". 99 std::string TT = M.getTargetTriple(); 100 if (TT.size() >= 7 && TT[0] == 'x' && TT[1] == '8' && TT[2] == '6' && 101 TT[3] == '_' && TT[4] == '6' && TT[5] == '4' && TT[6] == '-') 102 return 20; 103 104 // We strongly match "amd64-*". 105 if (TT.size() >= 6 && TT[0] == 'a' && TT[1] == 'm' && TT[2] == 'd' && 106 TT[3] == '6' && TT[4] == '4' && TT[5] == '-') 107 return 20; 108 109 // If the target triple is something non-X86-64, we don't match. 110 if (!TT.empty()) return 0; 111 112 if (M.getEndianness() == Module::LittleEndian && 113 M.getPointerSize() == Module::Pointer64) 114 return 10; // Weak match 115 else if (M.getEndianness() != Module::AnyEndianness || 116 M.getPointerSize() != Module::AnyPointerSize) 117 return 0; // Match for some other target 118 119 return getJITMatchQuality()/2; 120 } 121 122 X86_32TargetMachine::X86_32TargetMachine(const Module &M, const std::string &FS) 123 : X86TargetMachine(M, FS, false) { 124 } 125 126 127 X86_64TargetMachine::X86_64TargetMachine(const Module &M, const std::string &FS) 128 : X86TargetMachine(M, FS, true) { 129 } 130 131 /// X86TargetMachine ctor - Create an ILP32 architecture model 132 /// 133 X86TargetMachine::X86TargetMachine(const Module &M, const std::string &FS, 134 bool is64Bit) 135 : Subtarget(M, FS, is64Bit), 136 DataLayout(Subtarget.getDataLayout()), 137 FrameInfo(TargetFrameInfo::StackGrowsDown, 138 Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4), 139 InstrInfo(*this), JITInfo(*this), TLInfo(*this), ELFWriterInfo(*this) { 140 DefRelocModel = getRelocationModel(); 141 // FIXME: Correctly select PIC model for Win64 stuff 142 if (getRelocationModel() == Reloc::Default) { 143 if (Subtarget.isTargetDarwin() || 144 (Subtarget.isTargetCygMing() && !Subtarget.isTargetWin64())) 145 setRelocationModel(Reloc::DynamicNoPIC); 146 else 147 setRelocationModel(Reloc::Static); 148 } 149 150 // ELF doesn't have a distinct dynamic-no-PIC model. Dynamic-no-PIC 151 // is defined as a model for code which may be used in static or 152 // dynamic executables but not necessarily a shared library. On ELF 153 // implement this by using the Static model. 154 if (Subtarget.isTargetELF() && 155 getRelocationModel() == Reloc::DynamicNoPIC) 156 setRelocationModel(Reloc::Static); 157 158 if (Subtarget.is64Bit()) { 159 // No DynamicNoPIC support under X86-64. 160 if (getRelocationModel() == Reloc::DynamicNoPIC) 161 setRelocationModel(Reloc::PIC_); 162 // Default X86-64 code model is small. 163 if (getCodeModel() == CodeModel::Default) 164 setCodeModel(CodeModel::Small); 165 } 166 167 if (Subtarget.isTargetCygMing()) 168 Subtarget.setPICStyle(PICStyles::WinPIC); 169 else if (Subtarget.isTargetDarwin()) { 170 if (Subtarget.is64Bit()) 171 Subtarget.setPICStyle(PICStyles::RIPRel); 172 else 173 Subtarget.setPICStyle(PICStyles::Stub); 174 } else if (Subtarget.isTargetELF()) { 175 if (Subtarget.is64Bit()) 176 Subtarget.setPICStyle(PICStyles::RIPRel); 177 else 178 Subtarget.setPICStyle(PICStyles::GOT); 179 } 180 } 181 182 //===----------------------------------------------------------------------===// 183 // Pass Pipeline Configuration 184 //===----------------------------------------------------------------------===// 185 186 bool X86TargetMachine::addInstSelector(PassManagerBase &PM, 187 CodeGenOpt::Level OptLevel) { 188 // Install an instruction selector. 189 PM.add(createX86ISelDag(*this, OptLevel)); 190 191 // If we're using Fast-ISel, clean up the mess. 192 if (EnableFastISel) 193 PM.add(createDeadMachineInstructionElimPass()); 194 195 // Install a pass to insert x87 FP_REG_KILL instructions, as needed. 196 PM.add(createX87FPRegKillInserterPass()); 197 198 return false; 199 } 200 201 bool X86TargetMachine::addPreRegAlloc(PassManagerBase &PM, 202 CodeGenOpt::Level OptLevel) { 203 // Calculate and set max stack object alignment early, so we can decide 204 // whether we will need stack realignment (and thus FP). 205 PM.add(createX86MaxStackAlignmentCalculatorPass()); 206 return false; // -print-machineinstr shouldn't print after this. 207 } 208 209 bool X86TargetMachine::addPostRegAlloc(PassManagerBase &PM, 210 CodeGenOpt::Level OptLevel) { 211 PM.add(createX86FloatingPointStackifierPass()); 212 return true; // -print-machineinstr should print after this. 213 } 214 215 bool X86TargetMachine::addAssemblyEmitter(PassManagerBase &PM, 216 CodeGenOpt::Level OptLevel, 217 bool Verbose, 218 raw_ostream &Out) { 219 // FIXME: Move this somewhere else! 220 // On Darwin, override 64-bit static relocation to pic_ since the 221 // assembler doesn't support it. 222 if (DefRelocModel == Reloc::Static && 223 Subtarget.isTargetDarwin() && Subtarget.is64Bit() && 224 getCodeModel() == CodeModel::Small) 225 setRelocationModel(Reloc::PIC_); 226 227 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 228 if (AsmPrinterCtor) 229 PM.add(AsmPrinterCtor(Out, *this, Verbose)); 230 return false; 231 } 232 233 bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM, 234 CodeGenOpt::Level OptLevel, 235 bool DumpAsm, 236 MachineCodeEmitter &MCE) { 237 // FIXME: Move this to TargetJITInfo! 238 // On Darwin, do not override 64-bit setting made in X86TargetMachine(). 239 if (DefRelocModel == Reloc::Default && 240 (!Subtarget.isTargetDarwin() || !Subtarget.is64Bit())) 241 setRelocationModel(Reloc::Static); 242 243 // 64-bit JIT places everything in the same buffer except external functions. 244 // On Darwin, use small code model but hack the call instruction for 245 // externals. Elsewhere, do not assume globals are in the lower 4G. 246 if (Subtarget.is64Bit()) { 247 if (Subtarget.isTargetDarwin()) 248 setCodeModel(CodeModel::Small); 249 else 250 setCodeModel(CodeModel::Large); 251 } 252 253 PM.add(createX86CodeEmitterPass(*this, MCE)); 254 if (DumpAsm) { 255 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 256 if (AsmPrinterCtor) 257 PM.add(AsmPrinterCtor(errs(), *this, true)); 258 } 259 260 return false; 261 } 262 263 bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM, 264 CodeGenOpt::Level OptLevel, 265 bool DumpAsm, 266 JITCodeEmitter &JCE) { 267 // FIXME: Move this to TargetJITInfo! 268 // On Darwin, do not override 64-bit setting made in X86TargetMachine(). 269 if (DefRelocModel == Reloc::Default && 270 (!Subtarget.isTargetDarwin() || !Subtarget.is64Bit())) 271 setRelocationModel(Reloc::Static); 272 273 // 64-bit JIT places everything in the same buffer except external functions. 274 // On Darwin, use small code model but hack the call instruction for 275 // externals. Elsewhere, do not assume globals are in the lower 4G. 276 if (Subtarget.is64Bit()) { 277 if (Subtarget.isTargetDarwin()) 278 setCodeModel(CodeModel::Small); 279 else 280 setCodeModel(CodeModel::Large); 281 } 282 283 PM.add(createX86JITCodeEmitterPass(*this, JCE)); 284 if (DumpAsm) { 285 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 286 if (AsmPrinterCtor) 287 PM.add(AsmPrinterCtor(errs(), *this, true)); 288 } 289 290 return false; 291 } 292 293 bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM, 294 CodeGenOpt::Level OptLevel, 295 bool DumpAsm, 296 ObjectCodeEmitter &OCE) { 297 // FIXME: Move this to TargetJITInfo! 298 // On Darwin, do not override 64-bit setting made in X86TargetMachine(). 299 if (DefRelocModel == Reloc::Default && 300 (!Subtarget.isTargetDarwin() || !Subtarget.is64Bit())) 301 setRelocationModel(Reloc::Static); 302 303 // 64-bit JIT places everything in the same buffer except external functions. 304 // On Darwin, use small code model but hack the call instruction for 305 // externals. Elsewhere, do not assume globals are in the lower 4G. 306 if (Subtarget.is64Bit()) { 307 if (Subtarget.isTargetDarwin()) 308 setCodeModel(CodeModel::Small); 309 else 310 setCodeModel(CodeModel::Large); 311 } 312 313 PM.add(createX86ObjectCodeEmitterPass(*this, OCE)); 314 if (DumpAsm) { 315 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 316 if (AsmPrinterCtor) 317 PM.add(AsmPrinterCtor(errs(), *this, true)); 318 } 319 320 return false; 321 } 322 323 bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, 324 CodeGenOpt::Level OptLevel, 325 bool DumpAsm, 326 MachineCodeEmitter &MCE) { 327 PM.add(createX86CodeEmitterPass(*this, MCE)); 328 if (DumpAsm) { 329 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 330 if (AsmPrinterCtor) 331 PM.add(AsmPrinterCtor(errs(), *this, true)); 332 } 333 334 return false; 335 } 336 337 bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, 338 CodeGenOpt::Level OptLevel, 339 bool DumpAsm, 340 JITCodeEmitter &JCE) { 341 PM.add(createX86JITCodeEmitterPass(*this, JCE)); 342 if (DumpAsm) { 343 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 344 if (AsmPrinterCtor) 345 PM.add(AsmPrinterCtor(errs(), *this, true)); 346 } 347 348 return false; 349 } 350 351 bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, 352 CodeGenOpt::Level OptLevel, 353 bool DumpAsm, 354 ObjectCodeEmitter &OCE) { 355 PM.add(createX86ObjectCodeEmitterPass(*this, OCE)); 356 if (DumpAsm) { 357 assert(AsmPrinterCtor && "AsmPrinter was not linked in"); 358 if (AsmPrinterCtor) 359 PM.add(AsmPrinterCtor(errs(), *this, true)); 360 } 361 362 return false; 363 } 364