test/CodeGen/switch.c

   1 // RUN: %clang_cc1 -triple i386-unknown-unknown -O3 %s -emit-llvm -o - | FileCheck %s
   2
   3 int foo(int i) {
   4   int j = 0;
   5   switch (i) {
   6   case -1:
   7     j = 1; break;
   8   case 1 :
   9     j = 2; break;
  10   case 2:
  11     j = 3; break;
  12   default:
  13     j = 42; break;
  14   }
  15   j = j + 1;
  16   return j;
  17 }
  18
  19 int foo2(int i) {
  20   int j = 0;
  21   switch (i) {
  22   case 1 :
  23     j = 2; break;
  24   case 2 ... 10:
  25     j = 3; break;
  26   default:
  27     j = 42; break;
  28   }
  29   j = j + 1;
  30   return j;
  31 }
  32
  33 int foo3(int i) {
  34   int j = 0;
  35   switch (i) {
  36   default:
  37     j = 42; break;
  38   case 111:
  39     j = 111; break;
  40   case 0 ... 100:
  41     j = 1; break;
  42   case 222:
  43     j = 222; break;
  44   }
  45   return j;
  46 }
  47
  48
  49 static int foo4(int i) {
  50   int j = 0;
  51   switch (i) {
  52   case 111:
  53     j = 111; break;
  54   case 0 ... 100:
  55     j = 1; break;
  56   case 222:
  57     j = 222; break;
  58   default:
  59     j = 42; break;
  60   case 501 ... 600:
  61     j = 5; break;
  62   }
  63   return j;
  64 }
  65
  66 // CHECK: define i32 @foo4t()
  67 // CHECK: ret i32 376
  68 // CHECK: }
  69 int foo4t() {
  70   // 111 + 1 + 222 + 42 = 376
  71   return foo4(111) + foo4(99) + foo4(222) + foo4(601);
  72 }
  73
  74 // CHECK: define void @foo5()
  75 // CHECK-NOT: switch
  76 // CHECK: }
  77 void foo5(){
  78     switch(0){
  79     default:
  80         if (0) {
  81
  82         }
  83     }
  84 }
  85
  86 // CHECK: define void @foo6()
  87 // CHECK-NOT: switch
  88 // CHECK: }
  89 void foo6(){
  90     switch(0){
  91     }
  92 }
  93
  94 // CHECK: define void @foo7()
  95 // CHECK-NOT: switch
  96 // CHECK: }
  97 void foo7(){
  98     switch(0){
  99       foo7();
 100     }
 101 }
 102
 103
 104 // CHECK: define i32 @f8(
 105 // CHECK: ret i32 3
 106 // CHECK: }
 107 int f8(unsigned x) {
 108   switch(x) {
 109   default:
 110     return 3;
 111   case 0xFFFFFFFF ... 1: // This range should be empty because x is unsigned.
 112     return 0;
 113   }
 114 }
 115
 116 // Ensure that default after a case range is not ignored.
 117 //
 118 // CHECK: define i32 @f9()
 119 // CHECK: ret i32 10
 120 // CHECK: }
 121 static int f9_0(unsigned x) {
 122   switch(x) {
 123   case 10 ... 0xFFFFFFFF:
 124     return 0;
 125   default:
 126     return 10;
 127   }
 128 }
 129 int f9() {
 130   return f9_0(2);
 131 }
 132
 133 // Ensure that this doesn't compile to infinite loop in g() due to
 134 // miscompilation of fallthrough from default to a (tested) case
 135 // range.
 136 //
 137 // CHECK: define i32 @f10()
 138 // CHECK: ret i32 10
 139 // CHECK: }
 140 static int f10_0(unsigned x) {
 141   switch(x) {
 142   default:
 143     x += 1;
 144   case 10 ... 0xFFFFFFFF:
 145     return 0;
 146   }
 147 }
 148
 149 int f10() {
 150   f10_0(1);
 151   return 10;
 152 }
 153
 154 // This generated incorrect code because of poor switch chaining.
 155 //
 156 // CHECK: define i32 @f11(
 157 // CHECK: ret i32 3
 158 // CHECK: }
 159 int f11(int x) {
 160   switch(x) {
 161   default:
 162     return 3;
 163   case 10 ... 0xFFFFFFFF:
 164     return 0;
 165   }
 166 }
 167
 168 // This just asserted because of the way case ranges were calculated.
 169 //
 170 // CHECK: define i32 @f12(
 171 // CHECK: ret i32 3
 172 // CHECK: }
 173 int f12(int x) {
 174   switch (x) {
 175   default:
 176     return 3;
 177   case 10 ... -1:
 178     return 0;
 179   }
 180 }
 181
 182 // Make sure return is not constant (if empty range is skipped or miscompiled)
 183 //
 184 // CHECK: define i32 @f13(
 185 // CHECK: ret i32 %
 186 // CHECK: }
 187 int f13(unsigned x) {
 188   switch(x) {
 189   case 2:
 190     // fallthrough empty range
 191   case 10 ... 9:
 192     return 10;
 193   default:
 194     return 0;
 195   }
 196 }
 197
 198 // Don't delete a basic block that we want to introduce later references to.
 199 // This isn't really specific to switches, but it's easy to show with them.
 200 // rdar://problem/8837067
 201 int f14(int x) {
 202   switch (x) {
 203
 204   // case range so that the case block has no predecessors
 205   case 0 ... 15:
 206     // any expression which doesn't introduce a new block
 207     (void) 0;
 208     // kaboom
 209
 210   default:
 211     return x;
 212   }
 213 }