Fix DWARF DebugInfo unit test errors when cross-compiling

[daltenty]

Summary

When building with a Default Target set we can experience issues in the DWARF DebugInfo unit tests because:

• They assume we can generate object files for the host platform
• Some tests assume the endianess of the target we are generating DWARF for and the host match

This patch correct these issues by ensuring the tests which generate objects in memory are run with respect to LVM_DEFAULT_TARGET_TRIPLE and it's
endianess. We also make sure we don't use the hosts address size for line test and split the triple util function in DwarfUtils into a version that takes an address size and one that doesn't.

See also for discussion: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131212.html

[hubert.reinterpretcast]

For implementing the direction discussed on the referenced thread, the changes look correct to me.

[probinson]

Looks like the right solution, but have you actually tried it with an empty default triple?

llvm/unittests/DebugInfo/DWARF/DwarfUtils.cpp

28 ↗

(On Diff #200097)

I think getDefaultTargetTriple would be a better name here.

[daltenty]

Respond to comments round 1.

If LLVM_DEFAULT_TARGET_TRIPLE is set to empty, cmake will not define it due to the behavior of configure_file, so the fallback behavior in this patch needs to be corrected.

Rather than trying to guess a fall back for these empty triple situations (some existing tests do not handle this anyway), I've update the patch to rely on the functionality of sys::getDefaultTargetTriple().

This brings us in line with other tests and allows selection of a test triple with the LLVM_TARGET_TRIPLE_ENV functionality (introduced in D33662). Thus in cases where an empty LLVM_DEFAULT_TARGET_TRIPLE is specified at configuration time, running the tests with LLVM_TARGET_TRIPLE_ENV is required.

[hubert.reinterpretcast]

@probinson, does this look good now?

[probinson]

LGTM

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 using namespace llvm;
 using namespace dwarf;
 using namespace utils;
 
 namespace {
 
 template <uint16_t Version, class AddrType, class RefAddrType>
 void TestAllForms() {
-  Triple Triple = getHostTripleForAddrSize(sizeof(AddrType));
+  Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test that we can decode all DW_FORM values correctly.
   const AddrType AddrValue = (AddrType)0x0123456789abcdefULL;
   const uint8_t BlockData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
   const uint32_t BlockSize = sizeof(BlockData);
   const RefAddrType RefAddr = 0x12345678;
TEST(DWARFDebugInfo, TestDWARF32Version5Addr8AllForms) {
   // addresses.
   typedef uint64_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<5, AddrType, RefAddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestChildren() {
-  Triple Triple = getHostTripleForAddrSize(sizeof(AddrType));
+  Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with
   // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using
   // 8 byte addresses.
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);

 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) {
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestChildren<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestReferences() {
-  Triple Triple = getHostTripleForAddrSize(sizeof(AddrType));
+  Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test that we can decode DW_FORM_refXXX values correctly in DWARF.
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU1 = DG->addCompileUnit();

 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) {
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestReferences<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestAddresses() {
-  Triple Triple = getHostTripleForAddrSize(sizeof(AddrType));
+  Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   const bool SupportsHighPCAsOffset = Version >= 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());

 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Addresses) {
   // Test that we can decode address values in DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestAddresses<4, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestStringOffsets) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   const char *String1 = "Hello";
   const char *String2 = "World";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
TEST(DWARFDebugInfo, TestStringOffsets) {
   ASSERT_TRUE((bool)Form3);
   EXPECT_EQ(1u, Form3->getRawUValue());
   auto Extracted3 = toString(Form3);
   ASSERT_TRUE((bool)Extracted3);
   EXPECT_STREQ(String1, *Extracted3);
 }
 
 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   const char *String1 = "Hello";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   ASSERT_TRUE((bool)Obj);
   std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
   EXPECT_TRUE(
       DwarfContext->getDWARFObj().getStringOffsetSection().Data.empty());
 }
 
 TEST(DWARFDebugInfo, TestRelations) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
TEST(DWARFDebugInfo, TestDWARFDie) {
   // or child;
   DWARFDie DefaultDie;
   EXPECT_FALSE(DefaultDie.getParent().isValid());
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
 TEST(DWARFDebugInfo, TestChildIterators) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test the DWARF APIs related to iterating across the children of a DIE using
   // the DWARFDie::iterator class.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
TEST(DWARFDebugInfo, TestEmptyChildren) {
 
   // 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) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test the DWARF APIs related to iterating across all attribute values in a
   // a DWARFDie.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
TEST(DWARFDebugInfo, TestAttributeIterators) {
   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) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
 
   // Test
 }
 
 TEST(DWARFDebugInfo, TestFindAttrs) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
   // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
TEST(DWARFDebugInfo, TestFindAttrs) {
   // 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) {
-  Triple Triple = getHostTripleForAddrSize(sizeof(void *));
+  Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
 
   uint16_t Version = 5;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

CommonFixture()
                                       std::placeholders::_1)){};
 
   ~CommonFixture() {
     EXPECT_FALSE(Recoverable);
     EXPECT_FALSE(Unrecoverable);
   }
 
   bool setupGenerator(uint16_t Version = 4) {
-    Triple T = getHostTripleForAddrSize(8);
+    Triple T = getDefaultTargetTripleForAddrSize(8);
     if (!isConfigurationSupported(T))
       return false;
     auto ExpectedGenerator = Generator::create(T, Version);
     if (ExpectedGenerator)
       Gen.reset(ExpectedGenerator->release());
     return true;
   }
 
   void generate() {
     Context = createContext();
     assert(Context != nullptr && "test state is not valid");
     const DWARFObject &Obj = Context->getDWARFObj();
-    LineData = DWARFDataExtractor(Obj, Obj.getLineSection(),
-                                  sys::IsLittleEndianHost, 8);
+    LineData = DWARFDataExtractor(
+        Obj, Obj.getLineSection(),
+        getDefaultTargetTripleForAddrSize(8).isLittleEndian(), 8);
   }
 
   std::unique_ptr<DWARFContext> createContext() {
     if (!Gen)
       return nullptr;
     StringRef FileBytes = Gen->generate();
     MemoryBufferRef FileBuffer(FileBytes, "dwarf");
     auto Obj = object::ObjectFile::createObjectFile(FileBuffer);

llvm/trunk/unittests/DebugInfo/DWARF/DwarfUtils.h

 
 namespace llvm {
 
 class Triple;
 
 namespace dwarf {
 namespace utils {
 
-Triple getHostTripleForAddrSize(uint8_t AddrSize);
+Triple getDefaultTargetTripleForAddrSize(uint8_t AddrSize);
+Triple getNormalizedDefaultTargetTriple();
 bool isConfigurationSupported(Triple &T);
 
 } // end namespace utils
 } // end namespace dwarf
 } // end namespace llvm
 
 #endif // LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFUTILS_H

llvm/trunk/unittests/DebugInfo/DWARF/DwarfUtils.cpp

 //===--- unittests/DebugInfo/DWARF/DwarfUtils.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfUtils.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace llvm;
 
 static void initLLVMIfNeeded() {
   static bool gInitialized = false;
   if (!gInitialized) {
     gInitialized = true;
     InitializeAllTargets();
     InitializeAllTargetMCs();
     InitializeAllAsmPrinters();
     InitializeAllAsmParsers();
   }
 }
 
-Triple llvm::dwarf::utils::getHostTripleForAddrSize(uint8_t AddrSize) {
-  Triple T(Triple::normalize(LLVM_HOST_TRIPLE));
+Triple llvm::dwarf::utils::getNormalizedDefaultTargetTriple() {
+  Triple T(Triple::normalize(sys::getDefaultTargetTriple()));
 
+  return T;
+}
+
+Triple llvm::dwarf::utils::getDefaultTargetTripleForAddrSize(uint8_t AddrSize) {
+  Triple T = getNormalizedDefaultTargetTriple();
+
+  assert((AddrSize == 4 || AddrSize == 8) &&
+         "Only 32-bit/64-bit address size variants are supported");
+
+  // If a 32-bit/64-bit address size was specified, try to convert the triple
+  // if it is for the wrong variant.
   if (AddrSize == 8 && T.isArch32Bit())
     return T.get64BitArchVariant();
   if (AddrSize == 4 && T.isArch64Bit())
     return T.get32BitArchVariant();
   return T;
 }
 
 bool llvm::dwarf::utils::isConfigurationSupported(Triple &T) {
   initLLVMIfNeeded();
   std::string Err;
   return TargetRegistry::lookupTarget(T.getTriple(), Err);
 }