LVScope.h Source File (original) (raw)

14#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H

15#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H

23#include

24#include

26namespace llvm {

30using LVNameInfo = std::pair<LVAddress, uint64_t>;

76 enum class Property {

77 HasDiscriminator,

78 CanHaveRanges,

79 CanHaveLines,

80 HasGlobals,

81 HasLocals,

82 HasLines,

83 HasScopes,

84 HasSymbols,

85 HasTypes,

86 IsComdat,

87 HasComdatScopes,

88 HasRanges,

89 AddedMissing,

90 LastEntry

91 };

99 static const LVTypes EmptyTypes;

100 static const LVSymbols EmptySymbols;

101 static const LVScopes EmptyScopes;

102

103

105

106

107 unsigned CoverageFactor = 0;

108

109

110 void calculateCoverage() {

111 float CoveragePercentage = 0;

113 CoveragePercentage);

114 }

115

116

117

118 bool resolvePrinting() const;

119

120

122

123

124

127

128protected:

129

130 std::unique_ptr Types;

132 std::unique_ptr Scopes;

133 std::unique_ptr Lines;

134 std::unique_ptr Ranges;

135

136

139

143

144

147

148public:

150 setIsScope();

151 setIncludeInPrint();

152 }

156

160

168 TransformName);

187

201

202 bool isCompileUnit() const override { return getIsCompileUnit(); }

203 bool isRoot() const override { return getIsRoot(); }

204

205 const char *kind() const override;

206

207

213

214

215

216

217

218

219

225

226

227

230

231 void addElement(LVElement *Element);

233 void addElement(LVScope *Scope);

234 void addElement(LVSymbol *Symbol);

238

239

240

242

243

244

247

248

254

255

257

258

260 bool RecordInvalid = false);

262 bool RecordInvalid = false);

263 void getRanges(LVRange &RangeList);

264

266

268 bool Full = true) const override;

269

270

272

273

274 bool getTemplateParameterTypes(LVTypes &Params);

275

276

278

282

283

284

285 StringRef resolveReferencesChain();

286

287 bool removeElement(LVElement *Element) override;

288 void updateLevel(LVScope *Parent, bool Moved) override;

289

292

293 void resolve() override;

294 void resolveName() override;

295 void resolveReferences() override;

296

297

298 void getQualifiedName(std::string &QualifiedName) const;

299

300 void encodeTemplateArguments(std::string &Name) const;

301 void encodeTemplateArguments(std::string &Name, const LVTypes *Types) const;

302

303 void resolveElements();

304

305

306

307

308 static void markMissingParents(const LVScopes *References,

310 bool TraverseChildren);

311

312

313

314 virtual void markMissingParents(const LVScope *Target, bool TraverseChildren);

315

316

317

318 virtual bool equalNumberOfChildren(const LVScope *Scope) const;

319

320

321 virtual bool equals(const LVScope *Scope) const;

322

323

324

325 static bool equals(const LVScopes *References, const LVScopes *Targets);

326

327

328

330

331

333

335

337 void printExtra(raw_ostream &OS, bool Full = true) const override;

340};

341

342

344 LVScope *Reference = nullptr;

345 size_t EncodedArgsIndex = 0;

346

347public:

352

353

356 Reference = Scope;

357 setHasReference();

358 }

362

367 EncodedArgsIndex = getStringPool().getIndex(EncodedArgs);

368 }

369

370

371 bool equals(const LVScope *Scope) const override;

372

373

374

376

377 void printExtra(raw_ostream &OS, bool Full = true) const override;

378};

379

380

382public:

384 setIsTemplateAlias();

385 setIsTemplate();

386 }

390

391

393

395};

396

397

399public:

404

406

407

409

411};

412

413

415

416 std::vector<size_t> Filenames;

417

418

419

420

421

423

424

425 size_t ProducerIndex = 0;

426

427

428 size_t CompilationDirectoryIndex = 0;

429

430

432

433

435

436

437

441

442

445

446

447

448

449

450 using LVAddressToLine = std::map<LVAddress, LVLine *>;

452

453

455

456

457

459

460

462

463

465

466

468

469

471

472

473 using LVSizesMap = std::map<const LVScope *, LVOffset>;

474 LVSizesMap Sizes;

475 LVOffset CUContributionSize = 0;

476

477

484 }

485

486

487

488 static constexpr size_t TotalInitialSize = 8;

489 using LVTotalsEntry = std::pair<unsigned, float>;

491

492

493 LVLevel MaxSeenLevel = 0;

494

495

498

502 }

504

505protected:

508

509public:

511 setIsCompileUnit();

512 }

516

520

521

524

527 PublicNames.emplace(std::piecewise_construct, std::forward_as_tuple(Scope),

528 std::forward_as_tuple(LowPC, HighPC - LowPC));

529 }

531 LVPublicNames::iterator Iter = PublicNames.find(Scope);

532 return (Iter != PublicNames.end()) ? Iter->second : NameNone;

533 }

535

536

537

538

539

541 return Ranges ? Ranges->front()->getLowerAddress() : 0;

542 }

543

545 return getStringPool().getString(CompilationDirectoryIndex);

546 }

548 CompilationDirectoryIndex = getStringPool().getIndex(CompilationDirectory);

549 }

550

555

560 ProducerIndex = getStringPool().getIndex(ProducerName);

561 }

562

565

568

569

571

573

574 void addInvalidCoverage(LVSymbol *Symbol);

575

577

579

581

585 return InvalidLocations;

586 }

588 return InvalidCoverages;

589 }

592

593

594 void processRangeLocationCoverage(

596

597

600 void propagatePatternMatch();

601

604

605 void printLocalNames(raw_ostream &OS, bool Full = true) const;

607 const char *Header) const;

608

609 void incrementPrintedLines();

610 void incrementPrintedScopes();

611 void incrementPrintedSymbols();

612 void incrementPrintedTypes();

613

614

616 void increment(LVScope *Scope);

617 void increment(LVSymbol *Symbol);

619

620

621

622

624 void addedElement(LVScope *Scope);

625 void addedElement(LVSymbol *Symbol);

627

629

630

631 bool equals(const LVScope *Scope) const override;

632

634 void printExtra(raw_ostream &OS, bool Full = true) const override;

635 void printWarnings(raw_ostream &OS, bool Full = true) const override;

636 void printMatchedElements(raw_ostream &OS, bool UseMatchedElements) override;

637};

638

639

641public:

646

647

649

651};

652

653

654

656public:

661

662

664

666};

667

668

670 LVScope *Reference = nullptr;

671 size_t LinkageNameIndex = 0;

672 size_t EncodedArgsIndex = 0;

673

674public:

679

680

683 Reference = Scope;

684 setHasReference();

685 }

689

694 EncodedArgsIndex = getStringPool().getIndex(EncodedArgs);

695 }

696

704

705 void setName(StringRef ObjectName) override;

706

707 void resolveExtra() override;

708 void resolveReferences() override;

709

710

711 bool equals(const LVScope *Scope) const override;

712

713

714

716

717 void printExtra(raw_ostream &OS, bool Full = true) const override;

718};

719

720

722 size_t CallFilenameIndex = 0;

725

726public:

731

734 Discriminator = Value;

735 setHasDiscriminator();

736 }

737

742 CallFilenameIndex = Index;

743 }

744

745

746

750

751 void resolveExtra() override;

752

753

754 bool equals(const LVScope *Scope) const override;

755

756

757

759

760 void printExtra(raw_ostream &OS, bool Full = true) const override;

761};

762

763

773

774

776public:

778 setIsModule();

779 setIsLexicalBlock();

780 }

784

785

787

789};

790

791

793 LVScope *Reference = nullptr;

794

795public:

800

801

804 Reference = Scope;

805 setHasReference();

806 }

810

811

812 bool equals(const LVScope *Scope) const override;

813

814

815

817

818 void printExtra(raw_ostream &OS, bool Full = true) const override;

819};

820

821

823 size_t FileFormatNameIndex = 0;

824

825public:

830

835 FileFormatNameIndex = getStringPool().getIndex(FileFormatName);

836 }

837

838

839

840 void transformScopedName();

841

842

843 void processRangeInformation();

844

845

846 bool equals(const LVScope *Scope) const override;

847

849 void printExtra(raw_ostream &OS, bool Full = true) const override;

851 bool UseMatchedElements) const;

852};

853

854

855

857public:

862

863

865

867};

868

869}

870}

871

872#endif

static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)

static SmallString< 128 > getFilename(const DIScope *SP, vfs::FileSystem &VFS)

Extract a filename for a DIScope.

Lightweight error class with error context and mandatory checking.

Pass interface - Implemented by all 'passes'.

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

StringRef - Represent a constant reference to a string, i.e.

Target - Wrapper for Target specific information.

The instances of the Type class are immutable: once they are created, they are never changed.

LLVM Value Representation.

virtual LVScope * getCompileUnitParent() const

LVElement(LVSubclassID ID)

static bool calculateCoverage(LVLocations *Locations, unsigned &Factor, float &Percentage)

std::string lineAsString(uint32_t LineNumber, LVHalf Discriminator, bool ShowZero) const

LVScopeAggregate & operator=(const LVScopeAggregate &)=delete

void setEncodedArgs(StringRef EncodedArgs) override

Definition LVScope.h:366

StringRef getEncodedArgs() const override

Definition LVScope.h:363

void setReference(LVScope *Scope) override

Definition LVScope.h:355

LVScope * getReference() const override

Definition LVScope.h:354

LVScopeAggregate(const LVScopeAggregate &)=delete

LVScopeAggregate()

Definition LVScope.h:348

~LVScopeAggregate() override=default

void setReference(LVElement *Element) override

Definition LVScope.h:359

LVScopeAlias(const LVScopeAlias &)=delete

bool equals(const LVScope *Scope) const override

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeAlias & operator=(const LVScopeAlias &)=delete

~LVScopeAlias() override=default

LVScopeAlias()

Definition LVScope.h:383

LVScopeArray()

Definition LVScope.h:400

void resolveExtra() override

~LVScopeArray() override=default

LVScopeArray(const LVScopeArray &)=delete

bool equals(const LVScope *Scope) const override

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeArray & operator=(const LVScopeArray &)=delete

const LVScopes & getMatchedScopes() const

Definition LVScope.h:603

static constexpr LVNameInfo NameNone

Definition LVScope.h:525

void printSummary(raw_ostream &OS) const override

const LVOffsetElementMap & getWarningOffsets() const

Definition LVScope.h:583

void addFilename(StringRef Name)

Definition LVScope.h:552

void setProducer(StringRef ProducerName) override

Definition LVScope.h:559

codeview::CPUType getCPUType()

Definition LVScope.h:567

~LVScopeCompileUnit() override=default

LVSourceLanguage getSourceLanguage() const override

Definition LVScope.h:563

void addMatched(LVElement *Element)

Definition LVScope.h:598

LVScopeCompileUnit & operator=(const LVScopeCompileUnit &)=delete

const LVOffsetLocationsMap & getInvalidRanges() const

Definition LVScope.h:590

const LVTagOffsetsMap & getDebugTags() const

Definition LVScope.h:582

LVScopeCompileUnit(const LVScopeCompileUnit &)=delete

void addMatched(LVScope *Scope)

Definition LVScope.h:599

const LVOffsetSymbolMap & getInvalidCoverages() const

Definition LVScope.h:587

const LVPublicNames & getPublicNames() const

Definition LVScope.h:534

void setCPUType(codeview::CPUType Type)

Definition LVScope.h:566

void addInvalidOffset(LVOffset Offset, LVElement *Element)

void setCompilationDirectory(StringRef CompilationDirectory)

Definition LVScope.h:547

LVAddress getBaseAddress() const

Definition LVScope.h:540

const LVElements & getMatchedElements() const

Definition LVScope.h:602

const LVOffsetLinesMap & getLinesZero() const

Definition LVScope.h:591

StringRef getCompilationDirectory() const

Definition LVScope.h:544

LVScopeCompileUnit()

Definition LVScope.h:510

void addPublicName(LVScope *Scope, LVAddress LowPC, LVAddress HighPC)

Definition LVScope.h:526

const LVOffsetLocationsMap & getInvalidLocations() const

Definition LVScope.h:584

void printSizes(raw_ostream &OS) const override

StringRef getProducer() const override

Definition LVScope.h:556

const LVNameInfo & findPublicName(LVScope *Scope)

Definition LVScope.h:530

void setSourceLanguage(LVSourceLanguage SL) override

Definition LVScope.h:564

LVScope * getCompileUnitParent() const override

Definition LVScope.h:517

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeEnumeration(const LVScopeEnumeration &)=delete

LVScopeEnumeration & operator=(const LVScopeEnumeration &)=delete

LVScopeEnumeration()

Definition LVScope.h:642

bool equals(const LVScope *Scope) const override

~LVScopeEnumeration() override=default

~LVScopeFormalPack() override=default

LVScopeFormalPack(const LVScopeFormalPack &)=delete

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeFormalPack & operator=(const LVScopeFormalPack &)=delete

LVScopeFormalPack()

Definition LVScope.h:657

bool equals(const LVScope *Scope) const override

~LVScopeFunctionInlined() override=default

LVScopeFunctionInlined(const LVScopeFunctionInlined &)=delete

void setDiscriminator(uint32_t Value) override

Definition LVScope.h:733

LVScopeFunctionInlined & operator=(const LVScopeFunctionInlined &)=delete

uint32_t getCallLineNumber() const override

Definition LVScope.h:738

LVScopeFunctionInlined()

Definition LVScope.h:727

void setCallLineNumber(uint32_t Number) override

Definition LVScope.h:739

uint32_t getDiscriminator() const override

Definition LVScope.h:732

std::string lineNumberAsString(bool ShowZero=false) const override

Definition LVScope.h:747

size_t getCallFilenameIndex() const override

Definition LVScope.h:740

void setCallFilenameIndex(size_t Index) override

Definition LVScope.h:741

~LVScopeFunctionType() override=default

LVScopeFunctionType(const LVScopeFunctionType &)=delete

void resolveExtra() override

LVScopeFunctionType()

Definition LVScope.h:766

LVScopeFunctionType & operator=(const LVScopeFunctionType &)=delete

void setLinkageName(StringRef LinkageName) override

Definition LVScope.h:697

LVScopeFunction()

Definition LVScope.h:675

LVScope * getReference() const override

Definition LVScope.h:681

void setEncodedArgs(StringRef EncodedArgs) override

Definition LVScope.h:693

size_t getLinkageNameIndex() const override

Definition LVScope.h:703

LVScopeFunction(const LVScopeFunction &)=delete

void setReference(LVScope *Scope) override

Definition LVScope.h:682

StringRef getEncodedArgs() const override

Definition LVScope.h:690

LVScopeFunction & operator=(const LVScopeFunction &)=delete

StringRef getLinkageName() const override

Definition LVScope.h:700

~LVScopeFunction() override=default

void setReference(LVElement *Element) override

Definition LVScope.h:686

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeModule & operator=(const LVScopeModule &)=delete

LVScopeModule(const LVScopeModule &)=delete

bool equals(const LVScope *Scope) const override

LVScopeModule()

Definition LVScope.h:777

~LVScopeModule() override=default

~LVScopeNamespace() override=default

LVScopeNamespace & operator=(const LVScopeNamespace &)=delete

LVScopeNamespace(const LVScopeNamespace &)=delete

LVScope * getReference() const override

Definition LVScope.h:802

LVScopeNamespace()

Definition LVScope.h:796

void setReference(LVScope *Scope) override

Definition LVScope.h:803

void setReference(LVElement *Element) override

Definition LVScope.h:807

LVScopeRoot & operator=(const LVScopeRoot &)=delete

StringRef getFileFormatName() const

Definition LVScope.h:831

LVScopeRoot()

Definition LVScope.h:826

void setFileFormatName(StringRef FileFormatName)

Definition LVScope.h:834

LVScopeRoot(const LVScopeRoot &)=delete

~LVScopeRoot() override=default

~LVScopeTemplatePack() override=default

void printExtra(raw_ostream &OS, bool Full=true) const override

LVScopeTemplatePack()

Definition LVScope.h:858

bool equals(const LVScope *Scope) const override

LVScopeTemplatePack(const LVScopeTemplatePack &)=delete

LVScopeTemplatePack & operator=(const LVScopeTemplatePack &)=delete

LVScope()

Definition LVScope.h:149

virtual LVScope * getReference() const

Definition LVScope.h:277

LVScope & operator=(const LVScope &)=delete

static LVScopeDispatch & getDispatch()

Definition LVScope.h:334

const LVLines * getLines() const

Definition LVScope.h:208

virtual void printSummary(raw_ostream &OS) const

Definition LVScope.h:142

PROPERTY(Property, CanHaveLines)

KIND_2(LVScopeKind, IsBlock, CanHaveRanges, CanHaveLines)

KIND_1(LVScopeKind, IsLexicalBlock, IsBlock)

bool isCompileUnit() const override

Definition LVScope.h:202

KIND(LVScopeKind, IsEnumeration)

static bool classof(const LVElement *Element)

Definition LVScope.h:157

KIND(LVScopeKind, IsTemplatePack)

PROPERTY(Property, HasLines)

PROPERTY(Property, HasTypes)

const LVScopes * getScopes() const

Definition LVScope.h:210

KIND_1(LVScopeKind, IsSubprogram, IsFunction)

LVElementsView getChildren() const

Definition LVScope.h:220

PROPERTY(Property, HasDiscriminator)

PROPERTY(Property, HasLocals)

PROPERTY(Property, HasGlobals)

void printActiveRanges(raw_ostream &OS, bool Full=true) const

size_t scopeCount() const

Definition LVScope.h:251

KIND_1(LVScopeKind, IsCallSite, IsFunction)

size_t lineCount() const

Definition LVScope.h:249

const LVSymbols * getSymbols() const

Definition LVScope.h:211

KIND(LVScopeKind, IsTemplate)

PROPERTY(Property, HasSymbols)

virtual void printMatchedElements(raw_ostream &OS, bool UseMatchedElements)

Definition LVScope.h:339

PROPERTY(Property, CanHaveRanges)

virtual void setEncodedArgs(StringRef EncodedArgs)

Definition LVScope.h:146

void printEncodedArgs(raw_ostream &OS, bool Full) const

PROPERTY(Property, IsComdat)

bool isRoot() const override

Definition LVScope.h:203

KIND(LVScopeKind, IsNamespace)

PROPERTY(Property, AddedMissing)

KIND(LVScopeKind, IsTemplateAlias)

PROPERTY(Property, HasScopes)

KIND_3(LVScopeKind, IsCompileUnit, CanHaveRanges, CanHaveLines, TransformName)

std::unique_ptr< LVLocations > Ranges

Definition LVScope.h:134

KIND_1(LVScopeKind, IsUnion, IsAggregate)

~LVScope() override=default

KIND(LVScopeKind, IsMember)

std::unique_ptr< LVSymbols > Symbols

Definition LVScope.h:131

const LVTypes * getTypes() const

Definition LVScope.h:212

KIND_1(LVScopeKind, IsCatchBlock, IsBlock)

LVScope * getCompileUnitParent() const override

Definition LVScope.h:279

KIND_1(LVScopeKind, IsTryBlock, IsBlock)

KIND_2(LVScopeKind, IsModule, CanHaveRanges, CanHaveLines)

virtual void printSizes(raw_ostream &OS) const

Definition LVScope.h:141

std::unique_ptr< LVTypes > Types

Definition LVScope.h:130

LVScope(const LVScope &)=delete

uint32_t getBitSize() const override

Definition LVScope.h:290

KIND_1(LVScopeKind, IsStructure, IsAggregate)

virtual StringRef getEncodedArgs() const

Definition LVScope.h:145

std::unique_ptr< LVLines > Lines

Definition LVScope.h:133

KIND(LVScopeKind, IsAggregate)

unsigned getCoverageFactor() const

Definition LVScope.h:265

KIND_1(LVScopeKind, IsLabel, IsFunction)

void setBitSize(uint32_t Size) override

Definition LVScope.h:291

virtual void printWarnings(raw_ostream &OS, bool Full=true) const

Definition LVScope.h:338

KIND_1(LVScopeKind, IsFunctionType, IsFunction)

std::unique_ptr< LVScopes > Scopes

Definition LVScope.h:132

const LVLocations * getRanges() const

Definition LVScope.h:209

size_t typeCount() const

Definition LVScope.h:253

PROPERTY(Property, HasComdatScopes)

KIND_1(LVScopeKind, IsRoot, TransformName)

KIND_1(LVScopeKind, IsClass, IsAggregate)

PROPERTY(Property, HasRanges)

KIND(LVScopeKind, IsArray)

size_t symbolCount() const

Definition LVScope.h:252

KIND_1(LVScopeKind, IsEntryPoint, IsFunction)

size_t rangeCount() const

Definition LVScope.h:250

KIND_2(LVScopeKind, IsFunction, CanHaveRanges, CanHaveLines)

KIND_2(LVScopeKind, IsInlinedFunction, IsFunction, IsInlined)

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

CPUType

These values correspond to the CV_CPU_TYPE_e enumeration, and are documented here: https://msdn....

std::pair< LVAddress, uint64_t > LVNameInfo

Definition LVScope.h:30

std::map< LVOffset, LVElement * > LVOffsetElementMap

Definition LVScope.h:68

LLVM_ABI LVStringPool & getStringPool()

SmallVector< LVElement *, 8 > LVElements

bool(LVScope::*)() const LVScopeGetFunction

std::map< LVOffset, LVLines > LVOffsetLinesMap

Definition LVScope.h:69

std::map< LVOffset, LVLocations > LVOffsetLocationsMap

Definition LVScope.h:70

void addItem(MapType *Map, KeyType Key, ValueType Value)

SmallVector< LVScope *, 8 > LVScopes

std::map< LVScopeKind, LVScopeGetFunction > LVScopeDispatch

Definition LVScope.h:65

bool(LVLocation::*)() LVValidLocation

LVSortValue(*)(const LVObject *LHS, const LVObject *RHS) LVSortFunction

void(LVScope::*)() LVScopeSetFunction

LVScopeKind

Definition LVScope.h:36

@ IsClass

Definition LVScope.h:42

@ IsCatchBlock

Definition LVScope.h:41

@ IsTryBlock

Definition LVScope.h:60

@ IsInlinedFunction

Definition LVScope.h:48

@ IsUnion

Definition LVScope.h:61

@ IsStructure

Definition LVScope.h:55

@ IsFunction

Definition LVScope.h:46

@ IsEntryPoint

Definition LVScope.h:44

@ IsSubprogram

Definition LVScope.h:56

@ IsArray

Definition LVScope.h:38

@ IsCompileUnit

Definition LVScope.h:43

@ IsCallSite

Definition LVScope.h:40

@ IsTemplatePack

Definition LVScope.h:59

@ IsEnumeration

Definition LVScope.h:45

@ IsBlock

Definition LVScope.h:39

@ IsRoot

Definition LVScope.h:54

@ IsNamespace

Definition LVScope.h:53

@ IsLabel

Definition LVScope.h:49

@ IsFunctionType

Definition LVScope.h:47

@ IsMember

Definition LVScope.h:51

@ IsModule

Definition LVScope.h:52

@ IsTemplateAlias

Definition LVScope.h:58

@ IsLexicalBlock

Definition LVScope.h:50

@ IsTemplate

Definition LVScope.h:57

detail::concat_range< LVElement *const, const LVScopes &, const LVTypes &, const LVSymbols & > LVElementsView

SmallVector< LVSymbol *, 8 > LVSymbols

LLVM_ABI LVSortFunction getSortFunction()

std::set< LVScopeKind > LVScopeKindSet

Definition LVScope.h:64

std::map< LVScope *, LVNameInfo > LVPublicNames

Definition LVScope.h:31

std::map< dwarf::Tag, LVOffsets > LVTagOffsetsMap

Definition LVScope.h:72

std::pair< LVLine *, LVLine * > LVLineRange

std::vector< LVScopeGetFunction > LVScopeRequest

Definition LVScope.h:66

SmallVector< LVLine *, 8 > LVLines

bool(LVObject::*)() const LVObjectGetFunction

std::map< LVOffset, LVSymbol * > LVOffsetSymbolMap

Definition LVScope.h:71

SmallVector< LVType *, 8 > LVTypes

void(LVObject::*)() LVObjectSetFunction

SmallVector< LVLocation *, 8 > LVLocations

std::map< LVAddress, LVNameInfo > LVPublicAddresses

Definition LVScope.h:32

This is an optimization pass for GlobalISel generic memory operations.

detail::concat_range< ValueT, RangeTs... > concat(RangeTs &&...Ranges)

Returns a concatenated range across two or more ranges.

void sort(IteratorTy Start, IteratorTy End)

A source language supported by any of the debug info representations.