RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-29 23:12:55 +01:00
Code Issues Projects Releases Wiki Activity
7ce6b4003f
llvm-mirror/unittests/CodeGen/DIEHashTest.cpp

655 lines
23 KiB
C++
Raw Normal View History

Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
//===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "../lib/CodeGen/AsmPrinter/DIE.h"
#include "../lib/CodeGen/AsmPrinter/DIEHash.h"
#include "llvm/Support/Debug.h"
Re-sort all of the includes with ./utils/sort_includes.py so that subsequent changes are easier to review. About to fix some layering issues, and wanted to separate out the necessary churn. Also comment and sink the include of "Windows.h" in three .inc files to match the usage in Memory.inc. llvm-svn: 198685
2014-01-07 12:48:04 +01:00
#include "llvm/Support/Dwarf.h"
Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
#include "llvm/Support/Format.h"
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
#include "llvm/ADT/STLExtras.h"
Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
#include "gtest/gtest.h"
using namespace llvm;
Use ASSERT_EQ rather than ASSERT_TRUE for better unit test failures. Also minor using namespace move so it's not hard-up against the function definition and outside the namespace as is usual. llvm-svn: 192744
2013-10-16 01:00:17 +02:00
namespace {
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, Data1) {
Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
DIEHash Hash;
Plug a memory leak in a unit test. Stack allocation is sufficient here. llvm-svn: 191638
2013-09-29 13:29:20 +02:00
DIE Die(dwarf::DW_TAG_base_type);
DIEInteger Size(4);
Die.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Size);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = Hash.computeTypeSignature(Die);
DIEHash: Use DW_FORM_sdata for integers, per spec. This allows us to produce the same hash as GCC for at least some simple examples. llvm-svn: 192855
2013-10-17 01:36:20 +02:00
ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res);
}
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct {};
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, TrivialType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEHash: Use DW_FORM_sdata for integers, per spec. This allows us to produce the same hash as GCC for at least some simple examples. llvm-svn: 192855
2013-10-17 01:36:20 +02:00
DIEInteger One(1);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIEHash: Use DW_FORM_sdata for integers, per spec. This allows us to produce the same hash as GCC for at least some simple examples. llvm-svn: 192855
2013-10-17 01:36:20 +02:00
// Line and file number are ignored.
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
Unnamed.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
DIEHash: Use DW_FORM_sdata for integers, per spec. This allows us to produce the same hash as GCC for at least some simple examples. llvm-svn: 192855
2013-10-17 01:36:20 +02:00
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res);
Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
}
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct foo { };
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, NamedType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
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);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
}
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// namespace space { struct foo { }; }
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, NamespacedType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DIE CU(dwarf::DW_TAG_compile_unit);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DIEInteger One(1);
DIEString SpaceStr(&One, "space");
Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr);
// DW_AT_declaration is ignored.
Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
// sibling?
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
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);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
DIE &N = *Foo;
Space->addChild(std::move(Foo));
CU.addChild(std::move(Space));
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(N);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 02:10:34 +02:00
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
}
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 00:07:09 +02:00
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct { int member; };
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, TypeWithMember) {
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 00:07:09 +02:00
DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger Four(4);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
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: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry IntRef(Int);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
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);
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 00:07:09 +02:00
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Unnamed.addChild(std::move(Member));
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 00:07:09 +02:00
ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
}
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct foo { int mem1, mem2; };
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, ReusedType) {
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEInteger Four(4);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
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);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIEString Mem1Str(&Four, "mem1");
Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
DIEInteger Zero(0);
Format. llvm-svn: 201746
2014-02-20 01:54:38 +01:00
Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Unnamed.addChild(std::move(Mem1));
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIEString Mem2Str(&Four, "mem2");
Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
Format. llvm-svn: 201746
2014-02-20 01:54:38 +01:00
Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Four);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Unnamed.addChild(std::move(Mem2));
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
}
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct foo { static foo f; };
DIEHashTest: Correct the order of operands to the TEST macro And add the 'Test' suffix so the test case name matches the file name. llvm-svn: 193119
2013-10-21 22:28:30 +02:00
TEST(DIEHashTest, RecursiveType) {
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIEString FooStr(&One, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIEString MemStr(&One, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRef(Foo);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
// DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: Handle multiple (including recursive) references to the same type This uses a map, keeping the type DIE numbering separate from the DIEs themselves - alternatively we could do things the way GCC does if we want to add an integer to the DIE type to record the numbering there. llvm-svn: 193105
2013-10-21 20:59:40 +02:00
ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
}
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
// struct foo { foo *mem; };
TEST(DIEHashTest, Pointer) {
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIE FooPtr(dwarf::DW_TAG_pointer_type);
FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRef(Foo);
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooPtrRef(FooPtr);
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: begin implementing Step 5, summary hashing in declarable contexts There are several other tag types that need similar handling but to ensure test coverage they'll be coming incrementally. llvm-svn: 193126
2013-10-22 00:36:50 +02:00
ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
}
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
// struct foo { foo &mem; };
TEST(DIEHashTest, Reference) {
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIE FooRef(dwarf::DW_TAG_reference_type);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooEntry(Foo);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRefRef(FooRef);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRefConstRef(FooRefConst);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
}
// struct foo { foo &&mem; };
TEST(DIEHashTest, RValueReference) {
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIE FooRef(dwarf::DW_TAG_rvalue_reference_type);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooEntry(Foo);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRefRef(FooRef);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooRefConstRef(FooRefConst);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DWARF Type Hashing: Include reference and rvalue reference type in the declarable summary hashing path More support for 7.25 Part 5. llvm-svn: 193129
2013-10-22 01:06:19 +02:00
ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
}
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
// struct foo { foo foo::*mem; };
TEST(DIEHashTest, PtrToMember) {
DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEString FooStr(&Eight, "foo");
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEString MemStr(&Eight, "mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooEntry(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
Format. llvm-svn: 201746
2014-02-20 01:54:38 +01:00
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PtrToFooMemRef(PtrToFooMem);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
}
// Check that the hash for a pointer-to-member matches regardless of whether the
// pointed-to type is a declaration or a definition.
//
// struct bar; // { };
// struct foo { bar foo::*mem; };
TEST(DIEHashTest, PtrToMemberDeclDefMatch) {
DIEInteger Zero(0);
DIEInteger One(1);
DIEInteger Eight(8);
DIEString FooStr(&Eight, "foo");
DIEString BarStr(&Eight, "bar");
DIEString MemStr(&Eight, "mem");
uint64_t MD5ResDecl;
{
DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry BarEntry(Bar);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooEntry(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PtrToFooMemRef(PtrToFooMem);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
MD5ResDecl = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
}
uint64_t MD5ResDef;
{
DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry BarEntry(Bar);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FooEntry(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PtrToFooMemRef(PtrToFooMem);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
MD5ResDef = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
}
ASSERT_EQ(MD5ResDef, MD5ResDecl);
}
// Check that the hash for a pointer-to-member matches regardless of whether the
// pointed-to type is a declaration or a definition.
//
// struct bar; // { };
// struct foo { bar bar::*mem; };
TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) {
DIEInteger Zero(0);
DIEInteger One(1);
DIEInteger Eight(8);
DIEString FooStr(&Eight, "foo");
DIEString BarStr(&Eight, "bar");
DIEString MemStr(&Eight, "mem");
uint64_t MD5ResDecl;
{
DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry BarEntry(Bar);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PtrToFooMemRef(PtrToFooMem);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
MD5ResDecl = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
}
uint64_t MD5ResDef;
{
DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry BarEntry(Bar);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PtrToFooMemRef(PtrToFooMem);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
MD5ResDef = DIEHash().computeTypeSignature(Foo);
DWARF type hashing: pointers to members Includes a test case/FIXME demonstrating a bug/limitation in pointer to member hashing. To be honest I'm not sure why we don't just always use summary hashing for referenced types... but perhaps I'm missing something. llvm-svn: 193175
2013-10-22 20:14:41 +02:00
}
// FIXME: This seems to be a bug in the DWARF type hashing specification that
// only uses the brief name hashing for types referenced via DW_AT_type. In
// this case the type is referenced via DW_AT_containing_type and full hashing
// causes a hash to differ when the containing type is a declaration in one TU
// and a definition in another.
ASSERT_NE(MD5ResDef, MD5ResDecl);
}
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
// struct { } a;
// struct foo { decltype(a) mem; };
TEST(DIEHashTest, RefUnnamedType) {
DIEInteger Zero(0);
DIEInteger One(1);
DIEInteger Eight(8);
DIEString FooStr(&Zero, "foo");
DIEString MemStr(&Zero, "mem");
DIE Unnamed(dwarf::DW_TAG_structure_type);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry UnnamedRef(Unnamed);
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry UnnamedPtrRef(UnnamedPtr);
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Foo.addChild(std::move(Mem));
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-24 20:29:03 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-24 19:53:58 +02:00
ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
}
DIEHash: Summary hashing of nested types llvm-svn: 193427
2013-10-25 20:38:43 +02:00
Fix name of nested type in comment to match code. llvm-svn: 200570
2014-01-31 21:02:55 +01:00
// struct { struct foo { }; };
DIEHash: Summary hashing of nested types llvm-svn: 193427
2013-10-25 20:38:43 +02:00
TEST(DIEHashTest, NestedType) {
DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEHash: Summary hashing of nested types llvm-svn: 193427
2013-10-25 20:38:43 +02:00
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);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Unnamed.addChild(std::move(Foo));
DIEHash: Summary hashing of nested types llvm-svn: 193427
2013-10-25 20:38:43 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
}
DIEHash: Summary hashing of member functions llvm-svn: 193432
2013-10-25 22:04:25 +02:00
// struct { static void func(); };
TEST(DIEHashTest, MemberFunc) {
DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEHash: Summary hashing of member functions llvm-svn: 193432
2013-10-25 22:04:25 +02:00
DIEString FuncStr(&One, "func");
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
Unnamed.addChild(std::move(Func));
DIEHash: Summary hashing of member functions llvm-svn: 193432
2013-10-25 22:04:25 +02:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);
}
Add support for DW_FORM_flag and DW_FORM_flag_present to the DIE hashing algorithm. Sink the 'A' + Attribute hash into each form so we don't have to check valid forms before deciding whether or not we're going to hash which will let the default be to return without doing anything. llvm-svn: 200571
2014-01-31 21:02:58 +01:00
// struct A {
// static void func();
// };
TEST(DIEHashTest, MemberFuncFlag) {
DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
DIEString AStr(&One, "A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
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: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
Add support for DW_FORM_flag and DW_FORM_flag_present to the DIE hashing algorithm. Sink the 'A' + Attribute hash into each form so we don't have to check valid forms before deciding whether or not we're going to hash which will let the default be to return without doing anything. llvm-svn: 200571
2014-01-31 21:02:58 +01:00
DIEString FuncStr(&One, "func");
DIEString FuncLinkage(&One, "_ZN1A4funcEv");
DIEInteger Two(2);
Func->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, &FuncLinkage);
Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
A.addChild(std::move(Func));
Add support for DW_FORM_flag and DW_FORM_flag_present to the DIE hashing algorithm. Sink the 'A' + Attribute hash into each form so we don't have to check valid forms before deciding whether or not we're going to hash which will let the default be to return without doing anything. llvm-svn: 200571
2014-01-31 21:02:58 +01:00
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res);
}
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
// Derived from:
// struct A {
Fix commit thinkos from splitting out patches. llvm-svn: 201748
2014-02-20 01:59:17 +01:00
// const static int PI = -3;
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
// };
// A a;
This tests DW_FORM_sdata, not DW_FORM_block. Make the test say so. llvm-svn: 201749
2014-02-20 02:27:51 +01:00
TEST(DIEHashTest, MemberSdata) {
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
DIEString AStr(&One, "A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
DIEInteger Four(4);
DIEInteger Five(5);
DIEString FStr(&One, "int");
PR19554: Fix some memory leaks in DIEHashTest.cpp llvm-svn: 207240
2014-04-25 19:07:55 +02:00
DIE IntTyDIE(dwarf::DW_TAG_base_type);
IntTyDIE.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry IntTy(IntTyDIE);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PITy(*PITyDIE);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
DIEString PIStr(&One, "PI");
DIEInteger Two(2);
DIEInteger NegThree(-3);
PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, &NegThree);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
A.addChild(std::move(PI));
Add support for hashing DW_FORM_sdata and a small testcase. llvm-svn: 201747
2014-02-20 01:54:40 +01:00
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
}
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
// Derived from:
// struct A {
// const static float PI = 3.14;
// };
// A a;
TEST(DIEHashTest, MemberBlock) {
DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1);
DIEString AStr(&One, "A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
DIEInteger Four(4);
DIEString FStr(&One, "float");
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto FloatTyDIE = make_unique<DIE>(dwarf::DW_TAG_base_type);
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
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: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry FloatTy(*FloatTyDIE);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy);
DIEEntry: Refer to the specified DIE via reference rather than pointer. Makes some more cases (the unit tests, specifically), lexically compatible with a change to unique_ptr. llvm-svn: 207261
2014-04-25 21:33:43 +02:00
DIEEntry PITy(*PITyDIE);
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
DIEString PIStr(&One, "PI");
DIEInteger Two(2);
PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
PR19554: Fix some memory leaks in DIEHashTest.cpp llvm-svn: 207240
2014-04-25 19:07:55 +02:00
DIEBlock PIBlock;
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
DIEInteger Blk1(0xc3);
DIEInteger Blk2(0xf5);
DIEInteger Blk3(0x48);
DIEInteger Blk4(0x40);
PR19554: Fix some memory leaks in DIEHashTest.cpp llvm-svn: 207240
2014-04-25 19:07:55 +02:00
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk1);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk2);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk3);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk4);
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
PR19554: Fix some memory leaks in DIEHashTest.cpp llvm-svn: 207240
2014-04-25 19:07:55 +02:00
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock);
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
DIE: Pass ownership of children via std::unique_ptr rather than raw pointer. 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. llvm-svn: 207263
2014-04-25 22:00:34 +02:00
A.addChild(std::move(PI));
Add support for hashing attributes with DW_FORM_block. This required passing down an AsmPrinter instance so we could compute the size of the block which could be target specific. All of the test cases in the unittest don't have any target specific data so we can use a NULL AsmPrinter there. This also depends upon block data being added as integers. We can now hash the entire fission-cu.ll compile unit so turn the flag on there with the hash value. llvm-svn: 201752
2014-02-20 03:50:45 +01:00
uint64_t MD5Res = DIEHash().computeTypeSignature(A);
ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);
}
Add a hashing routine that handles hashing types. Add a test for hashing the contents of DW_FORM_data1 on top of a type with attributes. llvm-svn: 189862
2013-09-03 23:57:57 +02:00
}
Reference in New Issue Copy Permalink