clang/test/CodeGenCXX/optnone-class-members.cpp

   1 // RUN: %clang_cc1 < %s -triple %itanium_abi_triple -fms-extensions -O2 -disable-llvm-passes -emit-llvm -x c++ | FileCheck %s
   2
   3 // Test attribute 'optnone' on methods:
   4 //  -- member functions;
   5 //  -- static member functions.
   6
   7 // Verify that all methods of struct A are associated to the same attribute set.
   8 // The attribute set shall contain attributes 'noinline' and 'optnone'.
   9
  10 struct A {
  11   // Definition of an optnone static method.
  12   __attribute__((optnone))
  13   static int static_optnone_method(int a) {
  14     return a + a;
  15   }
  16   // CHECK: @_ZN1A21static_optnone_methodEi({{.*}}) [[OPTNONE:#[0-9]+]]
  17
  18   // Definition of an optnone normal method.
  19   __attribute__((optnone))
  20   int optnone_method(int a) {
  21     return a + a + a + a;
  22   }
  23   // CHECK: @_ZN1A14optnone_methodEi({{.*}}) [[OPTNONE]]
  24
  25   // Declaration of an optnone method with out-of-line definition
  26   // that doesn't say optnone.
  27   __attribute__((optnone))
  28   int optnone_decl_method(int a);
  29
  30   // Methods declared without attribute optnone; the definitions will
  31   // have attribute optnone, and we verify optnone wins.
  32   __forceinline static int static_forceinline_method(int a);
  33   __attribute__((always_inline)) int alwaysinline_method(int a);
  34   __attribute__((noinline)) int noinline_method(int a);
  35   __attribute__((minsize)) int minsize_method(int a);
  36 };
  37
  38 void foo() {
  39   A a;
  40   A::static_optnone_method(4);
  41   a.optnone_method(14);
  42   a.optnone_decl_method(12);
  43   A::static_forceinline_method(5);
  44   a.alwaysinline_method(5);
  45   a.noinline_method(6);
  46   a.minsize_method(7);
  47 }
  48
  49 // No attribute here, should still be on the definition.
  50 int A::optnone_decl_method(int a) {
  51   return a;
  52 }
  53 // CHECK: @_ZN1A19optnone_decl_methodEi({{.*}}) [[OPTNONE]]
  54
  55 // optnone implies noinline; therefore attribute noinline is added to
  56 // the set of function attributes.
  57 // forceinline is instead translated as 'always_inline'.
  58 // However 'noinline' wins over 'always_inline' and therefore
  59 // the resulting attributes for this method are: noinline + optnone
  60 __attribute__((optnone))
  61 int A::static_forceinline_method(int a) {
  62   return a + a + a + a;
  63 }
  64 // CHECK: @_ZN1A25static_forceinline_methodEi({{.*}}) [[OPTNONE]]
  65
  66 __attribute__((optnone))
  67 int A::alwaysinline_method(int a) {
  68   return a + a + a + a;
  69 }
  70 // CHECK: @_ZN1A19alwaysinline_methodEi({{.*}}) [[OPTNONE]]
  71
  72 // 'noinline' + 'noinline and optnone' = 'noinline and optnone'
  73 __attribute__((optnone))
  74 int A::noinline_method(int a) {
  75   return a + a + a + a;
  76 }
  77 // CHECK: @_ZN1A15noinline_methodEi({{.*}}) [[OPTNONE]]
  78
  79 // 'optnone' wins over 'minsize'
  80 __attribute__((optnone))
  81 int A::minsize_method(int a) {
  82   return a + a + a + a;
  83 }
  84 // CHECK: @_ZN1A14minsize_methodEi({{.*}}) [[OPTNONE]]
  85
  86
  87 // Test attribute 'optnone' on methods:
  88 //  -- pure virtual functions
  89 //  -- base virtual and derived virtual
  90 //  -- base virtual but not derived virtual
  91 //  -- optnone methods redefined in override
  92
  93 // A method defined in override doesn't inherit the function attributes of the
  94 // superclass method.
  95
  96 struct B {
  97   virtual int pure_virtual(int a) = 0;
  98   __attribute__((optnone))
  99   virtual int pure_virtual_with_optnone(int a) = 0;
 100
 101   virtual int base(int a) {
 102     return a + a + a + a;
 103   }
 104
 105   __attribute__((optnone))
 106   virtual int optnone_base(int a) {
 107     return a + a + a + a;
 108   }
 109
 110   __attribute__((optnone))
 111   virtual int only_base_virtual(int a) {
 112     return a + a;
 113   }
 114 };
 115
 116 struct C : public B {
 117   __attribute__((optnone))
 118   virtual int pure_virtual(int a) {
 119     return a + a + a + a;
 120   }
 121
 122   virtual int pure_virtual_with_optnone(int a) {
 123     return a + a + a + a;
 124   }
 125
 126   __attribute__((optnone))
 127   virtual int base(int a) {
 128     return a + a;
 129   }
 130
 131   virtual int optnone_base(int a) {
 132     return a + a;
 133   }
 134
 135   int only_base_virtual(int a) {
 136     return a + a + a + a;
 137   }
 138 };
 139
 140 int bar() {
 141   C c;
 142   int result;
 143   result = c.pure_virtual(3);
 144   result += c.pure_virtual_with_optnone(2);
 145   result += c.base(5);
 146   result += c.optnone_base(7);
 147   result += c.only_base_virtual(9);
 148   return result;
 149 }
 150
 151 // CHECK: @_ZN1C12pure_virtualEi({{.*}}) {{.*}} [[OPTNONE]]
 152 // CHECK: @_ZN1C25pure_virtual_with_optnoneEi({{.*}}) {{.*}} [[NORMAL:#[0-9]+]]
 153 // CHECK: @_ZN1C4baseEi({{.*}}) {{.*}} [[OPTNONE]]
 154 // CHECK: @_ZN1C12optnone_baseEi({{.*}}) {{.*}} [[NORMAL]]
 155 // CHECK: @_ZN1C17only_base_virtualEi({{.*}}) {{.*}} [[NORMAL]]
 156 // CHECK: @_ZN1B4baseEi({{.*}}) {{.*}} [[NORMAL]]
 157 // CHECK: @_ZN1B12optnone_baseEi({{.*}}) {{.*}} [[OPTNONE]]
 158 // CHECK: @_ZN1B17only_base_virtualEi({{.*}}) {{.*}} [[OPTNONE]]
 159
 160
 161 // CHECK: attributes [[NORMAL]] =
 162 // CHECK-NOT: noinline
 163 // CHECK-NOT: optnone
 164 // CHECK: attributes [[OPTNONE]] = {{.*}} noinline {{.*}} optnone