src/rt/rust_test_helpers.c

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Helper functions used only in tests
  12
  13 #include <stdint.h>
  14 #include <assert.h>
  15 #include <stdarg.h>
  16
  17 // These functions are used in the unit tests for C ABI calls.
  18
  19 uint32_t
  20 rust_dbg_extern_identity_u32(uint32_t u) {
  21     return u;
  22 }
  23
  24 uint64_t
  25 rust_dbg_extern_identity_u64(uint64_t u) {
  26     return u;
  27 }
  28
  29 double
  30 rust_dbg_extern_identity_double(double u) {
  31     return u;
  32 }
  33
  34 char
  35 rust_dbg_extern_identity_u8(char u) {
  36     return u;
  37 }
  38
  39 typedef void *(*dbg_callback)(void*);
  40
  41 void *
  42 rust_dbg_call(dbg_callback cb, void *data) {
  43     return cb(data);
  44 }
  45
  46 void rust_dbg_do_nothing() { }
  47
  48 struct TwoU8s {
  49     uint8_t one;
  50     uint8_t two;
  51 };
  52
  53 struct TwoU8s
  54 rust_dbg_extern_return_TwoU8s() {
  55     struct TwoU8s s;
  56     s.one = 10;
  57     s.two = 20;
  58     return s;
  59 }
  60
  61 struct TwoU8s
  62 rust_dbg_extern_identity_TwoU8s(struct TwoU8s u) {
  63     return u;
  64 }
  65
  66 struct TwoU16s {
  67     uint16_t one;
  68     uint16_t two;
  69 };
  70
  71 struct TwoU16s
  72 rust_dbg_extern_return_TwoU16s() {
  73     struct TwoU16s s;
  74     s.one = 10;
  75     s.two = 20;
  76     return s;
  77 }
  78
  79 struct TwoU16s
  80 rust_dbg_extern_identity_TwoU16s(struct TwoU16s u) {
  81     return u;
  82 }
  83
  84 struct TwoU32s {
  85     uint32_t one;
  86     uint32_t two;
  87 };
  88
  89 struct TwoU32s
  90 rust_dbg_extern_return_TwoU32s() {
  91     struct TwoU32s s;
  92     s.one = 10;
  93     s.two = 20;
  94     return s;
  95 }
  96
  97 struct TwoU32s
  98 rust_dbg_extern_identity_TwoU32s(struct TwoU32s u) {
  99     return u;
 100 }
 101
 102 struct TwoU64s {
 103     uint64_t one;
 104     uint64_t two;
 105 };
 106
 107 struct TwoU64s
 108 rust_dbg_extern_return_TwoU64s() {
 109     struct TwoU64s s;
 110     s.one = 10;
 111     s.two = 20;
 112     return s;
 113 }
 114
 115 struct TwoU64s
 116 rust_dbg_extern_identity_TwoU64s(struct TwoU64s u) {
 117     return u;
 118 }
 119
 120 struct TwoDoubles {
 121     double one;
 122     double two;
 123 };
 124
 125 struct TwoDoubles
 126 rust_dbg_extern_identity_TwoDoubles(struct TwoDoubles u) {
 127     return u;
 128 }
 129
 130 struct ManyInts {
 131     int8_t arg1;
 132     int16_t arg2;
 133     int32_t arg3;
 134     int16_t arg4;
 135     int8_t arg5;
 136     struct TwoU8s arg6;
 137 };
 138
 139 // MSVC doesn't allow empty structs or unions
 140 #ifndef _MSC_VER
 141 struct Empty {
 142 };
 143
 144 void
 145 rust_dbg_extern_empty_struct(struct ManyInts v1, struct Empty e, struct ManyInts v2) {
 146     assert(v1.arg1 == v2.arg1 + 1);
 147     assert(v1.arg2 == v2.arg2 + 1);
 148     assert(v1.arg3 == v2.arg3 + 1);
 149     assert(v1.arg4 == v2.arg4 + 1);
 150     assert(v1.arg5 == v2.arg5 + 1);
 151     assert(v1.arg6.one == v2.arg6.one + 1);
 152     assert(v1.arg6.two == v2.arg6.two + 1);
 153 }
 154 #endif
 155
 156 intptr_t
 157 rust_get_test_int() {
 158   return 1;
 159 }
 160
 161 char *
 162 rust_get_null_ptr() {
 163     return 0;
 164 }
 165
 166 /* Debug helpers strictly to verify ABI conformance.
 167  *
 168  * FIXME (#2665): move these into a testcase when the testsuite
 169  * understands how to have explicit C files included.
 170  */
 171
 172 struct quad {
 173     uint64_t a;
 174     uint64_t b;
 175     uint64_t c;
 176     uint64_t d;
 177 };
 178
 179 struct floats {
 180     double a;
 181     uint8_t b;
 182     double c;
 183 };
 184
 185 struct quad
 186 rust_dbg_abi_1(struct quad q) {
 187     struct quad qq = { q.c + 1,
 188                        q.d - 1,
 189                        q.a + 1,
 190                        q.b - 1 };
 191     return qq;
 192 }
 193
 194 struct floats
 195 rust_dbg_abi_2(struct floats f) {
 196     struct floats ff = { f.c + 1.0,
 197                          0xff,
 198                          f.a - 1.0 };
 199     return ff;
 200 }
 201
 202 int
 203 rust_dbg_static_mut = 3;
 204
 205 void
 206 rust_dbg_static_mut_check_four() {
 207     assert(rust_dbg_static_mut == 4);
 208 }
 209
 210 struct S {
 211     uint64_t x;
 212     uint64_t y;
 213     uint64_t z;
 214 };
 215
 216 uint64_t get_x(struct S s) {
 217     return s.x;
 218 }
 219
 220 uint64_t get_y(struct S s) {
 221     return s.y;
 222 }
 223
 224 uint64_t get_z(struct S s) {
 225     return s.z;
 226 }
 227
 228 uint64_t get_c_many_params(void *a, void *b, void *c, void *d, struct quad f) {
 229     return f.c;
 230 }
 231
 232 // Calculates the average of `(x + y) / n` where x: i64, y: f64. There must be exactly n pairs
 233 // passed as variadic arguments.
 234 double rust_interesting_average(uint64_t n, ...) {
 235     va_list pairs;
 236     double sum = 0.0;
 237     int i;
 238     va_start(pairs, n);
 239     for(i = 0; i < n; i += 1) {
 240         sum += (double)va_arg(pairs, int64_t);
 241         sum += va_arg(pairs, double);
 242     }
 243     va_end(pairs);
 244     return sum / n;
 245 }
 246
 247 int32_t rust_int8_to_int32(int8_t x) {
 248     return (int32_t)x;
 249 }