[Test][DebugInfo] Check for backend object emission support.

[nigelp-xmos]

Summary

The XCore backend does not support object emission. Several tests fail for this
reason when XCore is the default target. See staging buildbot builder:
clang-xcore-ubuntu-20-x64.

So check for backend object emission before running the tests requiring it.

[nigelp-xmos]

Run clang-format

[labath]

@jhenderson is probably the best person for this, but my suggestion would be to avoid the need to query both isConfigurationSupported and supportsObjectEmission everywhere. Having the latter subsume the former should make things simpler and still be understandable, I think.

[nigelp-xmos]

@labath Thanks for the quick response. That looks like a good idea. I will try that.

[nigelp-xmos]

• Incorporate isConfigurationSupported in isObjectEmissionSupported

[clayborg]

Looks good to me, probably best to get an ok from someone else as well.

[nigelp-xmos]

Thanks @clayborg

[jhenderson]

Looks reasonable to me, with one possible nit.

llvm/unittests/DebugInfo/DWARF/DwarfUtils.cpp

50

Is this still in use anywhere? If not, you can delete it (and the declaration in the header).

[nigelp-xmos]

llvm/unittests/DebugInfo/DWARF/DwarfUtils.cpp

50

Yes, isConfigurationSupported is used in two places that don't need to check for object emission. Thank you for the review!

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 //===- llvm/unittest/DebugInfo/DWARFDebugInfoTest.cpp ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 
 namespace {
 
 template <uint16_t Version, class AddrType, class RefAddrType>
 void TestAllForms() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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;
   const uint16_t Data2 = 0x2345U;
TEST(DWARFDebugInfo, TestDWARF32Version5Addr8AllForms) {
   typedef uint32_t RefAddrType;
   TestAllForms<5, AddrType, RefAddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestChildren() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) {
   typedef uint64_t AddrType;
   TestChildren<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestReferences() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
 
TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) {
   typedef uint64_t AddrType;
   TestReferences<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestAddresses() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Addresses) {
   typedef uint64_t AddrType;
   TestAddresses<4, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestStringOffsets) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestStringOffsets) {
   ASSERT_TRUE((bool)Extracted3);
   EXPECT_STREQ(String1, *Extracted3);
 }
 
 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::DIE CUDie = CU.getUnitDIE();
TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   EXPECT_TRUE(
       DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty());
 }
 
 TEST(DWARFDebugInfo, TestRelations) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestDWARFDie) {
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
 TEST(DWARFDebugInfo, TestChildIterators) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestEmptyChildren) {
   // see the Null DIEs during iteration.
   EXPECT_EQ(CUDie.begin(), CUDie.end());
 }
 
 TEST(DWARFDebugInfo, TestAttributeIterators) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestAttributeIterators) {
 
   EXPECT_EQ(E, ++I);
 }
 
 TEST(DWARFDebugInfo, TestFindRecurse) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
 
   StringRef SpecDieName = "spec";
TEST(DWARFDebugInfo, TestDwarfToFunctions) {
 
   // Test
 }
 
 TEST(DWARFDebugInfo, TestFindAttrs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestFindAttrs) {
   EXPECT_TRUE(NameOpt.hasValue());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 
 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
     return;
+  if (!supportsObjectEmission(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();
   const dwarf::Attribute Attr = DW_AT_lo_user;

llvm/unittests/DebugInfo/DWARF/DwarfUtils.h

 //===--- unittests/DebugInfo/DWARF/DwarfUtils.h -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFUTILS_H
 #define LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFUTILS_H
 
 #include <cstdint>
 
 namespace llvm {
 
 class Triple;
 
 namespace dwarf {
 namespace utils {
 
 Triple getDefaultTargetTripleForAddrSize(uint8_t AddrSize);
 Triple getNormalizedDefaultTargetTriple();
 bool isConfigurationSupported(Triple &T);
+bool supportsObjectEmission(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

 //===--- 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
 //
 //===----------------------------------------------------------------------===//
 
Triple llvm::dwarf::utils::getDefaultTargetTripleForAddrSize(uint8_t AddrSize) {
   // 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);
 }
+
+bool llvm::dwarf::utils::supportsObjectEmission(Triple &T) {
+  std::string ErrorStr;
+  std::string TripleName;
+  const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, T, ErrorStr);
+  return TheTarget->hasMCAsmBackend();
+}