LLVM  16.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 
17 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/IR/InstrTypes.h"
20 #include "llvm/IR/PassManager.h"
21 
22 namespace llvm {
23 class Function;
24 class 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 
32 public:
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
78  int64_t TotalInstructionCount = 0;
79 };
80 
81 // Analysis pass
83  : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
84 
85 public:
86  static AnalysisKey Key;
87 
89 
91 };
92 
93 /// Printer pass for the FunctionPropertiesAnalysis results.
95  : public PassInfoMixin<FunctionPropertiesPrinterPass> {
96  raw_ostream &OS;
97 
98 public:
99  explicit FunctionPropertiesPrinterPass(raw_ostream &OS) : OS(OS) {}
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.
111 public:
113 
114  void finish(FunctionAnalysisManager &FAM) const;
115 
116 private:
118  const BasicBlock &CallSiteBB;
119  const Function &Caller;
120 
121  DenseSet<const BasicBlock *> Successors;
122 };
123 } // namespace llvm
124 #endif // LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H
llvm::FunctionPropertiesInfo::getFunctionPropertiesInfo
static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F, FunctionAnalysisManager &FAM)
Definition: FunctionPropertiesAnalysis.cpp:84
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::FunctionPropertiesInfo::operator==
bool operator==(const FunctionPropertiesInfo &FPI) const
Definition: FunctionPropertiesAnalysis.h:36
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::Function
Definition: Function.h:60
llvm::FunctionPropertiesPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: FunctionPropertiesAnalysis.cpp:121
llvm::FunctionPropertiesInfo::TopLevelLoopCount
int64_t TopLevelLoopCount
Definition: FunctionPropertiesAnalysis.h:75
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:907
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::FunctionPropertiesPrinterPass
Printer pass for the FunctionPropertiesAnalysis results.
Definition: FunctionPropertiesAnalysis.h:94
llvm::FunctionPropertiesAnalysis::run
FunctionPropertiesInfo run(Function &F, FunctionAnalysisManager &FAM)
Definition: FunctionPropertiesAnalysis.cpp:116
llvm::FunctionPropertiesInfo::LoadInstCount
int64_t LoadInstCount
Definition: FunctionPropertiesAnalysis.h:66
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::FunctionPropertiesAnalysis::Key
static AnalysisKey Key
Definition: FunctionPropertiesAnalysis.h:86
InstrTypes.h
llvm::FunctionPropertiesUpdater::finish
void finish(FunctionAnalysisManager &FAM) const
Definition: FunctionPropertiesAnalysis.cpp:179
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
SmallPtrSet.h
llvm::FunctionPropertiesPrinterPass::FunctionPropertiesPrinterPass
FunctionPropertiesPrinterPass(raw_ostream &OS)
Definition: FunctionPropertiesAnalysis.h:99
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
llvm::FunctionPropertiesUpdater
Correctly update FunctionPropertiesInfo post-inlining.
Definition: FunctionPropertiesAnalysis.h:110
iterator_range.h
llvm::AnalysisInfoMixin
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:394
llvm::FunctionPropertiesInfo::print
void print(raw_ostream &OS) const
Definition: FunctionPropertiesAnalysis.cpp:99
llvm::FunctionPropertiesInfo::Uses
int64_t Uses
Number of uses of this function, plus 1 if the function is callable outside the module.
Definition: FunctionPropertiesAnalysis.h:59
llvm::FunctionPropertiesAnalysis
Definition: FunctionPropertiesAnalysis.h:82
llvm::LoopInfo
Definition: LoopInfo.h:1108
llvm::FunctionPropertiesInfo::MaxLoopDepth
int64_t MaxLoopDepth
Definition: FunctionPropertiesAnalysis.h:72
Direction
Loop::LoopBounds::Direction Direction
Definition: LoopInfo.cpp:230
PassManager.h
llvm::FunctionPropertiesInfo::BlocksReachedFromConditionalInstruction
int64_t BlocksReachedFromConditionalInstruction
Number of blocks reached from a conditional instruction, or that are 'cases' of a SwitchInstr.
Definition: FunctionPropertiesAnalysis.h:55
llvm::FunctionPropertiesInfo::operator!=
bool operator!=(const FunctionPropertiesInfo &FPI) const
Definition: FunctionPropertiesAnalysis.h:40
llvm::FunctionPropertiesInfo::TotalInstructionCount
int64_t TotalInstructionCount
Definition: FunctionPropertiesAnalysis.h:78
llvm::FunctionPropertiesInfo::BasicBlockCount
int64_t BasicBlockCount
Number of basic blocks.
Definition: FunctionPropertiesAnalysis.h:47
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::FunctionPropertiesUpdater::FunctionPropertiesUpdater
FunctionPropertiesUpdater(FunctionPropertiesInfo &FPI, const CallBase &CB)
Definition: FunctionPropertiesAnalysis.cpp:129
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::FunctionPropertiesInfo
Definition: FunctionPropertiesAnalysis.h:26
llvm::FunctionPropertiesInfo::StoreInstCount
int64_t StoreInstCount
Definition: FunctionPropertiesAnalysis.h:69
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::FunctionPropertiesInfo::DirectCallsToDefinedFunctions
int64_t DirectCallsToDefinedFunctions
Number of direct calls made from this function to other functions defined in this module.
Definition: FunctionPropertiesAnalysis.h:63