blob: 037c18853ad9bb6081846d535b2dcbeca7415dab (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
//===- FunctionPropertiesAnalysis.cpp - Function Properties Analysis ------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the FunctionPropertiesInfo and FunctionPropertiesAnalysis
// classes used to extract function properties.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/FunctionPropertiesAnalysis.h"
#include "llvm/IR/Instructions.h"
using namespace llvm;
FunctionPropertiesInfo
FunctionPropertiesInfo::getFunctionPropertiesInfo(const Function &F,
const LoopInfo &LI) {
FunctionPropertiesInfo FPI;
FPI.Uses = ((!F.hasLocalLinkage()) ? 1 : 0) + F.getNumUses();
for (const auto &BB : F) {
++FPI.BasicBlockCount;
if (const auto *BI = dyn_cast<BranchInst>(BB.getTerminator())) {
if (BI->isConditional())
FPI.BlocksReachedFromConditionalInstruction += BI->getNumSuccessors();
} else if (const auto *SI = dyn_cast<SwitchInst>(BB.getTerminator())) {
FPI.BlocksReachedFromConditionalInstruction +=
(SI->getNumCases() + (nullptr != SI->getDefaultDest()));
}
for (const auto &I : BB) {
if (auto *CS = dyn_cast<CallBase>(&I)) {
const auto *Callee = CS->getCalledFunction();
if (Callee && !Callee->isIntrinsic() && !Callee->isDeclaration())
++FPI.DirectCallsToDefinedFunctions;
}
if (I.getOpcode() == Instruction::Load) {
++FPI.LoadInstCount;
} else if (I.getOpcode() == Instruction::Store) {
++FPI.StoreInstCount;
}
}
// Loop Depth of the Basic Block
int64_t LoopDepth;
LoopDepth = LI.getLoopDepth(&BB);
if (FPI.MaxLoopDepth < LoopDepth)
FPI.MaxLoopDepth = LoopDepth;
}
FPI.TopLevelLoopCount += llvm::size(LI);
return FPI;
}
void FunctionPropertiesInfo::print(raw_ostream &OS) const {
OS << "BasicBlockCount: " << BasicBlockCount << "\n"
<< "BlocksReachedFromConditionalInstruction: "
<< BlocksReachedFromConditionalInstruction << "\n"
<< "Uses: " << Uses << "\n"
<< "DirectCallsToDefinedFunctions: " << DirectCallsToDefinedFunctions
<< "\n"
<< "LoadInstCount: " << LoadInstCount << "\n"
<< "StoreInstCount: " << StoreInstCount << "\n"
<< "MaxLoopDepth: " << MaxLoopDepth << "\n"
<< "TopLevelLoopCount: " << TopLevelLoopCount << "\n\n";
}
AnalysisKey FunctionPropertiesAnalysis::Key;
FunctionPropertiesInfo
FunctionPropertiesAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
return FunctionPropertiesInfo::getFunctionPropertiesInfo(
F, FAM.getResult<LoopAnalysis>(F));
}
PreservedAnalyses
FunctionPropertiesPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
OS << "Printing analysis results of CFA for function "
<< "'" << F.getName() << "':"
<< "\n";
AM.getResult<FunctionPropertiesAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}
|
