Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Analysis/GlobalsModRef.h
Line
Count
Source (jump to first uncovered line)
1
//===- GlobalsModRef.h - Simple Mod/Ref AA for Globals ----------*- 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
/// This is the interface for a simple mod/ref and alias analysis over globals.
10
///
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_ANALYSIS_GLOBALSMODREF_H
14
#define LLVM_ANALYSIS_GLOBALSMODREF_H
15
16
#include "llvm/Analysis/AliasAnalysis.h"
17
#include "llvm/Analysis/CallGraph.h"
18
#include "llvm/IR/Constants.h"
19
#include "llvm/IR/Function.h"
20
#include "llvm/IR/Module.h"
21
#include "llvm/IR/ValueHandle.h"
22
#include "llvm/Pass.h"
23
#include <list>
24
25
namespace llvm {
26
27
/// An alias analysis result set for globals.
28
///
29
/// This focuses on handling aliasing properties of globals and interprocedural
30
/// function call mod/ref information.
31
class GlobalsAAResult : public AAResultBase<GlobalsAAResult> {
32
  friend AAResultBase<GlobalsAAResult>;
33
34
  class FunctionInfo;
35
36
  const DataLayout &DL;
37
  const TargetLibraryInfo &TLI;
38
39
  /// The globals that do not have their addresses taken.
40
  SmallPtrSet<const GlobalValue *, 8> NonAddressTakenGlobals;
41
42
  /// IndirectGlobals - The memory pointed to by this global is known to be
43
  /// 'owned' by the global.
44
  SmallPtrSet<const GlobalValue *, 8> IndirectGlobals;
45
46
  /// AllocsForIndirectGlobals - If an instruction allocates memory for an
47
  /// indirect global, this map indicates which one.
48
  DenseMap<const Value *, const GlobalValue *> AllocsForIndirectGlobals;
49
50
  /// For each function, keep track of what globals are modified or read.
51
  DenseMap<const Function *, FunctionInfo> FunctionInfos;
52
53
  /// A map of functions to SCC. The SCCs are described by a simple integer
54
  /// ID that is only useful for comparing for equality (are two functions
55
  /// in the same SCC or not?)
56
  DenseMap<const Function *, unsigned> FunctionToSCCMap;
57
58
  /// Handle to clear this analysis on deletion of values.
59
  struct DeletionCallbackHandle final : CallbackVH {
60
    GlobalsAAResult *GAR;
61
    std::list<DeletionCallbackHandle>::iterator I;
62
63
    DeletionCallbackHandle(GlobalsAAResult &GAR, Value *V)
64
554k
        : CallbackVH(V), GAR(&GAR) {}
65
66
    void deleted() override;
67
  };
68
69
  /// List of callbacks for globals being tracked by this analysis. Note that
70
  /// these objects are quite large, but we only anticipate having one per
71
  /// global tracked by this analysis. There are numerous optimizations we
72
  /// could perform to the memory utilization here if this becomes a problem.
73
  std::list<DeletionCallbackHandle> Handles;
74
75
  explicit GlobalsAAResult(const DataLayout &DL, const TargetLibraryInfo &TLI);
76
77
public:
78
  GlobalsAAResult(GlobalsAAResult &&Arg);
79
  ~GlobalsAAResult();
80
81
  static GlobalsAAResult analyzeModule(Module &M, const TargetLibraryInfo &TLI,
82
                                       CallGraph &CG);
83
84
  //------------------------------------------------
85
  // Implement the AliasAnalysis API
86
  //
87
  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
88
                    AAQueryInfo &AAQI);
89
90
  using AAResultBase::getModRefInfo;
91
  ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
92
                           AAQueryInfo &AAQI);
93
94
  /// getModRefBehavior - Return the behavior of the specified function if
95
  /// called from the specified call site.  The call site may be null in which
96
  /// case the most generic behavior of this function should be returned.
97
  FunctionModRefBehavior getModRefBehavior(const Function *F);
98
99
  /// getModRefBehavior - Return the behavior of the specified function if
100
  /// called from the specified call site.  The call site may be null in which
101
  /// case the most generic behavior of this function should be returned.
102
  FunctionModRefBehavior getModRefBehavior(const CallBase *Call);
103
104
private:
105
  FunctionInfo *getFunctionInfo(const Function *F);
106
107
  void AnalyzeGlobals(Module &M);
108
  void AnalyzeCallGraph(CallGraph &CG, Module &M);
109
  bool AnalyzeUsesOfPointer(Value *V,
110
                            SmallPtrSetImpl<Function *> *Readers = nullptr,
111
                            SmallPtrSetImpl<Function *> *Writers = nullptr,
112
                            GlobalValue *OkayStoreDest = nullptr);
113
  bool AnalyzeIndirectGlobalMemory(GlobalVariable *GV);
114
  void CollectSCCMembership(CallGraph &CG);
115
116
  bool isNonEscapingGlobalNoAlias(const GlobalValue *GV, const Value *V);
117
  ModRefInfo getModRefInfoForArgument(const CallBase *Call,
118
                                      const GlobalValue *GV, AAQueryInfo &AAQI);
119
};
120
121
/// Analysis pass providing a never-invalidated alias analysis result.
122
class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
123
  friend AnalysisInfoMixin<GlobalsAA>;
124
  static AnalysisKey Key;
125
126
public:
127
  typedef GlobalsAAResult Result;
128
129
  GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM);
130
};
131
132
/// Legacy wrapper pass to provide the GlobalsAAResult object.
133
class GlobalsAAWrapperPass : public ModulePass {
134
  std::unique_ptr<GlobalsAAResult> Result;
135
136
public:
137
  static char ID;
138
139
  GlobalsAAWrapperPass();
140
141
8.10M
  GlobalsAAResult &getResult() { return *Result; }
142
0
  const GlobalsAAResult &getResult() const { return *Result; }
143
144
  bool runOnModule(Module &M) override;
145
  bool doFinalization(Module &M) override;
146
  void getAnalysisUsage(AnalysisUsage &AU) const override;
147
};
148
149
//===--------------------------------------------------------------------===//
150
//
151
// createGlobalsAAWrapperPass - This pass provides alias and mod/ref info for
152
// global values that do not have their addresses taken.
153
//
154
ModulePass *createGlobalsAAWrapperPass();
155
}
156
157
#endif