summaryrefslogtreecommitdiff
path: root/unittests/DebugInfo
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/DebugInfo')
-rw-r--r--unittests/DebugInfo/DWARF/CMakeLists.txt1
-rw-r--r--unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp698
-rw-r--r--unittests/DebugInfo/DWARF/DwarfGenerator.cpp14
-rw-r--r--unittests/DebugInfo/DWARF/DwarfGenerator.h3
-rw-r--r--unittests/DebugInfo/PDB/CMakeLists.txt3
-rw-r--r--unittests/DebugInfo/PDB/HashTableTest.cpp168
-rw-r--r--unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp90
-rw-r--r--unittests/DebugInfo/PDB/PDBApiTest.cpp1
-rw-r--r--unittests/DebugInfo/PDB/StringTableBuilderTest.cpp55
-rw-r--r--unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp175
10 files changed, 1006 insertions, 202 deletions
diff --git a/unittests/DebugInfo/DWARF/CMakeLists.txt b/unittests/DebugInfo/DWARF/CMakeLists.txt
index eafca4a2fc06..ed512a92ef18 100644
--- a/unittests/DebugInfo/DWARF/CMakeLists.txt
+++ b/unittests/DebugInfo/DWARF/CMakeLists.txt
@@ -4,6 +4,7 @@ set(LLVM_LINK_COMPONENTS
DebugInfoDWARF
MC
Object
+ ObjectYAML
Support
)
diff --git a/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp b/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
index a4109a34097f..a6c5b3a34ccb 100644
--- a/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
+++ b/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
@@ -8,16 +8,27 @@
//===----------------------------------------------------------------------===//
#include "DwarfGenerator.h"
-#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/DWARF/DWARFDie.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
-#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
+#include "llvm/ObjectYAML/DWARFEmitter.h"
#include "llvm/Support/Dwarf.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/TargetSelect.h"
#include "gtest/gtest.h"
#include <climits>
+#include <cstdint>
+#include <cstring>
+#include <string>
using namespace llvm;
using namespace dwarf;
@@ -52,7 +63,7 @@ Triple getHostTripleForAddrSize(uint8_t AddrSize) {
template <typename T>
static bool HandleExpectedError(T &Expected) {
std::string ErrorMsg;
- handleAllErrors(Expected.takeError(), [&](const llvm::ErrorInfoBase &EI) {
+ handleAllErrors(Expected.takeError(), [&](const ErrorInfoBase &EI) {
ErrorMsg = EI.message();
});
if (!ErrorMsg.empty()) {
@@ -228,8 +239,7 @@ void TestAllForms() {
//----------------------------------------------------------------------
// Test address forms
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_DW_FORM_addr).getValueOr(0),
- AddrValue);
+ EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_DW_FORM_addr), 0));
//----------------------------------------------------------------------
// Test block forms
@@ -238,7 +248,7 @@ void TestAllForms() {
ArrayRef<uint8_t> ExtractedBlockData;
Optional<ArrayRef<uint8_t>> BlockDataOpt;
- FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block);
+ FormValue = DieDG.find(Attr_DW_FORM_block);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
@@ -246,7 +256,7 @@ void TestAllForms() {
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block1);
+ FormValue = DieDG.find(Attr_DW_FORM_block1);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
@@ -254,7 +264,7 @@ void TestAllForms() {
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block2);
+ FormValue = DieDG.find(Attr_DW_FORM_block2);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
@@ -262,7 +272,7 @@ void TestAllForms() {
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block4);
+ FormValue = DieDG.find(Attr_DW_FORM_block4);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
@@ -273,100 +283,64 @@ void TestAllForms() {
//----------------------------------------------------------------------
// Test data forms
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data1)
- .getValueOr(0),
- Data1);
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data2)
- .getValueOr(0),
- Data2);
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data4)
- .getValueOr(0),
- Data4);
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data8)
- .getValueOr(0),
- Data8);
+ EXPECT_EQ(Data1, toUnsigned(DieDG.find(Attr_DW_FORM_data1), 0));
+ EXPECT_EQ(Data2, toUnsigned(DieDG.find(Attr_DW_FORM_data2), 0));
+ EXPECT_EQ(Data4, toUnsigned(DieDG.find(Attr_DW_FORM_data4), 0));
+ EXPECT_EQ(Data8, toUnsigned(DieDG.find(Attr_DW_FORM_data8), 0));
//----------------------------------------------------------------------
// Test string forms
//----------------------------------------------------------------------
- const char *ExtractedStringValue =
- DieDG.getAttributeValueAsString(Attr_DW_FORM_string, nullptr);
- EXPECT_TRUE(ExtractedStringValue != nullptr);
- EXPECT_TRUE(strcmp(StringValue, ExtractedStringValue) == 0);
+ auto ExtractedStringValue = toString(DieDG.find(Attr_DW_FORM_string));
+ EXPECT_TRUE((bool)ExtractedStringValue);
+ EXPECT_TRUE(strcmp(StringValue, *ExtractedStringValue) == 0);
- const char *ExtractedStrpValue =
- DieDG.getAttributeValueAsString(Attr_DW_FORM_strp, nullptr);
- EXPECT_TRUE(ExtractedStrpValue != nullptr);
- EXPECT_TRUE(strcmp(StrpValue, ExtractedStrpValue) == 0);
+ auto ExtractedStrpValue = toString(DieDG.find(Attr_DW_FORM_strp));
+ EXPECT_TRUE((bool)ExtractedStrpValue);
+ EXPECT_TRUE(strcmp(StrpValue, *ExtractedStrpValue) == 0);
//----------------------------------------------------------------------
// Test reference forms
//----------------------------------------------------------------------
- EXPECT_EQ(
- DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_addr).getValueOr(0),
- RefAddr);
- EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref1).getValueOr(0),
- Data1);
- EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref2).getValueOr(0),
- Data2);
- EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref4).getValueOr(0),
- Data4);
- EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref8).getValueOr(0),
- Data8);
- EXPECT_EQ(
- DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_sig8).getValueOr(0),
- Data8_2);
- EXPECT_EQ(
- DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_udata).getValueOr(0),
- UData[0]);
+ EXPECT_EQ(RefAddr, toReference(DieDG.find(Attr_DW_FORM_ref_addr), 0));
+ EXPECT_EQ(Data1, toReference(DieDG.find(Attr_DW_FORM_ref1), 0));
+ EXPECT_EQ(Data2, toReference(DieDG.find(Attr_DW_FORM_ref2), 0));
+ EXPECT_EQ(Data4, toReference(DieDG.find(Attr_DW_FORM_ref4), 0));
+ EXPECT_EQ(Data8, toReference(DieDG.find(Attr_DW_FORM_ref8), 0));
+ EXPECT_EQ(Data8_2, toReference(DieDG.find(Attr_DW_FORM_ref_sig8), 0));
+ EXPECT_EQ(UData[0], toReference(DieDG.find(Attr_DW_FORM_ref_udata), 0));
//----------------------------------------------------------------------
// Test flag forms
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_true)
- .getValueOr(0),
- 1ULL);
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_false)
- .getValueOr(1),
- 0ULL);
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_present)
- .getValueOr(0ULL),
- 1ULL);
+ EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_true), 0));
+ EXPECT_EQ(0ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_false), 1));
+ EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_present), 0));
//----------------------------------------------------------------------
// Test SLEB128 based forms
//----------------------------------------------------------------------
- EXPECT_EQ(
- DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_sdata).getValueOr(0),
- SData);
+ EXPECT_EQ(SData, toSigned(DieDG.find(Attr_DW_FORM_sdata), 0));
if (Version >= 5)
- EXPECT_EQ(
- DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_implicit_const)
- .getValueOr(0),
- ICSData);
+ EXPECT_EQ(ICSData, toSigned(DieDG.find(Attr_DW_FORM_implicit_const), 0));
//----------------------------------------------------------------------
// Test ULEB128 based forms
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_udata)
- .getValueOr(0),
- UData[0]);
+ EXPECT_EQ(UData[0], toUnsigned(DieDG.find(Attr_DW_FORM_udata), 0));
//----------------------------------------------------------------------
// Test DWARF32/DWARF64 forms
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_GNU_ref_alt)
- .getValueOr(0),
- Dwarf32Values[0]);
- EXPECT_EQ(DieDG.getAttributeValueAsSectionOffset(Attr_DW_FORM_sec_offset)
- .getValueOr(0),
- Dwarf32Values[1]);
+ EXPECT_EQ(Dwarf32Values[0],
+ toReference(DieDG.find(Attr_DW_FORM_GNU_ref_alt), 0));
+ EXPECT_EQ(Dwarf32Values[1],
+ toSectionOffset(DieDG.find(Attr_DW_FORM_sec_offset), 0));
//----------------------------------------------------------------------
// Add an address at the end to make sure we can decode this value
//----------------------------------------------------------------------
- EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_Last).getValueOr(0),
- AddrValue);
+ EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_Last), 0));
}
TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
@@ -488,7 +462,6 @@ template <uint16_t Version, class AddrType> void TestChildren() {
// Get the compile unit DIE is valid.
auto DieDG = U->getUnitDIE(false);
EXPECT_TRUE(DieDG.isValid());
- // DieDG.dump(llvm::outs(), U, UINT32_MAX);
// Verify the first child of the compile unit DIE is our subprogram.
auto SubprogramDieDG = DieDG.getFirstChild();
@@ -662,133 +635,115 @@ template <uint16_t Version, class AddrType> void TestReferences() {
// Get the compile unit DIE is valid.
auto Unit1DieDG = U1->getUnitDIE(false);
EXPECT_TRUE(Unit1DieDG.isValid());
- // Unit1DieDG.dump(llvm::outs(), UINT32_MAX);
auto Unit2DieDG = U2->getUnitDIE(false);
EXPECT_TRUE(Unit2DieDG.isValid());
- // Unit2DieDG.dump(llvm::outs(), UINT32_MAX);
// Verify the first child of the compile unit 1 DIE is our int base type.
auto CU1TypeDieDG = Unit1DieDG.getFirstChild();
EXPECT_TRUE(CU1TypeDieDG.isValid());
EXPECT_EQ(CU1TypeDieDG.getTag(), DW_TAG_base_type);
- EXPECT_EQ(CU1TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding)
- .getValueOr(0),
- DW_ATE_signed);
+ EXPECT_EQ(DW_ATE_signed, toUnsigned(CU1TypeDieDG.find(DW_AT_encoding), 0));
// Verify the first child of the compile unit 2 DIE is our float base type.
auto CU2TypeDieDG = Unit2DieDG.getFirstChild();
EXPECT_TRUE(CU2TypeDieDG.isValid());
EXPECT_EQ(CU2TypeDieDG.getTag(), DW_TAG_base_type);
- EXPECT_EQ(CU2TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding)
- .getValueOr(0),
- DW_ATE_float);
+ EXPECT_EQ(DW_ATE_float, toUnsigned(CU2TypeDieDG.find(DW_AT_encoding), 0));
// Verify the sibling of the base type DIE is our Ref1 DIE and that its
// DW_AT_type points to our base type DIE.
auto CU1Ref1DieDG = CU1TypeDieDG.getSibling();
EXPECT_TRUE(CU1Ref1DieDG.isValid());
EXPECT_EQ(CU1Ref1DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU1Ref1DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU1Ref1DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
auto CU1Ref2DieDG = CU1Ref1DieDG.getSibling();
EXPECT_TRUE(CU1Ref2DieDG.isValid());
EXPECT_EQ(CU1Ref2DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU1Ref2DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU1Ref2DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
auto CU1Ref4DieDG = CU1Ref2DieDG.getSibling();
EXPECT_TRUE(CU1Ref4DieDG.isValid());
EXPECT_EQ(CU1Ref4DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU1Ref4DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU1Ref4DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
auto CU1Ref8DieDG = CU1Ref4DieDG.getSibling();
EXPECT_TRUE(CU1Ref8DieDG.isValid());
EXPECT_EQ(CU1Ref8DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU1Ref8DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU1Ref8DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
// base type DIE in CU1.
auto CU1RefAddrDieDG = CU1Ref8DieDG.getSibling();
EXPECT_TRUE(CU1RefAddrDieDG.isValid());
EXPECT_EQ(CU1RefAddrDieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
- .getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU1RefAddrDieDG.find(DW_AT_type), -1ULL));
// Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
// DW_AT_type points to our base type DIE.
auto CU1ToCU2RefAddrDieDG = CU1RefAddrDieDG.getSibling();
EXPECT_TRUE(CU1ToCU2RefAddrDieDG.isValid());
EXPECT_EQ(CU1ToCU2RefAddrDieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1ToCU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
- .getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU1ToCU2RefAddrDieDG.find(DW_AT_type), -1ULL));
// Verify the sibling of the base type DIE is our Ref1 DIE and that its
// DW_AT_type points to our base type DIE.
auto CU2Ref1DieDG = CU2TypeDieDG.getSibling();
EXPECT_TRUE(CU2Ref1DieDG.isValid());
EXPECT_EQ(CU2Ref1DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU2Ref1DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU2Ref1DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
auto CU2Ref2DieDG = CU2Ref1DieDG.getSibling();
EXPECT_TRUE(CU2Ref2DieDG.isValid());
EXPECT_EQ(CU2Ref2DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU2Ref2DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU2Ref2DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
auto CU2Ref4DieDG = CU2Ref2DieDG.getSibling();
EXPECT_TRUE(CU2Ref4DieDG.isValid());
EXPECT_EQ(CU2Ref4DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU2Ref4DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU2Ref4DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
auto CU2Ref8DieDG = CU2Ref4DieDG.getSibling();
EXPECT_TRUE(CU2Ref8DieDG.isValid());
EXPECT_EQ(CU2Ref8DieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(
- CU2Ref8DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU2Ref8DieDG.find(DW_AT_type), -1ULL));
// Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
// base type DIE in CU2.
auto CU2RefAddrDieDG = CU2Ref8DieDG.getSibling();
EXPECT_TRUE(CU2RefAddrDieDG.isValid());
EXPECT_EQ(CU2RefAddrDieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
- .getValueOr(-1ULL),
- CU2TypeDieDG.getOffset());
+ EXPECT_EQ(CU2TypeDieDG.getOffset(),
+ toReference(CU2RefAddrDieDG.find(DW_AT_type), -1ULL));
// Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
// DW_AT_type points to our base type DIE.
auto CU2ToCU1RefAddrDieDG = CU2RefAddrDieDG.getSibling();
EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2ToCU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
- .getValueOr(-1ULL),
- CU1TypeDieDG.getOffset());
+ EXPECT_EQ(CU1TypeDieDG.getOffset(),
+ toReference(CU2ToCU1RefAddrDieDG.find(DW_AT_type), -1ULL));
}
TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
@@ -887,7 +842,6 @@ template <uint16_t Version, class AddrType> void TestAddresses() {
// Get the compile unit DIE is valid.
auto DieDG = U->getUnitDIE(false);
EXPECT_TRUE(DieDG.isValid());
- // DieDG.dump(llvm::outs(), U, UINT32_MAX);
uint64_t LowPC, HighPC;
Optional<uint64_t> OptU64;
@@ -896,50 +850,48 @@ template <uint16_t Version, class AddrType> void TestAddresses() {
auto SubprogramDieNoPC = DieDG.getFirstChild();
EXPECT_TRUE(SubprogramDieNoPC.isValid());
EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
- OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_low_pc);
+ OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_low_pc));
EXPECT_FALSE((bool)OptU64);
- OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_high_pc);
+ OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
EXPECT_FALSE((bool)OptU64);
EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
- OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_high_pc);
+ OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
EXPECT_FALSE((bool)OptU64);
- OptU64 = SubprogramDieNoPC.getAttributeValueAsUnsignedConstant(DW_AT_high_pc);
+ OptU64 = toUnsigned(SubprogramDieNoPC.find(DW_AT_high_pc));
EXPECT_FALSE((bool)OptU64);
OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
EXPECT_FALSE((bool)OptU64);
EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
-
-
+
// Verify the that our subprogram with only a low PC value succeeds when
// we ask for the Low PC, but fails appropriately when asked for the high PC
// or both low and high PC values.
auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
EXPECT_TRUE(SubprogramDieLowPC.isValid());
EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
- OptU64 = SubprogramDieLowPC.getAttributeValueAsAddress(DW_AT_low_pc);
+ OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_low_pc));
EXPECT_TRUE((bool)OptU64);
EXPECT_EQ(OptU64.getValue(), ActualLowPC);
- OptU64 = SubprogramDieLowPC.getAttributeValueAsAddress(DW_AT_high_pc);
+ OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_high_pc));
EXPECT_FALSE((bool)OptU64);
- OptU64 = SubprogramDieLowPC.getAttributeValueAsUnsignedConstant(DW_AT_high_pc);
+ OptU64 = toUnsigned(SubprogramDieLowPC.find(DW_AT_high_pc));
EXPECT_FALSE((bool)OptU64);
OptU64 = SubprogramDieLowPC.getHighPC(ActualLowPC);
EXPECT_FALSE((bool)OptU64);
EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC));
-
// Verify the that our subprogram with only a low PC value succeeds when
// we ask for the Low PC, but fails appropriately when asked for the high PC
// or both low and high PC values.
auto SubprogramDieLowHighPC = SubprogramDieLowPC.getSibling();
EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
EXPECT_EQ(SubprogramDieLowHighPC.getTag(), DW_TAG_subprogram);
- OptU64 = SubprogramDieLowHighPC.getAttributeValueAsAddress(DW_AT_low_pc);
+ OptU64 = toAddress(SubprogramDieLowHighPC.find(DW_AT_low_pc));
EXPECT_TRUE((bool)OptU64);
EXPECT_EQ(OptU64.getValue(), ActualLowPC);
// Get the high PC as an address. This should succeed if the high PC was
// encoded as an address and fail if the high PC was encoded as an offset.
- OptU64 = SubprogramDieLowHighPC.getAttributeValueAsAddress(DW_AT_high_pc);
+ OptU64 = toAddress(SubprogramDieLowHighPC.find(DW_AT_high_pc));
if (SupportsHighPCAsOffset) {
EXPECT_FALSE((bool)OptU64);
} else {
@@ -948,8 +900,7 @@ template <uint16_t Version, class AddrType> void TestAddresses() {
}
// Get the high PC as an unsigned constant. This should succeed if the high PC
// was encoded as an offset and fail if the high PC was encoded as an address.
- OptU64 = SubprogramDieLowHighPC.getAttributeValueAsUnsignedConstant(
- DW_AT_high_pc);
+ OptU64 = toUnsigned(SubprogramDieLowHighPC.find(DW_AT_high_pc));
if (SupportsHighPCAsOffset) {
EXPECT_TRUE((bool)OptU64);
EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset);
@@ -1067,7 +1018,6 @@ TEST(DWARFDebugInfo, TestRelations) {
// Get the compile unit DIE is valid.
auto CUDie = U->getUnitDIE(false);
EXPECT_TRUE(CUDie.isValid());
- // CUDie.dump(llvm::outs(), UINT32_MAX);
// The compile unit doesn't have a parent or a sibling.
auto ParentDie = CUDie.getParent();
@@ -1132,7 +1082,6 @@ TEST(DWARFDebugInfo, TestRelations) {
}
TEST(DWARFDebugInfo, TestDWARFDie) {
-
// Make sure a default constructed DWARFDie doesn't have any parent, sibling
// or child;
DWARFDie DefaultDie;
@@ -1185,7 +1134,6 @@ TEST(DWARFDebugInfo, TestChildIterators) {
// Get the compile unit DIE is valid.
auto CUDie = U->getUnitDIE(false);
EXPECT_TRUE(CUDie.isValid());
- // CUDie.dump(llvm::outs(), UINT32_MAX);
uint32_t Index;
DWARFDie A;
DWARFDie B;
@@ -1217,11 +1165,49 @@ TEST(DWARFDebugInfo, TestChildIteratorsOnInvalidDie) {
EXPECT_EQ(begin, end);
}
-
TEST(DWARFDebugInfo, TestEmptyChildren) {
- // Test a DIE that says it has children in the abbreviation, but actually
- // doesn't have any attributes, will not return anything during iteration.
- // We do this by making sure the begin and end iterators are equal.
+ const char *yamldata = "debug_abbrev:\n"
+ " - Code: 0x00000001\n"
+ " Tag: DW_TAG_compile_unit\n"
+ " Children: DW_CHILDREN_yes\n"
+ " Attributes:\n"
+ "debug_info:\n"
+ " - Length:\n"
+ " TotalLength: 9\n"
+ " Version: 4\n"
+ " AbbrOffset: 0\n"
+ " AddrSize: 8\n"
+ " Entries:\n"
+ " - AbbrCode: 0x00000001\n"
+ " Values:\n"
+ " - AbbrCode: 0x00000000\n"
+ " Values:\n";
+
+ auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
+ ASSERT_TRUE((bool)ErrOrSections);
+
+ auto &DebugSections = *ErrOrSections;
+
+ DWARFContextInMemory DwarfContext(DebugSections, 8);
+
+ // Verify the number of compile units is correct.
+ uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+ EXPECT_EQ(NumCUs, 1u);
+ DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+
+ // Get the compile unit DIE is valid.
+ auto CUDie = U->getUnitDIE(false);
+ EXPECT_TRUE(CUDie.isValid());
+
+ // Verify that the CU Die that says it has children, but doesn't, actually
+ // has begin and end iterators that are equal. We want to make sure we don't
+ // see the Null DIEs during iteration.
+ EXPECT_EQ(CUDie.begin(), CUDie.end());
+}
+
+TEST(DWARFDebugInfo, TestAttributeIterators) {
+ // Test the DWARF APIs related to iterating across all attribute values in a
+ // a DWARFDie.
uint16_t Version = 4;
const uint8_t AddrSize = sizeof(void *);
@@ -1232,14 +1218,19 @@ TEST(DWARFDebugInfo, TestEmptyChildren) {
return;
dwarfgen::Generator *DG = ExpectedDG.get().get();
dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+ const uint64_t CULowPC = 0x1000;
+ StringRef CUPath("/tmp/main.c");
// Scope to allow us to re-use the same DIE names
{
- // Create a compile unit DIE that has an abbreviation that says it has
- // children, but doesn't have any actual attributes. This helps us test
- // a DIE that has only one child: a NULL DIE.
auto CUDie = CU.getUnitDIE();
- CUDie.setForceChildren();
+ // Encode an attribute value before an attribute with no data.
+ CUDie.addAttribute(DW_AT_name, DW_FORM_strp, CUPath.data());
+ // Encode an attribute value with no data in .debug_info/types to ensure
+ // the iteration works correctly.
+ CUDie.addAttribute(DW_AT_declaration, DW_FORM_flag_present);
+ // Encode an attribute value after an attribute with no data.
+ CUDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, CULowPC);
}
MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
@@ -1255,12 +1246,419 @@ TEST(DWARFDebugInfo, TestEmptyChildren) {
// Get the compile unit DIE is valid.
auto CUDie = U->getUnitDIE(false);
EXPECT_TRUE(CUDie.isValid());
- CUDie.dump(llvm::outs(), UINT32_MAX);
- // Verify that the CU Die that says it has children, but doesn't, actually
- // has begin and end iterators that are equal. We want to make sure we don't
- // see the Null DIEs during iteration.
- EXPECT_EQ(CUDie.begin(), CUDie.end());
+ auto R = CUDie.attributes();
+ auto I = R.begin();
+ auto E = R.end();
+
+ ASSERT_NE(E, I);
+ EXPECT_EQ(I->Attr, DW_AT_name);
+ auto ActualCUPath = I->Value.getAsCString();
+ EXPECT_EQ(CUPath, *ActualCUPath);
+
+ ASSERT_NE(E, ++I);
+ EXPECT_EQ(I->Attr, DW_AT_declaration);
+ EXPECT_EQ(1ull, *I->Value.getAsUnsignedConstant());
+
+ ASSERT_NE(E, ++I);
+ EXPECT_EQ(I->Attr, DW_AT_low_pc);
+ EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
+
+ EXPECT_EQ(E, ++I);
+}
+
+TEST(DWARFDebugInfo, TestFindRecurse) {
+ uint16_t Version = 4;
+
+ const uint8_t AddrSize = sizeof(void *);
+ initLLVMIfNeeded();
+ Triple Triple = getHostTripleForAddrSize(AddrSize);
+ auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+ if (HandleExpectedError(ExpectedDG))
+ return;
+ dwarfgen::Generator *DG = ExpectedDG.get().get();
+ dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+
+ StringRef SpecDieName = "spec";
+ StringRef SpecLinkageName = "spec_linkage";
+ StringRef AbsDieName = "abs";
+ // Scope to allow us to re-use the same DIE names
+ {
+ auto CUDie = CU.getUnitDIE();
+ auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
+ auto FuncAbsDie = CUDie.addChild(DW_TAG_subprogram);
+ auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
+ auto VarAbsDie = CUDie.addChild(DW_TAG_variable);
+ auto VarDie = CUDie.addChild(DW_TAG_variable);
+ FuncSpecDie.addAttribute(DW_AT_name, DW_FORM_strp, SpecDieName);
+ FuncAbsDie.addAttribute(DW_AT_linkage_name, DW_FORM_strp, SpecLinkageName);
+ FuncAbsDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
+ FuncDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie);
+ VarAbsDie.addAttribute(DW_AT_name, DW_FORM_strp, AbsDieName);
+ VarDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, VarAbsDie);
+ }
+
+ MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
+ auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+ EXPECT_TRUE((bool)Obj);
+ DWARFContextInMemory DwarfContext(*Obj.get());
+
+ // Verify the number of compile units is correct.
+ uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+ EXPECT_EQ(NumCUs, 1u);
+ DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+
+ // Get the compile unit DIE is valid.
+ auto CUDie = U->getUnitDIE(false);
+ EXPECT_TRUE(CUDie.isValid());
+
+ auto FuncSpecDie = CUDie.getFirstChild();
+ auto FuncAbsDie = FuncSpecDie.getSibling();
+ auto FuncDie = FuncAbsDie.getSibling();
+ auto VarAbsDie = FuncDie.getSibling();
+ auto VarDie = VarAbsDie.getSibling();
+
+ // Make sure we can't extract the name from the specification die when using
+ // DWARFDie::find() since it won't check the DW_AT_specification DIE.
+ EXPECT_FALSE(FuncDie.find(DW_AT_name));
+
+ // Make sure we can extract the name from the specification die when using
+ // DWARFDie::findRecursively() since it should recurse through the
+ // DW_AT_specification DIE.
+ auto NameOpt = FuncDie.findRecursively(DW_AT_name);
+ EXPECT_TRUE(NameOpt);
+ // Test the dwarf::toString() helper function.
+ auto StringOpt = toString(NameOpt);
+ EXPECT_TRUE(StringOpt);
+ EXPECT_EQ(SpecDieName, StringOpt.getValueOr(nullptr));
+ // Test the dwarf::toString() helper function with a default value specified.
+ EXPECT_EQ(SpecDieName, toString(NameOpt, nullptr));
+
+ auto LinkageNameOpt = FuncDie.findRecursively(DW_AT_linkage_name);
+ EXPECT_EQ(SpecLinkageName, toString(LinkageNameOpt).getValueOr(nullptr));
+
+ // Make sure we can't extract the name from the abstract origin die when using
+ // DWARFDie::find() since it won't check the DW_AT_abstract_origin DIE.
+ EXPECT_FALSE(VarDie.find(DW_AT_name));
+
+ // Make sure we can extract the name from the abstract origin die when using
+ // DWARFDie::findRecursively() since it should recurse through the
+ // DW_AT_abstract_origin DIE.
+ NameOpt = VarDie.findRecursively(DW_AT_name);
+ EXPECT_TRUE(NameOpt);
+ // Test the dwarf::toString() helper function.
+ StringOpt = toString(NameOpt);
+ EXPECT_TRUE(StringOpt);
+ EXPECT_EQ(AbsDieName, StringOpt.getValueOr(nullptr));
+}
+
+TEST(DWARFDebugInfo, TestDwarfToFunctions) {
+ // Test all of the dwarf::toXXX functions that take a
+ // Optional<DWARFFormValue> and extract the values from it.
+ DWARFFormValue FormVal;
+ uint64_t InvalidU64 = 0xBADBADBADBADBADB;
+ int64_t InvalidS64 = 0xBADBADBADBADBADB;
+ // First test that we don't get valid values back when using an optional with
+ // no value.
+ Optional<DWARFFormValue> FormValOpt;
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toReference(FormValOpt).hasValue());
+ EXPECT_FALSE(toSigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ EXPECT_FALSE(toBlock(FormValOpt).hasValue());
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidS64));
+
+ // Test successful and unsuccessful address decoding.
+ uint64_t Address = 0x100000000ULL;
+ FormVal.setForm(DW_FORM_addr);
+ FormVal.setUValue(Address);
+ FormValOpt = FormVal;
+
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toReference(FormValOpt).hasValue());
+ EXPECT_FALSE(toSigned(FormValOpt).hasValue());
+ EXPECT_TRUE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ EXPECT_FALSE(toBlock(FormValOpt).hasValue());
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(Address, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
+
+ // Test successful and unsuccessful unsigned constant decoding.
+ uint64_t UData8 = 0x1020304050607080ULL;
+ FormVal.setForm(DW_FORM_udata);
+ FormVal.setUValue(UData8);
+ FormValOpt = FormVal;
+
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_TRUE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toReference(FormValOpt).hasValue());
+ EXPECT_TRUE(toSigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ EXPECT_FALSE(toBlock(FormValOpt).hasValue());
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ(UData8, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ((int64_t)UData8, toSigned(FormValOpt, InvalidU64));
+
+ // Test successful and unsuccessful reference decoding.
+ uint32_t RefData = 0x11223344U;
+ FormVal.setForm(DW_FORM_ref_addr);
+ FormVal.setUValue(RefData);
+ FormValOpt = FormVal;
+
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_TRUE(toReference(FormValOpt).hasValue());
+ EXPECT_FALSE(toSigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ EXPECT_FALSE(toBlock(FormValOpt).hasValue());
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(RefData, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
+
+ // Test successful and unsuccessful signed constant decoding.
+ int64_t SData8 = 0x1020304050607080ULL;
+ FormVal.setForm(DW_FORM_udata);
+ FormVal.setSValue(SData8);
+ FormValOpt = FormVal;
+
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_TRUE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toReference(FormValOpt).hasValue());
+ EXPECT_TRUE(toSigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ EXPECT_FALSE(toBlock(FormValOpt).hasValue());
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ(SData8, toSigned(FormValOpt, InvalidU64));
+
+ // Test successful and unsuccessful block decoding.
+ uint8_t Data[] = { 2, 3, 4 };
+ ArrayRef<uint8_t> Array(Data);
+ FormVal.setForm(DW_FORM_block1);
+ FormVal.setBlockValue(Array);
+ FormValOpt = FormVal;
+
+ EXPECT_FALSE(toString(FormValOpt).hasValue());
+ EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toReference(FormValOpt).hasValue());
+ EXPECT_FALSE(toSigned(FormValOpt).hasValue());
+ EXPECT_FALSE(toAddress(FormValOpt).hasValue());
+ EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
+ auto BlockOpt = toBlock(FormValOpt);
+ EXPECT_TRUE(BlockOpt.hasValue());
+ EXPECT_EQ(*BlockOpt, Array);
+ EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
+ EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
+ EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
+
+ // Test
+}
+
+TEST(DWARFDebugInfo, TestFindAttrs) {
+ // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
+ // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
+ uint16_t Version = 4;
+
+ const uint8_t AddrSize = sizeof(void *);
+ initLLVMIfNeeded();
+ Triple Triple = getHostTripleForAddrSize(AddrSize);
+ auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+ if (HandleExpectedError(ExpectedDG))
+ return;
+ dwarfgen::Generator *DG = ExpectedDG.get().get();
+ dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+
+ StringRef DieMangled("_Z3fooi");
+ // Scope to allow us to re-use the same DIE names
+ {
+ auto CUDie = CU.getUnitDIE();
+ auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
+ auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
+ FuncSpecDie.addAttribute(DW_AT_MIPS_linkage_name, DW_FORM_strp, DieMangled);
+ FuncDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
+ }
+
+ MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
+ auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+ EXPECT_TRUE((bool)Obj);
+ DWARFContextInMemory DwarfContext(*Obj.get());
+
+ // Verify the number of compile units is correct.
+ uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+ EXPECT_EQ(NumCUs, 1u);
+ DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+
+ // Get the compile unit DIE is valid.
+ auto CUDie = U->getUnitDIE(false);
+ EXPECT_TRUE(CUDie.isValid());
+
+ auto FuncSpecDie = CUDie.getFirstChild();
+ auto FuncDie = FuncSpecDie.getSibling();
+
+ // Make sure that passing in an empty attribute list behave correctly.
+ EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue());
+
+ // Make sure that passing in a list of attribute that are not contained
+ // in the DIE returns nothing.
+ EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue());
+
+ const dwarf::Attribute Attrs[] = {DW_AT_linkage_name,
+ DW_AT_MIPS_linkage_name};
+
+ // Make sure we can't extract the linkage name attributes when using
+ // DWARFDie::find() since it won't check the DW_AT_specification DIE.
+ EXPECT_FALSE(FuncDie.find(Attrs).hasValue());
+
+ // Make sure we can extract the name from the specification die when using
+ // DWARFDie::findRecursively() since it should recurse through the
+ // DW_AT_specification DIE.
+ auto NameOpt = FuncDie.findRecursively(Attrs);
+ EXPECT_TRUE(NameOpt.hasValue());
+ EXPECT_EQ(DieMangled, toString(NameOpt, ""));
+}
+
+TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
+ uint16_t Version = 5;
+
+ const uint8_t AddrSize = sizeof(void *);
+ initLLVMIfNeeded();
+ Triple Triple = getHostTripleForAddrSize(AddrSize);
+ auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+ if (HandleExpectedError(ExpectedDG))
+ return;
+ dwarfgen::Generator *DG = ExpectedDG.get().get();
+ dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+ dwarfgen::DIE CUDie = CU.getUnitDIE();
+ const dwarf::Attribute Attr = DW_AT_lo_user;
+ const int64_t Val1 = 42;
+ const int64_t Val2 = 43;
+
+ auto FirstVal1DIE = CUDie.addChild(DW_TAG_class_type);
+ FirstVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1);
+
+ auto SecondVal1DIE = CUDie.addChild(DW_TAG_class_type);
+ SecondVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1);
+
+ auto Val2DIE = CUDie.addChild(DW_TAG_class_type);
+ Val2DIE.addAttribute(Attr, DW_FORM_implicit_const, Val2);
+
+ MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
+ auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+ EXPECT_TRUE((bool)Obj);
+ DWARFContextInMemory DwarfContext(*Obj.get());
+ DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+ EXPECT_TRUE((bool)U);
+
+ const auto *Abbrevs = U->getAbbreviations();
+ EXPECT_TRUE((bool)Abbrevs);
+
+ // Let's find implicit_const abbrevs and verify,
+ // that there are exactly two of them and both of them
+ // can be dumped correctly.
+ typedef decltype(Abbrevs->begin()) AbbrevIt;
+ AbbrevIt Val1Abbrev = Abbrevs->end();
+ AbbrevIt Val2Abbrev = Abbrevs->end();
+ for(auto it = Abbrevs->begin(); it != Abbrevs->end(); ++it) {
+ if (it->getNumAttributes() == 0)
+ continue; // root abbrev for DW_TAG_compile_unit
+
+ auto A = it->getAttrByIndex(0);
+ EXPECT_EQ(A, Attr);
+
+ auto FormValue = it->getAttributeValue(/* offset */ 0, A, *U);
+ EXPECT_TRUE((bool)FormValue);
+ EXPECT_EQ(FormValue->getForm(), dwarf::DW_FORM_implicit_const);
+
+ const auto V = FormValue->getAsSignedConstant();
+ EXPECT_TRUE((bool)V);
+
+ auto VerifyAbbrevDump = [&V](AbbrevIt it) {
+ std::string S;
+ llvm::raw_string_ostream OS(S);
+ it->dump(OS);
+ auto FormPos = OS.str().find("DW_FORM_implicit_const");
+ EXPECT_NE(FormPos, std::string::npos);
+ auto ValPos = S.find_first_of("-0123456789", FormPos);
+ EXPECT_NE(ValPos, std::string::npos);
+ int64_t Val = std::atoll(S.substr(ValPos).c_str());
+ EXPECT_EQ(Val, *V);
+ };
+
+ switch(*V) {
+ case Val1:
+ EXPECT_EQ(Val1Abbrev, Abbrevs->end());
+ Val1Abbrev = it;
+ VerifyAbbrevDump(it);
+ break;
+ case Val2:
+ EXPECT_EQ(Val2Abbrev, Abbrevs->end());
+ Val2Abbrev = it;
+ VerifyAbbrevDump(it);
+ break;
+ default:
+ FAIL() << "Unexpected attribute value: " << *V;
+ }
+ }
+
+ // Now let's make sure that two Val1-DIEs refer to the same abbrev,
+ // and Val2-DIE refers to another one.
+ auto DieDG = U->getUnitDIE(false);
+ auto it = DieDG.begin();
+ std::multimap<int64_t, decltype(it->getAbbreviationDeclarationPtr())> DIEs;
+ const DWARFAbbreviationDeclaration *AbbrevPtrVal1 = nullptr;
+ const DWARFAbbreviationDeclaration *AbbrevPtrVal2 = nullptr;
+ for (; it != DieDG.end(); ++it) {
+ const auto *AbbrevPtr = it->getAbbreviationDeclarationPtr();
+ EXPECT_TRUE((bool)AbbrevPtr);
+ auto FormValue = it->find(Attr);
+ EXPECT_TRUE((bool)FormValue);
+ const auto V = FormValue->getAsSignedConstant();
+ EXPECT_TRUE((bool)V);
+ switch(*V) {
+ case Val1:
+ AbbrevPtrVal1 = AbbrevPtr;
+ break;
+ case Val2:
+ AbbrevPtrVal2 = AbbrevPtr;
+ break;
+ default:
+ FAIL() << "Unexpected attribute value: " << *V;
+ }
+ DIEs.insert(std::make_pair(*V, AbbrevPtr));
+ }
+ EXPECT_EQ(DIEs.count(Val1), 2u);
+ EXPECT_EQ(DIEs.count(Val2), 1u);
+ auto Val1Range = DIEs.equal_range(Val1);
+ for (auto it = Val1Range.first; it != Val1Range.second; ++it)
+ EXPECT_EQ(it->second, AbbrevPtrVal1);
+ EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
}
} // end anonymous namespace
diff --git a/unittests/DebugInfo/DWARF/DwarfGenerator.cpp b/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
index 9ec43cab4dc0..ac63bbaf0a11 100644
--- a/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
+++ b/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -108,10 +108,6 @@ dwarfgen::DIE dwarfgen::CompileUnit::getUnitDIE() {
return dwarfgen::DIE(this, &DU.getUnitDie());
}
-void dwarfgen::DIE::setForceChildren() {
- Die->setForceChildren(true);
-}
-
//===----------------------------------------------------------------------===//
/// dwarfgen::Generator implementation.
//===----------------------------------------------------------------------===//
@@ -240,8 +236,14 @@ StringRef dwarfgen::Generator::generate() {
assert(Length != -1U);
Asm->EmitInt32(Length);
Asm->EmitInt16(Version);
- Asm->EmitInt32(0);
- Asm->EmitInt8(CU->getAddressSize());
+ if (Version <= 4) {
+ Asm->EmitInt32(0);
+ Asm->EmitInt8(CU->getAddressSize());
+ } else {
+ Asm->EmitInt8(dwarf::DW_UT_compile);
+ Asm->EmitInt8(CU->getAddressSize());
+ Asm->EmitInt32(0);
+ }
Asm->emitDwarfDIE(*CU->getUnitDIE().Die);
}
diff --git a/unittests/DebugInfo/DWARF/DwarfGenerator.h b/unittests/DebugInfo/DWARF/DwarfGenerator.h
index 2978d1ca0021..966725b4fa4e 100644
--- a/unittests/DebugInfo/DWARF/DwarfGenerator.h
+++ b/unittests/DebugInfo/DWARF/DwarfGenerator.h
@@ -129,9 +129,6 @@ public:
/// \returns the newly created DIE object that is now a child owned by this
/// object.
dwarfgen::DIE addChild(dwarf::Tag Tag);
-
- /// Force a DIE to say it has children even when it doesn't.
- void setForceChildren();
};
/// A DWARF compile unit used to generate DWARF compile/type units.
diff --git a/unittests/DebugInfo/PDB/CMakeLists.txt b/unittests/DebugInfo/PDB/CMakeLists.txt
index 406b487e7a18..cbbbd8177483 100644
--- a/unittests/DebugInfo/PDB/CMakeLists.txt
+++ b/unittests/DebugInfo/PDB/CMakeLists.txt
@@ -5,9 +5,12 @@ set(LLVM_LINK_COMPONENTS
)
set(DebugInfoPDBSources
+ HashTableTest.cpp
MappedBlockStreamTest.cpp
+ StringTableBuilderTest.cpp
MSFBuilderTest.cpp
PDBApiTest.cpp
+ TypeServerHandlerTest.cpp
)
add_llvm_unittest(DebugInfoPDBTests
diff --git a/unittests/DebugInfo/PDB/HashTableTest.cpp b/unittests/DebugInfo/PDB/HashTableTest.cpp
new file mode 100644
index 000000000000..94c9ee86c4a6
--- /dev/null
+++ b/unittests/DebugInfo/PDB/HashTableTest.cpp
@@ -0,0 +1,168 @@
+//===- llvm/unittest/DebugInfo/PDB/HashTableTest.cpp ----------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ErrorChecking.h"
+#include "gtest/gtest.h"
+
+#include "llvm/DebugInfo/PDB/Native/HashTable.h"
+#include "llvm/Support/BinaryByteStream.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::pdb;
+using namespace llvm::support;
+
+namespace {
+class HashTableInternals : public HashTable {
+public:
+ using HashTable::Buckets;
+ using HashTable::Present;
+ using HashTable::Deleted;
+};
+}
+
+TEST(HashTableTest, TestSimple) {
+ HashTable Table;
+ EXPECT_EQ(0u, Table.size());
+ EXPECT_GT(Table.capacity(), 0u);
+
+ Table.set(3, 7);
+ EXPECT_EQ(1u, Table.size());
+ ASSERT_NE(Table.end(), Table.find(3));
+ EXPECT_EQ(7u, Table.get(3));
+}
+
+TEST(HashTableTest, TestCollision) {
+ HashTable Table;
+ EXPECT_EQ(0u, Table.size());
+ EXPECT_GT(Table.capacity(), 0u);
+
+ // We use knowledge of the hash table's implementation details to make sure
+ // to add another value that is the equivalent to the first value modulo the
+ // hash table's capacity.
+ uint32_t N1 = Table.capacity() + 1;
+ uint32_t N2 = 2 * N1;
+
+ Table.set(N1, 7);
+ Table.set(N2, 12);
+ EXPECT_EQ(2u, Table.size());
+ ASSERT_NE(Table.end(), Table.find(N1));
+ ASSERT_NE(Table.end(), Table.find(N2));
+
+ EXPECT_EQ(7u, Table.get(N1));
+ EXPECT_EQ(12u, Table.get(N2));
+}
+
+TEST(HashTableTest, TestRemove) {
+ HashTable Table;
+ EXPECT_EQ(0u, Table.size());
+ EXPECT_GT(Table.capacity(), 0u);
+
+ Table.set(1, 2);
+ Table.set(3, 4);
+ EXPECT_EQ(2u, Table.size());
+ ASSERT_NE(Table.end(), Table.find(1));
+ ASSERT_NE(Table.end(), Table.find(3));
+
+ EXPECT_EQ(2u, Table.get(1));
+ EXPECT_EQ(4u, Table.get(3));
+
+ Table.remove(1u);
+ EXPECT_EQ(1u, Table.size());
+ EXPECT_EQ(Table.end(), Table.find(1));
+ ASSERT_NE(Table.end(), Table.find(3));
+ EXPECT_EQ(4u, Table.get(3));
+}
+
+TEST(HashTableTest, TestCollisionAfterMultipleProbes) {
+ HashTable Table;
+ EXPECT_EQ(0u, Table.size());
+ EXPECT_GT(Table.capacity(), 0u);
+
+ // Probing looks for the first available slot. A slot may already be filled
+ // as a result of an item with a *different* hash value already being there.
+ // Test that when this happens, the probe still finds the value.
+ uint32_t N1 = Table.capacity() + 1;
+ uint32_t N2 = N1 + 1;
+ uint32_t N3 = 2 * N1;
+
+ Table.set(N1, 7);
+ Table.set(N2, 11);
+ Table.set(N3, 13);
+ EXPECT_EQ(3u, Table.size());
+ ASSERT_NE(Table.end(), Table.find(N1));
+ ASSERT_NE(Table.end(), Table.find(N2));
+ ASSERT_NE(Table.end(), Table.find(N3));
+
+ EXPECT_EQ(7u, Table.get(N1));
+ EXPECT_EQ(11u, Table.get(N2));
+ EXPECT_EQ(13u, Table.get(N3));
+
+ // Remove the one that had been filled in the middle, then insert another one
+ // with a collision. It should fill the newly emptied slot.
+ Table.remove(N2);
+ uint32_t N4 = N1 * 3;
+ Table.set(N4, 17);
+ EXPECT_EQ(3u, Table.size());
+ ASSERT_NE(Table.end(), Table.find(N1));
+ ASSERT_NE(Table.end(), Table.find(N3));
+ ASSERT_NE(Table.end(), Table.find(N4));
+
+ EXPECT_EQ(7u, Table.get(N1));
+ EXPECT_EQ(13u, Table.get(N3));
+ EXPECT_EQ(17u, Table.get(N4));
+}
+
+TEST(HashTableTest, Grow) {
+ // So that we are independent of the load factor, `capacity` items, which is
+ // guaranteed to trigger a grow. Then verify that the size is the same, the
+ // capacity is larger, and all the original items are still in the table.
+
+ HashTable Table;
+ uint32_t OldCapacity = Table.capacity();
+ for (uint32_t I = 0; I < OldCapacity; ++I) {
+ Table.set(OldCapacity + I * 2 + 1, I * 2 + 3);
+ }
+ EXPECT_EQ(OldCapacity, Table.size());
+ EXPECT_GT(Table.capacity(), OldCapacity);
+ for (uint32_t I = 0; I < OldCapacity; ++I) {
+ ASSERT_NE(Table.end(), Table.find(OldCapacity + I * 2 + 1));
+ EXPECT_EQ(I * 2 + 3, Table.get(OldCapacity + I * 2 + 1));
+ }
+}
+
+TEST(HashTableTest, Serialization) {
+ HashTableInternals Table;
+ uint32_t Cap = Table.capacity();
+ for (uint32_t I = 0; I < Cap; ++I) {
+ Table.set(Cap + I * 2 + 1, I * 2 + 3);
+ }
+
+ std::vector<uint8_t> Buffer(Table.calculateSerializedLength());
+ MutableBinaryByteStream Stream(Buffer, little);
+ BinaryStreamWriter Writer(Stream);
+ EXPECT_NO_ERROR(Table.commit(Writer));
+ // We should have written precisely the number of bytes we calculated earlier.
+ EXPECT_EQ(Buffer.size(), Writer.getOffset());
+
+ HashTableInternals Table2;
+ BinaryStreamReader Reader(Stream);
+ EXPECT_NO_ERROR(Table2.load(Reader));
+ // We should have read precisely the number of bytes we calculated earlier.
+ EXPECT_EQ(Buffer.size(), Reader.getOffset());
+
+ EXPECT_EQ(Table.size(), Table2.size());
+ EXPECT_EQ(Table.capacity(), Table2.capacity());
+ EXPECT_EQ(Table.Buckets, Table2.Buckets);
+ EXPECT_EQ(Table.Present, Table2.Present);
+ EXPECT_EQ(Table.Deleted, Table2.Deleted);
+}
diff --git a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
index 07591ca69d30..9f8940b77f28 100644
--- a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
+++ b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
@@ -9,26 +9,28 @@
#include "ErrorChecking.h"
-#include "llvm/DebugInfo/MSF/ByteStream.h"
#include "llvm/DebugInfo/MSF/IMSFFile.h"
-#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
+#include "llvm/DebugInfo/MSF/MSFError.h"
#include "llvm/DebugInfo/MSF/MSFStreamLayout.h"
-#include "llvm/DebugInfo/MSF/StreamReader.h"
-#include "llvm/DebugInfo/MSF/StreamRef.h"
-#include "llvm/DebugInfo/MSF/StreamWriter.h"
+#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
+#include "llvm/Support/BinaryByteStream.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/BinaryStreamRef.h"
+#include "llvm/Support/BinaryStreamWriter.h"
#include "gtest/gtest.h"
#include <unordered_map>
using namespace llvm;
using namespace llvm::msf;
+using namespace llvm::support;
namespace {
static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'};
-class DiscontiguousStream : public WritableStream {
+class DiscontiguousStream : public WritableBinaryStream {
public:
DiscontiguousStream(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data)
: Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {}
@@ -36,31 +38,33 @@ public:
uint32_t block_size() const { return 1; }
uint32_t block_count() const { return Blocks.size(); }
+ endianness getEndian() const override { return little; }
+
Error readBytes(uint32_t Offset, uint32_t Size,
- ArrayRef<uint8_t> &Buffer) const override {
- if (Offset + Size > Data.size())
- return make_error<MSFError>(msf_error_code::insufficient_buffer);
+ ArrayRef<uint8_t> &Buffer) override {
+ if (auto EC = checkOffset(Offset, Size))
+ return EC;
Buffer = Data.slice(Offset, Size);
return Error::success();
}
Error readLongestContiguousChunk(uint32_t Offset,
- ArrayRef<uint8_t> &Buffer) const override {
- if (Offset >= Data.size())
- return make_error<MSFError>(msf_error_code::insufficient_buffer);
+ ArrayRef<uint8_t> &Buffer) override {
+ if (auto EC = checkOffset(Offset, 1))
+ return EC;
Buffer = Data.drop_front(Offset);
return Error::success();
}
- uint32_t getLength() const override { return Data.size(); }
+ uint32_t getLength() override { return Data.size(); }
- Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) const override {
- if (Offset + SrcData.size() > Data.size())
- return make_error<MSFError>(msf_error_code::insufficient_buffer);
+ Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) override {
+ if (auto EC = checkOffset(Offset, SrcData.size()))
+ return EC;
::memcpy(&Data[Offset], SrcData.data(), SrcData.size());
return Error::success();
}
- Error commit() const override { return Error::success(); }
+ Error commit() override { return Error::success(); }
MSFStreamLayout layout() const {
return MSFStreamLayout{static_cast<uint32_t>(Data.size()), Blocks};
@@ -78,8 +82,8 @@ TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) {
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
- ReadableStreamRef SR;
+ BinaryStreamReader R(*S);
+ BinaryStreamRef SR;
EXPECT_NO_ERROR(R.readStreamRef(SR, 0U));
ArrayRef<uint8_t> Buffer;
EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer));
@@ -94,7 +98,7 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
EXPECT_NO_ERROR(R.readFixedString(Str, 1));
EXPECT_EQ(Str, StringRef("A"));
@@ -108,7 +112,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
EXPECT_NO_ERROR(R.readFixedString(Str, 2));
EXPECT_EQ(Str, StringRef("AB"));
@@ -127,7 +131,7 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
EXPECT_NO_ERROR(R.readFixedString(Str, 10));
EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
@@ -140,7 +144,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
R.setOffset(10);
@@ -154,7 +158,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
R.setOffset(6);
@@ -168,7 +172,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
EXPECT_ERROR(R.readFixedString(Str, 11));
@@ -181,7 +185,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str;
EXPECT_NO_ERROR(R.readFixedString(Str, 1));
EXPECT_EQ(Str, StringRef("A"));
@@ -195,7 +199,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str1;
StringRef Str2;
EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
@@ -216,7 +220,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
DiscontiguousStream F(BlocksAry, DataAry);
auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
F.layout(), F);
- StreamReader R(*S);
+ BinaryStreamReader R(*S);
StringRef Str1;
StringRef Str2;
EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
@@ -323,8 +327,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) {
uint32_t intArr1[] = {890723408, 29082234};
ArrayRef<uint32_t> intArray[] = {intArr0, intArr1};
- StreamReader Reader(*S);
- StreamWriter Writer(*S);
+ BinaryStreamReader Reader(*S);
+ BinaryStreamWriter Writer(*S);
EXPECT_NO_ERROR(Writer.writeInteger(u16[0]));
EXPECT_NO_ERROR(Reader.readInteger(u16[1]));
EXPECT_EQ(u16[0], u16[1]);
@@ -352,8 +356,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) {
Reader.setOffset(0);
Writer.setOffset(0);
::memset(DataBytes.data(), 0, 10);
- EXPECT_NO_ERROR(Writer.writeZeroString(ZStr[0]));
- EXPECT_NO_ERROR(Reader.readZeroString(ZStr[1]));
+ EXPECT_NO_ERROR(Writer.writeCString(ZStr[0]));
+ EXPECT_NO_ERROR(Reader.readCString(ZStr[1]));
EXPECT_EQ(ZStr[0], ZStr[1]);
EXPECT_EQ(
std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}),
@@ -399,22 +403,22 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
F.block_size(), F.block_count(), F.layout(), F);
// First write "Test Str" into the source stream.
- MutableByteStream SourceStream(SrcData);
- StreamWriter SourceWriter(SourceStream);
- EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
+ MutableBinaryByteStream SourceStream(SrcData, little);
+ BinaryStreamWriter SourceWriter(SourceStream);
+ EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str"));
EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
{'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0}));
// Then write the source stream into the dest stream.
- StreamWriter DestWriter(*DestStream);
+ BinaryStreamWriter DestWriter(*DestStream);
EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream));
EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
{'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
// Then read the string back out of the dest stream.
StringRef Result;
- StreamReader DestReader(*DestStream);
- EXPECT_NO_ERROR(DestReader.readZeroString(Result));
+ BinaryStreamReader DestReader(*DestStream);
+ EXPECT_NO_ERROR(DestReader.readCString(Result));
EXPECT_EQ(Result, "Test Str");
}
@@ -436,21 +440,21 @@ TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) {
SrcF.block_size(), SrcF.block_count(), SrcF.layout(), SrcF);
// First write "Test Str" into the source stream.
- StreamWriter SourceWriter(*Src);
- EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
+ BinaryStreamWriter SourceWriter(*Src);
+ EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str"));
EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
{'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0}));
// Then write the source stream into the dest stream.
- StreamWriter DestWriter(*Dest);
+ BinaryStreamWriter DestWriter(*Dest);
EXPECT_NO_ERROR(DestWriter.writeStreamRef(*Src));
EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
{'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
// Then read the string back out of the dest stream.
StringRef Result;
- StreamReader DestReader(*Dest);
- EXPECT_NO_ERROR(DestReader.readZeroString(Result));
+ BinaryStreamReader DestReader(*Dest);
+ EXPECT_NO_ERROR(DestReader.readCString(Result));
EXPECT_EQ(Result, "Test Str");
}
diff --git a/unittests/DebugInfo/PDB/PDBApiTest.cpp b/unittests/DebugInfo/PDB/PDBApiTest.cpp
index cd0f928a08ab..6afe83cd90dd 100644
--- a/unittests/DebugInfo/PDB/PDBApiTest.cpp
+++ b/unittests/DebugInfo/PDB/PDBApiTest.cpp
@@ -226,6 +226,7 @@ public:
MOCK_SYMBOL_ACCESSOR(getMachineType)
MOCK_SYMBOL_ACCESSOR(getThunkOrdinal)
MOCK_SYMBOL_ACCESSOR(getLength)
+ MOCK_SYMBOL_ACCESSOR(getVirtualBaseTableType)
MOCK_SYMBOL_ACCESSOR(getLiveRangeLength)
MOCK_SYMBOL_ACCESSOR(getVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getUdtKind)
diff --git a/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp b/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
new file mode 100644
index 000000000000..7c4838778e43
--- /dev/null
+++ b/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
@@ -0,0 +1,55 @@
+//===- StringTableBuilderTest.cpp -----------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ErrorChecking.h"
+
+#include "llvm/DebugInfo/PDB/Native/StringTable.h"
+#include "llvm/DebugInfo/PDB/Native/StringTableBuilder.h"
+#include "llvm/Support/BinaryByteStream.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+using namespace llvm::support;
+
+namespace {
+class StringTableBuilderTest : public ::testing::Test {};
+}
+
+TEST_F(StringTableBuilderTest, Simple) {
+ // Create /names table contents.
+ StringTableBuilder Builder;
+ EXPECT_EQ(1U, Builder.insert("foo"));
+ EXPECT_EQ(5U, Builder.insert("bar"));
+ EXPECT_EQ(1U, Builder.insert("foo"));
+ EXPECT_EQ(9U, Builder.insert("baz"));
+
+ std::vector<uint8_t> Buffer(Builder.finalize());
+ MutableBinaryByteStream OutStream(Buffer, little);
+ BinaryStreamWriter Writer(OutStream);
+ EXPECT_NO_ERROR(Builder.commit(Writer));
+
+ // Reads the contents back.
+ BinaryByteStream InStream(Buffer, little);
+ BinaryStreamReader Reader(InStream);
+ StringTable Table;
+ EXPECT_NO_ERROR(Table.load(Reader));
+
+ EXPECT_EQ(3U, Table.getNameCount());
+ EXPECT_EQ(1U, Table.getHashVersion());
+ EXPECT_EQ("foo", Table.getStringForID(1));
+ EXPECT_EQ("bar", Table.getStringForID(5));
+ EXPECT_EQ("baz", Table.getStringForID(9));
+ EXPECT_EQ(1U, Table.getIDForString("foo"));
+ EXPECT_EQ(5U, Table.getIDForString("bar"));
+ EXPECT_EQ(9U, Table.getIDForString("baz"));
+}
diff --git a/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp b/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp
new file mode 100644
index 000000000000..6995e8f9dded
--- /dev/null
+++ b/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp
@@ -0,0 +1,175 @@
+//===- llvm/unittest/DebugInfo/PDB/TypeServerHandlerTest.cpp --------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ErrorChecking.h"
+
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
+#include "llvm/DebugInfo/CodeView/TypeSerializer.h"
+#include "llvm/DebugInfo/CodeView/TypeServerHandler.h"
+#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/DebugInfo/PDB/Native/RawTypes.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Error.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+namespace {
+
+constexpr uint8_t Guid[] = {0x2a, 0x2c, 0x1c, 0x2a, 0xcb, 0x9e, 0x48, 0x18,
+ 0x82, 0x82, 0x7a, 0x87, 0xc3, 0xfe, 0x16, 0xe8};
+StringRef GuidStr(reinterpret_cast<const char *>(Guid),
+ llvm::array_lengthof(Guid));
+
+constexpr const char *Name = "Test Name";
+constexpr int Age = 1;
+
+class MockTypeServerHandler : public TypeServerHandler {
+public:
+ explicit MockTypeServerHandler(bool HandleAlways)
+ : HandleAlways(HandleAlways) {}
+
+ Expected<bool> handle(TypeServer2Record &TS,
+ TypeVisitorCallbacks &Callbacks) override {
+ if (TS.Age != Age || TS.Guid != GuidStr || TS.Name != Name)
+ return make_error<CodeViewError>(cv_error_code::corrupt_record,
+ "Invalid TypeServer record!");
+
+ if (Handled && !HandleAlways)
+ return false;
+
+ Handled = true;
+ return true;
+ }
+
+ bool Handled = false;
+ bool HandleAlways;
+};
+
+class MockTypeVisitorCallbacks : public TypeVisitorCallbacks {
+public:
+ enum class State {
+ Ready,
+ VisitTypeBegin,
+ VisitKnownRecord,
+ VisitTypeEnd,
+ };
+ Error visitTypeBegin(CVType &CVT) override {
+ if (S != State::Ready)
+ return make_error<CodeViewError>(cv_error_code::unspecified,
+ "Invalid visitor state!");
+
+ S = State::VisitTypeBegin;
+ return Error::success();
+ }
+
+ Error visitKnownRecord(CVType &CVT, TypeServer2Record &TS) override {
+ if (S != State::VisitTypeBegin)
+ return make_error<CodeViewError>(cv_error_code::unspecified,
+ "Invalid visitor state!");
+
+ S = State::VisitKnownRecord;
+ return Error::success();
+ }
+
+ Error visitTypeEnd(CVType &CVT) override {
+ if (S != State::VisitKnownRecord)
+ return make_error<CodeViewError>(cv_error_code::unspecified,
+ "Invalid visitor state!");
+
+ S = State::VisitTypeEnd;
+ return Error::success();
+ }
+
+ State S = State::Ready;
+};
+
+class TypeServerHandlerTest : public testing::Test {
+public:
+ void SetUp() override {
+ TypeServer2Record R(TypeRecordKind::TypeServer2);
+ R.Age = Age;
+ R.Guid = GuidStr;
+ R.Name = Name;
+
+ TypeTableBuilder Builder(Allocator);
+ Builder.writeKnownType(R);
+ TypeServerRecord.RecordData = Builder.records().front();
+ TypeServerRecord.Type = TypeLeafKind::LF_TYPESERVER2;
+ }
+
+protected:
+ BumpPtrAllocator Allocator;
+ CVType TypeServerRecord;
+};
+
+// Test that when no type server handler is registered, it gets handled by the
+// normal
+// visitor callbacks.
+TEST_F(TypeServerHandlerTest, VisitRecordNoTypeServer) {
+ MockTypeVisitorCallbacks C2;
+ MockTypeVisitorCallbacks C1;
+ TypeVisitorCallbackPipeline Pipeline;
+
+ Pipeline.addCallbackToPipeline(C1);
+ Pipeline.addCallbackToPipeline(C2);
+ CVTypeVisitor Visitor(Pipeline);
+ EXPECT_NO_ERROR(Visitor.visitTypeRecord(TypeServerRecord));
+
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C1.S);
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C2.S);
+}
+
+// Test that when a TypeServerHandler is registered, it gets consumed by the
+// handler if and only if the handler returns true.
+TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerOnce) {
+ MockTypeServerHandler Handler(false);
+
+ MockTypeVisitorCallbacks C1;
+ CVTypeVisitor Visitor(C1);
+ Visitor.addTypeServerHandler(Handler);
+
+ // Our mock server returns true the first time.
+ EXPECT_NO_ERROR(Visitor.visitTypeRecord(TypeServerRecord));
+ EXPECT_TRUE(Handler.Handled);
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
+
+ // And false the second time.
+ EXPECT_NO_ERROR(Visitor.visitTypeRecord(TypeServerRecord));
+ EXPECT_TRUE(Handler.Handled);
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C1.S);
+}
+
+// Test that when a type server handler is registered, if the handler keeps
+// returning true, it will keep getting consumed by the handler and not go
+// to the default processor.
+TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerAlways) {
+ MockTypeServerHandler Handler(true);
+
+ MockTypeVisitorCallbacks C1;
+ CVTypeVisitor Visitor(C1);
+ Visitor.addTypeServerHandler(Handler);
+
+ EXPECT_NO_ERROR(Visitor.visitTypeRecord(TypeServerRecord));
+ EXPECT_TRUE(Handler.Handled);
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
+
+ EXPECT_NO_ERROR(Visitor.visitTypeRecord(TypeServerRecord));
+ EXPECT_TRUE(Handler.Handled);
+ EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
+}
+
+} // end anonymous namespace
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-25 09:50:37 +0000