1 //===-- llvm/CodeGen/AssignmentTrackingAnalysis.h --------------*- 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 #ifndef LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
10 #define LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
11 
12 #include "llvm/IR/DebugInfoMetadata.h"
13 #include "llvm/IR/DebugLoc.h"
14 #include "llvm/IR/IntrinsicInst.h"
15 #include "llvm/IR/PassManager.h"
16 #include "llvm/Pass.h"
17 
18 namespace llvm {
19 class Instruction;
20 class raw_ostream;
21 } // namespace llvm
22 class FunctionVarLocsBuilder;
23 
24 namespace llvm {
25 /// Type wrapper for integer ID for Variables. 0 is reserved.
26 enum class VariableID : unsigned { Reserved = 0 };
27 /// Variable location definition used by FunctionVarLocs.
28 struct VarLocInfo {
29   llvm::VariableID VariableID;
30   DIExpression *Expr = nullptr;
31   DebugLoc DL;
32   RawLocationWrapper Values = RawLocationWrapper();
33 };
34 
35 /// Data structure describing the variable locations in a function. Used as the
36 /// result of the AssignmentTrackingAnalysis pass. Essentially read-only
37 /// outside of AssignmentTrackingAnalysis where it is built.
38 class FunctionVarLocs {
39   /// Maps VarLocInfo.VariableID to a DebugVariable for VarLocRecords.
40   SmallVector<DebugVariable> Variables;
41   /// List of variable location changes grouped by the instruction the
42   /// change occurs before (see VarLocsBeforeInst). The elements from
43   /// zero to SingleVarLocEnd represent variables with a single location.
44   SmallVector<VarLocInfo> VarLocRecords;
45   /// End of range of VarLocRecords that represent variables with a single
46   /// location that is valid for the entire scope. Range starts at 0.
47   unsigned SingleVarLocEnd = 0;
48   /// Maps an instruction to a range of VarLocs that start just before it.
49   DenseMap<const Instruction *, std::pair<unsigned, unsigned>>
50       VarLocsBeforeInst;
51 
52 public:
53   /// Return the DILocalVariable for the location definition represented by \p
54   /// ID.
55   DILocalVariable *getDILocalVariable(const VarLocInfo *Loc) const {
56     VariableID VarID = Loc->VariableID;
57     return getDILocalVariable(VarID);
58   }
59   /// Return the DILocalVariable of the variable represented by \p ID.
60   DILocalVariable *getDILocalVariable(VariableID ID) const {
61     return const_cast<DILocalVariable *>(getVariable(ID).getVariable());
62   }
63   /// Return the DebugVariable represented by \p ID.
64   const DebugVariable &getVariable(VariableID ID) const {
65     return Variables[static_cast<unsigned>(ID)];
66   }
67 
68   ///@name iterators
69   ///@{
70   /// First single-location variable location definition.
71   const VarLocInfo *single_locs_begin() const { return VarLocRecords.begin(); }
72   /// One past the last single-location variable location definition.
73   const VarLocInfo *single_locs_end() const {
74     const auto *It = VarLocRecords.begin();
75     std::advance(It, SingleVarLocEnd);
76     return It;
77   }
78   /// First variable location definition that comes before \p Before.
79   const VarLocInfo *locs_begin(const Instruction *Before) const {
80     auto Span = VarLocsBeforeInst.lookup(Before);
81     const auto *It = VarLocRecords.begin();
82     std::advance(It, Span.first);
83     return It;
84   }
85   /// One past the last variable location definition that comes before \p
86   /// Before.
87   const VarLocInfo *locs_end(const Instruction *Before) const {
88     auto Span = VarLocsBeforeInst.lookup(Before);
89     const auto *It = VarLocRecords.begin();
90     std::advance(It, Span.second);
91     return It;
92   }
93   ///@}
94 
95   void print(raw_ostream &OS, const Function &Fn) const;
96 
97   ///@{
98   /// Non-const methods used by AssignmentTrackingAnalysis (which invalidate
99   /// analysis results if called incorrectly).
100   void init(FunctionVarLocsBuilder &Builder);
101   void clear();
102   ///@}
103 };
104 
105 class DebugAssignmentTrackingAnalysis
106     : public AnalysisInfoMixin<DebugAssignmentTrackingAnalysis> {
107   friend AnalysisInfoMixin<DebugAssignmentTrackingAnalysis>;
108   static AnalysisKey Key;
109 
110 public:
111   using Result = FunctionVarLocs;
112   Result run(Function &F, FunctionAnalysisManager &FAM);
113 };
114 
115 class DebugAssignmentTrackingPrinterPass
116     : public PassInfoMixin<DebugAssignmentTrackingPrinterPass> {
117   raw_ostream &OS;
118 
119 public:
120   DebugAssignmentTrackingPrinterPass(raw_ostream &OS) : OS(OS) {}
121   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
122 };
123 
124 class AssignmentTrackingAnalysis : public FunctionPass {
125   std::unique_ptr<FunctionVarLocs> Results;
126 
127 public:
128   static char ID;
129 
130   AssignmentTrackingAnalysis();
131 
132   bool runOnFunction(Function &F) override;
133 
134   static bool isRequired() { return true; }
135 
136   void getAnalysisUsage(AnalysisUsage &AU) const override {
137     AU.setPreservesAll();
138   }
139 
140   const FunctionVarLocs *getResults() { return Results.get(); }
141 };
142 
143 } // end namespace llvm
144 #endif // LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
145