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