[WIP] Add IR function attributes to represent codegen optimization level

[mcrosier]

Summary

This patch is being posted along with the following RFC:

[RFC] Adding function attributes to represent codegen optimization level

This patch is a WIP and not necessarily something that is ready for review. As such, please direct your comments to the RFC rather than here.

Chad

include/clang/Basic/Attr.td

 }
 
 def OptimizeNone : InheritableAttr {
   let Spellings = [Clang<"optnone">];
   let Subjects = SubjectList<[Function, ObjCMethod]>;
   let Documentation = [OptnoneDocs];
 }
 
+def OptimizeLess : InheritableAttr {
+  let Spellings = [Clang<"optless">];
+  let Subjects = SubjectList<[Function, ObjCMethod]>;
+  let Documentation = [Undocumented];
+}
+
+def OptimizeDefault : InheritableAttr {
+  let Spellings = [Clang<"optdefault">];
+  let Subjects = SubjectList<[Function, ObjCMethod]>;
+  let Documentation = [Undocumented];
+}
+
+def OptimizeAggressive : InheritableAttr {
+  let Spellings = [Clang<"optaggr">];
+  let Subjects = SubjectList<[Function, ObjCMethod]>;
+  let Documentation = [Undocumented];
+}
+
 def Overloadable : Attr {
   let Spellings = [Clang<"overloadable">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [OverloadableDocs];
 }
 
 def Override : InheritableAttr { 
   let Spellings = [Keyword<"override">];

lib/CodeGen/CGCall.cpp

void CodeGenModule::ConstructDefaultFnAttrList(StringRef Name, bool HasOptnone,
                                                bool AttrOnCallSite,
                                                llvm::AttrBuilder &FuncAttrs) {
   // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed.
   if (!HasOptnone) {
     if (CodeGenOpts.OptimizeSize)
       FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
     if (CodeGenOpts.OptimizeSize == 2)
       FuncAttrs.addAttribute(llvm::Attribute::MinSize);
+    switch (CodeGenOpts.OptimizationLevel) {
+    case 0:
+      FuncAttrs.addAttribute(llvm::Attribute::OptimizeNone);
+      break;
+    case 1:
+      FuncAttrs.addAttribute(llvm::Attribute::OptimizeLess);
+      break;
+    case 2:
+      FuncAttrs.addAttribute(llvm::Attribute::OptimizeDefault);
+      break;
+    case 3:
+      FuncAttrs.addAttribute(llvm::Attribute::OptimizeAggressive);
+      break;
+    }
   }
 
   if (CodeGenOpts.DisableRedZone)
     FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
   if (CodeGenOpts.NoImplicitFloat)
     FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
 
   if (AttrOnCallSite) {

lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
   // starting with the default for this optimization level.
   bool ShouldAddOptNone =
       !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
   // We can't add optnone in the following cases, it won't pass the verifier.
   ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
   ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
   ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
 
+  if (!ShouldAddOptNone)
+    F->removeFnAttr(llvm::Attribute::OptimizeNone);
   if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) {
     B.addAttribute(llvm::Attribute::OptimizeNone);
 
     // OptimizeNone implies noinline; we should not be inlining such functions.
     B.addAttribute(llvm::Attribute::NoInline);
     assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
            "OptimizeNone and AlwaysInline on same function!");
 
     // We still need to handle naked functions even though optnone subsumes
     // much of their semantics.
     if (D->hasAttr<NakedAttr>())
       B.addAttribute(llvm::Attribute::Naked);
 
-    // OptimizeNone wins over OptimizeForSize and MinSize.
+    // OptimizeNone wins over all optimization levels including OptimizeForSize
+    // and MinSizesize.
     F->removeFnAttr(llvm::Attribute::OptimizeForSize);
     F->removeFnAttr(llvm::Attribute::MinSize);
+    F->removeFnAttr(llvm::Attribute::OptimizeLess);
+    F->removeFnAttr(llvm::Attribute::OptimizeDefault);
+    F->removeFnAttr(llvm::Attribute::OptimizeAggressive);
   } else if (D->hasAttr<NakedAttr>()) {
     // Naked implies noinline: we should not be inlining such functions.
     B.addAttribute(llvm::Attribute::Naked);
     B.addAttribute(llvm::Attribute::NoInline);
   } else if (D->hasAttr<NoDuplicateAttr>()) {
     B.addAttribute(llvm::Attribute::NoDuplicate);
   } else if (D->hasAttr<NoInlineAttr>()) {
     B.addAttribute(llvm::Attribute::NoInline);

test/CodeGen/aarch64-neon-2velem.c

-// RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
+// RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon -O2 -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
 
 // Test new aarch64 intrinsics and types
 
 #include <arm_neon.h>
 
 // CHECK-LABEL: @test_vmla_lane_s16(
 // CHECK:   [[SHUFFLE:%.*]] = shufflevector <4 x i16> %v, <4 x i16> %v, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 // CHECK:   [[MUL:%.*]] = mul <4 x i16> %b, [[SHUFFLE]]

test/CodeGen/function-attributes-opt-level.c

+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,NONE
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O0 -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,NONE
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O1 -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,LESS
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O2 -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,DEFAULT
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O3 -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,AGGR
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -Os -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,SIZE
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -Oz -std=c99 -o - %s | FileCheck %s --check-prefixes=CHECK,MINSIZE
+
+void f0(void) { }
+// CHECK-LABEL: define void @f0()
+// CHECK: [[ATTR0:#[0-9]+]]
+
+// We can't add optnone if minsize is present.
+void __attribute__((minsize)) f1(void) { }
+// CHECK-LABEL: define void @f1()
+// CHECK: [[MS:#[0-9]+]]
+
+// We can't add optnone if alwaysinline is present.
+void __attribute__((always_inline)) f2(void) { }
+// CHECK-LABEL: define void @f2()
+// CHECK: [[AI:#[0-9]+]]
+
+// NONE:    attributes [[ATTR0]] = { noinline nounwind optnone
+// LESS:    attributes [[ATTR0]] = { nounwind optless
+// DEFAULT: attributes [[ATTR0]] = { nounwind optdefault
+// AGGR:    attributes [[ATTR0]] = { nounwind optaggr
+// SIZE:    attributes [[ATTR0]] = { nounwind optdefault optsize
+// MINSIZE: attributes [[ATTR0]] = { minsize nounwind optdefault optsize
+
+// NONE:    attributes [[MS]] = { minsize noinline nounwind
+// LESS:    attributes [[MS]] = { minsize nounwind optless
+// DEFAULT: attributes [[MS]] = { minsize nounwind optdefault
+// AGGR:    attributes [[MS]] = { minsize nounwind optaggr
+// SIZE:    attributes [[MS]] = { minsize nounwind optdefault optsize
+// No check for MINSIZE because the attributes for f1 match those for f0.
+
+// NONE:    attributes [[AI]] = { alwaysinline nounwind
+// LESS:    attributes [[AI]] = { alwaysinline nounwind optless
+// DEFAULT: attributes [[AI]] = { alwaysinline nounwind optdefault
+// AGGR:    attributes [[AI]] = { alwaysinline nounwind optaggr
+// SIZE:    attributes [[AI]] = { alwaysinline nounwind optdefault optsize
+// MINSIZE: attributes [[AI]] = { alwaysinline minsize nounwind optdefault optsize

test/CodeGen/function-attributes.c

 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -std=c99 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -disable-llvm-passes -Os -std=c99 -o - %s | FileCheck %s
+
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O0 -std=c99 -o - %s | FileCheck %s --check-prefix:NONE
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O1 -std=c99 -o - %s | FileCheck %s --check-prefix:LESS
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O2 -std=c99 -o - %s | FileCheck %s --check-prefix:DEFAULT
+// RUN: %clang_cc1 -triple arm64-unknown-unknown -emit-llvm -disable-llvm-passes -O3 -std=c99 -o - %s | FileCheck %s --check-prefix:AGGR
+
 // CHECK: define signext i8 @f0(i32 %x) [[NUW:#[0-9]+]]
 // CHECK: define zeroext i8 @f1(i32 %x) [[NUW]]
 // CHECK: define void @f2(i8 signext %x) [[NUW]]
 // CHECK: define void @f3(i8 zeroext %x) [[NUW]]
 // CHECK: define signext i16 @f4(i32 %x) [[NUW]]
 // CHECK: define zeroext i16 @f5(i32 %x) [[NUW]]
 // CHECK: define void @f6(i16 signext %x) [[NUW]]
 // CHECK: define void @f7(i16 zeroext %x) [[NUW]]

 // CHECK: call i32 @_setjmp(i32* null)
 // CHECK: [[RT_CALL]]
 // CHECK: ret void
 int _setjmp(jmp_buf);
 void f20(void) {
   _setjmp(0);
 }
 
-// CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} }
-// CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} }
-// CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize readnone{{.*}} }
-// CHECK: attributes [[ALIGN]] = { nounwind optsize alignstack=16{{.*}} }
-// CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
-// CHECK: attributes [[NR]] = { noreturn optsize }
-// CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
-// CHECK: attributes [[RT_CALL]] = { optsize returns_twice }
+// CHECK: attributes [[NUW]] = { nounwind optdefault optsize{{.*}} }
+// CHECK: attributes [[AI]] = { alwaysinline nounwind optdefault optsize{{.*}} }
+// CHECK: attributes [[NUW_OS_RN]] = { nounwind optdefault optsize readnone{{.*}} }
+// CHECK: attributes [[ALIGN]] = { nounwind optdefault optsize alignstack=16{{.*}} }
+// CHECK: attributes [[RT]] = { nounwind optdefault optsize returns_twice{{.*}} }
+// CHECK: attributes [[NR]] = { noreturn optdefault optsize }
+// CHECK: attributes [[NUW_RN]] = { nounwind optdefault optsize readnone }
+// CHECK: attributes [[RT_CALL]] = { optdefault optsize returns_twice }

test/CodeGen/ms-declspecs.c

 // CHECK: call void @f20_t() [[NR:#[0-9]+]]
 __declspec(noreturn) void f20_t(void);
 void f20(void) { f20_t(); }
 
 __declspec(noalias) void noalias_callee(int *x);
 // CHECK: call void @noalias_callee({{.*}}) [[NA:#[0-9]+]]
 void noalias_caller(int *x) { noalias_callee(x); }
 
-// CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} }
-// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
-// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} }
-// CHECK: attributes [[NR]] = { noreturn }
-// CHECK: attributes [[NA]] = { argmemonly nounwind{{.*}} }
+// CHECK: attributes [[NAKED]] = { naked noinline nounwind optdefault{{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind optdefault{{.*}} }
+// CHECK: attributes [[NI]] = { noinline nounwind optdefault{{.*}} }
+// CHECK: attributes [[NR]] = { noreturn optdefault }
+// CHECK: attributes [[NA]] = { argmemonly nounwind optdefault{{.*}} }

test/CodeGenCXX/thunks.cpp

 // This is from Test5:
 // CHECK-OPT-LABEL: define linkonce_odr void @_ZTv0_n24_N5Test51B1fEv
 
 // This is from Test10:
 // CHECK-OPT-LABEL: define linkonce_odr void @_ZN6Test101C3fooEv
 // CHECK-OPT-LABEL: define linkonce_odr void @_ZThn8_N6Test101C3fooEv
 
 // CHECK-NONOPT: attributes [[NUW]] = { noinline nounwind optnone uwtable{{.*}} }
-// CHECK-OPT: attributes [[NUW]] = { nounwind uwtable{{.*}} }
+// CHECK-OPT: attributes [[NUW]] = { nounwind optless uwtable{{.*}} }

test/CodeGenObjC/arc-no-arc-exceptions.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fblocks -fexceptions -fobjc-exceptions -O2 -disable-llvm-passes -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fblocks -fexceptions -fobjc-exceptions -disable-llvm-passes -o - %s | FileCheck -check-prefix=NO-METADATA %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fblocks -fexceptions -fobjc-exceptions -O2 -disable-llvm-passes -o - %s -fobjc-arc-exceptions | FileCheck -check-prefix=NO-METADATA %s
 
 // The front-end should emit clang.arc.no_objc_arc_exceptions in -fobjc-arc-exceptions
 // mode when optimization is enabled, and not otherwise.
 
 void thrower(void);
 void not(void) __attribute__((nothrow));
 
 // CHECK-LABEL: define void @test0(
-// CHECK: call void @thrower(), !clang.arc.no_objc_arc_exceptions !
+// CHECK: call void @thrower() {{#[0-9]}}, !clang.arc.no_objc_arc_exceptions !
 // CHECK: call void @not() [[NUW:#[0-9]+]], !clang.arc.no_objc_arc_exceptions !
 // NO-METADATA-LABEL: define void @test0(
 // NO-METADATA-NOT: !clang.arc.no_objc_arc_exceptions
 // NO-METADATA: }
 void test0(void) {
   thrower();
   not();
 }
 
 // CHECK-LABEL: define void @test1(
-// CHECK: call void @thrower(), !clang.arc.no_objc_arc_exceptions !
+// CHECK: call void @thrower() {{#[0-9]}}, !clang.arc.no_objc_arc_exceptions !
 // CHECK: call void @not() [[NUW]], !clang.arc.no_objc_arc_exceptions !
 // NO-METADATA-LABEL: define void @test1(
 // NO-METADATA-NOT: !clang.arc.no_objc_arc_exceptions
 // NO-METADATA: }
 void test1(id x) {
   id y = x;
   thrower();
   not();
@autoreleasepool {
         __attribute__((__blocks__(byref))) int x;
         void (^b)(void) = ^{
             NSLog(@"Address of x in assigned block: %p", &x);
         };
         b();
     }
 }
 
-// CHECK: attributes [[NUW]] = { nounwind }
+// CHECK: attributes [[NUW]] = { nounwind optdefault }

test/CodeGenOpenCL/convergent.cl

 void test_not_unroll() {
   for (int i = 0; i < 10; i++)
     nodupfun();
 }
 
 // CHECK: declare spir_func void @nodupfun(){{[^#]*}} #[[attr3:[0-9]+]]
 
 // CHECK-LABEL: @assume_convergent_asm
-// CHECK: tail call void asm sideeffect "s_barrier", ""() #5
+// CHECK: tail call void asm sideeffect "s_barrier", ""() #8
 kernel void assume_convergent_asm()
 {
   __asm__ volatile("s_barrier");
 }
 
-// CHECK: attributes #0 = { noinline norecurse nounwind "
+// CHECK: attributes #0 = { noinline norecurse nounwind
 // CHECK: attributes #1 = { {{[^}]*}}convergent{{[^}]*}} }
 // CHECK: attributes #2 = { {{[^}]*}}convergent{{[^}]*}} }
 // CHECK: attributes #3 = { {{[^}]*}}convergent noduplicate{{[^}]*}} }
 // CHECK: attributes #4 = { {{[^}]*}}convergent{{[^}]*}} }
 // CHECK: attributes #5 = { {{[^}]*}}convergent{{[^}]*}} }
-// CHECK: attributes #6 = { {{[^}]*}}convergent noduplicate{{[^}]*}} }
+// CHECK: attributes #6 = { optdefault }
+// CHECK: attributes #7 = { {{[^}]*}}convergent noduplicate{{[^}]*}} }
+// CHECK: attributes #8 = { {{[^}]*}}convergent{{[^}]*}} }