Go to the documentation of this file.
31 cl::desc(
"Enable adding flow sensitive discriminators"));
37 DILocation::DILocation(
LLVMContext &
C, StorageType Storage,
unsigned Line,
40 :
MDNode(
C, DILocationKind, Storage, MDs) {
42 "Expected a scope and optional inlined-at");
45 assert(Column < (1u << 16) &&
"Expected 16-bit column");
47 SubclassData32 = Line;
48 SubclassData16 = Column;
50 setImplicitCode(ImplicitCode);
55 if (Column >= (1u << 16))
61 Metadata *InlinedAt,
bool ImplicitCode,
62 StorageType Storage,
bool ShouldCreate) {
74 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
92 auto *Merged = Locs[0];
95 if (Merged ==
nullptr)
110 for (
DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
111 InlinedLocationsA.
insert(L);
116 Locations.insert(std::make_pair(
S, L));
120 L = L->getInlinedAt();
124 S = LocB->getScope();
125 L = LocB->getInlinedAt();
127 if (Locations.count(std::make_pair(
S, L)))
132 L = L->getInlinedAt();
138 if (!
S || !isa<DILocalScope>(
S))
139 S = LocA->getScope();
145 std::array<unsigned, 3> Components = {BD,
DF, CI};
153 std::accumulate(Components.begin(), Components.end(), RemainingWork);
157 unsigned NextBitInsertionIndex = 0;
158 while (RemainingWork > 0) {
159 unsigned C = Components[
I++];
162 Ret |= (EC << NextBitInsertionIndex);
170 unsigned TBD, TDF, TCI = 0;
172 if (TBD == BD && TDF ==
DF && TCI == CI)
188 #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
189 #include "llvm/IR/DebugInfoFlags.def"
195 #define HANDLE_DI_FLAG(ID, NAME) \
197 return "DIFlag" #NAME;
198 #include "llvm/IR/DebugInfoFlags.def"
209 if (A == FlagPrivate)
210 SplitFlags.push_back(FlagPrivate);
211 else if (A == FlagProtected)
212 SplitFlags.push_back(FlagProtected);
214 SplitFlags.push_back(FlagPublic);
218 if (R == FlagSingleInheritance)
219 SplitFlags.push_back(FlagSingleInheritance);
220 else if (R == FlagMultipleInheritance)
221 SplitFlags.push_back(FlagMultipleInheritance);
223 SplitFlags.push_back(FlagVirtualInheritance);
226 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
227 Flags &= ~FlagIndirectVirtualBase;
228 SplitFlags.push_back(FlagIndirectVirtualBase);
231 #define HANDLE_DI_FLAG(ID, NAME) \
232 if (DIFlags Bit = Flags & Flag##NAME) { \
233 SplitFlags.push_back(Bit); \
236 #include "llvm/IR/DebugInfoFlags.def"
241 if (
auto *
T = dyn_cast<DIType>(
this))
242 return T->getScope();
244 if (
auto *SP = dyn_cast<DISubprogram>(
this))
245 return SP->getScope();
247 if (
auto *LB = dyn_cast<DILexicalBlockBase>(
this))
248 return LB->getScope();
250 if (
auto *NS = dyn_cast<DINamespace>(
this))
251 return NS->getScope();
253 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
254 return CB->getScope();
256 if (
auto *
M = dyn_cast<DIModule>(
this))
257 return M->getScope();
259 assert((isa<DIFile>(
this) || isa<DICompileUnit>(
this)) &&
260 "Unhandled type of scope.");
265 if (
auto *
T = dyn_cast<DIType>(
this))
267 if (
auto *SP = dyn_cast<DISubprogram>(
this))
268 return SP->getName();
269 if (
auto *NS = dyn_cast<DINamespace>(
this))
270 return NS->getName();
271 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
272 return CB->getName();
273 if (
auto *
M = dyn_cast<DIModule>(
this))
275 assert((isa<DILexicalBlockBase>(
this) || isa<DIFile>(
this) ||
276 isa<DICompileUnit>(
this)) &&
277 "Unhandled type of scope.");
283 return !
S || !
S->getString().empty();
291 StorageType Storage,
bool ShouldCreate) {
299 Hash =
Key.getHash();
301 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
312 void GenericDINode::recalculateHash() {
313 setHash(GenericDINodeInfo::KeyTy::calculateHash(
this));
316 #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
317 #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
318 #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
320 if (Storage == Uniqued) { \
321 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
322 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
327 assert(ShouldCreate && \
328 "Expected non-uniqued nodes to always be created"); \
331 #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
332 return storeImpl(new (array_lengthof(OPS), Storage) \
333 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
334 Storage, Context.pImpl->CLASS##s)
335 #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
336 return storeImpl(new (0u, Storage) \
337 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
338 Storage, Context.pImpl->CLASS##s)
339 #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
340 return storeImpl(new (array_lengthof(OPS), Storage) \
341 CLASS(Context, Storage, OPS), \
342 Storage, Context.pImpl->CLASS##s)
343 #define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \
344 return storeImpl(new (NUM_OPS, Storage) \
345 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
346 Storage, Context.pImpl->CLASS##s)
348 DISubrange::DISubrange(
LLVMContext &
C, StorageType Storage,
350 :
DINode(
C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
352 StorageType Storage,
bool ShouldCreate) {
362 int64_t Lo, StorageType Storage,
372 StorageType Storage,
bool ShouldCreate) {
383 assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) ||
384 isa<DIExpression>(CB)) &&
385 "Count must be signed constant or DIVariable or DIExpression");
387 if (
auto *MD = dyn_cast<ConstantAsMetadata>(CB))
388 return BoundType(cast<ConstantInt>(MD->getValue()));
390 if (
auto *MD = dyn_cast<DIVariable>(CB))
391 return BoundType(MD);
393 if (
auto *MD = dyn_cast<DIExpression>(CB))
394 return BoundType(MD);
404 assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) ||
405 isa<DIExpression>(LB)) &&
406 "LowerBound must be signed constant or DIVariable or DIExpression");
408 if (
auto *MD = dyn_cast<ConstantAsMetadata>(LB))
409 return BoundType(cast<ConstantInt>(MD->getValue()));
411 if (
auto *MD = dyn_cast<DIVariable>(LB))
412 return BoundType(MD);
414 if (
auto *MD = dyn_cast<DIExpression>(LB))
415 return BoundType(MD);
425 assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) ||
426 isa<DIExpression>(UB)) &&
427 "UpperBound must be signed constant or DIVariable or DIExpression");
429 if (
auto *MD = dyn_cast<ConstantAsMetadata>(UB))
430 return BoundType(cast<ConstantInt>(MD->getValue()));
432 if (
auto *MD = dyn_cast<DIVariable>(UB))
433 return BoundType(MD);
435 if (
auto *MD = dyn_cast<DIExpression>(UB))
436 return BoundType(MD);
446 assert((isa<ConstantAsMetadata>(
ST) || isa<DIVariable>(
ST) ||
447 isa<DIExpression>(
ST)) &&
448 "Stride must be signed constant or DIVariable or DIExpression");
450 if (
auto *MD = dyn_cast<ConstantAsMetadata>(
ST))
451 return BoundType(cast<ConstantInt>(MD->getValue()));
453 if (
auto *MD = dyn_cast<DIVariable>(
ST))
454 return BoundType(MD);
456 if (
auto *MD = dyn_cast<DIExpression>(
ST))
457 return BoundType(MD);
461 DIGenericSubrange::DIGenericSubrange(
LLVMContext &
C, StorageType Storage,
463 :
DINode(
C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange,
472 Metadata *Ops[] = {CountNode, LB, UB, Stride};
481 assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) &&
482 "Count must be signed constant or DIVariable or DIExpression");
484 if (
auto *MD = dyn_cast<DIVariable>(CB))
487 if (
auto *MD = dyn_cast<DIExpression>(CB))
498 assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) &&
499 "LowerBound must be signed constant or DIVariable or DIExpression");
501 if (
auto *MD = dyn_cast<DIVariable>(LB))
504 if (
auto *MD = dyn_cast<DIExpression>(LB))
515 assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) &&
516 "UpperBound must be signed constant or DIVariable or DIExpression");
518 if (
auto *MD = dyn_cast<DIVariable>(UB))
521 if (
auto *MD = dyn_cast<DIExpression>(UB))
532 assert((isa<DIVariable>(
ST) || isa<DIExpression>(
ST)) &&
533 "Stride must be signed constant or DIVariable or DIExpression");
535 if (
auto *MD = dyn_cast<DIVariable>(
ST))
538 if (
auto *MD = dyn_cast<DIExpression>(
ST))
544 DIEnumerator::DIEnumerator(
LLVMContext &
C, StorageType Storage,
547 :
DINode(
C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
553 StorageType Storage,
bool ShouldCreate) {
562 uint32_t AlignInBits,
unsigned Encoding,
563 DIFlags Flags, StorageType Storage,
575 case dwarf::DW_ATE_signed:
576 case dwarf::DW_ATE_signed_char:
578 case dwarf::DW_ATE_unsigned:
579 case dwarf::DW_ATE_unsigned_char:
591 unsigned Encoding, StorageType Storage,
602 DIType *DIDerivedType::getClassType()
const {
604 return cast_or_null<DIType>(getExtraData());
608 if (
auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
609 if (
auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
610 return static_cast<uint32_t>(CI->getZExtValue());
615 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
616 return C->getValue();
622 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
623 return C->getValue();
628 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
629 return C->getValue();
647 DWARFAddressSpace,
Flags),
698 if (CT->getTag() !=
Tag)
703 if (!CT->isForwardDecl() || (
Flags & DINode::FlagFwdDecl))
714 "Mismatched number of operands");
715 for (
unsigned I = 0,
E = CT->getNumOperands();
I !=
E; ++
I)
716 if (Ops[
I] != CT->getOperand(
I))
717 CT->setOperand(
I, Ops[
I]);
725 DIFlags Flags,
Metadata *Elements,
unsigned RuntimeLang,
740 if (CT->getTag() !=
Tag)
753 DISubroutineType::DISubroutineType(
LLVMContext &
C, StorageType Storage,
754 DIFlags Flags, uint8_t CC,
756 :
DIType(
C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0,
757 0, 0, 0, Flags, Ops),
772 :
DIScope(
C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
773 Checksum(CS),
Source(Src) {}
810 Source.getValueOr(
nullptr)};
813 DICompileUnit::DICompileUnit(
LLVMContext &
C, StorageType Storage,
816 uint64_t DWOId,
bool SplitDebugInlining,
819 :
DIScope(
C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
822 SplitDebugInlining(SplitDebugInlining),
823 DebugInfoForProfiling(DebugInfoForProfiling),
831 unsigned RuntimeVersion,
MDString *SplitDebugFilename,
834 uint64_t DWOId,
bool SplitDebugInlining,
bool DebugInfoForProfiling,
836 MDString *SDK, StorageType Storage,
bool ShouldCreate) {
854 Context,
Storage, SourceLanguage, IsOptimized,
855 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
856 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
887 return "LineTablesOnly";
889 return "DebugDirectivesOnly";
905 DISubprogram::DISubprogram(
LLVMContext &
C, StorageType Storage,
unsigned Line,
906 unsigned ScopeLine,
unsigned VirtualIndex,
907 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
909 :
DILocalScope(
C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
910 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
911 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
916 unsigned Virtuality,
bool IsMainSubprogram) {
918 static_assert(
int(SPFlagVirtual) ==
int(dwarf::DW_VIRTUALITY_virtual) &&
919 int(SPFlagPureVirtual) ==
920 int(dwarf::DW_VIRTUALITY_pure_virtual),
921 "Virtuality constant mismatch");
924 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
925 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
926 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
927 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
931 if (
auto *Block = dyn_cast<DILexicalBlockBase>(
this))
932 return Block->getScope()->getSubprogram();
933 return const_cast<DISubprogram *
>(cast<DISubprogram>(
this));
937 if (
auto *File = dyn_cast<DILexicalBlockFile>(
this))
938 return File->getScope()->getNonLexicalBlockFileScope();
944 #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
945 #include "llvm/IR/DebugInfoFlags.def"
954 #define HANDLE_DISP_FLAG(ID, NAME) \
956 return "DISPFlag" #NAME;
957 #include "llvm/IR/DebugInfoFlags.def"
968 #define HANDLE_DISP_FLAG(ID, NAME) \
969 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
970 SplitFlags.push_back(Bit); \
973 #include "llvm/IR/DebugInfoFlags.def"
980 unsigned ScopeLine,
Metadata *ContainingType,
unsigned VirtualIndex,
981 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
Metadata *Unit,
984 StorageType Storage,
bool ShouldCreate) {
1015 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
1019 bool DISubprogram::describes(
const Function *
F)
const {
1020 assert(
F &&
"Invalid function");
1021 return F->getSubprogram() ==
this;
1030 unsigned Column, StorageType Storage,
1031 bool ShouldCreate) {
1043 unsigned Discriminator,
1044 StorageType Storage,
1045 bool ShouldCreate) {
1054 :
DIScope(
Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops),
1055 ExportSymbols(ExportSymbols) {}
1058 StorageType Storage,
bool ShouldCreate) {
1068 :
DIScope(
Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
1074 StorageType Storage,
bool ShouldCreate) {
1084 :
DIScope(
Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops),
1085 LineNo(LineNo), IsDecl(IsDecl) {}
1090 unsigned LineNo,
bool IsDecl, StorageType Storage,
1091 bool ShouldCreate) {
1100 StorageType Storage,
1104 dwarf::DW_TAG_template_type_parameter, IsDefault,
1110 StorageType Storage,
bool ShouldCreate) {
1119 bool isDefault,
Metadata *
Value, StorageType Storage,
bool ShouldCreate) {
1131 Metadata *StaticDataMemberDeclaration,
1134 bool ShouldCreate) {
1157 unsigned Arg, DIFlags Flags,
uint32_t AlignInBits,
1159 bool ShouldCreate) {
1161 assert(Arg <= UINT16_MAX &&
"Expected argument number to fit in 16-bits");
1174 :
DINode(
C,
ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
1175 AlignInBits(AlignInBits) {}
1181 if (
auto *
T = dyn_cast<DIType>(RawType))
1185 if (
auto *DT = dyn_cast<DIDerivedType>(RawType)) {
1187 RawType = DT->getRawBaseType();
1199 DILabel::DILabel(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1201 :
DINode(
C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
1203 Metadata *File,
unsigned Line, StorageType Storage,
1204 bool ShouldCreate) {
1214 StorageType Storage,
bool ShouldCreate) {
1228 if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
1234 case dwarf::DW_OP_bregx:
1236 case dwarf::DW_OP_constu:
1237 case dwarf::DW_OP_consts:
1238 case dwarf::DW_OP_deref_size:
1239 case dwarf::DW_OP_plus_uconst:
1243 case dwarf::DW_OP_regx:
1253 if (
I->get() +
I->getSize() >
E->get())
1257 if ((
Op >= dwarf::DW_OP_reg0 &&
Op <= dwarf::DW_OP_reg31) ||
1258 (
Op >= dwarf::DW_OP_breg0 &&
Op <= dwarf::DW_OP_breg31))
1267 return I->get() +
I->getSize() ==
E->get();
1268 case dwarf::DW_OP_stack_value: {
1270 if (
I->get() +
I->getSize() ==
E->get())
1277 case dwarf::DW_OP_swap: {
1301 case dwarf::DW_OP_constu:
1302 case dwarf::DW_OP_plus_uconst:
1303 case dwarf::DW_OP_plus:
1304 case dwarf::DW_OP_minus:
1305 case dwarf::DW_OP_mul:
1306 case dwarf::DW_OP_div:
1307 case dwarf::DW_OP_mod:
1308 case dwarf::DW_OP_or:
1309 case dwarf::DW_OP_and:
1310 case dwarf::DW_OP_xor:
1311 case dwarf::DW_OP_shl:
1312 case dwarf::DW_OP_shr:
1313 case dwarf::DW_OP_shra:
1314 case dwarf::DW_OP_deref:
1315 case dwarf::DW_OP_deref_size:
1316 case dwarf::DW_OP_xderef:
1317 case dwarf::DW_OP_lit0:
1318 case dwarf::DW_OP_not:
1319 case dwarf::DW_OP_dup:
1320 case dwarf::DW_OP_regx:
1321 case dwarf::DW_OP_bregx:
1322 case dwarf::DW_OP_push_object_address:
1323 case dwarf::DW_OP_over:
1324 case dwarf::DW_OP_consts:
1338 for (
const auto &It :
expr_ops()) {
1339 switch (It.getOp()) {
1342 case dwarf::DW_OP_stack_value:
1360 for (
const auto &It :
expr_ops()) {
1361 switch (It.getOp()) {
1375 for (
auto I = Start;
I != End; ++
I)
1386 Ops.push_back(dwarf::DW_OP_plus_uconst);
1387 Ops.push_back(Offset);
1388 }
else if (Offset < 0) {
1389 Ops.push_back(dwarf::DW_OP_constu);
1390 Ops.push_back(-Offset);
1391 Ops.push_back(dwarf::DW_OP_minus);
1401 if (
getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
1402 Offset = Elements[1];
1406 if (
getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
1407 if (Elements[2] == dwarf::DW_OP_plus) {
1408 Offset = Elements[1];
1411 if (Elements[2] == dwarf::DW_OP_minus) {
1412 Offset = -Elements[1];
1424 SeenOps.
insert(ExprOp.getArg(0));
1432 unsigned &AddrClass) {
1435 const unsigned PatternSize = 4;
1436 if (Expr->Elements.size() >= PatternSize &&
1437 Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu &&
1438 Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap &&
1439 Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) {
1440 AddrClass = Expr->Elements[PatternSize - 3];
1442 if (Expr->Elements.size() == PatternSize)
1446 Expr->Elements.size() - PatternSize));
1455 Ops.push_back(dwarf::DW_OP_deref);
1459 Ops.push_back(dwarf::DW_OP_deref);
1470 assert(Expr &&
"Can't add ops to this expression");
1474 [](
auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
1476 "Location Index must be 0 for a non-variadic expression.");
1483 Op.appendToVector(NewOps);
1493 assert(Expr &&
"Can't replace args in this expression");
1499 Op.appendToVector(NewOps);
1508 NewOps.push_back(
Arg);
1516 assert(Expr &&
"Can't prepend ops to this expression");
1532 if (
Op.getOp() == dwarf::DW_OP_stack_value)
1535 Ops.push_back(dwarf::DW_OP_stack_value);
1539 Op.appendToVector(Ops);
1542 Ops.push_back(dwarf::DW_OP_stack_value);
1548 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1554 if (
Op.getOp() == dwarf::DW_OP_stack_value ||
1561 Op.appendToVector(NewOps);
1566 assert(
result->isValid() &&
"concatenated expression is not valid");
1572 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1575 return Op == dwarf::DW_OP_stack_value ||
1578 "Can't append this op");
1585 unsigned DropUntilStackValue = FI.
hasValue() ? 3 : 0;
1588 bool NeedsDeref = (Expr->
getNumElements() > DropUntilStackValue) &&
1589 (ExprOpsBeforeFragment.
back() != dwarf::DW_OP_stack_value);
1590 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.
empty();
1596 NewOps.push_back(dwarf::DW_OP_deref);
1598 if (NeedsStackValue)
1599 NewOps.push_back(dwarf::DW_OP_stack_value);
1604 const DIExpression *Expr,
unsigned OffsetInBits,
unsigned SizeInBits) {
1609 switch (
Op.getOp()) {
1612 case dwarf::DW_OP_shr:
1613 case dwarf::DW_OP_shra:
1614 case dwarf::DW_OP_shl:
1615 case dwarf::DW_OP_plus:
1616 case dwarf::DW_OP_plus_uconst:
1617 case dwarf::DW_OP_minus:
1626 uint64_t FragmentOffsetInBits =
Op.getArg(0);
1628 (void)FragmentSizeInBits;
1629 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
1630 "new fragment outside of original fragment");
1631 OffsetInBits += FragmentOffsetInBits;
1635 Op.appendToVector(Ops);
1638 assert(Expr &&
"Unknown DIExpression");
1640 Ops.push_back(OffsetInBits);
1641 Ops.push_back(SizeInBits);
1645 std::pair<DIExpression *, const ConstantInt *>
1653 bool Changed =
false;
1655 switch (
Op.getOp()) {
1668 if (
Op.getArg(1) == dwarf::DW_ATE_signed)
1671 assert(
Op.getArg(1) == dwarf::DW_ATE_unsigned &&
"Unexpected operand");
1676 Op.appendToVector(Ops);
1688 Result =
std::max(Result, ExprOp.getArg(0) + 1);
1690 "Expression is missing one or more location operands.");
1710 return SignedOrUnsignedConstant::SignedConstant;
1717 ? SignedOrUnsignedConstant::UnsignedConstant
1718 : SignedOrUnsignedConstant::SignedConstant;
1730 unsigned FromSize,
unsigned ToSize,
1738 bool ShouldCreate) {
1746 :
DINode(
C, DIObjCPropertyKind,
Storage, dwarf::DW_TAG_APPLE_property, Ops),
1752 Metadata *
Type, StorageType Storage,
bool ShouldCreate) {
1766 StorageType Storage,
1767 bool ShouldCreate) {
1777 bool ShouldCreate) {
1786 Metadata *Elements, StorageType Storage,
1787 bool ShouldCreate) {
1795 StorageType Storage,
bool ShouldCreate) {
1802 assert((!New || isa<ValueAsMetadata>(New)) &&
1803 "DIArgList must be passed a ValueAsMetadata");
1813 if (&VM == OldVMPtr) {
1821 if (uniquify() !=
this)
1826 void DIArgList::track() {
1831 void DIArgList::untrack() {
1836 void DIArgList::dropAllReferences() {
static DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
StringSwitch & Case(StringLiteral S, T Value)
static unsigned getNextComponentInDiscriminator(unsigned D)
Returns the next component stored in discriminator.
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata * Macros
LLVMContextImpl *const pImpl
Metadata * getRawLowerBound() const
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
static const char * nameTableKindString(DebugNameTableKind PK)
This is an optimization pass for GlobalISel generic memory operations.
static T * storeImpl(T *N, StorageType Storage, StoreT &Store)
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
uint64_t getNumLocationOperands() const
Return the number of unique location operands referred to (via DW_OP_LLVM_arg) in this expression; th...
static unsigned getUnsignedFromPrefixEncoding(unsigned U)
Reverse transformation as getPrefixEncodingFromUnsigned.
static Optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
int64_t bool MDString * Name
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Metadata MDString Metadata * File
Metadata * getRawCountNode() const
static const DILocation * getMergedLocation(const DILocation *LocA, const DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
unsigned StringRef DIFile * File
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString * Identifier
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata * ImportedEntities
LLVM_NODISCARD R Default(T Value)
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString MDString * SDK
Metadata Metadata MDString Metadata * File
const APInt & getValue() const
Return the constant as an APInt value reference.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const Module *M)
This lazily constructs the LazyValueInfoImpl.
static T * getUniqued(DenseSet< T *, InfoT > &Store, const typename InfoT::KeyTy &Key)
Optional< uint64_t > getSizeInBits() const
Determines the size of the variable's type.
String type, Fortran CHARACTER(n)
A single checksum, represented by a Kind and a Value (a string).
MDString MDString * Directory
Implements a dense probed hash-table based set with some number of buckets stored inline.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
DIFlags uint8_t Metadata * TypeArray
unsigned MDString Metadata unsigned Metadata * Scope
static unsigned encodingBits(unsigned C)
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata * TemplateParams
StringRef getName() const
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata * GlobalVariables
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata * TemplateParams
@ DW_OP_LLVM_tag_offset
Only used in LLVM metadata.
cl::opt< bool > EnableFSDiscriminator
bool isStaticMember() const
BoundType getUpperBound() const
Metadata Metadata MDString MDString * ConfigurationMacros
The instances of the Type class are immutable: once they are created, they are never changed.
Metadata MDString MDString Metadata * File
const_iterator end(StringRef path)
Get end iterator over path.
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
bool extractIfOffset(int64_t &Offset) const
If this is a constant offset, extract it.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata * Associated
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata * EnumTypes
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t AlignInBits
static DISPFlags splitFlags(DISPFlags Flags, SmallVectorImpl< DISPFlags > &SplitFlags)
Split up a flags bitfield for easier printing.
unsigned getSize() const
Return the size of the operand.
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata * RetainedTypes
unsigned MDString ArrayRef< Metadata * > DwarfOps
unsigned Metadata MDString * Producer
std::pair< iterator, bool > insert(const ValueT &V)
unsigned MDString Metadata unsigned Line
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata * Discriminator
unsigned Metadata * Scope
Metadata Metadata MDString MDString MDString * IncludePath
static const char * emissionKindString(DebugEmissionKind EK)
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t Optional< unsigned > DIFlags Flags
Metadata MDString Metadata unsigned Line
bool empty() const
empty - Check if the array is empty.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Metadata Metadata * Scope
dwarf::Tag getTag() const
unsigned unsigned DILocalScope DILocation * InlinedAt
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString * SysRoot
Metadata MDString Metadata * File
Annotations lets you mark points and ranges inside source code, for tests:
void storeDistinctInContext()
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s result
constexpr bool hasValue() const
static DICompositeType * getODRTypeIfExists(LLVMContext &Context, MDString &Identifier)
uint64_t getElement(unsigned I) const
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
This is the shared class of boolean and integer constants.
static DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
Metadata Metadata MDString * Name
const T & back() const
back - Get the last element.
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata * Unit
unsigned MDString Metadata Metadata Metadata uint64_t SizeInBits
@ Ref
The access may reference the value stored in memory.
BoundType getCount() const
MDString MDString Optional< ChecksumInfo< MDString * > > CS
DILocalScope * getNonLexicalBlockFileScope() const
Get the first non DILexicalBlockFile scope of this scope.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
(vector float) vec_cmpeq(*A, *B) C
Metadata MDString Metadata unsigned Metadata * Type
Metadata MDString MDString Metadata unsigned Metadata * Type
unsigned MDString * Header
unsigned Metadata Metadata * Entity
DISPFlags
Debug info subprogram flags.
Constant * getConstant() const
dwarf::Tag getTag() const
Metadata MDString Metadata unsigned Metadata unsigned DIFlags uint32_t AlignInBits
uint32_t getVBPtrOffset() const
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
unsigned unsigned Metadata * File
unsigned unsigned DILocalScope * Scope
into llvm powi allowing the code generator to produce balanced multiplication trees First
unsigned StringRef DIFile unsigned DIScope DIType uint64_t SizeInBits
unsigned getEncoding() const
static Optional< ChecksumKind > getChecksumKind(StringRef CSKindStr)
Flag
These should be considered private to the implementation of the MCInstrDesc class.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata * DataLocation
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata MDString * TargetFuncName
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
static void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, unsigned &CI)
Raw decoder for values in an encoded discriminator D.
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata Metadata * Allocated
Analysis containing CSE Info
DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops)
Metadata * getRawUpperBound() const
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata * Declaration
static DIFlags splitFlags(DIFlags Flags, SmallVectorImpl< DIFlags > &SplitFlags)
Split up a flags bitfield.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t AlignInBits
void handleChangedOperand(void *Ref, Metadata *New)
static DICompositeType * buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank, Metadata *Annotations)
Build a DICompositeType with the given ODR identifier.
static DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata * Elements
std::array< uint64_t, 6 > ExtOps
bool isImplicit() const
Return whether this is an implicit location description.
Metadata MDString MDString Metadata unsigned Line
Metadata MDString MDString * LinkageName
static unsigned encodeComponent(unsigned C)
@ DW_OP_LLVM_entry_value
Only used in LLVM metadata.
This is an important base class in LLVM.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t SizeInBits
Metadata MDString MDString * LinkageName
Constant * getStorageOffsetInBits() const
static const DIExpression * extractAddressClass(const DIExpression *Expr, unsigned &AddrClass)
Checks if the last 4 elements of the expression are DW_OP_constu <DWARF Address Space> DW_OP_swap DW_...
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Metadata * getRawType() const
static DIExpression * appendToStack(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Convert DIExpr into a stack value if it isn't one already by appending DW_OP_deref if needed,...
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Metadata Metadata MDString * Name
llvm::Optional< SignedOrUnsignedConstant > isConstant() const
Determine whether this represents a constant value, if so.
Metadata MDString MDString Metadata unsigned Metadata * Type
This is an important class for using LLVM in a threaded context.
initializer< Ty > init(const Ty &Val)
An imported module (C++ using directive or similar).
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Metadata Metadata MDString MDString MDString MDString * APINotesFile
unsigned unsigned Metadata Metadata * Elements
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static StringRef getFlagString(DISPFlags Flag)
unsigned StringRef uint64_t SizeInBits
Optional< Signedness > getSignedness() const
Return the signedness of this type, or None if this type is neither signed nor unsigned.
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t Optional< unsigned > DIFlags Metadata * ExtraData
static DIFlags getFlag(StringRef Flag)
BoundType getCount() const
static DIExpression * replaceArg(const DIExpression *Expr, uint64_t OldArg, uint64_t NewArg)
Create a copy of Expr with each instance of DW_OP_LLVM_arg, \p OldArg replaced with DW_OP_LLVM_arg,...
Basic type, like 'int' or 'float'.
Class for arbitrary precision integers.
BoundType getStride() const
Type array for a subprogram.
Class representing an expression and its matching format.
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
DIScope * getScope() const
static Optional< unsigned > encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI)
Raw encoding of the discriminator.
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t OffsetInBits
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t OffsetInBits
unsigned StringRef DIFile unsigned Line
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
Base class for template parameters.
@ DW_OP_LLVM_implicit_pointer
Only used in LLVM metadata.
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &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.
StringRef - Represent a constant reference to a string, i.e.
unsigned MDString Metadata Metadata Metadata uint64_t uint32_t AlignInBits
BoundType getStride() const
Tagged DWARF-like metadata node.
unsigned MDString Metadata * File
DebugEmissionKind getEmissionKind() const
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata * VTableHolder
MDString Metadata unsigned MDString MDString * SetterName
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
uint64_t getOp() const
Get the operand code.
Generic tagged DWARF-like metadata node.
unsigned Metadata Metadata Metadata * File
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t unsigned DIFlags Flags
An iterator for expression operands.
unsigned unsigned MDString * Name
LLVMContext & getContext() const
unsigned MDString Metadata Metadata Metadata * StringLocationExp
static Optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata * StaticDataMemberDeclaration
unsigned Metadata Metadata Metadata unsigned MDString * Name
unsigned Metadata MDString bool MDString unsigned MDString * SplitDebugFilename
BoundType getLowerBound() const
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Flags
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata * RetainedNodes
static void appendOffset(SmallVectorImpl< uint64_t > &Ops, int64_t Offset)
Append Ops with operations to apply the Offset.
static DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)
Prepend DIExpr with the given opcodes and optionally turn it into a stack value.
PointerUnion< DIVariable *, DIExpression * > BoundType
static IntegerType * getInt64Ty(LLVMContext &C)
static DIExpression * appendExt(const DIExpression *Expr, unsigned FromSize, unsigned ToSize, bool Signed)
Append a zero- or sign-extension to Expr.
bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
Base class for scope-like contexts.
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata * ThrownTypes
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
bool startsWithDeref() const
Return whether the first element a DW_OP_deref.
bool isComplex() const
Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...
unsigned Metadata MDString bool MDString * Flags
unsigned unsigned DILocalScope DILocation bool ImplicitCode
std::pair< DIExpression *, const ConstantInt * > constantFold(const ConstantInt *CI)
Try to shorten an expression with an initial constant operand.
ArrayRef< uint64_t > getElements() const
static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed)
Returns the ops for a zero- or sign-extension in a DIExpression.
@ DW_OP_LLVM_convert
Only used in LLVM metadata.
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata uint32_t AlignInBits
A pair of DIGlobalVariable and DIExpression.
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Holds the characteristics of one fragment of a larger variable.
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata * Annotations
static StringRef getFlagString(DIFlags Flag)
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata * Rank
unsigned MDString Metadata * Type
const uint64_t * get() const
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata * ContainingType
MDString Metadata unsigned MDString * GetterName
BoundType getLowerBound() const
DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, signed Line, ArrayRef< Metadata * > Ops, uint32_t AlignInBits=0)
bool hasAllLocationOps(unsigned N) const
Returns true iff this DIExpression contains at least one instance of DW_OP_LLVM_arg,...
static const DILocation * getMergedLocations(ArrayRef< const DILocation * > Locs)
Try to combine the vector of locations passed as input in a single one.
unsigned MDString Metadata * StringLength
Metadata MDString MDString Metadata * File
size_t size() const
size - Get the array size.
unsigned MDString Metadata Metadata * StringLengthExp
Align max(MaybeAlign Lhs, Align Rhs)
unsigned MDString Metadata unsigned Metadata Metadata * BaseType
Optional< DenseMap< const MDString *, DICompositeType * > > DITypeMap
unsigned getNumElements() const
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
expr_op_iterator expr_op_end() const
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
A switch()-like statement whose cases are string literals.
unsigned StringRef DIFile unsigned DIScope DIType * BaseType
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t AlignInBits
DebugNameTableKind getNameTableKind() const
Metadata * getRawStride() const
unsigned StringRef DIFile unsigned DIScope * Scope
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
StringRef getString() const
Constant * getDiscriminantValue() const
LLVM Value Representation.
static DISPFlags getFlag(StringRef Flag)
BoundType getUpperBound() const
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata * TemplateParams
iterator_range< expr_op_iterator > expr_ops() const
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
iterator insert(iterator I, T &&Elt)
Optional< FragmentInfo > getFragmentInfo() const
Retrieve the details of this fragment expression.
expr_op_iterator expr_op_begin() const
Visit the elements via ExprOperand wrappers.