summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 172515f)
raw | patch | inline | side by side (parent: 172515f)
author | David Blaikie <dblaikie@gmail.com> | |
Fri, 25 Apr 2014 20:00:34 +0000 (20:00 +0000) | ||
committer | David Blaikie <dblaikie@gmail.com> | |
Fri, 25 Apr 2014 20:00:34 +0000 (20:00 +0000) |
This should reduce the chance of memory leaks like those fixed in
r207240.
There's still some unclear ownership of DIEs happening in DwarfDebug.
Pushing unique_ptr and references through more APIs should help expose
the cases where ownership is a bit fuzzy.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207263 91177308-0d34-0410-b5e6-96231b3b80d8
r207240.
There's still some unclear ownership of DIEs happening in DwarfDebug.
Pushing unique_ptr and references through more APIs should help expose
the cases where ownership is a bit fuzzy.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207263 91177308-0d34-0410-b5e6-96231b3b80d8
index a2841fe1ae6c576126e303ef1cbbe496f4b83cef..1a1c080c32c155d26ec4cee987d938dab7217b11 100644 (file)
/// addChild - Add a child to the DIE.
///
- void addChild(DIE *Child) {
+ void addChild(std::unique_ptr<DIE> Child) {
assert(!Child->getParent());
Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
- Children.push_back(std::unique_ptr<DIE>(Child));
Child->Parent = this;
+ Children.push_back(std::move(Child));
}
/// findAttribute - Find a value in the DIE with the attribute given,
index c0ce5d2f36efd9ed93038545d962a4e9bbae4ea6..3bc359425c023420918694c3354356e60d0160da 100644 (file)
return ScopeDIE;
}
-DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit &TheCU,
- LexicalScope *Scope,
- SmallVectorImpl<DIE *> &Children) {
+DIE *DwarfDebug::createScopeChildrenDIE(
+ DwarfCompileUnit &TheCU, LexicalScope *Scope,
+ SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
DIE *ObjectPointer = nullptr;
// Collect arguments for current function.
if (LScopes.isCurrentFunctionScope(Scope)) {
for (DbgVariable *ArgDV : CurrentFnArguments)
- if (ArgDV)
- if (DIE *Arg =
- TheCU.constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
- Children.push_back(Arg);
- if (ArgDV->isObjectPointer())
- ObjectPointer = Arg;
- }
+ if (ArgDV) {
+ std::unique_ptr<DIE> Arg =
+ TheCU.constructVariableDIE(*ArgDV, Scope->isAbstractScope());
+ assert(Arg);
+ if (ArgDV->isObjectPointer())
+ ObjectPointer = Arg.get();
+ Children.push_back(std::move(Arg));
+ }
// If this is a variadic function, add an unspecified parameter.
DISubprogram SP(Scope->getScopeNode());
DIArray FnArgs = SP.getType().getTypeArray();
if (FnArgs.getElement(FnArgs.getNumElements() - 1)
.isUnspecifiedParameter()) {
- DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
- Children.push_back(Ellipsis);
+ Children.push_back(
+ make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
}
}
// Collect lexical scope children first.
- for (DbgVariable *DV : ScopeVariables.lookup(Scope))
- if (DIE *Variable =
- TheCU.constructVariableDIE(*DV, Scope->isAbstractScope())) {
- Children.push_back(Variable);
- if (DV->isObjectPointer())
- ObjectPointer = Variable;
- }
+ for (DbgVariable *DV : ScopeVariables.lookup(Scope)) {
+ std::unique_ptr<DIE> Variable =
+ TheCU.constructVariableDIE(*DV, Scope->isAbstractScope());
+ assert(Variable);
+ Children.push_back(std::move(Variable));
+ if (DV->isObjectPointer())
+ ObjectPointer = Variable.get();
+ }
for (LexicalScope *LS : Scope->getChildren())
if (DIE *Nested = constructScopeDIE(TheCU, LS))
- Children.push_back(Nested);
+ Children.push_back(std::unique_ptr<DIE>(Nested));
return ObjectPointer;
}
DIScope DS(Scope->getScopeNode());
- SmallVector<DIE *, 8> Children;
+ SmallVector<std::unique_ptr<DIE>, 8> Children;
DIE *ObjectPointer = nullptr;
bool ChildrenCreated = false;
ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
// Add children
- for (DIE *I : Children)
- ScopeDIE->addChild(I);
+ for (auto &I : Children)
+ ScopeDIE->addChild(std::move(I));
if (DS.isSubprogram() && ObjectPointer != nullptr)
TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
if (!DV.isVariable())
continue;
DbgVariable NewVar(DV, nullptr, this);
- if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
- SPDIE->addChild(VariableDIE);
+ SPDIE->addChild(SPCU->constructVariableDIE(NewVar, false));
}
}
}
index 325e053029edf217121c1172cd6badc2e634311d..9038c648af340bfccc695f448c45b424ef05ec0e 100644 (file)
DIE *constructScopeDIE(DwarfCompileUnit &TheCU, LexicalScope *Scope);
/// A helper function to create children of a Scope DIE.
DIE *createScopeChildrenDIE(DwarfCompileUnit &TheCU, LexicalScope *Scope,
- SmallVectorImpl<DIE *> &Children);
+ SmallVectorImpl<std::unique_ptr<DIE>> &Children);
/// \brief Emit initial Dwarf sections with a label at the start of each one.
void emitSectionLabels();
index 874e0c051ab7f42a2995c9b98c5e01914a672453..c7d22724ce31819b87f0fea58d8ad91628fd95b4 100644 (file)
DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
assert(Tag != dwarf::DW_TAG_auto_variable &&
Tag != dwarf::DW_TAG_arg_variable);
- Parent.addChild(new DIE((dwarf::Tag)Tag));
+ Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
DIE &Die = *Parent.getChildren().back();
if (N)
insertDIE(N, &Die);
}
/// constructVariableDIE - Construct a DIE for the given DbgVariable.
-DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
+std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
+ bool isScopeAbstract) {
auto D = constructVariableDIEImpl(DV, isScopeAbstract);
DV.setDIE(*D);
return D;
}
-DIE *DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
- bool isScopeAbstract) {
+std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
+ bool isScopeAbstract) {
StringRef Name = DV.getName();
// Define variable debug information entry.
- DIE *VariableDie = new DIE(DV.getTag());
+ auto VariableDie = make_unique<DIE>(DV.getTag());
DbgVariable *AbsVar = DV.getAbstractVariable();
DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : nullptr;
if (AbsDIE)
index af5d2d54189e61b72863c27e3db920e6aaa015cf..2869841478c67c3066f4813f073b62d9cc111c56 100644 (file)
/// addDie - Adds or interns the DIE to the compile unit.
///
- void addDie(DIE *Buffer) { UnitDie->addChild(Buffer); }
+ void addDie(DIE *Buffer) { UnitDie->addChild(std::unique_ptr<DIE>(Buffer)); }
/// addFlag - Add a flag that is true to the DIE.
void addFlag(DIE &Die, dwarf::Attribute Attribute);
void constructContainingTypeDIEs();
/// constructVariableDIE - Construct a DIE for the given DbgVariable.
- DIE *constructVariableDIE(DbgVariable &DV, bool isScopeAbstract);
+ std::unique_ptr<DIE> constructVariableDIE(DbgVariable &DV,
+ bool isScopeAbstract);
/// constructSubprogramArguments - Construct function argument DIEs.
void constructSubprogramArguments(DIE &Buffer, DIArray Args);
private:
/// \brief Construct a DIE for the given DbgVariable without initializing the
/// DbgVariable's DIE reference.
- DIE *constructVariableDIEImpl(const DbgVariable &DV, bool isScopeAbstract);
+ std::unique_ptr<DIE> constructVariableDIEImpl(const DbgVariable &DV,
+ bool isScopeAbstract);
/// constructTypeDIE - Construct basic type die from DIBasicType.
void constructTypeDIE(DIE &Buffer, DIBasicType BTy);
index 5876bb38f6405ddf9fc30eb09af568cc2230e8d2..04c5a8ac01997dc894f7888c9b88495d2e1669e8 100644 (file)
#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/Format.h"
+#include "llvm/ADT/STLExtras.h"
#include "gtest/gtest.h"
using namespace llvm;
TEST(DIEHashTest, NamespacedType) {
DIE CU(dwarf::DW_TAG_compile_unit);
- DIE *Space = new DIE(dwarf::DW_TAG_namespace);
+ auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace);
DIEInteger One(1);
DIEString SpaceStr(&One, "space");
Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr);
Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
// sibling?
- DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
+ auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEString FooStr(&One, "foo");
Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
- Space->addChild(Foo);
- CU.addChild(Space);
+ DIE &N = *Foo;
+ Space->addChild(std::move(Foo));
+ CU.addChild(std::move(Space));
- uint64_t MD5Res = DIEHash().computeTypeSignature(*Foo);
+ uint64_t MD5Res = DIEHash().computeTypeSignature(N);
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
DIEInteger Four(4);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
- DIE *Member = new DIE(dwarf::DW_TAG_member);
- DIEString MemberStr(&Four, "member");
- Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr);
- DIEInteger Zero(0);
- Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
- &Zero);
-
- Unnamed.addChild(Member);
-
DIE Int(dwarf::DW_TAG_base_type);
DIEString IntStr(&Four, "int");
Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
DIEEntry IntRef(Int);
+
+ auto Member = make_unique<DIE>(dwarf::DW_TAG_member);
+ DIEString MemberStr(&Four, "member");
+ Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr);
+ DIEInteger Zero(0);
+ Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
+ &Zero);
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
+ Unnamed.addChild(std::move(Member));
+
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
DIEInteger Eight(8);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
- DIE *Mem1 = new DIE(dwarf::DW_TAG_member);
DIEInteger Four(4);
+ DIE Int(dwarf::DW_TAG_base_type);
+ DIEString IntStr(&Four, "int");
+ Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
+ Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
+ DIEInteger Five(5);
+ Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
+
+ DIEEntry IntRef(Int);
+
+ auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem1Str(&Four, "mem1");
Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
DIEInteger Zero(0);
Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
+ Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
- Unnamed.addChild(Mem1);
+ Unnamed.addChild(std::move(Mem1));
- DIE *Mem2 = new DIE(dwarf::DW_TAG_member);
+ auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem2Str(&Four, "mem2");
Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Four);
-
- Unnamed.addChild(Mem2);
-
- DIE Int(dwarf::DW_TAG_base_type);
- DIEString IntStr(&Four, "int");
- Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
- Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
- DIEInteger Five(5);
- Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
-
- DIEEntry IntRef(Int);
- Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
+ Unnamed.addChild(std::move(Mem2));
+
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
DIEString FooStr(&One, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr(&One, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEEntry FooRef(Foo);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
// DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
DIEEntry FooPtrRef(FooPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
DIEEntry FooRefConstRef(FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
DIEEntry FooRefConstRef(FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
MD5ResDecl = DIEHash().computeTypeSignature(Foo);
}
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
MD5ResDef = DIEHash().computeTypeSignature(Foo);
}
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
MD5ResDecl = DIEHash().computeTypeSignature(Foo);
}
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
MD5ResDef = DIEHash().computeTypeSignature(Foo);
}
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
- DIE *Mem = new DIE(dwarf::DW_TAG_member);
+ auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIEEntry UnnamedPtrRef(UnnamedPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
- Foo.addChild(Mem);
+ Foo.addChild(std::move(Mem));
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEInteger One(1);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
- DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
+ auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEString FooStr(&One, "foo");
Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
- Unnamed.addChild(Foo);
+ Unnamed.addChild(std::move(Foo));
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
DIEInteger One(1);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
- DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
+ auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEString FuncStr(&One, "func");
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
- Unnamed.addChild(Func);
+ Unnamed.addChild(std::move(Func));
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
- DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
+ auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEString FuncStr(&One, "func");
DIEString FuncLinkage(&One, "_ZN1A4funcEv");
DIEInteger Two(2);
Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, &FuncLinkage);
Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
- A.addChild(Func);
+ A.addChild(std::move(Func));
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
DIEEntry IntTy(IntTyDIE);
- DIE *PITyDIE = new DIE(dwarf::DW_TAG_const_type);
+ auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy);
DIEEntry PITy(*PITyDIE);
- DIE *PI = new DIE(dwarf::DW_TAG_member);
+ auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString PIStr(&One, "PI");
DIEInteger Two(2);
DIEInteger NegThree(-3);
PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, &NegThree);
- A.addChild(PI);
+ A.addChild(std::move(PI));
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
DIEInteger Four(4);
DIEString FStr(&One, "float");
- DIE *FloatTyDIE = new DIE(dwarf::DW_TAG_base_type);
+ auto FloatTyDIE = make_unique<DIE>(dwarf::DW_TAG_base_type);
FloatTyDIE->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Four);
FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
DIEEntry FloatTy(*FloatTyDIE);
- DIE *PITyDIE = new DIE(dwarf::DW_TAG_const_type);
+ auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy);
DIEEntry PITy(*PITyDIE);
- DIE *PI = new DIE(dwarf::DW_TAG_member);
+ auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString PIStr(&One, "PI");
DIEInteger Two(2);
PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock);
- A.addChild(PI);
+ A.addChild(std::move(PI));
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);