Add COMPILER_RT_ABI attribute to declarations of builtin functions in unittests

[dschuff]

Summary

This makes their local declarations match their definitions for ARM targets,
where they have a different calling convention.

This really only affects functions that use floating point types (since the
runtime functions use soft-float, and some targets may default to hard-float)
but it seemed good to make it uniform and do the int-only ones too.

[rengolin]

I can't see why this would be a bad idea, given that it makes it homogeneous and in sync with the lib/builtins/ function declarations.

[rengolin]

Hi Derek,

I say go for it, and we'll see if there's any side effects on the buildbots.

LGTM, Thanks!

[dschuff]

thanks, will do.

compiler-rt/trunk/test/builtins/Unit/absvdi2_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: absolute value
 
 // Effects: aborts if abs(x) < 0
 
-di_int __absvdi2(di_int a);
+COMPILER_RT_ABI di_int __absvdi2(di_int a);
 
 int test__absvdi2(di_int a)
 {
     di_int x = __absvdi2(a);
     di_int expected = a;
     if (expected < 0)
         expected = -expected;
     if (x != expected || expected < 0)

compiler-rt/trunk/test/builtins/Unit/absvsi2_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: absolute value
 
 // Effects: aborts if abs(x) < 0
 
-si_int __absvsi2(si_int a);
+COMPILER_RT_ABI si_int __absvsi2(si_int a);
 
 int test__absvsi2(si_int a)
 {
     si_int x = __absvsi2(a);
     si_int expected = a;
     if (expected < 0)
         expected = -expected;
     if (x != expected || expected < 0)

compiler-rt/trunk/test/builtins/Unit/absvti2_test.c

 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: absolute value
 
 // Effects: aborts if abs(x) < 0
 
-ti_int __absvti2(ti_int a);
+COMPILER_RT_ABI ti_int __absvti2(ti_int a);
 
 int test__absvti2(ti_int a)
 {
     ti_int x = __absvti2(a);
     ti_int expected = a;
     if (expected < 0)
         expected = -expected;
     if (x != expected || expected < 0)

compiler-rt/trunk/test/builtins/Unit/adddf3vfp_test.c

 //===-- adddf3vfp_test.c - Test __adddf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __adddf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 #if __arm__
-extern double __adddf3vfp(double a, double b);
+extern COMPILER_RT_ABI double __adddf3vfp(double a, double b);
 
 int test__adddf3vfp(double a, double b)
 {
     double actual = __adddf3vfp(a, b);
     double expected = a + b;
     if (actual != expected)
         printf("error in test__adddf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);

compiler-rt/trunk/test/builtins/Unit/addsf3vfp_test.c

 //===-- addsf3vfp_test.c - Test __addsf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __addsf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __addsf3vfp(float a, float b);
+extern COMPILER_RT_ABI float __addsf3vfp(float a, float b);
 
 #if __arm__
 int test__addsf3vfp(float a, float b)
 {
     float actual = __addsf3vfp(a, b);
     float expected = a + b;
     if (actual != expected)
         printf("error in test__addsf3vfp(%f, %f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/addtf3_test.c

 //===--------------- addtf3_test.c - Test __addtf3 ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __addtf3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: a + b
-long double __addtf3(long double a, long double b);
+COMPILER_RT_ABI long double __addtf3(long double a, long double b);
 
 int test__addtf3(long double a, long double b,
                  uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __addtf3(a, b);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){

compiler-rt/trunk/test/builtins/Unit/addvdi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a + b
 
 // Effects: aborts if a + b overflows
 
-di_int __addvdi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __addvdi3(di_int a, di_int b);
 
 int test__addvdi3(di_int a, di_int b)
 {
     di_int x = __addvdi3(a, b);
     di_int expected = a + b;
     if (x != expected)
         printf("error in test__addvdi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
                 a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/addvsi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a + b
 
 // Effects: aborts if a + b overflows
 
-si_int __addvsi3(si_int a, si_int b);
+COMPILER_RT_ABI si_int __addvsi3(si_int a, si_int b);
 
 int test__addvsi3(si_int a, si_int b)
 {
     si_int x = __addvsi3(a, b);
     si_int expected = a + b;
     if (x != expected)
         printf("error in test__addvsi3(0x%X, 0x%X) = %d, expected %d\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/addvti3_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a + b
 
 // Effects: aborts if a + b overflows
 
-ti_int __addvti3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __addvti3(ti_int a, ti_int b);
 
 int test__addvti3(ti_int a, ti_int b)
 {
     ti_int x = __addvti3(a, b);
     ti_int expected = a + b;
     if (x != expected)
     {
         twords at;

compiler-rt/trunk/test/builtins/Unit/ashldi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a << b
 
 // Precondition:  0 <= b < bits_in_dword
 
-di_int __ashldi3(di_int a, si_int b);
+COMPILER_RT_ABI di_int __ashldi3(di_int a, si_int b);
 
 int test__ashldi3(di_int a, si_int b, di_int expected)
 {
     di_int x = __ashldi3(a, b);
     if (x != expected)
         printf("error in __ashldi3: %llX << %d = %llX, expected %llX\n",
                a, b, __ashldi3(a, b), expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/ashlti3_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a << b
 
 // Precondition:  0 <= b < bits_in_tword
 
-ti_int __ashlti3(ti_int a, si_int b);
+COMPILER_RT_ABI ti_int __ashlti3(ti_int a, si_int b);
 
 int test__ashlti3(ti_int a, si_int b, ti_int expected)
 {
     ti_int x = __ashlti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/ashrdi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: arithmetic a >> b
 
 // Precondition:  0 <= b < bits_in_dword
 
-di_int __ashrdi3(di_int a, si_int b);
+COMPILER_RT_ABI di_int __ashrdi3(di_int a, si_int b);
 
 int test__ashrdi3(di_int a, si_int b, di_int expected)
 {
     di_int x = __ashrdi3(a, b);
     if (x != expected)
         printf("error in __ashrdi3: %llX >> %d = %llX, expected %llX\n",
                a, b, __ashrdi3(a, b), expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/ashrti3_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: arithmetic a >> b
 
 // Precondition:  0 <= b < bits_in_tword
 
-ti_int __ashrti3(ti_int a, si_int b);
+COMPILER_RT_ABI ti_int __ashrti3(ti_int a, si_int b);
 
 int test__ashrti3(ti_int a, si_int b, ti_int expected)
 {
     ti_int x = __ashrti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/clzdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-si_int __clzdi2(di_int a);
+COMPILER_RT_ABI si_int __clzdi2(di_int a);
 
 int test__clzdi2(di_int a, si_int expected)
 {
     si_int x = __clzdi2(a);
     if (x != expected)
         printf("error in __clzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/clzsi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-si_int __clzsi2(si_int a);
+COMPILER_RT_ABI si_int __clzsi2(si_int a);
 
 int test__clzsi2(si_int a, si_int expected)
 {
     si_int x = __clzsi2(a);
     if (x != expected)
         printf("error in __clzsi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/clzti2_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-si_int __clzti2(ti_int a);
+COMPILER_RT_ABI si_int __clzti2(ti_int a);
 
 int test__clzti2(ti_int a, si_int expected)
 {
     si_int x = __clzti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/cmpdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns:  if (a <  b) returns 0
 //           if (a == b) returns 1
 //           if (a >  b) returns 2
 
-si_int __cmpdi2(di_int a, di_int b);
+COMPILER_RT_ABI si_int __cmpdi2(di_int a, di_int b);
 
 int test__cmpdi2(di_int a, di_int b, si_int expected)
 {
     si_int x = __cmpdi2(a, b);
     if (x != expected)
         printf("error in __cmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/cmpti2_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns:  if (a <  b) returns 0
 //           if (a == b) returns 1
 //           if (a >  b) returns 2
 
-si_int __cmpti2(ti_int a, ti_int b);
+COMPILER_RT_ABI si_int __cmpti2(ti_int a, ti_int b);
 
 int test__cmpti2(ti_int a, ti_int b, si_int expected)
 {
     si_int x = __cmpti2(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/ctzdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-si_int __ctzdi2(di_int a);
+COMPILER_RT_ABI si_int __ctzdi2(di_int a);
 
 int test__ctzdi2(di_int a, si_int expected)
 {
     si_int x = __ctzdi2(a);
     if (x != expected)
         printf("error in __ctzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/ctzsi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-si_int __ctzsi2(si_int a);
+COMPILER_RT_ABI si_int __ctzsi2(si_int a);
 
 int test__ctzsi2(si_int a, si_int expected)
 {
     si_int x = __ctzsi2(a);
     if (x != expected)
         printf("error in __ctzsi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/ctzti2_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-si_int __ctzti2(ti_int a);
+COMPILER_RT_ABI si_int __ctzti2(ti_int a);
 
 int test__ctzti2(ti_int a, si_int expected)
 {
     si_int x = __ctzti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/divdc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-double _Complex __divdc3(double __a, double __b, double __c, double __d);
+COMPILER_RT_ABI double _Complex
+__divdc3(double __a, double __b, double __c, double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(double _Complex x)
 {
     if (x == 0)
         return zero;

compiler-rt/trunk/test/builtins/Unit/divdf3vfp_test.c

 //===-- divdf3vfp_test.c - Test __divdf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __divdf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 #if __arm__
-extern double __divdf3vfp(double a, double b);
+extern COMPILER_RT_ABI double __divdf3vfp(double a, double b);
 
 int test__divdf3vfp(double a, double b)
 {
     double actual = __divdf3vfp(a, b);
     double expected = a / b;
     if (actual != expected)
         printf("error in test__divdf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);

compiler-rt/trunk/test/builtins/Unit/divdi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-di_int __divdi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
 
 int test__divdi3(di_int a, di_int b, di_int expected)
 {
     di_int x = __divdi3(a, b);
     if (x != expected)
         printf("error in __divdi3: %lld / %lld = %lld, expected %lld\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/divmodsi4_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-extern si_int __divmodsi4(si_int a, si_int b, si_int* rem);
+extern COMPILER_RT_ABI si_int __divmodsi4(si_int a, si_int b, si_int* rem);
 
 
 int test__divmodsi4(si_int a, si_int b, 
             si_int expected_result, si_int expected_rem)
 {
   si_int rem;
     si_int result = __divmodsi4(a, b, &rem);
     if (result != expected_result) {

compiler-rt/trunk/test/builtins/Unit/divsc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-float _Complex __divsc3(float __a, float __b, float __c, float __d);
+COMPILER_RT_ABI float _Complex
+__divsc3(float __a, float __b, float __c, float __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(float _Complex x)
 {
     if (x == 0)
         return zero;

compiler-rt/trunk/test/builtins/Unit/divsf3vfp_test.c

 //===-- divsf3vfp_test.c - Test __divsf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __divsf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __divsf3vfp(float a, float b);
+extern COMPILER_RT_ABI float __divsf3vfp(float a, float b);
 
 #if __arm__
 int test__divsf3vfp(float a, float b)
 {
     float actual = __divsf3vfp(a, b);
     float expected = a / b;
     if (actual != expected)
         printf("error in test__divsf3vfp(%f, %f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/divsi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-si_int __divsi3(si_int a, si_int b);
+COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
 
 int test__divsi3(si_int a, si_int b, si_int expected)
 {
     si_int x = __divsi3(a, b);
     if (x != expected)
         printf("error in __divsi3: %d / %d = %d, expected %d\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/divtc3_test.c

 #if _ARCH_PPC
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-long double _Complex 
+COMPILER_RT_ABI long double _Complex
 __divtc3(long double __a, long double __b, long double __c, long double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(long double _Complex x)
 {
     if (x == 0)

compiler-rt/trunk/test/builtins/Unit/divtf3_test.c

 //===--------------- divtf3_test.c - Test __divtf3 ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __divtf3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: a / b
-long double __divtf3(long double a, long double b);
+COMPILER_RT_ABI long double __divtf3(long double a, long double b);
 
 int test__divtf3(long double a, long double b,
                  uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __divtf3(a, b);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){

compiler-rt/trunk/test/builtins/Unit/divti3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a / b
 
-ti_int __divti3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __divti3(ti_int a, ti_int b);
 
 int test__divti3(ti_int a, ti_int b, ti_int expected)
 {
     ti_int x = __divti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/divxc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-long double _Complex 
+COMPILER_RT_ABI long double _Complex
 __divxc3(long double __a, long double __b, long double __c, long double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(long double _Complex x)
 {
     if (x == 0)

compiler-rt/trunk/test/builtins/Unit/extebdsfdf2vfp_test.c

 //===-- extendsfdf2vfp_test.c - Test __extendsfdf2vfp ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __extendsfdf2vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern double __extendsfdf2vfp(float a);
+extern COMPILER_RT_ABI double __extendsfdf2vfp(float a);
 
 #if __arm__
 int test__extendsfdf2vfp(float a)
 {
     double actual = __extendsfdf2vfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__extendsfdf2vfp(%f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/extenddftf2_test.c

 //===--------------- extenddftf2_test.c - Test __extenddftf2 --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __extenddftf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-long double __extenddftf2(double a);
+COMPILER_RT_ABI long double __extenddftf2(double a);
 
 int test__extenddftf2(double a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __extenddftf2(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){
         printf("error in test__extenddftf2(%f) = %.20Lf, "

compiler-rt/trunk/test/builtins/Unit/extendsftf2_test.c

 //===--------------- extendsftf2_test.c - Test __extendsftf2 --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __extendsftf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-long double __extendsftf2(float a);
+COMPILER_RT_ABI long double __extendsftf2(float a);
 
 int test__extendsftf2(float a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __extendsftf2(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret)
     {

compiler-rt/trunk/test/builtins/Unit/ffsdi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the index of the least significant 1-bit in a, or
 // the value zero if a is zero. The least significant bit is index one.
 
-si_int __ffsdi2(di_int a);
+COMPILER_RT_ABI si_int __ffsdi2(di_int a);
 
 int test__ffsdi2(di_int a, si_int expected)
 {
     si_int x = __ffsdi2(a);
     if (x != expected)
         printf("error in __ffsdi2(0x%llX) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/ffsti2_test.c

 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the index of the least significant 1-bit in a, or
 // the value zero if a is zero. The least significant bit is index one.
 
-si_int __ffsti2(ti_int a);
+COMPILER_RT_ABI si_int __ffsti2(ti_int a);
 
 int test__ffsti2(ti_int a, si_int expected)
 {
     si_int x = __ffsti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/fixdfdi_test.c

 // Returns: convert a to a signed long long, rounding toward zero.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in double is representable in di_int (no range checking performed)
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-di_int __fixdfdi(double a);
+COMPILER_RT_ABI di_int __fixdfdi(double a);
 
 int test__fixdfdi(double a, di_int expected)
 {
     di_int x = __fixdfdi(a);
     if (x != expected)
         printf("error in __fixdfdi(%A) = %llX, expected %llX\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixdfti_test.c

 // Returns: convert a to a signed long long, rounding toward zero.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in double is representable in ti_int (no range checking performed)
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-ti_int __fixdfti(double a);
+COMPILER_RT_ABI ti_int __fixdfti(double a);
 
 int test__fixdfti(double a, ti_int expected)
 {
     ti_int x = __fixdfti(a);
     if (x != expected)
     {
         twords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/fixsfdi_test.c

 // Returns: convert a to a signed long long, rounding toward zero.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in float is representable in di_int (no range checking performed)
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-di_int __fixsfdi(float a);
+COMPILER_RT_ABI di_int __fixsfdi(float a);
 
 int test__fixsfdi(float a, di_int expected)
 {
     di_int x = __fixsfdi(a);
     if (x != expected)
         printf("error in __fixsfdi(%A) = %llX, expected %llX\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixsfti_test.c

 // Returns: convert a to a signed long long, rounding toward zero.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in float is representable in ti_int (no range checking performed)
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-ti_int __fixsfti(float a);
+COMPILER_RT_ABI ti_int __fixsfti(float a);
 
 int test__fixsfti(float a, ti_int expected)
 {
     ti_int x = __fixsfti(a);
     if (x != expected)
     {
         twords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/fixunsdfdi_test.c

 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             du_int is a 64 bit integral type
 //             value in double is representable in du_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-du_int __fixunsdfdi(double a);
+COMPILER_RT_ABI du_int __fixunsdfdi(double a);
 
 int test__fixunsdfdi(double a, du_int expected)
 {
     du_int x = __fixunsdfdi(a);
     if (x != expected)
         printf("error in __fixunsdfdi(%A) = %llX, expected %llX\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixunsdfsi_test.c

 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in double is representable in su_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-su_int __fixunsdfsi(double a);
+COMPILER_RT_ABI su_int __fixunsdfsi(double a);
 
 int test__fixunsdfsi(double a, su_int expected)
 {
     su_int x = __fixunsdfsi(a);
     if (x != expected)
         printf("error in __fixunsdfsi(%A) = %X, expected %X\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixunsdfsivfp_test.c

 //===-- fixunsdfsivfp_test.c - Test __fixunsdfsivfp -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __fixunsdfsivfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern unsigned int __fixunsdfsivfp(double a);
+extern COMPILER_RT_ABI unsigned int __fixunsdfsivfp(double a);
 
 #if __arm__
 int test__fixunsdfsivfp(double a)
 {
     unsigned int actual = __fixunsdfsivfp(a);
     unsigned int expected = a;
     if (actual != expected)
         printf("error in test__fixunsdfsivfp(%f) = %u, expected %u\n",

compiler-rt/trunk/test/builtins/Unit/fixunsdfti_test.c

 //             tu_int is a 64 bit integral type
 //             value in double is representable in tu_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
 #ifdef CRT_HAS_128BIT
 
-tu_int __fixunsdfti(double a);
+COMPILER_RT_ABI tu_int __fixunsdfti(double a);
 
 int test__fixunsdfti(double a, tu_int expected)
 {
     tu_int x = __fixunsdfti(a);
     if (x != expected)
     {
         utwords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/fixunssfdi_test.c

 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             du_int is a 64 bit integral type
 //             value in float is representable in du_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-du_int __fixunssfdi(float a);
+COMPILER_RT_ABI du_int __fixunssfdi(float a);
 
 int test__fixunssfdi(float a, du_int expected)
 {
     du_int x = __fixunssfdi(a);
     if (x != expected)
         printf("error in __fixunssfdi(%A) = %llX, expected %llX\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/fixunssfsi_test.c

 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             su_int is a 32 bit integral type
 //             value in float is representable in su_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-su_int __fixunssfsi(float a);
+COMPILER_RT_ABI su_int __fixunssfsi(float a);
 
 int test__fixunssfsi(float a, su_int expected)
 {
     su_int x = __fixunssfsi(a);
     if (x != expected)
         printf("error in __fixunssfsi(%A) = %X, expected %X\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixunssfti_test.c

 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             tu_int is a 64 bit integral type
 //             value in float is representable in tu_int or is negative 
 //                 (no range checking performed)
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-tu_int __fixunssfti(float a);
+COMPILER_RT_ABI tu_int __fixunssfti(float a);
 
 int test__fixunssfti(float a, tu_int expected)
 {
     tu_int x = __fixunssfti(a);
     if (x != expected)
     {
         utwords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/fixunstfdi_test.c

 // Returns: convert a to a unsigned long long, rounding toward zero.
 //          Negative values all become zero.
 
 // Assumption: long double is a ppc 128 bit floating point type
 //             du_int is a 64 bit integral type
 //             value in long double is representable in du_int or is negative 
 //                 (no range checking performed)
 
-du_int __fixunstfdi(long double a);
+COMPILER_RT_ABI du_int __fixunstfdi(long double a);
 
 int test__fixunstfdi(long double a, du_int expected)
 {
     du_int x = __fixunstfdi(a);
     if (x != expected)
         printf("error in __fixunstfdi(%LA) = %llX, expected %llX\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/fixunsxfdi_test.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             du_int is a 64 bit integral type
 //             value in long double is representable in du_int or is negative 
 //                 (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-du_int __fixunsxfdi(long double a);
+COMPILER_RT_ABI du_int __fixunsxfdi(long double a);
 
 int test__fixunsxfdi(long double a, du_int expected)
 {
     du_int x = __fixunsxfdi(a);
     if (x != expected)
         printf("error in __fixunsxfdi(%LA) = %llX, expected %llX\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/fixunsxfsi_test.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             su_int is a 32 bit integral type
 //             value in long double is representable in su_int or is negative 
 //                 (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-su_int __fixunsxfsi(long double a);
+COMPILER_RT_ABI su_int __fixunsxfsi(long double a);
 
 int test__fixunsxfsi(long double a, su_int expected)
 {
     su_int x = __fixunsxfsi(a);
     if (x != expected)
         printf("error in __fixunsxfsi(%LA) = %X, expected %X\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/fixunsxfti_test.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             tu_int is a 64 bit integral type
 //             value in long double is representable in tu_int or is negative 
 //                 (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-tu_int __fixunsxfti(long double a);
+COMPILER_RT_ABI tu_int __fixunsxfti(long double a);
 
 int test__fixunsxfti(long double a, tu_int expected)
 {
     tu_int x = __fixunsxfti(a);
     if (x != expected)
     {
         utwords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/fixxfdi_test.c

 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             su_int is a 32 bit integral type
 //             value in long double is representable in di_int (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-di_int __fixxfdi(long double a);
+COMPILER_RT_ABI di_int __sfixxfdi(long double a);
 
 int test__fixxfdi(long double a, di_int expected)
 {
     di_int x = __fixxfdi(a);
     if (x != expected)
         printf("error in __fixxfdi(%LA) = %llX, expected %llX\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/fixxfti_test.c

 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             su_int is a 32 bit integral type
 //             value in long double is representable in ti_int (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-ti_int __fixxfti(long double a);
+COMPILER_RT_ABI ti_int __fixxfti(long double a);
 
 int test__fixxfti(long double a, ti_int expected)
 {
     ti_int x = __fixxfti(a);
     if (x != expected)
     {
         utwords xt;
         xt.all = x;

compiler-rt/trunk/test/builtins/Unit/floatdidf_test.c

 
 // Returns: convert a to a double, rounding toward even.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             di_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-double __floatdidf(di_int a);
+COMPILER_RT_ABI double __floatdidf(di_int a);
 
 int test__floatdidf(di_int a, double expected)
 {
     double x = __floatdidf(a);
     if (x != expected)
         printf("error in __floatdidf(%llX) = %a, expected %a\n", a, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/floatdisf_test.c

 
 // Returns: convert a to a float, rounding toward even.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             di_int is a 64 bit integral type
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-float __floatdisf(di_int a);
+COMPILER_RT_ABI float __floatdisf(di_int a);
 
 int test__floatdisf(di_int a, float expected)
 {
     float x = __floatdisf(a);
     if (x != expected)
         printf("error in __floatdisf(%llX) = %a, expected %a\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/floatdixf_test.c

 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             di_int is a 64 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-long double __floatdixf(di_int a);
+long COMPILER_RT_ABI double __floatdixf(di_int a);
 
 int test__floatdixf(di_int a, long double expected)
 {
     long double x = __floatdixf(a);
     if (x != expected)
         printf("error in __floatdixf(%llX) = %LA, expected %LA\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/floatsidfvfp_test.c

 //===-- floatsidfvfp_test.c - Test __floatsidfvfp -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatsidfvfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern double __floatsidfvfp(int a);
+extern COMPILER_RT_ABI double __floatsidfvfp(int a);
 
 #if __arm__
 int test__floatsidfvfp(int a)
 {
     double actual = __floatsidfvfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__ floatsidfvfp(%d) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/floatsisfvfp_test.c

 //===-- floatsisfvfp_test.c - Test __floatsisfvfp -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatsisfvfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __floatsisfvfp(int a);
+extern COMPILER_RT_ABI float __floatsisfvfp(int a);
 
 #if __arm__
 int test__floatsisfvfp(int a)
 {
     float actual = __floatsisfvfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__floatsisfvfp(%d) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/floatsitf_test.c

 //===--------------- floatsitf_test.c - Test __floatsitf ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatsitf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-long double __floatsitf(int a);
+long COMPILER_RT_ABI double __floatsitf(int a);
 
 int test__floatsitf(int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatsitf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret)
     {

compiler-rt/trunk/test/builtins/Unit/floattidf_test.c

 
 // Returns: convert a to a double, rounding toward even.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             ti_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-double __floattidf(ti_int a);
+COMPILER_RT_ABI double __floattidf(ti_int a);
 
 int test__floattidf(ti_int a, double expected)
 {
     double x = __floattidf(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/floattisf_test.c

 
 // Returns: convert a to a float, rounding toward even.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             ti_int is a 64 bit integral type
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-float __floattisf(ti_int a);
+COMPILER_RT_ABI float __floattisf(ti_int a);
 
 int test__floattisf(ti_int a, float expected)
 {
     float x = __floattisf(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/floattixf_test.c

 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             ti_int is a 128 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-long double __floattixf(ti_int a);
+COMPILER_RT_ABI long double __floattixf(ti_int a);
 
 int test__floattixf(ti_int a, long double expected)
 {
     long double x = __floattixf(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/floatundidf_test.c

 
 // Returns: convert a to a double, rounding toward even.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             du_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-double __floatundidf(du_int a);
+COMPILER_RT_ABI double __floatundidf(du_int a);
 
 int test__floatundidf(di_int a, double expected)
 {
     double x = __floatundidf(a);
     if (x != expected)
         printf("error in __floatundidf(%llX) = %a, expected %a\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/floatundisf_test.c

 
 // Returns: convert a to a float, rounding toward even.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             du_int is a 64 bit integral type
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-float __floatundisf(du_int a);
+COMPILER_RT_ABI float __floatundisf(du_int a);
 
 int test__floatundisf(du_int a, float expected)
 {
     float x = __floatundisf(a);
     if (x != expected)
         printf("error in __floatundisf(%llX) = %a, expected %a\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/floatundixf_test.c

 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             du_int is a 64 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-long double __floatundixf(du_int a);
+COMPILER_RT_ABI long double __floatundixf(du_int a);
 
 int test__floatundixf(du_int a, long double expected)
 {
     long double x = __floatundixf(a);
     if (x != expected)
         printf("error in __floatundixf(%llX) = %LA, expected %LA\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/floatunsitf_test.c

 //===--------------- floatunsitf_test.c - Test __floatunsitf --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatunsitf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-long double __floatunsitf(unsigned int a);
+COMPILER_RT_ABI long double __floatunsitf(unsigned int a);
 
 int test__floatunsitf(unsigned int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatunsitf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){
         printf("error in test__floatunsitf(%u) = %.20Lf, "

compiler-rt/trunk/test/builtins/Unit/floatunssidfvfp_test.c

 //===-- floatunssidfvfp_test.c - Test __floatunssidfvfp -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatunssidfvfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern double __floatunssidfvfp(unsigned int a);
+extern COMPILER_RT_ABI double __floatunssidfvfp(unsigned int a);
 
 #if __arm__
 int test__floatunssidfvfp(unsigned int a)
 {
     double actual = __floatunssidfvfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__floatunssidfvfp(%u) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/floatunssisfvfp_test.c

 //===-- floatunssisfvfp_test.c - Test __floatunssisfvfp -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __floatunssisfvfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
+#include "int_lib.h"
 
-
-extern float __floatunssisfvfp(unsigned int a);
+extern COMPILER_RT_ABI float __floatunssisfvfp(unsigned int a);
 
 #if __arm__
 int test__floatunssisfvfp(unsigned int a)
 {
     float actual = __floatunssisfvfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__floatunssisfvfp(%u) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/floatuntidf_test.c

 
 // Returns: convert a to a double, rounding toward even.
 
 // Assumption: double is a IEEE 64 bit floating point type 
 //             tu_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-double __floatuntidf(tu_int a);
+COMPILER_RT_ABI double __floatuntidf(tu_int a);
 
 int test__floatuntidf(tu_int a, double expected)
 {
     double x = __floatuntidf(a);
     if (x != expected)
     {
         utwords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/floatuntisf_test.c

 
 // Returns: convert a to a float, rounding toward even.
 
 // Assumption: float is a IEEE 32 bit floating point type 
 //             tu_int is a 128 bit integral type
 
 // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
 
-float __floatuntisf(tu_int a);
+COMPILER_RT_ABI float __floatuntisf(tu_int a);
 
 int test__floatuntisf(tu_int a, float expected)
 {
     float x = __floatuntisf(a);
     if (x != expected)
     {
         utwords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/floatuntixf_test.c

 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             tu_int is a 128 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 
-long double __floatuntixf(tu_int a);
+COMPILER_RT_ABI long double __floatuntixf(tu_int a);
 
 int test__floatuntixf(tu_int a, long double expected)
 {
     long double x = __floatuntixf(a);
     if (x != expected)
     {
         utwords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/lshrdi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: logical a >> b
 
 // Precondition:  0 <= b < bits_in_dword
 
-di_int __lshrdi3(di_int a, si_int b);
+COMPILER_RT_ABI di_int __lshrdi3(di_int a, si_int b);
 
 int test__lshrdi3(di_int a, si_int b, di_int expected)
 {
     di_int x = __lshrdi3(a, b);
     if (x != expected)
         printf("error in __lshrdi3: %llX >> %d = %llX, expected %llX\n",
                a, b, __lshrdi3(a, b), expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/lshrti3_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: logical a >> b
 
 // Precondition:  0 <= b < bits_in_dword
 
-ti_int __lshrti3(ti_int a, si_int b);
+COMPILER_RT_ABI ti_int __lshrti3(ti_int a, si_int b);
 
 int test__lshrti3(ti_int a, si_int b, ti_int expected)
 {
     ti_int x = __lshrti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/moddi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a % b
 
-di_int __moddi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __moddi3(di_int a, di_int b);
 
 int test__moddi3(di_int a, di_int b, di_int expected)
 {
     di_int x = __moddi3(a, b);
     if (x != expected)
         printf("error in __moddi3: %lld %% %lld = %lld, expected %lld\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/modsi3_test.c

  * ===----------------------------------------------------------------------===
  */
 
 #include "int_lib.h"
 #include <stdio.h>
 
 /* Returns: a % b */
 
-si_int __modsi3(si_int a, si_int b);
+COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b);
 
 int test__modsi3(si_int a, si_int b, si_int expected) {
     si_int x = __modsi3(a, b);
     if (x != expected)
         fprintf(stderr, "error in __modsi3: %d %% %d = %d, expected %d\n",
                a, b, x, expected);
     return x != expected;
 }

compiler-rt/trunk/test/builtins/Unit/modti3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a % b
 
-ti_int __modti3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __modti3(ti_int a, ti_int b);
 
 int test__modti3(ti_int a, ti_int b, ti_int expected)
 {
     ti_int x = __modti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/muldc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the product of a + ib and c + id
 
-double _Complex __muldc3(double __a, double __b, double __c, double __d);
+COMPILER_RT_ABI double _Complex
+__muldc3(double __a, double __b, double __c, double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(double _Complex x)
 {
     if (x == 0)
         return zero;

compiler-rt/trunk/test/builtins/Unit/muldf3vfp_test.c

 //===-- muldf3vfp_test.c - Test __muldf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __muldf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 #if __arm__
-extern double __muldf3vfp(double a, double b);
+extern COMPILER_RT_ABI double __muldf3vfp(double a, double b);
 
 int test__muldf3vfp(double a, double b)
 {
     double actual = __muldf3vfp(a, b);
     double expected = a * b;
     if (actual != expected)
         printf("error in test__muldf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);

compiler-rt/trunk/test/builtins/Unit/muldi3_test.c

 //===-- muldi3_test.c - Test __muldi3 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __muldi3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
-di_int __muldi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __muldi3(di_int a, di_int b);
 
 int test__muldi3(di_int a, di_int b, di_int expected)
 {
     di_int x = __muldi3(a, b);
     if (x != expected)
         printf("error in __muldi3: %lld * %lld = %lld, expected %lld\n",
                a, b, __muldi3(a, b), expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/mulodi4_test.c

 //===-- mulodi4_test.c - Test __mulodi4 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __mulodi4 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
-extern di_int __mulodi4(di_int a, di_int b, int* overflow);
+extern COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int* overflow);
 
 int test__mulodi4(di_int a, di_int b, di_int expected, int expected_overflow)
 {
     int ov;
     di_int x = __mulodi4(a, b, &ov);
     if (ov != expected_overflow)
       printf("error in __mulodi4: overflow=%d expected=%d\n",
        ov, expected_overflow);

compiler-rt/trunk/test/builtins/Unit/mulosi4_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a * b
 
 // Effects: aborts if a * b overflows
 
-si_int __mulosi4(si_int a, si_int b, int *overflow);
+COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow);
 
 int test__mulosi4(si_int a, si_int b, si_int expected, int expected_overflow)
 {
   int ov;
   si_int x = __mulosi4(a, b, &ov);
   if (ov != expected_overflow)
     printf("error in __mulosi4: overflow=%d expected=%d\n",
      ov, expected_overflow);

compiler-rt/trunk/test/builtins/Unit/muloti4_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a * b
 
 // Effects: sets overflow if a * b overflows
 
-ti_int __muloti4(ti_int a, ti_int b, int *overflow);
+COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow);
 
 int test__muloti4(ti_int a, ti_int b, ti_int expected, int expected_overflow)
 {
     int ov;
     ti_int x = __muloti4(a, b, &ov);
     if (ov != expected_overflow) {
       twords at;
       at.all = a;

compiler-rt/trunk/test/builtins/Unit/mulsc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the product of a + ib and c + id
 
-float _Complex __mulsc3(float __a, float __b, float __c, float __d);
+COMPILER_RT_ABI float _Complex
+__mulsc3(float __a, float __b, float __c, float __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(float _Complex x)
 {
     if (x == 0)
         return zero;

compiler-rt/trunk/test/builtins/Unit/mulsf3vfp_test.c

 //===-- mulsf3vfp_test.c - Test __mulsf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __mulsf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __mulsf3vfp(float a, float b);
+extern COMPILER_RT_ABI float __mulsf3vfp(float a, float b);
 
 #if __arm__
 int test__mulsf3vfp(float a, float b)
 {
     float actual = __mulsf3vfp(a, b);
     float expected = a * b;
     if (actual != expected)
         printf("error in test__mulsf3vfp(%f, %f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/multc3_test.c

 #if _ARCH_PPC
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 
 // Returns: the product of a + ib and c + id
 
-long double _Complex
+COMPILER_RT_ABI long double _Complex
 __multc3(long double __a, long double __b, long double __c, long double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(long double _Complex x)
 {
     if (x == 0)

compiler-rt/trunk/test/builtins/Unit/multf3_test.c

 
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: a * b
-long double __multf3(long double a, long double b);
+COMPILER_RT_ABI long double __multf3(long double a, long double b);
 
 int test__multf3(long double a, long double b,
                  uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __multf3(a, b);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){

compiler-rt/trunk/test/builtins/Unit/multi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
-ti_int __multi3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __multi3(ti_int a, ti_int b);
 
 int test__multi3(ti_int a, ti_int b, ti_int expected)
 {
     ti_int x = __multi3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/mulvdi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a * b
 
 // Effects: aborts if a * b overflows
 
-di_int __mulvdi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __mulvdi3(di_int a, di_int b);
 
 int test__mulvdi3(di_int a, di_int b, di_int expected)
 {
     di_int x = __mulvdi3(a, b);
     if (x != expected)
         printf("error in __mulvdi3: %lld * %lld = %lld, expected %lld\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/mulvsi3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a * b
 
 // Effects: aborts if a * b overflows
 
-si_int __mulvsi3(si_int a, si_int b);
+COMPILER_RT_ABI si_int __mulvsi3(si_int a, si_int b);
 
 int test__mulvsi3(si_int a, si_int b, si_int expected)
 {
     si_int x = __mulvsi3(a, b);
     if (x != expected)
         printf("error in __mulvsi3: %d * %d = %d, expected %d\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/mulvti3_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a * b
 
 // Effects: aborts if a * b overflows
 
-ti_int __mulvti3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __mulvti3(ti_int a, ti_int b);
 
 int test__mulvti3(ti_int a, ti_int b, ti_int expected)
 {
     ti_int x = __mulvti3(a, b);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/mulxc3_test.c

 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // Returns: the product of a + ib and c + id
 
-long double _Complex
+COMPILER_RT_ABI long double _Complex
 __mulxc3(long double __a, long double __b, long double __c, long double __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 int
 classify(long double _Complex x)
 {
     if (x == 0)

compiler-rt/trunk/test/builtins/Unit/negdf2vfp_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern double __negdf2vfp(double a);
+extern COMPILER_RT_ABI double __negdf2vfp(double a);
 
 #if __arm__
 int test__negdf2vfp(double a)
 {
     double actual = __negdf2vfp(a);
     double expected = -a;
     if (actual != expected)
         printf("error in test__negdf2vfp(%f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/negdi2_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: -a
 
-di_int __negdi2(di_int a);
+COMPILER_RT_ABI di_int __negdi2(di_int a);
 
 int test__negdi2(di_int a, di_int expected)
 {
     di_int x = __negdi2(a);
     if (x != expected)
         printf("error in __negdi2: -0x%llX = 0x%llX, expected 0x%llX\n",
                a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/negsf2vfp_test.c

 //===-- negsf2vfp_test.c - Test __negsf2vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __negsf2vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __negsf2vfp(float a);
+extern COMPILER_RT_ABI float __negsf2vfp(float a);
 
 #if __arm__
 int test__negsf2vfp(float a)
 {
     float actual = __negsf2vfp(a);
     float expected = -a;
     if (actual != expected)
         printf("error in test__negsf2vfp(%f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/negti2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: -a
 
-ti_int __negti2(ti_int a);
+COMPILER_RT_ABI ti_int __negti2(ti_int a);
 
 int test__negti2(ti_int a, ti_int expected)
 {
     ti_int x = __negti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/negvdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
-di_int __negvdi2(di_int a);
+COMPILER_RT_ABI di_int __negvdi2(di_int a);
 
 int test__negvdi2(di_int a)
 {
     di_int x = __negvdi2(a);
     di_int expected = -a;
     if (x != expected)
         printf("error in __negvdi2(0x%llX) = %lld, expected %lld\n",
                a, x, expected);

compiler-rt/trunk/test/builtins/Unit/negvsi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
-si_int __negvsi2(si_int a);
+COMPILER_RT_ABI si_int __negvsi2(si_int a);
 
 int test__negvsi2(si_int a)
 {
     si_int x = __negvsi2(a);
     si_int expected = -a;
     if (x != expected)
         printf("error in __negvsi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/negvti2_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
-ti_int __negvti2(ti_int a);
-ti_int __negti2(ti_int a);
+COMPILER_RT_ABI ti_int __negvti2(ti_int a);
+COMPILER_RT_ABI ti_int __negti2(ti_int a);
 
 int test__negvti2(ti_int a)
 {
     ti_int x = __negvti2(a);
     ti_int expected = __negti2(a);
     if (x != expected)
     {
         twords at;

compiler-rt/trunk/test/builtins/Unit/paritydi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: 1 if number of bits is odd else returns 0
 
-si_int __paritydi2(di_int a);
+COMPILER_RT_ABI si_int __paritydi2(di_int a);
 
 int naive_parity(di_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

compiler-rt/trunk/test/builtins/Unit/paritysi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: 1 if number of bits is odd else returns 0
 
-si_int __paritysi2(si_int a);
+COMPILER_RT_ABI si_int __paritysi2(si_int a);
 
 int naive_parity(si_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

compiler-rt/trunk/test/builtins/Unit/parityti2_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: 1 if number of bits is odd else returns 0
 
-si_int __parityti2(ti_int a);
+COMPILER_RT_ABI si_int __parityti2(ti_int a);
 
 int naive_parity(ti_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

compiler-rt/trunk/test/builtins/Unit/popcountdi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: count of 1 bits
 
-si_int __popcountdi2(di_int a);
+COMPILER_RT_ABI si_int __popcountdi2(di_int a);
 
 int naive_popcount(di_int a)
 {
     int r = 0;
     for (; a; a = (du_int)a >> 1)
         r += a & 1;
     return r;
 }

compiler-rt/trunk/test/builtins/Unit/popcountsi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: count of 1 bits
 
-si_int __popcountsi2(si_int a);
+COMPILER_RT_ABI si_int __popcountsi2(si_int a);
 
 int naive_popcount(si_int a)
 {
     int r = 0;
     for (; a; a = (su_int)a >> 1)
         r += a & 1;
     return r;
 }

compiler-rt/trunk/test/builtins/Unit/popcountti2_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: count of 1 bits
 
-si_int __popcountti2(ti_int a);
+COMPILER_RT_ABI si_int __popcountti2(ti_int a);
 
 int naive_popcount(ti_int a)
 {
     int r = 0;
     for (; a; a = (tu_int)a >> 1)
         r += a & 1;
     return r;
 }

compiler-rt/trunk/test/builtins/Unit/powidf2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-double __powidf2(double a, si_int b);
+COMPILER_RT_ABI double __powidf2(double a, si_int b);
 
 int test__powidf2(double a, si_int b, double expected)
 {
     double x = __powidf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powidf2(%f, %d) = %f, expected %f\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/powisf2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-float __powisf2(float a, si_int b);
+COMPILER_RT_ABI float __powisf2(float a, si_int b);
 
 int test__powisf2(float a, si_int b, float expected)
 {
     float x = __powisf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powisf2(%f, %d) = %f, expected %f\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/powitf2_test.c

 
 #if _ARCH_PPC
 
 #include "int_lib.h"
 #include <math.h>
 
 // Returns: a ^ b
 
-long double __powitf2(long double a, si_int b);
+COMPILER_RT_ABI long double __powitf2(long double a, si_int b);
 
 int test__powitf2(long double a, si_int b, long double expected)
 {
     long double x = __powitf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powitf2(%Lf, %d) = %Lf, expected %Lf\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/powixf2_test.c

 #if !_ARCH_PPC
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-long double __powixf2(long double a, si_int b);
+COMPILER_RT_ABI long double __powixf2(long double a, si_int b);
 
 int test__powixf2(long double a, si_int b, long double expected)
 {
     long double x = __powixf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/ppc/floatditf_test.c

 #include <stdint.h>
 #include <stdio.h>
 
-long double __floatditf(int64_t);
+COMPILER_RT_ABI long double __floatditf(int64_t);
 
 #include "floatunditf_test.h"
 #include "DD.h"
 
 int main(int argc, char *argv[]) {
   int i;
   
   DD expected;

compiler-rt/trunk/test/builtins/Unit/ppc/floatunditf_test.c

 #include <stdint.h>
 #include <stdio.h>
 
-long double __floatunditf(uint64_t);
+COMPILER_RT_ABI long double __floatunditf(uint64_t);
 
 #include "floatunditf_test.h"
 #include "DD.h"
 
 int main(int argc, char *argv[]) {
   int i;
   
   DD expected;

compiler-rt/trunk/test/builtins/Unit/subdf3vfp_test.c

 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 #if __arm__
-extern double __subdf3vfp(double a, double b);
+extern COMPILER_RT_ABI double __subdf3vfp(double a, double b);
 
 int test__subdf3vfp(double a, double b)
 {
     double actual = __subdf3vfp(a, b);
     double expected = a - b;
     if (actual != expected)
         printf("error in test__subdf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);

compiler-rt/trunk/test/builtins/Unit/subsf3vfp_test.c

 //===-- subsf3vfp_test.c - Test __subsf3vfp -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __subsf3vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __subsf3vfp(float a, float b);
+extern COMPILER_RT_ABI float __subsf3vfp(float a, float b);
 
 #if __arm__
 int test__subsf3vfp(float a, float b)
 {
     float actual = __subsf3vfp(a, b);
     float expected = a - b;
     if (actual != expected)
         printf("error in test__subsf3vfp(%f, %f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/subtf3_test.c

 
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: a - b
-long double __subtf3(long double a, long double b);
+COMPILER_RT_ABI long double __subtf3(long double a, long double b);
 
 int test__subtf3(long double a, long double b,
                  uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __subtf3(a, b);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){

compiler-rt/trunk/test/builtins/Unit/subvdi3_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: a - b
 
 // Effects: aborts if a - b overflows
 
-di_int __subvdi3(di_int a, di_int b);
+COMPILER_RT_ABI di_int __subvdi3(di_int a, di_int b);
 
 int test__subvdi3(di_int a, di_int b)
 {
     di_int x = __subvdi3(a, b);
     di_int expected = a - b;
     if (x != expected)
         printf("error in test__subvsi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/subvsi3_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: a - b
 
 // Effects: aborts if a - b overflows
 
-si_int __subvsi3(si_int a, si_int b);
+COMPILER_RT_ABI si_int __subvsi3(si_int a, si_int b);
 
 int test__subvsi3(si_int a, si_int b)
 {
     si_int x = __subvsi3(a, b);
     si_int expected = a - b;
     if (x != expected)
         printf("error in test__subvsi3(0x%X, 0x%X) = %d, expected %d\n",
                a, b, x, expected);

compiler-rt/trunk/test/builtins/Unit/subvti3_test.c

 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a - b
 
 // Effects: aborts if a - b overflows
 
-ti_int __subvti3(ti_int a, ti_int b);
+COMPILER_RT_ABI ti_int __subvti3(ti_int a, ti_int b);
 
 int test__subvti3(ti_int a, ti_int b)
 {
     ti_int x = __subvti3(a, b);
     ti_int expected = a - b;
     if (x != expected)
     {
         twords at;

compiler-rt/trunk/test/builtins/Unit/truncdfsf2vfp_test.c

 //===-- truncdfsf2vfp_test.c - Test __truncdfsf2vfp -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __truncdfsf2vfp for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-extern float __truncdfsf2vfp(double a);
+extern COMPILER_RT_ABI float __truncdfsf2vfp(double a);
 
 #if __arm__
 int test__truncdfsf2vfp(double a)
 {
     float actual = __truncdfsf2vfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n",

compiler-rt/trunk/test/builtins/Unit/trunctfdf2_test.c

 //===-------------- trunctfdf2_test.c - Test __trunctfdf2 -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __trunctfdf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-double __trunctfdf2(long double a);
+COMPILER_RT_ABI double __trunctfdf2(long double a);
 
 int test__trunctfdf2(long double a, uint64_t expected)
 {
     double x = __trunctfdf2(a);
     int ret = compareResultD(x, expected);
 
     if (ret)
     {

compiler-rt/trunk/test/builtins/Unit/trunctfsf2_test.c

 //===--------------- trunctfsf2_test.c - Test __trunctfsf2 ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __trunctfsf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-float __trunctfsf2(long double a);
+COMPILER_RT_ABI float __trunctfsf2(long double a);
 
 int test__trunctfsf2(long double a, uint32_t expected)
 {
     float x = __trunctfsf2(a);
     int ret = compareResultF(x, expected);
 
     if (ret){
         printf("error in test__trunctfsf2(%.20Lf) = %f, "

compiler-rt/trunk/test/builtins/Unit/ucmpdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns:  if (a <  b) returns 0
 //           if (a == b) returns 1
 //           if (a >  b) returns 2
 
-si_int __ucmpdi2(du_int a, du_int b);
+COMPILER_RT_ABI si_int __ucmpdi2(du_int a, du_int b);
 
 int test__ucmpdi2(du_int a, du_int b, si_int expected)
 {
     si_int x = __ucmpdi2(a, b);
     if (x != expected)
         printf("error in __ucmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
                a, b, x, expected);
     return x != expected;

compiler-rt/trunk/test/builtins/Unit/ucmpti2_test.c

 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns:  if (a <  b) returns 0
 //           if (a == b) returns 1
 //           if (a >  b) returns 2
 
-si_int __ucmpti2(tu_int a, tu_int b);
+COMPILER_RT_ABI si_int __ucmpti2(tu_int a, tu_int b);
 
 int test__ucmpti2(tu_int a, tu_int b, si_int expected)
 {
     si_int x = __ucmpti2(a, b);
     if (x != expected)
     {
         utwords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/udivdi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-du_int __udivdi3(du_int a, du_int b);
+COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b);
 
 int test__udivdi3(du_int a, du_int b, du_int expected_q)
 {
     du_int q = __udivdi3(a, b);
     if (q != expected_q)
         printf("error in __udivdi3: %lld / %lld = %lld, expected %lld\n",
                a, b, q, expected_q);
     return q != expected_q;

compiler-rt/trunk/test/builtins/Unit/udivmoddi4_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Effects: if rem != 0, *rem = a % b
 // Returns: a / b
 
-du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
 
 int test__udivmoddi4(du_int a, du_int b, du_int expected_q, du_int expected_r)
 {
     du_int r;
     du_int q = __udivmoddi4(a, b, &r);
     if (q != expected_q || r != expected_r)
         printf("error in __udivmoddi4: %llX / %llX = %llX, R = %llX, expected %llX, %llX\n",
                a, b, q, r, expected_q, expected_r);

compiler-rt/trunk/test/builtins/Unit/udivmodsi4_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-extern su_int __udivmodsi4(su_int a, su_int b, su_int* rem);
+extern COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem);
 
 int test__udivmodsi4(su_int a, su_int b, 
             su_int expected_result, su_int expected_rem)
 {
   su_int rem;
     su_int result = __udivmodsi4(a, b, &rem);
     if (result != expected_result) {
         printf("error in __udivmodsi4: %u / %u = %u, expected %u\n",

compiler-rt/trunk/test/builtins/Unit/udivmodti4_test.c

 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Effects: if rem != 0, *rem = a % b
 // Returns: a / b
 
-tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
 
 int test__udivmodti4(tu_int a, tu_int b, tu_int expected_q, tu_int expected_r)
 {
     tu_int r;
     tu_int q = __udivmodti4(a, b, &r);
     if (q != expected_q || r != expected_r)
     {
         utwords at;

compiler-rt/trunk/test/builtins/Unit/udivsi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a / b
 
-su_int __udivsi3(su_int a, su_int b);
+COMPILER_RT_ABI su_int __udivsi3(su_int a, su_int b);
 
 int test__udivsi3(su_int a, su_int b, su_int expected_q)
 {
     su_int q = __udivsi3(a, b);
     if (q != expected_q)
         printf("error in __udivsi3: %X / %X = %X, expected %X\n",
                a, b, q, expected_q);
     return q != expected_q;

compiler-rt/trunk/test/builtins/Unit/udivti3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a / b
 
-tu_int __udivti3(tu_int a, tu_int b);
+COMPILER_RT_ABI tu_int __udivti3(tu_int a, tu_int b);
 
 int test__udivti3(tu_int a, tu_int b, tu_int expected_q)
 {
     tu_int q = __udivti3(a, b);
     if (q != expected_q)
     {
         utwords at;
         at.all = a;

compiler-rt/trunk/test/builtins/Unit/umoddi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a % b
 
-du_int __umoddi3(du_int a, du_int b);
+COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b);
 
 int test__umoddi3(du_int a, du_int b, du_int expected_r)
 {
     du_int r = __umoddi3(a, b);
     if (r != expected_r)
         printf("error in __umoddi3: %lld %% %lld = %lld, expected %lld\n",
                a, b, r, expected_r);
     return r != expected_r;

compiler-rt/trunk/test/builtins/Unit/umodsi3_test.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: a % b
 
-su_int __umodsi3(su_int a, su_int b);
+COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b);
 
 int test__umodsi3(su_int a, su_int b, su_int expected_r)
 {
     su_int r = __umodsi3(a, b);
     if (r != expected_r)
         printf("error in __umodsi3: %X %% %X = %X, expected %X\n",
                a, b, r, expected_r);
     return r != expected_r;

compiler-rt/trunk/test/builtins/Unit/umodti3_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a % b
 
-tu_int __umodti3(tu_int a, tu_int b);
+COMPILER_RT_ABI tu_int __umodti3(tu_int a, tu_int b);
 
 int test__umodti3(tu_int a, tu_int b, tu_int expected_r)
 {
     tu_int r = __umodti3(a, b);
     if (r != expected_r)
     {
         utwords at;
         at.all = a;