X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FSparc%2FSparcTargetMachine.cpp;h=cabfce118aa11ae44e1a8a4f326f37792071bd80;hb=2e9d5f912a9841d3685ba0241abe1131943fed29;hp=8059853bc21f5541ab181b077d824624a5a51633;hpb=b3a86a6d49234475a7f697648a0fb23e51cf64a2;p=oota-llvm.git diff --git a/lib/Target/Sparc/SparcTargetMachine.cpp b/lib/Target/Sparc/SparcTargetMachine.cpp index 8059853bc21..cabfce118aa 100644 --- a/lib/Target/Sparc/SparcTargetMachine.cpp +++ b/lib/Target/Sparc/SparcTargetMachine.cpp @@ -1,50 +1,59 @@ -//===-- SparcV8TargetMachine.cpp - Define TargetMachine for SparcV8 -------===// -// +//===-- SparcTargetMachine.cpp - Define TargetMachine for Sparc -----------===// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// -// +// // //===----------------------------------------------------------------------===// -#include "SparcV8TargetMachine.h" -#include "SparcV8.h" -#include "llvm/Assembly/PrintModulePass.h" +#include "SparcTargetAsmInfo.h" +#include "SparcTargetMachine.h" +#include "Sparc.h" #include "llvm/Module.h" #include "llvm/PassManager.h" -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/Passes.h" -#include "llvm/Target/TargetOptions.h" #include "llvm/Target/TargetMachineRegistry.h" -#include "llvm/Transforms/Scalar.h" -#include using namespace llvm; -namespace { - // Register the target. - RegisterTarget X("sparcv8"," SPARC V8 (experimental)"); +/// SparcTargetMachineModule - Note that this is used on hosts that +/// cannot link in a library unless there are references into the +/// library. In particular, it seems that it is not possible to get +/// things to work on Win32 without this. Though it is unused, do not +/// remove it. +extern "C" int SparcTargetMachineModule; +int SparcTargetMachineModule = 0; + +// Register the target. +static RegisterTarget X("sparc", "SPARC"); + +const TargetAsmInfo *SparcTargetMachine::createTargetAsmInfo() const { + // FIXME: Handle Solaris subtarget someday :) + return new SparcELFTargetAsmInfo(*this); } -/// SparcV8TargetMachine ctor - Create an ILP32 architecture model +/// SparcTargetMachine ctor - Create an ILP32 architecture model /// -SparcV8TargetMachine::SparcV8TargetMachine(const Module &M, - IntrinsicLowering *IL) - : TargetMachine("SparcV8", IL, false, 4, 4), - FrameInfo(TargetFrameInfo::StackGrowsDown, 8, 0), JITInfo(*this) { +SparcTargetMachine::SparcTargetMachine(const Module &M, const std::string &FS) + : DataLayout("E-p:32:32-f128:128:128"), + Subtarget(M, FS), TLInfo(*this), InstrInfo(Subtarget), + FrameInfo(TargetFrameInfo::StackGrowsDown, 8, 0) { } -unsigned SparcV8TargetMachine::getJITMatchQuality() { - return 0; // No JIT yet. -} +unsigned SparcTargetMachine::getModuleMatchQuality(const Module &M) { + std::string TT = M.getTargetTriple(); + if (TT.size() >= 6 && std::string(TT.begin(), TT.begin()+6) == "sparc-") + return 20; + + // If the target triple is something non-sparc, we don't match. + if (!TT.empty()) return 0; -unsigned SparcV8TargetMachine::getModuleMatchQuality(const Module &M) { if (M.getEndianness() == Module::BigEndian && M.getPointerSize() == Module::Pointer32) #ifdef __sparc__ - return 20; // BE/32 ==> Prefer sparcv8 on sparc + return 20; // BE/32 ==> Prefer sparc on sparc #else return 5; // BE/32 ==> Prefer ppc elsewhere #endif @@ -52,113 +61,33 @@ unsigned SparcV8TargetMachine::getModuleMatchQuality(const Module &M) { M.getPointerSize() != Module::AnyPointerSize) return 0; // Match for some other target - return getJITMatchQuality()/2; +#if defined(__sparc__) + return 10; +#else + return 0; +#endif } -/// addPassesToEmitAssembly - Add passes to the specified pass manager -/// to implement a static compiler for this target. -/// -bool SparcV8TargetMachine::addPassesToEmitAssembly(PassManager &PM, - std::ostream &Out) { - // FIXME: Implement efficient support for garbage collection intrinsics. - PM.add(createLowerGCPass()); - - // Replace malloc and free instructions with library calls. - PM.add(createLowerAllocationsPass()); - - // FIXME: implement the switch instruction in the instruction selector. - PM.add(createLowerSwitchPass()); - - // FIXME: implement the invoke/unwind instructions! - PM.add(createLowerInvokePass()); - - PM.add(createLowerConstantExpressionsPass()); - - // Make sure that no unreachable blocks are instruction selected. - PM.add(createUnreachableBlockEliminationPass()); - - // FIXME: implement the select instruction in the instruction selector. - PM.add(createLowerSelectPass()); - - // Print LLVM code input to instruction selector: - if (PrintMachineCode) - PM.add(new PrintModulePass()); - - PM.add(createSparcV8SimpleInstructionSelector(*this)); - - // Print machine instructions as they were initially generated. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); - - PM.add(createRegisterAllocator()); - PM.add(createPrologEpilogCodeInserter()); - - // Print machine instructions after register allocation and prolog/epilog - // insertion. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); - - PM.add(createSparcV8FPMoverPass(*this)); - PM.add(createSparcV8DelaySlotFillerPass(*this)); - - // Print machine instructions after filling delay slots. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); - - // Output assembly language. - PM.add(createSparcV8CodePrinterPass(Out, *this)); - - // Delete the MachineInstrs we generated, since they're no longer needed. - PM.add(createMachineCodeDeleter()); +bool SparcTargetMachine::addInstSelector(PassManagerBase &PM, + unsigned OptLevel) { + PM.add(createSparcISelDag(*this)); return false; } -/// addPassesToJITCompile - Add passes to the specified pass manager to -/// implement a fast dynamic compiler for this target. -/// -void SparcV8JITInfo::addPassesToJITCompile(FunctionPassManager &PM) { - // FIXME: Implement efficient support for garbage collection intrinsics. - PM.add(createLowerGCPass()); - - // Replace malloc and free instructions with library calls. - PM.add(createLowerAllocationsPass()); - - // FIXME: implement the switch instruction in the instruction selector. - PM.add(createLowerSwitchPass()); - - // FIXME: implement the invoke/unwind instructions! - PM.add(createLowerInvokePass()); - - PM.add(createLowerConstantExpressionsPass()); - - // Make sure that no unreachable blocks are instruction selected. - PM.add(createUnreachableBlockEliminationPass()); - - // FIXME: implement the select instruction in the instruction selector. - PM.add(createLowerSelectPass()); - - // Print LLVM code input to instruction selector: - if (PrintMachineCode) - PM.add(new PrintFunctionPass()); - - PM.add(createSparcV8SimpleInstructionSelector(TM)); - - // Print machine instructions as they were initially generated. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); - - PM.add(createRegisterAllocator()); - PM.add(createPrologEpilogCodeInserter()); - - // Print machine instructions after register allocation and prolog/epilog - // insertion. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); - - PM.add(createSparcV8FPMoverPass(TM)); - PM.add(createSparcV8DelaySlotFillerPass(TM)); +/// addPreEmitPass - This pass may be implemented by targets that want to run +/// passes immediately before machine code is emitted. This should return +/// true if -print-machineinstrs should print out the code after the passes. +bool SparcTargetMachine::addPreEmitPass(PassManagerBase &PM, unsigned OptLevel){ + PM.add(createSparcFPMoverPass(*this)); + PM.add(createSparcDelaySlotFillerPass(*this)); + return true; +} - // Print machine instructions after filling delay slots. - if (PrintMachineCode) - PM.add(createMachineFunctionPrinterPass(&std::cerr)); +bool SparcTargetMachine::addAssemblyEmitter(PassManagerBase &PM, + unsigned OptLevel, + bool Verbose, + raw_ostream &Out) { + // Output assembly language. + PM.add(createSparcCodePrinterPass(Out, *this, OptLevel, Verbose)); + return false; }