diff --git a/lib/CodeGen/AsmPrinter/DIEHash.cpp b/lib/CodeGen/AsmPrinter/DIEHash.cpp index e345344901b..b8b2bd22059 100644 --- a/lib/CodeGen/AsmPrinter/DIEHash.cpp +++ b/lib/CodeGen/AsmPrinter/DIEHash.cpp @@ -83,33 +83,34 @@ void DIEHash::addSLEB128(int64_t Value) { } /// \brief Including \p Parent adds the context of Parent to the hash.. -void DIEHash::addParentContext(DIE *Parent) { +void DIEHash::addParentContext(const DIE &Parent) { DEBUG(dbgs() << "Adding parent context to hash...\n"); // [7.27.2] For each surrounding type or namespace beginning with the // outermost such construct... - SmallVector Parents; - while (Parent->getTag() != dwarf::DW_TAG_compile_unit) { - Parents.push_back(Parent); - Parent = Parent->getParent(); + SmallVector Parents; + const DIE *Cur = &Parent; + while (Cur->getTag() != dwarf::DW_TAG_compile_unit) { + Parents.push_back(Cur); + Cur = Cur->getParent(); } // Reverse iterate over our list to go from the outermost construct to the // innermost. - for (SmallVectorImpl::reverse_iterator I = Parents.rbegin(), - E = Parents.rend(); + for (SmallVectorImpl::reverse_iterator I = Parents.rbegin(), + E = Parents.rend(); I != E; ++I) { - DIE *Die = *I; + const DIE &Die = **I; // ... Append the letter "C" to the sequence... addULEB128('C'); // ... Followed by the DWARF tag of the construct... - addULEB128(Die->getTag()); + addULEB128(Die.getTag()); // ... Then the name, taken from the DW_AT_name attribute. - StringRef Name = getDIEStringAttr(*Die, dwarf::DW_AT_name); + StringRef Name = getDIEStringAttr(Die, dwarf::DW_AT_name); DEBUG(dbgs() << "... adding context: " << Name << "\n"); if (!Name.empty()) addString(Name); @@ -117,9 +118,9 @@ void DIEHash::addParentContext(DIE *Parent) { } // Collect all of the attributes for a particular DIE in single structure. -void DIEHash::collectAttributes(DIE *Die, DIEAttrs &Attrs) { - const SmallVectorImpl &Values = Die->getValues(); - const DIEAbbrev &Abbrevs = Die->getAbbrev(); +void DIEHash::collectAttributes(const DIE &Die, DIEAttrs &Attrs) { + const SmallVectorImpl &Values = Die.getValues(); + const DIEAbbrev &Abbrevs = Die.getAbbrev(); #define COLLECT_ATTR(NAME) \ case dwarf::NAME: \ @@ -196,8 +197,8 @@ void DIEHash::hashShallowTypeReference(dwarf::Attribute Attribute, addULEB128(Attribute); // the context of the tag, - if (DIE *Parent = Entry.getParent()) - addParentContext(Parent); + if (const DIE *Parent = Entry.getParent()) + addParentContext(*Parent); // the letter 'E', addULEB128('E'); @@ -227,7 +228,7 @@ void DIEHash::hashRepeatedTypeReference(dwarf::Attribute Attribute, } void DIEHash::hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag, - DIE &Entry) { + const DIE &Entry) { assert(Tag != dwarf::DW_TAG_friend && "No current LLVM clients emit friend " "tags. Add support here when there's " "a use case"); @@ -264,7 +265,7 @@ void DIEHash::hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag, // ... process the type T recursively by performing Steps 2 through 7, and // use the result as the attribute value. DieNumber = Numbering.size(); - computeHash(&Entry); + computeHash(Entry); } // Hash an individual attribute \param Attr based on the type of attribute and @@ -377,28 +378,28 @@ void DIEHash::hashAttributes(const DIEAttrs &Attrs, dwarf::Tag Tag) { } // Add all of the attributes for \param Die to the hash. -void DIEHash::addAttributes(DIE *Die) { +void DIEHash::addAttributes(const DIE &Die) { DIEAttrs Attrs = {}; collectAttributes(Die, Attrs); - hashAttributes(Attrs, Die->getTag()); + hashAttributes(Attrs, Die.getTag()); } // Compute the hash of a DIE. This is based on the type signature computation // given in section 7.27 of the DWARF4 standard. It is the md5 hash of a // flattened description of the DIE. -void DIEHash::computeHash(DIE *Die) { +void DIEHash::computeHash(const DIE &Die) { // Append the letter 'D', followed by the DWARF tag of the DIE. addULEB128('D'); - addULEB128(Die->getTag()); + addULEB128(Die.getTag()); // Add each of the attributes of the DIE. addAttributes(Die); // Then hash each of the children of the DIE. - for (std::vector::const_iterator I = Die->getChildren().begin(), - E = Die->getChildren().end(); + for (std::vector::const_iterator I = Die.getChildren().begin(), + E = Die.getChildren().end(); I != E; ++I) - computeHash(*I); + computeHash(**I); // Following the last (or if there are no children), append a zero byte. Hash.update(makeArrayRef((uint8_t)'\0')); @@ -408,24 +409,23 @@ void DIEHash::computeHash(DIE *Die) { /// DWARF4 standard. It is the md5 hash of a flattened description of the DIE /// with the exception that we are hashing only the context and the name of the /// type. -uint64_t DIEHash::computeDIEODRSignature(DIE *Die) { +uint64_t DIEHash::computeDIEODRSignature(const DIE &Die) { // Add the contexts to the hash. We won't be computing the ODR hash for // function local types so it's safe to use the generic context hashing // algorithm here. // FIXME: If we figure out how to account for linkage in some way we could // actually do this with a slight modification to the parent hash algorithm. - DIE *Parent = Die->getParent(); - if (Parent) - addParentContext(Parent); + if (const DIE *Parent = Die.getParent()) + addParentContext(*Parent); // Add the current DIE information. // Add the DWARF tag of the DIE. - addULEB128(Die->getTag()); + addULEB128(Die.getTag()); // Add the name of the type to the hash. - addString(getDIEStringAttr(*Die, dwarf::DW_AT_name)); + addString(getDIEStringAttr(Die, dwarf::DW_AT_name)); // Now get the result. MD5::MD5Result Result; @@ -441,9 +441,9 @@ uint64_t DIEHash::computeDIEODRSignature(DIE *Die) { /// DWARF4 standard. It is an md5 hash of the flattened description of the DIE /// with the inclusion of the full CU and all top level CU entities. // TODO: Initialize the type chain at 0 instead of 1 for CU signatures. -uint64_t DIEHash::computeCUSignature(DIE *Die) { +uint64_t DIEHash::computeCUSignature(const DIE &Die) { Numbering.clear(); - Numbering[Die] = 1; + Numbering[&Die] = 1; // Hash the DIE. computeHash(Die); @@ -462,12 +462,12 @@ uint64_t DIEHash::computeCUSignature(DIE *Die) { /// DWARF4 standard. It is an md5 hash of the flattened description of the DIE /// with the inclusion of additional forms not specifically called out in the /// standard. -uint64_t DIEHash::computeTypeSignature(DIE *Die) { +uint64_t DIEHash::computeTypeSignature(const DIE &Die) { Numbering.clear(); - Numbering[Die] = 1; + Numbering[&Die] = 1; - if (DIE *Parent = Die->getParent()) - addParentContext(Parent); + if (const DIE *Parent = Die.getParent()) + addParentContext(*Parent); // Hash the DIE. computeHash(Die); diff --git a/lib/CodeGen/AsmPrinter/DIEHash.h b/lib/CodeGen/AsmPrinter/DIEHash.h index 2869ce7614d..da373de3f0f 100644 --- a/lib/CodeGen/AsmPrinter/DIEHash.h +++ b/lib/CodeGen/AsmPrinter/DIEHash.h @@ -84,24 +84,24 @@ class DIEHash { public: /// \brief Computes the ODR signature. - uint64_t computeDIEODRSignature(DIE *Die); + uint64_t computeDIEODRSignature(const DIE &Die); /// \brief Computes the CU signature. - uint64_t computeCUSignature(DIE *Die); + uint64_t computeCUSignature(const DIE &Die); /// \brief Computes the type signature. - uint64_t computeTypeSignature(DIE *Die); + uint64_t computeTypeSignature(const DIE &Die); // Helper routines to process parts of a DIE. private: /// \brief Adds the parent context of \param Die to the hash. - void addParentContext(DIE *Die); + void addParentContext(const DIE &Die); /// \brief Adds the attributes of \param Die to the hash. - void addAttributes(DIE *Die); + void addAttributes(const DIE &Die); /// \brief Computes the full DWARF4 7.27 hash of the DIE. - void computeHash(DIE *Die); + void computeHash(const DIE &Die); // Routines that add DIEValues to the hash. private: @@ -116,7 +116,7 @@ private: /// \brief Collects the attributes of DIE \param Die into the \param Attrs /// structure. - void collectAttributes(DIE *Die, DIEAttrs &Attrs); + void collectAttributes(const DIE &Die, DIEAttrs &Attrs); /// \brief Hashes the attributes in \param Attrs in order. void hashAttributes(const DIEAttrs &Attrs, dwarf::Tag Tag); @@ -126,19 +126,19 @@ private: /// \brief Hashes an attribute that refers to another DIE. void hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag, - DIE &Entry); + const DIE &Entry); /// \brief Hashes a reference to a named type in such a way that is /// independent of whether that type is described by a declaration or a /// definition. - void hashShallowTypeReference(dwarf::Attribute Attribute, - const DIE &Entry, StringRef Name); + void hashShallowTypeReference(dwarf::Attribute Attribute, const DIE &Entry, + StringRef Name); /// \brief Hashes a reference to a previously referenced type DIE. void hashRepeatedTypeReference(dwarf::Attribute Attribute, unsigned DieNumber); private: MD5 Hash; - DenseMap Numbering; + DenseMap Numbering; }; } diff --git a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 906239d7097..adcf655b44f 100644 --- a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -1062,7 +1062,7 @@ void DwarfDebug::finalizeModuleInfo() { if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die)) CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8, - Hash.computeDIEODRSignature(Die)); + Hash.computeDIEODRSignature(*Die)); } // Handle anything that needs to be done on a per-cu basis. @@ -1080,7 +1080,7 @@ void DwarfDebug::finalizeModuleInfo() { uint64_t ID = 0; if (GenerateCUHash) { DIEHash CUHash; - ID = CUHash.computeCUSignature(TheCU->getCUDie()); + ID = CUHash.computeCUSignature(*TheCU->getCUDie()); } // This should be a unique identifier when we want to build .dwp files. TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, diff --git a/unittests/CodeGen/DIEHashTest.cpp b/unittests/CodeGen/DIEHashTest.cpp index 8b198c7da3b..6f71462bfdf 100644 --- a/unittests/CodeGen/DIEHashTest.cpp +++ b/unittests/CodeGen/DIEHashTest.cpp @@ -22,7 +22,7 @@ TEST(DIEHashTest, Data1) { DIE Die(dwarf::DW_TAG_base_type); DIEInteger Size(4); Die.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Size); - uint64_t MD5Res = Hash.computeTypeSignature(&Die); + uint64_t MD5Res = Hash.computeTypeSignature(Die); ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res); } @@ -35,7 +35,7 @@ TEST(DIEHashTest, TrivialType) { // Line and file number are ignored. Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); Unnamed.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Unnamed); + uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); // The exact same hash GCC produces for this DIE. ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res); @@ -49,7 +49,7 @@ TEST(DIEHashTest, NamedType) { Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); // The exact same hash GCC produces for this DIE. ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res); @@ -75,7 +75,7 @@ TEST(DIEHashTest, NamespacedType) { Space->addChild(Foo); CU.addChild(Space); - uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(*Foo); // The exact same hash GCC produces for this DIE. ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res); @@ -105,7 +105,7 @@ TEST(DIEHashTest, TypeWithMember) { DIEEntry IntRef(&Int); Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Unnamed); + uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res); } @@ -143,7 +143,7 @@ TEST(DIEHashTest, ReusedType) { Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Unnamed); + uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res); } @@ -165,7 +165,7 @@ TEST(DIEHashTest, RecursiveType) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res); } @@ -194,7 +194,7 @@ TEST(DIEHashTest, Pointer) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res); } @@ -227,7 +227,7 @@ TEST(DIEHashTest, Reference) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res); } @@ -260,7 +260,7 @@ TEST(DIEHashTest, RValueReference) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res); } @@ -289,7 +289,7 @@ TEST(DIEHashTest, PtrToMember) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res); } @@ -333,7 +333,7 @@ TEST(DIEHashTest, PtrToMemberDeclDefMatch) { Foo.addChild(Mem); - MD5ResDecl = DIEHash().computeTypeSignature(&Foo); + MD5ResDecl = DIEHash().computeTypeSignature(Foo); } uint64_t MD5ResDef; { @@ -362,7 +362,7 @@ TEST(DIEHashTest, PtrToMemberDeclDefMatch) { Foo.addChild(Mem); - MD5ResDef = DIEHash().computeTypeSignature(&Foo); + MD5ResDef = DIEHash().computeTypeSignature(Foo); } ASSERT_EQ(MD5ResDef, MD5ResDecl); } @@ -405,7 +405,7 @@ TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) { Foo.addChild(Mem); - MD5ResDecl = DIEHash().computeTypeSignature(&Foo); + MD5ResDecl = DIEHash().computeTypeSignature(Foo); } uint64_t MD5ResDef; { @@ -433,7 +433,7 @@ TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) { Foo.addChild(Mem); - MD5ResDef = DIEHash().computeTypeSignature(&Foo); + MD5ResDef = DIEHash().computeTypeSignature(Foo); } // 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 @@ -473,7 +473,7 @@ TEST(DIEHashTest, RefUnnamedType) { Foo.addChild(Mem); - uint64_t MD5Res = DIEHash().computeTypeSignature(&Foo); + uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); ASSERT_EQ(0x954e026f01c02529ULL, MD5Res); }