maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/unittests/CodeGen/DIEHashTest.cpp

518 lines
18 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-04 05:57:57 +08: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 19:48:04 +08: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-04 05:57:57 +08:00
#include "llvm/Support/Format.h"
#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 07:00:17 +08: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-22 04:28:30 +08: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-04 05:57:57 +08:00
DIEHash Hash;
Plug a memory leak in a unit test. Stack allocation is sufficient here. llvm-svn: 191638
2013-09-29 19:29:20 +08: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-25 02:29:03 +08: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 07:36:20 +08: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 06:36:50 +08: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-22 04:28:30 +08:00
TEST(DIEHashTest, TrivialType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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 07:36:20 +08:00
DIEInteger One(1);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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 07:36:20 +08:00
// Line and file number are ignored.
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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-25 02:29:03 +08: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 07:36:20 +08: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-04 05:57:57 +08:00
}
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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 06:36:50 +08: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-22 04:28:30 +08:00
TEST(DIEHashTest, NamedType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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-25 02:29:03 +08:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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 06:36:50 +08: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-22 04:28:30 +08:00
TEST(DIEHashTest, NamespacedType) {
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08:00
DIE CU(dwarf::DW_TAG_compile_unit);
DIE *Space = new DIE(dwarf::DW_TAG_namespace);
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 *Foo = new 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);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08:00
uint64_t MD5Res = DIEHash().computeTypeSignature(*Foo);
DIEHash: Include the type's context in the type hash. llvm-svn: 192856
2013-10-17 08:10:34 +08: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 06:07:09 +08: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 06:36:50 +08: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-22 04:28:30 +08:00
TEST(DIEHashTest, TypeWithMember) {
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 06:07:09 +08:00
DIE Unnamed(dwarf::DW_TAG_structure_type);
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_byte_size, dwarf::DW_FORM_data1, &Four);
DIEInteger Five(5);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
DIEEntry IntRef(&Int);
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
DIEHash: Support for simple (non-recursive, non-reused) type references llvm-svn: 192924
2013-10-18 06:07:09 +08: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-22 02:59:40 +08: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 06:36:50 +08: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-22 04:28:30 +08: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-22 02:59:40 +08:00
DIE Unnamed(dwarf::DW_TAG_structure_type);
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);
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);
Unnamed.addChild(Mem1);
DIE *Mem2 = new 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);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-22 02:59:40 +08: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 06:36:50 +08: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-22 04:28:30 +08: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-22 02:59:40 +08: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 *Mem = new 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);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-22 02:59:40 +08: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 06:36:50 +08: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 *Mem = new DIE(dwarf::DW_TAG_member);
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 FooRef(&Foo);
FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
DIEEntry FooPtrRef(&FooPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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 06:36:50 +08: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 07:06:19 +08: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 *Mem = new DIE(dwarf::DW_TAG_member);
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 FooEntry(&Foo);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(&FooRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
DIEEntry FooRefConstRef(&FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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 07:06:19 +08: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 *Mem = new DIE(dwarf::DW_TAG_member);
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 FooEntry(&Foo);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(&FooRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
DIEEntry FooRefConstRef(&FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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 07:06:19 +08: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-23 02:14:41 +08: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 *Mem = new DIE(dwarf::DW_TAG_member);
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 FooEntry(&Foo);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, &FooEntry);
DIEEntry PtrToFooMemRef(&PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-23 02:14:41 +08: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 *Mem = new 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);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(&Bar);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
DIEEntry FooEntry(&Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
DIEEntry PtrToFooMemRef(&PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-23 02:14:41 +08: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 *Mem = new 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);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(&Bar);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
DIEEntry FooEntry(&Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
DIEEntry PtrToFooMemRef(&PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-23 02:14:41 +08: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 *Mem = new 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);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(&Bar);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
DIEEntry PtrToFooMemRef(&PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-23 02:14:41 +08: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 *Mem = new 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);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(&Bar);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
DIEEntry PtrToFooMemRef(&PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08: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-23 02:14:41 +08: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-25 01:53:58 +08: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 *Mem = new 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);
DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
DIEEntry UnnamedRef(&Unnamed);
UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
DIEEntry UnnamedPtrRef(&UnnamedPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
Foo.addChild(Mem);
DIEHash: Const correct and use references where non-null/non-rebound. llvm-svn: 193363
2013-10-25 02:29:03 +08:00
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
DIEHash: Do not use shallow type hashing for unnamed types llvm-svn: 193361
2013-10-25 01:53:58 +08:00
ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
}
DIEHash: Summary hashing of nested types llvm-svn: 193427
2013-10-26 02:38:43 +08:00
// struct { struct bar { }; };
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 *Foo = new 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);
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-26 04:04:25 +08: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 *Func = new DIE(dwarf::DW_TAG_subprogram);
DIEString FuncStr(&One, "func");
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
Unnamed.addChild(Func);
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
// The exact same hash GCC produces for this DIE.
ASSERT_EQ(0xd36a1b6dfb604ba0ULL, 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-04 05:57:57 +08:00
}