MipsTargetMachine.cpp revision 564fbf6aff8fb95646a1290078a37c2d4dbe629f 
1//===-- MipsTargetMachine.cpp - Define TargetMachine for Mips -------------===//
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// Implements the info about Mips target spec.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MipsTargetMachine.h"
15#include "Mips.h"
16#include "llvm/PassManager.h"
17#include "llvm/CodeGen/Passes.h"
18#include "llvm/Support/TargetRegistry.h"
19using namespace llvm;
20
21extern "C" void LLVMInitializeMipsTarget() {
22  // Register the target.
23  RegisterTargetMachine<MipsebTargetMachine> X(TheMipsTarget);
24  RegisterTargetMachine<MipselTargetMachine> Y(TheMipselTarget);
25  RegisterTargetMachine<Mips64ebTargetMachine> A(TheMips64Target);
26  RegisterTargetMachine<Mips64elTargetMachine> B(TheMips64elTarget);
27}
28
29// DataLayout --> Big-endian, 32-bit pointer/ABI/alignment
30// The stack is always 8 byte aligned
31// On function prologue, the stack is created by decrementing
32// its pointer. Once decremented, all references are done with positive
33// offset from the stack/frame pointer, using StackGrowsUp enables
34// an easier handling.
35// Using CodeModel::Large enables different CALL behavior.
36MipsTargetMachine::
37MipsTargetMachine(const Target &T, StringRef TT,
38                  StringRef CPU, StringRef FS, const TargetOptions &Options,
39                  Reloc::Model RM, CodeModel::Model CM,
40                  CodeGenOpt::Level OL,
41                  bool isLittle)
42  : LLVMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL),
43    Subtarget(TT, CPU, FS, isLittle),
44    DataLayout(isLittle ?
45               (Subtarget.isABI_N64() ?
46                "e-p:64:64:64-i8:8:32-i16:16:32-i64:64:64-f128:128:128-n32" :
47                "e-p:32:32:32-i8:8:32-i16:16:32-i64:64:64-n32") :
48               (Subtarget.isABI_N64() ?
49                "E-p:64:64:64-i8:8:32-i16:16:32-i64:64:64-f128:128:128-n32" :
50                "E-p:32:32:32-i8:8:32-i16:16:32-i64:64:64-n32")),
51    InstrInfo(*this),
52    FrameLowering(Subtarget),
53    TLInfo(*this), TSInfo(*this), JITInfo() {
54}
55
56void MipsebTargetMachine::anchor() { }
57
58MipsebTargetMachine::
59MipsebTargetMachine(const Target &T, StringRef TT,
60                    StringRef CPU, StringRef FS, const TargetOptions &Options,
61                    Reloc::Model RM, CodeModel::Model CM,
62                    CodeGenOpt::Level OL)
63  : MipsTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, false) {}
64
65void MipselTargetMachine::anchor() { }
66
67MipselTargetMachine::
68MipselTargetMachine(const Target &T, StringRef TT,
69                    StringRef CPU, StringRef FS, const TargetOptions &Options,
70                    Reloc::Model RM, CodeModel::Model CM,
71                    CodeGenOpt::Level OL)
72  : MipsTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
73
74void Mips64ebTargetMachine::anchor() { }
75
76Mips64ebTargetMachine::
77Mips64ebTargetMachine(const Target &T, StringRef TT,
78                      StringRef CPU, StringRef FS, const TargetOptions &Options,
79                      Reloc::Model RM, CodeModel::Model CM,
80                      CodeGenOpt::Level OL)
81  : MipsTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, false) {}
82
83void Mips64elTargetMachine::anchor() { }
84
85Mips64elTargetMachine::
86Mips64elTargetMachine(const Target &T, StringRef TT,
87                      StringRef CPU, StringRef FS, const TargetOptions &Options,
88                      Reloc::Model RM, CodeModel::Model CM,
89                      CodeGenOpt::Level OL)
90  : MipsTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
91
92namespace {
93/// Mips Code Generator Pass Configuration Options.
94class MipsPassConfig : public TargetPassConfig {
95public:
96  MipsPassConfig(MipsTargetMachine *TM, PassManagerBase &PM)
97    : TargetPassConfig(TM, PM) {}
98
99  MipsTargetMachine &getMipsTargetMachine() const {
100    return getTM<MipsTargetMachine>();
101  }
102
103  const MipsSubtarget &getMipsSubtarget() const {
104    return *getMipsTargetMachine().getSubtargetImpl();
105  }
106
107  virtual bool addInstSelector();
108  virtual bool addPreEmitPass();
109};
110} // namespace
111
112TargetPassConfig *MipsTargetMachine::createPassConfig(PassManagerBase &PM) {
113  return new MipsPassConfig(this, PM);
114}
115
116// Install an instruction selector pass using
117// the ISelDag to gen Mips code.
118bool MipsPassConfig::addInstSelector() {
119  addPass(createMipsISelDag(getMipsTargetMachine()));
120  return false;
121}
122
123// Implemented by targets that want to run passes immediately before
124// machine code is emitted. return true if -print-machineinstrs should
125// print out the code after the passes.
126bool MipsPassConfig::addPreEmitPass() {
127  MipsTargetMachine &TM = getMipsTargetMachine();
128  addPass(createMipsDelaySlotFillerPass(TM));
129
130  // NOTE: long branch has not been implemented for mips16.
131  if (TM.getSubtarget<MipsSubtarget>().hasStandardEncoding())
132    addPass(createMipsLongBranchPass(TM));
133
134  return true;
135}
136
137bool MipsTargetMachine::addCodeEmitter(PassManagerBase &PM,
138                                       JITCodeEmitter &JCE) {
139  // Machine code emitter pass for Mips.
140  PM.add(createMipsJITCodeEmitterPass(*this, JCE));
141  return false;
142}
143