gcc/testsuite/gcc.dg/attr-noipa.c

   1 /* Test the noipa attribute.  */
   2 /* { dg-do compile } */
   3 /* { dg-options "-O2 -fdump-tree-optimized" } */
   4 /* { dg-require-effective-target alloca } */
   5
   6 static inline int __attribute__((noipa))
   7 fn1 (void) /* { dg-warning "inline function \[^\n\]* given attribute noinline" "" } */
   8 {
   9   return 1;
  10 }
  11
  12 /* Verify the function is not inlined into its caller.  */
  13
  14 static __attribute__((noipa)) int
  15 fn2 (int x, int y)
  16 {
  17   return x + y;
  18 }
  19
  20 int
  21 fn3 (int x)
  22 {
  23   return fn2 (x, 0);
  24 }
  25
  26 /* { dg-final { scan-tree-dump "= fn2 \\(" "optimized" } } */
  27
  28 void fn4 (char *);
  29
  30 /* Verify the function is not cloned.  */
  31
  32 __attribute__((__noipa__)) static int
  33 fn5 (int x, int y)
  34 {
  35   char *p = __builtin_alloca (x + y);
  36   fn4 (p);
  37   return x + y;
  38 }
  39
  40 int
  41 fn6 (int x)
  42 {
  43   return fn5 (x, 2);
  44 }
  45
  46 /* { dg-final { scan-tree-dump "= fn5 \\(" "optimized" } } */
  47 /* { dg-final { scan-tree-dump-not "fn5\\.constprop" "optimized" } } */
  48
  49 /* Verify we still remove unused function calls, even if they have
  50    noipa attribute.  */
  51
  52 static void fn7 (void) __attribute__((noipa));
  53 static void
  54 fn7 (void)
  55 {
  56 }
  57
  58 /* { dg-final { scan-tree-dump-not "fn7 \\(" "optimized" } } */
  59
  60 /* Verify noipa functions are not ICF optimized.  */
  61
  62 static __attribute__((noipa)) int
  63 fn8 (int x)
  64 {
  65   return x + 12;
  66 }
  67
  68 static __attribute__((noipa)) int
  69 fn9 (int x)
  70 {
  71   return x + 12;
  72 }
  73
  74 int
  75 fn10 (int x)
  76 {
  77   return fn8 (x) + fn9 (x);
  78 }
  79
  80 /* { dg-final { scan-tree-dump "fn8 \\(int" "optimized" } } */
  81 /* { dg-final { scan-tree-dump "fn9 \\(int" "optimized" } } */
  82
  83 /* Verify IPA-VRP is not performed.  */
  84
  85 void fn11 (void);
  86
  87 static int __attribute__((noipa))
  88 fn12 (int x)
  89 {
  90   if (x < 6 || x >= 29)
  91     fn11 ();
  92 }
  93
  94 void
  95 fn13 (int x)
  96 {
  97   fn12 (6 + (x & 15));
  98 }
  99
 100 /* { dg-final { scan-tree-dump "fn11 \\(\\)" "optimized" } } */
 101
 102 void fn14 (void);
 103
 104 __attribute__((noipa)) static int
 105 fn15 (int x)
 106 {
 107   return x & 7;
 108 }
 109
 110 int
 111 fn16 (int x)
 112 {
 113   x = fn15 (x);
 114   if (x < 0 || x >= 7)
 115     fn14 ();
 116 }
 117
 118 /* { dg-final { scan-tree-dump "fn14 \\(\\)" "optimized" } } */
 119
 120 /* Verify IPA BIT CP is not performed.  */
 121
 122 void fn17 (void);
 123
 124 __attribute__((noipa)) static int
 125 fn18 (int x)
 126 {
 127   if (x & 8)
 128     fn17 ();
 129 }
 130
 131 void
 132 fn19 (void)
 133 {
 134   fn18 (1);
 135   fn18 (2);
 136   fn18 (4);
 137   fn18 (16);
 138   fn18 (32);
 139   fn18 (64);
 140 }
 141
 142 /* { dg-final { scan-tree-dump "fn17 \\(\\)" "optimized" } } */
 143
 144 /* Ensure pure/const discovery is not performed.  */
 145
 146 int var1;
 147 void fn20 (void);
 148
 149 __attribute__((noipa)) static int
 150 fn21 (int x, int y)
 151 {
 152   return x * y;
 153 }
 154
 155 int
 156 fn22 (void)
 157 {
 158   var1 = 7;
 159   asm volatile ("" : "+g" (var1) : : "memory");
 160   int a = var1;
 161   int b = fn21 (a, a);
 162   if (a != var1)
 163     fn20 ();
 164   return b;
 165 }
 166
 167 /* { dg-final { scan-tree-dump "fn20 \\(\\)" "optimized" } } */
 168
 169 /* Verify IPA alignment propagation is not performed.  */
 170
 171 static __attribute__ ((aligned(16))) char var2[32];
 172 void fn23 (void);
 173
 174 __attribute__((noipa)) static void
 175 fn24 (char *p)
 176 {
 177   if ((((__UINTPTR_TYPE__) p) & 15) != 0)
 178     fn23 ();
 179   asm ("");
 180 }
 181
 182 void
 183 fn25 (void)
 184 {
 185   fn24 (var2);
 186   fn24 (var2 + 16);
 187 }
 188
 189 /* { dg-final { scan-tree-dump "fn20 \\(\\)" "optimized" } } */