lib/Target/Alpha/AlphaTargetMachine.cpp

   1 //===-- AlphaTargetMachine.cpp - Define TargetMachine for Alpha -----------===//
   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 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "Alpha.h"
  14 #include "AlphaJITInfo.h"
  15 #include "AlphaTargetAsmInfo.h"
  16 #include "AlphaTargetMachine.h"
  17 #include "llvm/Module.h"
  18 #include "llvm/PassManager.h"
  19 #include "llvm/Target/TargetMachineRegistry.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 using namespace llvm;
  23
  24 // Register the targets
  25 static RegisterTarget<AlphaTargetMachine> X("alpha", "Alpha [experimental]");
  26
  27 // No assembler printer by default
  28 AlphaTargetMachine::AsmPrinterCtorFn AlphaTargetMachine::AsmPrinterCtor = 0;
  29
  30 // Force static initialization.
  31 extern "C" void LLVMInitializeAlphaTarget() { }
  32
  33 const TargetAsmInfo *AlphaTargetMachine::createTargetAsmInfo() const {
  34   return new AlphaTargetAsmInfo(*this);
  35 }
  36
  37 unsigned AlphaTargetMachine::getModuleMatchQuality(const Module &M) {
  38   // We strongly match "alpha*".
  39   std::string TT = M.getTargetTriple();
  40   if (TT.size() >= 5 && TT[0] == 'a' && TT[1] == 'l' && TT[2] == 'p' &&
  41       TT[3] == 'h' && TT[4] == 'a')
  42     return 20;
  43   // If the target triple is something non-alpha, we don't match.
  44   if (!TT.empty()) return 0;
  45
  46   if (M.getEndianness()  == Module::LittleEndian &&
  47       M.getPointerSize() == Module::Pointer64)
  48     return 10;                                   // Weak match
  49   else if (M.getEndianness() != Module::AnyEndianness ||
  50            M.getPointerSize() != Module::AnyPointerSize)
  51     return 0;                                    // Match for some other target
  52
  53   return getJITMatchQuality()/2;
  54 }
  55
  56 unsigned AlphaTargetMachine::getJITMatchQuality() {
  57 #ifdef __alpha
  58   return 10;
  59 #else
  60   return 0;
  61 #endif
  62 }
  63
  64 AlphaTargetMachine::AlphaTargetMachine(const Module &M, const std::string &FS)
  65   : DataLayout("e-f128:128:128"),
  66     FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0),
  67     JITInfo(*this),
  68     Subtarget(M, FS),
  69     TLInfo(*this) {
  70   setRelocationModel(Reloc::PIC_);
  71 }
  72
  73
  74 //===----------------------------------------------------------------------===//
  75 // Pass Pipeline Configuration
  76 //===----------------------------------------------------------------------===//
  77
  78 bool AlphaTargetMachine::addInstSelector(PassManagerBase &PM,
  79                                          CodeGenOpt::Level OptLevel) {
  80   PM.add(createAlphaISelDag(*this));
  81   return false;
  82 }
  83 bool AlphaTargetMachine::addPreEmitPass(PassManagerBase &PM,
  84                                         CodeGenOpt::Level OptLevel) {
  85   // Must run branch selection immediately preceding the asm printer
  86   PM.add(createAlphaBranchSelectionPass());
  87   return false;
  88 }
  89 bool AlphaTargetMachine::addAssemblyEmitter(PassManagerBase &PM,
  90                                             CodeGenOpt::Level OptLevel,
  91                                             bool Verbose,
  92                                             raw_ostream &Out) {
  93   PM.add(createAlphaLLRPPass(*this));
  94   // Output assembly language.
  95   assert(AsmPrinterCtor && "AsmPrinter was not linked in");
  96   if (AsmPrinterCtor)
  97     PM.add(AsmPrinterCtor(Out, *this, Verbose));
  98   return false;
  99 }
 100 bool AlphaTargetMachine::addCodeEmitter(PassManagerBase &PM,
 101                                         CodeGenOpt::Level OptLevel,
 102                                         bool DumpAsm, MachineCodeEmitter &MCE) {
 103   PM.add(createAlphaCodeEmitterPass(*this, MCE));
 104   if (DumpAsm) {
 105     assert(AsmPrinterCtor && "AsmPrinter was not linked in");
 106     if (AsmPrinterCtor)
 107       PM.add(AsmPrinterCtor(errs(), *this, true));
 108   }
 109   return false;
 110 }
 111 bool AlphaTargetMachine::addCodeEmitter(PassManagerBase &PM,
 112                                         CodeGenOpt::Level OptLevel,
 113                                         bool DumpAsm, JITCodeEmitter &JCE) {
 114   PM.add(createAlphaJITCodeEmitterPass(*this, JCE));
 115   if (DumpAsm) {
 116     assert(AsmPrinterCtor && "AsmPrinter was not linked in");
 117     if (AsmPrinterCtor)
 118       PM.add(AsmPrinterCtor(errs(), *this, true));
 119   }
 120   return false;
 121 }
 122 bool AlphaTargetMachine::addCodeEmitter(PassManagerBase &PM,
 123                                         CodeGenOpt::Level OptLevel,
 124                                         bool DumpAsm, ObjectCodeEmitter &OCE) {
 125   PM.add(createAlphaObjectCodeEmitterPass(*this, OCE));
 126   if (DumpAsm) {
 127     assert(AsmPrinterCtor && "AsmPrinter was not linked in");
 128     if (AsmPrinterCtor)
 129       PM.add(AsmPrinterCtor(errs(), *this, true));
 130   }
 131   return false;
 132 }
 133 bool AlphaTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
 134                                               CodeGenOpt::Level OptLevel,
 135                                               bool DumpAsm,
 136                                               MachineCodeEmitter &MCE) {
 137   return addCodeEmitter(PM, OptLevel, DumpAsm, MCE);
 138 }
 139 bool AlphaTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
 140                                               CodeGenOpt::Level OptLevel,
 141                                               bool DumpAsm,
 142                                               JITCodeEmitter &JCE) {
 143   return addCodeEmitter(PM, OptLevel, DumpAsm, JCE);
 144 }
 145 bool AlphaTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
 146                                               CodeGenOpt::Level OptLevel,
 147                                               bool DumpAsm,
 148                                               ObjectCodeEmitter &OCE) {
 149   return addCodeEmitter(PM, OptLevel, DumpAsm, OCE);
 150 }
 151