LLVM  12.0.0git
CodeMetrics.h
Go to the documentation of this file.
1 //===- CodeMetrics.h - Code cost measurements -------------------*- 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 implements various weight measurements for code, helping
10 // the Inliner and other passes decide whether to duplicate its contents.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_ANALYSIS_CODEMETRICS_H
15 #define LLVM_ANALYSIS_CODEMETRICS_H
16 
17 #include "llvm/ADT/DenseMap.h"
18 
19 namespace llvm {
20 class AssumptionCache;
21 class BasicBlock;
22 class Loop;
23 class Function;
24 template <class T> class SmallPtrSetImpl;
25 class TargetTransformInfo;
26 class Value;
27 
28 /// Utility to calculate the size and a few similar metrics for a set
29 /// of basic blocks.
30 struct CodeMetrics {
31  /// True if this function contains a call to setjmp or other functions
32  /// with attribute "returns twice" without having the attribute itself.
33  bool exposesReturnsTwice = false;
34 
35  /// True if this function calls itself.
36  bool isRecursive = false;
37 
38  /// True if this function cannot be duplicated.
39  ///
40  /// True if this function contains one or more indirect branches, or it contains
41  /// one or more 'noduplicate' instructions.
42  bool notDuplicatable = false;
43 
44  /// True if this function contains a call to a convergent function.
45  bool convergent = false;
46 
47  /// True if this function calls alloca (in the C sense).
48  bool usesDynamicAlloca = false;
49 
50  /// Number of instructions in the analyzed blocks.
51  unsigned NumInsts = false;
52 
53  /// Number of analyzed blocks.
54  unsigned NumBlocks = false;
55 
56  /// Keeps track of basic block code size estimates.
58 
59  /// Keep track of the number of calls to 'big' functions.
60  unsigned NumCalls = false;
61 
62  /// The number of calls to internal functions with a single caller.
63  ///
64  /// These are likely targets for future inlining, likely exposed by
65  /// interleaved devirtualization.
66  unsigned NumInlineCandidates = 0;
67 
68  /// How many instructions produce vector values.
69  ///
70  /// The inliner is more aggressive with inlining vector kernels.
71  unsigned NumVectorInsts = 0;
72 
73  /// How many 'ret' instructions the blocks contain.
74  unsigned NumRets = 0;
75 
76  /// Add information about a block to the current state.
77  void analyzeBasicBlock(const BasicBlock *BB, const TargetTransformInfo &TTI,
78  const SmallPtrSetImpl<const Value*> &EphValues);
79 
80  /// Collect a loop's ephemeral values (those used only by an assume
81  /// or similar intrinsics in the loop).
82  static void collectEphemeralValues(const Loop *L, AssumptionCache *AC,
84 
85  /// Collect a functions's ephemeral values (those used only by an
86  /// assume or similar intrinsics in the function).
87  static void collectEphemeralValues(const Function *L, AssumptionCache *AC,
89 };
90 
91 }
92 
93 #endif
static void collectEphemeralValues(const Loop *L, AssumptionCache *AC, SmallPtrSetImpl< const Value *> &EphValues)
Collect a loop&#39;s ephemeral values (those used only by an assume or similar intrinsics in the loop)...
Definition: CodeMetrics.cpp:69
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:64
bool convergent
True if this function contains a call to a convergent function.
Definition: CodeMetrics.h:45
bool isRecursive
True if this function calls itself.
Definition: CodeMetrics.h:36
unsigned NumVectorInsts
How many instructions produce vector values.
Definition: CodeMetrics.h:71
unsigned NumCalls
Keep track of the number of calls to &#39;big&#39; functions.
Definition: CodeMetrics.h:60
A cache of @llvm.assume calls within a function.
unsigned NumInlineCandidates
The number of calls to internal functions with a single caller.
Definition: CodeMetrics.h:66
bool notDuplicatable
True if this function cannot be duplicated.
Definition: CodeMetrics.h:42
unsigned NumBlocks
Number of analyzed blocks.
Definition: CodeMetrics.h:54
bool usesDynamicAlloca
True if this function calls alloca (in the C sense).
Definition: CodeMetrics.h:48
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
void analyzeBasicBlock(const BasicBlock *BB, const TargetTransformInfo &TTI, const SmallPtrSetImpl< const Value *> &EphValues)
Add information about a block to the current state.
DenseMap< const BasicBlock *, unsigned > NumBBInsts
Keeps track of basic block code size estimates.
Definition: CodeMetrics.h:57
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
bool exposesReturnsTwice
True if this function contains a call to setjmp or other functions with attribute "returns twice" wit...
Definition: CodeMetrics.h:33
Utility to calculate the size and a few similar metrics for a set of basic blocks.
Definition: CodeMetrics.h:30
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:516
unsigned NumRets
How many &#39;ret&#39; instructions the blocks contain.
Definition: CodeMetrics.h:74
unsigned NumInsts
Number of instructions in the analyzed blocks.
Definition: CodeMetrics.h:51