6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

[mips] Remove trivial header for the Mips16HardFloat pass. NFC.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232259 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Vasileios Kalintiris 2015-03-14 09:02:23 +00:00
parent 3ccd82623a
commit 56fe63e20e
4 changed files with 97 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/Target/Mips/Mips.h
View File

@ -24,6 +24,7 @@ namespace llvm {
class FunctionPass;
ModulePass *createMipsOs16Pass(MipsTargetMachine &TM);
ModulePass *createMips16HardFloatPass(MipsTargetMachine &TM);
FunctionPass *createMipsOptimizePICCallPass(MipsTargetMachine &TM);
FunctionPass *createMipsDelaySlotFillerPass(MipsTargetMachine &TM);

197
lib/Target/Mips/Mips16HardFloat.cpp
View File

@ -11,48 +11,58 @@
//
//===----------------------------------------------------------------------===//
#include "Mips16HardFloat.h"
#include "MipsTargetMachine.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "MipsTargetMachine.h"
#include <algorithm>
#include <string>
using namespace llvm;
#define DEBUG_TYPE "mips16-hard-float"
static void inlineAsmOut
(LLVMContext &C, StringRef AsmString, BasicBlock *BB ) {
std::vector<llvm::Type *> AsmArgTypes;
std::vector<llvm::Value*> AsmArgs;
llvm::FunctionType *AsmFTy =
llvm::FunctionType::get(Type::getVoidTy(C),
AsmArgTypes, false);
llvm::InlineAsm *IA =
llvm::InlineAsm::get(AsmFTy, AsmString, "", true,
/* IsAlignStack */ false,
llvm::InlineAsm::AD_ATT);
CallInst::Create(IA, AsmArgs, "", BB);
}
namespace {
class Mips16HardFloat : public ModulePass {
public:
static char ID;
class InlineAsmHelper {
LLVMContext &C;
BasicBlock *BB;
public:
InlineAsmHelper(LLVMContext &C_, BasicBlock *BB_) :
C(C_), BB(BB_) {
}
Mips16HardFloat(MipsTargetMachine &TM_) : ModulePass(ID), TM(TM_) {}
void Out(StringRef AsmString) {
inlineAsmOut(C, AsmString, BB);
}
const char *getPassName() const override {
return "MIPS16 Hard Float Pass";
}
};
bool runOnModule(Module &M) override;
protected:
const MipsTargetMachine &TM;
};
class InlineAsmHelper {
LLVMContext &C;
BasicBlock *BB;
public:
InlineAsmHelper(LLVMContext &C_, BasicBlock *BB_) :
C(C_), BB(BB_) {
}
void Out(StringRef AsmString) {
std::vector<llvm::Type *> AsmArgTypes;
std::vector<llvm::Value*> AsmArgs;
llvm::FunctionType *AsmFTy = llvm::FunctionType::get(Type::getVoidTy(C),
AsmArgTypes, false);
llvm::InlineAsm *IA = llvm::InlineAsm::get(AsmFTy, AsmString, "", true,
/* IsAlignStack */ false,
llvm::InlineAsm::AD_ATT);
CallInst::Create(IA, AsmArgs, "", BB);
}
};
char Mips16HardFloat::ID = 0;
}
//
// Return types that matter for hard float are:
// float, double, complex float, and complex double
@ -156,11 +166,11 @@ static bool needsFPStubFromParams(Function &F) {
if (F.arg_size() >=1) {
Type *ArgType = F.getFunctionType()->getParamType(0);
switch (ArgType->getTypeID()) {
case Type::FloatTyID:
case Type::DoubleTyID:
return true;
default:
break;
case Type::FloatTyID:
case Type::DoubleTyID:
return true;
default:
break;
}
}
return false;
@ -184,10 +194,8 @@ static bool needsFPHelperFromSig(Function &F) {
// We swap between FP and Integer registers to allow Mips16 and Mips32 to
// interoperate
//
static void swapFPIntParams
(FPParamVariant PV, Module *M, InlineAsmHelper &IAH,
bool LE, bool ToFP) {
static void swapFPIntParams(FPParamVariant PV, Module *M, InlineAsmHelper &IAH,
bool LE, bool ToFP) {
//LLVMContext &Context = M->getContext();
std::string MI = ToFP? "mtc1 ": "mfc1 ";
switch (PV) {
@ -244,6 +252,7 @@ static void swapFPIntParams
return;
}
}
//
// Make sure that we know we already need a stub for this function.
// Having called needsFPHelperFromSig
@ -299,8 +308,8 @@ static void assureFPCallStub(Function &F, Module *M,
break;
case CFRet:
if (LE) {
IAH.Out("mfc1 $$2,$$f0");
IAH.Out("mfc1 $$3,$$f2");
IAH.Out("mfc1 $$2,$$f0");
IAH.Out("mfc1 $$3,$$f2");
} else {
IAH.Out("mfc1 $$3,$$f0");
IAH.Out("mfc1 $$3,$$f2");
@ -333,28 +342,27 @@ static void assureFPCallStub(Function &F, Module *M,
//
// Functions that are llvm intrinsics and don't need helpers.
//
static const char *IntrinsicInline[] =
{"fabs",
"fabsf",
"llvm.ceil.f32", "llvm.ceil.f64",
"llvm.copysign.f32", "llvm.copysign.f64",
"llvm.cos.f32", "llvm.cos.f64",
"llvm.exp.f32", "llvm.exp.f64",
"llvm.exp2.f32", "llvm.exp2.f64",
"llvm.fabs.f32", "llvm.fabs.f64",
"llvm.floor.f32", "llvm.floor.f64",
"llvm.fma.f32", "llvm.fma.f64",
"llvm.log.f32", "llvm.log.f64",
"llvm.log10.f32", "llvm.log10.f64",
"llvm.nearbyint.f32", "llvm.nearbyint.f64",
"llvm.pow.f32", "llvm.pow.f64",
"llvm.powi.f32", "llvm.powi.f64",
"llvm.rint.f32", "llvm.rint.f64",
"llvm.round.f32", "llvm.round.f64",
"llvm.sin.f32", "llvm.sin.f64",
"llvm.sqrt.f32", "llvm.sqrt.f64",
"llvm.trunc.f32", "llvm.trunc.f64",
};
static const char *IntrinsicInline[] = {
"fabs", "fabsf",
"llvm.ceil.f32", "llvm.ceil.f64",
"llvm.copysign.f32", "llvm.copysign.f64",
"llvm.cos.f32", "llvm.cos.f64",
"llvm.exp.f32", "llvm.exp.f64",
"llvm.exp2.f32", "llvm.exp2.f64",
"llvm.fabs.f32", "llvm.fabs.f64",
"llvm.floor.f32", "llvm.floor.f64",
"llvm.fma.f32", "llvm.fma.f64",
"llvm.log.f32", "llvm.log.f64",
"llvm.log10.f32", "llvm.log10.f64",
"llvm.nearbyint.f32", "llvm.nearbyint.f64",
"llvm.pow.f32", "llvm.pow.f64",
"llvm.powi.f32", "llvm.powi.f64",
"llvm.rint.f32", "llvm.rint.f64",
"llvm.round.f32", "llvm.round.f64",
"llvm.sin.f32", "llvm.sin.f64",
"llvm.sqrt.f32", "llvm.sqrt.f64",
"llvm.trunc.f32", "llvm.trunc.f64",
};
static bool isIntrinsicInline(Function *F) {
return std::binary_search(std::begin(IntrinsicInline),
@ -386,9 +394,10 @@ static bool fixupFPReturnAndCall(Function &F, Module *M,
Type *T = RVal->getType();
FPReturnVariant RV = whichFPReturnVariant(T);
if (RV == NoFPRet) continue;
static const char* Helper[NoFPRet] =
{"__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc",
"__mips16_ret_dc"};
static const char* Helper[NoFPRet] = {
"__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc",
"__mips16_ret_dc"
};
const char *Name = Helper[RV];
AttributeSet A;
Value *Params[] = {RVal};
@ -408,33 +417,33 @@ static bool fixupFPReturnAndCall(Function &F, Module *M,
Value *F = (M->getOrInsertFunction(Name, A, MyVoid, T, nullptr));
CallInst::Create(F, Params, "", &Inst );
} else if (const CallInst *CI = dyn_cast<CallInst>(I)) {
const Value* V = CI->getCalledValue();
const Type* T = nullptr;
if (V) T = V->getType();
const PointerType *PFT=nullptr;
if (T) PFT = dyn_cast<PointerType>(T);
const FunctionType *FT=nullptr;
if (PFT) FT = dyn_cast<FunctionType>(PFT->getElementType());
Function *F_ = CI->getCalledFunction();
if (FT && needsFPReturnHelper(*FT) &&
!(F_ && isIntrinsicInline(F_))) {
const Value* V = CI->getCalledValue();
const Type* T = nullptr;
if (V) T = V->getType();
const PointerType *PFT=nullptr;
if (T) PFT = dyn_cast<PointerType>(T);
const FunctionType *FT=nullptr;
if (PFT) FT = dyn_cast<FunctionType>(PFT->getElementType());
Function *F_ = CI->getCalledFunction();
if (FT && needsFPReturnHelper(*FT) &&
!(F_ && isIntrinsicInline(F_))) {
Modified=true;
F.addFnAttr("saveS2");
}
if (F_ && !isIntrinsicInline(F_)) {
// pic mode calls are handled by already defined
// helper functions
if (needsFPReturnHelper(*F_)) {
Modified=true;
F.addFnAttr("saveS2");
}
if (F_ && !isIntrinsicInline(F_)) {
// pic mode calls are handled by already defined
// helper functions
if (needsFPReturnHelper(*F_)) {
if (TM.getRelocationModel() != Reloc::PIC_ ) {
if (needsFPHelperFromSig(*F_)) {
assureFPCallStub(*F_, M, TM);
Modified=true;
F.addFnAttr("saveS2");
}
if (TM.getRelocationModel() != Reloc::PIC_ ) {
if (needsFPHelperFromSig(*F_)) {
assureFPCallStub(*F_, M, TM);
Modified=true;
}
}
}
}
}
}
return Modified;
@ -491,20 +500,6 @@ static void removeUseSoftFloat(Function &F) {
F.addAttributes(AttributeSet::FunctionIndex, A);
}
namespace {
class Mips16HardFloat : public ModulePass {
public:
static char ID;
Mips16HardFloat(MipsTargetMachine &TM_) : ModulePass(ID), TM(TM_) {}
const char *getPassName() const override { return "MIPS16 Hard Float Pass"; }
bool runOnModule(Module &M) override;
protected:
const MipsTargetMachine &TM;
};
} // namespace
//
// This pass only makes sense when the underlying chip has floating point but
@ -545,9 +540,7 @@ bool Mips16HardFloat::runOnModule(Module &M) {
return Modified;
}
char Mips16HardFloat::ID = 0;
ModulePass *llvm::createMips16HardFloat(MipsTargetMachine &TM) {
ModulePass *llvm::createMips16HardFloatPass(MipsTargetMachine &TM) {
return new Mips16HardFloat(TM);
}

25
lib/Target/Mips/Mips16HardFloat.h
View File

@ -1,25 +0,0 @@
//===---- Mips16HardFloat.h for Mips16 Hard Float --------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a phase which implements part of the floating point
// interoperability between Mips16 and Mips32 code.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_MIPS_MIPS16HARDFLOAT_H
#define LLVM_LIB_TARGET_MIPS_MIPS16HARDFLOAT_H
namespace llvm {
class MipsTargetMachine;
class ModulePass;
ModulePass *createMips16HardFloat(MipsTargetMachine &TM);
}
#endif

3
lib/Target/Mips/MipsTargetMachine.cpp
View File

@ -14,7 +14,6 @@
#include "MipsTargetMachine.h"
#include "Mips.h"
#include "Mips16FrameLowering.h"
#include "Mips16HardFloat.h"
#include "Mips16ISelDAGToDAG.h"
#include "Mips16ISelLowering.h"
#include "Mips16InstrInfo.h"
@ -215,7 +214,7 @@ void MipsPassConfig::addIRPasses() {
if (getMipsSubtarget().os16())
addPass(createMipsOs16Pass(getMipsTargetMachine()));
if (getMipsSubtarget().inMips16HardFloat())
addPass(createMips16HardFloat(getMipsTargetMachine()));
addPass(createMips16HardFloatPass(getMipsTargetMachine()));
}
// Install an instruction selector pass using
// the ISelDag to gen Mips code.