AssignmentTrackingAnalysis.h Source File (original) (raw)

9#ifndef LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H

10#define LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H

18namespace llvm {

19class Instruction;

20class raw_ostream;

21}

24namespace llvm {

33};

47 unsigned SingleVarLocEnd = 0;

50 VarLocsBeforeInst;

52public:

58 }

62 }

65 return Variables[static_cast<unsigned>(ID)];

66 }

74 const auto *It = VarLocRecords.begin();

75 std::advance(It, SingleVarLocEnd);

76 return It;

77 }

81 const auto *It = VarLocRecords.begin();

82 std::advance(It, Span.first);

83 return It;

84 }

89 const auto *It = VarLocRecords.begin();

90 std::advance(It, Span.second);

91 return It;

92 }

102

103};

104

109

110public:

113};

114

116 : public PassInfoMixin {

118

119public:

122};

123

125 std::unique_ptr Results;

126

127public:

129

131

133

135

138 }

139

141};

142

143}

144#endif

Function Alias Analysis Results

This header defines various interfaces for pass management in LLVM.

FunctionAnalysisManager FAM

Helper class to build FunctionVarLocs, since that class isn't easy to modify.

A container for analyses that lazily runs them and caches their results.

Represent the analysis usage information of a pass.

void setPreservesAll()

Set by analyses that do not transform their input at all.

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...

AssignmentTrackingAnalysis()

const FunctionVarLocs * getResults()

bool runOnFunction(Function &F) override

runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.

Result run(Function &F, FunctionAnalysisManager &FAM)

DebugAssignmentTrackingPrinterPass(raw_ostream &OS)

PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)

Identifies a unique instance of a variable.

const DILocalVariable * getVariable() const

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

FunctionPass class - This class is used to implement most global optimizations.

Data structure describing the variable locations in a function.

void print(raw_ostream &OS, const Function &Fn) const

const VarLocInfo * locs_begin(const Instruction *Before) const

First variable location definition that comes before Before.

const VarLocInfo * single_locs_begin() const

DILocalVariable * getDILocalVariable(const VarLocInfo *Loc) const

Return the DILocalVariable for the location definition represented by ID.

DILocalVariable * getDILocalVariable(VariableID ID) const

Return the DILocalVariable of the variable represented by ID.

const DebugVariable & getVariable(VariableID ID) const

Return the DebugVariable represented by ID.

const VarLocInfo * locs_end(const Instruction *Before) const

One past the last variable location definition that comes before Before.

const VarLocInfo * single_locs_end() const

One past the last single-location variable location definition.

void init(FunctionVarLocsBuilder &Builder)

A set of analyses that are preserved following a run of a transformation pass.

Lightweight class that wraps the location operand metadata of a debug intrinsic.

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

This class implements an extremely fast bulk output stream that can only output to a stream.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

This is an optimization pass for GlobalISel generic memory operations.

std::tuple< const DIScope *, const DIScope *, const DILocalVariable * > VarID

A unique key that represents a debug variable.

VariableID

Type wrapper for integer ID for Variables. 0 is reserved.

A CRTP mix-in that provides informational APIs needed for analysis passes.

A special type used by analysis passes to provide an address that identifies that particular analysis...

A CRTP mix-in to automatically provide informational APIs needed for passes.

Variable location definition used by FunctionVarLocs.

RawLocationWrapper Values

llvm::VariableID VariableID