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/FormattedStream.h"
22 using namespace llvm;
23 
24 // Register the targets
25 static RegisterTarget<PPC32TargetMachine>
26 X(ThePPC32Target, "ppc32", "PowerPC 32");
27 
28 static RegisterTarget<PPC64TargetMachine>
29 Y(ThePPC64Target, "ppc64", "PowerPC 64");
30 
31 // Force static initialization.
32 extern "C" void LLVMInitializePowerPCTarget() { }
33 
34 const TargetAsmInfo *PPCTargetMachine::createTargetAsmInfo() const {
35   if (Subtarget.isDarwin())
36     return new PPCDarwinTargetAsmInfo(*this);
37   else
38     return new PPCLinuxTargetAsmInfo(*this);
39 }
40 
41 PPCTargetMachine::PPCTargetMachine(const Target&T, const Module &M,
42                                    const std::string &FS, bool is64Bit)
43   : LLVMTargetMachine(T),
44     Subtarget(*this, M, FS, is64Bit),
45     DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this),
46     FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this),
47     InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) {
48 
49   if (getRelocationModel() == Reloc::Default) {
50     if (Subtarget.isDarwin())
51       setRelocationModel(Reloc::DynamicNoPIC);
52     else
53       setRelocationModel(Reloc::Static);
54   }
55 }
56 
57 /// Override this for PowerPC.  Tail merging happily breaks up instruction issue
58 /// groups, which typically degrades performance.
59 bool PPCTargetMachine::getEnableTailMergeDefault() const { return false; }
60 
61 PPC32TargetMachine::PPC32TargetMachine(const Target &T, const Module &M,
62                                        const std::string &FS)
63   : PPCTargetMachine(T, M, FS, false) {
64 }
65 
66 
67 PPC64TargetMachine::PPC64TargetMachine(const Target &T, const Module &M,
68                                        const std::string &FS)
69   : PPCTargetMachine(T, M, FS, true) {
70 }
71 
72 
73 //===----------------------------------------------------------------------===//
74 // Pass Pipeline Configuration
75 //===----------------------------------------------------------------------===//
76 
77 bool PPCTargetMachine::addInstSelector(PassManagerBase &PM,
78                                        CodeGenOpt::Level OptLevel) {
79   // Install an instruction selector.
80   PM.add(createPPCISelDag(*this));
81   return false;
82 }
83 
84 bool PPCTargetMachine::addPreEmitPass(PassManagerBase &PM,
85                                       CodeGenOpt::Level OptLevel) {
86   // Must run branch selection immediately preceding the asm printer.
87   PM.add(createPPCBranchSelectionPass());
88   return false;
89 }
90 
91 bool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM,
92                                       CodeGenOpt::Level OptLevel,
93                                       MachineCodeEmitter &MCE) {
94   // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64.
95   // FIXME: This should be moved to TargetJITInfo!!
96   if (Subtarget.isPPC64()) {
97     // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many
98     // instructions to materialize arbitrary global variable + function +
99     // constant pool addresses.
100     setRelocationModel(Reloc::PIC_);
101     // Temporary workaround for the inability of PPC64 JIT to handle jump
102     // tables.
103     DisableJumpTables = true;
104   } else {
105     setRelocationModel(Reloc::Static);
106   }
107 
108   // Inform the subtarget that we are in JIT mode.  FIXME: does this break macho
109   // writing?
110   Subtarget.SetJITMode();
111 
112   // Machine code emitter pass for PowerPC.
113   PM.add(createPPCCodeEmitterPass(*this, MCE));
114 
115   return false;
116 }
117 
118 bool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM,
119                                       CodeGenOpt::Level OptLevel,
120                                       JITCodeEmitter &JCE) {
121   // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64.
122   // FIXME: This should be moved to TargetJITInfo!!
123   if (Subtarget.isPPC64()) {
124     // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many
125     // instructions to materialize arbitrary global variable + function +
126     // constant pool addresses.
127     setRelocationModel(Reloc::PIC_);
128     // Temporary workaround for the inability of PPC64 JIT to handle jump
129     // tables.
130     DisableJumpTables = true;
131   } else {
132     setRelocationModel(Reloc::Static);
133   }
134 
135   // Inform the subtarget that we are in JIT mode.  FIXME: does this break macho
136   // writing?
137   Subtarget.SetJITMode();
138 
139   // Machine code emitter pass for PowerPC.
140   PM.add(createPPCJITCodeEmitterPass(*this, JCE));
141 
142   return false;
143 }
144 
145 bool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM,
146                                       CodeGenOpt::Level OptLevel,
147                                       ObjectCodeEmitter &OCE) {
148   // The JIT should use the static relocation model in ppc32 mode, PIC in ppc64.
149   // FIXME: This should be moved to TargetJITInfo!!
150   if (Subtarget.isPPC64()) {
151     // We use PIC codegen in ppc64 mode, because otherwise we'd have to use many
152     // instructions to materialize arbitrary global variable + function +
153     // constant pool addresses.
154     setRelocationModel(Reloc::PIC_);
155     // Temporary workaround for the inability of PPC64 JIT to handle jump
156     // tables.
157     DisableJumpTables = true;
158   } else {
159     setRelocationModel(Reloc::Static);
160   }
161 
162   // Inform the subtarget that we are in JIT mode.  FIXME: does this break macho
163   // writing?
164   Subtarget.SetJITMode();
165 
166   // Machine code emitter pass for PowerPC.
167   PM.add(createPPCObjectCodeEmitterPass(*this, OCE));
168 
169   return false;
170 }
171 
172 bool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
173                                             CodeGenOpt::Level OptLevel,
174                                             MachineCodeEmitter &MCE) {
175   // Machine code emitter pass for PowerPC.
176   PM.add(createPPCCodeEmitterPass(*this, MCE));
177   return false;
178 }
179 
180 bool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
181                                             CodeGenOpt::Level OptLevel,
182                                             JITCodeEmitter &JCE) {
183   // Machine code emitter pass for PowerPC.
184   PM.add(createPPCJITCodeEmitterPass(*this, JCE));
185   return false;
186 }
187 
188 bool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
189                                             CodeGenOpt::Level OptLevel,
190                                             ObjectCodeEmitter &OCE) {
191   // Machine code emitter pass for PowerPC.
192   PM.add(createPPCObjectCodeEmitterPass(*this, OCE));
193   return false;
194 }
195 
196 
197