LLVM 17.0.0git
FunctionPropertiesAnalysis.h
Go to the documentation of this file.
1//=- FunctionPropertiesAnalysis.h - Function Properties Analysis --*- C++ -*-=//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the FunctionPropertiesInfo and FunctionPropertiesAnalysis
10// classes used to extract function properties.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H
15#define LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H
16
19#include "llvm/IR/InstrTypes.h"
20#include "llvm/IR/PassManager.h"
21
22namespace llvm {
23class Function;
24class LoopInfo;
25
28 void updateForBB(const BasicBlock &BB, int64_t Direction);
29 void updateAggregateStats(const Function &F, const LoopInfo &LI);
30 void reIncludeBB(const BasicBlock &BB);
31
32public:
35
36 bool operator==(const FunctionPropertiesInfo &FPI) const {
37 return std::memcmp(this, &FPI, sizeof(FunctionPropertiesInfo)) == 0;
38 }
39
40 bool operator!=(const FunctionPropertiesInfo &FPI) const {
41 return !(*this == FPI);
42 }
43
44 void print(raw_ostream &OS) const;
45
46 /// Number of basic blocks
47 int64_t BasicBlockCount = 0;
48
49 /// Number of blocks reached from a conditional instruction, or that are
50 /// 'cases' of a SwitchInstr.
51 // FIXME: We may want to replace this with a more meaningful metric, like
52 // number of conditionally executed blocks:
53 // 'if (a) s();' would be counted here as 2 blocks, just like
54 // 'if (a) s(); else s2(); s3();' would.
56
57 /// Number of uses of this function, plus 1 if the function is callable
58 /// outside the module.
59 int64_t Uses = 0;
60
61 /// Number of direct calls made from this function to other functions
62 /// defined in this module.
64
65 // Load Instruction Count
66 int64_t LoadInstCount = 0;
67
68 // Store Instruction Count
69 int64_t StoreInstCount = 0;
70
71 // Maximum Loop Depth in the Function
72 int64_t MaxLoopDepth = 0;
73
74 // Number of Top Level Loops in the Function
75 int64_t TopLevelLoopCount = 0;
76
77 // All non-debug instructions
79};
80
81// Analysis pass
83 : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
84
85public:
87
89
91};
92
93/// Printer pass for the FunctionPropertiesAnalysis results.
95 : public PassInfoMixin<FunctionPropertiesPrinterPass> {
96 raw_ostream &OS;
97
98public:
100
102};
103
104/// Correctly update FunctionPropertiesInfo post-inlining. A
105/// FunctionPropertiesUpdater keeps the state necessary for tracking the changes
106/// llvm::InlineFunction makes. The idea is that inlining will at most modify
107/// a few BBs of the Caller (maybe the entry BB and definitely the callsite BB)
108/// and potentially affect exception handling BBs in the case of invoke
109/// inlining.
111public:
113
115
116private:
118 const BasicBlock &CallSiteBB;
119 const Function &Caller;
120
122};
123} // namespace llvm
124#endif // LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H
Loop::LoopBounds::Direction Direction
Definition: LoopInfo.cpp:230
#define F(x, y, z)
Definition: MD5.cpp:55
FunctionAnalysisManager FAM
This header defines various interfaces for pass management in LLVM.
raw_pwrite_stream & OS
This file defines the SmallPtrSet class.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1186
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
FunctionPropertiesInfo run(Function &F, FunctionAnalysisManager &FAM)
bool operator!=(const FunctionPropertiesInfo &FPI) const
int64_t BasicBlockCount
Number of basic blocks.
int64_t Uses
Number of uses of this function, plus 1 if the function is callable outside the module.
bool operator==(const FunctionPropertiesInfo &FPI) const
int64_t BlocksReachedFromConditionalInstruction
Number of blocks reached from a conditional instruction, or that are 'cases' of a SwitchInstr.
static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F, FunctionAnalysisManager &FAM)
int64_t DirectCallsToDefinedFunctions
Number of direct calls made from this function to other functions defined in this module.
Printer pass for the FunctionPropertiesAnalysis results.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Correctly update FunctionPropertiesInfo post-inlining.
void finish(FunctionAnalysisManager &FAM) const
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:394
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371