summaryrefslogtreecommitdiff
path: root/llvm/unittests
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests')
-rw-r--r--llvm/unittests/Analysis/CMakeLists.txt11
-rw-r--r--llvm/unittests/Analysis/TargetLibraryInfoTest.cpp4
-rw-r--r--llvm/unittests/BinaryFormat/MachOTest.cpp11
-rw-r--r--llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt4
-rw-r--r--llvm/unittests/IR/ConstantRangeTest.cpp39
-rw-r--r--llvm/unittests/Passes/Plugins/CMakeLists.txt3
-rw-r--r--llvm/unittests/ProfileData/PGOCtxProfReaderWriterTest.cpp2
-rw-r--r--llvm/unittests/SandboxIR/SandboxIRTest.cpp200
-rw-r--r--llvm/unittests/SandboxIR/TrackerTest.cpp54
-rw-r--r--llvm/unittests/Support/CMakeLists.txt1
-rw-r--r--llvm/unittests/Support/DynamicLibrary/CMakeLists.txt7
-rw-r--r--llvm/unittests/Support/GenericDomTreeTest.cpp109
-rw-r--r--llvm/unittests/TargetParser/TargetParserTest.cpp23
13 files changed, 441 insertions, 27 deletions
diff --git a/llvm/unittests/Analysis/CMakeLists.txt b/llvm/unittests/Analysis/CMakeLists.txt
index 3cba630867a8..a1199adba076 100644
--- a/llvm/unittests/Analysis/CMakeLists.txt
+++ b/llvm/unittests/Analysis/CMakeLists.txt
@@ -62,8 +62,14 @@ else()
LIST(APPEND LLVM_OPTIONAL_SOURCES ${MLGO_TESTS})
endif()
+# Export symbols from the plugins shared objects.
+if(NOT WIN32)
+ set(export_symbols EXPORT_SYMBOLS_FOR_PLUGINS)
+endif()
+
add_llvm_unittest_with_input_files(AnalysisTests
${ANALYSIS_TEST_SOURCES}
+ ${export_symbols}
)
add_dependencies(AnalysisTests intrinsics_gen)
@@ -76,10 +82,5 @@ if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-brtl")
endif()
-# Export symbols from the plugins shared objects.
-if(NOT WIN32)
- export_executable_symbols_for_plugins(AnalysisTests)
-endif()
-
add_subdirectory(InlineAdvisorPlugin)
add_subdirectory(InlineOrderPlugin)
diff --git a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
index d344ebe67679..d200956f7410 100644
--- a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
+++ b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
@@ -472,6 +472,10 @@ TEST_F(TargetLibraryInfoTest, ValidProto) {
"declare i8* @_ZnwmSt11align_val_tRKSt9nothrow_t(i64, i64, %struct*)\n"
"declare i8* @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64, i64, "
"%struct*, i8)\n"
+ "declare %struct @__size_returning_new(i64)\n"
+ "declare %struct @__size_returning_new_hot_cold(i64, i8)\n"
+ "declare %struct @__size_returning_new_aligned(i64, i64)\n"
+ "declare %struct @__size_returning_new_aligned_hot_cold(i64, i64, i8)\n"
"declare void @\"??3@YAXPEAX@Z\"(i8*)\n"
"declare void @\"??3@YAXPEAXAEBUnothrow_t@std@@@Z\"(i8*, %struct*)\n"
diff --git a/llvm/unittests/BinaryFormat/MachOTest.cpp b/llvm/unittests/BinaryFormat/MachOTest.cpp
index 391298ff38d7..78b20c28a954 100644
--- a/llvm/unittests/BinaryFormat/MachOTest.cpp
+++ b/llvm/unittests/BinaryFormat/MachOTest.cpp
@@ -6,6 +6,7 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/ADT/bit.h"
#include "llvm/BinaryFormat/MachO.h"
#include "llvm/TargetParser/Triple.h"
#include "gtest/gtest.h"
@@ -13,7 +14,15 @@
using namespace llvm;
using namespace llvm::MachO;
-TEST(MachOTest, UnalignedLC) {
+#if BYTE_ORDER == BIG_ENDIAN
+// As discussed in Issue #86793, this test cannot work on a strict-alignment
+// targets like SPARC. Besides, it's undefined behaviour on big-endian hosts.
+#define MAYBE_UnalignedLC DISABLED_UnalignedLC
+#else
+#define MAYBE_UnalignedLC UnalignedLC
+#endif
+
+TEST(MachOTest, MAYBE_UnalignedLC) {
unsigned char Valid32BitMachO[] = {
0xCE, 0xFA, 0xED, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
diff --git a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
index cc868e7587dc..dc3380d35fda 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
+++ b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
@@ -43,10 +43,10 @@ add_llvm_unittest(OrcJITTests
TaskDispatchTest.cpp
ThreadSafeModuleTest.cpp
WrapperFunctionUtilsTest.cpp
+
+ EXPORT_SYMBOLS
)
target_link_libraries(OrcJITTests PRIVATE
LLVMTestingSupport
${ORC_JIT_TEST_LIBS})
-
-export_executable_symbols(OrcJITTests)
diff --git a/llvm/unittests/IR/ConstantRangeTest.cpp b/llvm/unittests/IR/ConstantRangeTest.cpp
index 1705f3e6af97..4815117458b9 100644
--- a/llvm/unittests/IR/ConstantRangeTest.cpp
+++ b/llvm/unittests/IR/ConstantRangeTest.cpp
@@ -228,6 +228,12 @@ static bool CheckNonSignWrappedOnly(const ConstantRange &CR1,
return !CR1.isSignWrappedSet() && !CR2.isSignWrappedSet();
}
+static bool
+CheckNoSignedWrappedLHSAndNoWrappedRHSOnly(const ConstantRange &CR1,
+ const ConstantRange &CR2) {
+ return !CR1.isSignWrappedSet() && !CR2.isWrappedSet();
+}
+
static bool CheckNonWrappedOrSignWrappedOnly(const ConstantRange &CR1,
const ConstantRange &CR2) {
return !CR1.isWrappedSet() && !CR1.isSignWrappedSet() &&
@@ -1506,7 +1512,9 @@ TEST_F(ConstantRangeTest, ShlWithNoWrap) {
using OBO = OverflowingBinaryOperator;
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
- return CR1.shlWithNoWrap(CR2, OBO::NoUnsignedWrap);
+ ConstantRange Res = CR1.shlWithNoWrap(CR2, OBO::NoUnsignedWrap);
+ EXPECT_TRUE(CR1.shl(CR2).contains(Res));
+ return Res;
},
[](const APInt &N1, const APInt &N2) -> std::optional<APInt> {
bool IsOverflow;
@@ -1515,7 +1523,7 @@ TEST_F(ConstantRangeTest, ShlWithNoWrap) {
return std::nullopt;
return Res;
},
- PreferSmallest, CheckCorrectnessOnly);
+ PreferSmallest, CheckNonWrappedOnly);
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.shlWithNoWrap(CR2, OBO::NoSignedWrap);
@@ -1527,7 +1535,7 @@ TEST_F(ConstantRangeTest, ShlWithNoWrap) {
return std::nullopt;
return Res;
},
- PreferSmallest, CheckCorrectnessOnly);
+ PreferSmallestSigned, CheckNoSignedWrappedLHSAndNoWrappedRHSOnly);
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.shlWithNoWrap(CR2, OBO::NoUnsignedWrap | OBO::NoSignedWrap);
@@ -1542,6 +1550,31 @@ TEST_F(ConstantRangeTest, ShlWithNoWrap) {
return Res1;
},
PreferSmallest, CheckCorrectnessOnly);
+
+ EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoSignedWrap),
+ ConstantRange(APInt(16, 10), APInt(16, 20481)));
+ EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoUnsignedWrap),
+ ConstantRange(APInt(16, 10), APInt(16, -24575)));
+ EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoSignedWrap | OBO::NoUnsignedWrap),
+ ConstantRange(APInt(16, 10), APInt(16, 20481)));
+ ConstantRange NegOne(APInt(16, 0xffff));
+ EXPECT_EQ(NegOne.shlWithNoWrap(Full, OBO::NoSignedWrap),
+ ConstantRange(APInt(16, -32768), APInt(16, 0)));
+ EXPECT_EQ(NegOne.shlWithNoWrap(Full, OBO::NoUnsignedWrap), NegOne);
+ EXPECT_EQ(ConstantRange(APInt(16, 768))
+ .shlWithNoWrap(Full, OBO::NoSignedWrap | OBO::NoUnsignedWrap),
+ ConstantRange(APInt(16, 768), APInt(16, 24577)));
+ EXPECT_EQ(Full.shlWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 16)),
+ OBO::NoUnsignedWrap),
+ ConstantRange(APInt(16, 0), APInt(16, -1)));
+ EXPECT_EQ(ConstantRange(APInt(4, 3), APInt(4, -8))
+ .shlWithNoWrap(ConstantRange(APInt(4, 0), APInt(4, 4)),
+ OBO::NoSignedWrap),
+ ConstantRange(APInt(4, 3), APInt(4, -8)));
+ EXPECT_EQ(ConstantRange(APInt(4, -1), APInt(4, 0))
+ .shlWithNoWrap(ConstantRange(APInt(4, 1), APInt(4, 4)),
+ OBO::NoSignedWrap),
+ ConstantRange(APInt(4, -8), APInt(4, -1)));
}
TEST_F(ConstantRangeTest, Lshr) {
diff --git a/llvm/unittests/Passes/Plugins/CMakeLists.txt b/llvm/unittests/Passes/Plugins/CMakeLists.txt
index e90cae167bc2..55d7e715014f 100644
--- a/llvm/unittests/Passes/Plugins/CMakeLists.txt
+++ b/llvm/unittests/Passes/Plugins/CMakeLists.txt
@@ -6,8 +6,9 @@ if (NOT WIN32 AND NOT CYGWIN)
set(LLVM_LINK_COMPONENTS Support Passes Core AsmParser)
add_llvm_unittest(PluginsTests
PluginsTest.cpp
+
+ EXPORT_SYMBOLS_FOR_PLUGINS
)
- export_executable_symbols_for_plugins(PluginsTests)
target_link_libraries(PluginsTests PRIVATE LLVMTestingSupport)
unset(LLVM_LINK_COMPONENTS)
diff --git a/llvm/unittests/ProfileData/PGOCtxProfReaderWriterTest.cpp b/llvm/unittests/ProfileData/PGOCtxProfReaderWriterTest.cpp
index 476f293780d8..7be01445558e 100644
--- a/llvm/unittests/ProfileData/PGOCtxProfReaderWriterTest.cpp
+++ b/llvm/unittests/ProfileData/PGOCtxProfReaderWriterTest.cpp
@@ -64,7 +64,7 @@ public:
const std::map<GUID, const ContextNode *> &roots() const { return Roots; }
};
-void checkSame(const ContextNode &Raw, const PGOContextualProfile &Profile) {
+void checkSame(const ContextNode &Raw, const PGOCtxProfContext &Profile) {
EXPECT_EQ(Raw.guid(), Profile.guid());
ASSERT_EQ(Raw.counters_size(), Profile.counters().size());
for (auto I = 0U; I < Raw.counters_size(); ++I)
diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
index 550c0576e023..f4b23784dc36 100644
--- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp
+++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
@@ -1475,6 +1475,147 @@ define void @foo(ptr %ptr, <2 x ptr> %ptrs) {
EXPECT_EQ(NewGEP2->getNextNode(), nullptr);
}
+TEST_F(SandboxIRTest, AllocaInst) {
+ parseIR(C, R"IR(
+define void @foo() {
+ %allocaScalar = alloca i32, align 1024
+ %allocaArray = alloca i32, i32 42
+ ret void
+}
+)IR");
+ DataLayout DL(M.get());
+ llvm::Function &LLVMF = *M->getFunction("foo");
+ llvm::BasicBlock *LLVMBB = &*LLVMF.begin();
+ auto LLVMIt = LLVMBB->begin();
+ auto *LLVMAllocaScalar = cast<llvm::AllocaInst>(&*LLVMIt++);
+ auto *LLVMAllocaArray = cast<llvm::AllocaInst>(&*LLVMIt++);
+
+ sandboxir::Context Ctx(C);
+ sandboxir::Function *F = Ctx.createFunction(&LLVMF);
+ auto *BB = &*F->begin();
+ auto It = BB->begin();
+ auto *AllocaScalar = cast<sandboxir::AllocaInst>(&*It++);
+ auto *AllocaArray = cast<sandboxir::AllocaInst>(&*It++);
+ auto *Ret = cast<sandboxir::ReturnInst>(&*It++);
+
+ // Check isArrayAllocation().
+ EXPECT_EQ(AllocaScalar->isArrayAllocation(),
+ LLVMAllocaScalar->isArrayAllocation());
+ EXPECT_EQ(AllocaArray->isArrayAllocation(),
+ LLVMAllocaArray->isArrayAllocation());
+ // Check getArraySize().
+ EXPECT_EQ(AllocaScalar->getArraySize(),
+ Ctx.getValue(LLVMAllocaScalar->getArraySize()));
+ EXPECT_EQ(AllocaArray->getArraySize(),
+ Ctx.getValue(LLVMAllocaArray->getArraySize()));
+ // Check getType().
+ EXPECT_EQ(AllocaScalar->getType(), LLVMAllocaScalar->getType());
+ EXPECT_EQ(AllocaArray->getType(), LLVMAllocaArray->getType());
+ // Check getAddressSpace().
+ EXPECT_EQ(AllocaScalar->getAddressSpace(),
+ LLVMAllocaScalar->getAddressSpace());
+ EXPECT_EQ(AllocaArray->getAddressSpace(), LLVMAllocaArray->getAddressSpace());
+ // Check getAllocationSize().
+ EXPECT_EQ(AllocaScalar->getAllocationSize(DL),
+ LLVMAllocaScalar->getAllocationSize(DL));
+ EXPECT_EQ(AllocaArray->getAllocationSize(DL),
+ LLVMAllocaArray->getAllocationSize(DL));
+ // Check getAllocationSizeInBits().
+ EXPECT_EQ(AllocaScalar->getAllocationSizeInBits(DL),
+ LLVMAllocaScalar->getAllocationSizeInBits(DL));
+ EXPECT_EQ(AllocaArray->getAllocationSizeInBits(DL),
+ LLVMAllocaArray->getAllocationSizeInBits(DL));
+ // Check getAllocatedType().
+ EXPECT_EQ(AllocaScalar->getAllocatedType(),
+ LLVMAllocaScalar->getAllocatedType());
+ EXPECT_EQ(AllocaArray->getAllocatedType(),
+ LLVMAllocaArray->getAllocatedType());
+ // Check setAllocatedType().
+ auto *OrigType = AllocaScalar->getAllocatedType();
+ auto *NewType = PointerType::get(C, 0);
+ EXPECT_NE(NewType, OrigType);
+ AllocaScalar->setAllocatedType(NewType);
+ EXPECT_EQ(AllocaScalar->getAllocatedType(), NewType);
+ AllocaScalar->setAllocatedType(OrigType);
+ EXPECT_EQ(AllocaScalar->getAllocatedType(), OrigType);
+ // Check getAlign().
+ EXPECT_EQ(AllocaScalar->getAlign(), LLVMAllocaScalar->getAlign());
+ EXPECT_EQ(AllocaArray->getAlign(), LLVMAllocaArray->getAlign());
+ // Check setAlignment().
+ Align OrigAlign = AllocaScalar->getAlign();
+ Align NewAlign(16);
+ EXPECT_NE(NewAlign, OrigAlign);
+ AllocaScalar->setAlignment(NewAlign);
+ EXPECT_EQ(AllocaScalar->getAlign(), NewAlign);
+ AllocaScalar->setAlignment(OrigAlign);
+ EXPECT_EQ(AllocaScalar->getAlign(), OrigAlign);
+ // Check isStaticAlloca().
+ EXPECT_EQ(AllocaScalar->isStaticAlloca(), LLVMAllocaScalar->isStaticAlloca());
+ EXPECT_EQ(AllocaArray->isStaticAlloca(), LLVMAllocaArray->isStaticAlloca());
+ // Check isUsedWithInAlloca(), setUsedWithInAlloca().
+ EXPECT_EQ(AllocaScalar->isUsedWithInAlloca(),
+ LLVMAllocaScalar->isUsedWithInAlloca());
+ bool OrigUsedWithInAlloca = AllocaScalar->isUsedWithInAlloca();
+ bool NewUsedWithInAlloca = true;
+ EXPECT_NE(NewUsedWithInAlloca, OrigUsedWithInAlloca);
+ AllocaScalar->setUsedWithInAlloca(NewUsedWithInAlloca);
+ EXPECT_EQ(AllocaScalar->isUsedWithInAlloca(), NewUsedWithInAlloca);
+ AllocaScalar->setUsedWithInAlloca(OrigUsedWithInAlloca);
+ EXPECT_EQ(AllocaScalar->isUsedWithInAlloca(), OrigUsedWithInAlloca);
+
+ auto *Ty = Type::getInt32Ty(C);
+ unsigned AddrSpace = 42;
+ auto *PtrTy = PointerType::get(C, AddrSpace);
+ auto *ArraySize = sandboxir::Constant::createInt(Ty, 43, Ctx);
+ {
+ // Check create() WhereIt, WhereBB.
+ auto *NewI = cast<sandboxir::AllocaInst>(sandboxir::AllocaInst::create(
+ Ty, AddrSpace, /*WhereIt=*/Ret->getIterator(),
+ /*WhereBB=*/Ret->getParent(), Ctx, ArraySize, "NewAlloca1"));
+ // Check getOpcode().
+ EXPECT_EQ(NewI->getOpcode(), sandboxir::Instruction::Opcode::Alloca);
+ // Check getType().
+ EXPECT_EQ(NewI->getType(), PtrTy);
+ // Check getArraySize().
+ EXPECT_EQ(NewI->getArraySize(), ArraySize);
+ // Check getAddrSpace().
+ EXPECT_EQ(NewI->getAddressSpace(), AddrSpace);
+ // Check instr position.
+ EXPECT_EQ(NewI->getNextNode(), Ret);
+ }
+ {
+ // Check create() InsertBefore.
+ auto *NewI = cast<sandboxir::AllocaInst>(sandboxir::AllocaInst::create(
+ Ty, AddrSpace, /*InsertBefore=*/Ret, Ctx, ArraySize, "NewAlloca2"));
+ // Check getOpcode().
+ EXPECT_EQ(NewI->getOpcode(), sandboxir::Instruction::Opcode::Alloca);
+ // Check getType().
+ EXPECT_EQ(NewI->getType(), PtrTy);
+ // Check getArraySize().
+ EXPECT_EQ(NewI->getArraySize(), ArraySize);
+ // Check getAddrSpace().
+ EXPECT_EQ(NewI->getAddressSpace(), AddrSpace);
+ // Check instr position.
+ EXPECT_EQ(NewI->getNextNode(), Ret);
+ }
+ {
+ // Check create() InsertAtEnd.
+ auto *NewI = cast<sandboxir::AllocaInst>(sandboxir::AllocaInst::create(
+ Ty, AddrSpace, /*InsertAtEnd=*/BB, Ctx, ArraySize, "NewAlloca3"));
+ // Check getOpcode().
+ EXPECT_EQ(NewI->getOpcode(), sandboxir::Instruction::Opcode::Alloca);
+ // Check getType().
+ EXPECT_EQ(NewI->getType(), PtrTy);
+ // Check getArraySize().
+ EXPECT_EQ(NewI->getArraySize(), ArraySize);
+ // Check getAddrSpace().
+ EXPECT_EQ(NewI->getAddressSpace(), AddrSpace);
+ // Check instr position.
+ EXPECT_EQ(NewI->getParent(), BB);
+ EXPECT_EQ(NewI->getNextNode(), nullptr);
+ }
+}
+
TEST_F(SandboxIRTest, CastInst) {
parseIR(C, R"IR(
define void @foo(i32 %arg, float %farg, double %darg, ptr %ptr) {
@@ -1925,10 +2066,17 @@ bb1:
br label %bb2
bb2:
- %phi = phi i32 [ %arg, %bb1 ], [ 0, %bb2 ]
+ %phi = phi i32 [ %arg, %bb1 ], [ 0, %bb2 ], [ 1, %bb3 ], [ 2, %bb4 ], [ 3, %bb5 ]
br label %bb2
bb3:
+ br label %bb2
+
+bb4:
+ br label %bb2
+
+bb5:
+ br label %bb2
ret void
}
)IR");
@@ -2023,7 +2171,29 @@ bb3:
EXPECT_EQ(PHI->hasConstantOrUndefValue(), LLVMPHI->hasConstantOrUndefValue());
// Check isComplete().
EXPECT_EQ(PHI->isComplete(), LLVMPHI->isComplete());
-
+ // Check replaceIncomingValueIf
+ EXPECT_EQ(PHI->getNumIncomingValues(), 5u);
+ auto *RemainBB0 = PHI->getIncomingBlock(0);
+ auto *RemoveBB0 = PHI->getIncomingBlock(1);
+ auto *RemainBB1 = PHI->getIncomingBlock(2);
+ auto *RemoveBB1 = PHI->getIncomingBlock(3);
+ auto *RemainBB2 = PHI->getIncomingBlock(4);
+ PHI->removeIncomingValueIf([&](unsigned Idx) {
+ return PHI->getIncomingBlock(Idx) == RemoveBB0 ||
+ PHI->getIncomingBlock(Idx) == RemoveBB1;
+ });
+ EXPECT_EQ(PHI->getNumIncomingValues(), 3u);
+ EXPECT_EQ(PHI->getIncomingBlock(0), RemainBB0);
+ EXPECT_EQ(PHI->getIncomingBlock(1), RemainBB1);
+ EXPECT_EQ(PHI->getIncomingBlock(2), RemainBB2);
+ // Check replaceIncomingBlockWith
+ OrigBB = RemainBB0;
+ auto *NewBB = RemainBB1;
+ EXPECT_NE(NewBB, OrigBB);
+ PHI->replaceIncomingBlockWith(OrigBB, NewBB);
+ EXPECT_EQ(PHI->getIncomingBlock(0), NewBB);
+ EXPECT_EQ(PHI->getIncomingBlock(1), RemainBB1);
+ EXPECT_EQ(PHI->getIncomingBlock(2), RemainBB2);
// Check create().
auto *NewPHI = cast<sandboxir::PHINode>(
sandboxir::PHINode::create(PHI->getType(), 0, Br, Ctx, "NewPHI"));
@@ -2037,3 +2207,29 @@ bb3:
}
EXPECT_EQ(NewPHI->getNumIncomingValues(), PHI->getNumIncomingValues());
}
+
+TEST_F(SandboxIRTest, UnreachableInst) {
+ parseIR(C, R"IR(
+define void @foo() {
+ unreachable
+}
+)IR");
+ llvm::Function *LLVMF = &*M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+ sandboxir::Function *F = Ctx.createFunction(LLVMF);
+ auto *BB = &*F->begin();
+ auto It = BB->begin();
+ auto *UI = cast<sandboxir::UnreachableInst>(&*It++);
+
+ EXPECT_EQ(UI->getNumSuccessors(), 0u);
+ EXPECT_EQ(UI->getNumOfIRInstrs(), 1u);
+ // Check create(InsertBefore)
+ sandboxir::UnreachableInst *NewUI =
+ sandboxir::UnreachableInst::create(/*InsertBefore=*/UI, Ctx);
+ EXPECT_EQ(NewUI->getNextNode(), UI);
+ // Check create(InsertAtEnd)
+ sandboxir::UnreachableInst *NewUIEnd =
+ sandboxir::UnreachableInst::create(/*InsertAtEnd=*/BB, Ctx);
+ EXPECT_EQ(NewUIEnd->getParent(), BB);
+ EXPECT_EQ(NewUIEnd->getNextNode(), nullptr);
+}
diff --git a/llvm/unittests/SandboxIR/TrackerTest.cpp b/llvm/unittests/SandboxIR/TrackerTest.cpp
index e61258392a38..a8cf41a177d1 100644
--- a/llvm/unittests/SandboxIR/TrackerTest.cpp
+++ b/llvm/unittests/SandboxIR/TrackerTest.cpp
@@ -644,6 +644,51 @@ define void @foo(i8 %arg) {
EXPECT_EQ(Invoke->getSuccessor(1), ExceptionBB);
}
+TEST_F(TrackerTest, AllocaInstSetters) {
+ parseIR(C, R"IR(
+define void @foo(i8 %arg) {
+ %alloca = alloca i32, align 64
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+ auto &F = *Ctx.createFunction(&LLVMF);
+ auto *BB = &*F.begin();
+ auto It = BB->begin();
+ auto *Alloca = cast<sandboxir::AllocaInst>(&*It++);
+
+ // Check setAllocatedType().
+ Ctx.save();
+ auto *OrigTy = Alloca->getAllocatedType();
+ auto *NewTy = Type::getInt64Ty(C);
+ EXPECT_NE(NewTy, OrigTy);
+ Alloca->setAllocatedType(NewTy);
+ EXPECT_EQ(Alloca->getAllocatedType(), NewTy);
+ Ctx.revert();
+ EXPECT_EQ(Alloca->getAllocatedType(), OrigTy);
+
+ // Check setAlignment().
+ Ctx.save();
+ auto OrigAlign = Alloca->getAlign();
+ Align NewAlign(128);
+ EXPECT_NE(NewAlign, OrigAlign);
+ Alloca->setAlignment(NewAlign);
+ EXPECT_EQ(Alloca->getAlign(), NewAlign);
+ Ctx.revert();
+ EXPECT_EQ(Alloca->getAlign(), OrigAlign);
+
+ // Check setUsedWithInAlloca().
+ Ctx.save();
+ auto OrigWIA = Alloca->isUsedWithInAlloca();
+ bool NewWIA = true;
+ EXPECT_NE(NewWIA, OrigWIA);
+ Alloca->setUsedWithInAlloca(NewWIA);
+ EXPECT_EQ(Alloca->isUsedWithInAlloca(), NewWIA);
+ Ctx.revert();
+ EXPECT_EQ(Alloca->isUsedWithInAlloca(), OrigWIA);
+}
+
TEST_F(TrackerTest, CallBrSetters) {
parseIR(C, R"IR(
define void @foo(i8 %arg) {
@@ -779,6 +824,15 @@ bb2:
EXPECT_EQ(PHI->getIncomingBlock(1), BB1);
EXPECT_EQ(PHI->getIncomingValue(1), Arg1);
+ // Check removeIncomingValueIf(FromBB1).
+ Ctx.save();
+ PHI->removeIncomingValueIf(
+ [&](unsigned Idx) { return PHI->getIncomingBlock(Idx) == BB1; });
+ EXPECT_EQ(PHI->getNumIncomingValues(), 1u);
+ Ctx.revert();
+ EXPECT_EQ(PHI->getNumIncomingValues(), 2u);
+ EXPECT_EQ(PHI->getIncomingBlock(0), BB0);
+ EXPECT_EQ(PHI->getIncomingBlock(1), BB1);
// Check removeIncomingValue() remove all.
Ctx.save();
PHI->removeIncomingValue(0u);
diff --git a/llvm/unittests/Support/CMakeLists.txt b/llvm/unittests/Support/CMakeLists.txt
index 631f2e6bf00d..db47a170e814 100644
--- a/llvm/unittests/Support/CMakeLists.txt
+++ b/llvm/unittests/Support/CMakeLists.txt
@@ -44,6 +44,7 @@ add_llvm_unittest(SupportTests
FileOutputBufferTest.cpp
FormatVariadicTest.cpp
FSUniqueIDTest.cpp
+ GenericDomTreeTest.cpp
GlobPatternTest.cpp
HashBuilderTest.cpp
IndexedAccessorTest.cpp
diff --git a/llvm/unittests/Support/DynamicLibrary/CMakeLists.txt b/llvm/unittests/Support/DynamicLibrary/CMakeLists.txt
index 4574acd62906..d8dff1ef4a3f 100644
--- a/llvm/unittests/Support/DynamicLibrary/CMakeLists.txt
+++ b/llvm/unittests/Support/DynamicLibrary/CMakeLists.txt
@@ -17,9 +17,10 @@ set_output_directory(DynamicLibraryLib
add_llvm_unittest(DynamicLibraryTests
DynamicLibraryTest.cpp
+
+ EXPORT_SYMBOLS
)
target_link_libraries(DynamicLibraryTests PRIVATE DynamicLibraryLib)
-export_executable_symbols(DynamicLibraryTests)
function(dynlib_add_module NAME)
add_library(${NAME} MODULE
@@ -38,7 +39,7 @@ function(dynlib_add_module NAME)
)
add_dependencies(DynamicLibraryTests ${NAME})
-
+
if(LLVM_INTEGRATED_CRT_ALLOC)
# We need to link in the Support lib for the Memory allocator override,
# otherwise the DynamicLibrary.Shutdown test will fail, because it would
@@ -48,7 +49,7 @@ function(dynlib_add_module NAME)
llvm_map_components_to_libnames(llvm_libs Support)
target_link_libraries(${NAME} ${llvm_libs} "-INCLUDE:malloc")
endif()
-
+
endfunction(dynlib_add_module)
# Revert -Wl,-z,nodelete on this test since it relies on the file
diff --git a/llvm/unittests/Support/GenericDomTreeTest.cpp b/llvm/unittests/Support/GenericDomTreeTest.cpp
new file mode 100644
index 000000000000..f0f87e3a9890
--- /dev/null
+++ b/llvm/unittests/Support/GenericDomTreeTest.cpp
@@ -0,0 +1,109 @@
+//===- unittests/Support/GenericDomTreeTest.cpp - GenericDomTree.h 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/Support/GenericDomTree.h"
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/Support/DataTypes.h"
+#include "gtest/gtest.h"
+using namespace llvm;
+
+namespace {
+
+// Very simple (fake) graph structure to test dominator tree on.
+struct NumberedGraph;
+
+struct NumberedNode {
+ NumberedGraph *Parent;
+ unsigned Number;
+
+ NumberedNode(NumberedGraph *Parent, unsigned Number)
+ : Parent(Parent), Number(Number) {}
+
+ NumberedGraph *getParent() const { return Parent; }
+};
+
+struct NumberedGraph {
+ SmallVector<std::unique_ptr<NumberedNode>> Nodes;
+ unsigned NumberEpoch = 0;
+
+ NumberedNode *addNode() {
+ unsigned Num = Nodes.size();
+ return Nodes.emplace_back(std::make_unique<NumberedNode>(this, Num)).get();
+ }
+};
+} // namespace
+
+namespace llvm {
+template <> struct GraphTraits<NumberedNode *> {
+ using NodeRef = NumberedNode *;
+ static unsigned getNumber(NumberedNode *Node) { return Node->Number; }
+};
+
+template <> struct GraphTraits<const NumberedNode *> {
+ using NodeRef = NumberedNode *;
+ static unsigned getNumber(const NumberedNode *Node) { return Node->Number; }
+};
+
+template <> struct GraphTraits<NumberedGraph *> {
+ using NodeRef = NumberedNode *;
+ static unsigned getMaxNumber(NumberedGraph *G) { return G->Nodes.size(); }
+ static unsigned getNumberEpoch(NumberedGraph *G) { return G->NumberEpoch; }
+};
+
+namespace DomTreeBuilder {
+// Dummy specialization. Only needed so that we can call recalculate(), which
+// sets DT.Parent -- but we can't access DT.Parent here.
+template <> void Calculate(DomTreeBase<NumberedNode> &DT) {}
+} // end namespace DomTreeBuilder
+} // end namespace llvm
+
+namespace {
+
+TEST(GenericDomTree, BlockNumbers) {
+ NumberedGraph G;
+ NumberedNode *N1 = G.addNode();
+ NumberedNode *N2 = G.addNode();
+
+ DomTreeBase<NumberedNode> DT;
+ DT.recalculate(G); // only sets parent
+ // Construct fake domtree: node 0 dominates all other nodes
+ DT.setNewRoot(N1);
+ DT.addNewBlock(N2, N1);
+
+ // Roundtrip is correct
+ for (auto &N : G.Nodes)
+ EXPECT_EQ(DT.getNode(N.get())->getBlock(), N.get());
+ // If we manually change a number, we should get a different node.
+ ASSERT_EQ(N1->Number, 0u);
+ ASSERT_EQ(N2->Number, 1u);
+ N1->Number = 1;
+ EXPECT_EQ(DT.getNode(N1)->getBlock(), N2);
+ EXPECT_EQ(DT.getNode(N2)->getBlock(), N2);
+ N2->Number = 0;
+ EXPECT_EQ(DT.getNode(N2)->getBlock(), N1);
+
+ // Renumer blocks, should fix node domtree-internal node map
+ DT.updateBlockNumbers();
+ for (auto &N : G.Nodes)
+ EXPECT_EQ(DT.getNode(N.get())->getBlock(), N.get());
+
+ // Adding a new node with a higher number is no problem
+ NumberedNode *N3 = G.addNode();
+ EXPECT_EQ(DT.getNode(N3), nullptr);
+ // ... even if it exceeds getMaxNumber()
+ NumberedNode *N4 = G.addNode();
+ N4->Number = 1000;
+ EXPECT_EQ(DT.getNode(N4), nullptr);
+
+ DT.addNewBlock(N3, N1);
+ DT.addNewBlock(N4, N1);
+ for (auto &N : G.Nodes)
+ EXPECT_EQ(DT.getNode(N.get())->getBlock(), N.get());
+}
+
+} // namespace
diff --git a/llvm/unittests/TargetParser/TargetParserTest.cpp b/llvm/unittests/TargetParser/TargetParserTest.cpp
index 3d55b0309d26..9efebeba0677 100644
--- a/llvm/unittests/TargetParser/TargetParserTest.cpp
+++ b/llvm/unittests/TargetParser/TargetParserTest.cpp
@@ -1591,7 +1591,7 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT, AArch64::AEK_FCMA,
- AArch64::AEK_PAUTH, AArch64::AEK_PERFMON}),
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC, AArch64::AEK_PERFMON}),
AArch64CPUTestParams(
"apple-m2", "armv8.6-a",
{AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2,
@@ -1600,7 +1600,7 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT, AArch64::AEK_FCMA,
- AArch64::AEK_PAUTH, AArch64::AEK_PERFMON}),
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC, AArch64::AEK_PERFMON}),
AArch64CPUTestParams(
"apple-a16", "armv8.6-a",
{AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2,
@@ -1609,7 +1609,8 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT, AArch64::AEK_FCMA,
- AArch64::AEK_PAUTH, AArch64::AEK_PERFMON, AArch64::AEK_HCX}),
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC, AArch64::AEK_PERFMON,
+ AArch64::AEK_HCX}),
AArch64CPUTestParams(
"apple-m3", "armv8.6-a",
{AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2,
@@ -1618,7 +1619,8 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT, AArch64::AEK_FCMA,
- AArch64::AEK_PAUTH, AArch64::AEK_PERFMON, AArch64::AEK_HCX}),
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC, AArch64::AEK_PERFMON,
+ AArch64::AEK_HCX}),
AArch64CPUTestParams(
"apple-a17", "armv8.6-a",
{AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2,
@@ -1627,7 +1629,8 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT, AArch64::AEK_FCMA,
- AArch64::AEK_PAUTH, AArch64::AEK_PERFMON, AArch64::AEK_HCX}),
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC, AArch64::AEK_PERFMON,
+ AArch64::AEK_HCX}),
AArch64CPUTestParams("apple-m4", "armv9.2-a",
{AArch64::AEK_CRC, AArch64::AEK_AES,
AArch64::AEK_SHA2, AArch64::AEK_SHA3,
@@ -1637,10 +1640,10 @@ INSTANTIATE_TEST_SUITE_P(
AArch64::AEK_DOTPROD, AArch64::AEK_FP16,
AArch64::AEK_FP16FML, AArch64::AEK_BF16,
AArch64::AEK_I8MM, AArch64::AEK_JSCVT,
- AArch64::AEK_FCMA, AArch64::AEK_PAUTH,
+ AArch64::AEK_PAUTH, AArch64::AEK_FPAC,
+ AArch64::AEK_FCMA, AArch64::AEK_PERFMON,
AArch64::AEK_SME, AArch64::AEK_SME2,
- AArch64::AEK_SMEF64F64, AArch64::AEK_SMEI16I64,
- AArch64::AEK_PERFMON}),
+ AArch64::AEK_SMEF64F64, AArch64::AEK_SMEI16I64}),
AArch64CPUTestParams("exynos-m3", "armv8-a",
{AArch64::AEK_CRC, AArch64::AEK_AES,
AArch64::AEK_SHA2, AArch64::AEK_FP,
@@ -2005,7 +2008,7 @@ TEST(TargetParserTest, AArch64ExtensionFeatures) {
AArch64::AEK_CPA, AArch64::AEK_PAUTHLR,
AArch64::AEK_TLBIW, AArch64::AEK_JSCVT,
AArch64::AEK_FCMA, AArch64::AEK_FP8,
-
+ AArch64::AEK_SVEB16B16,
};
std::vector<StringRef> Features;
@@ -2037,6 +2040,7 @@ TEST(TargetParserTest, AArch64ExtensionFeatures) {
EXPECT_TRUE(llvm::is_contained(Features, "+spe"));
EXPECT_TRUE(llvm::is_contained(Features, "+ras"));
EXPECT_TRUE(llvm::is_contained(Features, "+sve"));
+ EXPECT_TRUE(llvm::is_contained(Features, "+sve-b16b16"));
EXPECT_TRUE(llvm::is_contained(Features, "+sve2"));
EXPECT_TRUE(llvm::is_contained(Features, "+sve2-aes"));
EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sm4"));
@@ -2188,6 +2192,7 @@ TEST(TargetParserTest, AArch64ArchExtFeature) {
{"lse", "nolse", "+lse", "-lse"},
{"rdm", "nordm", "+rdm", "-rdm"},
{"sve", "nosve", "+sve", "-sve"},
+ {"sve-b16b16", "nosve-b16b16", "+sve-b16b16", "-sve-b16b16"},
{"sve2", "nosve2", "+sve2", "-sve2"},
{"sve2-aes", "nosve2-aes", "+sve2-aes", "-sve2-aes"},
{"sve2-sm4", "nosve2-sm4", "+sve2-sm4", "-sve2-sm4"},
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-31 10:57:16 +0000