[unittest][DebugInfo/DWARF] Do not create dwarfgen::Generator if MCAsmBackend is missing

[ikudrin]

Summary

dwarfgen::Generator cannot be created if there is no asm backend for a target. For example, if the default target triple is nvptx-nvidia-cuda, some tests fail even after D98400, which added checks for most cases. This patch extends the approach to the remaining cases.

[dblaikie]

Is this accurate? Do all uses of DWARFUtils need the asm emission? I'd have thought the DWARFGenerator would mostly be used to go straight to machine code, without assembly?

[ikudrin]

In D116107#3205043, @dblaikie wrote:

Is this accurate? Do all uses of DWARFUtils need the asm emission? I'd have thought the DWARFGenerator would mostly be used to go straight to machine code, without assembly?

The generator requires the assembler internally, see dwarfgen::Generator::generate(). dwarfgen::Generator::init() creates MCAsmBackend and fails if the asm backend is not available.

After D98400, there are only two places where isConfigurationSupported() is still called, but right after the check, dwarfgen::Generator is created.

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 using namespace utils;
 using ::testing::HasSubstr;
 
 namespace {
 
 template <uint16_t Version, class AddrType, class RefAddrType>
 void TestAllForms() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
-  if (!isObjectEmissionSupported(Triple))
+  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;
   const uint8_t Data1 = 0x01U;
#endif
   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 = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
-  if (!isObjectEmissionSupported(Triple))
+  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);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
#endif
   // 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 = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
-  if (!isObjectEmissionSupported(Triple))
+  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();
   dwarfgen::CompileUnit &CU2 = DG->addCompileUnit();
#endif
   // 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 = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
-  if (!isObjectEmissionSupported(Triple))
+  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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();

 }
 
 #ifdef _AIX
 TEST(DWARFDebugInfo, DISABLED_TestStringOffsets) {
 #else
 TEST(DWARFDebugInfo, TestStringOffsets) {
 #endif
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  if (!isConfigurationSupported(Triple))
     return;
 
   const char *String1 = "Hello";
   const char *String2 = "World";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
#endif
   EXPECT_EQ(1u, Form3->getRawUValue());
   auto Extracted3 = toString(Form3);
   ASSERT_TRUE((bool)Extracted3);
   EXPECT_STREQ(String1, *Extracted3);
 }
 
 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   ASSERT_TRUE((bool)Obj);
   std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
   EXPECT_TRUE(
       DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty());
 }
 
 TEST(DWARFDebugInfo, TestRelations) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestDWARFDie) {
   DWARFDie DefaultDie;
   EXPECT_FALSE(DefaultDie.getParent().isValid());
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
 TEST(DWARFDebugInfo, TestChildIterators) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
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 = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestAttributeIterators) {
   EXPECT_EQ(I->Attr, DW_AT_low_pc);
   EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
 
   EXPECT_EQ(E, ++I);
 }
 
 TEST(DWARFDebugInfo, TestFindRecurse) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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, toSectionOffset(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
 
   // Test
 }
 
 TEST(DWARFDebugInfo, TestFindAttrs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestFindAttrs) {
   // DW_AT_specification DIE.
   auto NameOpt = FuncDie.findRecursively(Attrs);
   EXPECT_TRUE(NameOpt.hasValue());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 
 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
-  if (!isObjectEmissionSupported(Triple))
+  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();
   dwarfgen::DIE CUDie = CU.getUnitDIE();

llvm/unittests/DebugInfo/DWARF/DWARFDieManualExtractTest.cpp

 using namespace utils;
 
 namespace {
 
 TEST(DWARFDie, manualExtractDump) {
   typedef uint32_t AddrType;
   uint16_t Version = 4;
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
-  if (!isObjectEmissionSupported(Triple))
+  if (!isConfigurationSupported(Triple))
     return;
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &DGCU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = DGCU.getUnitDIE();
 

llvm/unittests/DebugInfo/DWARF/DwarfUtils.h

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

llvm/unittests/DebugInfo/DWARF/DwarfUtils.cpp

Triple llvm::dwarf::utils::getDefaultTargetTripleForAddrSize(uint8_t AddrSize) {
   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);
-}
-
-bool llvm::dwarf::utils::isObjectEmissionSupported(Triple &T) {
-  initLLVMIfNeeded();
-  std::string Err;
   const Target *TheTarget = TargetRegistry::lookupTarget(T.getTriple(), Err);
   return TheTarget && TheTarget->hasMCAsmBackend();
 }