[Clang] Allow the combination of loader_uninitialized and address spaces

[jdoerfert]

Summary

When an object is allocated in a non-default address space we do not
need to check for a constructor if it is not initialized and has a
trivial constructor (which we won't call then).

[JonChesterfield]

I misread this as implying loaded_uninitialized for addrspace globals, but actually it's a straightforward oversight from the original implementation. Thanks!

clang/test/CodeGen/attr-loader-uninitialized.c

21

addrspace(0) presumably works the same way. Iirc addrspace(0) is different from no addrspace specified.

[jdoerfert]

Fix test

[JonChesterfield]

Diff now shows unrelated changed (// C++ for OpenCL v1.0 s2.4:....), maybe needs to be rebased?
edit: commit itself looks clean, think we're good

clang/lib/Sema/SemaDecl.cpp

if (!Var->isInvalidDecl() && RealDecl->hasAttr<LoaderUninitializedAttr>()) {
       }
       if (CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
         if (!RD->hasTrivialDefaultConstructor()) {
           Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
           Var->setInvalidDecl();
           return;
         }
       }
+      // The declaration is unitialized, no need for further checks.
+      return;
     }
 
     VarDecl::DefinitionKind DefKind = Var->isThisDeclarationADefinition();
     if (!Var->isInvalidDecl() && DefKind != VarDecl::DeclarationOnly &&
         Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
       checkNonTrivialCUnion(Var->getType(), Var->getLocation(),
                             NTCUC_DefaultInitializedObject, NTCUK_Init);
 

clang/test/CodeGen/attr-loader-uninitialized.c

 
 typedef struct
 {
   int x;
   float y;
 } s;
 
 // CHECK: @i ={{.*}} global %struct.s undef
+// CHECK: @j1 ={{.*}}addrspace(1) global %struct.s undef
+// CHECK: @j2 ={{.*}}addrspace(2) global %struct.s undef
+// CHECK: @j3 ={{.*}}addrspace(3) global %struct.s undef
+// CHECK: @j4 ={{.*}}addrspace(4) global %struct.s undef
+// CHECK: @j5 ={{.*}}addrspace(5) global %struct.s undef
+// CHECK: @j99 ={{.*}}addrspace(99) global %struct.s undef
 s i __attribute__((loader_uninitialized));
+s j1 __attribute__((loader_uninitialized, address_space(1)));
+s j2 __attribute__((loader_uninitialized, address_space(2)));
+s j3 __attribute__((loader_uninitialized, address_space(3)));
+s j4 __attribute__((loader_uninitialized, address_space(4)));
+s j5 __attribute__((loader_uninitialized, address_space(5)));
+s j99 __attribute__((loader_uninitialized, address_space(99)));
 
 // CHECK: @private_extern_ok = hidden global i32 undef
 __private_extern__ int private_extern_ok __attribute__((loader_uninitialized));

clang/test/OpenMP/declare_target_codegen.cpp

 // CHECK-DAG: weak constant %struct.__tgt_offload_entry { i8* bitcast (i32* @bbb to i8*),
 // CHECK-DAG: @ccc = external global i32,
 // CHECK-DAG: @ddd ={{ hidden | }}global i32 0,
 // CHECK-DAG: @hhh_decl_tgt_ref_ptr = weak global i32* null
 // CHECK-DAG: @ggg_decl_tgt_ref_ptr = weak global i32* null
 // CHECK-DAG: @fff_decl_tgt_ref_ptr = weak global i32* null
 // CHECK-DAG: @eee_decl_tgt_ref_ptr = weak global i32* null
 // CHECK-DAG: @{{.*}}maini1{{.*}}aaa = internal global i64 23,
+// CHECK-DAG: @pair = {{.*}}addrspace(3) global %struct.PAIR undef
 // CHECK-DAG: @b ={{ hidden | }}global i32 15,
 // CHECK-DAG: @d ={{ hidden | }}global i32 0,
 // CHECK-DAG: @c = external global i32,
 // CHECK-DAG: @globals ={{ hidden | }}global %struct.S zeroinitializer,
 // CHECK-DAG: [[STAT:@.+stat]] = internal global %struct.S zeroinitializer,
 // CHECK-DAG: [[STAT_REF:@.+]] = internal constant %struct.S* [[STAT]]
 // CHECK-DAG: @out_decl_target ={{ hidden | }}global i32 0,
 // CHECK-DAG: @llvm.used = appending global [2 x i8*] [i8* bitcast (void ()* @__omp_offloading__{{.+}}_globals_l[[@LINE+84]]_ctor to i8*), i8* bitcast (void ()* @__omp_offloading__{{.+}}_stat_l[[@LINE+85]]_ctor to i8*)],

 // HOST5: define {{.*}}void {{.*}}host_fun{{.*}}
 // HOST5-NOT: define {{.*}}void {{.*}}device_fun{{.*}}
 
 // DEV5-NOT: define {{.*}}void {{.*}}host_fun{{.*}}
 // DEV5: define {{.*}}void {{.*}}device_fun{{.*}}
 // DEV5-NOT: define {{.*}}void {{.*}}host_fun{{.*}}
 #endif // OMP5
 
+struct PAIR {
+  int a;
+  int b;
+};
+
+#pragma omp declare target
+PAIR pair __attribute__((address_space(3), loader_uninitialized));
+#pragma omp end declare target
+
 #endif // HEADER
 
 #ifdef LOAD
 #pragma omp declare target
 void new_bar1() {
   TTT<int> *X = new TTT<int>();
   X->emitted();
 }
 #pragma omp end declare target
 #endif

clang/test/Sema/attr-loader-uninitialized.cpp

 // RUN: %clang_cc1 %s -verify -fsyntax-only
 
 int good __attribute__((loader_uninitialized));
 static int local_ok __attribute__((loader_uninitialized));
 int hidden_ok __attribute__((visibility("hidden"))) __attribute__((loader_uninitialized));
 
 const int still_cant_be_const __attribute__((loader_uninitialized));
-// expected-error@-1 {{default initialization of an object of const type}}
 extern int external_rejected __attribute__((loader_uninitialized));
 // expected-error@-1 {{variable 'external_rejected' cannot be declared both 'extern' and with the 'loader_uninitialized' attribute}}
 
 struct S;
 extern S incomplete_external_rejected __attribute__((loader_uninitialized));
 // expected-error@-1 {{variable 'incomplete_external_rejected' cannot be declared both 'extern' and with the 'loader_uninitialized' attribute}}
 
 int noargs __attribute__((loader_uninitialized(0)));