aboutsummaryrefslogtreecommitdiff
path: root/llvm/unittests
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests')
-rw-r--r--llvm/unittests/Analysis/IR2VecTest.cpp54
-rw-r--r--llvm/unittests/BinaryFormat/DwarfTest.cpp73
-rw-r--r--llvm/unittests/CodeGen/CMakeLists.txt1
-rw-r--r--llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp46
-rw-r--r--llvm/unittests/CodeGen/InstrRefLDVTest.cpp4
-rw-r--r--llvm/unittests/CodeGen/LexicalScopesTest.cpp4
-rw-r--r--llvm/unittests/CodeGen/MIR2VecTest.cpp246
-rw-r--r--llvm/unittests/CodeGen/MachineBasicBlockTest.cpp4
-rw-r--r--llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp5
-rw-r--r--llvm/unittests/IR/DebugInfoTest.cpp11
-rw-r--r--llvm/unittests/IR/IRBuilderTest.cpp35
-rw-r--r--llvm/unittests/IR/MetadataTest.cpp25
-rw-r--r--llvm/unittests/IR/VerifierTest.cpp8
-rw-r--r--llvm/unittests/Support/SpecialCaseListTest.cpp62
-rw-r--r--llvm/unittests/TargetParser/RISCVISAInfoTest.cpp6
-rw-r--r--llvm/unittests/Transforms/Utils/CloningTest.cpp24
16 files changed, 518 insertions, 90 deletions
diff --git a/llvm/unittests/Analysis/IR2VecTest.cpp b/llvm/unittests/Analysis/IR2VecTest.cpp
index d136cb6..40b4aa2 100644
--- a/llvm/unittests/Analysis/IR2VecTest.cpp
+++ b/llvm/unittests/Analysis/IR2VecTest.cpp
@@ -430,6 +430,60 @@ TEST_F(IR2VecTestFixture, GetFunctionVector_FlowAware) {
EXPECT_TRUE(FuncVec.approximatelyEquals(Embedding(2, 58.1)));
}
+TEST_F(IR2VecTestFixture, MultipleComputeEmbeddingsConsistency_Symbolic) {
+ auto Emb = Embedder::create(IR2VecKind::Symbolic, *F, *V);
+ ASSERT_TRUE(static_cast<bool>(Emb));
+
+ // Get initial function vector
+ const auto &FuncVec1 = Emb->getFunctionVector();
+
+ // Compute embeddings again by calling getFunctionVector multiple times
+ const auto &FuncVec2 = Emb->getFunctionVector();
+ const auto &FuncVec3 = Emb->getFunctionVector();
+
+ // All function vectors should be identical
+ EXPECT_TRUE(FuncVec1.approximatelyEquals(FuncVec2));
+ EXPECT_TRUE(FuncVec1.approximatelyEquals(FuncVec3));
+ EXPECT_TRUE(FuncVec2.approximatelyEquals(FuncVec3));
+
+ // Also check that instruction vectors remain consistent
+ const auto &InstMap1 = Emb->getInstVecMap();
+ const auto &InstMap2 = Emb->getInstVecMap();
+
+ EXPECT_EQ(InstMap1.size(), InstMap2.size());
+ for (const auto &[Inst, Vec1] : InstMap1) {
+ ASSERT_TRUE(InstMap2.count(Inst));
+ EXPECT_TRUE(Vec1.approximatelyEquals(InstMap2.at(Inst)));
+ }
+}
+
+TEST_F(IR2VecTestFixture, MultipleComputeEmbeddingsConsistency_FlowAware) {
+ auto Emb = Embedder::create(IR2VecKind::FlowAware, *F, *V);
+ ASSERT_TRUE(static_cast<bool>(Emb));
+
+ // Get initial function vector
+ const auto &FuncVec1 = Emb->getFunctionVector();
+
+ // Compute embeddings again by calling getFunctionVector multiple times
+ const auto &FuncVec2 = Emb->getFunctionVector();
+ const auto &FuncVec3 = Emb->getFunctionVector();
+
+ // All function vectors should be identical
+ EXPECT_TRUE(FuncVec1.approximatelyEquals(FuncVec2));
+ EXPECT_TRUE(FuncVec1.approximatelyEquals(FuncVec3));
+ EXPECT_TRUE(FuncVec2.approximatelyEquals(FuncVec3));
+
+ // Also check that instruction vectors remain consistent
+ const auto &InstMap1 = Emb->getInstVecMap();
+ const auto &InstMap2 = Emb->getInstVecMap();
+
+ EXPECT_EQ(InstMap1.size(), InstMap2.size());
+ for (const auto &[Inst, Vec1] : InstMap1) {
+ ASSERT_TRUE(InstMap2.count(Inst));
+ EXPECT_TRUE(Vec1.approximatelyEquals(InstMap2.at(Inst)));
+ }
+}
+
static constexpr unsigned MaxOpcodes = Vocabulary::MaxOpcodes;
[[maybe_unused]]
static constexpr unsigned MaxTypeIDs = Vocabulary::MaxTypeIDs;
diff --git a/llvm/unittests/BinaryFormat/DwarfTest.cpp b/llvm/unittests/BinaryFormat/DwarfTest.cpp
index 684e59f..f4519f6 100644
--- a/llvm/unittests/BinaryFormat/DwarfTest.cpp
+++ b/llvm/unittests/BinaryFormat/DwarfTest.cpp
@@ -219,4 +219,77 @@ TEST(DwarfTest, lname) {
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"
+}
+
+TEST(DWARFDebugInfo, TestLanguageDescription_Versioned) {
+ // Tests for the llvm::dwarf::LanguageDescription API that
+ // takes a name *and* a version.
+
+ // Unknown language.
+ EXPECT_EQ(
+ llvm::dwarf::LanguageDescription(static_cast<SourceLanguageName>(0)),
+ "Unknown");
+
+ EXPECT_EQ(
+ llvm::dwarf::LanguageDescription(static_cast<SourceLanguageName>(0), 0),
+ "Unknown");
+
+ // Test that specifying an invalid version falls back to a valid language name
+ // regardless.
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_ObjC, 0), "Objective C");
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_Julia, 0), "Julia");
+
+ // Check some versions.
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_C_plus_plus, 199711),
+ "C++98");
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_C_plus_plus, 201402),
+ "C++14");
+
+ // Versions round up.
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_C_plus_plus, 201400),
+ "C++14");
+
+ // Version 0 for C and C++ is an unversioned name.
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_C, 0), "C (K&R and ISO)");
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_C_plus_plus, 0),
+ "ISO C++");
+
+ // Version 0 for other versioned languages may not be the unversioned name.
+ EXPECT_EQ(llvm::dwarf::LanguageDescription(DW_LNAME_Fortran, 0),
+ "FORTRAN 77");
+}
} // end namespace
diff --git a/llvm/unittests/CodeGen/CMakeLists.txt b/llvm/unittests/CodeGen/CMakeLists.txt
index 22dbdaa..18332d2 100644
--- a/llvm/unittests/CodeGen/CMakeLists.txt
+++ b/llvm/unittests/CodeGen/CMakeLists.txt
@@ -37,6 +37,7 @@ add_llvm_unittest(CodeGenTests
MachineInstrBundleIteratorTest.cpp
MachineInstrTest.cpp
MachineOperandTest.cpp
+ MIR2VecTest.cpp
RegAllocScoreTest.cpp
PassManagerTest.cpp
ScalableVectorMVTsTest.cpp
diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index 988e307..7340f56 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -480,18 +480,21 @@ TEST(LegalizerInfoTest, MMOAlignment) {
LegacyInfo.computeTables();
- EXPECT_ACTION(Legal, 0, LLT(),
- LegalityQuery(G_LOAD, {s32, p0},
- LegalityQuery::MemDesc{
- s32, 32, AtomicOrdering::NotAtomic}));
- EXPECT_ACTION(Unsupported, 0, LLT(),
- LegalityQuery(G_LOAD, {s32, p0},
- LegalityQuery::MemDesc{
- s32, 16, AtomicOrdering::NotAtomic }));
- EXPECT_ACTION(Unsupported, 0, LLT(),
- LegalityQuery(G_LOAD, {s32, p0},
- LegalityQuery::MemDesc{
- s32, 8, AtomicOrdering::NotAtomic}));
+ EXPECT_ACTION(
+ Legal, 0, LLT(),
+ LegalityQuery(G_LOAD, {s32, p0},
+ LegalityQuery::MemDesc{s32, 32, AtomicOrdering::NotAtomic,
+ AtomicOrdering::NotAtomic}));
+ EXPECT_ACTION(
+ Unsupported, 0, LLT(),
+ LegalityQuery(G_LOAD, {s32, p0},
+ LegalityQuery::MemDesc{s32, 16, AtomicOrdering::NotAtomic,
+ AtomicOrdering::NotAtomic}));
+ EXPECT_ACTION(
+ Unsupported, 0, LLT(),
+ LegalityQuery(G_LOAD, {s32, p0},
+ LegalityQuery::MemDesc{s32, 8, AtomicOrdering::NotAtomic,
+ AtomicOrdering::NotAtomic}));
}
// Test that the maximum supported alignment value isn't truncated
@@ -506,14 +509,17 @@ TEST(LegalizerInfoTest, MMOAlignment) {
LegacyInfo.computeTables();
- EXPECT_ACTION(Legal, 0, LLT(),
- LegalityQuery(G_LOAD, {s32, p0},
- LegalityQuery::MemDesc{s32,
- MaxAlignInBits, AtomicOrdering::NotAtomic}));
- EXPECT_ACTION(Unsupported, 0, LLT(),
- LegalityQuery(G_LOAD, {s32, p0},
- LegalityQuery::MemDesc{
- s32, 8, AtomicOrdering::NotAtomic }));
+ EXPECT_ACTION(
+ Legal, 0, LLT(),
+ LegalityQuery(G_LOAD, {s32, p0},
+ LegalityQuery::MemDesc{s32, MaxAlignInBits,
+ AtomicOrdering::NotAtomic,
+ AtomicOrdering::NotAtomic}));
+ EXPECT_ACTION(
+ Unsupported, 0, LLT(),
+ LegalityQuery(G_LOAD, {s32, p0},
+ LegalityQuery::MemDesc{s32, 8, AtomicOrdering::NotAtomic,
+ AtomicOrdering::NotAtomic}));
}
}
diff --git a/llvm/unittests/CodeGen/InstrRefLDVTest.cpp b/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
index 3a625b2..ce2a38b 100644
--- a/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
+++ b/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
@@ -100,8 +100,8 @@ public:
// scope.
DIBuilder DIB(*Mod);
OurFile = DIB.createFile("xyzzy.c", "/cave");
- OurCU =
- DIB.createCompileUnit(dwarf::DW_LANG_C99, OurFile, "nou", false, "", 0);
+ OurCU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C99),
+ OurFile, "nou", false, "", 0);
auto OurSubT = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
OurFunc =
DIB.createFunction(OurCU, "bees", "", OurFile, 1, OurSubT, 1,
diff --git a/llvm/unittests/CodeGen/LexicalScopesTest.cpp b/llvm/unittests/CodeGen/LexicalScopesTest.cpp
index 34bd37a..0c6b932 100644
--- a/llvm/unittests/CodeGen/LexicalScopesTest.cpp
+++ b/llvm/unittests/CodeGen/LexicalScopesTest.cpp
@@ -102,8 +102,8 @@ public:
// scope.
DIBuilder DIB(Mod);
OurFile = DIB.createFile("xyzzy.c", "/cave");
- OurCU =
- DIB.createCompileUnit(dwarf::DW_LANG_C99, OurFile, "nou", false, "", 0);
+ OurCU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C99),
+ OurFile, "nou", false, "", 0);
OurSubT = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
OurFunc =
DIB.createFunction(OurCU, "bees", "", OurFile, 1, OurSubT, 1,
diff --git a/llvm/unittests/CodeGen/MIR2VecTest.cpp b/llvm/unittests/CodeGen/MIR2VecTest.cpp
new file mode 100644
index 0000000..11222b4
--- /dev/null
+++ b/llvm/unittests/CodeGen/MIR2VecTest.cpp
@@ -0,0 +1,246 @@
+//===- MIR2VecTest.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/MIR2Vec.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/Triple.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace mir2vec;
+using VocabMap = std::map<std::string, ir2vec::Embedding>;
+
+namespace {
+
+TEST(MIR2VecTest, RegexExtraction) {
+ // Test simple instruction names
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("NOP"), "NOP");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("RET"), "RET");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("ADD16ri"), "ADD");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("ADD32rr"), "ADD");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("ADD64rm"), "ADD");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("MOV8ri"), "MOV");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("MOV32mr"), "MOV");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("PUSH64r"), "PUSH");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("POP64r"), "POP");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("JMP_4"), "JMP");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("CALL64pcrel32"), "CALL");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("SOME_INSTR_123"),
+ "SOME_INSTR");
+ EXPECT_EQ(MIRVocabulary::extractBaseOpcodeName("123ADD"), "ADD");
+ EXPECT_FALSE(MIRVocabulary::extractBaseOpcodeName("123").empty());
+}
+
+class MIR2VecVocabTestFixture : public ::testing::Test {
+protected:
+ std::unique_ptr<LLVMContext> Ctx;
+ std::unique_ptr<Module> M;
+ std::unique_ptr<TargetMachine> TM;
+ const TargetInstrInfo *TII = nullptr;
+
+ static void SetUpTestCase() {
+ InitializeAllTargets();
+ InitializeAllTargetMCs();
+ }
+
+ void SetUp() override {
+ Triple TargetTriple("x86_64-unknown-linux-gnu");
+ std::string Error;
+ const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
+ if (!T) {
+ GTEST_SKIP() << "x86_64-unknown-linux-gnu target triple not available; "
+ "Skipping test";
+ return;
+ }
+
+ Ctx = std::make_unique<LLVMContext>();
+ M = std::make_unique<Module>("test", *Ctx);
+ M->setTargetTriple(TargetTriple);
+
+ TargetOptions Options;
+ TM = std::unique_ptr<TargetMachine>(
+ T->createTargetMachine(TargetTriple, "", "", Options, std::nullopt));
+ if (!TM) {
+ GTEST_SKIP() << "Failed to create X86 target machine; Skipping test";
+ return;
+ }
+
+ // Create a dummy function to get subtarget info
+ FunctionType *FT = FunctionType::get(Type::getVoidTy(*Ctx), false);
+ Function *F =
+ Function::Create(FT, Function::ExternalLinkage, "test", M.get());
+
+ // Get the target instruction info
+ TII = TM->getSubtargetImpl(*F)->getInstrInfo();
+ if (!TII) {
+ GTEST_SKIP() << "Failed to get target instruction info; Skipping test";
+ return;
+ }
+ }
+
+ void TearDown() override { TII = nullptr; }
+};
+
+// Function to find an opcode by name
+static int findOpcodeByName(const TargetInstrInfo *TII, StringRef Name) {
+ for (unsigned Opcode = 1; Opcode < TII->getNumOpcodes(); ++Opcode) {
+ if (TII->getName(Opcode) == Name)
+ return Opcode;
+ }
+ return -1; // Not found
+}
+
+TEST_F(MIR2VecVocabTestFixture, CanonicalOpcodeMappingTest) {
+ // Test that same base opcodes get same canonical indices
+ std::string BaseName1 = MIRVocabulary::extractBaseOpcodeName("ADD16ri");
+ std::string BaseName2 = MIRVocabulary::extractBaseOpcodeName("ADD32rr");
+ std::string BaseName3 = MIRVocabulary::extractBaseOpcodeName("ADD64rm");
+
+ EXPECT_EQ(BaseName1, BaseName2);
+ EXPECT_EQ(BaseName2, BaseName3);
+
+ // Create a MIRVocabulary instance to test the mapping
+ // Use a minimal MIRVocabulary to trigger canonical mapping construction
+ VocabMap VMap;
+ Embedding Val = Embedding(64, 1.0f);
+ VMap["ADD"] = Val;
+ auto TestVocabOrErr = MIRVocabulary::create(std::move(VMap), *TII);
+ ASSERT_TRUE(static_cast<bool>(TestVocabOrErr))
+ << "Failed to create vocabulary: "
+ << toString(TestVocabOrErr.takeError());
+ auto &TestVocab = *TestVocabOrErr;
+
+ unsigned Index1 = TestVocab.getCanonicalIndexForBaseName(BaseName1);
+ unsigned Index2 = TestVocab.getCanonicalIndexForBaseName(BaseName2);
+ unsigned Index3 = TestVocab.getCanonicalIndexForBaseName(BaseName3);
+ EXPECT_EQ(Index1, Index2);
+ EXPECT_EQ(Index2, Index3);
+
+ // Test that different base opcodes get different canonical indices
+ std::string AddBase = MIRVocabulary::extractBaseOpcodeName("ADD32rr");
+ std::string SubBase = MIRVocabulary::extractBaseOpcodeName("SUB32rr");
+ std::string MovBase = MIRVocabulary::extractBaseOpcodeName("MOV32rr");
+
+ unsigned AddIndex = TestVocab.getCanonicalIndexForBaseName(AddBase);
+ unsigned SubIndex = TestVocab.getCanonicalIndexForBaseName(SubBase);
+ unsigned MovIndex = TestVocab.getCanonicalIndexForBaseName(MovBase);
+
+ EXPECT_NE(AddIndex, SubIndex);
+ EXPECT_NE(SubIndex, MovIndex);
+ EXPECT_NE(AddIndex, MovIndex);
+
+ // Even though we only added "ADD" to the vocab, the canonical mapping
+ // should assign unique indices to all the base opcodes of the target
+ // Ideally, we would check against the exact number of unique base opcodes
+ // for X86, but that would make the test brittle. So we just check that
+ // the number is reasonably closer to the expected number (>6880) and not just
+ // opcodes that we added.
+ EXPECT_GT(TestVocab.getCanonicalSize(),
+ 6880u); // X86 has >6880 unique base opcodes
+
+ // Check that the embeddings for opcodes not in the vocab are zero vectors
+ int Add32rrOpcode = findOpcodeByName(TII, "ADD32rr");
+ ASSERT_NE(Add32rrOpcode, -1) << "ADD32rr opcode not found";
+ EXPECT_TRUE(TestVocab[Add32rrOpcode].approximatelyEquals(Val));
+
+ int Sub32rrOpcode = findOpcodeByName(TII, "SUB32rr");
+ ASSERT_NE(Sub32rrOpcode, -1) << "SUB32rr opcode not found";
+ EXPECT_TRUE(
+ TestVocab[Sub32rrOpcode].approximatelyEquals(Embedding(64, 0.0f)));
+
+ int Mov32rrOpcode = findOpcodeByName(TII, "MOV32rr");
+ ASSERT_NE(Mov32rrOpcode, -1) << "MOV32rr opcode not found";
+ EXPECT_TRUE(
+ TestVocab[Mov32rrOpcode].approximatelyEquals(Embedding(64, 0.0f)));
+}
+
+// Test deterministic mapping
+TEST_F(MIR2VecVocabTestFixture, DeterministicMapping) {
+ // Test that the same base name always maps to the same canonical index
+ std::string BaseName = "ADD";
+
+ // Create a MIRVocabulary instance to test deterministic mapping
+ // Use a minimal MIRVocabulary to trigger canonical mapping construction
+ VocabMap VMap;
+ VMap["ADD"] = Embedding(64, 1.0f);
+ auto TestVocabOrErr = MIRVocabulary::create(std::move(VMap), *TII);
+ ASSERT_TRUE(static_cast<bool>(TestVocabOrErr))
+ << "Failed to create vocabulary: "
+ << toString(TestVocabOrErr.takeError());
+ auto &TestVocab = *TestVocabOrErr;
+
+ unsigned Index1 = TestVocab.getCanonicalIndexForBaseName(BaseName);
+ unsigned Index2 = TestVocab.getCanonicalIndexForBaseName(BaseName);
+ unsigned Index3 = TestVocab.getCanonicalIndexForBaseName(BaseName);
+
+ EXPECT_EQ(Index1, Index2);
+ EXPECT_EQ(Index2, Index3);
+
+ // Test across multiple runs
+ for (int Pos = 0; Pos < 100; ++Pos) {
+ unsigned Index = TestVocab.getCanonicalIndexForBaseName(BaseName);
+ EXPECT_EQ(Index, Index1);
+ }
+}
+
+// Test MIRVocabulary construction
+TEST_F(MIR2VecVocabTestFixture, VocabularyConstruction) {
+ VocabMap VMap;
+ VMap["ADD"] = Embedding(128, 1.0f); // Dimension 128, all values 1.0
+ VMap["SUB"] = Embedding(128, 2.0f); // Dimension 128, all values 2.0
+
+ auto VocabOrErr = MIRVocabulary::create(std::move(VMap), *TII);
+ ASSERT_TRUE(static_cast<bool>(VocabOrErr))
+ << "Failed to create vocabulary: " << toString(VocabOrErr.takeError());
+ auto &Vocab = *VocabOrErr;
+ EXPECT_EQ(Vocab.getDimension(), 128u);
+
+ // Test iterator - iterates over individual embeddings
+ auto IT = Vocab.begin();
+ EXPECT_NE(IT, Vocab.end());
+
+ // Check first embedding exists and has correct dimension
+ EXPECT_EQ((*IT).size(), 128u);
+
+ size_t Count = 0;
+ for (auto IT = Vocab.begin(); IT != Vocab.end(); ++IT) {
+ EXPECT_EQ((*IT).size(), 128u);
+ ++Count;
+ }
+ EXPECT_GT(Count, 0u);
+}
+
+// Test factory method with empty vocabulary
+TEST_F(MIR2VecVocabTestFixture, EmptyVocabularyCreation) {
+ VocabMap EmptyVMap;
+
+ auto VocabOrErr = MIRVocabulary::create(std::move(EmptyVMap), *TII);
+ EXPECT_FALSE(static_cast<bool>(VocabOrErr))
+ << "Factory method should fail with empty vocabulary";
+
+ // Consume the error
+ if (!VocabOrErr) {
+ auto Err = VocabOrErr.takeError();
+ std::string ErrorMsg = toString(std::move(Err));
+ EXPECT_FALSE(ErrorMsg.empty());
+ }
+}
+
+} // namespace
diff --git a/llvm/unittests/CodeGen/MachineBasicBlockTest.cpp b/llvm/unittests/CodeGen/MachineBasicBlockTest.cpp
index bcb5a18..ef0d40b 100644
--- a/llvm/unittests/CodeGen/MachineBasicBlockTest.cpp
+++ b/llvm/unittests/CodeGen/MachineBasicBlockTest.cpp
@@ -40,8 +40,8 @@ TEST(FindDebugLocTest, DifferentIterators) {
// scope.
DIBuilder DIB(Mod);
DIFile *OurFile = DIB.createFile("foo.c", "/bar");
- DICompileUnit *OurCU =
- DIB.createCompileUnit(dwarf::DW_LANG_C99, OurFile, "", false, "", 0);
+ DICompileUnit *OurCU = DIB.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C99), OurFile, "", false, "", 0);
auto OurSubT = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
DISubprogram *OurFunc =
DIB.createFunction(OurCU, "bees", "", OurFile, 1, OurSubT, 1,
diff --git a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
index c13570d..e568723 100644
--- a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
+++ b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
@@ -11,6 +11,7 @@
#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
@@ -212,8 +213,8 @@ protected:
DIBuilder DIB(*M);
auto File = DIB.createFile("test.dbg", "/src", std::nullopt,
std::optional<StringRef>("/src/test.dbg"));
- auto CU =
- DIB.createCompileUnit(dwarf::DW_LANG_C, File, "llvm-C", true, "", 0);
+ auto CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C),
+ File, "llvm-C", true, "", 0);
auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
auto SP = DIB.createFunction(
CU, "foo", "", File, 1, Type, 1, DINode::FlagZero,
diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp
index 475e0a9..060f45d 100644
--- a/llvm/unittests/IR/DebugInfoTest.cpp
+++ b/llvm/unittests/IR/DebugInfoTest.cpp
@@ -409,7 +409,8 @@ TEST(DIBuilder, CreateFortranArrayTypeWithAttributes) {
DIFile *F = DIB.createFile("main.c", "/");
DICompileUnit *CU = DIB.createCompileUnit(
- dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
+ DISourceLanguageName(dwarf::DW_LANG_C), DIB.createFile("main.c", "/"),
+ "llvm-c", true, "", 0);
DIVariable *DataLocation =
DIB.createTempGlobalVariableFwdDecl(CU, "dl", "_dl", F, 1, nullptr, true);
@@ -1335,8 +1336,8 @@ TEST(DIBuilder, HashingDISubprogram) {
DIBuilder DIB(*M);
DIFile *F = DIB.createFile("main.c", "/");
- DICompileUnit *CU =
- DIB.createCompileUnit(dwarf::DW_LANG_C, F, "Test", false, "", 0);
+ DICompileUnit *CU = DIB.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C), F, "Test", false, "", 0);
llvm::TempDIType ForwardDeclaredType =
llvm::TempDIType(DIB.createReplaceableCompositeType(
@@ -1381,8 +1382,8 @@ TEST(DIBuilder, CompositeTypes) {
DIBuilder DIB(*M);
DIFile *F = DIB.createFile("main.c", "/");
- DICompileUnit *CU =
- DIB.createCompileUnit(dwarf::DW_LANG_C, F, "Test", false, "", 0);
+ DICompileUnit *CU = DIB.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C), F, "Test", false, "", 0);
DICompositeType *Class =
DIB.createClassType(CU, "MyClass", F, 0, 8, 8, 0, {}, nullptr, {}, 0,
diff --git a/llvm/unittests/IR/IRBuilderTest.cpp b/llvm/unittests/IR/IRBuilderTest.cpp
index 773c32e..37826b2 100644
--- a/llvm/unittests/IR/IRBuilderTest.cpp
+++ b/llvm/unittests/IR/IRBuilderTest.cpp
@@ -6,11 +6,12 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Analysis/InstSimplifyFolder.h"
#include "llvm/IR/IRBuilder.h"
+#include "llvm/Analysis/InstSimplifyFolder.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/IntrinsicsAArch64.h"
@@ -859,8 +860,8 @@ TEST_F(IRBuilderTest, createFunction) {
IRBuilder<> Builder(BB);
DIBuilder DIB(*M);
auto File = DIB.createFile("error.swift", "/");
- auto CU =
- DIB.createCompileUnit(dwarf::DW_LANG_Swift, File, "swiftc", true, "", 0);
+ auto CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_Swift),
+ File, "swiftc", true, "", 0);
auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
auto NoErr = DIB.createFunction(
CU, "noerr", "", File, 1, Type, 1, DINode::FlagZero,
@@ -893,9 +894,9 @@ TEST_F(IRBuilderTest, DIBuilder) {
IRBuilder<> Builder(BB);
DIBuilder DIB(*M);
auto File = DIB.createFile("F.CBL", "/");
- auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
- DIB.createFile("F.CBL", "/"),
- "llvm-cobol74", true, "", 0);
+ auto CU = DIB.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_Cobol74),
+ DIB.createFile("F.CBL", "/"), "llvm-cobol74", true, "", 0);
auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
auto SP = DIB.createFunction(
CU, "foo", "", File, 1, Type, 1, DINode::FlagZero,
@@ -1004,7 +1005,8 @@ TEST_F(IRBuilderTest, createArtificialSubprogram) {
IRBuilder<> Builder(BB);
DIBuilder DIB(*M);
auto File = DIB.createFile("main.c", "/");
- auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "clang",
+ auto CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C), File,
+ "clang",
/*isOptimized=*/true, /*Flags=*/"",
/*Runtime Version=*/0);
auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
@@ -1083,7 +1085,8 @@ TEST_F(IRBuilderTest, appendDebugInfo) {
{
DIBuilder DIB(*M);
auto *File = DIB.createFile("main.c", "/");
- CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "clang",
+ CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C), File,
+ "clang",
/*isOptimized=*/true, /*Flags=*/"",
/*Runtime Version=*/0);
auto *ByteTy = DIB.createBasicType("byte0", 8, dwarf::DW_ATE_signed);
@@ -1158,9 +1161,9 @@ TEST_F(IRBuilderTest, DebugLoc) {
DIBuilder DIB(*M);
auto File = DIB.createFile("tmp.cpp", "/");
- auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
- DIB.createFile("tmp.cpp", "/"), "", true, "",
- 0);
+ auto CU =
+ DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C_plus_plus_11),
+ DIB.createFile("tmp.cpp", "/"), "", true, "", 0);
auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray({}));
auto SP =
DIB.createFunction(CU, "foo", "foo", File, 1, SPType, 1, DINode::FlagZero,
@@ -1191,9 +1194,8 @@ TEST_F(IRBuilderTest, DIImportedEntity) {
IRBuilder<> Builder(BB);
DIBuilder DIB(*M);
auto F = DIB.createFile("F.CBL", "/");
- auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
- F, "llvm-cobol74",
- true, "", 0);
+ auto CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_Cobol74),
+ F, "llvm-cobol74", true, "", 0);
MDTuple *Elements = MDTuple::getDistinct(Ctx, {});
DIB.createImportedDeclaration(CU, nullptr, F, 1);
@@ -1218,8 +1220,9 @@ TEST_F(IRBuilderTest, DIBuilderMacro) {
DIBuilder DIB(*M);
auto File1 = DIB.createFile("main.c", "/");
auto File2 = DIB.createFile("file.h", "/");
- auto CU = DIB.createCompileUnit(
- dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
+ auto CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C),
+ DIB.createFile("main.c", "/"), "llvm-c", true,
+ "", 0);
auto MDef0 =
DIB.createMacro(nullptr, 0, dwarf::DW_MACINFO_define, "M0", "V0");
auto TMF1 = DIB.createTempMacroFile(nullptr, 0, File1);
diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp
index 7425703..85c79d1 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -101,8 +101,8 @@ protected:
}
DICompileUnit *getUnit() {
return DICompileUnit::getDistinct(
- Context, 1, getFile(), "clang", false, "-g", 2, "",
- DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
+ Context, DISourceLanguageName(1), getFile(), "clang", false, "-g", 2,
+ "", DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
getTuple(), getTuple(), 0, true, false,
DICompileUnit::DebugNameTableKind::Default, false, "/", "");
}
@@ -2896,13 +2896,14 @@ TEST_F(DICompileUnitTest, get) {
StringRef SysRoot = "/";
StringRef SDK = "MacOSX.sdk";
auto *N = DICompileUnit::getDistinct(
- Context, SourceLanguage, File, Producer, IsOptimized, Flags,
- RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
- RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
- false, DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK);
+ Context, DISourceLanguageName(SourceLanguage), File, Producer,
+ IsOptimized, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind,
+ EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities, Macros,
+ DWOId, true, false, DICompileUnit::DebugNameTableKind::Default, false,
+ SysRoot, SDK);
EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
- EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
+ EXPECT_EQ(SourceLanguage, N->getSourceLanguage().getUnversionedName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Producer, N->getProducer());
EXPECT_EQ(IsOptimized, N->isOptimized());
@@ -2921,7 +2922,7 @@ TEST_F(DICompileUnitTest, get) {
TempDICompileUnit Temp = N->clone();
EXPECT_EQ(dwarf::DW_TAG_compile_unit, Temp->getTag());
- EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage());
+ EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage().getUnversionedName());
EXPECT_EQ(File, Temp->getFile());
EXPECT_EQ(Producer, Temp->getProducer());
EXPECT_EQ(IsOptimized, Temp->isOptimized());
@@ -2959,10 +2960,10 @@ TEST_F(DICompileUnitTest, replaceArrays) {
StringRef SysRoot = "/";
StringRef SDK = "MacOSX.sdk";
auto *N = DICompileUnit::getDistinct(
- Context, SourceLanguage, File, Producer, IsOptimized, Flags,
- RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
- RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false,
- DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK);
+ Context, DISourceLanguageName(SourceLanguage), File, Producer,
+ IsOptimized, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind,
+ EnumTypes, RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true,
+ false, DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK);
auto *GlobalVariables = MDTuple::getDistinct(Context, {});
EXPECT_EQ(nullptr, N->getGlobalVariables().get());
diff --git a/llvm/unittests/IR/VerifierTest.cpp b/llvm/unittests/IR/VerifierTest.cpp
index 7a136e6..440db12 100644
--- a/llvm/unittests/IR/VerifierTest.cpp
+++ b/llvm/unittests/IR/VerifierTest.cpp
@@ -9,6 +9,7 @@
#include "llvm/IR/Verifier.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalAlias.h"
@@ -232,8 +233,9 @@ TEST(VerifierTest, DetectInvalidDebugInfo) {
LLVMContext C;
Module M("M", C);
DIBuilder DIB(M);
- DIB.createCompileUnit(dwarf::DW_LANG_C89, DIB.createFile("broken.c", "/"),
- "unittest", false, "", 0);
+ DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C89),
+ DIB.createFile("broken.c", "/"), "unittest", false,
+ "", 0);
DIB.finalize();
EXPECT_FALSE(verifyModule(M));
@@ -247,7 +249,7 @@ TEST(VerifierTest, DetectInvalidDebugInfo) {
LLVMContext C;
Module M("M", C);
DIBuilder DIB(M);
- auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89,
+ auto *CU = DIB.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C89),
DIB.createFile("broken.c", "/"),
"unittest", false, "", 0);
new GlobalVariable(M, Type::getInt8Ty(C), false,
diff --git a/llvm/unittests/Support/SpecialCaseListTest.cpp b/llvm/unittests/Support/SpecialCaseListTest.cpp
index 5be2b9e..750feda 100644
--- a/llvm/unittests/Support/SpecialCaseListTest.cpp
+++ b/llvm/unittests/Support/SpecialCaseListTest.cpp
@@ -22,33 +22,31 @@ namespace {
class SpecialCaseListTest : public ::testing::Test {
protected:
- std::unique_ptr<SpecialCaseList> makeSpecialCaseList(StringRef List,
- std::string &Error,
- bool UseGlobs = true) {
+ std::unique_ptr<SpecialCaseList>
+ makeSpecialCaseList(StringRef List, std::string &Error, int Version = 0) {
auto S = List.str();
- if (!UseGlobs)
- S = (Twine("#!special-case-list-v1\n") + S).str();
+ if (Version)
+ S = (Twine("#!special-case-list-v") + Twine(Version) + "\n" + S).str();
std::unique_ptr<MemoryBuffer> MB = MemoryBuffer::getMemBuffer(S);
return SpecialCaseList::create(MB.get(), Error);
}
std::unique_ptr<SpecialCaseList> makeSpecialCaseList(StringRef List,
- bool UseGlobs = true) {
+ int Version = 0) {
std::string Error;
- auto SCL = makeSpecialCaseList(List, Error, UseGlobs);
+ auto SCL = makeSpecialCaseList(List, Error, Version);
assert(SCL);
assert(Error == "");
return SCL;
}
- std::string makeSpecialCaseListFile(StringRef Contents,
- bool UseGlobs = true) {
+ std::string makeSpecialCaseListFile(StringRef Contents, int Version = 0) {
int FD;
SmallString<64> Path;
sys::fs::createTemporaryFile("SpecialCaseListTest", "temp", FD, Path);
raw_fd_ostream OF(FD, true, true);
- if (!UseGlobs)
- OF << "#!special-case-list-v1\n";
+ if (Version)
+ OF << "#!special-case-list-v" << Version << "\n";
OF << Contents;
OF.close();
return std::string(Path.str());
@@ -261,7 +259,7 @@ TEST_F(SpecialCaseListTest, Version1) {
"fun:foo.*\n"
"fun:abc|def\n"
"fun:b.r\n",
- /*UseGlobs=*/false);
+ /*Version=*/1);
EXPECT_TRUE(SCL->inSection("sect1", "fun", "fooz"));
EXPECT_TRUE(SCL->inSection("sect2", "fun", "fooz"));
@@ -309,6 +307,46 @@ TEST_F(SpecialCaseListTest, Version2) {
EXPECT_FALSE(SCL->inSection("sect3", "fun", "bar"));
}
+TEST_F(SpecialCaseListTest, DotSlash) {
+ std::unique_ptr<SpecialCaseList> SCL2 = makeSpecialCaseList("[dot]\n"
+ "fun:./foo\n"
+ "src:./bar\n"
+ "[not]\n"
+ "fun:foo\n"
+ "src:bar\n");
+ std::unique_ptr<SpecialCaseList> SCL3 = makeSpecialCaseList("[dot]\n"
+ "fun:./foo\n"
+ "src:./bar\n"
+ "[not]\n"
+ "fun:foo\n"
+ "src:bar\n",
+ /*Version=*/3);
+
+ EXPECT_TRUE(SCL2->inSection("dot", "fun", "./foo"));
+ EXPECT_TRUE(SCL3->inSection("dot", "fun", "./foo"));
+
+ EXPECT_FALSE(SCL2->inSection("dot", "fun", "foo"));
+ EXPECT_FALSE(SCL3->inSection("dot", "fun", "foo"));
+
+ EXPECT_TRUE(SCL2->inSection("dot", "src", "./bar"));
+ EXPECT_FALSE(SCL3->inSection("dot", "src", "./bar"));
+
+ EXPECT_FALSE(SCL2->inSection("dot", "src", "bar"));
+ EXPECT_FALSE(SCL3->inSection("dot", "src", "bar"));
+
+ EXPECT_FALSE(SCL2->inSection("not", "fun", "./foo"));
+ EXPECT_FALSE(SCL3->inSection("not", "fun", "./foo"));
+
+ EXPECT_TRUE(SCL2->inSection("not", "fun", "foo"));
+ EXPECT_TRUE(SCL3->inSection("not", "fun", "foo"));
+
+ EXPECT_FALSE(SCL2->inSection("not", "src", "./bar"));
+ EXPECT_TRUE(SCL3->inSection("not", "src", "./bar"));
+
+ EXPECT_TRUE(SCL2->inSection("not", "src", "bar"));
+ EXPECT_TRUE(SCL3->inSection("not", "src", "bar"));
+}
+
TEST_F(SpecialCaseListTest, LinesInSection) {
std::unique_ptr<SpecialCaseList> SCL = makeSpecialCaseList("fun:foo\n"
"fun:bar\n"
diff --git a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp
index 5c6c824..5d69a31 100644
--- a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp
+++ b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp
@@ -552,7 +552,7 @@ TEST(ParseArchString,
const auto &Exts = (*MaybeISAInfo)->getExtensions();
EXPECT_EQ(Exts.size(), 2UL);
EXPECT_EQ(Exts.count("zalasr"), 1U);
- auto MaybeISAInfo2 = RISCVISAInfo::parseArchString("rv64izalasr0p1", true);
+ auto MaybeISAInfo2 = RISCVISAInfo::parseArchString("rv64izalasr0p9", true);
ASSERT_THAT_EXPECTED(MaybeISAInfo2, Succeeded());
const auto &Exts2 = (*MaybeISAInfo2)->getExtensions();
EXPECT_EQ(Exts2.size(), 2UL);
@@ -581,7 +581,7 @@ TEST(ParseArchString, RejectsUnrecognizedVersionForExperimentalExtension) {
toString(
RISCVISAInfo::parseArchString("rv64izalasr9p9", true).takeError()),
"unsupported version number 9.9 for experimental extension 'zalasr' "
- "(this compiler supports 0.1)");
+ "(this compiler supports 0.9)");
}
TEST(ParseArchString, RejectsExtensionVersionForG) {
@@ -1188,7 +1188,7 @@ Experimental extensions
zibi 0.1
zicfilp 1.0 This is a long dummy description
zicfiss 1.0
- zalasr 0.1
+ zalasr 0.9
zvbc32e 0.7
zvfbfa 0.1
zvfofp8min 0.2
diff --git a/llvm/unittests/Transforms/Utils/CloningTest.cpp b/llvm/unittests/Transforms/Utils/CloningTest.cpp
index fe81986..d990808 100644
--- a/llvm/unittests/Transforms/Utils/CloningTest.cpp
+++ b/llvm/unittests/Transforms/Utils/CloningTest.cpp
@@ -18,6 +18,7 @@
#include "llvm/IR/Constant.h"
#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstIterator.h"
@@ -482,10 +483,10 @@ protected:
DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray({});
DISubroutineType *FuncType =
DBuilder.createSubroutineType(ParamTypes);
- auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
- DBuilder.createFile("filename.c",
- "/file/dir"),
- "CloneFunc", false, "", 0);
+ auto *CU = DBuilder.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C99),
+ DBuilder.createFile("filename.c", "/file/dir"), "CloneFunc", false, "",
+ 0);
auto *Subprogram = DBuilder.createFunction(
CU, "f", "f", File, 4, FuncType, 3, DINode::FlagZero,
@@ -540,7 +541,7 @@ protected:
// Create another, empty, compile unit.
DIBuilder DBuilder2(*M);
- DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
+ DBuilder2.createCompileUnit(DISourceLanguageName(dwarf::DW_LANG_C99),
DBuilder.createFile("extra.c", "/file/dir"),
"CloneFunc", false, "", 0);
DBuilder2.finalize();
@@ -953,8 +954,9 @@ protected:
// confirm that compile units get cloned in the correct order.
DIBuilder EmptyBuilder(*OldM);
auto *File = EmptyBuilder.createFile("empty.c", "/file/dir/");
- (void)EmptyBuilder.createCompileUnit(dwarf::DW_LANG_C99, File,
- "EmptyUnit", false, "", 0);
+ (void)EmptyBuilder.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C99), File, "EmptyUnit", false,
+ "", 0);
EmptyBuilder.finalize();
}
@@ -973,10 +975,10 @@ protected:
auto *File = DBuilder.createFile("filename.c", "/file/dir/");
DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray({});
DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
- auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
- DBuilder.createFile("filename.c",
- "/file/dir"),
- "CloneModule", false, "", 0);
+ auto *CU = DBuilder.createCompileUnit(
+ DISourceLanguageName(dwarf::DW_LANG_C99),
+ DBuilder.createFile("filename.c", "/file/dir"), "CloneModule", false,
+ "", 0);
// Function DI
auto *Subprogram = DBuilder.createFunction(
CU, "f", "f", File, 4, DFuncType, 3, DINode::FlagZero,
generated by cgit v1.1 at 2025-10-09 17:06:52 +0000