| //===- unittest/BinaryFormat/DwarfTest.cpp - Dwarf support tests ----------===// |
| // |
| // 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 "llvm/BinaryFormat/Dwarf.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/Support/FormatVariadic.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| using namespace llvm::dwarf; |
| |
| namespace { |
| |
| TEST(DwarfTest, TagStringOnInvalid) { |
| // This is invalid, so it shouldn't be stringified. |
| EXPECT_EQ(StringRef(), TagString(DW_TAG_invalid)); |
| |
| // These aren't really tags: they describe ranges within tags. They |
| // shouldn't be stringified either. |
| EXPECT_EQ(StringRef(), TagString(DW_TAG_lo_user)); |
| EXPECT_EQ(StringRef(), TagString(DW_TAG_hi_user)); |
| EXPECT_EQ(StringRef(), TagString(DW_TAG_user_base)); |
| } |
| |
| TEST(DwarfTest, getTag) { |
| // A couple of valid tags. |
| EXPECT_EQ(DW_TAG_array_type, getTag("DW_TAG_array_type")); |
| EXPECT_EQ(DW_TAG_module, getTag("DW_TAG_module")); |
| |
| // Invalid tags. |
| EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_invalid")); |
| EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_madeuptag")); |
| EXPECT_EQ(DW_TAG_invalid, getTag("something else")); |
| |
| // Tag range markers should not be recognized. |
| EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_lo_user")); |
| EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_hi_user")); |
| EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_user_base")); |
| } |
| |
| TEST(DwarfTest, getOperationEncoding) { |
| // Some valid ops. |
| EXPECT_EQ(DW_OP_deref, getOperationEncoding("DW_OP_deref")); |
| EXPECT_EQ(DW_OP_bit_piece, getOperationEncoding("DW_OP_bit_piece")); |
| |
| // Invalid ops. |
| EXPECT_EQ(0u, getOperationEncoding("DW_OP_otherthings")); |
| EXPECT_EQ(0u, getOperationEncoding("other")); |
| |
| // Markers shouldn't be recognized. |
| EXPECT_EQ(0u, getOperationEncoding("DW_OP_lo_user")); |
| EXPECT_EQ(0u, getOperationEncoding("DW_OP_hi_user")); |
| } |
| |
| TEST(DwarfTest, LanguageStringOnInvalid) { |
| // This is invalid, so it shouldn't be stringified. |
| EXPECT_EQ(StringRef(), LanguageString(0)); |
| |
| // These aren't really tags: they describe ranges within tags. They |
| // shouldn't be stringified either. |
| EXPECT_EQ(StringRef(), LanguageString(DW_LANG_lo_user)); |
| EXPECT_EQ(StringRef(), LanguageString(DW_LANG_hi_user)); |
| } |
| |
| TEST(DwarfTest, getLanguage) { |
| // A couple of valid languages. |
| EXPECT_EQ(DW_LANG_C89, getLanguage("DW_LANG_C89")); |
| EXPECT_EQ(DW_LANG_C_plus_plus_11, getLanguage("DW_LANG_C_plus_plus_11")); |
| EXPECT_EQ(DW_LANG_OCaml, getLanguage("DW_LANG_OCaml")); |
| EXPECT_EQ(DW_LANG_Mips_Assembler, getLanguage("DW_LANG_Mips_Assembler")); |
| |
| // Invalid languages. |
| EXPECT_EQ(0u, getLanguage("DW_LANG_invalid")); |
| EXPECT_EQ(0u, getLanguage("DW_TAG_array_type")); |
| EXPECT_EQ(0u, getLanguage("something else")); |
| |
| // Language range markers should not be recognized. |
| EXPECT_EQ(0u, getLanguage("DW_LANG_lo_user")); |
| EXPECT_EQ(0u, getLanguage("DW_LANG_hi_user")); |
| } |
| |
| TEST(DwarfTest, AttributeEncodingStringOnInvalid) { |
| // This is invalid, so it shouldn't be stringified. |
| EXPECT_EQ(StringRef(), AttributeEncodingString(0)); |
| |
| // These aren't really tags: they describe ranges within tags. They |
| // shouldn't be stringified either. |
| EXPECT_EQ(StringRef(), AttributeEncodingString(DW_ATE_lo_user)); |
| EXPECT_EQ(StringRef(), AttributeEncodingString(DW_ATE_hi_user)); |
| } |
| |
| TEST(DwarfTest, getAttributeEncoding) { |
| // A couple of valid languages. |
| EXPECT_EQ(DW_ATE_boolean, getAttributeEncoding("DW_ATE_boolean")); |
| EXPECT_EQ(DW_ATE_imaginary_float, |
| getAttributeEncoding("DW_ATE_imaginary_float")); |
| |
| // Invalid languages. |
| EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_invalid")); |
| EXPECT_EQ(0u, getAttributeEncoding("DW_TAG_array_type")); |
| EXPECT_EQ(0u, getAttributeEncoding("something else")); |
| |
| // AttributeEncoding range markers should not be recognized. |
| EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_lo_user")); |
| EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_hi_user")); |
| } |
| |
| TEST(DwarfTest, VirtualityString) { |
| EXPECT_EQ(StringRef("DW_VIRTUALITY_none"), |
| VirtualityString(DW_VIRTUALITY_none)); |
| EXPECT_EQ(StringRef("DW_VIRTUALITY_virtual"), |
| VirtualityString(DW_VIRTUALITY_virtual)); |
| EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"), |
| VirtualityString(DW_VIRTUALITY_pure_virtual)); |
| |
| // DW_VIRTUALITY_max should be pure virtual. |
| EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"), |
| VirtualityString(DW_VIRTUALITY_max)); |
| |
| // Invalid numbers shouldn't be stringified. |
| EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 1)); |
| EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 77)); |
| } |
| |
| TEST(DwarfTest, getVirtuality) { |
| EXPECT_EQ(DW_VIRTUALITY_none, getVirtuality("DW_VIRTUALITY_none")); |
| EXPECT_EQ(DW_VIRTUALITY_virtual, getVirtuality("DW_VIRTUALITY_virtual")); |
| EXPECT_EQ(DW_VIRTUALITY_pure_virtual, |
| getVirtuality("DW_VIRTUALITY_pure_virtual")); |
| |
| // Invalid strings. |
| EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_invalid")); |
| EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_max")); |
| EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("something else")); |
| } |
| |
| TEST(DwarfTest, FixedFormSizes) { |
| std::optional<uint8_t> RefSize; |
| std::optional<uint8_t> AddrSize; |
| |
| // Test 32 bit DWARF version 2 with 4 byte addresses. |
| FormParams Params_2_4_32 = {2, 4, DWARF32}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32); |
| AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_TRUE(AddrSize.has_value()); |
| EXPECT_EQ(*RefSize, *AddrSize); |
| |
| // Test 32 bit DWARF version 2 with 8 byte addresses. |
| FormParams Params_2_8_32 = {2, 8, DWARF32}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32); |
| AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_TRUE(AddrSize.has_value()); |
| EXPECT_EQ(*RefSize, *AddrSize); |
| |
| // DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond. |
| FormParams Params_3_4_32 = {3, 4, DWARF32}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_4_32); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 4); |
| |
| FormParams Params_4_4_32 = {4, 4, DWARF32}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_4_32); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 4); |
| |
| FormParams Params_5_4_32 = {5, 4, DWARF32}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_4_32); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 4); |
| |
| // DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond. |
| FormParams Params_3_8_64 = {3, 8, DWARF64}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_8_64); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 8); |
| |
| FormParams Params_4_8_64 = {4, 8, DWARF64}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_8_64); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 8); |
| |
| FormParams Params_5_8_64 = {5, 8, DWARF64}; |
| RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_8_64); |
| EXPECT_TRUE(RefSize.has_value()); |
| EXPECT_EQ(*RefSize, 8); |
| } |
| |
| TEST(DwarfTest, format_provider) { |
| EXPECT_EQ("DW_AT_name", formatv("{0}", DW_AT_name).str()); |
| EXPECT_EQ("DW_AT_unknown_3fff", formatv("{0}", DW_AT_hi_user).str()); |
| EXPECT_EQ("DW_FORM_addr", formatv("{0}", DW_FORM_addr).str()); |
| EXPECT_EQ("DW_FORM_unknown_1f00", formatv("{0}", DW_FORM_lo_user).str()); |
| EXPECT_EQ("DW_IDX_compile_unit", formatv("{0}", DW_IDX_compile_unit).str()); |
| EXPECT_EQ("DW_IDX_unknown_3fff", formatv("{0}", DW_IDX_hi_user).str()); |
| EXPECT_EQ("DW_TAG_compile_unit", formatv("{0}", DW_TAG_compile_unit).str()); |
| EXPECT_EQ("DW_TAG_unknown_ffff", formatv("{0}", DW_TAG_hi_user).str()); |
| EXPECT_EQ("DW_OP_lit0", formatv("{0}", DW_OP_lit0).str()); |
| EXPECT_EQ("DW_OP_unknown_ff", formatv("{0}", DW_OP_hi_user).str()); |
| } |
| |
| TEST(DwarfTest, lname) { |
| auto roundtrip = [](llvm::dwarf::SourceLanguage sl) { |
| auto name_version = toDW_LNAME(sl); |
| // Ignore ones without a defined mapping. |
| if (sl == DW_LANG_Mips_Assembler || sl == DW_LANG_GOOGLE_RenderScript || |
| !name_version.has_value()) |
| return sl; |
| return dwarf::toDW_LANG(name_version->first, name_version->second) |
| .value_or(sl); |
| }; |
| #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
| EXPECT_EQ(roundtrip(DW_LANG_##NAME), DW_LANG_##NAME); |
| #include "llvm/BinaryFormat/Dwarf.def" |
| } |
| |
| TEST(DwarfTest, lname_getSourceLanguageName) { |
| // Some basics. |
| EXPECT_EQ(getSourceLanguageName("DW_LNAME_Ada"), DW_LNAME_Ada); |
| EXPECT_EQ(getSourceLanguageName("DW_LNAME_Metal"), DW_LNAME_Metal); |
| |
| // Test invalid input. |
| EXPECT_EQ(getSourceLanguageName(""), 0U); |
| EXPECT_EQ(getSourceLanguageName("blah"), 0U); |
| EXPECT_EQ(getSourceLanguageName("DW_LNAME__something_unlikely"), 0U); |
| EXPECT_EQ(getSourceLanguageName("DW_LANG_C"), 0U); |
| |
| // Test that we cover all DW_LNAME_ names. |
| #define xstr(X) #X |
| #define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \ |
| EXPECT_EQ(getSourceLanguageName(xstr(DW_LNAME_##NAME)), DW_LNAME_##NAME); |
| #include "llvm/BinaryFormat/Dwarf.def" |
| } |
| |
| TEST(DwarfTest, lname_SourceLanguageNameString) { |
| // Some basics. |
| EXPECT_EQ(SourceLanguageNameString(DW_LNAME_C_plus_plus), |
| "DW_LNAME_C_plus_plus"); |
| EXPECT_EQ(SourceLanguageNameString(DW_LNAME_CPP_for_OpenCL), |
| "DW_LNAME_CPP_for_OpenCL"); |
| |
| // Test invalid input. |
| EXPECT_EQ(SourceLanguageNameString(static_cast<SourceLanguageName>(0)), ""); |
| |
| // Test that we cover all DW_LNAME_ names. |
| #define xstr(X) #X |
| #define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \ |
| EXPECT_EQ(SourceLanguageNameString(DW_LNAME_##NAME), xstr(DW_LNAME_##NAME)); |
| #include "llvm/BinaryFormat/Dwarf.def" |
| } |
| |
| struct LanguageDescriptionTestCase { |
| llvm::dwarf::SourceLanguageName LName; |
| uint32_t LVersion; |
| llvm::StringRef ExpectedDescription; |
| }; |
| |
| LanguageDescriptionTestCase LanguageDescriptionTestCases[] = { |
| {static_cast<SourceLanguageName>(0), 0, "Unknown"}, |
| {static_cast<SourceLanguageName>(0), 1, "Unknown"}, |
| {DW_LNAME_Ada, 0, "Ada 83"}, |
| {DW_LNAME_Ada, 1982, "Ada 83"}, |
| {DW_LNAME_Ada, 1983, "Ada 83"}, |
| {DW_LNAME_Ada, 1994, "Ada 95"}, |
| {DW_LNAME_Ada, 1995, "Ada 95"}, |
| {DW_LNAME_Ada, 2004, "Ada 2005"}, |
| {DW_LNAME_Ada, 2005, "Ada 2005"}, |
| {DW_LNAME_Ada, 2011, "Ada 2012"}, |
| {DW_LNAME_Ada, 2012, "Ada 2012"}, |
| {DW_LNAME_Ada, 2013, "ISO Ada"}, |
| {DW_LNAME_Cobol, 0, "COBOL-74"}, |
| {DW_LNAME_Cobol, 1973, "COBOL-74"}, |
| {DW_LNAME_Cobol, 1974, "COBOL-74"}, |
| {DW_LNAME_Cobol, 1984, "COBOL-85"}, |
| {DW_LNAME_Cobol, 1985, "COBOL-85"}, |
| {DW_LNAME_Cobol, 1986, "ISO Cobol"}, |
| {DW_LNAME_Fortran, 0, "FORTRAN 77"}, |
| {DW_LNAME_Fortran, 1976, "FORTRAN 77"}, |
| {DW_LNAME_Fortran, 1977, "FORTRAN 77"}, |
| {DW_LNAME_Fortran, 1989, "FORTRAN 90"}, |
| {DW_LNAME_Fortran, 1990, "FORTRAN 90"}, |
| {DW_LNAME_Fortran, 1994, "Fortran 95"}, |
| {DW_LNAME_Fortran, 1995, "Fortran 95"}, |
| {DW_LNAME_Fortran, 2002, "Fortran 2003"}, |
| {DW_LNAME_Fortran, 2003, "Fortran 2003"}, |
| {DW_LNAME_Fortran, 2007, "Fortran 2008"}, |
| {DW_LNAME_Fortran, 2008, "Fortran 2008"}, |
| {DW_LNAME_Fortran, 2017, "Fortran 2018"}, |
| {DW_LNAME_Fortran, 2018, "Fortran 2018"}, |
| {DW_LNAME_Fortran, 2019, "ISO Fortran"}, |
| {DW_LNAME_C, 0, "C (K&R and ISO)"}, |
| {DW_LNAME_C, 198911, "C89"}, |
| {DW_LNAME_C, 198912, "C89"}, |
| {DW_LNAME_C, 199901, "C99"}, |
| {DW_LNAME_C, 199902, "C11"}, |
| {DW_LNAME_C, 201111, "C11"}, |
| {DW_LNAME_C, 201112, "C11"}, |
| {DW_LNAME_C, 201201, "C17"}, |
| {DW_LNAME_C, 201709, "C17"}, |
| {DW_LNAME_C, 201710, "C17"}, |
| {DW_LNAME_C, 201711, "C (K&R and ISO)"}, |
| {DW_LNAME_C_plus_plus, 0, "ISO C++"}, |
| {DW_LNAME_C_plus_plus, 199710, "C++98"}, |
| {DW_LNAME_C_plus_plus, 199711, "C++98"}, |
| {DW_LNAME_C_plus_plus, 199712, "C++03"}, |
| {DW_LNAME_C_plus_plus, 200310, "C++03"}, |
| {DW_LNAME_C_plus_plus, 200311, "C++11"}, |
| {DW_LNAME_C_plus_plus, 201102, "C++11"}, |
| {DW_LNAME_C_plus_plus, 201103, "C++11"}, |
| {DW_LNAME_C_plus_plus, 201104, "C++14"}, |
| {DW_LNAME_C_plus_plus, 201401, "C++14"}, |
| {DW_LNAME_C_plus_plus, 201402, "C++14"}, |
| {DW_LNAME_C_plus_plus, 201403, "C++17"}, |
| {DW_LNAME_C_plus_plus, 201702, "C++17"}, |
| {DW_LNAME_C_plus_plus, 201703, "C++17"}, |
| {DW_LNAME_C_plus_plus, 201704, "C++20"}, |
| {DW_LNAME_C_plus_plus, 202001, "C++20"}, |
| {DW_LNAME_C_plus_plus, 202002, "C++20"}, |
| {DW_LNAME_C_plus_plus, 202003, "ISO C++"}, |
| {DW_LNAME_ObjC_plus_plus, 0, LanguageDescription(DW_LNAME_ObjC_plus_plus)}, |
| {DW_LNAME_ObjC_plus_plus, 1, LanguageDescription(DW_LNAME_ObjC_plus_plus)}, |
| {DW_LNAME_ObjC, 0, LanguageDescription(DW_LNAME_ObjC)}, |
| {DW_LNAME_ObjC, 1, LanguageDescription(DW_LNAME_ObjC)}, |
| {DW_LNAME_Move, 0, LanguageDescription(DW_LNAME_Move)}, |
| {DW_LNAME_Move, 1, LanguageDescription(DW_LNAME_Move)}, |
| {DW_LNAME_SYCL, 0, LanguageDescription(DW_LNAME_SYCL)}, |
| {DW_LNAME_SYCL, 1, LanguageDescription(DW_LNAME_SYCL)}, |
| {DW_LNAME_BLISS, 0, LanguageDescription(DW_LNAME_BLISS)}, |
| {DW_LNAME_BLISS, 1, LanguageDescription(DW_LNAME_BLISS)}, |
| {DW_LNAME_Crystal, 0, LanguageDescription(DW_LNAME_Crystal)}, |
| {DW_LNAME_Crystal, 1, LanguageDescription(DW_LNAME_Crystal)}, |
| {DW_LNAME_D, 0, LanguageDescription(DW_LNAME_D)}, |
| {DW_LNAME_D, 1, LanguageDescription(DW_LNAME_D)}, |
| {DW_LNAME_Dylan, 0, LanguageDescription(DW_LNAME_Dylan)}, |
| {DW_LNAME_Dylan, 1, LanguageDescription(DW_LNAME_Dylan)}, |
| {DW_LNAME_Go, 0, LanguageDescription(DW_LNAME_Go)}, |
| {DW_LNAME_Go, 1, LanguageDescription(DW_LNAME_Go)}, |
| {DW_LNAME_Haskell, 0, LanguageDescription(DW_LNAME_Haskell)}, |
| {DW_LNAME_Haskell, 1, LanguageDescription(DW_LNAME_Haskell)}, |
| {DW_LNAME_HLSL, 0, LanguageDescription(DW_LNAME_HLSL)}, |
| {DW_LNAME_HLSL, 1, LanguageDescription(DW_LNAME_HLSL)}, |
| {DW_LNAME_Java, 0, LanguageDescription(DW_LNAME_Java)}, |
| {DW_LNAME_Java, 1, LanguageDescription(DW_LNAME_Java)}, |
| {DW_LNAME_Julia, 0, LanguageDescription(DW_LNAME_Julia)}, |
| {DW_LNAME_Julia, 1, LanguageDescription(DW_LNAME_Julia)}, |
| {DW_LNAME_Kotlin, 0, LanguageDescription(DW_LNAME_Kotlin)}, |
| {DW_LNAME_Kotlin, 1, LanguageDescription(DW_LNAME_Kotlin)}, |
| {DW_LNAME_Modula2, 0, LanguageDescription(DW_LNAME_Modula2)}, |
| {DW_LNAME_Modula2, 1, LanguageDescription(DW_LNAME_Modula2)}, |
| {DW_LNAME_Modula3, 0, LanguageDescription(DW_LNAME_Modula3)}, |
| {DW_LNAME_Modula3, 1, LanguageDescription(DW_LNAME_Modula3)}, |
| {DW_LNAME_OCaml, 0, LanguageDescription(DW_LNAME_OCaml)}, |
| {DW_LNAME_OCaml, 1, LanguageDescription(DW_LNAME_OCaml)}, |
| {DW_LNAME_OpenCL_C, 0, LanguageDescription(DW_LNAME_OpenCL_C)}, |
| {DW_LNAME_OpenCL_C, 1, LanguageDescription(DW_LNAME_OpenCL_C)}, |
| {DW_LNAME_Pascal, 0, LanguageDescription(DW_LNAME_Pascal)}, |
| {DW_LNAME_Pascal, 1, LanguageDescription(DW_LNAME_Pascal)}, |
| {DW_LNAME_PLI, 0, LanguageDescription(DW_LNAME_PLI)}, |
| {DW_LNAME_PLI, 1, LanguageDescription(DW_LNAME_PLI)}, |
| {DW_LNAME_Python, 0, LanguageDescription(DW_LNAME_Python)}, |
| {DW_LNAME_Python, 1, LanguageDescription(DW_LNAME_Python)}, |
| {DW_LNAME_RenderScript, 0, LanguageDescription(DW_LNAME_RenderScript)}, |
| {DW_LNAME_RenderScript, 1, LanguageDescription(DW_LNAME_RenderScript)}, |
| {DW_LNAME_Rust, 0, LanguageDescription(DW_LNAME_Rust)}, |
| {DW_LNAME_Rust, 1, LanguageDescription(DW_LNAME_Rust)}, |
| {DW_LNAME_Swift, 0, LanguageDescription(DW_LNAME_Swift)}, |
| {DW_LNAME_Swift, 1, LanguageDescription(DW_LNAME_Swift)}, |
| {DW_LNAME_UPC, 0, LanguageDescription(DW_LNAME_UPC)}, |
| {DW_LNAME_UPC, 1, LanguageDescription(DW_LNAME_UPC)}, |
| {DW_LNAME_Zig, 0, LanguageDescription(DW_LNAME_Zig)}, |
| {DW_LNAME_Zig, 1, LanguageDescription(DW_LNAME_Zig)}, |
| {DW_LNAME_Assembly, 0, LanguageDescription(DW_LNAME_Assembly)}, |
| {DW_LNAME_Assembly, 1, LanguageDescription(DW_LNAME_Assembly)}, |
| {DW_LNAME_C_sharp, 0, LanguageDescription(DW_LNAME_C_sharp)}, |
| {DW_LNAME_C_sharp, 1, LanguageDescription(DW_LNAME_C_sharp)}, |
| {DW_LNAME_Mojo, 0, LanguageDescription(DW_LNAME_Mojo)}, |
| {DW_LNAME_Mojo, 1, LanguageDescription(DW_LNAME_Mojo)}, |
| {DW_LNAME_GLSL, 0, LanguageDescription(DW_LNAME_GLSL)}, |
| {DW_LNAME_GLSL, 1, LanguageDescription(DW_LNAME_GLSL)}, |
| {DW_LNAME_GLSL_ES, 0, LanguageDescription(DW_LNAME_GLSL_ES)}, |
| {DW_LNAME_GLSL_ES, 1, LanguageDescription(DW_LNAME_GLSL_ES)}, |
| {DW_LNAME_OpenCL_CPP, 0, LanguageDescription(DW_LNAME_OpenCL_CPP)}, |
| {DW_LNAME_OpenCL_CPP, 1, LanguageDescription(DW_LNAME_OpenCL_CPP)}, |
| {DW_LNAME_CPP_for_OpenCL, 0, LanguageDescription(DW_LNAME_CPP_for_OpenCL)}, |
| {DW_LNAME_CPP_for_OpenCL, 1, LanguageDescription(DW_LNAME_CPP_for_OpenCL)}, |
| {DW_LNAME_Ruby, 0, LanguageDescription(DW_LNAME_Ruby)}, |
| {DW_LNAME_Ruby, 1, LanguageDescription(DW_LNAME_Ruby)}, |
| {DW_LNAME_Hylo, 0, LanguageDescription(DW_LNAME_Hylo)}, |
| {DW_LNAME_Hylo, 1, LanguageDescription(DW_LNAME_Hylo)}, |
| {DW_LNAME_Metal, 0, LanguageDescription(DW_LNAME_Metal)}, |
| {DW_LNAME_Metal, 1, LanguageDescription(DW_LNAME_Metal)}}; |
| |
| struct LanguageDescriptionTestFixture |
| : public testing::Test, |
| public testing::WithParamInterface<LanguageDescriptionTestCase> {}; |
| |
| TEST_P(LanguageDescriptionTestFixture, TestLanguageDescription) { |
| auto [LName, LVersion, ExpectedDescription] = GetParam(); |
| |
| // Basic test. |
| EXPECT_EQ(llvm::dwarf::LanguageDescription(LName, LVersion), |
| ExpectedDescription); |
| |
| // Now do the same test but roundtrip through the DW_LANG_ <-> DW_LNAME_ |
| // conversion APIs first. |
| |
| auto DWLang = llvm::dwarf::toDW_LANG(LName, LVersion); |
| // Some languages are not 1-to-1 mapped. In which case there's nothing else |
| // to test. |
| if (!DWLang) |
| return; |
| |
| std::optional<std::pair<SourceLanguageName, uint32_t>> DWLName = |
| llvm::dwarf::toDW_LNAME(*DWLang); |
| |
| // We are roundtripping, so there definitely should be a mapping back to |
| // DW_LNAME_. |
| ASSERT_TRUE(DWLName); |
| |
| // There is no official DW_LANG_ code for C++98. So the roundtripping turns it |
| // into a plain DW_LANG_C_plus_plus. |
| if (DWLang == DW_LANG_C_plus_plus && LVersion <= 199711) |
| EXPECT_EQ(llvm::dwarf::LanguageDescription(DWLName->first, DWLName->second), |
| "ISO C++"); |
| else |
| EXPECT_EQ(llvm::dwarf::LanguageDescription(DWLName->first, DWLName->second), |
| ExpectedDescription); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(LanguageDescriptionTests, |
| LanguageDescriptionTestFixture, |
| ::testing::ValuesIn(LanguageDescriptionTestCases)); |
| |
| } // end namespace |
