159 lines · cpp
1//===--------- ExecutorAddrTest.cpp - Unit tests for ExecutorAddr ---------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"10#include "OrcTestCommon.h"11#include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"12 13using namespace llvm;14using namespace llvm::orc;15 16namespace {17 18TEST(ExecutorAddrTest, DefaultAndNull) {19 // Check that default constructed values and isNull behave as expected.20 21 ExecutorAddr Default;22 ExecutorAddr Null(0);23 ExecutorAddr NonNull(1);24 25 EXPECT_TRUE(Null.isNull());26 EXPECT_EQ(Default, Null);27 28 EXPECT_FALSE(NonNull.isNull());29 EXPECT_NE(Default, NonNull);30}31 32TEST(ExecutorAddrTest, Ordering) {33 // Check that ordering operations.34 ExecutorAddr A1(1), A2(2);35 36 EXPECT_LE(A1, A1);37 EXPECT_LT(A1, A2);38 EXPECT_GT(A2, A1);39 EXPECT_GE(A2, A2);40}41 42TEST(ExecutorAddrTest, PtrConversion) {43 // Test toPtr / fromPtr round-tripping.44 int X = 0;45 auto XAddr = ExecutorAddr::fromPtr(&X);46 int *XPtr = XAddr.toPtr<int *>();47 48 EXPECT_EQ(XPtr, &X);49}50 51static void F() {}52 53TEST(ExecutorAddrTest, PtrConversionWithFunctionType) {54 // Test that function types (as opposed to function pointer types) can be55 // used with toPtr.56 auto FAddr = ExecutorAddr::fromPtr(F);57 void (*FPtr)() = FAddr.toPtr<void()>();58 59 EXPECT_EQ(FPtr, &F);60}61 62TEST(ExecutorAddrTest, WrappingAndUnwrapping) {63 constexpr uintptr_t RawAddr = 0x123456;64 int *RawPtr = (int *)RawAddr;65 66 constexpr uintptr_t TagOffset = 8 * (sizeof(uintptr_t) - 1);67 uintptr_t TagVal = 0xA5;68 uintptr_t TagBits = TagVal << TagOffset;69 void *TaggedPtr = (void *)((uintptr_t)RawPtr | TagBits);70 71 ExecutorAddr EA =72 ExecutorAddr::fromPtr(TaggedPtr, ExecutorAddr::Untag(8, TagOffset));73 74 EXPECT_EQ(EA.getValue(), RawAddr);75 76 void *ReconstitutedTaggedPtr =77 EA.toPtr<void *>(ExecutorAddr::Tag(TagVal, TagOffset));78 79 EXPECT_EQ(TaggedPtr, ReconstitutedTaggedPtr);80}81 82TEST(ExecutorAddrTest, AddrRanges) {83 ExecutorAddr A0(0), A1(1), A2(2), A3(3);84 ExecutorAddrRange R0(A0, A1), R1(A1, A2), R2(A2, A3), R3(A0, A2), R4(A1, A3);85 // 01286 // R0: # -- Before R187 // R1: # --88 // R2: # -- After R189 // R3: ## -- Overlaps R1 start90 // R4: ## -- Overlaps R1 end91 92 EXPECT_EQ(R1, ExecutorAddrRange(A1, A2));93 EXPECT_EQ(R1, ExecutorAddrRange(A1, ExecutorAddrDiff(1)));94 EXPECT_NE(R1, R2);95 96 EXPECT_TRUE(R1.contains(A1));97 EXPECT_FALSE(R1.contains(A0));98 EXPECT_FALSE(R1.contains(A2));99 100 EXPECT_TRUE(R3.contains(R0)); // True for singleton range at start.101 EXPECT_TRUE(R3.contains(R1)); // True for singleton range at end.102 EXPECT_FALSE(R3.contains(R2)); // False for non-overlaping singleton range.103 EXPECT_FALSE(R3.contains(R4)); // False for overlapping, uncontained range.104 105 EXPECT_FALSE(R1.overlaps(R0));106 EXPECT_FALSE(R1.overlaps(R2));107 EXPECT_TRUE(R1.overlaps(R3));108 EXPECT_TRUE(R1.overlaps(R4));109 EXPECT_TRUE(R3.overlaps(R4));110 111 EXPECT_LE(R0, R0);112 EXPECT_LT(R0, R1);113 EXPECT_GE(R0, R0);114 EXPECT_GT(R1, R0);115 116 // Check fromPtr support.117 char A[10];118 auto RP1 = ExecutorAddrRange::fromPtrRange(A, A + 10);119 EXPECT_EQ(RP1.Start.toPtr<char *>(), A);120 EXPECT_EQ(RP1.End.toPtr<char *>(), A + 10);121 122 auto RP2 = ExecutorAddrRange::fromPtrRange(A, 10);123 EXPECT_EQ(RP2.Start.toPtr<char *>(), A);124 EXPECT_EQ(RP2.End.toPtr<char *>(), A + 10);125}126 127TEST(ExecutorSymbolDef, PointerConversion) {128 int X = 0;129 130 auto XHiddenSym = ExecutorSymbolDef::fromPtr(&X);131 int *XHiddenPtr = XHiddenSym.toPtr<int *>();132 133 auto XExportedSym = ExecutorSymbolDef::fromPtr(&X, JITSymbolFlags::Exported);134 int *XExportedPtr = XExportedSym.toPtr<int *>();135 136 EXPECT_EQ(XHiddenPtr, &X);137 EXPECT_EQ(XExportedPtr, &X);138 139 EXPECT_EQ(XHiddenSym.getFlags(), JITSymbolFlags());140 EXPECT_EQ(XExportedSym.getFlags(), JITSymbolFlags::Exported);141}142 143TEST(ExecutorSymbolDef, FunctionPointerConversion) {144 auto FHiddenSym = ExecutorSymbolDef::fromPtr(&F);145 void (*FHiddenPtr)() = FHiddenSym.toPtr<void()>();146 147 auto FExportedSym = ExecutorSymbolDef::fromPtr(&F, JITSymbolFlags::Exported);148 void (*FExportedPtr)() = FExportedSym.toPtr<void()>();149 150 EXPECT_EQ(FHiddenPtr, &F);151 EXPECT_EQ(FExportedPtr, &F);152 153 EXPECT_EQ(FHiddenSym.getFlags(), JITSymbolFlags::Callable);154 EXPECT_EQ(FExportedSym.getFlags(),155 JITSymbolFlags::Exported | JITSymbolFlags::Callable);156}157 158} // namespace159