test/CodeGenOpenCL/amdgpu-nullptr.cl

   1 // RUN: %clang_cc1 %s -cl-std=CL2.0 -include opencl-c.h -triple amdgcn -emit-llvm -o - | FileCheck %s
   2 // RUN: %clang_cc1 %s -O0 -cl-std=CL2.0 -include opencl-c.h -triple amdgcn -emit-llvm -o - | FileCheck --check-prefix=NOOPT %s
   3
   4 typedef struct {
   5   private char *p1;
   6   local char *p2;
   7   constant char *p3;
   8   global char *p4;
   9   generic char *p5;
  10 } StructTy1;
  11
  12 typedef struct {
  13   constant char *p3;
  14   global char *p4;
  15   generic char *p5;
  16 } StructTy2;
  17
  18 // LLVM requests global variable with common linkage to be initialized with zeroinitializer, therefore use -fno-common
  19 // to suppress common linkage for tentative definition.
  20
  21 // Test 0 as initializer.
  22
  23 // CHECK: @private_p = local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
  24 private char *private_p = 0;
  25
  26 // CHECK: @local_p = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
  27 local char *local_p = 0;
  28
  29 // CHECK: @global_p = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
  30 global char *global_p = 0;
  31
  32 // CHECK: @constant_p = local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
  33 constant char *constant_p = 0;
  34
  35 // CHECK: @generic_p = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
  36 generic char *generic_p = 0;
  37
  38 // Test NULL as initializer.
  39
  40 // CHECK: @private_p_NULL = local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
  41 private char *private_p_NULL = NULL;
  42
  43 // CHECK: @local_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
  44 local char *local_p_NULL = NULL;
  45
  46 // CHECK: @global_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
  47 global char *global_p_NULL = NULL;
  48
  49 // CHECK: @constant_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
  50 constant char *constant_p_NULL = NULL;
  51
  52 // CHECK: @generic_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
  53 generic char *generic_p_NULL = NULL;
  54
  55 // Test constant folding of null pointer.
  56 // A null pointer should be folded to a null pointer in the target address space.
  57
  58 // CHECK: @fold_generic = local_unnamed_addr addrspace(1) global i32 addrspace(4)* null, align 4
  59 generic int *fold_generic = (global int*)(generic float*)(private char*)0;
  60
  61 // CHECK: @fold_priv = local_unnamed_addr addrspace(1) global i16* addrspacecast (i16 addrspace(4)* null to i16*), align 4
  62 private short *fold_priv = (private short*)(generic int*)(global void*)0;
  63
  64 // CHECK: @fold_priv_arith = local_unnamed_addr addrspace(1) global i8* inttoptr (i32 9 to i8*), align 4
  65 private char *fold_priv_arith = (private char*)0 + 10;
  66
  67 // CHECK: @fold_int = local_unnamed_addr addrspace(1) global i32 13, align 4
  68 int fold_int = (int)(private void*)(generic char*)(global int*)0 + 14;
  69
  70 // CHECK: @fold_int2 = local_unnamed_addr addrspace(1) global i32 12, align 4
  71 int fold_int2 = (int) ((private void*)0 + 13);
  72
  73 // CHECK: @fold_int3 = local_unnamed_addr addrspace(1) global i32 -1, align 4
  74 int fold_int3 = (int) ((private int*)0);
  75
  76 // CHECK: @fold_int4 = local_unnamed_addr addrspace(1) global i32 7, align 4
  77 int fold_int4 = (int) &((private int*)0)[2];
  78
  79 // CHECK: @fold_int5 = local_unnamed_addr addrspace(1) global i32 3, align 4
  80 int fold_int5 = (int) &((private StructTy1*)0)->p2;
  81
  82 // Test static variable initialization.
  83
  84 // NOOPT: @test_static_var.sp1 = internal addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
  85 // NOOPT: @test_static_var.sp2 = internal addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
  86 // NOOPT: @test_static_var.sp3 = internal addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
  87 // NOOPT: @test_static_var.sp4 = internal addrspace(1) global i8* null, align 4
  88 // NOOPT: @test_static_var.sp5 = internal addrspace(1) global i8* null, align 4
  89 // NOOPT: @test_static_var.SS1 = internal addrspace(1) global %struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }, align 4
  90 // NOOPT: @test_static_var.SS2 = internal addrspace(1) global %struct.StructTy2 zeroinitializer, align 4
  91
  92 void test_static_var(void) {
  93   static private char *sp1 = 0;
  94   static private char *sp2 = NULL;
  95   static private char *sp3;
  96   static private char *sp4 = (private char*)((void)0, 0);
  97   const int x = 0;
  98   static private char *sp5 = (private char*)x;
  99   static StructTy1 SS1;
 100   static StructTy2 SS2;
 101 }
 102
 103 // Test function-scope variable initialization.
 104 // NOOPT-LABEL: test_func_scope_var
 105 // NOOPT: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8** %sp1, align 4
 106 // NOOPT: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8** %sp2, align 4
 107 // NOOPT: store i8* null, i8** %sp3, align 4
 108 // NOOPT: store i8* null, i8** %sp4, align 4
 109 // NOOPT: %[[SS1:.*]] = bitcast %struct.StructTy1* %SS1 to i8*
 110 // NOOPT: call void @llvm.memcpy.p0i8.p2i8.i64(i8* %[[SS1]], i8 addrspace(2)* bitcast (%struct.StructTy1 addrspace(2)* @test_func_scope_var.SS1 to i8 addrspace(2)*), i64 32, i32 4, i1 false)
 111 // NOOPT: %[[SS2:.*]] = bitcast %struct.StructTy2* %SS2 to i8*
 112 // NOOPT: call void @llvm.memset.p0i8.i64(i8* %[[SS2]], i8 0, i64 24, i32 4, i1 false)
 113
 114 void test_func_scope_var(void) {
 115   private char *sp1 = 0;
 116   private char *sp2 = NULL;
 117   private char *sp3 = (private char*)((void)0, 0);
 118   const int x = 0;
 119   private char *sp4 = (private char*)x;
 120   StructTy1 SS1 = {0, 0, 0, 0, 0};
 121   StructTy2 SS2 = {0, 0, 0};
 122 }
 123
 124 // Test default initialization of pointers.
 125
 126 // Tentative definition of global variables with non-zero initializer
 127 // cannot have common linkage since common linkage requires zero initialization
 128 // and does not have explicit section.
 129
 130 // CHECK: @p1 = weak local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
 131 private char *p1;
 132
 133 // CHECK: @p2 = weak local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
 134 local char *p2;
 135
 136 // CHECK: @p3 = common local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
 137 constant char *p3;
 138
 139 // CHECK: @p4 = common local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
 140 global char *p4;
 141
 142 // CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
 143 generic char *p5;
 144
 145 // Test default initialization of sturcture.
 146
 147 // CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }, align 4
 148 StructTy1 S1;
 149
 150 // CHECK: @S2 = common local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 4
 151 StructTy2 S2;
 152
 153 // Test default initialization of array.
 154 // CHECK: @A1 = weak local_unnamed_addr addrspace(1) global [2 x %struct.StructTy1] [%struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }, %struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }], align 4
 155 StructTy1 A1[2];
 156
 157 // CHECK: @A2 = common local_unnamed_addr addrspace(1) global [2 x %struct.StructTy2] zeroinitializer, align 4
 158 StructTy2 A2[2];
 159
 160 // Test comparison with 0.
 161
 162 // CHECK-LABEL: cmp_private
 163 // CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
 164 void cmp_private(private char* p) {
 165   if (p != 0)
 166     *p = 0;
 167 }
 168
 169 // CHECK-LABEL: cmp_local
 170 // CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
 171 void cmp_local(local char* p) {
 172   if (p != 0)
 173     *p = 0;
 174 }
 175
 176 // CHECK-LABEL: cmp_global
 177 // CHECK: icmp eq i8 addrspace(1)* %p, null
 178 void cmp_global(global char* p) {
 179   if (p != 0)
 180     *p = 0;
 181 }
 182
 183 // CHECK-LABEL: cmp_constant
 184 // CHECK: icmp eq i8 addrspace(2)* %p, null
 185 char cmp_constant(constant char* p) {
 186   if (p != 0)
 187     return *p;
 188   else
 189     return 0;
 190 }
 191
 192 // CHECK-LABEL: cmp_generic
 193 // CHECK: icmp eq i8 addrspace(4)* %p, null
 194 void cmp_generic(generic char* p) {
 195   if (p != 0)
 196     *p = 0;
 197 }
 198
 199 // Test comparison with NULL.
 200
 201 // CHECK-LABEL: cmp_NULL_private
 202 // CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
 203 void cmp_NULL_private(private char* p) {
 204   if (p != NULL)
 205     *p = 0;
 206 }
 207
 208 // CHECK-LABEL: cmp_NULL_local
 209 // CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
 210 void cmp_NULL_local(local char* p) {
 211   if (p != NULL)
 212     *p = 0;
 213 }
 214
 215 // CHECK-LABEL: cmp_NULL_global
 216 // CHECK: icmp eq i8 addrspace(1)* %p, null
 217 void cmp_NULL_global(global char* p) {
 218   if (p != NULL)
 219     *p = 0;
 220 }
 221
 222 // CHECK-LABEL: cmp_NULL_constant
 223 // CHECK: icmp eq i8 addrspace(2)* %p, null
 224 char cmp_NULL_constant(constant char* p) {
 225   if (p != NULL)
 226     return *p;
 227   else
 228     return 0;
 229 }
 230
 231 // CHECK-LABEL: cmp_NULL_generic
 232 // CHECK: icmp eq i8 addrspace(4)* %p, null
 233 void cmp_NULL_generic(generic char* p) {
 234   if (p != NULL)
 235     *p = 0;
 236 }
 237
 238 // Test storage 0 as null pointer.
 239 // CHECK-LABEL: test_storage_null_pointer
 240 // CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8* addrspace(4)* %arg_private
 241 // CHECK: store i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(3)* addrspace(4)* %arg_local
 242 // CHECK: store i8 addrspace(1)* null, i8 addrspace(1)* addrspace(4)* %arg_global
 243 // CHECK: store i8 addrspace(2)* null, i8 addrspace(2)* addrspace(4)* %arg_constant
 244 // CHECK: store i8 addrspace(4)* null, i8 addrspace(4)* addrspace(4)* %arg_generic
 245 void test_storage_null_pointer(private char** arg_private,
 246                                local char** arg_local,
 247                                global char** arg_global,
 248                                constant char** arg_constant,
 249                                generic char** arg_generic) {
 250    *arg_private = 0;
 251    *arg_local = 0;
 252    *arg_global = 0;
 253    *arg_constant = 0;
 254    *arg_generic = 0;
 255 }
 256
 257 // Test storage NULL as null pointer.
 258 // CHECK-LABEL: test_storage_null_pointer_NULL
 259 // CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8* addrspace(4)* %arg_private
 260 // CHECK: store i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(3)* addrspace(4)* %arg_local
 261 // CHECK: store i8 addrspace(1)* null, i8 addrspace(1)* addrspace(4)* %arg_global
 262 // CHECK: store i8 addrspace(2)* null, i8 addrspace(2)* addrspace(4)* %arg_constant
 263 // CHECK: store i8 addrspace(4)* null, i8 addrspace(4)* addrspace(4)* %arg_generic
 264 void test_storage_null_pointer_NULL(private char** arg_private,
 265                                     local char** arg_local,
 266                                     global char** arg_global,
 267                                     constant char** arg_constant,
 268                                     generic char** arg_generic) {
 269    *arg_private = NULL;
 270    *arg_local = NULL;
 271    *arg_global = NULL;
 272    *arg_constant = NULL;
 273    *arg_generic = NULL;
 274 }
 275
 276 // Test pass null pointer to function as argument.
 277 void test_pass_null_pointer_arg_calee(private char* arg_private,
 278                                       local char* arg_local,
 279                                       global char* arg_global,
 280                                       constant char* arg_constant,
 281                                       generic char* arg_generic);
 282
 283 // CHECK-LABEL: test_pass_null_pointer_arg
 284 // CHECK: call void @test_pass_null_pointer_arg_calee(i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(1)* null, i8 addrspace(2)* null, i8 addrspace(4)* null)
 285 // CHECK: call void @test_pass_null_pointer_arg_calee(i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(1)* null, i8 addrspace(2)* null, i8 addrspace(4)* null)
 286 void test_pass_null_pointer_arg(void) {
 287   test_pass_null_pointer_arg_calee(0, 0, 0, 0, 0);
 288   test_pass_null_pointer_arg_calee(NULL, NULL, NULL, NULL, NULL);
 289 }
 290
 291 // Test cast null pointer to size_t.
 292 void test_cast_null_pointer_to_sizet_calee(size_t arg_private,
 293                                            size_t arg_local,
 294                                            size_t arg_global,
 295                                            size_t arg_constant,
 296                                            size_t arg_generic);
 297
 298 // CHECK-LABEL: test_cast_null_pointer_to_sizet
 299 // CHECK: call void @test_cast_null_pointer_to_sizet_calee(i64 ptrtoint (i8* addrspacecast (i8 addrspace(4)* null to i8*) to i64), i64 ptrtoint (i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*) to i64), i64 0, i64 0, i64 0)
 300 // CHECK: call void @test_cast_null_pointer_to_sizet_calee(i64 ptrtoint (i8* addrspacecast (i8 addrspace(4)* null to i8*) to i64), i64 ptrtoint (i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*) to i64), i64 0, i64 0, i64 0)
 301 void test_cast_null_pointer_to_sizet(void) {
 302   test_cast_null_pointer_to_sizet_calee((size_t)((private char*)0),
 303                                         (size_t)((local char*)0),
 304                                         (size_t)((global char*)0),
 305                                         (size_t)((constant char*)0),
 306                                         (size_t)((generic char*)0));
 307   test_cast_null_pointer_to_sizet_calee((size_t)((private char*)NULL),
 308                                         (size_t)((local char*)NULL),
 309                                         (size_t)((global char*)NULL),
 310                                         (size_t)((constant char*)0), // NULL cannot be casted to constant pointer since it is defined as a generic pointer
 311                                         (size_t)((generic char*)NULL));
 312 }
 313
 314 // Test comparision between null pointers.
 315 #define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; }
 316 #define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
 317 #define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; }
 318 #define TEST_EQNN(addr1, addr2) int test_eqNN_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
 319 #define TEST_NE00(addr1, addr2) int test_ne00_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)0; }
 320 #define TEST_NE0N(addr1, addr2) int test_ne0N_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
 321 #define TEST_NEN0(addr1, addr2) int test_neN0_##addr1##_##addr2(void) { return (addr1 char*)NULL != (addr2 char*)0; }
 322 #define TEST_NENN(addr1, addr2) int test_neNN_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
 323 #define TEST(addr1, addr2) \
 324         TEST_EQ00(addr1, addr2) \
 325         TEST_EQ0N(addr1, addr2) \
 326         TEST_EQN0(addr1, addr2) \
 327         TEST_EQNN(addr1, addr2) \
 328         TEST_NE00(addr1, addr2) \
 329         TEST_NE0N(addr1, addr2) \
 330         TEST_NEN0(addr1, addr2) \
 331         TEST_NENN(addr1, addr2)
 332
 333 // CHECK-LABEL: test_eq00_generic_private
 334 // CHECK: ret i32 1
 335 // CHECK-LABEL: test_eq0N_generic_private
 336 // CHECK: ret i32 1
 337 // CHECK-LABEL: test_eqN0_generic_private
 338 // CHECK: ret i32 1
 339 // CHECK-LABEL: test_eqNN_generic_private
 340 // CHECK: ret i32 1
 341 // CHECK-LABEL: test_ne00_generic_private
 342 // CHECK: ret i32 0
 343 // CHECK-LABEL: test_ne0N_generic_private
 344 // CHECK: ret i32 0
 345 // CHECK-LABEL: test_neN0_generic_private
 346 // CHECK: ret i32 0
 347 // CHECK-LABEL: test_neNN_generic_private
 348 // CHECK: ret i32 0
 349 TEST(generic, private)
 350
 351 // CHECK-LABEL: test_eq00_generic_local
 352 // CHECK: ret i32 1
 353 // CHECK-LABEL: test_eq0N_generic_local
 354 // CHECK: ret i32 1
 355 // CHECK-LABEL: test_eqN0_generic_local
 356 // CHECK: ret i32 1
 357 // CHECK-LABEL: test_eqNN_generic_local
 358 // CHECK: ret i32 1
 359 // CHECK-LABEL: test_ne00_generic_local
 360 // CHECK: ret i32 0
 361 // CHECK-LABEL: test_ne0N_generic_local
 362 // CHECK: ret i32 0
 363 // CHECK-LABEL: test_neN0_generic_local
 364 // CHECK: ret i32 0
 365 // CHECK-LABEL: test_neNN_generic_local
 366 // CHECK: ret i32 0
 367 TEST(generic, local)
 368
 369 // CHECK-LABEL: test_eq00_generic_global
 370 // CHECK: ret i32 1
 371 // CHECK-LABEL: test_eq0N_generic_global
 372 // CHECK: ret i32 1
 373 // CHECK-LABEL: test_eqN0_generic_global
 374 // CHECK: ret i32 1
 375 // CHECK-LABEL: test_eqNN_generic_global
 376 // CHECK: ret i32 1
 377 // CHECK-LABEL: test_ne00_generic_global
 378 // CHECK: ret i32 0
 379 // CHECK-LABEL: test_ne0N_generic_global
 380 // CHECK: ret i32 0
 381 // CHECK-LABEL: test_neN0_generic_global
 382 // CHECK: ret i32 0
 383 // CHECK-LABEL: test_neNN_generic_global
 384 // CHECK: ret i32 0
 385 TEST(generic, global)
 386
 387 // CHECK-LABEL: test_eq00_generic_generic
 388 // CHECK: ret i32 1
 389 // CHECK-LABEL: test_eq0N_generic_generic
 390 // CHECK: ret i32 1
 391 // CHECK-LABEL: test_eqN0_generic_generic
 392 // CHECK: ret i32 1
 393 // CHECK-LABEL: test_eqNN_generic_generic
 394 // CHECK: ret i32 1
 395 // CHECK-LABEL: test_ne00_generic_generic
 396 // CHECK: ret i32 0
 397 // CHECK-LABEL: test_ne0N_generic_generic
 398 // CHECK: ret i32 0
 399 // CHECK-LABEL: test_neN0_generic_generic
 400 // CHECK: ret i32 0
 401 // CHECK-LABEL: test_neNN_generic_generic
 402 // CHECK: ret i32 0
 403 TEST(generic, generic)
 404
 405 // CHECK-LABEL: test_eq00_constant_constant
 406 // CHECK: ret i32 1
 407 TEST_EQ00(constant, constant)
 408
 409 // Test cast to bool.
 410
 411 // CHECK-LABEL: cast_bool_private
 412 // CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
 413 void cast_bool_private(private char* p) {
 414   if (p)
 415     *p = 0;
 416 }
 417
 418 // CHECK-LABEL: cast_bool_local
 419 // CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
 420 void cast_bool_local(local char* p) {
 421   if (p)
 422     *p = 0;
 423 }
 424
 425 // CHECK-LABEL: cast_bool_global
 426 // CHECK: icmp eq i8 addrspace(1)* %p, null
 427 void cast_bool_global(global char* p) {
 428   if (p)
 429     *p = 0;
 430 }
 431
 432 // CHECK-LABEL: cast_bool_constant
 433 // CHECK: icmp eq i8 addrspace(2)* %p, null
 434 char cast_bool_constant(constant char* p) {
 435   if (p)
 436     return *p;
 437   else
 438     return 0;
 439 }
 440
 441 // CHECK-LABEL: cast_bool_generic
 442 // CHECK: icmp eq i8 addrspace(4)* %p, null
 443 void cast_bool_generic(generic char* p) {
 444   if (p)
 445     *p = 0;
 446 }
 447
 448 // Test initialize a struct using memset.
 449 // For large structures which is mostly zero, clang generats llvm.memset for
 450 // the zero part and store for non-zero members.
 451 typedef struct {
 452   long a, b, c, d;
 453   private char *p;
 454 } StructTy3;
 455
 456 // CHECK-LABEL: test_memset
 457 // CHECK: call void @llvm.memset.p0i8.i64(i8* {{.*}}, i8 0, i64 32, i32 8, i1 false)
 458 // CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8** {{.*}}
 459 StructTy3 test_memset(void) {
 460   StructTy3 S3 = {0, 0, 0, 0, 0};
 461   return S3;
 462 }
 463
 464 // Test casting literal 0 to pointer.
 465 // A 0 literal casted to pointer should become a null pointer.
 466
 467 // CHECK-LABEL: test_cast_0_to_ptr
 468 // CHECK: ret i32* addrspacecast (i32 addrspace(4)* null to i32*)
 469 private int* test_cast_0_to_ptr(void) {
 470   return (private int*)0;
 471 }
 472
 473 // Test casting non-literal integer with 0 value to pointer.
 474 // A non-literal integer expression with 0 value is casted to a pointer with
 475 // zero value.
 476
 477 // CHECK-LABEL: test_cast_int_to_ptr1
 478 // CHECK: ret i32* null
 479 private int* test_cast_int_to_ptr1(void) {
 480   return (private int*)((void)0, 0);
 481 }
 482
 483 // CHECK-LABEL: test_cast_int_to_ptr2
 484 // CHECK: ret i32* null
 485 private int* test_cast_int_to_ptr2(void) {
 486   int x = 0;
 487   return (private int*)x;
 488 }
 489
 490 // Test logical operations.
 491 // CHECK-LABEL: test_not_nullptr
 492 // CHECK: ret i32 1
 493 int test_not_nullptr(void) {
 494   return !(private char*)NULL;
 495 }
 496
 497 // CHECK-LABEL: test_and_nullptr
 498 // CHECK: ret i32 0
 499 int test_and_nullptr(int a) {
 500   return a && ((private char*)NULL);
 501 }
 502
 503 // CHECK-LABEL: test_not_ptr
 504 // CHECK: %[[lnot:.*]] = icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
 505 // CHECK: %[[lnot_ext:.*]] = zext i1 %[[lnot]] to i32
 506 // CHECK: ret i32 %[[lnot_ext]]
 507 int test_not_ptr(private char* p) {
 508   return !p;
 509 }
 510 // CHECK-LABEL: test_and_ptr
 511 // CHECK: %[[tobool:.*]] = icmp ne i8* %p1, addrspacecast (i8 addrspace(4)* null to i8*)
 512 // CHECK: %[[tobool1:.*]] = icmp ne i8 addrspace(3)* %p2, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
 513 // CHECK: %[[res:.*]] = and i1 %[[tobool]], %[[tobool1]]
 514 // CHECK: %[[land_ext:.*]] = zext i1 %[[res]] to i32
 515 // CHECK: ret i32 %[[land_ext]]
 516 int test_and_ptr(private char* p1, local char* p2) {
 517   return p1 && p2;
 518 }
 519
 520 // Test folding of null pointer in function scope.
 521 // NOOPT-LABEL: test_fold
 522 // NOOPT: call void @test_fold_callee
 523 // NOOPT: store i32 addrspace(1)* null, i32 addrspace(1)** %glob, align 4
 524 // NOOPT: %{{.*}} = sub i64 %{{.*}}, 0
 525 // NOOPT: call void @test_fold_callee
 526 // NOOPT: %{{.*}} = add nsw i64 %{{.*}}, sext (i32 ptrtoint (i32* addrspacecast (i32 addrspace(4)* null to i32*) to i32) to i64)
 527 // NOOPT: %{{.*}} = sub nsw i64 %{{.*}}, 1
 528 void test_fold_callee(void);
 529 void test_fold(void) {
 530   global int* glob = (test_fold_callee(), (global int*)(generic char*)0);
 531   long x = glob - (global int*)(generic char*)0;
 532   x = x + (int)(test_fold_callee(), (private int*)(generic char*)(global short*)0);
 533   x = x - (int)((private int*)0 == (private int*)(generic char*)0);
 534 }