LLVM  16.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 GlobalValueSummary;
26 class ModuleSummaryIndex;
27 class Function;
28 class Module;
29 class Pass;
30 
31 /// Returns the memory access properties of this copy of the function.
32 MemoryEffects computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR);
33 
34 /// Propagate function attributes for function summaries along the index's
35 /// callgraph during thinlink
37  ModuleSummaryIndex &Index,
38  function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
39  isPrevailing);
40 
41 /// Computes function attributes in post-order over the call graph.
42 ///
43 /// By operating in post-order, this pass computes precise attributes for
44 /// called functions prior to processsing their callers. This "bottom-up"
45 /// approach allows powerful interprocedural inference of function attributes
46 /// like memory access patterns, etc. It can discover functions that do not
47 /// access memory, or only read memory, and give them the readnone/readonly
48 /// attribute. It also discovers function arguments that are not captured by
49 /// the function and marks them with the nocapture attribute.
50 struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
53 };
54 
55 /// Create a legacy pass manager instance of a pass to compute function attrs
56 /// in post-order.
58 
59 /// A pass to do RPO deduction and propagation of function attributes.
60 ///
61 /// This pass provides a general RPO or "top down" propagation of
62 /// function attributes. For a few (rare) cases, we can deduce significantly
63 /// more about function attributes by working in RPO, so this pass
64 /// provides the complement to the post-order pass above where the majority of
65 /// deduction is performed.
66 // FIXME: Currently there is no RPO CGSCC pass structure to slide into and so
67 // this is a boring module pass, but eventually it should be an RPO CGSCC pass
68 // when such infrastructure is available.
70  : public PassInfoMixin<ReversePostOrderFunctionAttrsPass> {
71 public:
73 };
74 
75 } // end namespace llvm
76 
77 #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:581
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
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:1999
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::ReversePostOrderFunctionAttrsPass
A pass to do RPO deduction and propagation of function attributes.
Definition: FunctionAttrs.h:69
F
#define F(x, y, z)
Definition: MD5.cpp:55
AliasAnalysis.h
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:420
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:50
LazyCallGraph.h
llvm::computeFunctionBodyMemoryAccess
MemoryEffects computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR)
Returns the memory access properties of this copy of the function.
Definition: FunctionAttrs.cpp:232
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
CGSCCPassManager.h
llvm::ReversePostOrderFunctionAttrsPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: FunctionAttrs.cpp:1977
llvm::createPostOrderFunctionAttrsLegacyPass
Pass * createPostOrderFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to compute function attrs in post-order.
Definition: FunctionAttrs.cpp:1853
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::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:232
llvm::PostOrderFunctionAttrsPass::run
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
Definition: FunctionAttrs.cpp:1772
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:370
PassManager.h
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::LazyCallGraph
A lazily constructed view of the call graph of a module.
Definition: LazyCallGraph.h:111
llvm::codeview::PublicSymFlags::Function
@ Function