1// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s 2// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -cl-std=CL2.0 -emit-llvm -o - | FileCheck --check-prefix=CHECK-NOFAKE %s 3// When -ffake-address-space-map is not used, all addr space mapped to 0 for x86_64. 4 5// test that we generate address space casts everywhere we need conversions of 6// pointers to different address spaces 7 8// CHECK: define{{.*}} void @test 9void test(global int *arg_glob, generic int *arg_gen, 10 __attribute__((opencl_global_device)) int *arg_device, 11 __attribute__((opencl_global_host)) int *arg_host) { 12 int var_priv; 13 arg_gen = arg_glob; // implicit cast global -> generic 14 // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(4)* 15 // CHECK-NOFAKE-NOT: addrspacecast 16 17 arg_gen = &var_priv; // implicit cast with obtaining adr, private -> generic 18 // CHECK: %{{[._a-z0-9]+}} = addrspacecast i32* %{{[._a-z0-9]+}} to i32 addrspace(4)* 19 // CHECK-NOFAKE-NOT: addrspacecast 20 21 arg_glob = (global int *)arg_gen; // explicit cast 22 // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(4)* %{{[0-9]+}} to i32 addrspace(1)* 23 // CHECK-NOFAKE-NOT: addrspacecast 24 25 global int *var_glob = 26 (global int *)arg_glob; // explicit cast in the same address space 27 // CHECK-NOT: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(1)* 28 // CHECK-NOFAKE-NOT: addrspacecast 29 30 var_priv = arg_gen - arg_glob; // arithmetic operation 31 // CHECK: %{{.*}} = ptrtoint i32 addrspace(4)* %{{.*}} to i64 32 // CHECK: %{{.*}} = ptrtoint i32 addrspace(1)* %{{.*}} to i64 33 // CHECK-NOFAKE: %{{.*}} = ptrtoint i32* %{{.*}} to i64 34 // CHECK-NOFAKE: %{{.*}} = ptrtoint i32* %{{.*}} to i64 35 36 var_priv = arg_gen > arg_glob; // comparison 37 // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(4)* 38 39 generic void *var_gen_v = arg_glob; 40 // CHECK: addrspacecast 41 // CHECK-NOT: bitcast 42 // CHECK-NOFAKE: bitcast 43 // CHECK-NOFAKE-NOT: addrspacecast 44 45 arg_glob = arg_device; // implicit cast 46 // CHECK: addrspacecast 47 // CHECK-NOFAKE-NOT: addrspacecast 48 49 arg_glob = arg_host; // implicit cast 50 // CHECK: addrspacecast 51 // CHECK-NOFAKE-NOT: addrspacecast 52 53 arg_glob = (global int *)arg_device; // explicit cast 54 // CHECK: addrspacecast 55 // CHECK-NOFAKE-NOT: addrspacecast 56 57 arg_glob = (global int *)arg_host; // explicit cast 58 // CHECK: addrspacecast 59 // CHECK-NOFAKE-NOT: addrspacecast 60 61 arg_device = (__attribute((opencl_global_device)) int *)arg_glob; // explicit cast 62 // CHECK: addrspacecast 63 // CHECK-NOFAKE-NOT: addrspacecast 64 65 arg_host = (__attribute((opencl_global_host)) int *)arg_glob; // explicit cast 66 // CHECK: addrspacecast 67 // CHECK-NOFAKE-NOT: addrspacecast 68} 69 70// Test ternary operator. 71// CHECK: define{{.*}} void @test_ternary 72void test_ternary(void) { 73 global int *var_glob; 74 generic int *var_gen; 75 generic int *var_gen2; 76 generic float *var_gen_f; 77 generic void *var_gen_v; 78 79 var_gen = var_gen ? var_gen : var_gen2; // operands of the same addr spaces and the same type 80 // CHECK: icmp 81 // CHECK-NOT: addrspacecast 82 // CHECK-NOT: bitcast 83 // CHECK: phi 84 // CHECK: store i32 addrspace(4)* %{{.+}}, i32 addrspace(4)** %{{.+}} 85 86 var_gen = var_gen ? var_gen : var_glob; // operands of overlapping addr spaces and the same type 87 // CHECK: icmp 88 // CHECK-NOT: bitcast 89 // CHECK: %{{.+}} = addrspacecast i32 addrspace(1)* %{{.+}} to i32 addrspace(4)* 90 // CHECK: phi 91 // CHECK: store 92 93 typedef int int_t; 94 global int_t *var_glob_typedef; 95 var_gen = var_gen ? var_gen : var_glob_typedef; // operands of overlapping addr spaces and equivalent types 96 // CHECK: icmp 97 // CHECK-NOT: bitcast 98 // CHECK: %{{.+}} = addrspacecast i32 addrspace(1)* %{{.+}} to i32 addrspace(4)* 99 // CHECK: phi 100 // CHECK: store 101 102 var_gen_v = var_gen ? var_gen : var_gen_f; // operands of the same addr space and different types 103 // CHECK: icmp 104 // CHECK: %{{.+}} = bitcast i32 addrspace(4)* %{{.+}} to i8 addrspace(4)* 105 // CHECK: %{{.+}} = bitcast float addrspace(4)* %{{.+}} to i8 addrspace(4)* 106 // CHECK: phi 107 // CHECK: store 108 109 var_gen_v = var_gen ? var_glob : var_gen_f; // operands of overlapping addr spaces and different types 110 // CHECK: icmp 111 // CHECK: %{{.+}} = addrspacecast i32 addrspace(1)* %{{.+}} to i8 addrspace(4)* 112 // CHECK: %{{.+}} = bitcast float addrspace(4)* %{{.+}} to i8 addrspace(4)* 113 // CHECK: phi 114 // CHECK: store 115} 116