[clang] Allow setting the uninitialized attribute on record

[serge-sans-paille]

Summary

This attribute would then affect all stack variables of that type, when the type has been evaluated as ok wrt. initialisation, or a for performance / security trade-offs.
An example of use could be container with preallocated storage like SmallVector, if we consider that it is too costly to initialize that storage.

[shafik]

Adding clang-language-wg for more visibility.

[shafik]

I think a test verifying that during constant evaluation we still flag the read of a local tagged uninitialized as ill-formed would be nice.

[Fznamznon]

clang/lib/CodeGen/CGDecl.cpp

1906–1908

Should we have curly braces here?

1909

clang/lib/Sema/SemaDeclAttr.cpp

8442

AFAIK cast does isa, since it is already done here we can probably switch to dyn_cast.

[serge-sans-paille]

Take reviewers comment into account.

[serge-sans-paille]

(rebased on main)

[aaron.ballman]

Was there an RFC for this extension to the attribute? (There doesn't need to be one, I'm just wondering if there's more background info on what's driving this patch forward and discussion around the design.)

I'd like some more details about how this attribute impacts class hierarchies. e.g., if you put the attribute on the base class, does it impact the derived class members as well, or just the base class members? Also, what should happen in a case like this:

template <typename Ty>
void func() {
  Ty Val; // Does this know it's uninitialized? Or did we lose that information because this isn't a type attribute?
}

struct __attribute__((uninitialized)) S { int  value; };

int main() {
  func<S>();
}

clang/include/clang/Basic/AttrDocs.td

5786

clang/lib/CodeGen/CGDecl.cpp

1905–1915

[serge-sans-paille]

In D156337#4558410, @aaron.ballman wrote:

Was there an RFC for this extension to the attribute? (There doesn't need to be one, I'm just wondering if there's more background info on what's driving this patch forward and discussion around the design.)

I'd like some more details about how this attribute impacts class hierarchies. e.g., if you put the attribute on the base class, does it impact the derived class members as well, or just the base class members? Also, what should happen in a case like this:

template <typename Ty>
void func() {
  Ty Val; // Does this know it's uninitialized? Or did we lose that information because this isn't a type attribute?
}

struct __attribute__((uninitialized)) S { int  value; };

int main() {
  func<S>();
}

All very relevant topics. Concerning inheritance, I'd say that if the base class is marked as uninitialized and the child class is not, then base members are uninitialized and child members are not.

Concerning your example, I'd expect Val to be uninitialized as it's type has the according attribute, but I also don't quite understand "Or did we lose that information because this isn't a type attribute?"

clang/include/clang/Basic/Attr.td

def NoSpeculativeLoadHardening : InheritableAttr {
   let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
   let Documentation = [NoSpeculativeLoadHardeningDocs];
   let SimpleHandler = 1;
 }
 def : MutualExclusions<[SpeculativeLoadHardening, NoSpeculativeLoadHardening]>;
 
 def Uninitialized : InheritableAttr {
   let Spellings = [Clang<"uninitialized", 0>];
-  let Subjects = SubjectList<[LocalVar]>;
+  let Subjects = SubjectList<[LocalVar, Record]>;
   let PragmaAttributeSupport = 1;
   let Documentation = [UninitializedDocs];
 }
 
 def LoaderUninitialized : Attr {
   let Spellings = [Clang<"loader_uninitialized">];
   let Subjects = SubjectList<[GlobalVar]>;
   let Documentation = [LoaderUninitializedDocs];

clang/include/clang/Basic/AttrDocs.td

 }
 
 def UninitializedDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{
 The command-line parameter ``-ftrivial-auto-var-init=*`` can be used to
 initialize trivial automatic stack variables. By default, trivial automatic
 stack variables are uninitialized. This attribute is used to override the
-command-line parameter, forcing variables to remain uninitialized. It has no
-semantic meaning in that using uninitialized values is undefined behavior,
+command-line parameter, forcing variables to remain uninitialized.
+When set on a struct or class, all stack variables of this type are affected.
+
+It has no semantic meaning in that using uninitialized values is undefined behavior,
 it rather documents the programmer's intent.
   }];
 }
 
 def LoaderUninitializedDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{
 The ``loader_uninitialized`` attribute can be placed on global variables to

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitAutoVarInit(const AutoVarEmission &emission) {
   // emit the initializer first, then copy into the variable.
   bool capturedByInit =
       Init && emission.IsEscapingByRef && isCapturedBy(D, Init);
 
   bool locIsByrefHeader = !capturedByInit;
   const Address Loc =
       locIsByrefHeader ? emission.getObjectAddress(*this) : emission.Addr;
 
+  LangOptions::TrivialAutoVarInitKind trivialAutoVarInit;
+  if (D.isConstexpr()) {
     // Note: constexpr already initializes everything correctly.
-  LangOptions::TrivialAutoVarInitKind trivialAutoVarInit =
-      (D.isConstexpr()
-           ? LangOptions::TrivialAutoVarInitKind::Uninitialized
-           : (D.getAttr<UninitializedAttr>()
-                  ? LangOptions::TrivialAutoVarInitKind::Uninitialized
-                  : getContext().getLangOpts().getTrivialAutoVarInit()));
+    trivialAutoVarInit = LangOptions::TrivialAutoVarInitKind::Uninitialized;
+  } else if (D.hasAttr<UninitializedAttr>())
+    trivialAutoVarInit = LangOptions::TrivialAutoVarInitKind::Uninitialized;
+  else if (const auto *RecordTy = D.getType()->getAsRecordDecl();
+           RecordTy && RecordTy->hasAttr<UnusedAttr>())
+    trivialAutoVarInit = LangOptions::TrivialAutoVarInitKind::Uninitialized;
+  else
+    trivialAutoVarInit = getContext().getLangOpts().getTrivialAutoVarInit();
 
   auto initializeWhatIsTechnicallyUninitialized = [&](Address Loc) {
     if (trivialAutoVarInit ==
         LangOptions::TrivialAutoVarInitKind::Uninitialized)
       return;
 
     // Only initialize a __block's storage: we always initialize the header.
     if (emission.IsEscapingByRef && !locIsByrefHeader)

clang/lib/Sema/SemaDeclAttr.cpp

static void handleDestroyAttr(Sema &S, Decl *D, const ParsedAttr &A) {
 
   if (A.getKind() == ParsedAttr::AT_AlwaysDestroy)
     handleSimpleAttribute<AlwaysDestroyAttr>(S, D, A);
   else
     handleSimpleAttribute<NoDestroyAttr>(S, D, A);
 }
 
 static void handleUninitializedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
-  assert(cast<VarDecl>(D)->getStorageDuration() == SD_Automatic &&
-         "uninitialized is only valid on automatic duration variables");
+  assert((isa<RecordDecl>(D) ||
+          (cast<VarDecl>(D)->getStorageDuration() == SD_Automatic)) &&
+         "uninitialized is only valid on automatic duration variables and "
+         "record type");
   D->addAttr(::new (S.Context) UninitializedAttr(S.Context, AL));
 }
 
 static bool tryMakeVariablePseudoStrong(Sema &S, VarDecl *VD,
                                         bool DiagnoseFailure) {
   QualType Ty = VD->getType();
   if (!Ty->isObjCRetainableType()) {
     if (DiagnoseFailure) {

clang/test/CodeGenCXX/trivial-auto-var-init-attribute.cpp

 // PATTERN:      alloca
 // PATTERN-NEXT: call void
 void test_pragma_attribute_uninitialized() {
   int i;
   used(i);
 }
 #pragma clang attribute pop
 
+struct [[clang::uninitialized]] uninitialized_record {
+  int i;
+};
+
+// UNINIT-LABEL:  test_record_attribute_uninitialized(
+// UNINIT:      alloca
+// UNINIT-NEXT: call void
+// ZERO-LABEL:    test_record_attribute_uninitialized(
+// ZERO:      alloca
+// ZERO-NOT:  !annotation
+// ZERO-NEXT: call void
+// PATTERN-LABEL: test_record_attribute_uninitialized(
+// PATTERN:      alloca
+// PATTERN-NOT:  !annotation
+// PATTERN-NEXT: call void
+void test_record_attribute_uninitialized() {
+  uninitialized_record some;
+  used(some);
+}
+
 } // extern "C"

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: SwiftNewType (SubjectMatchRule_type_alias)
 // CHECK-NEXT: SwiftObjCMembers (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: TLSModel (SubjectMatchRule_variable_is_thread_local)
 // CHECK-NEXT: Target (SubjectMatchRule_function)
 // CHECK-NEXT: TargetClones (SubjectMatchRule_function)
 // CHECK-NEXT: TargetVersion (SubjectMatchRule_function)
 // CHECK-NEXT: TestTypestate (SubjectMatchRule_function_is_member)
 // CHECK-NEXT: TrivialABI (SubjectMatchRule_record)
-// CHECK-NEXT: Uninitialized (SubjectMatchRule_variable_is_local)
+// CHECK-NEXT: Uninitialized (SubjectMatchRule_variable_is_local, SubjectMatchRule_record)
 // CHECK-NEXT: UnsafeBufferUsage (SubjectMatchRule_function)
 // CHECK-NEXT: UseHandle (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: VecReturn (SubjectMatchRule_record)
 // CHECK-NEXT: VecTypeHint (SubjectMatchRule_function)
 // CHECK-NEXT: WarnUnused (SubjectMatchRule_record)
 // CHECK-NEXT: WarnUnusedResult (SubjectMatchRule_objc_method, SubjectMatchRule_enum, SubjectMatchRule_record, SubjectMatchRule_hasType_functionType, SubjectMatchRule_type_alias)
 // CHECK-NEXT: Weak (SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_record)
 // CHECK-NEXT: WeakRef (SubjectMatchRule_variable, SubjectMatchRule_function)
 // CHECK-NEXT: WebAssemblyExportName (SubjectMatchRule_function)
 // CHECK-NEXT: WebAssemblyImportModule (SubjectMatchRule_function)
 // CHECK-NEXT: WebAssemblyImportName (SubjectMatchRule_function)
 // CHECK-NEXT: WorkGroupSizeHint (SubjectMatchRule_function)
 // CHECK-NEXT: XRayInstrument (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: XRayLogArgs (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: ZeroCallUsedRegs (SubjectMatchRule_function)
 // CHECK-NEXT: End of supported attributes.

clang/test/Sema/attr-uninitialized.c

 int you_know __attribute((uninitialized));                          // expected-warning {{'uninitialized' attribute only applies to local variables}}
 static int and_the_whole_world_has_to __attribute((uninitialized)); // expected-warning {{'uninitialized' attribute only applies to local variables}}
 
 void answer_right_now(void) __attribute((uninitialized)) {}                        // expected-warning {{'uninitialized' attribute only applies to local variables}}
 void just_to_tell_you_once_again(__attribute((uninitialized)) int whos_bad) {} // expected-warning {{'uninitialized' attribute only applies to local variables}}
 
 struct TheWordIsOut {
   __attribute((uninitialized)) int youre_doin_wrong; // expected-warning {{'uninitialized' attribute only applies to local variables}}
-} __attribute((uninitialized));                      // expected-warning {{'uninitialized' attribute only applies to local variables}}
+} __attribute((uninitialized));

clang/test/SemaCXX/constant-expression-cxx14.cpp

namespace StmtExpr {
   }
   static_assert(g() == 0, ""); // expected-error {{constant expression}} expected-note {{in call}}
 
   // FIXME: We should handle the void statement expression case.
   constexpr int h() { // expected-error {{never produces a constant}}
     ({ if (true) {} }); // expected-note {{not supported}}
     return 0;
   }
+
+  // Make sure the uninitialized attribute does not silent constant expression
+  // warnings.
+  constexpr int i() {
+    return ({ __attribute__((uninitialized)) int n; n; }); // expected-note {{read of uninitialized object}}
+  }
+  static_assert(i() == 0, ""); // expected-error {{constant expression}} expected-note {{in call}}
 }
 
 namespace VirtualFromBase {
   struct S1 {
     virtual int f() const;
   };
   struct S2 {
     virtual int f();

clang/test/SemaCXX/constant-expression-cxx2a.cpp

namespace mutable_subobjects {
   };
   constexpr Z z;
   constexpr const X *pz = &z.y;
   constexpr const Y *qz = dynamic_cast<const Y*>(pz);
   auto &zti = typeid(z.y);
   static_assert(&zti == &typeid(Y));
 }
 
+struct __attribute__((uninitialized)) j { int v; constexpr j() {}};
+static_assert(j().v == 0, ""); // expected-error {{constant expression}} expected-note {{read of uninitialized object is not allowed in a constant expression}}
+
 namespace PR45133 {
   struct A { long x; };
 
   union U;
   constexpr A foo(U *up);
 
   union U {
     A a = foo(this); // expected-note {{in call to 'foo(&u)'}}