[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–90

Looks like these are unused, should they be removed?

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

79

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?)

495

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

559–568

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

135–139

Maybe simplify this?

157

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

184

184–185

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

211–212

(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.

77

remove this default?

87

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

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

167–170

Perhaps?

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

286

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?

610–611

(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

355–366

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?)

431

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)

887

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–90

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;

495

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

135–139

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

157

Removed both default ctor and dtor.

184

Removed the extra parenthesis.

184–185

Removed the extra variable.

211–212

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>>;

77

Removed.

87

You are correct. Changed to return Err;.

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

167–170

Nice simplification.

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

286

Removed.

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

583

Good point. Changed to push_back.

610–611

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

887

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

559–568

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

355–366

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;

355–366

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

79

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

431

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

490

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–177

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

79

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

111

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

431

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

125–126

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–177

Good observation. Changed to use the bumpptr mechanism.

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

79

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

111

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

431

See previous comment that explains the role of DiscoveredLines.

llvm/unittests/DebugInfo/LogicalView/LogicalElementsTest.cpp

125–126

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

111

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

111

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

111

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

111

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

111

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

145

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.

147

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

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

160

This seems unnecessary - could be sunk into the uses.

163–167

165–166

168–170

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

692–696

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 ↗

(On Diff #491321)

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

429–431

430

[CarlosAlbertoEnciso]

Address feedback from @dblaikie.

[CarlosAlbertoEnciso]

@dblaikie: Thanks for your valuable feedback.

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

145

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).

147

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

160

Good point. Removed unnecessary definitions.

163–167

Changed to use auto.

165–166

Removed SecondMap.

168–170

Added LVSecondMapType *.

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

692–696

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

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

258–259 ↗

(On Diff #491321)

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

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

429–431

Changed to use auto.

430

Changed to reference.

[dblaikie]

Thanks

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

145

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.

147

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

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

692–696

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

145

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).

147

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–696

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

261 ↗

(On Diff #497907)

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

261 ↗

(On Diff #497907)

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

261 ↗

(On Diff #497907)

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;
+  using LVOperationPtr = std::unique_ptr<LVOperation>;
+  using LVOperationSet = SmallVector<LVOperationPtr, 8>;
+  std::unique_ptr<LVOperationSet> Entries = nullptr;
 
   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 LVElementPtr = std::unique_ptr<LVElement>;
+using LVLinePtr = std::unique_ptr<LVLine>;
+using LVLocationPtr = std::unique_ptr<LVLocation>;
+using LVScopePtr = std::unique_ptr<LVScope>;
+using LVSymbolPtr = std::unique_ptr<LVSymbol>;
+using LVTypePtr = std::unique_ptr<LVType>;
+
+using LVElementsPtr = std::unique_ptr<LVElements>;
+using LVLinesPtr = std::unique_ptr<LVLines>;
+using LVLocationsPtr = std::unique_ptr<LVLocations>;
+using LVScopesPtr = std::unique_ptr<LVScopes>;
+using LVSymbolsPtr = std::unique_ptr<LVSymbols>;
+using LVTypesPtr = std::unique_ptr<LVTypes>;
+
 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.

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

class LVReader {
   LVScopes Scopes;
   LVSymbols Symbols;
   LVTypes Types;
 
   // Create split folder.
   Error createSplitFolder();
   bool OutputSplit = false;
 
+  // Allocated logical elements.
+  using LVObjectPtr = std::unique_ptr<LVObject>;
+  SmallVector<LVObjectPtr> AllocatedObjects;
+
 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 = createObject<LVScopeRoot>();
     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 and records it in the Reader.
+  template <typename ObjectType> ObjectType *createObject() {
+    LVObjectPtr ObjectPtr = std::make_unique<ObjectType>();
+    LVObject *Object = ObjectPtr.get();
+    AllocatedObjects.emplace_back(std::move(ObjectPtr));
+    return (ObjectType *)Object;
   }
 
   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;
+  LVTypesPtr Types = nullptr;
+  LVSymbolsPtr Symbols = nullptr;
+  LVScopesPtr Scopes = nullptr;
+  LVLinesPtr Lines = nullptr;
+  LVLocationsPtr Ranges = nullptr;
 
   // 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;
+  LVElementsPtr Children = nullptr;
 
   // 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() {}
 
   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 {
+  const LVTagOffsetsMap &getDebugTags() const { return DebugTags; }
+  const LVOffsetElementMap &getWarningOffsets() const { return WarningOffsets; }
+  const LVOffsetLocationsMap &getInvalidLocations() const {
     return InvalidLocations;
   }
-  const LVOffsetSymbolMap getInvalidCoverages() const {
+  const LVOffsetSymbolMap &getInvalidCoverages() const {
     return InvalidCoverages;
   }
-  const LVOffsetLocationsMap getInvalidRanges() const { return InvalidRanges; }
-  const LVOffsetLinesMap getLinesZero() const { return LinesZero; }
+  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); }

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

 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <map>
 #include <sstream>
 
 namespace llvm {
 namespace logicalview {
 
-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;
-  }
-};
-
 using LVStringRefs = std::vector<StringRef>;
 using LVLexicalComponent = std::tuple<StringRef, StringRef>;
 using LVLexicalIndex =
     std::tuple<LVStringRefs::size_type, LVStringRefs::size_type>;
 
 // Used to record specific characteristics about the objects.
 template <typename T> class LVProperties {
   SmallBitVector Bits = SmallBitVector(static_cast<unsigned>(T::LastEntry) + 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;
+  typename MapType::iterator Iter = Map->find(Key);
+  if (Iter == Map->end())
+    Map->emplace(Key, std::initializer_list<ValueType>{Value});
+  else
+    (*Iter).second.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 LVSecondMapTypePtr = std::unique_ptr<LVSecondMapType>;
+  using LVFirstMapType = std::map<FirstKeyType, LVSecondMapTypePtr>;
   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;
-  }
+  ~LVDoubleMap() {}
 
   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);
+      LVSecondMapTypePtr SecondMapPtr = std::make_unique<LVSecondMapType>();
+      SecondMap = SecondMapPtr.get();
+      SecondMap->emplace(SecondKey, Value);
+      FirstMap.emplace(FirstKey, std::move(SecondMapPtr));
     } else {
-      SecondMap = FirstIter->second;
-    }
-
-    assert(SecondMap && "SecondMap is null.");
-    if (SecondMap && SecondMap->find(SecondKey) == SecondMap->end())
+      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;
+    LVSecondMapType *SecondMap = (FirstIter->second).get();
     return SecondMap;
   }
 
   ValueType find(FirstKeyType FirstKey, SecondKeyType SecondKey) const {
     LVSecondMapType *SecondMap = findMap(FirstKey);
     if (!SecondMap)
       return nullptr;
 
     typename LVSecondMapType::const_iterator SecondIter =
public:
   }
 
   // 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;
+      LVSecondMapType *SecondMap = (FirstEntry.second).get();
       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;
+  LVLocationsPtr Locations = nullptr;
   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 LVReaderObj = std::unique_ptr<LVReader>;
+using LVReaders = std::vector<LVReaderObj>;
 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(); }
+  ~LVReaderHandler() = default;
 
   Error createReader(StringRef Filename, LVReaders &Readers) {
     return handleFile(Readers, Filename);
   }
   Error process();
 
-  Expected<LVReader *> createReader(StringRef Pathname) {
+  Expected<LVReaderObj> 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 {
   // Function names extracted from the object symbol table.
   LVSymbolTable SymbolTable;
 
   // It contains the LVLineDebug elements representing the inlined logical
   // lines for the current compile unit, created by parsing the CodeView
   // S_INLINESITE symbol annotation data.
-  using LVInlineeLine = std::map<LVScope *, LVLines *>;
+  using LVInlineeLine = std::map<LVScope *, LVLinesPtr>;
   LVInlineeLine CUInlineeLines;
 
   // Instruction lines for a logical scope. These instructions are fetched
   // during its merge with the debug lines.
   LVDoubleMap<LVSectionIndex, LVScope *, LVLines *> ScopeInstructions;
 
   // Links the scope with its first assembler address line.
   LVDoubleMap<LVSectionIndex, LVAddress, LVScope *> AssemblerMappings;
 
   // Mapping from virtual address to section.
   // The virtual address refers to the address where the section is loaded.
   using LVSectionAddresses = std::map<LVSectionIndex, object::SectionRef>;
   LVSectionAddresses SectionAddresses;
 
   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 LVRangePtr = std::unique_ptr<LVRange>;
+  using LVSectionRanges = std::map<LVSectionIndex, LVRangePtr>;
   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<LVLinesPtr> 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 addInlineeLines(LVScope *Scope, LVLines &Lines) {
-    LVLines *InlineeLines = new LVLines();
+    LVLinesPtr InlineeLinesPtr = std::make_unique<LVLines>();
+    LVLines *InlineeLines = InlineeLinesPtr.get();
     *InlineeLines = std::move(Lines);
-    CUInlineeLines.emplace(Scope, InlineeLines);
+    CUInlineeLines.emplace(Scope, std::move(InlineeLinesPtr));
   }
 
   // Convert Segment::Offset pair to absolute address.
   LVAddress linearAddress(uint16_t Segment, uint32_t Offset,
                           LVAddress Addendum = 0) {
     return ImageBaseAddress + (Segment * VirtualAddress) + Offset + Addendum;
   }
 

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

class LVLogicalVisitor final {
   ScopedPrinter &W;
 
   // Encapsulates access to the input file and any dependent type server,
   // including any precompiled header object.
   llvm::pdb::InputFile &Input;
   std::shared_ptr<llvm::pdb::InputFile> TypeServer = nullptr;
   std::shared_ptr<LazyRandomTypeCollection> PrecompHeader = nullptr;
 
-  LVShared *Shared;
+  std::shared_ptr<LVShared> Shared;
 
   // Object files have only one type stream that contains both types and ids.
   // Precompiled header objects don't contain an IPI stream. Use the TPI.
   LazyRandomTypeCollection &types() {
     return TypeServer ? TypeServer->types()
                       : (PrecompHeader ? *PrecompHeader : Input.types());
   }
   LazyRandomTypeCollection &ids() {
LVSymbol *createParameter(LVElement *Element, StringRef Name,
                             LVScope *Parent);
   void createDataMember(CVMemberRecord &Record, LVScope *Parent, StringRef Name,
                         TypeIndex Type, MemberAccess Access);
   void createParents(StringRef ScopedName, LVElement *Element);
 
 public:
   LVLogicalVisitor(LVCodeViewReader *Reader, ScopedPrinter &W,
                    llvm::pdb::InputFile &Input);
-  ~LVLogicalVisitor();
+  ~LVLogicalVisitor() = default;
 
   // Current elements during the processing of a RecordType or RecordSymbol.
   // They are shared with the SymbolVisitor.
   LVElement *CurrentElement = nullptr;
   LVScope *CurrentScope = nullptr;
   LVSymbol *CurrentSymbol = nullptr;
   LVType *CurrentType = nullptr;
 
public:
 
   std::string getCompileUnitName() { return CompileUnitName; }
   void setCompileUnitName(std::string Name) {
     CompileUnitName = std::move(Name);
   }
 
   LVElement *getElement(uint32_t StreamIdx, TypeIndex TI,
                         LVScope *Parent = nullptr);
-  LVShared *getShared() { return Shared; }
+  LVShared *getShared() { return Shared.get(); }
 
   LVScope *getReaderScope() const { return ReaderScope; }
 
   void printTypeBegin(CVType &Record, TypeIndex TI, LVElement *Element,
                       uint32_t StreamIdx);
   void printTypeEnd(CVType &Record);
   void printMemberBegin(CVMemberRecord &Record, TypeIndex TI,
                         LVElement *Element, uint32_t StreamIdx);

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<LVOperationSet>();
+  Entries->emplace_back(
+      std::make_unique<LVOperation>(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;
void LVLocation::setKind() {
   // 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();
+    LVOperation *Operation = (Entries->front()).get();
     if (dwarf::DW_OP_fbreg == Operation->getOpcode())
       setIsStackOffset();
   }
 }
 
 void LVLocationSymbol::printRawExtra(raw_ostream &OS, bool Full) const {
   if (Entries)
-    for (const LVOperation *Operation : *Entries)
+    for (const LVOperationPtr &Operation : *Entries)
       Operation->print(OS, Full);
 }
 
 // Print location (formatted version).
 void LVLocation::print(LVLocations *Locations, raw_ostream &OS, bool Full) {
   if (!Locations || Locations->empty())
     return;
 
void LVLocationSymbol::printExtra(raw_ostream &OS, bool Full) const {
   printInterval(OS, Full);
   OS << "\n";
 
   // Print location entries.
   if (Full && Entries) {
     bool CodeViewLocation = getParentSymbol()->getHasCodeViewLocation();
     std::stringstream Stream;
     std::string Leading = "";
-    for (LVOperation *Operation : *Entries) {
+    for (LVOperationPtr &Operation : *Entries) {
       Stream << Leading
              << (CodeViewLocation ? Operation->getOperandsCodeViewInfo()
                                   : Operation->getOperandsDWARFInfo());
       Leading = ", ";
     }
     printAttributes(OS, Full, "{Entry} ", const_cast<LVLocationSymbol *>(this),
                     StringRef(Stream.str()),
                     /*UseQuotes=*/false,
                     /*PrintRef=*/false);
   }
 }

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().createObject<LVLocation>();
   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().createObject<LVSymbol>();
       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() {
   LVSortFunction SortFunction = getSortFunction();
   if (SortFunction) {
     std::function<void(LVScope * Parent, LVSortFunction SortFunction)> Sort =
         [&](LVScope *Parent, 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);
+          Traverse(Parent->Types.get(), SortFunction);
+          Traverse(Parent->Symbols.get(), SortFunction);
+          Traverse(Parent->Scopes.get(), SortFunction);
+          Traverse(Parent->Ranges.get(), compareRange);
+          Traverse(Parent->Children.get(), 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);

 }
 
 void LVScope::markMissingParents(const LVScope *Target, bool TraverseChildren) {
   auto SetCompareState = [&](auto *Container) {
     if (Container)
       for (auto *Entry : *Container)
         Entry->setIsInCompare();
   };
-  SetCompareState(Types);
-  SetCompareState(Symbols);
-  SetCompareState(Lines);
-  SetCompareState(Scopes);
+  SetCompareState(Types.get());
+  SetCompareState(Symbols.get());
+  SetCompareState(Lines.get());
+  SetCompareState(Scopes.get());
 
   // At this point, we are ready to start comparing the current scope, once
   // the compare bits have been set.
   if (options().getCompareTypes() && getTypes() && Target->getTypes())
     LVType::markMissingParents(getTypes(), Target->getTypes());
   if (options().getCompareSymbols() && getSymbols() && Target->getSymbols())
     LVSymbol::markMissingParents(getSymbols(), Target->getSymbols());
   if (options().getCompareLines() && getLines() && Target->getLines())

 }
 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().createObject<LVLocationSymbol>();
   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().createObject<LVLocationSymbol>();
   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/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 = [&]() -> LVReaderObj {
     if (Input.is<ObjectFile *>()) {
       ObjectFile &Obj = *Input.get<ObjectFile *>();
       if (Obj.isCOFF()) {
         COFFObjectFile *COFF = cast<COFFObjectFile>(&Obj);
-        return new LVCodeViewReader(Filename, FileFormatName, *COFF, W,
-                                    ExePath);
+        return std::make_unique<LVCodeViewReader>(Filename, FileFormatName,
+                                                  *COFF, W, ExePath);
       }
       if (Obj.isELF() || Obj.isMachO())
-        return new LVELFReader(Filename, FileFormatName, Obj, W);
+        return std::make_unique<LVELFReader>(Filename, FileFormatName, Obj, W);
     }
     if (Input.is<PDBFile *>()) {
       PDBFile &Pdb = *Input.get<PDBFile *>();
-      return new LVCodeViewReader(Filename, FileFormatName, Pdb, W, ExePath);
+      return std::make_unique<LVCodeViewReader>(Filename, FileFormatName, Pdb,
+                                                W, ExePath);
     }
     return nullptr;
   };
 
-  LVReader *Reader = CreateOneReader();
-  if (!Reader)
+  LVReaderObj 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 LVReaderObj &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);
+    LVRangePtr RangePtr = std::make_unique<LVRange>();
+    Range = RangePtr.get();
+    SectionRanges.emplace(SectionIndex, std::move(RangePtr));
   } else {
-    Range = IterSection->second;
+    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();
+  LVLinesPtr InstructionsPtr = std::make_unique<LVLines>();
+  LVLines *Instructions = InstructionsPtr.get();
+  DiscoveredLines.emplace_back(std::move(InstructionsPtr));
 
   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 = createObject<LVLineAssembler>();
       Line->setAddress(Address);
       Line->setName(StringRef(Stream.str()).trim());
       Instructions->push_back(Line);
       break;
     }
     }
     Address += BytesConsumed;
     Begin += BytesConsumed;
std::function<void(LVScope * Parent)> FindInlinedScopes =
       };
 
   // Find all inlined scopes for the given 'Function'.
   FindInlinedScopes(Function);
   for (LVInlineeLine::iterator InlineeIter : InlineeIters) {
     LVScope *Scope = InlineeIter->first;
     addToSymbolTable(Scope->getLinkageName(), Scope, SectionIndex);
 
-    LVLines *InlineeLines = InlineeIter->second;
+    LVLines *InlineeLines = (InlineeIter->second).get();
     LLVM_DEBUG({
       dbgs() << "Inlined lines for: " << Scope->getName() << "\n";
       for (const LVLine *Line : *InlineeLines)
         dbgs() << "[" << hexValue(Line->getAddress()) << "] "
                << Line->getLineNumber() << "\n";
       dbgs() << format("Debug lines: %d\n", CULines.size());
       for (const LVLine *Line : CULines)
         dbgs() << "Line address: " << hexValue(Line->getOffset()) << ", ("
if (InlineeLines->size()) {
         CULines.insert(Iter, InlineeLines->begin() + 1, InlineeLines->end());
       }
     }
 
     // Remove this set of lines from the container; each inlined function
     // creates an unique set of lines. Remove only the created container.
     CUInlineeLines.erase(InlineeIter);
     InlineeLines->clear();
-    delete InlineeLines;
   }
   LLVM_DEBUG({
     dbgs() << "Merged Inlined lines for: " << Function->getName() << "\n";
     dbgs() << format("Debug lines: %d\n", CULines.size());
     for (const LVLine *Line : CULines)
       dbgs() << "Line address: " << hexValue(Line->getOffset()) << ", ("
              << Line->getLineNumber() << ")\n";
     ;
   });
 }
 
 void LVBinaryReader::print(raw_ostream &OS) const {
   OS << "LVBinaryReader\n";
   LLVM_DEBUG(dbgs() << "PrintReader\n");
 }

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

LLVM_DEBUG({
       W.getOStream() << formatv(
           "{0} {1:x-8}\n", utostr(LI.getStartLine()),
           fmt_align(Begin + Line.Offset, AlignStyle::Right, 8, '0'));
     });
 
     // 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 *LineDebug = new LVLineDebug();
+    LVLineDebug *LineDebug = createObject<LVLineDebug>();
     CULines.push_back(LineDebug);
     LVAddress Address = linearAddress(Segment, Begin + Line.Offset);
     LineDebug->setAddress(Address + Addendum);
 
     if (LI.isAlwaysStepInto())
       LineDebug->setIsAlwaysStepInto();
     else if (LI.isNeverStepInto())
       LineDebug->setIsNeverStepInto();

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

LVScope *LVNamespaceDeduction::get(LVStringRefs Components) {
   LVScope *Namespace = nullptr;
   LVScope *Parent = Shared->Reader->getCompileUnit();
   for (const StringRef &Component : Components) {
     // Check if we have seen the namespace.
     Namespace = find(Component);
     if (!Namespace) {
       // We have identified namespaces that are generated by MSVC. Mark them
       // as 'system' so they will be excluded from the logical view.
-      Namespace = new LVScopeNamespace();
+      Namespace = Shared->Reader->createObject<LVScopeNamespace>();
       Namespace->setTag(dwarf::DW_TAG_namespace);
       Namespace->setName(Component);
       Parent->addElement(Namespace);
       getReader().isSystemEntry(Namespace);
       add(Component, Namespace);
     }
     Parent = Namespace;
   }

 }
 
 // S_INLINESITE
 Error LVSymbolVisitor::visitKnownRecord(CVSymbol &Record,
                                         InlineSiteSym &InlineSite) {
   LLVM_DEBUG({ printTypeIndex("Inlinee", InlineSite.Inlinee); });
 
   if (LVScope *InlinedFunction = LogicalVisitor->CurrentScope) {
-    LVScope *AbstractFunction = new LVScopeFunction();
+    LVScope *AbstractFunction = Reader->createObject<LVScopeFunction>();
     AbstractFunction->setIsSubprogram();
     AbstractFunction->setTag(dwarf::DW_TAG_subprogram);
     AbstractFunction->setInlineCode(dwarf::DW_INL_inlined);
     AbstractFunction->setIsInlinedAbstract();
     InlinedFunction->setReference(AbstractFunction);
 
     LogicalVisitor->startProcessArgumentList();
     // 'Inlinee' is a Type ID.

 //===----------------------------------------------------------------------===//
 // Logical visitor.
 //===----------------------------------------------------------------------===//
 LVLogicalVisitor::LVLogicalVisitor(LVCodeViewReader *Reader, ScopedPrinter &W,
                                    InputFile &Input)
     : Reader(Reader), W(W), Input(Input) {
   // The LogicalVisitor connects the CodeViewReader with the visitors that
   // traverse the types, symbols, etc. Do any initialization that is needed.
-  Shared = new LVShared(Reader, this);
+  Shared = std::make_shared<LVShared>(Reader, this);
 }
-LVLogicalVisitor::~LVLogicalVisitor() { delete Shared; }
 
 void LVLogicalVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI,
                                       uint32_t StreamIdx) {
   codeview::printTypeIndex(W, FieldName, TI,
                            StreamIdx == StreamTPI ? types() : ids());
 }
 
 void LVLogicalVisitor::printTypeBegin(CVType &Record, TypeIndex TI,
Error LVLogicalVisitor::visitKnownRecord(CVType &Record, ArrayRecord &AT,
 
   LVType *PrevSubrange = nullptr;
   LazyRandomTypeCollection &Types = types();
 
   // As the logical view is modeled on DWARF, for each dimension we have to
   // create a DW_TAG_subrange_type, with dimension size.
   // The subrange type can be: unsigned __int32 or unsigned __int64.
   auto AddSubrangeType = [&](ArrayRecord &AR) {
-    LVType *Subrange = new LVTypeSubrange();
+    LVType *Subrange = Reader->createObject<LVTypeSubrange>();
     Subrange->setTag(dwarf::DW_TAG_subrange_type);
     Subrange->setType(getElement(StreamTPI, AR.getIndexType()));
     Subrange->setCount(AR.getSize());
     Subrange->setOffset(
         TIElementType.isSimple()
             ? (uint32_t)(TypeLeafKind)TIElementType.getSimpleKind()
             : TIElementType.getIndex());
     Array->addElement(Subrange);
Error LVLogicalVisitor::visitKnownRecord(CVType &Record, ModifierRecord &Mod,
   if (Mods & uint16_t(ModifierOptions::Const)) {
     SeenModifier = true;
     LastLink->setTag(dwarf::DW_TAG_const_type);
     LastLink->setIsConst();
     LastLink->setName("const");
   }
   if (Mods & uint16_t(ModifierOptions::Volatile)) {
     if (SeenModifier) {
-      LVType *Volatile = new LVType();
+      LVType *Volatile = Reader->createObject<LVType>();
       Volatile->setIsModifier();
       LastLink->setType(Volatile);
       LastLink = Volatile;
       CompileUnit->addElement(LastLink);
     }
     LastLink->setTag(dwarf::DW_TAG_volatile_type);
     LastLink->setIsVolatile();
     LastLink->setName("volatile");
   }
   if (Mods & uint16_t(ModifierOptions::Unaligned)) {
     if (SeenModifier) {
-      LVType *Unaligned = new LVType();
+      LVType *Unaligned = Reader->createObject<LVType>();
       Unaligned->setIsModifier();
       LastLink->setType(Unaligned);
       LastLink = Unaligned;
       CompileUnit->addElement(LastLink);
     }
     LastLink->setTag(dwarf::DW_TAG_unaligned);
     LastLink->setIsUnaligned();
     LastLink->setName("unaligned");
Error LVLogicalVisitor::visitKnownRecord(CVType &Record, PointerRecord &Ptr,
   // Const and volatile already processed.
   bool SeenModifier = false;
   LVType *LastLink = Pointer;
   if (!LastLink->getParentScope())
     CompileUnit->addElement(LastLink);
 
   if (Ptr.isRestrict()) {
     SeenModifier = true;
-    LVType *Restrict = new LVType();
+    LVType *Restrict = Reader->createObject<LVType>();
     Restrict->setTag(dwarf::DW_TAG_restrict_type);
     Restrict->setIsRestrict();
     Restrict->setName("restrict");
     LastLink->setType(Restrict);
     LastLink = Restrict;
     CompileUnit->addElement(LastLink);
   }
   if (Mode == PointerMode::LValueReference) {
     if (SeenModifier) {
-      LVType *LReference = new LVType();
+      LVType *LReference = Reader->createObject<LVType>();
       LReference->setIsModifier();
       LastLink->setType(LReference);
       LastLink = LReference;
       CompileUnit->addElement(LastLink);
     }
     LastLink->setTag(dwarf::DW_TAG_reference_type);
     LastLink->setIsReference();
     LastLink->setName("&");
   }
   if (Mode == PointerMode::RValueReference) {
     if (SeenModifier) {
-      LVType *RReference = new LVType();
+      LVType *RReference = Reader->createObject<LVType>();
       RReference->setIsModifier();
       LastLink->setType(RReference);
       LastLink = RReference;
       CompileUnit->addElement(LastLink);
     }
     LastLink->setTag(dwarf::DW_TAG_rvalue_reference_type);
     LastLink->setIsRvalueReference();
     LastLink->setName("&&");

 }
 
 LVElement *LVLogicalVisitor::createElement(TypeLeafKind Kind) {
   CurrentScope = nullptr;
   CurrentSymbol = nullptr;
   CurrentType = nullptr;
 
   if (Kind < TypeIndex::FirstNonSimpleIndex) {
-    CurrentType = new LVType();
+    CurrentType = Reader->createObject<LVType>();
     CurrentType->setIsBase();
     CurrentType->setTag(dwarf::DW_TAG_base_type);
     if (options().getAttributeBase())
       CurrentType->setIncludeInPrint();
     return CurrentType;
   }
 
   switch (Kind) {
   // Types.
   case TypeLeafKind::LF_ENUMERATE:
-    CurrentType = new LVTypeEnumerator();
+    CurrentType = Reader->createObject<LVTypeEnumerator>();
     CurrentType->setTag(dwarf::DW_TAG_enumerator);
     return CurrentType;
   case TypeLeafKind::LF_MODIFIER:
-    CurrentType = new LVType();
+    CurrentType = Reader->createObject<LVType>();
     CurrentType->setIsModifier();
     return CurrentType;
   case TypeLeafKind::LF_POINTER:
-    CurrentType = new LVType();
+    CurrentType = Reader->createObject<LVType>();
     CurrentType->setIsPointer();
     CurrentType->setName("*");
     CurrentType->setTag(dwarf::DW_TAG_pointer_type);
     return CurrentType;
 
     // Symbols.
   case TypeLeafKind::LF_BCLASS:
   case TypeLeafKind::LF_IVBCLASS:
   case TypeLeafKind::LF_VBCLASS:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = Reader->createObject<LVSymbol>();
     CurrentSymbol->setTag(dwarf::DW_TAG_inheritance);
     CurrentSymbol->setIsInheritance();
     return CurrentSymbol;
   case TypeLeafKind::LF_MEMBER:
   case TypeLeafKind::LF_STMEMBER:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = Reader->createObject<LVSymbol>();
     CurrentSymbol->setIsMember();
     CurrentSymbol->setTag(dwarf::DW_TAG_member);
     return CurrentSymbol;
 
   // Scopes.
   case TypeLeafKind::LF_ARRAY:
-    CurrentScope = new LVScopeArray();
+    CurrentScope = Reader->createObject<LVScopeArray>();
     CurrentScope->setTag(dwarf::DW_TAG_array_type);
     return CurrentScope;
   case TypeLeafKind::LF_CLASS:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = Reader->createObject<LVScopeAggregate>();
     CurrentScope->setTag(dwarf::DW_TAG_class_type);
     CurrentScope->setIsClass();
     return CurrentScope;
   case TypeLeafKind::LF_ENUM:
-    CurrentScope = new LVScopeEnumeration();
+    CurrentScope = Reader->createObject<LVScopeEnumeration>();
     CurrentScope->setTag(dwarf::DW_TAG_enumeration_type);
     return CurrentScope;
   case TypeLeafKind::LF_METHOD:
   case TypeLeafKind::LF_ONEMETHOD:
   case TypeLeafKind::LF_PROCEDURE:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = Reader->createObject<LVScopeFunction>();
     CurrentScope->setIsSubprogram();
     CurrentScope->setTag(dwarf::DW_TAG_subprogram);
     return CurrentScope;
   case TypeLeafKind::LF_STRUCTURE:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = Reader->createObject<LVScopeAggregate>();
     CurrentScope->setIsStructure();
     CurrentScope->setTag(dwarf::DW_TAG_structure_type);
     return CurrentScope;
   case TypeLeafKind::LF_UNION:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = Reader->createObject<LVScopeAggregate>();
     CurrentScope->setIsUnion();
     CurrentScope->setTag(dwarf::DW_TAG_union_type);
     return CurrentScope;
   default:
     // If '--internal=tag' and '--print=warning' are specified in the command
     // line, we record and print each seen 'TypeLeafKind'.
     break;
   }
   return nullptr;
 }
 
 LVElement *LVLogicalVisitor::createElement(SymbolKind Kind) {
   CurrentScope = nullptr;
   CurrentSymbol = nullptr;
   CurrentType = nullptr;
   switch (Kind) {
   // Types.
   case SymbolKind::S_UDT:
-    CurrentType = new LVTypeDefinition();
+    CurrentType = Reader->createObject<LVTypeDefinition>();
     CurrentType->setTag(dwarf::DW_TAG_typedef);
     return CurrentType;
 
   // Symbols.
   case SymbolKind::S_CONSTANT:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = Reader->createObject<LVSymbol>();
     CurrentSymbol->setIsConstant();
     CurrentSymbol->setTag(dwarf::DW_TAG_constant);
     return CurrentSymbol;
 
   case SymbolKind::S_BPREL32:
   case SymbolKind::S_REGREL32:
   case SymbolKind::S_GDATA32:
   case SymbolKind::S_LDATA32:
   case SymbolKind::S_LOCAL:
     // During the symbol traversal more information is available to
     // determine if the symbol is a parameter or a variable. At this
     // stage mark it as variable.
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = Reader->createObject<LVSymbol>();
     CurrentSymbol->setIsVariable();
     CurrentSymbol->setTag(dwarf::DW_TAG_variable);
     return CurrentSymbol;
 
   // Scopes.
   case SymbolKind::S_BLOCK32:
-    CurrentScope = new LVScope();
+    CurrentScope = Reader->createObject<LVScope>();
     CurrentScope->setIsLexicalBlock();
     CurrentScope->setTag(dwarf::DW_TAG_lexical_block);
     return CurrentScope;
   case SymbolKind::S_COMPILE2:
   case SymbolKind::S_COMPILE3:
-    CurrentScope = new LVScopeCompileUnit();
+    CurrentScope = Reader->createObject<LVScopeCompileUnit>();
     CurrentScope->setTag(dwarf::DW_TAG_compile_unit);
     Reader->setCompileUnit(static_cast<LVScopeCompileUnit *>(CurrentScope));
     return CurrentScope;
   case SymbolKind::S_INLINESITE:
   case SymbolKind::S_INLINESITE2:
-    CurrentScope = new LVScopeFunctionInlined();
+    CurrentScope = Reader->createObject<LVScopeFunctionInlined>();
     CurrentScope->setIsInlinedFunction();
     CurrentScope->setTag(dwarf::DW_TAG_inlined_subroutine);
     return CurrentScope;
   case SymbolKind::S_LPROC32:
   case SymbolKind::S_GPROC32:
   case SymbolKind::S_LPROC32_ID:
   case SymbolKind::S_GPROC32_ID:
   case SymbolKind::S_SEPCODE:
   case SymbolKind::S_THUNK32:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = Reader->createObject<LVScopeFunction>();
     CurrentScope->setIsSubprogram();
     CurrentScope->setTag(dwarf::DW_TAG_subprogram);
     return CurrentScope;
   default:
     // If '--internal=tag' and '--print=warning' are specified in the command
     // line, we record and print each seen 'SymbolKind'.
     break;
   }
if (LVSymbol *Symbol = CurrentSymbol) {
     }
     Symbol->setAccessibilityCode(Access);
     Parent->addElement(Symbol);
   }
 }
 
 LVSymbol *LVLogicalVisitor::createParameter(LVElement *Element, StringRef Name,
                                             LVScope *Parent) {
-  LVSymbol *Parameter = new LVSymbol();
+  LVSymbol *Parameter = Reader->createObject<LVSymbol>();
   Parent->addElement(Parameter);
   Parameter->setIsParameter();
   Parameter->setTag(dwarf::DW_TAG_formal_parameter);
   Parameter->setName(Name);
   Parameter->setType(Element);
   return Parameter;
 }
 
Error LVLogicalVisitor::inlineSiteAnnotation(LVScope *AbstractFunction,
   auto UpdateFileOffset = [&](int32_t Offset) {
     FileOffset = Offset;
     LLVM_DEBUG({ dbgs() << formatv(" file {0}", FileOffset); });
   };
 
   LVLines InlineeLines;
   auto CreateLine = [&]() {
     // Create the logical line record.
-    LVLineDebug *Line = new LVLineDebug();
+    LVLineDebug *Line = Reader->createObject<LVLineDebug>();
     Line->setAddress(CodeOffset);
     Line->setLineNumber(LineOffset);
     // TODO: This part needs additional work in order to set properly the
     // correct filename in order to detect changes between filenames.
     // Line->setFilename(Filename);
     InlineeLines.push_back(Line);
   };
 

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 = createObject<LVType>();
     CurrentType->setIsBase();
     if (options().getAttributeBase())
       CurrentType->setIncludeInPrint();
     return CurrentType;
   case dwarf::DW_TAG_const_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsConst();
     CurrentType->setName("const");
     return CurrentType;
   case dwarf::DW_TAG_enumerator:
-    CurrentType = new LVTypeEnumerator();
+    CurrentType = createObject<LVTypeEnumerator>();
     return CurrentType;
   case dwarf::DW_TAG_imported_declaration:
-    CurrentType = new LVTypeImport();
+    CurrentType = createObject<LVTypeImport>();
     CurrentType->setIsImportDeclaration();
     return CurrentType;
   case dwarf::DW_TAG_imported_module:
-    CurrentType = new LVTypeImport();
+    CurrentType = createObject<LVTypeImport>();
     CurrentType->setIsImportModule();
     return CurrentType;
   case dwarf::DW_TAG_pointer_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsPointer();
     CurrentType->setName("*");
     return CurrentType;
   case dwarf::DW_TAG_ptr_to_member_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsPointerMember();
     CurrentType->setName("*");
     return CurrentType;
   case dwarf::DW_TAG_reference_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsReference();
     CurrentType->setName("&");
     return CurrentType;
   case dwarf::DW_TAG_restrict_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsRestrict();
     CurrentType->setName("restrict");
     return CurrentType;
   case dwarf::DW_TAG_rvalue_reference_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsRvalueReference();
     CurrentType->setName("&&");
     return CurrentType;
   case dwarf::DW_TAG_subrange_type:
-    CurrentType = new LVTypeSubrange();
+    CurrentType = createObject<LVTypeSubrange>();
     return CurrentType;
   case dwarf::DW_TAG_template_value_parameter:
-    CurrentType = new LVTypeParam();
+    CurrentType = createObject<LVTypeParam>();
     CurrentType->setIsTemplateValueParam();
     return CurrentType;
   case dwarf::DW_TAG_template_type_parameter:
-    CurrentType = new LVTypeParam();
+    CurrentType = createObject<LVTypeParam>();
     CurrentType->setIsTemplateTypeParam();
     return CurrentType;
   case dwarf::DW_TAG_GNU_template_template_param:
-    CurrentType = new LVTypeParam();
+    CurrentType = createObject<LVTypeParam>();
     CurrentType->setIsTemplateTemplateParam();
     return CurrentType;
   case dwarf::DW_TAG_typedef:
-    CurrentType = new LVTypeDefinition();
+    CurrentType = createObject<LVTypeDefinition>();
     return CurrentType;
   case dwarf::DW_TAG_unspecified_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsUnspecified();
     return CurrentType;
   case dwarf::DW_TAG_volatile_type:
-    CurrentType = new LVType();
+    CurrentType = createObject<LVType>();
     CurrentType->setIsVolatile();
     CurrentType->setName("volatile");
     return CurrentType;
 
   // Symbols.
   case dwarf::DW_TAG_formal_parameter:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsParameter();
     return CurrentSymbol;
   case dwarf::DW_TAG_unspecified_parameters:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsUnspecified();
     CurrentSymbol->setName("...");
     return CurrentSymbol;
   case dwarf::DW_TAG_member:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsMember();
     return CurrentSymbol;
   case dwarf::DW_TAG_variable:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsVariable();
     return CurrentSymbol;
   case dwarf::DW_TAG_inheritance:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsInheritance();
     return CurrentSymbol;
   case dwarf::DW_TAG_call_site_parameter:
   case dwarf::DW_TAG_GNU_call_site_parameter:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsCallSiteParameter();
     return CurrentSymbol;
   case dwarf::DW_TAG_constant:
-    CurrentSymbol = new LVSymbol();
+    CurrentSymbol = createObject<LVSymbol>();
     CurrentSymbol->setIsConstant();
     return CurrentSymbol;
 
   // Scopes.
   case dwarf::DW_TAG_catch_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createObject<LVScope>();
     CurrentScope->setIsCatchBlock();
     return CurrentScope;
   case dwarf::DW_TAG_lexical_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createObject<LVScope>();
     CurrentScope->setIsLexicalBlock();
     return CurrentScope;
   case dwarf::DW_TAG_try_block:
-    CurrentScope = new LVScope();
+    CurrentScope = createObject<LVScope>();
     CurrentScope->setIsTryBlock();
     return CurrentScope;
   case dwarf::DW_TAG_compile_unit:
   case dwarf::DW_TAG_skeleton_unit:
-    CurrentScope = new LVScopeCompileUnit();
+    CurrentScope = createObject<LVScopeCompileUnit>();
     CompileUnit = static_cast<LVScopeCompileUnit *>(CurrentScope);
     return CurrentScope;
   case dwarf::DW_TAG_inlined_subroutine:
-    CurrentScope = new LVScopeFunctionInlined();
+    CurrentScope = createObject<LVScopeFunctionInlined>();
     return CurrentScope;
   case dwarf::DW_TAG_namespace:
-    CurrentScope = new LVScopeNamespace();
+    CurrentScope = createObject<LVScopeNamespace>();
     return CurrentScope;
   case dwarf::DW_TAG_template_alias:
-    CurrentScope = new LVScopeAlias();
+    CurrentScope = createObject<LVScopeAlias>();
     return CurrentScope;
   case dwarf::DW_TAG_array_type:
-    CurrentScope = new LVScopeArray();
+    CurrentScope = createObject<LVScopeArray>();
     return CurrentScope;
   case dwarf::DW_TAG_call_site:
   case dwarf::DW_TAG_GNU_call_site:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createObject<LVScopeFunction>();
     CurrentScope->setIsCallSite();
     return CurrentScope;
   case dwarf::DW_TAG_entry_point:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createObject<LVScopeFunction>();
     CurrentScope->setIsEntryPoint();
     return CurrentScope;
   case dwarf::DW_TAG_subprogram:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createObject<LVScopeFunction>();
     CurrentScope->setIsSubprogram();
     return CurrentScope;
   case dwarf::DW_TAG_subroutine_type:
-    CurrentScope = new LVScopeFunctionType();
+    CurrentScope = createObject<LVScopeFunctionType>();
     return CurrentScope;
   case dwarf::DW_TAG_label:
-    CurrentScope = new LVScopeFunction();
+    CurrentScope = createObject<LVScopeFunction>();
     CurrentScope->setIsLabel();
     return CurrentScope;
   case dwarf::DW_TAG_class_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createObject<LVScopeAggregate>();
     CurrentScope->setIsClass();
     return CurrentScope;
   case dwarf::DW_TAG_structure_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createObject<LVScopeAggregate>();
     CurrentScope->setIsStructure();
     return CurrentScope;
   case dwarf::DW_TAG_union_type:
-    CurrentScope = new LVScopeAggregate();
+    CurrentScope = createObject<LVScopeAggregate>();
     CurrentScope->setIsUnion();
     return CurrentScope;
   case dwarf::DW_TAG_enumeration_type:
-    CurrentScope = new LVScopeEnumeration();
+    CurrentScope = createObject<LVScopeEnumeration>();
     return CurrentScope;
   case dwarf::DW_TAG_GNU_formal_parameter_pack:
-    CurrentScope = new LVScopeFormalPack();
+    CurrentScope = createObject<LVScopeFormalPack>();
     return CurrentScope;
   case dwarf::DW_TAG_GNU_template_parameter_pack:
-    CurrentScope = new LVScopeTemplatePack();
+    CurrentScope = createObject<LVScopeTemplatePack>();
     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 = createObject<LVLineDebug>();
       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/CodeViewReaderTest.cpp

LVScope *getFirstScopeChild(LVScope *Parent) {
 
   LVScopes::const_iterator Iter = Scopes->begin();
   LVScope *Child = *Iter;
   EXPECT_NE(Child, nullptr);
   return Child;
 }
 
 // Helper function to create a reader.
-LVReader *createReader(LVReaderHandler &ReaderHandler,
+LVReaderObj createReader(LVReaderHandler &ReaderHandler,
                          SmallString<128> &InputsDir, StringRef Filename) {
   SmallString<128> ObjectName(InputsDir);
   llvm::sys::path::append(ObjectName, Filename);
 
-  Expected<LVReader *> ReaderOrErr =
+  Expected<LVReaderObj> ReaderOrErr =
       ReaderHandler.createReader(std::string(ObjectName));
   EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
-  LVReader *Reader = *ReaderOrErr;
+  LVReaderObj Reader = std::move(*ReaderOrErr);
   EXPECT_NE(Reader, nullptr);
   return Reader;
 }
 
 // Check the logical elements basic properties (Clang - Codeview).
 void checkElementPropertiesClangCodeview(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit =
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, CodeViewClang);
-  checkElementPropertiesClangCodeview(Reader);
-  ReaderHandler.deleteReader(Reader);
-
-  Reader = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
-  checkElementPropertiesMsvcCodeview(Reader);
-  ReaderHandler.deleteReader(Reader);
-
-  Reader = createReader(ReaderHandler, InputsDir, CodeViewPdbMsvc);
-  checkElementPropertiesMsvcCodeviewPdb(Reader);
-  ReaderHandler.deleteReader(Reader);
+  {
+    LVReaderObj Reader = createReader(ReaderHandler, InputsDir, CodeViewClang);
+    checkElementPropertiesClangCodeview(Reader.get());
+  }
+  {
+    LVReaderObj Reader = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
+    checkElementPropertiesMsvcCodeview(Reader.get());
+  }
+  {
+    LVReaderObj Reader =
+        createReader(ReaderHandler, InputsDir, CodeViewPdbMsvc);
+    checkElementPropertiesMsvcCodeviewPdb(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.
+  {
     std::vector<SelectionInfo> DataClang = {
         {"* const int", &LVElement::getIsType},
         {"CONSTANT", &LVElement::getIsSymbol},
         {"INTEGER", &LVElement::getIsType},
         {"INTPTR", &LVElement::getIsType},
         {"ParamPtr", &LVElement::getIsSymbol},
         {"const int", &LVElement::getIsType},
         {"foo", &LVElement::getIsScope},
         {"foo::?", &LVElement::getIsScope},
         {"int", &LVElement::getIsType},
         {"movl", &LVElement::getIsLine},
         {"movl", &LVElement::getIsLine}};
-  LVReader *Reader = createReader(ReaderHandler, InputsDir, CodeViewClang);
-  checkElementSelection(Reader, DataClang, DataClang.size());
-  ReaderHandler.deleteReader(Reader);
-
-  std::vector<SelectionInfo> DataMsvc = {{"* const int", &LVElement::getIsType},
-                                         {"CONSTANT", &LVElement::getIsSymbol},
-                                         {"INTEGER", &LVElement::getIsType},
-                                         {"INTPTR", &LVElement::getIsType},
-                                         {"ParamPtr", &LVElement::getIsSymbol},
-                                         {"const int", &LVElement::getIsType},
-                                         {"foo", &LVElement::getIsScope},
-                                         {"foo::?", &LVElement::getIsScope},
-                                         {"int", &LVElement::getIsType},
-                                         {"movl", &LVElement::getIsLine}};
-  Reader = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
-  checkElementSelection(Reader, DataMsvc, DataMsvc.size());
-  ReaderHandler.deleteReader(Reader);
+    LVReaderObj Reader = createReader(ReaderHandler, InputsDir, CodeViewClang);
+    checkElementSelection(Reader.get(), DataClang, DataClang.size());
+  }
+  {
+    std::vector<SelectionInfo> DataMsvc = {
+        {"* const int", &LVElement::getIsType},
+    LVReaderObj Reader = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
+    checkElementSelection(Reader.get(), DataMsvc, DataMsvc.size());
+  }
 }
 
 // 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, CodeViewClang);
-  LVReader *Target = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
-  checkElementComparison(Reference, Target);
-  ReaderHandler.deleteReader(Reference);
-  ReaderHandler.deleteReader(Target);
+  LVReaderObj Reference = createReader(ReaderHandler, InputsDir, CodeViewClang);
+  LVReaderObj Target = createReader(ReaderHandler, InputsDir, CodeViewMsvc);
+  checkElementComparison(Reference.get(), Target.get());
 }
 
 TEST(LogicalViewTest, CodeViewReader) {
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 

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;
-
 public:
   // Types.
   LVType *IntegerType = nullptr;
   LVType *UnsignedType = nullptr;
   LVType *GlobalType = nullptr;
   LVType *LocalType = nullptr;
   LVType *NestedType = nullptr;
   LVTypeDefinition *TypeDefinitionOne = nullptr;
public:
   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();
+    T *Element = createObject<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:

 
 // 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,
+LVReaderObj createReader(LVReaderHandler &ReaderHandler,
                          SmallString<128> &InputsDir, StringRef Filename) {
   SmallString<128> ObjectName(InputsDir);
   llvm::sys::path::append(ObjectName, Filename);
 
-  Expected<LVReader *> ReaderOrErr =
+  Expected<LVReaderObj> ReaderOrErr =
       ReaderHandler.createReader(std::string(ObjectName));
   EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
-  LVReader *Reader = *ReaderOrErr;
+  LVReaderObj 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);
+  LVReaderObj 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);
+  LVReaderObj 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);
+  LVReaderObj Reference = createReader(ReaderHandler, InputsDir, DwarfClang);
+  LVReaderObj 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::logicalview;
 
 namespace {
 
 class ReaderTest : public LVReader {
 protected:
   void add(LVScope *Parent, LVElement *Element);
   template <typename T> T *create() {
-    T *Element = new (std::nothrow) T();
+    T *Element = createObject<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);

llvm/unittests/DebugInfo/LogicalView/LogicalElementsTest.cpp

class ReaderTestElements : public LVReader {
 
   // 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();
+    T *Element = createObject<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) {
void ReaderTestElements::createElements() {
   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 the logical scopes.
   NestedScope = create<LVScope>();
   Aggregate = create<LVScopeAggregate>();
   Array = create<LVScopeArray>();
   CompileUnit = create<LVScopeCompileUnit>();
   Enumeration = create<LVScopeEnumeration>();
   Function = create<LVScopeFunction>();
   ClassFunction = create<LVScopeFunction>();

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

class ReaderTestSelection : public LVReader {
   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();
+    T *Element = createObject<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:

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

class ReaderTestWarningInternal : public LVReader {
   MyLocation *LocationThree = nullptr;
   MyLocation *LocationFour = nullptr;
   MyLocation *LocationFive = nullptr;
   MyLocation *LocationSix = nullptr;
 
 protected:
   void add(LVScope *Parent, LVElement *Element);
   template <typename T> T *create() {
-    T *Element = new (std::nothrow) T();
+    T *Element = createObject<T>();
     EXPECT_NE(Element, nullptr);
     return 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);
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());