Home | History | Annotate | Download | only in CodeGen
      1 // RUN: %clang_cc1 -triple sparcv9-unknown-unknown -emit-llvm %s -o - | FileCheck %s
      2 #include <stdarg.h>
      3 
      4 // CHECK-LABEL: define void @f_void()
      5 void f_void(void) {}
      6 
      7 // Arguments and return values smaller than the word size are extended.
      8 
      9 // CHECK-LABEL: define signext i32 @f_int_1(i32 signext %x)
     10 int f_int_1(int x) { return x; }
     11 
     12 // CHECK-LABEL: define zeroext i32 @f_int_2(i32 zeroext %x)
     13 unsigned f_int_2(unsigned x) { return x; }
     14 
     15 // CHECK-LABEL: define i64 @f_int_3(i64 %x)
     16 long long f_int_3(long long x) { return x; }
     17 
     18 // CHECK-LABEL: define signext i8 @f_int_4(i8 signext %x)
     19 char f_int_4(char x) { return x; }
     20 
     21 // CHECK-LABEL: define fp128 @f_ld(fp128 %x)
     22 long double f_ld(long double x) { return x; }
     23 
     24 // Small structs are passed in registers.
     25 struct small {
     26   int *a, *b;
     27 };
     28 
     29 // CHECK-LABEL: define %struct.small @f_small(i32* %x.coerce0, i32* %x.coerce1)
     30 struct small f_small(struct small x) {
     31   x.a += *x.b;
     32   x.b = 0;
     33   return x;
     34 }
     35 
     36 // Medium-sized structs are passed indirectly, but can be returned in registers.
     37 struct medium {
     38   int *a, *b;
     39   int *c, *d;
     40 };
     41 
     42 // CHECK-LABEL: define %struct.medium @f_medium(%struct.medium* %x)
     43 struct medium f_medium(struct medium x) {
     44   x.a += *x.b;
     45   x.b = 0;
     46   return x;
     47 }
     48 
     49 // Large structs are also returned indirectly.
     50 struct large {
     51   int *a, *b;
     52   int *c, *d;
     53   int x;
     54 };
     55 
     56 // CHECK-LABEL: define void @f_large(%struct.large* noalias sret %agg.result, %struct.large* %x)
     57 struct large f_large(struct large x) {
     58   x.a += *x.b;
     59   x.b = 0;
     60   return x;
     61 }
     62 
     63 // A 64-bit struct fits in a register.
     64 struct reg {
     65   int a, b;
     66 };
     67 
     68 // CHECK-LABEL: define i64 @f_reg(i64 %x.coerce)
     69 struct reg f_reg(struct reg x) {
     70   x.a += x.b;
     71   return x;
     72 }
     73 
     74 // Structs with mixed int and float parts require the inreg attribute.
     75 struct mixed {
     76   int a;
     77   float b;
     78 };
     79 
     80 // CHECK-LABEL: define inreg %struct.mixed @f_mixed(i32 inreg %x.coerce0, float inreg %x.coerce1)
     81 struct mixed f_mixed(struct mixed x) {
     82   x.a += 1;
     83   return x;
     84 }
     85 
     86 // Struct with padding.
     87 struct mixed2 {
     88   int a;
     89   double b;
     90 };
     91 
     92 // CHECK: define { i64, double } @f_mixed2(i64 %x.coerce0, double %x.coerce1)
     93 // CHECK: store i64 %x.coerce0
     94 // CHECK: store double %x.coerce1
     95 struct mixed2 f_mixed2(struct mixed2 x) {
     96   x.a += 1;
     97   return x;
     98 }
     99 
    100 // Struct with single element and padding in passed in the high bits of a
    101 // register.
    102 struct tiny {
    103   char a;
    104 };
    105 
    106 // CHECK-LABEL: define i64 @f_tiny(i64 %x.coerce)
    107 // CHECK: %[[HB:[^ ]+]] = lshr i64 %x.coerce, 56
    108 // CHECK: = trunc i64 %[[HB]] to i8
    109 struct tiny f_tiny(struct tiny x) {
    110   x.a += 1;
    111   return x;
    112 }
    113 
    114 // CHECK-LABEL: define void @call_tiny()
    115 // CHECK: %[[XV:[^ ]+]] = zext i8 %{{[^ ]+}} to i64
    116 // CHECK: %[[HB:[^ ]+]] = shl i64 %[[XV]], 56
    117 // CHECK: = call i64 @f_tiny(i64 %[[HB]])
    118 void call_tiny() {
    119   struct tiny x = { 1 };
    120   f_tiny(x);
    121 }
    122 
    123 // CHECK-LABEL: define signext i32 @f_variable(i8* %f, ...)
    124 // CHECK: %ap = alloca i8*
    125 // CHECK: call void @llvm.va_start
    126 //
    127 int f_variable(char *f, ...) {
    128   int s = 0;
    129   char c;
    130   va_list ap;
    131   va_start(ap, f);
    132   while ((c = *f++)) switch (c) {
    133 
    134 // CHECK: %[[CUR:[^ ]+]] = load i8** %ap
    135 // CHECK-DAG: %[[NXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 8
    136 // CHECK-DAG: store i8* %[[NXT]], i8** %ap
    137 // CHECK-DAG: %[[EXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 4
    138 // CHECK-DAG: %[[ADR:[^ ]+]] = bitcast i8* %[[EXT]] to i32*
    139 // CHECK-DAG: load i32* %[[ADR]]
    140 // CHECK: br
    141   case 'i':
    142     s += va_arg(ap, int);
    143     break;
    144 
    145 // CHECK: %[[CUR:[^ ]+]] = load i8** %ap
    146 // CHECK-DAG: %[[NXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 8
    147 // CHECK-DAG: store i8* %[[NXT]], i8** %ap
    148 // CHECK-DAG: %[[ADR:[^ ]+]] = bitcast i8* %[[CUR]] to i64*
    149 // CHECK-DAG: load i64* %[[ADR]]
    150 // CHECK: br
    151   case 'l':
    152     s += va_arg(ap, long);
    153     break;
    154 
    155 // CHECK: %[[CUR:[^ ]+]] = load i8** %ap
    156 // CHECK-DAG: %[[NXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 8
    157 // CHECK-DAG: store i8* %[[NXT]], i8** %ap
    158 // CHECK-DAG: %[[ADR:[^ ]+]] = bitcast i8* %[[CUR]] to %struct.tiny*
    159 // CHECK: br
    160   case 't':
    161     s += va_arg(ap, struct tiny).a;
    162     break;
    163 
    164 // CHECK: %[[CUR:[^ ]+]] = load i8** %ap
    165 // CHECK-DAG: %[[NXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 16
    166 // CHECK-DAG: store i8* %[[NXT]], i8** %ap
    167 // CHECK-DAG: %[[ADR:[^ ]+]] = bitcast i8* %[[CUR]] to %struct.small*
    168 // CHECK: br
    169   case 's':
    170     s += *va_arg(ap, struct small).a;
    171     break;
    172 
    173 // CHECK: %[[CUR:[^ ]+]] = load i8** %ap
    174 // CHECK-DAG: %[[NXT:[^ ]+]] = getelementptr i8* %[[CUR]], i32 8
    175 // CHECK-DAG: store i8* %[[NXT]], i8** %ap
    176 // CHECK-DAG: %[[IND:[^ ]+]] = bitcast i8* %[[CUR]] to %struct.medium**
    177 // CHECK-DAG: %[[ADR:[^ ]+]] = load %struct.medium** %[[IND]]
    178 // CHECK: br
    179   case 'm':
    180     s += *va_arg(ap, struct medium).a;
    181     break;
    182   }
    183   return s;
    184 }
    185