DebugLocEntry.h Source File (original) (raw)

9#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H

10#define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H

13#include "llvm/Config/llvm-config.h"

20namespace llvm {

21class AsmPrinter;

34 }

35};

43 enum EntryType {

44 E_Location,

45 E_Integer,

46 E_ConstantFP,

47 E_ConstantInt,

48 E_TargetIndexLocation

49 };

50 enum EntryType EntryKind;

53 union {

59 union {

64 };

66public:

70 }

73 }

76 : EntryKind(E_TargetIndexLocation), TIL(Loc) {}

78 bool isLocation() const { return EntryKind == E_Location; }

80 return EntryKind == E_Location && Loc.isIndirect();

81 }

83 return EntryKind == E_TargetIndexLocation;

84 }

85 bool isInt() const { return EntryKind == E_Integer; }

86 bool isConstantFP() const { return EntryKind == E_ConstantFP; }

87 bool isConstantInt() const { return EntryKind == E_ConstantInt; }

94#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

105 }

106#endif

107};

108

109

110

112

114

116

117 bool IsVariadic;

118

119public:

121 : Expression(Expr), ValueLocEntries(Locs), IsVariadic(true) {}

122

124 bool IsVariadic)

125 : Expression(Expr), ValueLocEntries(Locs), IsVariadic(IsVariadic) {

126#ifndef NDEBUG

128 $any\_of$ (Locs, [](auto LE) { return LE.isLocation(); }));

129 if (!IsVariadic) {

131 }

132#endif

133 }

134

136 : Expression(Expr), ValueLocEntries(1, Loc), IsVariadic(false) {

138 "DBG_VALUE with a machine location must have a valid expression.");

139 }

140

145

146 if (ValueLocEntries.size() != Other.ValueLocEntries.size())

147 return false;

148 bool ThisIsIndirect =

149 !IsVariadic && ValueLocEntries[0].isIndirectLocation();

150 bool OtherIsIndirect =

151 Other .IsVariadic && Other.ValueLocEntries[0].isIndirectLocation();

152

154 Other.Expression, OtherIsIndirect))

155 return false;

156

157

158 if (ThisIsIndirect || OtherIsIndirect) {

163 }

164

165 return ValueLocEntries == Other.ValueLocEntries;

166 }

171#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

174 DV.dump();

177 }

178#endif

179};

180

181

182

184

187

188

189

191

192public:

193

194

195

198 : Begin(Begin), End(End) {

200 }

201

202

203

204

205

207

208 if (End != Next.Begin)

209 return false;

210 if (Values.size() != Next.Values.size())

211 return false;

212 for (unsigned EntryIdx = 0; EntryIdx < Values.size(); ++EntryIdx)

213 if (!Values[EntryIdx].isEquivalent(Next.Values[EntryIdx]))

214 return false;

215 End = Next.End;

216 return true;

217 }

218

226 return V.isFragment();

227 })) && "must either have a single value or multiple pieces");

228 }

229

230

231

233

234

235

236 if (Values.size() == 1)

237 return;

241 return A.getExpression() == B.getExpression();

242 }),

243 Values.end());

244 }

245

246

251};

252

253

255 if (A.EntryKind != B.EntryKind)

256 return false;

257

258 switch (A.EntryKind) {

259 case DbgValueLocEntry::E_Location:

260 return A.Loc == B.Loc;

261 case DbgValueLocEntry::E_TargetIndexLocation:

262 return A.TIL == B.TIL;

263 case DbgValueLocEntry::E_Integer:

264 return A.Constant.Int == B.Constant.Int;

265 case DbgValueLocEntry::E_ConstantFP:

266 return A.Constant.CFP == B.Constant.CFP;

267 case DbgValueLocEntry::E_ConstantInt:

268 return A.Constant.CIP == B.Constant.CIP;

269 }

271}

272

273

275 return A.ValueLocEntries == B.ValueLocEntries &&

276 A.Expression == B.Expression && A.IsVariadic == B.IsVariadic;

277}

278

279

282 return A.getExpression()->getFragmentInfo()->OffsetInBits <

283 B.getExpression()->getFragmentInfo()->OffsetInBits;

284}

285

286}

287

288#endif

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

This file contains the declarations for the subclasses of Constant, which represent the different fla...

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

This class is intended to be used as a driving class for all asm writers.

ConstantFP - Floating Point Values [float, double].

This is the shared class of boolean and integer constants.

This is an important base class in LLVM.

Basic type, like 'int' or 'float'.

bool isEntryValue() const

Check if the expression consists of exactly one entry value operand.

bool isFragment() const

Return whether this is a piece of an aggregate variable.

static bool isEqualExpression(const DIExpression *FirstExpr, bool FirstIndirect, const DIExpression *SecondExpr, bool SecondIndirect)

Determines whether two debug values should produce equivalent DWARF expressions, using their DIExpres...

A single location or constant within a variable location description, with either a single entry (wit...

DbgValueLocEntry(const ConstantFP *CFP)

TargetIndexLocation getTargetIndexLocation() const

MachineLocation Loc

Or a location in the machine frame.

friend bool operator==(const DbgValueLocEntry &, const DbgValueLocEntry &)

Compare two DbgValueLocEntries for equality.

const ConstantFP * getConstantFP() const

bool isConstantFP() const

DbgValueLocEntry(MachineLocation Loc)

DbgValueLocEntry(int64_t i)

bool isConstantInt() const

TargetIndexLocation TIL

Or a location from target specific location.

bool isIndirectLocation() const

const ConstantInt * getConstantInt() const

LLVM_DUMP_METHOD void dump() const

bool isTargetIndexLocation() const

MachineLocation getLoc() const

DbgValueLocEntry(const ConstantInt *CIP)

DbgValueLocEntry(TargetIndexLocation Loc)

The location of a single variable, composed of an expression and 0 or more DbgValueLocEntries.

DbgValueLoc(const DIExpression *Expr, DbgValueLocEntry Loc)

DbgValueLoc(const DIExpression *Expr, ArrayRef< DbgValueLocEntry > Locs, bool IsVariadic)

ArrayRef< DbgValueLocEntry > getLocEntries() const

DbgValueLoc(const DIExpression *Expr, ArrayRef< DbgValueLocEntry > Locs)

const DIExpression * getExpression() const

friend bool operator<(const DbgValueLoc &, const DbgValueLoc &)

Compare two fragments based on their offset.

friend bool operator==(const DbgValueLoc &, const DbgValueLoc &)

Compare two DbgValueLocs for equality.

LLVM_DUMP_METHOD void dump() const

bool isEquivalent(const DbgValueLoc &Other) const

This struct describes location entries emitted in the .debug_loc section.

DebugLocEntry(const MCSymbol *Begin, const MCSymbol *End, ArrayRef< DbgValueLoc > Vals)

Create a location list entry for the range [Begin, End).

void addValues(ArrayRef< DbgValueLoc > Vals)

ArrayRef< DbgValueLoc > getValues() const

const MCSymbol * getBeginSym() const

const MCSymbol * getEndSym() const

bool MergeRanges(const DebugLocEntry &Next)

Attempt to merge this DebugLocEntry with Next and return true if the merge was successful.

Builder for DebugLocStream lists.

Class representing an expression and its matching format.

MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...

iterator erase(const_iterator CI)

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

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

void dump() const

Support for debugging, callable in GDB: V->dump()

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

bool operator<(int64_t V1, const APSInt &V2)

bool all_of(R &&range, UnaryPredicate P)

Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.

auto unique(Range &&R, Predicate P)

bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

void sort(IteratorTy Start, IteratorTy End)

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

This struct describes target specific location.

TargetIndexLocation()=default

bool operator==(const TargetIndexLocation &Other) const

TargetIndexLocation(unsigned Idx, int64_t Offset)