mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-24 06:30:19 +00:00
13086a658a
generic function calls and intrinsics. This is somewhat overlapping with an existing intrinsic cost method, but that one seems targetted at vector intrinsics. I'll merge them or separate their names and use cases in a separate commit. This sinks the test of 'callIsSmall' down into TTI where targets can control it. The whole thing feels very hack-ish to me though. I've left a FIXME comment about the fundamental design problem this presents. It isn't yet clear to me what the users of this function *really* care about. I'll have to do more analysis to figure that out. Putting this here at least provides it access to proper analysis pass tools and other such. It also allows us to more cleanly implement the baseline cost interfaces in TTI. With this commit, it is now theoretically possible to simplify much of the inline cost analysis's handling of calls by calling through to this interface. That conversion will have to happen in subsequent commits as it requires more extensive restructuring of the inline cost analysis. The CodeMetrics class is now really only in the business of running over a block of code and aggregating the metrics on that block of code, with the actual cost evaluation done entirely in terms of TTI. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173148 91177308-0d34-0410-b5e6-96231b3b80d8
97 lines
3.7 KiB
C++
97 lines
3.7 KiB
C++
//===- CodeMetrics.cpp - Code cost measurements ---------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements code cost measurement utilities.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/CodeMetrics.h"
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
|
#include "llvm/IR/DataLayout.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/Support/CallSite.h"
|
|
|
|
using namespace llvm;
|
|
|
|
/// analyzeBasicBlock - Fill in the current structure with information gleaned
|
|
/// from the specified block.
|
|
void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB,
|
|
const TargetTransformInfo &TTI) {
|
|
++NumBlocks;
|
|
unsigned NumInstsBeforeThisBB = NumInsts;
|
|
for (BasicBlock::const_iterator II = BB->begin(), E = BB->end();
|
|
II != E; ++II) {
|
|
// Special handling for calls.
|
|
if (isa<CallInst>(II) || isa<InvokeInst>(II)) {
|
|
ImmutableCallSite CS(cast<Instruction>(II));
|
|
|
|
if (const Function *F = CS.getCalledFunction()) {
|
|
// If a function is both internal and has a single use, then it is
|
|
// extremely likely to get inlined in the future (it was probably
|
|
// exposed by an interleaved devirtualization pass).
|
|
if (!CS.isNoInline() && F->hasInternalLinkage() && F->hasOneUse())
|
|
++NumInlineCandidates;
|
|
|
|
// If this call is to function itself, then the function is recursive.
|
|
// Inlining it into other functions is a bad idea, because this is
|
|
// basically just a form of loop peeling, and our metrics aren't useful
|
|
// for that case.
|
|
if (F == BB->getParent())
|
|
isRecursive = true;
|
|
|
|
if (TTI.isLoweredToCall(F))
|
|
++NumCalls;
|
|
} else {
|
|
// We don't want inline asm to count as a call - that would prevent loop
|
|
// unrolling. The argument setup cost is still real, though.
|
|
if (!isa<InlineAsm>(CS.getCalledValue()))
|
|
++NumCalls;
|
|
}
|
|
}
|
|
|
|
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
|
|
if (!AI->isStaticAlloca())
|
|
this->usesDynamicAlloca = true;
|
|
}
|
|
|
|
if (isa<ExtractElementInst>(II) || II->getType()->isVectorTy())
|
|
++NumVectorInsts;
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(II))
|
|
if (CI->hasFnAttr(Attribute::NoDuplicate))
|
|
notDuplicatable = true;
|
|
|
|
if (const InvokeInst *InvI = dyn_cast<InvokeInst>(II))
|
|
if (InvI->hasFnAttr(Attribute::NoDuplicate))
|
|
notDuplicatable = true;
|
|
|
|
NumInsts += TTI.getUserCost(&*II);
|
|
}
|
|
|
|
if (isa<ReturnInst>(BB->getTerminator()))
|
|
++NumRets;
|
|
|
|
// We never want to inline functions that contain an indirectbr. This is
|
|
// incorrect because all the blockaddress's (in static global initializers
|
|
// for example) would be referring to the original function, and this indirect
|
|
// jump would jump from the inlined copy of the function into the original
|
|
// function which is extremely undefined behavior.
|
|
// FIXME: This logic isn't really right; we can safely inline functions
|
|
// with indirectbr's as long as no other function or global references the
|
|
// blockaddress of a block within the current function. And as a QOI issue,
|
|
// if someone is using a blockaddress without an indirectbr, and that
|
|
// reference somehow ends up in another function or global, we probably
|
|
// don't want to inline this function.
|
|
notDuplicatable |= isa<IndirectBrInst>(BB->getTerminator());
|
|
|
|
// Remember NumInsts for this BB.
|
|
NumBBInsts[BB] = NumInsts - NumInstsBeforeThisBB;
|
|
}
|