#include "Alpha.h"
#include "AlphaInstrInfo.h"
+#include "AlphaTargetMachine.h"
#include "llvm/Module.h"
#include "llvm/Type.h"
#include "llvm/Assembly/Writer.h"
using namespace llvm;
-namespace llvm {
- extern cl::opt<bool> EnableAlphaFTOI;
- extern cl::opt<bool> EnableAlphaCT;
-}
-
namespace {
Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
bool AlphaAsmPrinter::doInitialization(Module &M)
{
AsmPrinter::doInitialization(M);
- if(EnableAlphaFTOI || EnableAlphaCT)
+ if(TM.getSubtarget<AlphaSubtarget>().hasF2I()
+ || TM.getSubtarget<AlphaSubtarget>().hasCT())
O << "\t.arch ev6\n";
else
O << "\t.arch ev56\n";
namespace llvm {
extern cl::opt<bool> EnableAlphaIDIV;
- extern cl::opt<bool> EnableAlphaFTOI;
- extern cl::opt<bool> EnableAlphaCT;
extern cl::opt<bool> EnableAlphaCount;
extern cl::opt<bool> EnableAlphaLSMark;
}
setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand);
- if (!EnableAlphaCT) {
+ if (!TM.getSubtarget<AlphaSubtarget>().hasCT()) {
setOperationAction(ISD::CTPOP , MVT::i64 , Expand);
setOperationAction(ISD::CTTZ , MVT::i64 , Expand);
setOperationAction(ISD::CTLZ , MVT::i64 , Expand);
#include "Alpha.h"
#include "AlphaRegisterInfo.h"
+#include "AlphaTargetMachine.h"
#include "AlphaISelLowering.h"
#include "llvm/Constants.h" // FIXME: REMOVE
#include "llvm/Function.h"
cl::opt<bool> EnableAlphaIDIV("enable-alpha-intfpdiv",
cl::desc("Use the FP div instruction for integer div when possible"),
cl::Hidden);
- cl::opt<bool> EnableAlphaFTOI("enable-alpha-FTOI",
- cl::desc("Enable use of ftoi* and itof* instructions (ev6 and higher)"),
- cl::Hidden);
- cl::opt<bool> EnableAlphaCT("enable-alpha-CT",
- cl::desc("Enable use of the ctpop, ctlz, and cttz instructions"),
- cl::Hidden);
cl::opt<bool> EnableAlphaCount("enable-alpha-count",
cl::desc("Print estimates on live ins and outs"),
cl::Hidden);
void AlphaISel::MoveFP2Int(unsigned src, unsigned dst, bool isDouble)
{
unsigned Opc;
- if (EnableAlphaFTOI) {
+ if (TLI.getTargetMachine().getSubtarget<AlphaSubtarget>().hasF2I()) {
Opc = isDouble ? Alpha::FTOIT : Alpha::FTOIS;
BuildMI(BB, Opc, 1, dst).addReg(src).addReg(Alpha::F31);
} else {
void AlphaISel::MoveInt2FP(unsigned src, unsigned dst, bool isDouble)
{
unsigned Opc;
- if (EnableAlphaFTOI) {
+ if (TLI.getTargetMachine().getSubtarget<AlphaSubtarget>().hasF2I()) {
Opc = isDouble?Alpha::ITOFT:Alpha::ITOFS;
BuildMI(BB, Opc, 1, dst).addReg(src).addReg(Alpha::R31);
} else {
--- /dev/null
+//===- AlphaSubtarget.cpp - Alpha Subtarget Information ---------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Andrew Lenharth and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the Alpha specific subclass of TargetSubtarget.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AlphaSubtarget.h"
+#include "Alpha.h"
+#include "llvm/Module.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Target/SubtargetFeature.h"
+
+using namespace llvm;
+
+//"alphaev67-unknown-linux-gnu"
+
+AlphaSubtarget::AlphaSubtarget(const Module &M, const std::string &FS)
+ :HasF2I(false), HasCT(false)
+{
+//TODO: figure out host
+}
--- /dev/null
+//=====-- AlphaSubtarget.h - Define Subtarget for the Alpha --*- C++ -*--====//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Andrew Lenharth and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the Alpha specific subclass of TargetSubtarget.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ALPHASUBTARGET_H
+#define ALPHASUBTARGET_H
+
+#include "llvm/Target/TargetSubtarget.h"
+
+#include <string>
+
+namespace llvm {
+class Module;
+
+class AlphaSubtarget : public TargetSubtarget {
+protected:
+
+ /// Used by the ISel to turn in optimizations for POWER4-derived architectures
+ bool HasF2I;
+ bool HasCT;
+
+public:
+ /// This constructor initializes the data members to match that
+ /// of the specified module.
+ ///
+ AlphaSubtarget(const Module &M, const std::string &FS);
+
+ bool hasF2I() const { return HasF2I; }
+ bool hasCT() const { return HasCT; }
+};
+} // End llvm namespace
+
+#endif
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Transforms/Scalar.h"
+#include "llvm/Support/Debug.h"
#include <iostream>
using namespace llvm;
const std::string &FS)
: TargetMachine("alpha", IL, true),
FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0),
- JITInfo(*this)
-{}
+ JITInfo(*this),
+ Subtarget(M, FS)
+{
+ DEBUG(std::cerr << "FS is " << FS << "\n");
+}
/// addPassesToEmitFile - Add passes to the specified pass manager to implement
/// a static compiler for this target.
#include "llvm/PassManager.h"
#include "AlphaInstrInfo.h"
#include "AlphaJITInfo.h"
+#include "AlphaSubtarget.h"
namespace llvm {
AlphaInstrInfo InstrInfo;
TargetFrameInfo FrameInfo;
AlphaJITInfo JITInfo;
+ AlphaSubtarget Subtarget;
public:
AlphaTargetMachine(const Module &M, IntrinsicLowering *IL,
virtual const AlphaInstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }
+ virtual const TargetSubtarget *getSubtargetImpl() const{ return &Subtarget; }
virtual const MRegisterInfo *getRegisterInfo() const {
return &InstrInfo.getRegisterInfo();
}