llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp

   1 //===- llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp ---------===//
   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-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "DirectXIRPasses/PointerTypeAnalysis.h"
  10 #include "llvm/AsmParser/Parser.h"
  11 #include "llvm/IR/Instructions.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Type.h"
  14 #include "llvm/IR/TypedPointerType.h"
  15 #include "llvm/Support/SourceMgr.h"
  16
  17 #include "gmock/gmock.h"
  18 #include "gtest/gtest.h"
  19
  20 using ::testing::Contains;
  21 using ::testing::Pair;
  22
  23 using namespace llvm;
  24 using namespace llvm::dxil;
  25
  26 template <typename T> struct IsA {
  27   friend bool operator==(const Value *V, const IsA &) { return isa<T>(V); }
  28 };
  29
  30 TEST(PointerTypeAnalysis, DigressToi8) {
  31   StringRef Assembly = R"(
  32     define i64 @test(ptr %p) {
  33       store i32 0, ptr %p
  34       %v = load i64, ptr %p
  35       ret i64 %v
  36     }
  37   )";
  38
  39   LLVMContext Context;
  40   SMDiagnostic Error;
  41   auto M = parseAssemblyString(Assembly, Error, Context);
  42   ASSERT_TRUE(M) << "Bad assembly?";
  43
  44   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
  45   ASSERT_EQ(Map.size(), 2u);
  46   Type *I8Ptr = TypedPointerType::get(Type::getInt8Ty(Context), 0);
  47   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I8Ptr}, false);
  48
  49   EXPECT_THAT(Map,
  50               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
  51   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I8Ptr)));
  52 }
  53
  54 TEST(PointerTypeAnalysis, DiscoverStore) {
  55   StringRef Assembly = R"(
  56     define i32 @test(ptr %p) {
  57       store i32 0, ptr %p
  58       ret i32 0
  59     }
  60   )";
  61
  62   LLVMContext Context;
  63   SMDiagnostic Error;
  64   auto M = parseAssemblyString(Assembly, Error, Context);
  65   ASSERT_TRUE(M) << "Bad assembly?";
  66
  67   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
  68   ASSERT_EQ(Map.size(), 2u);
  69   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
  70   Type *FnTy = FunctionType::get(Type::getInt32Ty(Context), {I32Ptr}, false);
  71
  72   EXPECT_THAT(Map,
  73               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
  74   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I32Ptr)));
  75 }
  76
  77 TEST(PointerTypeAnalysis, DiscoverLoad) {
  78   StringRef Assembly = R"(
  79     define i32 @test(ptr %p) {
  80       %v = load i32, ptr %p
  81       ret i32 %v
  82     }
  83   )";
  84
  85   LLVMContext Context;
  86   SMDiagnostic Error;
  87   auto M = parseAssemblyString(Assembly, Error, Context);
  88   ASSERT_TRUE(M) << "Bad assembly?";
  89
  90   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
  91   ASSERT_EQ(Map.size(), 2u);
  92   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
  93   Type *FnTy = FunctionType::get(Type::getInt32Ty(Context), {I32Ptr}, false);
  94
  95   EXPECT_THAT(Map,
  96               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
  97   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I32Ptr)));
  98 }
  99
 100 TEST(PointerTypeAnalysis, DiscoverGEP) {
 101   StringRef Assembly = R"(
 102     define ptr @test(ptr %p) {
 103       %p2 = getelementptr i64, ptr %p, i64 1
 104       ret ptr %p2
 105     }
 106   )";
 107
 108   LLVMContext Context;
 109   SMDiagnostic Error;
 110   auto M = parseAssemblyString(Assembly, Error, Context);
 111   ASSERT_TRUE(M) << "Bad assembly?";
 112
 113   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
 114   ASSERT_EQ(Map.size(), 3u);
 115
 116   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
 117   Type *FnTy = FunctionType::get(I64Ptr, {I64Ptr}, false);
 118
 119   EXPECT_THAT(Map,
 120               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
 121   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I64Ptr)));
 122   EXPECT_THAT(Map, Contains(Pair(IsA<GetElementPtrInst>(), I64Ptr)));
 123 }
 124
 125 TEST(PointerTypeAnalysis, TraceIndirect) {
 126   StringRef Assembly = R"(
 127     define i64 @test(ptr %p) {
 128       %p2 = load ptr, ptr %p
 129       %v = load i64, ptr %p2
 130       ret i64 %v
 131     }
 132   )";
 133
 134   LLVMContext Context;
 135   SMDiagnostic Error;
 136   auto M = parseAssemblyString(Assembly, Error, Context);
 137   ASSERT_TRUE(M) << "Bad assembly?";
 138
 139   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
 140   ASSERT_EQ(Map.size(), 3u);
 141
 142   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
 143   Type *I64PtrPtr = TypedPointerType::get(I64Ptr, 0);
 144   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I64PtrPtr}, false);
 145
 146   EXPECT_THAT(Map,
 147               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
 148   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I64PtrPtr)));
 149   EXPECT_THAT(Map, Contains(Pair(IsA<LoadInst>(), I64Ptr)));
 150 }
 151
 152 TEST(PointerTypeAnalysis, WithNoOpCasts) {
 153   StringRef Assembly = R"(
 154     define i64 @test(ptr %p) {
 155       %1 = bitcast ptr %p to ptr
 156       %2 = bitcast ptr %p to ptr
 157       store i32 0, ptr %1, align 4
 158       %3 = load i64, ptr %2, align 8
 159       ret i64 %3
 160     }
 161   )";
 162
 163   LLVMContext Context;
 164   SMDiagnostic Error;
 165   auto M = parseAssemblyString(Assembly, Error, Context);
 166   ASSERT_TRUE(M) << "Bad assembly?";
 167
 168   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
 169   ASSERT_EQ(Map.size(), 4u);
 170
 171   Type *I8Ptr = TypedPointerType::get(Type::getInt8Ty(Context), 0);
 172   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
 173   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
 174   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I8Ptr}, false);
 175
 176   EXPECT_THAT(Map,
 177               Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
 178   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I8Ptr)));
 179   EXPECT_THAT(Map, Contains(Pair(IsA<BitCastInst>(), I64Ptr)));
 180   EXPECT_THAT(Map, Contains(Pair(IsA<BitCastInst>(), I32Ptr)));
 181 }