LLVM API Documentation

ARMTargetMachine.cpp

Go to the documentation of this file.
00001 //===-- ARMTargetMachine.cpp - Define TargetMachine for ARM ---------------===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 //
00011 //===----------------------------------------------------------------------===//
00012 
00013 #include "ARMTargetMachine.h"
00014 #include "ARMTargetAsmInfo.h"
00015 #include "ARMFrameInfo.h"
00016 #include "ARM.h"
00017 #include "llvm/PassManager.h"
00018 #include "llvm/CodeGen/Passes.h"
00019 #include "llvm/Support/CommandLine.h"
00020 #include "llvm/Support/FormattedStream.h"
00021 #include "llvm/Target/TargetOptions.h"
00022 #include "llvm/Target/TargetRegistry.h"
00023 using namespace llvm;
00024 
00025 static cl::opt<bool> DisableLdStOpti("disable-arm-loadstore-opti", cl::Hidden,
00026                               cl::desc("Disable load store optimization pass"));
00027 static cl::opt<bool> DisableIfConversion("disable-arm-if-conversion",cl::Hidden,
00028                               cl::desc("Disable if-conversion pass"));
00029 
00030 static const TargetAsmInfo *createTargetAsmInfo(const Target &T,
00031                                                 const StringRef &TT) {
00032   Triple TheTriple(TT);
00033   switch (TheTriple.getOS()) {
00034   case Triple::Darwin:
00035     return new ARMDarwinTargetAsmInfo();
00036   default:
00037     return new ARMELFTargetAsmInfo();
00038   }
00039 }
00040 
00041 
00042 extern "C" void LLVMInitializeARMTarget() {
00043   // Register the target.
00044   RegisterTargetMachine<ARMTargetMachine> X(TheARMTarget);
00045   RegisterTargetMachine<ThumbTargetMachine> Y(TheThumbTarget);
00046   
00047   // Register the target asm info.
00048   RegisterAsmInfoFn A(TheARMTarget, createTargetAsmInfo);
00049   RegisterAsmInfoFn B(TheThumbTarget, createTargetAsmInfo);
00050 }
00051 
00052 /// TargetMachine ctor - Create an ARM architecture model.
00053 ///
00054 ARMBaseTargetMachine::ARMBaseTargetMachine(const Target &T,
00055                                            const std::string &TT,
00056                                            const std::string &FS,
00057                                            bool isThumb)
00058   : LLVMTargetMachine(T, TT),
00059     Subtarget(TT, FS, isThumb),
00060     FrameInfo(Subtarget),
00061     JITInfo(),
00062     InstrItins(Subtarget.getInstrItineraryData()) {
00063   DefRelocModel = getRelocationModel();
00064 }
00065 
00066 ARMTargetMachine::ARMTargetMachine(const Target &T, const std::string &TT,
00067                                    const std::string &FS)
00068   : ARMBaseTargetMachine(T, TT, FS, false), InstrInfo(Subtarget),
00069     DataLayout(Subtarget.isAPCS_ABI() ?
00070                std::string("e-p:32:32-f64:32:32-i64:32:32") :
00071                std::string("e-p:32:32-f64:64:64-i64:64:64")),
00072     TLInfo(*this) {
00073 }
00074 
00075 ThumbTargetMachine::ThumbTargetMachine(const Target &T, const std::string &TT,
00076                                        const std::string &FS)
00077   : ARMBaseTargetMachine(T, TT, FS, true),
00078     InstrInfo(Subtarget.hasThumb2()
00079               ? ((ARMBaseInstrInfo*)new Thumb2InstrInfo(Subtarget))
00080               : ((ARMBaseInstrInfo*)new Thumb1InstrInfo(Subtarget))),
00081     DataLayout(Subtarget.isAPCS_ABI() ?
00082                std::string("e-p:32:32-f64:32:32-i64:32:32-"
00083                            "i16:16:32-i8:8:32-i1:8:32-a:0:32") :
00084                std::string("e-p:32:32-f64:64:64-i64:64:64-"
00085                            "i16:16:32-i8:8:32-i1:8:32-a:0:32")),
00086     TLInfo(*this) {
00087 }
00088 
00089 
00090 
00091 // Pass Pipeline Configuration
00092 bool ARMBaseTargetMachine::addInstSelector(PassManagerBase &PM,
00093                                            CodeGenOpt::Level OptLevel) {
00094   PM.add(createARMISelDag(*this));
00095   return false;
00096 }
00097 
00098 bool ARMBaseTargetMachine::addPreRegAlloc(PassManagerBase &PM,
00099                                           CodeGenOpt::Level OptLevel) {
00100   if (Subtarget.hasNEON())
00101     PM.add(createNEONPreAllocPass());
00102 
00103   // FIXME: temporarily disabling load / store optimization pass for Thumb mode.
00104   if (OptLevel != CodeGenOpt::None && !DisableLdStOpti && !Subtarget.isThumb())
00105     PM.add(createARMLoadStoreOptimizationPass(true));
00106   return true;
00107 }
00108 
00109 bool ARMBaseTargetMachine::addPreEmitPass(PassManagerBase &PM,
00110                                           CodeGenOpt::Level OptLevel) {
00111   // FIXME: temporarily disabling load / store optimization pass for Thumb1 mode.
00112   if (OptLevel != CodeGenOpt::None && !DisableLdStOpti &&
00113       !Subtarget.isThumb1Only())
00114     PM.add(createARMLoadStoreOptimizationPass());
00115 
00116   if (OptLevel != CodeGenOpt::None &&
00117       !DisableIfConversion && !Subtarget.isThumb1Only())
00118     PM.add(createIfConverterPass());
00119 
00120   if (Subtarget.isThumb2()) {
00121     PM.add(createThumb2ITBlockPass());
00122     PM.add(createThumb2SizeReductionPass());
00123   }
00124 
00125   PM.add(createARMConstantIslandPass());
00126   return true;
00127 }
00128 
00129 bool ARMBaseTargetMachine::addCodeEmitter(PassManagerBase &PM,
00130                                           CodeGenOpt::Level OptLevel,
00131                                           MachineCodeEmitter &MCE) {
00132   // FIXME: Move this to TargetJITInfo!
00133   if (DefRelocModel == Reloc::Default)
00134     setRelocationModel(Reloc::Static);
00135 
00136   // Machine code emitter pass for ARM.
00137   PM.add(createARMCodeEmitterPass(*this, MCE));
00138   return false;
00139 }
00140 
00141 bool ARMBaseTargetMachine::addCodeEmitter(PassManagerBase &PM,
00142                                           CodeGenOpt::Level OptLevel,
00143                                           JITCodeEmitter &JCE) {
00144   // FIXME: Move this to TargetJITInfo!
00145   if (DefRelocModel == Reloc::Default)
00146     setRelocationModel(Reloc::Static);
00147 
00148   // Machine code emitter pass for ARM.
00149   PM.add(createARMJITCodeEmitterPass(*this, JCE));
00150   return false;
00151 }
00152 
00153 bool ARMBaseTargetMachine::addCodeEmitter(PassManagerBase &PM,
00154                                           CodeGenOpt::Level OptLevel,
00155                                           ObjectCodeEmitter &OCE) {
00156   // FIXME: Move this to TargetJITInfo!
00157   if (DefRelocModel == Reloc::Default)
00158     setRelocationModel(Reloc::Static);
00159 
00160   // Machine code emitter pass for ARM.
00161   PM.add(createARMObjectCodeEmitterPass(*this, OCE));
00162   return false;
00163 }
00164 
00165 bool ARMBaseTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
00166                                                 CodeGenOpt::Level OptLevel,
00167                                                 MachineCodeEmitter &MCE) {
00168   // Machine code emitter pass for ARM.
00169   PM.add(createARMCodeEmitterPass(*this, MCE));
00170   return false;
00171 }
00172 
00173 bool ARMBaseTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
00174                                                 CodeGenOpt::Level OptLevel,
00175                                                 JITCodeEmitter &JCE) {
00176   // Machine code emitter pass for ARM.
00177   PM.add(createARMJITCodeEmitterPass(*this, JCE));
00178   return false;
00179 }
00180 
00181 bool ARMBaseTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
00182                                             CodeGenOpt::Level OptLevel,
00183                                             ObjectCodeEmitter &OCE) {
00184   // Machine code emitter pass for ARM.
00185   PM.add(createARMObjectCodeEmitterPass(*this, OCE));
00186   return false;
00187 }
00188