LLVM  14.0.0git
FunctionAttrs.h
Go to the documentation of this file.
1 //===- FunctionAttrs.h - Compute function attributes ------------*- 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 /// \file
10 /// Provides passes for computing function attributes based on interprocedural
11 /// analyses.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H
16 #define LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H
17 
21 #include "llvm/IR/PassManager.h"
22 
23 namespace llvm {
24 
25 class AAResults;
26 class Function;
27 class Module;
28 class Pass;
29 
30 /// The three kinds of memory access relevant to 'readonly' and
31 /// 'readnone' attributes.
37 };
38 
39 /// Returns the memory access properties of this copy of the function.
40 MemoryAccessKind computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR);
41 
42 /// Propagate function attributes for function summaries along the index's
43 /// callgraph during thinlink
45  ModuleSummaryIndex &Index,
46  function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
47  isPrevailing);
48 
49 /// Computes function attributes in post-order over the call graph.
50 ///
51 /// By operating in post-order, this pass computes precise attributes for
52 /// called functions prior to processsing their callers. This "bottom-up"
53 /// approach allows powerful interprocedural inference of function attributes
54 /// like memory access patterns, etc. It can discover functions that do not
55 /// access memory, or only read memory, and give them the readnone/readonly
56 /// attribute. It also discovers function arguments that are not captured by
57 /// the function and marks them with the nocapture attribute.
58 struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
61 };
62 
63 /// Create a legacy pass manager instance of a pass to compute function attrs
64 /// in post-order.
66 
67 /// A pass to do RPO deduction and propagation of function attributes.
68 ///
69 /// This pass provides a general RPO or "top down" propagation of
70 /// function attributes. For a few (rare) cases, we can deduce significantly
71 /// more about function attributes by working in RPO, so this pass
72 /// provides the complement to the post-order pass above where the majority of
73 /// deduction is performed.
74 // FIXME: Currently there is no RPO CGSCC pass structure to slide into and so
75 // this is a boring module pass, but eventually it should be an RPO CGSCC pass
76 // when such infrastructure is available.
78  : public PassInfoMixin<ReversePostOrderFunctionAttrsPass> {
79 public:
81 };
82 
83 } // end namespace llvm
84 
85 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H
llvm::GlobalValue::GUID
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:509
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1976
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:374
llvm::ReversePostOrderFunctionAttrsPass
A pass to do RPO deduction and propagation of function attributes.
Definition: FunctionAttrs.h:77
ModuleSummaryIndex.h
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::MAK_MayWrite
@ MAK_MayWrite
Definition: FunctionAttrs.h:35
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:422
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::PostOrderFunctionAttrsPass
Computes function attributes in post-order over the call graph.
Definition: FunctionAttrs.h:58
llvm::computeFunctionBodyMemoryAccess
MemoryAccessKind computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR)
Returns the memory access properties of this copy of the function.
Definition: FunctionAttrs.cpp:245
LazyCallGraph.h
llvm::MemoryAccessKind
MemoryAccessKind
The three kinds of memory access relevant to 'readonly' and 'readnone' attributes.
Definition: FunctionAttrs.h:32
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
CGSCCPassManager.h
llvm::ReversePostOrderFunctionAttrsPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: FunctionAttrs.cpp:2027
llvm::createPostOrderFunctionAttrsLegacyPass
Pass * createPostOrderFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to compute function attrs in post-order.
Definition: FunctionAttrs.cpp:1904
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::MAK_ReadOnly
@ MAK_ReadOnly
Definition: FunctionAttrs.h:34
llvm::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:238
llvm::PostOrderFunctionAttrsPass::run
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
Definition: FunctionAttrs.cpp:1824
llvm::thinLTOPropagateFunctionAttrs
bool thinLTOPropagateFunctionAttrs(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)
Propagate function attributes for function summaries along the index's callgraph during thinlink.
Definition: FunctionAttrs.cpp:437
PassManager.h
llvm::MAK_ReadNone
@ MAK_ReadNone
Definition: FunctionAttrs.h:33
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
llvm::MAK_WriteOnly
@ MAK_WriteOnly
Definition: FunctionAttrs.h:36
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::LazyCallGraph
A lazily constructed view of the call graph of a module.
Definition: LazyCallGraph.h:113
llvm::codeview::PublicSymFlags::Function
@ Function