mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-16 11:30:51 +00:00
a8a7099c18
...so that it can be used for z too. Most of the code is the same. The only real change is to use TargetTransformInfo to test when a sqrt instruction is available. The pass is opt-in because at the moment it only handles sqrt. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@189097 91177308-0d34-0410-b5e6-96231b3b80d8
157 lines
5.0 KiB
C++
157 lines
5.0 KiB
C++
//===--- PartiallyInlineLibCalls.cpp - Partially inline libcalls ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This pass tries to partially inline the fast path of well-known library
|
|
// functions, such as using square-root instructions for cases where sqrt()
|
|
// does not need to set errno.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "partially-inline-libcalls"
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
|
#include "llvm/IR/IRBuilder.h"
|
|
#include "llvm/IR/Intrinsics.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Target/TargetLibraryInfo.h"
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
class PartiallyInlineLibCalls : public FunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
PartiallyInlineLibCalls() :
|
|
FunctionPass(ID) {
|
|
initializePartiallyInlineLibCallsPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
|
|
virtual bool runOnFunction(Function &F);
|
|
|
|
private:
|
|
/// Optimize calls to sqrt.
|
|
bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
|
|
BasicBlock &CurrBB, Function::iterator &BB);
|
|
};
|
|
|
|
char PartiallyInlineLibCalls::ID = 0;
|
|
}
|
|
|
|
INITIALIZE_PASS(PartiallyInlineLibCalls, "partially-inline-libcalls",
|
|
"Partially inline calls to library functions", false, false)
|
|
|
|
void PartiallyInlineLibCalls::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired<TargetLibraryInfo>();
|
|
AU.addRequired<TargetTransformInfo>();
|
|
FunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
bool PartiallyInlineLibCalls::runOnFunction(Function &F) {
|
|
bool Changed = false;
|
|
Function::iterator CurrBB;
|
|
TargetLibraryInfo *TLI = &getAnalysis<TargetLibraryInfo>();
|
|
const TargetTransformInfo *TTI = &getAnalysis<TargetTransformInfo>();
|
|
for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE;) {
|
|
CurrBB = BB++;
|
|
|
|
for (BasicBlock::iterator II = CurrBB->begin(), IE = CurrBB->end();
|
|
II != IE; ++II) {
|
|
CallInst *Call = dyn_cast<CallInst>(&*II);
|
|
Function *CalledFunc;
|
|
|
|
if (!Call || !(CalledFunc = Call->getCalledFunction()))
|
|
continue;
|
|
|
|
// Skip if function either has local linkage or is not a known library
|
|
// function.
|
|
LibFunc::Func LibFunc;
|
|
if (CalledFunc->hasLocalLinkage() || !CalledFunc->hasName() ||
|
|
!TLI->getLibFunc(CalledFunc->getName(), LibFunc))
|
|
continue;
|
|
|
|
switch (LibFunc) {
|
|
case LibFunc::sqrtf:
|
|
case LibFunc::sqrt:
|
|
if (TTI->haveFastSqrt(Call->getType()) &&
|
|
optimizeSQRT(Call, CalledFunc, *CurrBB, BB))
|
|
break;
|
|
continue;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
Changed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
bool PartiallyInlineLibCalls::optimizeSQRT(CallInst *Call,
|
|
Function *CalledFunc,
|
|
BasicBlock &CurrBB,
|
|
Function::iterator &BB) {
|
|
// There is no need to change the IR, since backend will emit sqrt
|
|
// instruction if the call has already been marked read-only.
|
|
if (Call->onlyReadsMemory())
|
|
return false;
|
|
|
|
// Do the following transformation:
|
|
//
|
|
// (before)
|
|
// dst = sqrt(src)
|
|
//
|
|
// (after)
|
|
// v0 = sqrt_noreadmem(src) # native sqrt instruction.
|
|
// if (v0 is a NaN)
|
|
// v1 = sqrt(src) # library call.
|
|
// dst = phi(v0, v1)
|
|
//
|
|
|
|
// Move all instructions following Call to newly created block JoinBB.
|
|
// Create phi and replace all uses.
|
|
BasicBlock *JoinBB = llvm::SplitBlock(&CurrBB, Call->getNextNode(), this);
|
|
IRBuilder<> Builder(JoinBB, JoinBB->begin());
|
|
PHINode *Phi = Builder.CreatePHI(Call->getType(), 2);
|
|
Call->replaceAllUsesWith(Phi);
|
|
|
|
// Create basic block LibCallBB and insert a call to library function sqrt.
|
|
BasicBlock *LibCallBB = BasicBlock::Create(CurrBB.getContext(), "call.sqrt",
|
|
CurrBB.getParent(), JoinBB);
|
|
Builder.SetInsertPoint(LibCallBB);
|
|
Instruction *LibCall = Call->clone();
|
|
Builder.Insert(LibCall);
|
|
Builder.CreateBr(JoinBB);
|
|
|
|
// Add attribute "readnone" so that backend can use a native sqrt instruction
|
|
// for this call. Insert a FP compare instruction and a conditional branch
|
|
// at the end of CurrBB.
|
|
Call->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone);
|
|
CurrBB.getTerminator()->eraseFromParent();
|
|
Builder.SetInsertPoint(&CurrBB);
|
|
Value *FCmp = Builder.CreateFCmpOEQ(Call, Call);
|
|
Builder.CreateCondBr(FCmp, JoinBB, LibCallBB);
|
|
|
|
// Add phi operands.
|
|
Phi->addIncoming(Call, &CurrBB);
|
|
Phi->addIncoming(LibCall, LibCallBB);
|
|
|
|
BB = JoinBB;
|
|
return true;
|
|
}
|
|
|
|
FunctionPass *llvm::createPartiallyInlineLibCallsPass() {
|
|
return new PartiallyInlineLibCalls();
|
|
}
|