LLVM 17.0.0git
DependencyAnalysis.h
Go to the documentation of this file.
1//===- DependencyAnalysis.h - ObjC ARC Optimization ---*- 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/// \file
9///
10/// This file declares special dependency analysis routines used in Objective C
11/// ARC Optimizations.
12///
13/// WARNING: This file knows about certain library functions. It recognizes them
14/// by name, and hardwires knowledge of their semantics.
15///
16/// WARNING: This file knows about how certain Objective-C library functions are
17/// used. Naive LLVM IR transformations which would otherwise be
18/// behavior-preserving may break these assumptions.
19///
20//===----------------------------------------------------------------------===//
21
22#ifndef LLVM_LIB_TRANSFORMS_OBJCARC_DEPENDENCYANALYSIS_H
23#define LLVM_LIB_TRANSFORMS_OBJCARC_DEPENDENCYANALYSIS_H
24
27
28namespace llvm {
29 class BasicBlock;
30 class Instruction;
31 class Value;
32}
33
34namespace llvm {
35namespace objcarc {
36
37class ProvenanceAnalysis;
38
39/// \enum DependenceKind
40/// Defines different dependence kinds among various ARC constructs.
41///
42/// There are several kinds of dependence-like concepts in use here.
43///
48 RetainAutoreleaseDep, ///< Blocks objc_retainAutorelease.
49 RetainAutoreleaseRVDep ///< Blocks objc_retainAutoreleaseReturnValue.
50};
51
52/// Find dependent instructions. If there is exactly one dependent instruction,
53/// return it. Otherwise, return null.
55 BasicBlock *StartBB,
56 Instruction *StartInst,
57 ProvenanceAnalysis &PA);
58
59bool
60Depends(DependenceKind Flavor, Instruction *Inst, const Value *Arg,
61 ProvenanceAnalysis &PA);
62
63/// Test whether the given instruction can "use" the given pointer's object in a
64/// way that requires the reference count to be positive.
65bool CanUse(const Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA,
66 ARCInstKind Class);
67
68/// Test whether the given instruction can result in a reference count
69/// modification (positive or negative) for the pointer's object.
70bool CanAlterRefCount(const Instruction *Inst, const Value *Ptr,
71 ProvenanceAnalysis &PA, ARCInstKind Class);
72
73/// Returns true if we can not conservatively prove that Inst can not decrement
74/// the reference count of Ptr. Returns false if we can.
75bool CanDecrementRefCount(const Instruction *Inst, const Value *Ptr,
76 ProvenanceAnalysis &PA, ARCInstKind Class);
77
78static inline bool CanDecrementRefCount(const Instruction *Inst,
79 const Value *Ptr,
81 return CanDecrementRefCount(Inst, Ptr, PA, GetARCInstKind(Inst));
82}
83
84} // namespace objcarc
85} // namespace llvm
86
87#endif
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
This file defines the SmallPtrSet class.
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
LLVM Value Representation.
Definition: Value.h:74
This is similar to BasicAliasAnalysis, and it uses many of the same techniques, except it uses specia...
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
bool CanAlterRefCount(const Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class)
Test whether the given instruction can result in a reference count modification (positive or negative...
DependenceKind
Defines different dependence kinds among various ARC constructs.
@ RetainAutoreleaseDep
Blocks objc_retainAutorelease.
@ RetainAutoreleaseRVDep
Blocks objc_retainAutoreleaseReturnValue.
ARCInstKind
Equivalence classes of instructions in the ARC Model.
llvm::Instruction * findSingleDependency(DependenceKind Flavor, const Value *Arg, BasicBlock *StartBB, Instruction *StartInst, ProvenanceAnalysis &PA)
Find dependent instructions.
ARCInstKind GetARCInstKind(const Value *V)
Map V to its ARCInstKind equivalence class.
bool Depends(DependenceKind Flavor, Instruction *Inst, const Value *Arg, ProvenanceAnalysis &PA)
Test if there can be dependencies on Inst through Arg.
bool CanDecrementRefCount(ARCInstKind Kind)
Returns false if conservatively we can prove that any instruction mapped to this kind can not decreme...
bool CanUse(const Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class)
Test whether the given instruction can "use" the given pointer's object in a way that requires the re...
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18