Make static constructors + destructors minsize + cold (except for in -O0)

[paquette]

Summary

Since these are only ever run once, they can be marked as cold. On top of that, since they're only ever run once, they might as well be minsize.

I observed a 0.21% code size improvement in a standard release build of clang for x86 with this change.

[lebedev.ri]

clang/test/CodeGen/static-attr.cpp

5

This is fragile, it may have false-negative if they appear in other order.

[jyknight]

Looks reasonable to me.

clang/test/CodeGen/static-attr.cpp

5

I think we guarantee it's emitted in the same order, but it's certainly the case that nobody will ever notice if this is failing to fail the test, if other attributes get emitted in between in the future.

You can use 3 separate WITHOUT-NOT lines, instead, to avoid both of this kind of issue.

[paquette]

Made the test less fragile by splitting the WITHOUT-NOT into three lines.

(Thanks for the suggestion!)

clang/lib/CodeGen/CGDeclCXX.cpp

Fn->addFnAttr("sign-return-address-key",
                   RASignKey == CodeGenOptions::SignReturnAddressKeyValue::AKey
                       ? "a_key"
                       : "b_key");
   }
 
   if (getCodeGenOpts().BranchTargetEnforcement)
     Fn->addFnAttr("branch-target-enforcement");
 
+  // If we're optimizing, then we can make these small, since they're only ever
+  // run once.
+  if (getCodeGenOpts().DisableO0ImplyOptNone ||
+      getCodeGenOpts().OptimizationLevel != 0) {
+    Fn->addFnAttr(llvm::Attribute::OptimizeForSize);
+    Fn->addFnAttr(llvm::Attribute::MinSize);
+    Fn->addFnAttr(llvm::Attribute::Cold);
+  }
+
   return Fn;
 }
 
 /// Create a global pointer to a function that will initialize a global
 /// variable.  The user has requested that this pointer be emitted in a specific
 /// section.
 void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D,
                                           llvm::GlobalVariable *GV,

clang/test/CodeGen/address-safety-attr.cpp

 // Attributes for function defined in different source file:
 // WITHOUT: DefinedInDifferentFile{{.*}} [[NOATTR:#[0-9]+]]
 // BLFILE:  DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]]
 // BLFUNC:  DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]]
 // ASAN:    DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]]
 
 // Check that functions generated for global in different source file are
 // not blacklisted.
-// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
-// WITHOUT: @__cxx_global_array_dtor{{.*}}[[NOATTR]]
-// BLFILE: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
-// BLFILE: @__cxx_global_array_dtor{{.*}}[[WITH]]
-// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
-// BLFUNC: @__cxx_global_array_dtor{{.*}}[[WITH]]
-// ASAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
-// ASAN: @__cxx_global_array_dtor{{.*}}[[WITH]]
+// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR_STATIC:#[0-9]+]]
+// WITHOUT: @__cxx_global_array_dtor{{.*}}[[NOATTR_STATIC]]
+// BLFILE: @__cxx_global_var_init{{.*}}[[WITH_STATIC:#[0-9]+]]
+// BLFILE: @__cxx_global_array_dtor{{.*}}[[WITH_STATIC]]
+// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH_STATIC:#[0-9]+]]
+// BLFUNC: @__cxx_global_array_dtor{{.*}}[[WITH_STATIC]]
+// ASAN: @__cxx_global_var_init{{.*}}[[WITH_STATIC:#[0-9]+]]
+// ASAN: @__cxx_global_array_dtor{{.*}}[[WITH_STATIC]]
 
-
-// WITHOUT:  NoAddressSafety1{{.*}}) [[NOATTR]]
+// WITHOUT:  NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]]
 // BLFILE:  NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]]
 // BLFUNC:  NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]]
 // ASAN:  NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]]
 __attribute__((no_sanitize_address))
 int NoAddressSafety1(int *a) { return *a; }
 
 // WITHOUT:  NoAddressSafety2{{.*}}) [[NOATTR]]
 // BLFILE:  NoAddressSafety2{{.*}}) [[NOATTR]]

 
 int force_instance = TemplateAddressSafetyOk<42>()
                    + TemplateNoAddressSafety1<42>()
                    + TemplateNoAddressSafety2<42>();
 
 // Check that __cxx_global_var_init* get the sanitize_address attribute.
 int global1 = 0;
 int global2 = *(int*)((char*)&global1+1);
-// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR]]
-// BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
-// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH]]
-// ASAN: @__cxx_global_var_init{{.*}}[[WITH]]
+// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR_STATIC]]
+// BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR_STATIC:#[0-9]+]]
+// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH_STATIC]]
+// ASAN: @__cxx_global_var_init{{.*}}[[WITH_STATIC]]
 
 // WITHOUT: attributes [[NOATTR]] = { noinline nounwind{{.*}} }
+// WITHOUT: attributes [[NOATTR_STATIC]] = { cold minsize noinline nounwind optsize{{.*}} }
 
 // BLFILE: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} }
+// BLFILE: attributes [[WITH_STATIC]] = { cold minsize noinline nounwind optsize sanitize_address{{.*}} }
 // BLFILE: attributes [[NOATTR]] = { noinline nounwind{{.*}} }
+// BLFILE: attributes [[NOATTR_STATIC]] = { cold minsize noinline nounwind optsize{{.*}} }
 
 // BLFUNC: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} }
+// BLFUNC: attributes [[WITH_STATIC]] = { cold minsize noinline nounwind optsize sanitize_address{{.*}} }
 // BLFUNC: attributes [[NOATTR]] = { noinline nounwind{{.*}} }
 
 // ASAN: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} }
+// ASAN: attributes [[WITH_STATIC]] = { cold minsize noinline nounwind optsize sanitize_address{{.*}} }
 // ASAN: attributes [[NOATTR]] = { noinline nounwind{{.*}} }

clang/test/CodeGen/static-attr.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -disable-O0-optnone -emit-llvm %s -o - | FileCheck -check-prefix=WITH %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - | FileCheck -check-prefix=WITHOUT %s
+
+// WITHOUT-NOT: cold
+// WITHOUT-NOT: minsize
+// WITHOUT-NOT: noinline
+// WITH: define internal void @__cxx_global_var_init() [[ATTR:#[0-9]]]
+
+extern int
+baz(void);
+
+int foo(void) {
+  return baz();
+}
+
+static struct StaticInitializer {
+  StaticInitializer() {
+    foo();
+  }
+} I;
+
+int bar() {
+  StaticInitializer I;
+  return 0;
+}
+
+// WITH: attributes [[ATTR]] = { {{.*}}cold minsize noinline nounwind optsize{{.*}} }