[llvm-debuginfo-analyzer] 08a - Memory Management

[CarlosAlbertoEnciso]

Summary

LLVM debug information visual analyzer

For more information, see the RFC https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

Patches:
01 - Interval Tree
02 - Driver and Documentation
03 - Logical Elements
04 - Locations and Ranges
05 - Select Elements
06 - Warning and Internal Options
07 - Compare Elements
08 - ELF Reader
08a - Memory Management
09 - CodeView Reader

This is a high level summary of the changes in this patch.

Memory Management

• Use SpecificBumpPtrAllocator for memory management.

[dblaikie]

(some suggestions here might be too noisy to do all in this review - maybe a matter of splitting things up - the discussion about new data structures/changes in ownership might be one of those worth breaking down into smaller steps, not sure)

Perhaps some general discussion about the ownership/lifetime model of everything here would be useful to add to the patch description to get a general lay of the land?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVObject.h

84–85

Looks like these are unused, should they be removed?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

82

This addition of a new owning data structure (similar to some other comments I've made) makes me a bit uncomfortable - were there existing memory ownership issues in this code that this is addressing, or was the existing ownership hard to model in C++ explicit ownership? Or some other reason this is being introduced?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

119–132

Don't need the = nullptr for std::unique_ptr, that's the default behavior of the default ctor. (this is one of the reasons I'm a bit reticent to use aliases for unique_ptr names - I'm not sure the name shortening is worth the benefit compared to the obfuscation of these sort of core types with known semantics - might be better to keep the explicit unique_ptr usage here/generally?)

492

Remove this, since it's restating the default behavior of the implicit dtor?

553–563

Are these incidental/unrelated fixes? Maybe pre-commit/post-commit them to keep this patch more focussed? (oh, I guess maybe they're motivated by this patch because without unique_ptr these types were copyable, but probably weren't intended to be copied here anyway - so precommit cleanup might be suitable?)

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h

134–135

Maybe simplify this?

150–151

Remove this, since it's the default?
(& could probably remove the default ctor too, separately, since that's the default as well)

173–174

173–174

(I'd probably skip naming a variable here, FWIW - and roll the initialization into the return)

199–201

(or otherwise avoid the need to call .get() on one line only to dereference on the next (eg: if you find the named variable important for readability, change its type to a reference - and do type &x = *y; for (... : x) instead of .get()+*, perhaps))

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

76

Remove this default?

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

30

If there are going to be aliases for unique_ptr types, maybe worth using a consistent suffix (this one is Obj, others are Ptr) - and maybe SP rather than Ptr, to make it clear it's a smart pointer? But generally I'd avoid the aliases & find that seeing unique_ptr is probably sufficiently more clear to readers so as to be worth the extra characters required.

73–74

remove this default?

83

I /think/ we can write this as return Err; now we're using C++17?

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

155–156

Perhaps?

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVCodeViewVisitor.h

286 ↗

(On Diff #475097)

Remove this because it's the same as the default?

llvm/lib/DebugInfo/LogicalView/Core/LVLocation.cpp

583

push_back is probably fine here, since it's just calling an implicit move ctor, rather than any explicit operation?

608–609

(or remove the named variable entirely, perhaps - and roll the expressions together into Entries->front()->getOpcode())

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

130–131

There's a lot of code like this - Lines here, Children above, Ranges and Scopes below, etc - are they all needed, or could some of them be turned into direct values (eg: LVLines Lines rather than unique_ptr<LVLines> Lines?)?

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

299–307

Perhaps this'd be simpler as:

also - if this function never returns null, it should probably return by reference instead of pointer?

And if this map never contains null elements, perhaps it could contain values, instead of unique_ptrs? (they still have pointer stability in a std::map - so that probably is enough?)

372

What's the ownership model for "Instructions"/why did DiscoveredLines get introduced in this patch? (was there a memory ownership issue in the raw-new-using code that this is addressing? Otherwise I Wouldn't expect to see new containers in this patch)

806–807

Probably turn this into a reference? (could do that sort of thing pre or postpatch I guess)

[CarlosAlbertoEnciso]

In D137933#3925820, @dblaikie wrote:

(some suggestions here might be too noisy to do all in this review - maybe a matter of splitting things up - the discussion about new data structures/changes in ownership might be one of those worth breaking down into smaller steps, not sure)

Perhaps some general discussion about the ownership/lifetime model of everything here would be useful to add to the patch description to get a general lay of the land?

First of all, thanks very much for your reviews.
I have addressed some of them. Tomorrow I will finish the remaining (including a general discussion about the ownership/lifetime) and upload a new patch.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVObject.h

84–85

Good finding. They are unused. Removed

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

119–132

Happy to remove all the aliases for std::unique_ptr and keep the explicit unique_ptr.

std::unique_ptr<LVElements> Children;

492

Changed to ~LVScopeCompileUnit() = default; just for consistency with other LVScopexxx definitions.

May be in a post-commit: remove all default dtors.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h

134–135

Nice simplification. Changed to
(*Map)[Key].push_back(Value);

150–151

Removed both default ctor and dtor.

173–174

Removed the extra parenthesis.

173–174

Removed the extra variable.

199–201

Removed extra parenthesis.
Keep named variable for readability.

Changed to

for (typename LVFirstMapType::const_reference FirstEntry : FirstMap) {
  LVSecondMapType &SecondMap = *FirstEntry.second;
  for (typename LVSecondMapType::const_reference SecondEntry : SecondMap)
    Values.push_back(SecondEntry.second);
}

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

30

Happy to remove all the aliases for std::unique_ptr and keep the explicit unique_ptr.

using LVReaders = std::vector<std::unique_ptr<LVReader>>;

73–74

Removed.

83

You are correct. Changed to return Err;.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

155–156

Nice simplification.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVCodeViewVisitor.h

286 ↗

(On Diff #475097)

Removed.

llvm/lib/DebugInfo/LogicalView/Core/LVLocation.cpp

583

Good point. Changed to push_back.

608–609

Nice simplification. Changed to
if (dwarf::DW_OP_fbreg == Entries->front()->getOpcode())

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

130–131

This is a good question. They are all needed.
The reason to define Lines, Children, Ranges, Scopes, etc in that way is to keep the size of LVScope as small as possible.

struct LVLines {};

class ClassPointer {
  std::unique_ptr<SmallVector<LVLines *>> Lines;
};

class ClassVector {
  SmallVector<LVLines *,2> Lines; 
};

ClassPointer size = 8 bytes
ClassVector size = 32 bytes

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

806–807

Removed the extra parenthesis.
Changing LVLines *InlineeLines to reference can be done as a postpatch.
Adding

// TODO: Convert this into a reference.
LVLines *InlineeLines = InlineeIter->second.get();

[dblaikie]

(pulling this discussion about new data structures out of line as I think it'll take more words/quoting/etc than are easy to do in inline comments)

There's a lot of code like this - Lines here, Children above, Ranges and Scopes below, etc - are they all needed, or could some of them be turned into direct values (eg: LVLines Lines rather than unique_ptr<LVLines> Lines?)?

This is a good question. They are all needed.
The reason to define Lines, Children, Ranges, Scopes, etc in that way is to keep the size of LVScope as small as possible.

struct LVLines {};

class ClassPointer {
  std::unique_ptr<SmallVector<LVLines *>> Lines;
};

class ClassVector {
 SmallVector<LVLines *,2> Lines; 
};

ClassPointer size = 8 bytes
ClassVector size = 32 bytes

Could you expand on this a bit - what's the current ownership model (before moving to smart pointers)? (which things are owned by what/tracked where - where are the raw pointers stored/what code is responsible for cleaning them up) Maybe take one of these lists as an example.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

553–563

but probably weren't intended to be copied here anyway

You are correct. Created https://reviews.llvm.org/D138092

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

76

Keep it just for consistency with other LVScopexxx definitions.

May be in a post-commit: remove all default dtors.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

299–307

Nice simplification.
Changed to

LVSectionRanges::iterator IterSection = SectionRanges.find(SectionIndex);
if (IterSection == SectionRanges.end())
  IterSection =
      SectionRanges.emplace(SectionIndex, std::make_unique<LVRange>()).first;
LVRange *Range = IterSection->second.get();
assert(Range && "Range is null.");
return Range;

299–307

also - if this function never returns null, it should probably return by reference instead of pointer?

And if this map never contains null elements, perhaps it could contain values, instead of unique_ptrs? (they still have pointer stability in a std::map - so that probably is enough?)

What is your preference on those changes:
Part of this patch or post-commit?

[CarlosAlbertoEnciso]

The main logical unit is the LVReader, which is the main access point from the user point of view. Its functions are:

• Load the binary file
• Parse the debug information
• Create the logical view which is a tree composed of logical elements (LVScopes, LVSymbols, LVTypes and LVLines, etc.). Depending on the command line options, additional information is added to the those logical elements.
• Print the logical view.
• Select logical elements using user criterias.
• Compare two `logical views'.

This is a very broad relationship between the reader and the logical elements.

class LVReader {
  ...
  LVScopeRoot *Root = nullptr;
  ...
  // Allocated logical elements.
  SmallVector<std::unique_ptr<LVObject>> AllocatedObjects;
  ...
  createScopes() {
    Root = createObject<LVScopeRoot>();
  }
  ...
  doPrint()
  ...
  createObject(...)
}

class LVELFReader <- LVReader {
  ...
}

class LVCodeViewReader <- LVReader {
  ...
}

Root represents the loaded binary file.

The different Readers are created by the Reader Handler based on the binary files format. It records each created reader.

class LVReaderHandler {
  LVReaders TheReaders;
  ...
  createReaders();
  printReaders();
  compareReaders();
  ...
}

class LVScope <- LVObject {
  std::unique_ptr<LVTypes> Types;
  std::unique_ptr<LVSymbols> Symbols;
  std::unique_ptr<LVScopes> Scopes;
  std::unique_ptr<LVLines> Lines;
}

class LVScopeRoot <- LVScope {
   ...
}

A LVScope can represent a compile unit, function, lexical block, etc.

The other logical elements:

class LVLine <- LVObject {
  ...
}

class LVSymbol <- LVObject {
  ...
}

class LVType <- LVObject {
  ...
}

[CarlosAlbertoEnciso]

Owner	What	Tracked
LVReaderHander	LVReader	TheReaders
LVReader	Logical Elements	AllocatedObjects
LVReader	LVLineAssembler	DiscoveredLines

The raw pointers for the logical elements are stored in the LVScope: Types, Symbols, Scopes, Lines, etc.
The AllocatedObjects was introduced to record their smart pointers, to minimize the changes across the tool.

// Creates a logical object and records it in the Reader.
template <typename ObjectType> ObjectType *createObject() {
  std::unique_ptr<LVObject> ObjectSP = std::make_unique<ObjectType>();
  LVObject *Object = ObjectSP.get();
  AllocatedObjects.emplace_back(std::move(ObjectSP));
  return (ObjectType *)Object;
}

createObject is use to create any logical element within the tool or in the unittests.
DiscoveredLines are the lines created to represent the disassembly instructions. Those LVLineAssembler are moved to the Lines container in the LVScope.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

82

or was the existing ownership hard to model in C++ explicit ownership? Or some other reason this is being introduced?

Correct.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

372

The raw-new-using code stored those 'Instructions' in the 'LVDoubleMap` container. It was not very clear.
Now they are stored at the Reader scope.

[CarlosAlbertoEnciso]

Updated patch addressing @dblaikie review.

[dblaikie]

The AllocatedObjects was introduced to record their smart pointers, to minimize the changes across the tool.

This is probably the core of what I'm concerned about & the reason for more up-front review. If the logical ownership is for each node to own its children, then that's what I'd probably want to see here, rather than introducing a side table ownership "bucket".

It'd be good if this change didn't move ownership around - but mapped the ownership directly from the C code, where it's not too convoluted. Or if there's good reason (other than code churn, like "even if we were continuing to use raw new/delete, we would still want to change the ownership in this way") to change the ownership models at the same time I think more details about the old ownership and new ownership and why the new one is better would be suitable to have in the patch description.

As it stands, trees owning their children seems fine (though possibly slow to cleanup but the currently proposed change in ownership doesn't look like it'd speed that up much, and would increase memory usage I think - if perf is a problem, it might be worth considering one of LLVM's BumpPtrAllocator - if nodes are only ever allocated in one pass, never manipulated/created/destroyed later - maybe that's the good/correct and simpler path (not correct because it's simpler, but independently)?)

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

497

Perhaps as follow-up, this could/should be changed to a reference variable, then the next line (checking non-null) would be more obviously unneeded for instance.

(similarly in the several other cases above/below)

[CarlosAlbertoEnciso]

@dblaikie: I am sorry for my delay in addressing your feedback/concerns. I just came last week from a long annual leave (from Nov 19th).

[CarlosAlbertoEnciso]

Address @dblaikie concerns on the use of a bucket with smart pointers.

This patch uses a SpecificBumpPtrAllocator to manage the creation of logical elements.

[CarlosAlbertoEnciso]

I have explored several options for how to model the pointer ownership, and I think SpecificBumpPtrAllocator is probably the best, my reasoning is below.

Explored options:
Move ownership to scope nodes with SmartPointers (Very difficult).
The containers within the scope, will contain smart pointers. The main complication is that there are quite few functions that are executed from the point where the logical element is created up to the point where the element is added to its scope:

Element is created: createElement() -> SmartPointer
...
Element attributes are updated: func1(), ... -> rawPointer
...
Element is added to scope parent: addElement() --> rawPointer

• The functions addElement(), func1(), ... can use a raw pointer extracted from the smart pointer.
• This involves quite a lot of changes specially in the CodeView Reader which uses visitor modules (logical, types and symbols) to traverse the debug information.

Using LLVM's BumpPtrAllocator (Discarded).
Destructors are not called.

Using SpecificBumpPtrAllocator (Small changes).
As the Reader creates different variants of logical elements (see above), it is required to have individual allocators for each variant:

SpecificBumpPtrAllocator<LVScope> Scopes;
SpecificBumpPtrAllocator<LVScopeRoot> ScopesRoot;
...
SpecificBumpPtrAllocator<LVType> Types;
SpecificBumpPtrAllocator<LVTypeDefinition> TypesDefinition;
...
SpecificBumpPtrAllocator<LVLine> Lines;
SpecificBumpPtrAllocator<LVLineDebug> LinesDebug;
...

Each variant will be created by a specific function:

createScope(), createScopeRoot(), ...
createType(), createTypeDefinition(), ...
createLine(), createLineDebug(), ...

Options summary:
a) Keep the bucket with smart pointers

class LVReader {
  // Allocated logical elements.
  SmallVector<std::unique_ptr<LVObject>> AllocatedObjects;
};

b) Use SpecificBumpPtrAllocator

class LVReader {
  ...
  SpecificBumpPtrAllocator<LVScope> Scopes;
  SpecificBumpPtrAllocator<LVScopeRoot> ScopesRoot;
  ...
};

The current patch implements option (b).

[dblaikie]

This involves quite a lot of changes specially in the CodeView Reader which uses visitor modules (logical, types and symbols) to traverse the debug information.

Whenever I see this mentioned, I get pretty skittish - the solution chosen shouldn't be dependent on how much code churn is involved (because it's the LLVM coding standards we're concerned with before accepting this code into the LLVM project).

But if it's the right solution regardless of cost, I'm more inclined/comfortable with it.

Is this API purely a "build/growth" without ever modifying? (like Clang's AST which uses bump/arena allocation - because you can't mutate the AST after it's built - you can't remove nodes, change nodes, etc)

In which case was the old design excessively chatty about allocation management, given that monolithic nature of the data structure?

[Orlando]

Hi @CarlosAlbertoEnciso and @dblaikie - I've had a look at this patch too and have left some inline nits / questions / suggestions.

Is this API purely a "build/growth" without ever modifying? (like Clang's AST which uses bump/arena allocation - because you can't mutate the AST after it's built - you can't remove nodes, change nodes, etc)

This is the impression I get. AFAIK the tree is built and then printed, or compared with another tree, then the work is done and the nodes can be deleted (at once, together). Saying that, there is something interesting going on during the comparison where it looks like nodes are removed from one tree (which will be discarded) to another. Although some nodes are mutated in that case it doesn't involve deleting any nodes. I think the node-mutation works due to the fact that the containers used by nodes to point to their children are heap allocated using the standard allocator (i.e., some content of the nodes are spilled out from the bumpptrallocators into the general heap - this may be a necessary design choice, I'm not familiar enough to be able to say?).

FWIW I think this looks like a generally tidier memory management strategy than was previously used. It seems like a reasonable solution to me - it is now clear that all raw pointers are referencing memory owned by some other object (almost always the reader).

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLocation.h

175

Why is this using a unique_ptr - can or should this be a container of raw pointers, allocating the objects using the new bumpptr allocator?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

82

I think this comment should be copied or moved to the class LVReader level (and should be a doxygen comment there - using /// rather than //).

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

120–125

Not really related to the core issue being discussed here but do these members need to be heap allocated at all? Is the space saving between using SmallVector<T, 0> and std::unique_ptr<SmallVector<T, N> worth the additional complexity of having to explicably allocate the container when adding the first element? The answer might simply be yes.

In either case, if that change is worthwhile it doesn't need to be made in this patch.

132

Another point for a future patch - as discussed offline it would probably be better to use a chaining iterator over the other containers rather than keep a separate container Children that mirrors their contents.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

What benefit do we get from std::vector<std::unique_ptr<LVLines>> over std::vector<LVLines>? Are the elements compared by address?

EDIT: see comment later on asking if we actually need this container at all.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

372

Why do we need DiscoveredLines at all now? Since the reader now owns the line objects when createLineAssembler is called below.

llvm/unittests/DebugInfo/LogicalView/LogicalElementsTest.cpp

113–125

I think a macro that combined Z = createX(); EXPECT_NE(Z, nullptr) would've been reasonable in order to reduce the line count of this change. It's probably not worth going back and adding retrospectively though.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLocation.h

175

Good observation. Changed to use the bumpptr mechanism.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

82

Moved to the class LVReader level.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

120–125

The issue is the space saving:

SmallVector<T, 0> --> size: 16
std::unique_ptr<SmallVector<T, N> --> size: 8

132

Good point. This is something that it should be changed as it would reduce the space usage.
A future patch is the best way to proceed.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

To answer both questions, this is the logic behind the debug and assembler line processing:

In createScopes for each Compile Unit:

• call traverseDieAndChildren to parse the debug info
• Call createLineAndFileRecords that creates LVLineDebugs for each entry in the debug line section
• call createInstructions that creates a vector of LVLineAssembler for the associated text section. Its unique pointer is stored in DiscoveredLines and never updated. Its raw pointer is stored in ScopeInstructions. The AssemblerMappings is updated to record specific section index, current logical scope and text address.
• call addSectionRange to collect all debug ranges
• call processLines to allocate the collected lines (debug and assembler) to their logical scope. It uses the ScopeInstructions to locate specific assembler lines using data from AssemblerMappings. It moves lines (debug and assembler) to their logical scope.

At the end of the scopes creation, DiscoveredLines constains the unique pointers to empty vector.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

372

See previous comment that explains the role of DiscoveredLines.

llvm/unittests/DebugInfo/LogicalView/LogicalElementsTest.cpp

113–125

I think creating a macro that combines the creation and check is worth it, as it reduces the extra noise introduced by the current patch.

[CarlosAlbertoEnciso]

Address the feedback from @Orlando:

• Use SpecificBumpPtrAllocator for LVOperation.
• Replace the sequences

Z = createX(); EXPECT_NE(Z, nullptr);
Z = createX(); EXPECT_NE(Z, nullptr); Z->functionX();

with the macro

CREATE(Z, createX);
CREATE(Z, createX, FunctionX);

[Orlando]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

It moves lines (debug and assembler) to their logical scope.

Where does this happen? I can't see any uses of DiscoveredLines in this patch other than where entries are added. Sorry if this is a silly question - just trying to get my head around this field still.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

This function creates instructions (LVLineAssembler) for the specific SectionIndex in the .text section. Those
instructions are associated with the logica 'Scope'.

Error LVBinaryReader::createInstructions(LVScope *Scope,
                                         LVSectionIndex SectionIndex,
                                         const LVNameInfo &NameInfo) {
  ...
  std::unique_ptr<LVLines> InstructionsSP = std::make_unique<LVLines>();
  LVLines *Instructions = InstructionsSP.get();
  DiscoveredLines.emplace_back(std::move(InstructionsSP));
  ...
  // Traverse the .text section and create the assembler lines.
  // Adding each line to the 'Instructions' vector.
  Instructions->push_back(Line);
  ...
  // Create the following association:
  // the logical 'Scope' for the function in the .text section
  // identified with 'SectionIndex', has the assembler lines
  // contained in 'Instructions'.
  ScopeInstructions.add(SectionIndex, Scope, Instructions);

  // Note: The last item in 'DiscoveredLines' is the smart
  // pointer to the allocated vector 'InstructionsSP' and its
  // raw pointer is 'Instructions'.
}

During the traversal of the debug information sections, we created the logical lines representing the disassembled instructions from the text section and the logical lines representing the line records from the debug line section. Using the ranges associated with the logical scopes, we will allocate those logical lines to their logical scopes.

void LVBinaryReader::processLines(LVLines *DebugLines,
                                  LVSectionIndex SectionIndex,
                                  LVScope *Function) {
  ...
  // The 'DebugLines' vector contains the debug lines
  // for the current compile unit.
  ...
  // Get the associated instructions for the found 'Scope'.
  LVLines InstructionLines;
  LVLines *Lines = ScopeInstructions.find(SectionIndex, Scope);
  if (Lines)
    InstructionLines = std::move(*Lines);
  // Note: We get the vector of instructions from 'ScopeInstructions'
  // using the 'SectionIndex' and 'Scope' and move its contents
  // to a local working vector 'InstructionLines'.
  // 'ScopeInstructions' was updated in 'createInstructions'.
  ...
  for (LVLine *InstructionLine : InstructionLines) {
     ...
     // Using the 'address' information, insert some
     // of these 'InstructionLine' into the 'DebugLines'.
     // Basically merge some 'Instructions' with the
     // lines representing the .debug_line records.
     DebugLines->push_back(InstructionLine);
     ...
  }
  ...
  // Get 'ranges' information.
  LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
  ScopesWithRanges->startSearch();
  ...
  for (LVLine *Line : *DebugLines) {
    ...
    // Add line object to scope.
    Scope->addElement(Line);
    ...
  }

This function creates the logical scopes for all the compilation units.

Error LVELFReader::createScopes() {
  ...
  // Traverse compile units.
  for (const std::unique_ptr<DWARFUnit> &CU : CompileUnits) {
    ...
    traverseDieAndChildren(CUDie, Root, SkeletonDie);
    ...
    // Create debug lines for current compile unit and
    // store them in the 'CULines' vector. 
    createLineAndFileRecords(DwarfContext->getLineTableForUnit(CU.get()));
    ...
    // Create instruction lines
    createInstructions()
    ...
    processLines(&CULines, SectionIndex);
    ...
    CULines.clear();
  }
}

The moving of the lines (debug and/or assembler) is done in LVBinaryReader::processLines.

[Orlando]

That's all of my concerns addressed now, so this LGTM. Thanks @CarlosAlbertoEnciso for your detailed responses.

I won't hit accept though in case @dblaikie has further comments on this new approach.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

Thanks a lot for the detailed breakdown. I fundamentally misunderstood what DiscoveredLines represented and had misread its type as vector<unique_ptr<Line*>> (which is incorrect) rather than vector<unique_ptr<vector<Line*>>>. I'm happy with this now.

[CarlosAlbertoEnciso]

In D137933#4096494, @Orlando wrote:

That's all of my concerns addressed now, so this LGTM. Thanks @CarlosAlbertoEnciso for your detailed responses.

I won't hit accept though in case @dblaikie has further comments on this new approach.

@Orlando Thanks very much for your review and feedback.

[dblaikie]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

Any chance of avoiding the extra unique_ptr indirection in there, and having a vector<vector<Line*>> instead?

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

103

The nested vector in DiscoveredLines has its address taken by ScopeInstructions so we need the additional indirection of the unique_ptr to ensure the pointer remains valid.

[CarlosAlbertoEnciso]

@dblaikie Do you have any additional questions or concerns that I have not answered it? Thanks.

[dblaikie]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

188

Undefine the macro after its uses - and maybe add an LLVM prefix to make this less likely to collide with other things?

Be nice to avoid the macros if possible, but nothing comes up quickly for me - probably some sort of type map could be used for the allocators and then these creation functions could be a function template instead. But not sure if we have a convenient type map already at hand.

238

This macro's only used once, could it be removed (for now/until it's needed)?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h

151–152

This seems unnecessary - could be sunk into the uses.

154–157

156–157

158–160

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

692

If Traverse always takes something non-null, it'd be nice if it took its argument by reference - then these call sites could be:

Traverse(*Parent->Types, SortFunction);

(& avoid the need for the explicit .get() call)

Similarly below for SetCompareState

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

258–259

idly: Should this be else-if?
And there seems to be some extra {} here than is usually used in LLVM (except where ambiguous, single line blocks should omit the {})

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

370–372

371

[CarlosAlbertoEnciso]

Address feedback from @dblaikie.

[CarlosAlbertoEnciso]

@dblaikie: Thanks for your valuable feedback.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

188

Added undef for all the macros.
Added the LV prefix which is the one used across the tool.

Would you be OK if we leave the macros for the time being and find a more elegant solution based on your suggestion (type map and function templates) for a later patch (improvement).

238

I introduced the macro, just for consistency with the other macros.
But, may be I am misunderstanding your point.
Do you want to remove the macro and instead use the createLocation() function?
Something like:

LVOperation *createOperation(LVSmall OpCode, LVUnsigned Operand1, LVUnsigned Operand2)
    return new (AllocatedOperation.Allocate()) LVOperation(OpCode, Operand1, Operand2);
}

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h

151–152

Good point. Removed unnecessary definitions.

154–157

Changed to use auto.

156–157

Removed SecondMap.

158–160

Added LVSecondMapType *.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

692

Good point. Replaced to use reference for both Traverse and SetCompareState.

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

258–259

Good observation. Changed to else-if. Removed extra {}.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

370–372

Changed to use auto.

371

Changed to reference.

[dblaikie]

Thanks

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

188

LV doesn't seem like a sufficiently unique prefix - I'd expect all the LLVM macros to start with LLVM - do they not? Hmm, a quick grep seems to indicate yeah, a bunch of LLVM macros don't use a more strict prefix. Pity about that. Ah well.

*shrug*

Sure, separate patch is OK. Probably a standard (or LLVM) map with typeinfo (would need a specialization to expose equality and hasher) as the key might suffice.

238

yeah, since there's only one, that seems OK?

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

692

Actually now it looks like traverse takes the unique_ptr by reference, rather than the underlying value by reference, which I guess is necessary if they can be null. So, sounds good.

[CarlosAlbertoEnciso]

Update the patch to reflect a change based on @dblaikie feedback.

Replaced the macro LV_CREATE_OPERATION with the explicit function:

// Operations creation.
LVOperation *createOperation(LVSmall OpCode, LVUnsigned Operand1,
                             LVUnsigned Operand2) {
  return new (AllocatedOperation.Allocate())
      LVOperation(OpCode, Operand1, Operand2);
}

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

188

I will include the following item for a separate patch:

• Replace the macros used for the memory management with your suggested approach (map with typeinfo).

238

Removed the macro LV_CREATE_OPERATION.
Use the explicit function:

// Operations creation.
LVOperation *createOperation(LVSmall OpCode, LVUnsigned Operand1,
                             LVUnsigned Operand2) {
  return new (AllocatedOperation.Allocate())
      LVOperation(OpCode, Operand1, Operand2);
}

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

692

Thanks.

[CarlosAlbertoEnciso]

@Orlando Do you have any additional comments on the updated patch?

[Orlando]

Do you have any additional comments on the updated patch?

It looks like all the comments have been addressed or acknowledged, so LGTM.

I've put one question inline but I'm happy for you to address it (if it does need addressing) without another round of review.

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

265

Before your recent change this branch was taken if options().getAttributeArgument() is false, but now this branch is taken if options().getAttributeArgument() is true (and both Type->getIsKindType() and Type->getIsKindScope()) are false). Just checking - is the new behaviour correct?

And if so, what was the result of the previous incorrect behaviour?

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

265

Very good catch. The behaviour has not being changed.

Incorrec placement for the closing }. The code should be:

if (options().getAttributeArgument()) {
  if (Type->getIsKindType())
    TypesParam->push_back(Type->getTypeAsType());
  else if (Type->getIsKindScope())
    ScopesParam->push_back(Type->getTypeAsScope());
} else
  TypesParam->push_back(Type);

[Orlando]

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

265

nit-pick: when you make the change, please add a set of braces around the final else-block (to keep it uniform since the if-block does use braces (covered here).

Thanks!

[CarlosAlbertoEnciso]

@dblaikie, @Orlando Thanks very much for your valuable feedback.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLocation.h

 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
 class LVLocationSymbol final : public LVLocation {
   // Location descriptors for the active range.
-  LVAutoOperations *Entries = nullptr;
+  std::unique_ptr<LVOperations> Entries;
 
   void updateKind() override;
 
 public:
   LVLocationSymbol() : LVLocation() {}
   LVLocationSymbol(const LVLocationSymbol &) = delete;
   LVLocationSymbol &operator=(const LVLocationSymbol &) = delete;
-  ~LVLocationSymbol() { delete Entries; };
+  ~LVLocationSymbol() = default;
 
   void addObject(LVAddress LowPC, LVAddress HighPC, LVUnsigned SectionOffset,
                  uint64_t LocDescOffset) override;
   void addObject(LVSmall Opcode, LVUnsigned Operand1,
                  LVUnsigned Operand2) override;
 
   void printRawExtra(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLOCATION_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVObject.h

 using LVObjectGetFunction = bool (LVObject::*)() const;
 using LVScopeSetFunction = void (LVScope::*)();
 using LVScopeGetFunction = bool (LVScope::*)() const;
 using LVSymbolSetFunction = void (LVSymbol::*)();
 using LVSymbolGetFunction = bool (LVSymbol::*)() const;
 using LVTypeSetFunction = void (LVType::*)();
 using LVTypeGetFunction = bool (LVType::*)() const;
 
-// The LVScope class represents a logical scope and uses vectors to store its
-// children, which are pointers to other allocated logical elements (types,
-// symbols, lines, scopes, ranges). On destruction, we have to traverse each
-// vector and destroy its elements. The other case is LVSymbol.
-// These definitions are intended to be used by the LVScope and LVSymbol
-// to support automatic vector cleanup.
-using LVAutoLines = LVAutoSmallVector<LVLine *>;
-using LVAutoLocations = LVAutoSmallVector<LVLocation *>;
-using LVAutoOperations = LVAutoSmallVector<LVOperation *, 8>;
-using LVAutoScopes = LVAutoSmallVector<LVScope *>;
-using LVAutoSymbols = LVAutoSmallVector<LVSymbol *>;
-using LVAutoTypes = LVAutoSmallVector<LVType *>;
-
-// These definitions are intended to be used when the vector will be used
-// just a container, with no automatic destruction.
 using LVElements = SmallVector<LVElement *, 8>;
 using LVLines = SmallVector<LVLine *, 8>;
 using LVLocations = SmallVector<LVLocation *, 8>;
 using LVOperations = SmallVector<LVOperation *, 8>;
 using LVScopes = SmallVector<LVScope *, 8>;
 using LVSymbols = SmallVector<LVSymbol *, 8>;
 using LVTypes = SmallVector<LVType *, 8>;
 
 using LVOffsets = SmallVector<LVOffset, 8>;
 
 const LVAddress MaxAddress = std::numeric_limits<uint64_t>::max();
 
 enum class LVBinaryType { NONE, ELF, COFF };
 enum class LVComparePass { Missing, Added };
 
 // Validate functions.
 using LVValidLocation = bool (LVLocation::*)();

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

if (OutputFile) {
       OutputFile = nullptr;
     }
   }
 
   std::string getLocation() const { return Location; }
   raw_fd_ostream &os() { return OutputFile->os(); }
 };
 
+/// The logical reader owns of all the logical elements created during
+/// the debug information parsing. For its creation it uses a specific
+///  bump allocator for each type of logical element.
 class LVReader {
   LVBinaryType BinaryType;
 
   // Context used by '--output=split' command line option.
   LVSplitContext SplitContext;
 
   // Compile Units DIE Offset => Scope.
   using LVCompileUnits = std::map<LVOffset, LVScopeCompileUnit *>;
   LVCompileUnits CompileUnits;
 
   // Added elements to be used during elements comparison.
   LVLines Lines;
   LVScopes Scopes;
   LVSymbols Symbols;
   LVTypes Types;
 
   // Create split folder.
   Error createSplitFolder();
   bool OutputSplit = false;
 
+// Define a specific bump allocator for the given KIND.
+#define LV_OBJECT_ALLOCATOR(KIND)                                              \
+  llvm::SpecificBumpPtrAllocator<LV##KIND> Allocated##KIND;
+
+  // Lines allocator.
+  LV_OBJECT_ALLOCATOR(Line)
+  LV_OBJECT_ALLOCATOR(LineDebug)
+  LV_OBJECT_ALLOCATOR(LineAssembler)
+
+  // Locations allocator.
+  LV_OBJECT_ALLOCATOR(Location)
+  LV_OBJECT_ALLOCATOR(LocationSymbol)
+
+  // Operations allocator.
+  LV_OBJECT_ALLOCATOR(Operation)
+
+  // Scopes allocator.
+  LV_OBJECT_ALLOCATOR(Scope)
+  LV_OBJECT_ALLOCATOR(ScopeAggregate)
+  LV_OBJECT_ALLOCATOR(ScopeAlias)
+  LV_OBJECT_ALLOCATOR(ScopeArray)
+  LV_OBJECT_ALLOCATOR(ScopeCompileUnit)
+  LV_OBJECT_ALLOCATOR(ScopeEnumeration)
+  LV_OBJECT_ALLOCATOR(ScopeFormalPack)
+  LV_OBJECT_ALLOCATOR(ScopeFunction)
+  LV_OBJECT_ALLOCATOR(ScopeFunctionInlined)
+  LV_OBJECT_ALLOCATOR(ScopeFunctionType)
+  LV_OBJECT_ALLOCATOR(ScopeNamespace)
+  LV_OBJECT_ALLOCATOR(ScopeRoot)
+  LV_OBJECT_ALLOCATOR(ScopeTemplatePack)
+
+  // Symbols allocator.
+  LV_OBJECT_ALLOCATOR(Symbol)
+
+  // Types allocator.
+  LV_OBJECT_ALLOCATOR(Type)
+  LV_OBJECT_ALLOCATOR(TypeDefinition)
+  LV_OBJECT_ALLOCATOR(TypeEnumerator)
+  LV_OBJECT_ALLOCATOR(TypeImport)
+  LV_OBJECT_ALLOCATOR(TypeParam)
+  LV_OBJECT_ALLOCATOR(TypeSubrange)
+
+#undef LV_OBJECT_ALLOCATOR
+
 protected:
   LVScopeRoot *Root = nullptr;
   std::string InputFilename;
   std::string FileFormatName;
   ScopedPrinter &W;
   raw_ostream &OS;
   LVScopeCompileUnit *CompileUnit = nullptr;
 
   // Only for ELF format. The CodeView is handled in a different way.
   LVSectionIndex DotTextSectionIndex = UndefinedSectionIndex;
 
   // Record Compilation Unit entry.
   void addCompileUnitOffset(LVOffset Offset, LVScopeCompileUnit *CompileUnit) {
     CompileUnits.emplace(Offset, CompileUnit);
   }
 
   // Create the Scope Root.
   virtual Error createScopes() {
-    Root = new LVScopeRoot();
+    Root = createScopeRoot();
     Root->setName(getFilename());
     if (options().getAttributeFormat())
       Root->setFileFormatName(FileFormatName);
     return Error::success();
   }
 
   // Return a pathname composed by: parent_path(InputFilename)/filename(From).
   // This is useful when a type server (PDB file associated with an object
public:
   LVReader() = delete;
   LVReader(StringRef InputFilename, StringRef FileFormatName, ScopedPrinter &W,
            LVBinaryType BinaryType = LVBinaryType::NONE)
       : BinaryType(BinaryType), OutputSplit(options().getOutputSplit()),
         InputFilename(InputFilename), FileFormatName(FileFormatName), W(W),
         OS(W.getOStream()) {}
   LVReader(const LVReader &) = delete;
   LVReader &operator=(const LVReader &) = delete;
-  virtual ~LVReader() {
-    if (Root)
-      delete Root;
+  virtual ~LVReader() = default;
+
+// Creates a logical object of the given KIND. The signature for the created
+// functions looks like:
+//   ...
+//   LVScope *createScope()
+//   LVScopeRoot *creatScopeRoot()
+//   LVType *createType();
+//   ...
+#define LV_CREATE_OBJECT(KIND)                                                 \
+  LV##KIND *create##KIND() {                                                   \
+    return new (Allocated##KIND.Allocate()) LV##KIND();                        \
+  }
+
+  // Lines creation.
+  LV_CREATE_OBJECT(Line)
+  LV_CREATE_OBJECT(LineDebug)
+  LV_CREATE_OBJECT(LineAssembler)
+
+  // Locations creation.
+  LV_CREATE_OBJECT(Location)
+  LV_CREATE_OBJECT(LocationSymbol)
+
+  // Scopes creation.
+  LV_CREATE_OBJECT(Scope)
+  LV_CREATE_OBJECT(ScopeAggregate)
+  LV_CREATE_OBJECT(ScopeAlias)
+  LV_CREATE_OBJECT(ScopeArray)
+  LV_CREATE_OBJECT(ScopeCompileUnit)
+  LV_CREATE_OBJECT(ScopeEnumeration)
+  LV_CREATE_OBJECT(ScopeFormalPack)
+  LV_CREATE_OBJECT(ScopeFunction)
+  LV_CREATE_OBJECT(ScopeFunctionInlined)
+  LV_CREATE_OBJECT(ScopeFunctionType)
+  LV_CREATE_OBJECT(ScopeNamespace)
+  LV_CREATE_OBJECT(ScopeRoot)
+  LV_CREATE_OBJECT(ScopeTemplatePack)
+
+  // Symbols creation.
+  LV_CREATE_OBJECT(Symbol)
+
+  // Types creation.
+  LV_CREATE_OBJECT(Type)
+  LV_CREATE_OBJECT(TypeDefinition)
+  LV_CREATE_OBJECT(TypeEnumerator)
+  LV_CREATE_OBJECT(TypeImport)
+  LV_CREATE_OBJECT(TypeParam)
+  LV_CREATE_OBJECT(TypeSubrange)
+
+#undef LV_CREATE_OBJECT
+
+  // Operations creation.
+  LVOperation *createOperation(LVSmall OpCode, LVUnsigned Operand1,
+                               LVUnsigned Operand2) {
+    return new (AllocatedOperation.Allocate())
+        LVOperation(OpCode, Operand1, Operand2);
   }
 
   StringRef getFilename(LVObject *Object, size_t Index) const;
   StringRef getFilename() const { return InputFilename; }
   void setFilename(std::string Name) { InputFilename = std::move(Name); }
   StringRef getFileFormatName() const { return FileFormatName; }
 
   raw_ostream &outputStream() { return OS; }
 
   bool isBinaryTypeNone() const { return BinaryType == LVBinaryType::NONE; }
   bool isBinaryTypeELF() const { return BinaryType == LVBinaryType::ELF; }
   bool isBinaryTypeCOFF() const { return BinaryType == LVBinaryType::COFF; }

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

enum class LVScopeKind {
   IsTryBlock,
   IsUnion,
   LastEntry
 };
 using LVScopeKindSet = std::set<LVScopeKind>;
 using LVScopeDispatch = std::map<LVScopeKind, LVScopeGetFunction>;
 using LVScopeRequest = std::vector<LVScopeGetFunction>;
 
-using LVOffsetList = std::list<LVOffset>;
 using LVOffsetElementMap = std::map<LVOffset, LVElement *>;
-using LVOffsetLinesMap = std::map<LVOffset, LVLines *>;
-using LVOffsetLocationsMap = std::map<LVOffset, LVLocations *>;
+using LVOffsetLinesMap = std::map<LVOffset, LVLines>;
+using LVOffsetLocationsMap = std::map<LVOffset, LVLocations>;
 using LVOffsetSymbolMap = std::map<LVOffset, LVSymbol *>;
-using LVTagOffsetsMap = std::map<dwarf::Tag, LVOffsetList *>;
+using LVTagOffsetsMap = std::map<dwarf::Tag, LVOffsets>;
 
 // Class to represent a DWARF Scope.
 class LVScope : public LVElement {
   enum class Property {
     HasDiscriminator,
     CanHaveRanges,
     CanHaveLines,
     HasGlobals,
class LVScope : public LVElement {
   static LVScopeDispatch Dispatch;
 
   // Coverage factor in units (bytes).
   unsigned CoverageFactor = 0;
 
   // Calculate coverage factor.
   void calculateCoverage() {
     float CoveragePercentage = 0;
-    LVLocation::calculateCoverage(Ranges, CoverageFactor, CoveragePercentage);
+    LVLocation::calculateCoverage(Ranges.get(), CoverageFactor,
+                                  CoveragePercentage);
   }
 
   // Decide if the scope will be printed, using some conditions given by:
   // only-globals, only-locals, a-pattern.
   bool resolvePrinting() const;
 
   // Find the current scope in the given 'Targets'.
   LVScope *findIn(const LVScopes *Targets) const;
 
   // Traverse the scope parent tree, executing the given callback function
   // on each scope.
   void traverseParents(LVScopeGetFunction GetFunction,
                        LVScopeSetFunction SetFunction);
 
 protected:
   // Types, Symbols, Scopes, Lines, Locations in this scope.
-  LVAutoTypes *Types = nullptr;
-  LVAutoSymbols *Symbols = nullptr;
-  LVAutoScopes *Scopes = nullptr;
-  LVAutoLines *Lines = nullptr;
-  LVAutoLocations *Ranges = nullptr;
+  std::unique_ptr<LVTypes> Types;
+  std::unique_ptr<LVSymbols> Symbols;
+  std::unique_ptr<LVScopes> Scopes;
+  std::unique_ptr<LVLines> Lines;
+  std::unique_ptr<LVLocations> Ranges;
 
   // Vector of elements (types, scopes and symbols).
   // It is the union of (*Types, *Symbols and *Scopes) to be used for
   // the following reasons:
   // - Preserve the order the logical elements are read in.
   // - To have a single container with all the logical elements, when
   //   the traversal does not require any specific element kind.
-  LVElements *Children = nullptr;
+  std::unique_ptr<LVElements> Children;
 
   // Resolve the template parameters/arguments relationship.
   void resolveTemplate();
   void printEncodedArgs(raw_ostream &OS, bool Full) const;
 
   void printActiveRanges(raw_ostream &OS, bool Full = true) const;
   virtual void printSizes(raw_ostream &OS) const {}
   virtual void printSummary(raw_ostream &OS) const {}
 
   // Encoded template arguments.
   virtual StringRef getEncodedArgs() const { return StringRef(); }
   virtual void setEncodedArgs(StringRef EncodedArgs) {}
 
 public:
   LVScope() : LVElement(LVSubclassID::LV_SCOPE) {
     setIsScope();
     setIncludeInPrint();
   }
   LVScope(const LVScope &) = delete;
   LVScope &operator=(const LVScope &) = delete;
-  virtual ~LVScope();
+  virtual ~LVScope() = default;
 
   static bool classof(const LVElement *Element) {
     return Element->getSubclassID() == LVSubclassID::LV_SCOPE;
   }
 
   KIND(LVScopeKind, IsAggregate);
   KIND(LVScopeKind, IsArray);
   KIND_2(LVScopeKind, IsBlock, CanHaveRanges, CanHaveLines);
public:
   PROPERTY(Property, AddedMissing);
 
   bool isCompileUnit() const override { return getIsCompileUnit(); }
   bool isRoot() const override { return getIsRoot(); }
 
   const char *kind() const override;
 
   // Get the specific children.
-  const LVLines *getLines() const { return Lines; }
-  const LVLocations *getRanges() const { return Ranges; }
-  const LVScopes *getScopes() const { return Scopes; }
-  const LVSymbols *getSymbols() const { return Symbols; }
-  const LVTypes *getTypes() const { return Types; }
-  const LVElements *getChildren() const { return Children; }
+  const LVLines *getLines() const { return Lines.get(); }
+  const LVLocations *getRanges() const { return Ranges.get(); }
+  const LVScopes *getScopes() const { return Scopes.get(); }
+  const LVSymbols *getSymbols() const { return Symbols.get(); }
+  const LVTypes *getTypes() const { return Types.get(); }
+  const LVElements *getChildren() const { return Children.get(); }
 
   void addElement(LVElement *Element);
   void addElement(LVLine *Line);
   void addElement(LVScope *Scope);
   void addElement(LVSymbol *Symbol);
   void addElement(LVType *Type);
   void addObject(LVLocation *Location);
   void addObject(LVAddress LowerAddress, LVAddress UpperAddress);
class LVScopeCompileUnit final : public LVScope {
   LVSizesMap Sizes;
   LVOffset CUContributionSize = 0;
 
   // Helper function to add an invalid location/range.
   void addInvalidLocationOrRange(LVLocation *Location, LVElement *Element,
                                  LVOffsetLocationsMap *Map) {
     LVOffset Offset = Element->getOffset();
     addInvalidOffset(Offset, Element);
-    addItem<LVOffsetLocationsMap, LVLocations, LVOffset, LVLocation *>(
-        Map, Offset, Location);
+    addItem<LVOffsetLocationsMap, LVOffset, LVLocation *>(Map, Offset,
+                                                          Location);
   }
 
   // Record scope sizes indexed by lexical level.
   // Setting an initial size that will cover a very deep nested scopes.
   const size_t TotalInitialSize = 8;
   using LVTotalsEntry = std::pair<unsigned, float>;
   SmallVector<LVTotalsEntry> Totals;
   // Maximum seen lexical level. It is used to control how many entries
protected:
   void printSummary(raw_ostream &OS) const override;
 
 public:
   LVScopeCompileUnit() : LVScope(), Totals(TotalInitialSize, {0, 0.0}) {
     setIsCompileUnit();
   }
   LVScopeCompileUnit(const LVScopeCompileUnit &) = delete;
   LVScopeCompileUnit &operator=(const LVScopeCompileUnit &) = delete;
-  ~LVScopeCompileUnit() {
-    deleteList<LVTagOffsetsMap>(DebugTags);
-    deleteList<LVOffsetLocationsMap>(InvalidLocations);
-    deleteList<LVOffsetLocationsMap>(InvalidRanges);
-    deleteList<LVOffsetLinesMap>(LinesZero);
-  }
+  ~LVScopeCompileUnit() = default;
 
   LVScope *getCompileUnitParent() const override {
     return static_cast<LVScope *>(const_cast<LVScopeCompileUnit *>(this));
   }
 
   // Add line to address mapping.
   void addMapping(LVLine *Line, LVSectionIndex SectionIndex);
   LVLineRange lineRange(LVLocation *Location) const;
public:
   void addInvalidCoverage(LVSymbol *Symbol);
   // Record symbols with invalid locations.
   void addInvalidLocation(LVLocation *Location);
   // Record scopes with invalid ranges.
   void addInvalidRange(LVLocation *Location);
   // Record line zero.
   void addLineZero(LVLine *Line);
 
   const LVTagOffsetsMap &getDebugTags() const { return DebugTags; }
   const LVOffsetElementMap &getWarningOffsets() const { return WarningOffsets; }
   const LVOffsetLocationsMap &getInvalidLocations() const {
     return InvalidLocations;
   }
   const LVOffsetSymbolMap &getInvalidCoverages() const {
     return InvalidCoverages;
   }
   const LVOffsetLocationsMap &getInvalidRanges() const { return InvalidRanges; }
   const LVOffsetLinesMap &getLinesZero() const { return LinesZero; }
 
   // Process ranges, locations and calculate coverage.
   void processRangeLocationCoverage(
       LVValidLocation ValidLocation = &LVLocation::validateRanges);
 
   // Add matched element.
   void addMatched(LVElement *Element) { MatchedElements.push_back(Element); }
   void addMatched(LVScope *Scope) { MatchedScopes.push_back(Scope); }
   void propagatePatternMatch();

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h

 #include <sstream>
 
 namespace llvm {
 namespace logicalview {
 
 // Returns the unique string pool instance.
 LVStringPool &getStringPool();
 
-template <typename T>
-using TypeIsValid = std::bool_constant<std::is_pointer<T>::value>;
-
-// Utility class to help memory management and perform an automatic cleaning.
-template <typename T, unsigned N = 8>
-class LVAutoSmallVector : public SmallVector<T, N> {
-  static_assert(TypeIsValid<T>::value, "T must be a pointer type");
-
-public:
-  using iterator = typename SmallVector<T, N>::iterator;
-  LVAutoSmallVector() : SmallVector<T, N>::SmallVector() {}
-
-  ~LVAutoSmallVector() {
-    // Destroy the constructed elements in the vector.
-    for (auto *Item : *this)
-      delete Item;
-  }
-};
-
 // Used to record specific characteristics about the objects.
 template <typename T> class LVProperties {
   SmallBitVector Bits = SmallBitVector(static_cast<unsigned>(T::LastEntry) + 1);
 
 public:
   LVProperties() = default;
 
   void set(T Idx) { Bits[static_cast<unsigned>(Idx)] = 1; }
std::string formatAttributes(const StringRef First, Args... Others) {
   for (const StringRef &Item : List) {
     Stream << (Size ? " " : "") << Item.str();
     Size = Item.size();
   }
   Stream << (Size ? " " : "");
   return Stream.str();
 }
 
-// Add an item to a map with second being a list.
-template <typename MapType, typename ListType, typename KeyType,
-          typename ValueType>
+// Add an item to a map with second being a small vector.
+template <typename MapType, typename KeyType, typename ValueType>
 void addItem(MapType *Map, KeyType Key, ValueType Value) {
-  ListType *List = nullptr;
-  typename MapType::const_iterator Iter = Map->find(Key);
-  if (Iter != Map->end())
-    List = Iter->second;
-  else {
-    List = new ListType();
-    Map->emplace(Key, List);
-  }
-  List->push_back(Value);
-}
-
-// Delete the map contained list.
-template <typename MapType> void deleteList(MapType &Map) {
-  for (typename MapType::const_reference Entry : Map)
-    delete Entry.second;
+  (*Map)[Key].push_back(Value);
 }
 
 // Double map data structure.
 template <typename FirstKeyType, typename SecondKeyType, typename ValueType>
 class LVDoubleMap {
   static_assert(std::is_pointer<ValueType>::value,
                 "ValueType must be a pointer.");
   using LVSecondMapType = std::map<SecondKeyType, ValueType>;
-  using LVFirstMapType = std::map<FirstKeyType, LVSecondMapType *>;
+  using LVFirstMapType =
+      std::map<FirstKeyType, std::unique_ptr<LVSecondMapType>>;
   using LVAuxMapType = std::map<SecondKeyType, FirstKeyType>;
   using LVValueTypes = std::vector<ValueType>;
   LVFirstMapType FirstMap;
   LVAuxMapType AuxMap;
 
 public:
-  LVDoubleMap() = default;
-  ~LVDoubleMap() {
-    for (auto &Entry : FirstMap)
-      delete Entry.second;
-  }
-
   void add(FirstKeyType FirstKey, SecondKeyType SecondKey, ValueType Value) {
-    LVSecondMapType *SecondMap = nullptr;
     typename LVFirstMapType::iterator FirstIter = FirstMap.find(FirstKey);
     if (FirstIter == FirstMap.end()) {
-      SecondMap = new LVSecondMapType();
-      FirstMap.emplace(FirstKey, SecondMap);
+      auto SecondMapSP = std::make_unique<LVSecondMapType>();
+      SecondMapSP->emplace(SecondKey, Value);
+      FirstMap.emplace(FirstKey, std::move(SecondMapSP));
     } else {
-      SecondMap = FirstIter->second;
-    }
-
-    assert(SecondMap && "SecondMap is null.");
-    if (SecondMap && SecondMap->find(SecondKey) == SecondMap->end())
+      LVSecondMapType *SecondMap = FirstIter->second.get();
+      if (SecondMap->find(SecondKey) == SecondMap->end())
         SecondMap->emplace(SecondKey, Value);
+    }
 
     typename LVAuxMapType::iterator AuxIter = AuxMap.find(SecondKey);
     if (AuxIter == AuxMap.end()) {
       AuxMap.emplace(SecondKey, FirstKey);
     }
   }
 
   LVSecondMapType *findMap(FirstKeyType FirstKey) const {
     typename LVFirstMapType::const_iterator FirstIter = FirstMap.find(FirstKey);
     if (FirstIter == FirstMap.end())
       return nullptr;
 
-    LVSecondMapType *SecondMap = FirstIter->second;
-    return SecondMap;
+    return FirstIter->second.get();
   }
 
   ValueType find(FirstKeyType FirstKey, SecondKeyType SecondKey) const {
     LVSecondMapType *SecondMap = findMap(FirstKey);
     if (!SecondMap)
       return nullptr;
 
     typename LVSecondMapType::const_iterator SecondIter =
         SecondMap->find(SecondKey);
     return (SecondIter != SecondMap->end()) ? SecondIter->second : nullptr;
   }
 
   ValueType find(SecondKeyType SecondKey) const {
     typename LVAuxMapType::const_iterator AuxIter = AuxMap.find(SecondKey);
     if (AuxIter == AuxMap.end())
       return nullptr;
     return find(AuxIter->second, SecondKey);
   }
 
   // Return a vector with all the 'ValueType' values.
   LVValueTypes find() const {
     LVValueTypes Values;
     if (FirstMap.empty())
       return Values;
     for (typename LVFirstMapType::const_reference FirstEntry : FirstMap) {
-      LVSecondMapType *SecondMap = FirstEntry.second;
-      for (typename LVSecondMapType::const_reference SecondEntry : *SecondMap)
+      LVSecondMapType &SecondMap = *FirstEntry.second;
+      for (typename LVSecondMapType::const_reference SecondEntry : SecondMap)
         Values.push_back(SecondEntry.second);
     }
     return Values;
   }
 };
 
 // Unified and flattened pathnames.
 std::string transformPath(StringRef Path);

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

class LVSymbol final : public LVElement {
   LVProperties<Property> Properties;
   static LVSymbolDispatch Dispatch;
 
   // CodeView symbol Linkage name.
   size_t LinkageNameIndex = 0;
 
   // Reference to DW_AT_specification, DW_AT_abstract_origin attribute.
   LVSymbol *Reference = nullptr;
-  LVAutoLocations *Locations = nullptr;
+  std::unique_ptr<LVLocations> Locations;
   LVLocation *CurrentLocation = nullptr;
 
   // Bitfields length.
   uint32_t BitSize = 0;
 
   // Index in the String pool representing any initial value.
   size_t ValueIndex = 0;
 
   // Coverage factor in units (bytes).
   unsigned CoverageFactor = 0;
   float CoveragePercentage = 0;
 
   // Add a location gap into the location list.
-  LVAutoLocations::iterator addLocationGap(LVAutoLocations::iterator Pos,
-                                           LVAddress LowPC, LVAddress HighPC);
+  LVLocations::iterator addLocationGap(LVLocations::iterator Pos,
 
   // Find the current symbol in the given 'Targets'.
   LVSymbol *findIn(const LVSymbols *Targets) const;
 
 public:
   LVSymbol() : LVElement(LVSubclassID::LV_SYMBOL) {
     setIsSymbol();
     setIncludeInPrint();
   }
   LVSymbol(const LVSymbol &) = delete;
   LVSymbol &operator=(const LVSymbol &) = delete;
-  ~LVSymbol() { delete Locations; }
+  ~LVSymbol() = default;
 
   static bool classof(const LVElement *Element) {
     return Element->getSubclassID() == LVSubclassID::LV_SYMBOL;
   }
 
   KIND(LVSymbolKind, IsCallSiteParameter);
   KIND(LVSymbolKind, IsConstant);
   KIND(LVSymbolKind, IsInheritance);

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace logicalview {
 
-using LVReaders = std::vector<LVReader *>;
+using LVReaders = std::vector<std::unique_ptr<LVReader>>;
 using ArgVector = std::vector<std::string>;
 using PdbOrObj = PointerUnion<object::ObjectFile *, pdb::PDBFile *>;
 
 // This class performs the following tasks:
 // - Creates a logical reader for every binary file in the command line,
 //   that parses the debug information and creates a high level logical
 //   view representation containing scopes, symbols, types and lines.
 // - Prints and compares the logical views.
 //
 // The supported binary formats are: ELF, Mach-O and CodeView.
 class LVReaderHandler {
   ArgVector &Objects;
   ScopedPrinter &W;
   raw_ostream &OS;
   LVReaders TheReaders;
 
   Error createReaders();
-  void destroyReaders();
   Error printReaders();
   Error compareReaders();
 
   Error handleArchive(LVReaders &Readers, StringRef Filename,
                       object::Archive &Arch);
   Error handleBuffer(LVReaders &Readers, StringRef Filename,
                      MemoryBufferRef Buffer, StringRef ExePath = {});
   Error handleFile(LVReaders &Readers, StringRef Filename,

 public:
   LVReaderHandler() = delete;
   LVReaderHandler(ArgVector &Objects, ScopedPrinter &W,
                   LVOptions &ReaderOptions)
       : Objects(Objects), W(W), OS(W.getOStream()) {
     setOptions(&ReaderOptions);
   }
   LVReaderHandler(const LVReaderHandler &) = delete;
   LVReaderHandler &operator=(const LVReaderHandler &) = delete;
-  ~LVReaderHandler() { destroyReaders(); }
 
   Error createReader(StringRef Filename, LVReaders &Readers) {
     return handleFile(Readers, Filename);
   }
   Error process();
 
-  Expected<LVReader *> createReader(StringRef Pathname) {
+  Expected<std::unique_ptr<LVReader>> createReader(StringRef Pathname) {
     LVReaders Readers;
     if (Error Err = createReader(Pathname, Readers))
       return std::move(Err);
-    return Readers[0];
+    return std::move(Readers[0]);
   }
-  void deleteReader(LVReader *Reader) { delete Reader; }
 
   void print(raw_ostream &OS) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { print(dbgs()); }
 #endif
 };
 
 } // end namespace logicalview
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVREADERHANDLER_H

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

class LVBinaryReader : public LVReader {
   void addSectionAddress(const object::SectionRef &Section) {
     if (SectionAddresses.find(Section.getAddress()) == SectionAddresses.end())
       SectionAddresses.emplace(Section.getAddress(), Section);
   }
 
   // Scopes with ranges for current compile unit. It is used to find a line
   // giving its exact or closest address. To support comdat functions, all
   // addresses for the same section are recorded in the same map.
-  using LVSectionRanges = std::map<LVSectionIndex, LVRange *>;
+  using LVSectionRanges = std::map<LVSectionIndex, std::unique_ptr<LVRange>>;
   LVSectionRanges SectionRanges;
 
   // Image base and virtual address for Executable file.
   uint64_t ImageBaseAddress = 0;
   uint64_t VirtualAddress = 0;
 
   // Object sections with machine code.
   using LVSections = std::map<LVSectionIndex, object::SectionRef>;
   LVSections Sections;
 
+  std::vector<std::unique_ptr<LVLines>> DiscoveredLines;
+
 protected:
   // It contains the LVLineDebug elements representing the logical lines for
   // the current compile unit, created by parsing the debug line section.
   LVLines CULines;
 
   std::unique_ptr<const MCRegisterInfo> MRI;
   std::unique_ptr<const MCAsmInfo> MAI;
   std::unique_ptr<const MCSubtargetInfo> STI;

 
 public:
   LVBinaryReader() = delete;
   LVBinaryReader(StringRef Filename, StringRef FileFormatName, ScopedPrinter &W,
                  LVBinaryType BinaryType)
       : LVReader(Filename, FileFormatName, W, BinaryType) {}
   LVBinaryReader(const LVBinaryReader &) = delete;
   LVBinaryReader &operator=(const LVBinaryReader &) = delete;
-  virtual ~LVBinaryReader();
+  virtual ~LVBinaryReader() = default;
 
   void addToSymbolTable(StringRef Name, LVScope *Function,
                         LVSectionIndex SectionIndex = 0);
   void addToSymbolTable(StringRef Name, LVAddress Address,
                         LVSectionIndex SectionIndex, bool IsComdat);
   LVSectionIndex updateSymbolTable(LVScope *Function);
 
   const LVSymbolTableEntry &getSymbolTableEntry(StringRef Name);
   LVAddress getSymbolTableAddress(StringRef Name);
   LVSectionIndex getSymbolTableIndex(StringRef Name);

llvm/lib/DebugInfo/LogicalView/Core/LVLocation.cpp

void LVLocationSymbol::addObject(LVAddress LowPC, LVAddress HighPC,
   // Update the location kind, using the DWARF attribute.
   setKind();
 }
 
 // Add a Location Record.
 void LVLocationSymbol::addObject(LVSmall Opcode, LVUnsigned Operand1,
                                  LVUnsigned Operand2) {
   if (!Entries)
-    Entries = new LVAutoOperations();
-  Entries->emplace_back(new LVOperation(Opcode, Operand1, Operand2));
+    Entries = std::make_unique<LVOperations>();
+  Entries->push_back(getReader().createOperation(Opcode, Operand1, Operand2));
 }
 
 // Based on the DWARF attribute, define the location kind.
 void LVLocation::setKind() {
   switch (getAttr()) {
   case dwarf::DW_AT_data_member_location:
     setIsClassOffset();
     break;
   case dwarf::DW_AT_location:
     // Depending on the operand, we have a fixed address.
     setIsFixedAddress();
     break;
   default:
     break;
   }
   // For those symbols with absolute location information, ignore any
   // gaps in their location description; that is the case with absolute
   // memory addresses and members located at specific offsets.
   if (hasAssociatedRange())
     getParentSymbol()->setFillGaps();
 }
 
 void LVLocationSymbol::updateKind() {
   // Update the location type for simple ones.
   if (Entries && Entries->size() == 1) {
-    LVOperation *Operation = Entries->front();
-    if (dwarf::DW_OP_fbreg == Operation->getOpcode())
+    if (dwarf::DW_OP_fbreg == Entries->front()->getOpcode())
       setIsStackOffset();
   }
 }
 
 void LVLocationSymbol::printRawExtra(raw_ostream &OS, bool Full) const {
   if (Entries)
     for (const LVOperation *Operation : *Entries)
       Operation->print(OS, Full);

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

 const char *const KindTemplatePack = "TemplatePack";
 const char *const KindUndefined = "Undefined";
 const char *const KindUnion = "Union";
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // DWARF lexical block, such as: namespace, function, compile unit, module, etc.
 //===----------------------------------------------------------------------===//
-LVScope::~LVScope() {
-  delete Types;
-  delete Symbols;
-  delete Scopes;
-  delete Lines;
-  delete Ranges;
-  delete Children;
-}
-
 // Return a string representation for the scope kind.
 const char *LVScope::kind() const {
   const char *Kind = KindUndefined;
   if (getIsArray())
     Kind = KindArray;
   else if (getIsBlock())
     Kind = KindBlock;
   else if (getIsCallSite())
LVScopeDispatch LVScope::Dispatch = {
     {LVScopeKind::IsTemplate, &LVScope::getIsTemplate},
     {LVScopeKind::IsTemplateAlias, &LVScope::getIsTemplateAlias},
     {LVScopeKind::IsTemplatePack, &LVScope::getIsTemplatePack},
     {LVScopeKind::IsTryBlock, &LVScope::getIsTryBlock},
     {LVScopeKind::IsUnion, &LVScope::getIsUnion}};
 
 void LVScope::addToChildren(LVElement *Element) {
   if (!Children)
-    Children = new LVElements();
+    Children = std::make_unique<LVElements>();
   Children->push_back(Element);
 }
 
 void LVScope::addElement(LVElement *Element) {
   assert(Element && "Invalid element.");
   if (Element->getIsType())
     addElement(static_cast<LVType *>(Element));
   else if (Element->getIsScope())
     addElement(static_cast<LVScope *>(Element));
   else if (Element->getIsSymbol())
     addElement(static_cast<LVSymbol *>(Element));
   else if (Element->getIsLine())
     addElement(static_cast<LVLine *>(Element));
   else
     llvm_unreachable("Invalid Element.");
 }
 
 // Adds the line info item to the ones stored in the scope.
 void LVScope::addElement(LVLine *Line) {
   assert(Line && "Invalid line.");
   assert(!Line->getParent() && "Line already inserted");
   if (!Lines)
-    Lines = new LVAutoLines();
+    Lines = std::make_unique<LVLines>();
 
   // Add it to parent.
   Lines->push_back(Line);
   Line->setParent(this);
 
   // Notify the reader about the new element being added.
   getReaderCompileUnit()->addedElement(Line);
 
   // All logical elements added to the children, are sorted by any of the
   // following criterias: offset, name, line number, kind.
   // Do not add the line records to the children, as they represent the
   // logical view for the text section and any sorting will not preserve
   // the original sequence.
 
   // Indicate that this tree branch has lines.
   traverseParents(&LVScope::getHasLines, &LVScope::setHasLines);
 }
 
 // Add a location.
 void LVScope::addObject(LVLocation *Location) {
   assert(Location && "Invalid location.");
   assert(!Location->getParent() && "Location already inserted");
   if (!Ranges)
-    Ranges = new LVAutoLocations();
+    Ranges = std::make_unique<LVLocations>();
 
   // Add it to parent.
   Location->setParent(this);
   Location->setOffset(getOffset());
 
   Ranges->push_back(Location);
   setHasRanges();
 }
 
 // Adds the scope to the child scopes and sets the parent in the child.
 void LVScope::addElement(LVScope *Scope) {
   assert(Scope && "Invalid scope.");
   assert(!Scope->getParent() && "Scope already inserted");
   if (!Scopes)
-    Scopes = new LVAutoScopes();
+    Scopes = std::make_unique<LVScopes>();
 
   // Add it to parent.
   Scopes->push_back(Scope);
   addToChildren(Scope);
   Scope->setParent(this);
 
   // Notify the reader about the new element being added.
   getReaderCompileUnit()->addedElement(Scope);
void LVScope::addElement(LVScope *Scope) {
   traverseParents(&LVScope::getHasScopes, &LVScope::setHasScopes);
 }
 
 // Adds a symbol to the ones stored in the scope.
 void LVScope::addElement(LVSymbol *Symbol) {
   assert(Symbol && "Invalid symbol.");
   assert(!Symbol->getParent() && "Symbol already inserted");
   if (!Symbols)
-    Symbols = new LVAutoSymbols();
+    Symbols = std::make_unique<LVSymbols>();
 
   // Add it to parent.
   Symbols->push_back(Symbol);
   addToChildren(Symbol);
   Symbol->setParent(this);
 
   // Notify the reader about the new element being added.
   getReaderCompileUnit()->addedElement(Symbol);
void LVScope::addElement(LVSymbol *Symbol) {
   traverseParents(&LVScope::getHasSymbols, &LVScope::setHasSymbols);
 }
 
 // Adds a type to the ones stored in the scope.
 void LVScope::addElement(LVType *Type) {
   assert(Type && "Invalid type.");
   assert(!Type->getParent() && "Type already inserted");
   if (!Types)
-    Types = new LVAutoTypes();
+    Types = std::make_unique<LVTypes>();
 
   // Add it to parent.
   Types->push_back(Type);
   addToChildren(Type);
   Type->setParent(this);
 
   // Notify the reader about the new element being added.
   getReaderCompileUnit()->addedElement(Type);
 
   // If the element is a global reference, mark its parent as having global
   // references; that information is used, to print only those branches
   // with global references.
   if (Type->getIsGlobalReference())
     traverseParents(&LVScope::getHasGlobals, &LVScope::setHasGlobals);
   else
     traverseParents(&LVScope::getHasLocals, &LVScope::setHasLocals);
 
   // Indicate that this tree branch has types.
   traverseParents(&LVScope::getHasTypes, &LVScope::setHasTypes);
 }
 
 // Add a pair of ranges.
 void LVScope::addObject(LVAddress LowerAddress, LVAddress UpperAddress) {
   // Pack the ranges into a Location object.
-  LVLocation *Location = new LVLocation();
+  LVLocation *Location = getReader().createLocation();
   Location->setLowerAddress(LowerAddress);
   Location->setUpperAddress(UpperAddress);
   Location->setIsAddressRange();
 
   addObject(Location);
 }
 
 bool LVScope::removeElement(LVElement *Element) {
for (LVSymbol *Reference : References) {
       LLVM_DEBUG({
         dbgs() << "Missing Offset = " << hexSquareString(Reference->getOffset())
                << "\n";
       });
       // We can't clone the abstract origin reference, as it contain extra
       // information that is incorrect for the element to be inserted.
       // As the symbol being added does not exist in the debug section,
       // use its parent scope offset, to indicate its DIE location.
-      LVSymbol *Symbol = new LVSymbol();
+      LVSymbol *Symbol = getReader().createSymbol();
       addElement(Symbol);
       Symbol->setOffset(getOffset());
       Symbol->setIsOptimized();
       Symbol->setReference(Reference);
 
       // The symbol can be a constant, parameter or variable.
       if (Reference->getIsConstant())
         Symbol->setIsConstant();

 }
 
 void LVScope::sort() {
   // Preserve the lines order as they are associated with user code.
   LVSortFunction SortFunction = getSortFunction();
   if (SortFunction) {
     std::function<void(LVScope * Parent, LVSortFunction SortFunction)> Sort =
         [&](LVScope *Parent, LVSortFunction SortFunction) {
-          auto Traverse = [&](auto *Set, LVSortFunction SortFunction) {
+          auto Traverse = [&](auto &Set, LVSortFunction SortFunction) {
             if (Set)
               std::stable_sort(Set->begin(), Set->end(), SortFunction);
           };
           Traverse(Parent->Types, SortFunction);
           Traverse(Parent->Symbols, SortFunction);
           Traverse(Parent->Scopes, SortFunction);
           Traverse(Parent->Ranges, compareRange);
           Traverse(Parent->Children, SortFunction);
 
           if (Parent->Scopes)
             for (LVScope *Scope : *Parent->Scopes)
               Sort(Scope, SortFunction);
         };
 
     // Start traversing the scopes root and transform the element name.
     Sort(this, SortFunction);
return !(
       (options().getCompareScopes() && scopeCount() != Scope->scopeCount()) ||
       (options().getCompareSymbols() &&
        symbolCount() != Scope->symbolCount()) ||
       (options().getCompareTypes() && typeCount() != Scope->typeCount()) ||
       (options().getCompareLines() && lineCount() != Scope->lineCount()));
 }
 
 void LVScope::markMissingParents(const LVScope *Target, bool TraverseChildren) {
-  auto SetCompareState = [&](auto *Container) {
+  auto SetCompareState = [&](auto &Container) {
     if (Container)
       for (auto *Entry : *Container)
         Entry->setIsInCompare();
   };
   SetCompareState(Types);
   SetCompareState(Symbols);
   SetCompareState(Lines);
   SetCompareState(Scopes);

 }
 void LVScopeCompileUnit::addedElement(LVType *Type) {
   increment(Type);
   getReader().notifyAddedElement(Type);
 }
 
 // Record unsuported DWARF tags.
 void LVScopeCompileUnit::addDebugTag(dwarf::Tag Target, LVOffset Offset) {
-  addItem<LVTagOffsetsMap, LVOffsetList, dwarf::Tag, LVOffset>(&DebugTags,
-                                                               Target, Offset);
+  addItem<LVTagOffsetsMap, dwarf::Tag, LVOffset>(&DebugTags, Target, Offset);
 }
 
 // Record elements with invalid offsets.
 void LVScopeCompileUnit::addInvalidOffset(LVOffset Offset, LVElement *Element) {
   if (WarningOffsets.find(Offset) == WarningOffsets.end())
     WarningOffsets.emplace(Offset, Element);
 }
 
addInvalidLocationOrRange(Location, Location->getParentScope(),
                             &InvalidRanges);
 }
 
 // Record line zero.
 void LVScopeCompileUnit::addLineZero(LVLine *Line) {
   LVScope *Scope = Line->getParentScope();
   LVOffset Offset = Scope->getOffset();
   addInvalidOffset(Offset, Scope);
-  addItem<LVOffsetLinesMap, LVLines, LVOffset, LVLine *>(&LinesZero, Offset,
-                                                         Line);
+  addItem<LVOffsetLinesMap, LVOffset, LVLine *>(&LinesZero, Offset, Line);
 }
 
 void LVScopeCompileUnit::printLocalNames(raw_ostream &OS, bool Full) const {
   if (!options().getPrintFormatting())
     return;
 
   // Calculate an indentation value, to preserve a nice layout.
   size_t Indentation = options().indentationSize() +
if (Element)
          << formattedName(Element->getName());
     OS << "\n";
   };
   auto PrintInvalidLocations = [&](const LVOffsetLocationsMap &Map,
                                    const char *Header) {
     PrintHeader(Header);
     for (LVOffsetLocationsMap::const_reference Entry : Map) {
       PrintElement(WarningOffsets, Entry.first);
-      for (const LVLocation *Location : *Entry.second)
+      for (const LVLocation *Location : Entry.second)
         OS << hexSquareString(Location->getOffset()) << " "
            << Location->getIntervalInfo() << "\n";
     }
     PrintFooter(Map);
   };
 
   if (options().getInternalTag() && getReader().isBinaryTypeELF()) {
     PrintHeader("Unsupported DWARF Tags");
     for (LVTagOffsetsMap::const_reference Entry : DebugTags) {
       OS << format("\n0x%02x", (unsigned)Entry.first) << ", "
          << dwarf::TagString(Entry.first) << "\n";
       unsigned Count = 0;
-      for (const LVOffset &Offset : *Entry.second)
+      for (const LVOffset &Offset : Entry.second)
         PrintOffset(Count, Offset);
       OS << "\n";
     }
     PrintFooter(DebugTags);
   }
 
   if (options().getWarningCoverages()) {
     PrintHeader("Symbols Invalid Coverages");
     for (LVOffsetSymbolMap::const_reference Entry : InvalidCoverages) {
       // Symbol basic information.
       LVSymbol *Symbol = Entry.second;
       OS << hexSquareString(Entry.first) << " {Coverage} "
          << format("%.2f%%", Symbol->getCoveragePercentage()) << " "
          << formattedKind(Symbol->kind()) << " "
          << formattedName(Symbol->getName()) << "\n";
     }
     PrintFooter(InvalidCoverages);
   }
 
   if (options().getWarningLines()) {
     PrintHeader("Lines Zero References");
     for (LVOffsetLinesMap::const_reference Entry : LinesZero) {
       PrintElement(WarningOffsets, Entry.first);
       unsigned Count = 0;
-      for (const LVLine *Line : *Entry.second)
+      for (const LVLine *Line : Entry.second)
         PrintOffset(Count, Line->getOffset());
       OS << "\n";
     }
     PrintFooter(LinesZero);
   }
 
   if (options().getWarningLocations())
     PrintInvalidLocations(InvalidLocations, "Invalid Location Ranges");

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

LVSymbolDispatch LVSymbol::Dispatch = {
     {LVSymbolKind::IsUnspecified, &LVSymbol::getIsUnspecified},
     {LVSymbolKind::IsVariable, &LVSymbol::getIsVariable}};
 
 // Add a Location Entry.
 void LVSymbol::addLocation(dwarf::Attribute Attr, LVAddress LowPC,
                            LVAddress HighPC, LVUnsigned SectionOffset,
                            uint64_t LocDescOffset, bool CallSiteLocation) {
   if (!Locations)
-    Locations = new LVAutoLocations();
+    Locations = std::make_unique<LVLocations>();
 
   // Create the location entry.
-  CurrentLocation = new LVLocationSymbol();
+  CurrentLocation = getReader().createLocationSymbol();
   CurrentLocation->setParent(this);
   CurrentLocation->setAttr(Attr);
   if (CallSiteLocation)
     CurrentLocation->setIsCallSite();
   CurrentLocation->addObject(LowPC, HighPC, SectionOffset, LocDescOffset);
   Locations->push_back(CurrentLocation);
 
   // Mark the symbol as having location information.
void LVSymbol::addLocationConstant(dwarf::Attribute Attr, LVUnsigned Constant,
   addLocationOperands(/*Opcode=*/LVLocationMemberOffset,
                       /*Operand1=*/Constant, /*Operand2=*/0);
 }
 
 LVLocations::iterator LVSymbol::addLocationGap(LVLocations::iterator Pos,
                                                LVAddress LowPC,
                                                LVAddress HighPC) {
   // Create a location entry for the gap.
-  LVLocation *Gap = new LVLocationSymbol();
+  LVLocation *Gap = getReader().createLocationSymbol();
   Gap->setParent(this);
   Gap->setAttr(dwarf::DW_AT_location);
   Gap->addObject(LowPC, HighPC,
                  /*section_offset=*/0,
                  /*locdesc_offset=*/0);
 
   LVLocations::iterator Iter = Locations->insert(Pos, Gap);
 
if (!Locations)
     return;
 
   for (LVLocation *Location : *Locations)
     LocationList.push_back(Location);
 }
 
 // Calculate coverage factor.
 void LVSymbol::calculateCoverage() {
-  if (!LVLocation::calculateCoverage(Locations, CoverageFactor,
+  if (!LVLocation::calculateCoverage(Locations.get(), CoverageFactor,
                                      CoveragePercentage)) {
     LVScope *Parent = getParentScope();
     if (Parent->getIsInlinedFunction()) {
       // For symbols representing the inlined function parameters and its
       // variables, get the outer most parent that contains their location
       // lower address.
       // The symbol can have a set of non-contiguous locations. We are using
       // only the first location entry to get the outermost parent.
void LVSymbol::printExtra(raw_ostream &OS, bool Full) const {
 
   if (Full && options().getPrintFormatting()) {
     if (getLinkageNameIndex())
       printLinkageName(OS, Full, const_cast<LVSymbol *>(this));
     if (LVSymbol *Reference = getReference())
       Reference->printReference(OS, Full, const_cast<LVSymbol *>(this));
 
     // Print location information.
-    LVLocation::print(Locations, OS, Full);
+    LVLocation::print(Locations.get(), OS, Full);
   }
 }

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

if (!Types)
     return;
 
   // During a compare task, the template parameters are expanded to
   // point to their real types, to avoid compare conflicts.
   for (LVType *Type : *Types) {
     if (!Type->getIsTemplateParam())
       continue;
     if (options().getAttributeArgument()) {
-      LVScope *Scope = nullptr;
       if (Type->getIsKindType())
-        Type = Type->getTypeAsType();
-      else {
-        if (Type->getIsKindScope()) {
-          Scope = Type->getTypeAsScope();
-          Type = nullptr;
-        }
-      }
-      Type ? TypesParam->push_back(Type) : ScopesParam->push_back(Scope);
+        TypesParam->push_back(Type->getTypeAsType());
+      else if (Type->getIsKindScope())
+        ScopesParam->push_back(Type->getTypeAsScope());
     } else
       TypesParam->push_back(Type);
   }
 }
 
 bool LVType::equals(const LVType *Type) const {
   return LVElement::equals(Type);
 }
 
 bool LVType::equals(const LVTypes *References, const LVTypes *Targets) {
   if (!References && !Targets)
     return true;
   if (References && Targets && References->size() == Targets->size()) {
     for (const LVType *Reference : *References)

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

Error LVReaderHandler::process() {
   if (Error Err = printReaders())
     return Err;
   if (Error Err = compareReaders())
     return Err;
 
   return Error::success();
 }
 
-void LVReaderHandler::destroyReaders() {
-  LLVM_DEBUG(dbgs() << "destroyReaders\n");
-  for (const LVReader *Reader : TheReaders)
-    delete Reader;
-}
-
 Error LVReaderHandler::createReader(StringRef Filename, LVReaders &Readers,
                                     PdbOrObj &Input, StringRef FileFormatName,
                                     StringRef ExePath) {
-  auto CreateOneReader = [&]() -> LVReader * {
+  auto CreateOneReader = [&]() -> std::unique_ptr<LVReader> {
     if (Input.is<ObjectFile *>()) {
       ObjectFile &Obj = *Input.get<ObjectFile *>();
       if (Obj.isELF() || Obj.isMachO())
-        return new LVELFReader(Filename, FileFormatName, Obj, W);
+        return std::make_unique<LVELFReader>(Filename, FileFormatName, Obj, W);
     }
     return nullptr;
   };
 
-  LVReader *Reader = CreateOneReader();
-  if (!Reader)
+  std::unique_ptr<LVReader> ReaderObj = CreateOneReader();
+  if (!ReaderObj)
     return createStringError(errc::invalid_argument,
                              "unable to create reader for: '%s'",
                              Filename.str().c_str());
 
-  Readers.push_back(Reader);
+  LVReader *Reader = ReaderObj.get();
+  Readers.emplace_back(std::move(ReaderObj));
   return Reader->doLoad();
 }
 
 Error LVReaderHandler::handleArchive(LVReaders &Readers, StringRef Filename,
                                      Archive &Arch) {
   Error Err = Error::success();
   for (const Archive::Child &Child : Arch.children(Err)) {
     Expected<MemoryBufferRef> BuffOrErr = Child.getMemoryBufferRef();

 }
 
 Error LVReaderHandler::createReaders() {
   LLVM_DEBUG(dbgs() << "createReaders\n");
   for (std::string &Object : Objects) {
     LVReaders Readers;
     if (Error Err = createReader(Object, Readers))
       return Err;
-    TheReaders.insert(TheReaders.end(), Readers.begin(), Readers.end());
+    TheReaders.insert(TheReaders.end(),
+                      std::make_move_iterator(Readers.begin()),
+                      std::make_move_iterator(Readers.end()));
   }
 
   return Error::success();
 }
 
 Error LVReaderHandler::printReaders() {
   LLVM_DEBUG(dbgs() << "printReaders\n");
   if (options().getPrintExecute())
-    for (LVReader *Reader : TheReaders)
+    for (const std::unique_ptr<LVReader> &Reader : TheReaders)
       if (Error Err = Reader->doPrint())
         return Err;
 
   return Error::success();
 }
 
 Error LVReaderHandler::compareReaders() {
   LLVM_DEBUG(dbgs() << "compareReaders\n");
   size_t ReadersCount = TheReaders.size();
   if (options().getCompareExecute() && ReadersCount >= 2) {
     // If we have more than 2 readers, compare them by pairs.
     size_t ViewPairs = ReadersCount / 2;
     LVCompare Compare(OS);
     for (size_t Pair = 0, Index = 0; Pair < ViewPairs; ++Pair) {
-      if (Error Err = Compare.execute(TheReaders[Index], TheReaders[Index + 1]))
+      if (Error Err = Compare.execute(TheReaders[Index].get(),
+                                      TheReaders[Index + 1].get()))
         return Err;
       Index += 2;
     }
   }
 
   return Error::success();
 }
 
 void LVReaderHandler::print(raw_ostream &OS) const { OS << "ReaderHandler\n"; }

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

 
 void LVBinaryReader::addSectionRange(LVSectionIndex SectionIndex,
                                      LVScope *Scope, LVAddress LowerAddress,
                                      LVAddress UpperAddress) {
   LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
   ScopesWithRanges->addEntry(Scope, LowerAddress, UpperAddress);
 }
 
 LVRange *LVBinaryReader::getSectionRanges(LVSectionIndex SectionIndex) {
-  LVRange *Range = nullptr;
   // Check if we already have a mapping for this section index.
   LVSectionRanges::iterator IterSection = SectionRanges.find(SectionIndex);
-  if (IterSection == SectionRanges.end()) {
-    Range = new LVRange();
-    SectionRanges.emplace(SectionIndex, Range);
-  } else {
-    Range = IterSection->second;
-  }
+  if (IterSection == SectionRanges.end())
+    IterSection =
+        SectionRanges.emplace(SectionIndex, std::make_unique<LVRange>()).first;
+  LVRange *Range = IterSection->second.get();
   assert(Range && "Range is null.");
   return Range;
 }
 
-LVBinaryReader::~LVBinaryReader() {
-  // Delete the lines created by 'createInstructions'.
-  std::vector<LVLines *> AllInstructionLines = ScopeInstructions.find();
-  for (LVLines *Entry : AllInstructionLines)
-    delete Entry;
-  // Delete the ranges created by 'getSectionRanges'.
-  for (LVSectionRanges::reference Entry : SectionRanges)
-    delete Entry.second;
-}
-
 Error LVBinaryReader::createInstructions(LVScope *Scope,
                                          LVSectionIndex SectionIndex,
                                          const LVNameInfo &NameInfo) {
   assert(Scope && "Scope is null.");
 
   // Skip stripped functions.
   if (Scope->getIsDiscarded())
     return Error::success();
else
              << hexValue((uint64_t)Section.getAddress() + Section.getSize(), 10)
              << "] Name: '" << *SectionNameOrErr << "'\n"
              << "Begin: " << hexValue((uint64_t)Begin)
              << ", End: " << hexValue((uint64_t)End) << "\n";
   });
 
   // Address for first instruction line.
   LVAddress FirstAddress = Address;
-  LVLines *Instructions = new LVLines();
+  auto InstructionsSP = std::make_unique<LVLines>();
+  LVLines &Instructions = *InstructionsSP;
+  DiscoveredLines.emplace_back(std::move(InstructionsSP));
 
   while (Begin < End) {
     MCInst Instruction;
     uint64_t BytesConsumed = 0;
     SmallVector<char, 64> InsnStr;
     raw_svector_ostream Annotations(InsnStr);
     MCDisassembler::DecodeStatus const S =
         MD->getInstruction(Instruction, BytesConsumed,
case MCDisassembler::Success: {
                           fmt_align(StreamCodes.str(), AlignStyle::Left, 32))
                << ") " << hexValue((uint64_t)Address) << ": " << Stream.str()
                << "\n";
       });
       // Here we add logical lines to the Instructions. Later on,
       // the 'processLines()' function will move each created logical line
       // to its enclosing logical scope, using the debug ranges information
       // and they will be released when its scope parent is deleted.
-      LVLineAssembler *Line = new LVLineAssembler();
+      LVLineAssembler *Line = createLineAssembler();
       Line->setAddress(Address);
       Line->setName(StringRef(Stream.str()).trim());
-      Instructions->push_back(Line);
+      Instructions.push_back(Line);
       break;
     }
     }
     Address += BytesConsumed;
     Begin += BytesConsumed;
   }
 
   LLVM_DEBUG({
     size_t Index = 0;
     dbgs() << "\nSectionIndex: " << format_decimal(SectionIndex, 3)
            << " Scope DIE: " << hexValue(Scope->getOffset()) << "\n"
            << "Address: " << hexValue(FirstAddress)
            << format(" - Collected instructions lines: %d\n",
-                     Instructions->size());
-    for (const LVLine *Line : *Instructions)
+                     Instructions.size());
+    for (const LVLine *Line : Instructions)
       dbgs() << format_decimal(++Index, 5) << ": "
              << hexValue(Line->getOffset()) << ", (" << Line->getName()
              << ")\n";
   });
 
   // The scope in the assembler names is linked to its own instructions.
-  ScopeInstructions.add(SectionIndex, Scope, Instructions);
+  ScopeInstructions.add(SectionIndex, Scope, &Instructions);
   AssemblerMappings.add(SectionIndex, FirstAddress, Scope);
 
   return Error::success();
 }
 
 Error LVBinaryReader::createInstructions(LVScope *Function,
                                          LVSectionIndex SectionIndex) {
   if (!options().getPrintInstructions())
for (LVBucket &Bucket : Buckets) {
           Group.push_back(*Iter);
         processLines(&Group, SectionIndex, /*Function=*/nullptr);
         std::get<3>(Bucket) = true;
         break;
       }
     }
   }
 }
 
 void LVBinaryReader::print(raw_ostream &OS) const {
   OS << "LVBinaryReader\n";
   LLVM_DEBUG(dbgs() << "PrintReader\n");
 }

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

if (!options().getPrintSymbols()) {
     default:
       break;
     }
   }
 
   switch (Tag) {
   // Types.
   case dwarf::DW_TAG_base_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsBase();
     if (options().getAttributeBase())
       CurrentType->setIncludeInPrint();
     return CurrentType;
   case dwarf::DW_TAG_const_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsConst();
     CurrentType->setName("const");
     return CurrentType;
   case dwarf::DW_TAG_enumerator:
-    CurrentType = new LVTypeEnumerator();
+    CurrentType = createTypeEnumerator();
     return CurrentType;
   case dwarf::DW_TAG_imported_declaration:
-    CurrentType = new LVTypeImport();
+    CurrentType = createTypeImport();
     CurrentType->setIsImportDeclaration();
     return CurrentType;
   case dwarf::DW_TAG_imported_module:
-    CurrentType = new LVTypeImport();
+    CurrentType = createTypeImport();
     CurrentType->setIsImportModule();
     return CurrentType;
   case dwarf::DW_TAG_pointer_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsPointer();
     CurrentType->setName("*");
     return CurrentType;
   case dwarf::DW_TAG_ptr_to_member_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsPointerMember();
     CurrentType->setName("*");
     return CurrentType;
   case dwarf::DW_TAG_reference_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsReference();
     CurrentType->setName("&");
     return CurrentType;
   case dwarf::DW_TAG_restrict_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsRestrict();
     CurrentType->setName("restrict");
     return CurrentType;
   case dwarf::DW_TAG_rvalue_reference_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsRvalueReference();
     CurrentType->setName("&&");
     return CurrentType;
   case dwarf::DW_TAG_subrange_type:
-    CurrentType = new LVTypeSubrange();
+    CurrentType = createTypeSubrange();
     return CurrentType;
   case dwarf::DW_TAG_template_value_parameter:
-    CurrentType = new LVTypeParam();
+    CurrentType = createTypeParam();
     CurrentType->setIsTemplateValueParam();
     return CurrentType;
   case dwarf::DW_TAG_template_type_parameter:
-    CurrentType = new LVTypeParam();
+    CurrentType = createTypeParam();
     CurrentType->setIsTemplateTypeParam();
     return CurrentType;
   case dwarf::DW_TAG_GNU_template_template_param:
-    CurrentType = new LVTypeParam();
+    CurrentType = createTypeParam();
     CurrentType->setIsTemplateTemplateParam();
     return CurrentType;
   case dwarf::DW_TAG_typedef:
-    CurrentType = new LVTypeDefinition();
+    CurrentType = createTypeDefinition();
     return CurrentType;
   case dwarf::DW_TAG_unspecified_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsUnspecified();
     return CurrentType;
   case dwarf::DW_TAG_volatile_type:
-    CurrentType = new LVType();
+    CurrentType = createType();
     CurrentType->setIsVolatile();
     CurrentType->setName("volatile");
     return CurrentType;
 
   // Symbols.
   case dwarf::DW_TAG_formal_parameter:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsParameter();
     return CurrentSymbol;
   case dwarf::DW_TAG_unspecified_parameters:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsUnspecified();
     CurrentSymbol->setName("...");
     return CurrentSymbol;
   case dwarf::DW_TAG_member:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsMember();
     return CurrentSymbol;
   case dwarf::DW_TAG_variable:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsVariable();
     return CurrentSymbol;
   case dwarf::DW_TAG_inheritance:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsInheritance();
     return CurrentSymbol;
   case dwarf::DW_TAG_call_site_parameter:
   case dwarf::DW_TAG_GNU_call_site_parameter:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsCallSiteParameter();
     return CurrentSymbol;
   case dwarf::DW_TAG_constant:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createSymbol();
     CurrentSymbol->setIsConstant();
     return CurrentSymbol;
 
   // Scopes.
   case dwarf::DW_TAG_catch_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createScope();
     CurrentScope->setIsCatchBlock();
     return CurrentScope;
   case dwarf::DW_TAG_lexical_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createScope();
     CurrentScope->setIsLexicalBlock();
     return CurrentScope;
   case dwarf::DW_TAG_try_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createScope();
     CurrentScope->setIsTryBlock();
     return CurrentScope;
   case dwarf::DW_TAG_compile_unit:
   case dwarf::DW_TAG_skeleton_unit:
-    CurrentScope = new LVScopeCompileUnit();
+    CurrentScope = createScopeCompileUnit();
     CompileUnit = static_cast<LVScopeCompileUnit *>(CurrentScope);
     return CurrentScope;
   case dwarf::DW_TAG_inlined_subroutine:
-    CurrentScope = new LVScopeFunctionInlined();
+    CurrentScope = createScopeFunctionInlined();
     return CurrentScope;
   case dwarf::DW_TAG_namespace:
-    CurrentScope = new LVScopeNamespace();
+    CurrentScope = createScopeNamespace();
     return CurrentScope;
   case dwarf::DW_TAG_template_alias:
-    CurrentScope = new LVScopeAlias();
+    CurrentScope = createScopeAlias();
     return CurrentScope;
   case dwarf::DW_TAG_array_type:
-    CurrentScope = new LVScopeArray();
+    CurrentScope = createScopeArray();
     return CurrentScope;
   case dwarf::DW_TAG_call_site:
   case dwarf::DW_TAG_GNU_call_site:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createScopeFunction();
     CurrentScope->setIsCallSite();
     return CurrentScope;
   case dwarf::DW_TAG_entry_point:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createScopeFunction();
     CurrentScope->setIsEntryPoint();
     return CurrentScope;
   case dwarf::DW_TAG_subprogram:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createScopeFunction();
     CurrentScope->setIsSubprogram();
     return CurrentScope;
   case dwarf::DW_TAG_subroutine_type:
-    CurrentScope = new LVScopeFunctionType();
+    CurrentScope = createScopeFunctionType();
     return CurrentScope;
   case dwarf::DW_TAG_label:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createScopeFunction();
     CurrentScope->setIsLabel();
     return CurrentScope;
   case dwarf::DW_TAG_class_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createScopeAggregate();
     CurrentScope->setIsClass();
     return CurrentScope;
   case dwarf::DW_TAG_structure_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createScopeAggregate();
     CurrentScope->setIsStructure();
     return CurrentScope;
   case dwarf::DW_TAG_union_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createScopeAggregate();
     CurrentScope->setIsUnion();
     return CurrentScope;
   case dwarf::DW_TAG_enumeration_type:
-    CurrentScope = new LVScopeEnumeration();
+    CurrentScope = createScopeEnumeration();
     return CurrentScope;
   case dwarf::DW_TAG_GNU_formal_parameter_pack:
-    CurrentScope = new LVScopeFormalPack();
+    CurrentScope = createScopeFormalPack();
     return CurrentScope;
   case dwarf::DW_TAG_GNU_template_parameter_pack:
-    CurrentScope = new LVScopeTemplatePack();
+    CurrentScope = createScopeTemplatePack();
     return CurrentScope;
   default:
     // Collect TAGs not implemented.
     if (options().getInternalTag() && Tag)
       CompileUnit->addDebugTag(Tag, CurrentOffset);
     break;
   }
   return nullptr;
void LVELFReader::createLineAndFileRecords(
 
   // Get the source lines if requested by command line option.
   if (options().getPrintLines() && Lines->Rows.size())
     for (const DWARFDebugLine::Row &Row : Lines->Rows) {
       // Here we collect logical debug lines in CULines. Later on,
       // the 'processLines()' function will move each created logical line
       // to its enclosing logical scope, using the debug ranges information
       // and they will be released when its scope parent is deleted.
-      LVLineDebug *Line = new LVLineDebug();
+      LVLineDebug *Line = createLineDebug();
       CULines.push_back(Line);
       Line->setAddress(Row.Address.Address);
       Line->setFilename(
           CompileUnit->getFilename(IncrementIndex ? Row.File + 1 : Row.File));
       Line->setLineNumber(Row.Line);
       if (Row.Discriminator)
         Line->setDiscriminator(Row.Discriminator);
       if (Row.IsStmt)

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

 using namespace llvm;
 using namespace llvm::logicalview;
 
 namespace {
 
 //===----------------------------------------------------------------------===//
 // Basic Reader functionality.
 class ReaderTestCompare : public LVReader {
-  // Elements created but not added to any logical scope. They are
-  // deleted when the logical Reader is destroyed.
-  LVAutoSmallVector<LVElement *> OrphanElements;
+#define CREATE(VARIABLE, CREATE_FUNCTION, SET_FUNCTION)                        \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);                                                \
+  VARIABLE->SET_FUNCTION();
 
 public:
   // Types.
   LVType *IntegerType = nullptr;
   LVType *UnsignedType = nullptr;
   LVType *GlobalType = nullptr;
   LVType *LocalType = nullptr;
   LVType *NestedType = nullptr;
public:
 
   // Lines.
   LVLine *LineOne = nullptr;
   LVLine *LineTwo = nullptr;
   LVLine *LineThree = nullptr;
 
 protected:
   void add(LVScope *Parent, LVElement *Element);
-  template <typename T, typename F> T *create(F Function) {
-    // 'Function' will update a specific kind of the logical element to
-    // have the ability of kind selection.
-    T *Element = new (std::nothrow) T();
-    EXPECT_NE(Element, nullptr);
-    (Element->*Function)();
-    return Element;
-  }
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);
 
 public:
   ReaderTestCompare(ScopedPrinter &W) : LVReader("", "", W) {
     setInstance(this);
   }
 

 void ReaderTestCompare::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   ASSERT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
-  UnsignedType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
-  GlobalType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
-  LocalType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
-  NestedType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
-  EnumeratorOne =
-      create<LVTypeEnumerator, LVTypeSetFunction>(&LVType::setIsEnumerator);
-  EnumeratorTwo =
-      create<LVTypeEnumerator, LVTypeSetFunction>(&LVType::setIsEnumerator);
-  TypeDefinitionOne =
-      create<LVTypeDefinition, LVTypeSetFunction>(&LVType::setIsTypedef);
-  TypeDefinitionTwo =
-      create<LVTypeDefinition, LVTypeSetFunction>(&LVType::setIsTypedef);
+  CREATE(IntegerType, createType, setIsBase);
+  CREATE(UnsignedType, createType, setIsBase);
+  CREATE(GlobalType, createType, setIsBase);
+  CREATE(LocalType, createType, setIsBase);
+  CREATE(NestedType, createType, setIsBase);
+  CREATE(EnumeratorOne, createTypeEnumerator, setIsEnumerator);
+  CREATE(EnumeratorTwo, createTypeEnumerator, setIsEnumerator);
+  CREATE(TypeDefinitionOne, createTypeDefinition, setIsTypedef);
+  CREATE(TypeDefinitionTwo, createTypeDefinition, setIsTypedef);
 
   // Create the logical scopes.
-  NestedScope =
-      create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
-  InnerScope = create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
-  Aggregate =
-      create<LVScopeAggregate, LVScopeSetFunction>(&LVScope::setIsAggregate);
-  CompileUnit = create<LVScopeCompileUnit, LVScopeSetFunction>(
-      &LVScope::setIsCompileUnit);
-  Enumeration = create<LVScopeEnumeration, LVScopeSetFunction>(
-      &LVScope::setIsEnumeration);
-  FunctionOne =
-      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
-  FunctionTwo =
-      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
-  Namespace =
-      create<LVScopeNamespace, LVScopeSetFunction>(&LVScope::setIsNamespace);
+  CREATE(NestedScope, createScope, setIsLexicalBlock);
+  CREATE(InnerScope, createScope, setIsLexicalBlock);
+  CREATE(Aggregate, createScopeAggregate, setIsAggregate);
+  CREATE(CompileUnit, createScopeCompileUnit, setIsCompileUnit);
+  CREATE(Enumeration, createScopeEnumeration, setIsEnumeration);
+  CREATE(FunctionOne, createScopeFunction, setIsFunction);
+  CREATE(FunctionTwo, createScopeFunction, setIsFunction);
+  CREATE(Namespace, createScopeNamespace, setIsNamespace);
 
   // Create the logical symbols.
-  GlobalVariable =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
-  LocalVariable =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
-  ClassMember = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsMember);
-  NestedVariable =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
-  ParameterOne =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
-  ParameterTwo =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
+  CREATE(GlobalVariable, createSymbol, setIsVariable);
+  CREATE(LocalVariable, createSymbol, setIsVariable);
+  CREATE(ClassMember, createSymbol, setIsMember);
+  CREATE(NestedVariable, createSymbol, setIsVariable);
+  CREATE(ParameterOne, createSymbol, setIsParameter);
+  CREATE(ParameterTwo, createSymbol, setIsParameter);
 
   // Create the logical lines.
-  LineOne = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
-  LineTwo = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
-  LineThree = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
+  CREATE(LineOne, createLine, setIsLineDebug);
+  CREATE(LineTwo, createLine, setIsLineDebug);
+  CREATE(LineThree, createLine, setIsLineDebug);
 }
 
 // Reference Reader:              Target Reader:
 // ----------------------         ----------------------
 // Root                           Root
 //   CompileUnit                    CompileUnit
 //     IntegerType                    IntegerType
 //     UnsignedType                   UnsignedType

 
 // Create the logical view adding the created logical elements.
 void ReaderTestCompare::addElements(bool IsReference, bool IsTarget) {
   Root->setName(IsReference ? "Reference-Reader" : "Target-Reader");
 
   auto Insert = [&](bool Insert, auto *Parent, auto *Child) {
     if (Insert)
       add(Parent, Child);
-    else
-      OrphanElements.push_back(Child);
   };
 
   setCompileUnit(CompileUnit);
   add(Root, CompileUnit);
 
   // Add elements to CompileUnit.
   Insert(true, CompileUnit, IntegerType);
   Insert(true, CompileUnit, UnsignedType);

llvm/unittests/DebugInfo/LogicalView/ELFReaderTest.cpp

LVScopeCompileUnit *getFirstCompileUnit(LVScopeRoot *Root) {
   LVScopes::const_iterator Iter = CompileUnits->begin();
   EXPECT_NE(Iter, nullptr);
   LVScopeCompileUnit *CompileUnit = static_cast<LVScopeCompileUnit *>(*Iter);
   EXPECT_NE(CompileUnit, nullptr);
   return CompileUnit;
 }
 
 // Helper function to create a reader.
-LVReader *createReader(LVReaderHandler &ReaderHandler,
-                       SmallString<128> &InputsDir, StringRef Filename) {
+std::unique_ptr<LVReader> createReader(LVReaderHandler &ReaderHandler,
+                                       SmallString<128> &InputsDir,
+                                       StringRef Filename) {
   SmallString<128> ObjectName(InputsDir);
   llvm::sys::path::append(ObjectName, Filename);
 
-  Expected<LVReader *> ReaderOrErr =
+  Expected<std::unique_ptr<LVReader>> ReaderOrErr =
       ReaderHandler.createReader(std::string(ObjectName));
   EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
-  LVReader *Reader = *ReaderOrErr;
+  std::unique_ptr<LVReader> Reader = std::move(*ReaderOrErr);
   EXPECT_NE(Reader, nullptr);
   return Reader;
 }
 
 // Check the logical elements basic properties.
 void checkElementProperties(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);
void elementProperties(SmallString<128> &InputsDir) {
   ReaderOptions.setPrintAll();
   ReaderOptions.resolveDependencies();
 
   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 
   // Check logical elements properties.
-  LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfClang);
-  checkElementProperties(Reader);
-  ReaderHandler.deleteReader(Reader);
+  std::unique_ptr<LVReader> Reader =
+      createReader(ReaderHandler, InputsDir, DwarfClang);
+  checkElementProperties(Reader.get());
 }
 
 // Logical elements selection.
 void elementSelection(SmallString<128> &InputsDir) {
   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setAttributeOffset();
   ReaderOptions.setPrintAll();
void elementSelection(SmallString<128> &InputsDir) {
 
   ReaderOptions.resolveDependencies();
 
   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 
   // Check logical elements selection.
-  LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfGcc);
-  checkElementSelection(Reader);
-  ReaderHandler.deleteReader(Reader);
+  std::unique_ptr<LVReader> Reader =
+      createReader(ReaderHandler, InputsDir, DwarfGcc);
+  checkElementSelection(Reader.get());
 }
 
 // Compare logical elements.
 void compareElements(SmallString<128> &InputsDir) {
   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setAttributeOffset();
   ReaderOptions.setPrintLines();
   ReaderOptions.setPrintSymbols();
   ReaderOptions.setPrintTypes();
   ReaderOptions.setCompareLines();
   ReaderOptions.setCompareSymbols();
   ReaderOptions.setCompareTypes();
 
   ReaderOptions.resolveDependencies();
 
   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 
   // Check logical comparison.
-  LVReader *Reference = createReader(ReaderHandler, InputsDir, DwarfClang);
-  LVReader *Target = createReader(ReaderHandler, InputsDir, DwarfGcc);
-  checkElementComparison(Reference, Target);
-  ReaderHandler.deleteReader(Reference);
-  ReaderHandler.deleteReader(Target);
+  std::unique_ptr<LVReader> Reference =
+      createReader(ReaderHandler, InputsDir, DwarfClang);
+  std::unique_ptr<LVReader> Target =
+      createReader(ReaderHandler, InputsDir, DwarfGcc);
+  checkElementComparison(Reference.get(), Target.get());
 }
 
 TEST(LogicalViewTest, ELFReader) {
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 

llvm/unittests/DebugInfo/LogicalView/LocationRangesTest.cpp

 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 namespace {
 
 class ReaderTest : public LVReader {
 protected:
+  void add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine);
   void add(LVScope *Parent, LVElement *Element);
-  template <typename T> T *create() {
-    T *Element = new (std::nothrow) T();
-    EXPECT_NE(Element, nullptr);
-    return Element;
-  }
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);
   void set(LVLocation *Location, LVLine *LowerLine, LVLine *UpperLine,
            LVAddress LowerAddress, LVAddress UpperAddress);
-  void add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine);
 
 public:
   ReaderTest(ScopedPrinter &W) : LVReader("", "", W) { setInstance(this); }
 
   Error createScopes() { return LVReader::createScopes(); }
 };
 
 // Helper function to add a logical element to a given scope.

 void ReaderTest::add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine) {
   dwarf::Attribute Attr = dwarf::DW_AT_location;
 
   Symbol->addLocation(Attr, LowerLine->getAddress(), UpperLine->getAddress(),
                       /*SectionOffset=*/0, /*LocDesOffset=*/0);
 }
 
 class ReaderTestLocations : public ReaderTest {
+#define CREATE(VARIABLE, CREATE_FUNCTION)                                      \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);
+
   // Types.
   LVType *IntegerType = nullptr;
 
   // Scopes.
   LVScope *NestedScope = nullptr;
   LVScopeFunction *Function = nullptr;
 
   // Symbols.

 void ReaderTestLocations::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   EXPECT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType>();
+  CREATE(IntegerType, createType);
 
   // Create the logical scopes.
-  NestedScope = create<LVScope>();
-  CompileUnit = create<LVScopeCompileUnit>();
-  Function = create<LVScopeFunction>();
+  CREATE(NestedScope, createScope);
+  CREATE(CompileUnit, createScopeCompileUnit);
+  CREATE(Function, createScopeFunction);
 
   // Create the logical symbols.
-  LocalVariable = create<LVSymbol>();
-  NestedVariable = create<LVSymbol>();
-  Parameter = create<LVSymbol>();
+  CREATE(LocalVariable, createSymbol);
+  CREATE(NestedVariable, createSymbol);
+  CREATE(Parameter, createSymbol);
 
   // Create the logical lines.
-  LineOne = create<LVLine>();
-  LineTwo = create<LVLine>();
-  LineThree = create<LVLine>();
-  LineFour = create<LVLine>();
-  LineFive = create<LVLine>();
-  LineSix = create<LVLine>();
+  CREATE(LineOne, createLine);
+  CREATE(LineTwo, createLine);
+  CREATE(LineThree, createLine);
+  CREATE(LineFour, createLine);
+  CREATE(LineFive, createLine);
+  CREATE(LineSix, createLine);
 
   // Create the logical locations.
-  LocationOne = create<LVLocation>();
-  LocationTwo = create<LVLocation>();
-  LocationThree = create<LVLocation>();
-  LocationFour = create<LVLocation>();
-  LocationFive = create<LVLocation>();
-  LocationSix = create<LVLocation>();
+  CREATE(LocationOne, createLocation);
+  CREATE(LocationTwo, createLocation);
+  CREATE(LocationThree, createLocation);
+  CREATE(LocationFour, createLocation);
+  CREATE(LocationFive, createLocation);
+  CREATE(LocationSix, createLocation);
 }
 
 // Create the logical view adding the created logical elements.
 void ReaderTestLocations::addElements() {
   setCompileUnit(CompileUnit);
 
   // Root
   //   CompileUnit

 void ReaderTestCoverage::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   EXPECT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType>();
+  IntegerType = createType();
+  EXPECT_NE(IntegerType, nullptr);
 
   // Create the logical scopes.
-  CompileUnit = create<LVScopeCompileUnit>();
-  Function = create<LVScopeFunction>();
-  InlinedFunction = create<LVScopeFunctionInlined>();
+  CompileUnit = createScopeCompileUnit();
+  EXPECT_NE(CompileUnit, nullptr);
+  Function = createScopeFunction();
+  EXPECT_NE(Function, nullptr);
+  InlinedFunction = createScopeFunctionInlined();
+  EXPECT_NE(InlinedFunction, nullptr);
 
   // Create the logical symbols.
-  Variable = create<LVSymbol>();
-  Parameter = create<LVSymbol>();
+  Variable = createSymbol();
+  EXPECT_NE(Variable, nullptr);
+  Parameter = createSymbol();
+  EXPECT_NE(Parameter, nullptr);
 
   // Create the logical lines.
-  LineOne = create<LVLine>();
-  LineTwo = create<LVLine>();
-  LineThree = create<LVLine>();
-  LineFour = create<LVLine>();
-  LineFive = create<LVLine>();
-  LineSix = create<LVLine>();
+  LineOne = createLine();
+  EXPECT_NE(LineOne, nullptr);
+  LineTwo = createLine();
+  EXPECT_NE(LineTwo, nullptr);
+  LineThree = createLine();
+  EXPECT_NE(LineThree, nullptr);
+  LineFour = createLine();
+  EXPECT_NE(LineFour, nullptr);
+  LineFive = createLine();
+  EXPECT_NE(LineFive, nullptr);
+  LineSix = createLine();
+  EXPECT_NE(LineSix, nullptr);
 
   // Create the logical locations.
-  LocationOne = create<LVLocation>();
-  LocationTwo = create<LVLocation>();
-  LocationFive = create<LVLocation>();
-  LocationSix = create<LVLocation>();
+  LocationOne = createLocation();
+  EXPECT_NE(LocationOne, nullptr);
+  LocationTwo = createLocation();
+  EXPECT_NE(LocationTwo, nullptr);
+  LocationFive = createLocation();
+  EXPECT_NE(LocationFive, nullptr);
+  LocationSix = createLocation();
+  EXPECT_NE(LocationSix, nullptr);
 }
 
 // Create the logical view adding the created logical elements.
 void ReaderTestCoverage::addElements() {
   setCompileUnit(CompileUnit);
 
   // Root
   //   CompileUnit

llvm/unittests/DebugInfo/LogicalView/LogicalElementsTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 namespace {
 
 class ReaderTestElements : public LVReader {
+#define CREATE(VARIABLE, CREATE_FUNCTION)                                      \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);
+
   // Types.
   LVType *IntegerType = nullptr;
   LVType *UnsignedType = nullptr;
   LVType *GlobalType = nullptr;
   LVType *LocalType = nullptr;
   LVType *NestedType = nullptr;
   LVTypeDefinition *TypeDefinitionOne = nullptr;
   LVTypeDefinition *TypeDefinitionTwo = nullptr;
#define CREATE(VARIABLE, CREATE_FUNCTION)                                      \
   LVSymbol *Parameter = nullptr;
 
   // Lines.
   LVLine *LocalLine = nullptr;
   LVLine *NestedLine = nullptr;
 
 protected:
   void add(LVScope *Parent, LVElement *Element);
-  template <typename T> T *create() {
-    T *Element = new (std::nothrow) T();
-    EXPECT_NE(Element, nullptr);
-    return Element;
-  }
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);
 
 public:
   ReaderTestElements(ScopedPrinter &W) : LVReader("", "", W) {
     setInstance(this);
   }
 

 void ReaderTestElements::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   ASSERT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType>();
-  UnsignedType = create<LVType>();
-  GlobalType = create<LVType>();
-  LocalType = create<LVType>();
-  NestedType = create<LVType>();
-  EnumeratorOne = create<LVTypeEnumerator>();
-  EnumeratorTwo = create<LVTypeEnumerator>();
-  TypeDefinitionOne = create<LVTypeDefinition>();
-  TypeDefinitionTwo = create<LVTypeDefinition>();
-  TypeSubrange = create<LVTypeSubrange>();
-  TypeParam = create<LVTypeParam>();
-  TypeImport = create<LVTypeImport>();
+  CREATE(IntegerType, createType);
+  CREATE(UnsignedType, createType);
+  CREATE(GlobalType, createType);
+  CREATE(LocalType, createType);
+  CREATE(NestedType, createType);
+  CREATE(EnumeratorOne, createTypeEnumerator);
+  CREATE(EnumeratorTwo, createTypeEnumerator);
+  CREATE(TypeDefinitionOne, createTypeDefinition);
+  CREATE(TypeDefinitionTwo, createTypeDefinition);
+  CREATE(TypeSubrange, createTypeSubrange);
+  CREATE(TypeParam, createTypeParam);
+  CREATE(TypeImport, createTypeImport);
 
   // Create the logical scopes.
-  NestedScope = create<LVScope>();
-  Aggregate = create<LVScopeAggregate>();
-  Array = create<LVScopeArray>();
-  CompileUnit = create<LVScopeCompileUnit>();
-  Enumeration = create<LVScopeEnumeration>();
-  Function = create<LVScopeFunction>();
-  ClassFunction = create<LVScopeFunction>();
-  InlinedFunction = create<LVScopeFunctionInlined>();
-  Namespace = create<LVScopeNamespace>();
+  CREATE(NestedScope, createScope);
+  CREATE(Aggregate, createScopeAggregate);
+  CREATE(Array, createScopeArray);
+  CREATE(CompileUnit, createScopeCompileUnit);
+  CREATE(Enumeration, createScopeEnumeration);
+  CREATE(Function, createScopeFunction);
+  CREATE(ClassFunction, createScopeFunction);
+  CREATE(InlinedFunction, createScopeFunctionInlined);
+  CREATE(Namespace, createScopeNamespace);
 
   // Create the logical symbols.
-  GlobalVariable = create<LVSymbol>();
-  LocalVariable = create<LVSymbol>();
-  ClassMember = create<LVSymbol>();
-  NestedVariable = create<LVSymbol>();
-  Parameter = create<LVSymbol>();
+  CREATE(GlobalVariable, createSymbol);
+  CREATE(LocalVariable, createSymbol);
+  CREATE(ClassMember, createSymbol);
+  CREATE(NestedVariable, createSymbol);
+  CREATE(Parameter, createSymbol);
 
   // Create the logical lines.
-  LocalLine = create<LVLine>();
-  NestedLine = create<LVLine>();
+  CREATE(LocalLine, createLine);
+  CREATE(NestedLine, createLine);
 }
 
 // Create the logical view adding the created logical elements.
 void ReaderTestElements::addElements() {
   setCompileUnit(CompileUnit);
 
   // Root
   //   CompileUnit

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 namespace {
 
 class ReaderTestSelection : public LVReader {
+#define CREATE(VARIABLE, CREATE_FUNCTION, SET_FUNCTION)                        \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);                                                \
+  VARIABLE->SET_FUNCTION();
+
   // Types.
   LVType *IntegerType = nullptr;
 
   // Scopes.
   LVScope *NestedScope = nullptr;
   LVScopeAggregate *Aggregate = nullptr;
   LVScopeFunction *Function = nullptr;
   LVScopeNamespace *Namespace = nullptr;
 
   // Symbols.
   LVSymbol *ClassMember = nullptr;
   LVSymbol *LocalVariable = nullptr;
   LVSymbol *NestedVariable = nullptr;
   LVSymbol *Parameter = nullptr;
 
   // Lines.
   LVLine *LineOne = nullptr;
   LVLine *LineTwo = nullptr;
   LVLine *LineThree = nullptr;
   LVLine *LineFour = nullptr;
   LVLine *LineFive = nullptr;
 
 protected:
   void add(LVScope *Parent, LVElement *Element);
-  template <typename T, typename F> T *create(F Function) {
-    // 'Function' will update a specific kind of the logical element to
-    // have the ability of kind selection.
-    T *Element = new (std::nothrow) T();
-    EXPECT_NE(Element, nullptr);
-    (Element->*Function)();
-    return Element;
-  }
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);
 
 public:
   ReaderTestSelection(ScopedPrinter &W) : LVReader("", "", W) {
     setInstance(this);
   }
 

 void ReaderTestSelection::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   EXPECT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  CREATE(IntegerType, createType, setIsBase);
 
   // Create the logical scopes.
-  CompileUnit = create<LVScopeCompileUnit, LVScopeSetFunction>(
-      &LVScope::setIsCompileUnit);
-  Function =
-      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
-  NestedScope =
-      create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
-  Namespace =
-      create<LVScopeNamespace, LVScopeSetFunction>(&LVScope::setIsNamespace);
-  Aggregate =
-      create<LVScopeAggregate, LVScopeSetFunction>(&LVScope::setIsAggregate);
+  CREATE(CompileUnit, createScopeCompileUnit, setIsCompileUnit);
+  CREATE(Function, createScopeFunction, setIsFunction);
+  CREATE(NestedScope, createScope, setIsLexicalBlock);
+  CREATE(Namespace, createScopeNamespace, setIsNamespace);
+  CREATE(Aggregate, createScopeAggregate, setIsAggregate);
 
   // Create the logical symbols.
-  ClassMember = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsMember);
-  LocalVariable =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
-  NestedVariable =
-      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
-  Parameter = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
+  CREATE(ClassMember, createSymbol, setIsMember);
+  CREATE(LocalVariable, createSymbol, setIsVariable);
+  CREATE(NestedVariable, createSymbol, setIsVariable);
+  CREATE(Parameter, createSymbol, setIsParameter);
 
   // Create the logical lines.
-  LineOne = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
-  LineTwo = create<LVLine, LVLineSetFunction>(&LVLine::setIsBasicBlock);
-  LineThree = create<LVLine, LVLineSetFunction>(&LVLine::setIsNewStatement);
-  LineFour = create<LVLine, LVLineSetFunction>(&LVLine::setIsPrologueEnd);
-  LineFive = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineAssembler);
+  CREATE(LineOne, createLine, setIsLineDebug);
+  CREATE(LineTwo, createLine, setIsBasicBlock);
+  CREATE(LineThree, createLine, setIsNewStatement);
+  CREATE(LineFour, createLine, setIsPrologueEnd);
+  CREATE(LineFive, createLine, setIsLineAssembler);
 }
 
 // Create the logical view adding the created logical elements.
 void ReaderTestSelection::addElements() {
   setCompileUnit(CompileUnit);
 
   // Root
   //   CompileUnit

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

 
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 namespace {
 
-class MyLocation;
+class MyLocation : public LVLocation {
+public:
+  bool validateRanges();
+};
 
 // This code emulates the work done by the Readers when processing the
 // binary files and the creation of the AddressToLine mapping is done
 // automatically, using the text sections.
 class MyAddressToLine {
   using LVAddressToLine = std::map<LVAddress, LVLine *>;
   LVAddressToLine AddressToLineData;
 
LVLine *MyAddressToLine::lineUpperBound(LVAddress Address) {
   if (Iter != AddressToLineData.begin())
     Iter = std::prev(Iter);
   return Iter->second;
 }
 
 MyAddressToLine AddressToLine;
 
 class ReaderTestWarningInternal : public LVReader {
+#define CREATE(VARIABLE, CREATE_FUNCTION)                                      \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);
+
+#define CREATE_CUSTOM(VARIABLE, CREATE_FUNCTION)                               \
+  VARIABLE = CREATE_FUNCTION();                                                \
+  EXPECT_NE(VARIABLE, nullptr);
+
   // Types.
   LVType *IntegerType = nullptr;
 
   // Scopes.
   LVScope *NestedScope = nullptr;
   LVScopeFunction *Function = nullptr;
 
   // Symbols.
#define CREATE_CUSTOM(VARIABLE, CREATE_FUNCTION)                               \
   // Locations.
   MyLocation *LocationOne = nullptr;
   MyLocation *LocationTwo = nullptr;
   MyLocation *LocationThree = nullptr;
   MyLocation *LocationFour = nullptr;
   MyLocation *LocationFive = nullptr;
   MyLocation *LocationSix = nullptr;
 
+  llvm::SpecificBumpPtrAllocator<MyLocation> AllocatedLocations;
+
 protected:
-  void add(LVScope *Parent, LVElement *Element);
-  template <typename T> T *create() {
-    T *Element = new (std::nothrow) T();
-    EXPECT_NE(Element, nullptr);
-    return Element;
+  MyLocation *createCustomLocation() {
+    return new (AllocatedLocations.Allocate()) MyLocation();
   }
+
+  void add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine);
+  void add(LVScope *Parent, LVElement *Element);
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);
   void set(MyLocation *Location, LVLine *LowerLine, LVLine *UpperLine,
            LVAddress LowerAddress, LVAddress UpperAddress);
-  void add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine);
 
 public:
   ReaderTestWarningInternal(ScopedPrinter &W) : LVReader("", "", W) {
     setInstance(this);
   }
 
   Error createScopes() { return LVReader::createScopes(); }
 
   void setMapping();
   void createElements();
   void addElements();
   void initElements();
   void resolveElements();
   void checkWarnings();
 };
 
-class MyLocation : public LVLocation {
-public:
-  bool validateRanges();
-};
-
 bool MyLocation::validateRanges() {
   // Traverse the locations and validate them against the address to line
   // mapping in the current compile unit. Record those invalid ranges.
   // A valid range must meet the following conditions:
   // a) line(lopc) <= line(hipc)
   // b) line(lopc) and line(hipc) are valid.
 
   LVLine *LowLine = AddressToLine.lineLowerBound(getLowerAddress());

 void ReaderTestWarningInternal::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   EXPECT_NE(Root, nullptr);
 
   // Create the logical types.
-  IntegerType = create<LVType>();
+  CREATE(IntegerType, createType);
 
   // Create the logical scopes.
-  NestedScope = create<LVScope>();
-  CompileUnit = create<LVScopeCompileUnit>();
-  Function = create<LVScopeFunction>();
+  CREATE(NestedScope, createScope);
+  CREATE(CompileUnit, createScopeCompileUnit);
+  CREATE(Function, createScopeFunction);
 
   // Create the logical symbols.
-  LocalVariable = create<LVSymbol>();
-  NestedVariable = create<LVSymbol>();
-  Parameter = create<LVSymbol>();
+  CREATE(LocalVariable, createSymbol);
+  CREATE(NestedVariable, createSymbol);
+  CREATE(Parameter, createSymbol);
 
   // Create the logical lines.
-  LineOne = create<LVLine>();
-  LineTwo = create<LVLine>();
-  LineThree = create<LVLine>();
-  LineFour = create<LVLine>();
-  LineFive = create<LVLine>();
-  LineSix = create<LVLine>();
+  CREATE(LineOne, createLine);
+  CREATE(LineTwo, createLine);
+  CREATE(LineThree, createLine);
+  CREATE(LineFour, createLine);
+  CREATE(LineFive, createLine);
+  CREATE(LineSix, createLine);
 
   // Create the logical locations.
-  LocationOne = create<MyLocation>();
-  LocationTwo = create<MyLocation>();
-  LocationThree = create<MyLocation>();
-  LocationFour = create<MyLocation>();
-  LocationFive = create<MyLocation>();
-  LocationSix = create<MyLocation>();
+  CREATE_CUSTOM(LocationOne, createCustomLocation);
+  CREATE_CUSTOM(LocationTwo, createCustomLocation);
+  CREATE_CUSTOM(LocationThree, createCustomLocation);
+  CREATE_CUSTOM(LocationFour, createCustomLocation);
+  CREATE_CUSTOM(LocationFive, createCustomLocation);
+  CREATE_CUSTOM(LocationSix, createCustomLocation);
 }
 
 // Create the logical view adding the created logical elements.
 void ReaderTestWarningInternal::addElements() {
   setCompileUnit(CompileUnit);
 
   // Root
   //   CompileUnit
void ReaderTestWarningInternal::checkWarnings() {
   // Get lines with line zero. [Parent, Line]
   //   Function, LineTwo
   //   NestedScope, LineFour
   LVOffsetLinesMap LinesZero = CompileUnit->getLinesZero();
   ASSERT_EQ(LinesZero.size(), 2u);
 
   LVOffsetLinesMap::iterator IterZero = LinesZero.begin();
   EXPECT_EQ(IterZero->first, Function->getOffset());
-  LVLines *Lines = IterZero->second;
+  LVLines *Lines = &IterZero->second;
   EXPECT_NE(Lines, nullptr);
   ASSERT_EQ(Lines->size(), 1u);
   LVLine *Line = *(Lines->begin());
   EXPECT_NE(Line, nullptr);
   EXPECT_EQ(Line, LineTwo);
 
   ++IterZero;
   EXPECT_EQ(IterZero->first, NestedScope->getOffset());
-  Lines = IterZero->second;
+  Lines = &IterZero->second;
   EXPECT_NE(Lines, nullptr);
   ASSERT_EQ(Lines->size(), 1u);
   Line = *(Lines->begin());
   EXPECT_NE(Line, nullptr);
   EXPECT_EQ(Line, LineFour);
 
   // Elements with invalid offsets.
   //   Function (line zero)
void ReaderTestWarningInternal::checkWarnings() {
 
   // Invalid ranges.
   //   Function
   LVOffsetLocationsMap InvalidRanges = CompileUnit->getInvalidRanges();
   ASSERT_EQ(InvalidRanges.size(), 1u);
 
   LVOffsetLocationsMap::iterator IterRange = InvalidRanges.begin();
   EXPECT_EQ(IterRange->first, Function->getOffset());
-  LVLocations *Locations = IterRange->second;
+  LVLocations *Locations = &IterRange->second;
   EXPECT_NE(Locations, nullptr);
   ASSERT_EQ(Locations->size(), 1u);
   LVLocation *Location = *(Locations->begin());
   EXPECT_NE(Location, nullptr);
   EXPECT_EQ(Location, LocationFive);
 
   // Invalid location.
   //   NestedVariable
   LVOffsetLocationsMap InvalidLocations = CompileUnit->getInvalidLocations();
   ASSERT_EQ(InvalidLocations.size(), 1u);
 
   LVOffsetLocationsMap::iterator IterLocations = InvalidLocations.begin();
   EXPECT_EQ(IterLocations->first, NestedVariable->getOffset());
-  Locations = IterLocations->second;
+  Locations = &IterLocations->second;
   EXPECT_NE(Locations, nullptr);
   ASSERT_EQ(Locations->size(), 1u);
   Location = *(Locations->begin());
   EXPECT_NE(Location, nullptr);
   EXPECT_EQ(Location->getLowerAddress(), LocationThree->getLowerAddress());
   EXPECT_EQ(Location->getUpperAddress(), LocationFour->getLowerAddress());
   EXPECT_EQ(Location->getLowerLine()->getLineNumber(),
             LineThree->getLineNumber());