d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Import compiler-rt r132478.

Browse Source
This commit is contained in:
Ed Schouten 2011-06-02 20:02:42 +00:00
parent f170b6928b
commit b0a04aaa59
157 changed files with 1104 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
lib/abi.h Normal file
View File

@ -0,0 +1,23 @@
/* ===------ abi.h - configuration header for compiler-rt -----------------===
*
* 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 is a configuration header for compiler-rt.
* This file is not part of the interface of this library.
*
* ===----------------------------------------------------------------------===
*/
#if __ARM_EABI__
# define ARM_EABI_FNALIAS(aeabi_name, name) \
void __aeabi_##aeabi_name() __attribute__((alias("__" #name)));
# define COMPILER_RT_ABI __attribute__((pcs("aapcs")))
#else
# define ARM_EABI_FNALIAS(aeabi_name, name)
# define COMPILER_RT_ABI
#endif

3
lib/absvdi2.c
View File

@ -11,6 +11,7 @@
*
*===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if abs(x) < 0 */
di_int
COMPILER_RT_ABI di_int
__absvdi2(di_int a)
{
const int N = (int)(sizeof(di_int) * CHAR_BIT);

5
lib/absvsi2.c
View File

@ -10,7 +10,8 @@
* This file implements __absvsi2 for the compiler_rt library.
*
* ===----------------------------------------------------------------------===
*/
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if abs(x) < 0 */
si_int
COMPILER_RT_ABI si_int
__absvsi2(si_int a)
{
const int N = (int)(sizeof(si_int) * CHAR_BIT);

18
lib/adddf3.c
View File

@ -1,4 +1,4 @@
//===-- lib/adddf3.c - Double-precision addition and subtraction --*- C -*-===//
//===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -7,15 +7,20 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements double-precision soft-float addition and subtraction
// with the IEEE-754 default rounding (to nearest, ties to even).
// This file implements double-precision soft-float addition with the IEEE-754
// default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
fp_t __adddf3(fp_t a, fp_t b) {
ARM_EABI_FNALIAS(dadd, adddf3);
COMPILER_RT_ABI fp_t
__adddf3(fp_t a, fp_t b) {
rep_t aRep = toRep(a);
rep_t bRep = toRep(b);
@ -147,8 +152,3 @@ fp_t __adddf3(fp_t a, fp_t b) {
if (roundGuardSticky == 0x4) result += result & 1;
return fromRep(result);
}
// Subtraction; flip the sign bit of b and add.
fp_t __subdf3(fp_t a, fp_t b) {
return __adddf3(a, fromRep(toRep(b) ^ signBit));
}

25
lib/addsf3.c
View File

@ -1,4 +1,4 @@
//===-- lib/addsf3.c - Single-precision addition and subtraction --*- C -*-===//
//===-- lib/addsf3.c - Single-precision addition ------------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -7,14 +7,18 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements single-precision soft-float addition and subtraction
// with the IEEE-754 default rounding (to nearest, ties to even).
// This file implements single-precision soft-float addition with the IEEE-754
// default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
ARM_EABI_FNALIAS(fadd, addsf3);
fp_t __addsf3(fp_t a, fp_t b) {
rep_t aRep = toRep(a);
@ -147,18 +151,3 @@ fp_t __addsf3(fp_t a, fp_t b) {
if (roundGuardSticky == 0x4) result += result & 1;
return fromRep(result);
}
// Subtraction; flip the sign bit of b and add.
fp_t __subsf3(fp_t a, fp_t b) {
return __addsf3(a, fromRep(toRep(b) ^ signBit));
}

3
lib/addvdi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if a + b overflows */
di_int
COMPILER_RT_ABI di_int
__addvdi3(di_int a, di_int b)
{
di_int s = a + b;

3
lib/addvsi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if a + b overflows */
si_int
COMPILER_RT_ABI si_int
__addvsi3(si_int a, si_int b)
{
si_int s = a + b;

141
lib/apple_versioning.c
View File

@ -143,6 +143,147 @@ NOT_HERE_BEFORE_10_6(__gcc_qsub)
NOT_HERE_BEFORE_10_6(__trampoline_setup)
#endif /* __ppc__ */
#if __arm__ && __DYNAMIC__
#define NOT_HERE_UNTIL_AFTER_4_3(sym) \
extern const char sym##_tmp1 __asm("$ld$hide$os3.0$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp1 = 0; \
extern const char sym##_tmp2 __asm("$ld$hide$os3.1$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp2 = 0; \
extern const char sym##_tmp3 __asm("$ld$hide$os3.2$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp3 = 0; \
extern const char sym##_tmp4 __asm("$ld$hide$os4.0$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp4 = 0; \
extern const char sym##_tmp5 __asm("$ld$hide$os4.1$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp5 = 0; \
extern const char sym##_tmp6 __asm("$ld$hide$os4.2$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp6 = 0; \
extern const char sym##_tmp7 __asm("$ld$hide$os4.3$_" #sym ); \
__attribute__((visibility("default"))) const char sym##_tmp7 = 0;
NOT_HERE_UNTIL_AFTER_4_3(__absvdi2)
NOT_HERE_UNTIL_AFTER_4_3(__absvsi2)
NOT_HERE_UNTIL_AFTER_4_3(__adddf3)
NOT_HERE_UNTIL_AFTER_4_3(__adddf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__addsf3)
NOT_HERE_UNTIL_AFTER_4_3(__addsf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__addvdi3)
NOT_HERE_UNTIL_AFTER_4_3(__addvsi3)
NOT_HERE_UNTIL_AFTER_4_3(__ashldi3)
NOT_HERE_UNTIL_AFTER_4_3(__ashrdi3)
NOT_HERE_UNTIL_AFTER_4_3(__bswapdi2)
NOT_HERE_UNTIL_AFTER_4_3(__bswapsi2)
NOT_HERE_UNTIL_AFTER_4_3(__clzdi2)
NOT_HERE_UNTIL_AFTER_4_3(__clzsi2)
NOT_HERE_UNTIL_AFTER_4_3(__cmpdi2)
NOT_HERE_UNTIL_AFTER_4_3(__ctzdi2)
NOT_HERE_UNTIL_AFTER_4_3(__ctzsi2)
NOT_HERE_UNTIL_AFTER_4_3(__divdc3)
NOT_HERE_UNTIL_AFTER_4_3(__divdf3)
NOT_HERE_UNTIL_AFTER_4_3(__divdf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__divdi3)
NOT_HERE_UNTIL_AFTER_4_3(__divsc3)
NOT_HERE_UNTIL_AFTER_4_3(__divsf3)
NOT_HERE_UNTIL_AFTER_4_3(__divsf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__divsi3)
NOT_HERE_UNTIL_AFTER_4_3(__eqdf2)
NOT_HERE_UNTIL_AFTER_4_3(__eqdf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__eqsf2)
NOT_HERE_UNTIL_AFTER_4_3(__eqsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__extendsfdf2)
NOT_HERE_UNTIL_AFTER_4_3(__extendsfdf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__ffsdi2)
NOT_HERE_UNTIL_AFTER_4_3(__fixdfdi)
NOT_HERE_UNTIL_AFTER_4_3(__fixdfsi)
NOT_HERE_UNTIL_AFTER_4_3(__fixdfsivfp)
NOT_HERE_UNTIL_AFTER_4_3(__fixsfdi)
NOT_HERE_UNTIL_AFTER_4_3(__fixsfsi)
NOT_HERE_UNTIL_AFTER_4_3(__fixsfsivfp)
NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfdi)
NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfsi)
NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfsivfp)
NOT_HERE_UNTIL_AFTER_4_3(__fixunssfdi)
NOT_HERE_UNTIL_AFTER_4_3(__fixunssfsi)
NOT_HERE_UNTIL_AFTER_4_3(__fixunssfsivfp)
NOT_HERE_UNTIL_AFTER_4_3(__floatdidf)
NOT_HERE_UNTIL_AFTER_4_3(__floatdisf)
NOT_HERE_UNTIL_AFTER_4_3(__floatsidf)
NOT_HERE_UNTIL_AFTER_4_3(__floatsidfvfp)
NOT_HERE_UNTIL_AFTER_4_3(__floatsisf)
NOT_HERE_UNTIL_AFTER_4_3(__floatsisfvfp)
NOT_HERE_UNTIL_AFTER_4_3(__floatundidf)
NOT_HERE_UNTIL_AFTER_4_3(__floatundisf)
NOT_HERE_UNTIL_AFTER_4_3(__floatunsidf)
NOT_HERE_UNTIL_AFTER_4_3(__floatunsisf)
NOT_HERE_UNTIL_AFTER_4_3(__floatunssidfvfp)
NOT_HERE_UNTIL_AFTER_4_3(__floatunssisfvfp)
NOT_HERE_UNTIL_AFTER_4_3(__gedf2)
NOT_HERE_UNTIL_AFTER_4_3(__gedf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__gesf2)
NOT_HERE_UNTIL_AFTER_4_3(__gesf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__gtdf2)
NOT_HERE_UNTIL_AFTER_4_3(__gtdf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__gtsf2)
NOT_HERE_UNTIL_AFTER_4_3(__gtsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__ledf2)
NOT_HERE_UNTIL_AFTER_4_3(__ledf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__lesf2)
NOT_HERE_UNTIL_AFTER_4_3(__lesf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__lshrdi3)
NOT_HERE_UNTIL_AFTER_4_3(__ltdf2)
NOT_HERE_UNTIL_AFTER_4_3(__ltdf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__ltsf2)
NOT_HERE_UNTIL_AFTER_4_3(__ltsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__moddi3)
NOT_HERE_UNTIL_AFTER_4_3(__modsi3)
NOT_HERE_UNTIL_AFTER_4_3(__muldc3)
NOT_HERE_UNTIL_AFTER_4_3(__muldf3)
NOT_HERE_UNTIL_AFTER_4_3(__muldf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__muldi3)
NOT_HERE_UNTIL_AFTER_4_3(__mulsc3)
NOT_HERE_UNTIL_AFTER_4_3(__mulsf3)
NOT_HERE_UNTIL_AFTER_4_3(__mulsf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__mulvdi3)
NOT_HERE_UNTIL_AFTER_4_3(__mulvsi3)
NOT_HERE_UNTIL_AFTER_4_3(__nedf2)
NOT_HERE_UNTIL_AFTER_4_3(__nedf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__negdi2)
NOT_HERE_UNTIL_AFTER_4_3(__negvdi2)
NOT_HERE_UNTIL_AFTER_4_3(__negvsi2)
NOT_HERE_UNTIL_AFTER_4_3(__nesf2)
NOT_HERE_UNTIL_AFTER_4_3(__nesf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__paritydi2)
NOT_HERE_UNTIL_AFTER_4_3(__paritysi2)
NOT_HERE_UNTIL_AFTER_4_3(__popcountdi2)
NOT_HERE_UNTIL_AFTER_4_3(__popcountsi2)
NOT_HERE_UNTIL_AFTER_4_3(__powidf2)
NOT_HERE_UNTIL_AFTER_4_3(__powisf2)
NOT_HERE_UNTIL_AFTER_4_3(__subdf3)
NOT_HERE_UNTIL_AFTER_4_3(__subdf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__subsf3)
NOT_HERE_UNTIL_AFTER_4_3(__subsf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__subvdi3)
NOT_HERE_UNTIL_AFTER_4_3(__subvsi3)
NOT_HERE_UNTIL_AFTER_4_3(__truncdfsf2)
NOT_HERE_UNTIL_AFTER_4_3(__truncdfsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__ucmpdi2)
NOT_HERE_UNTIL_AFTER_4_3(__udivdi3)
NOT_HERE_UNTIL_AFTER_4_3(__udivmoddi4)
NOT_HERE_UNTIL_AFTER_4_3(__udivsi3)
NOT_HERE_UNTIL_AFTER_4_3(__umoddi3)
NOT_HERE_UNTIL_AFTER_4_3(__umodsi3)
NOT_HERE_UNTIL_AFTER_4_3(__unorddf2)
NOT_HERE_UNTIL_AFTER_4_3(__unorddf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__unordsf2)
NOT_HERE_UNTIL_AFTER_4_3(__unordsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__divmodsi4)
NOT_HERE_UNTIL_AFTER_4_3(__udivmodsi4)
#endif // __arm__ && __DYNAMIC__
#else /* !__APPLE__ */
extern int avoid_empty_file;

47
lib/arm/divmodsi4.S Normal file
View File

@ -0,0 +1,47 @@
/*===-- divmodsi4.S - 32-bit signed integer divide and modulus ------------===//
*
* 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 implements the __divmodsi4 (32-bit signed integer divide and
* modulus) function for the ARM architecture. A naive digit-by-digit
* computation is employed for simplicity.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
#define ESTABLISH_FRAME \
push {r4-r7, lr} ;\
add r7, sp, #12
#define CLEAR_FRAME_AND_RETURN \
pop {r4-r7, pc}
.syntax unified
.align 3
DEFINE_COMPILERRT_FUNCTION(__divmodsi4)
ESTABLISH_FRAME
// Set aside the sign of the quotient and modulus, and the address for the
// modulus.
eor r4, r0, r1
mov r5, r0
mov r6, r2
// Take the absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
eor ip, r0, r0, asr #31
eor lr, r1, r1, asr #31
sub r0, ip, r0, asr #31
sub r1, lr, r1, asr #31
// Unsigned divmod:
bl SYMBOL_NAME(__udivmodsi4)
// Apply the sign of quotient and modulus
ldr r1, [r6]
eor r0, r0, r4, asr #31
eor r1, r1, r5, asr #31
sub r0, r0, r4, asr #31
sub r1, r1, r5, asr #31
str r1, [r6]
CLEAR_FRAME_AND_RETURN

41
lib/arm/divsi3.S Normal file
View File

@ -0,0 +1,41 @@
/*===-- divsi3.S - 32-bit signed integer divide ---------------------------===//
*
* 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 implements the __divsi3 (32-bit signed integer divide) function
* for the ARM architecture as a wrapper around the unsigned routine.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
#define ESTABLISH_FRAME \
push {r4, r7, lr} ;\
add r7, sp, #4
#define CLEAR_FRAME_AND_RETURN \
pop {r4, r7, pc}
.syntax unified
.align 3
// Ok, APCS and AAPCS agree on 32 bit args, so it's safe to use the same routine.
DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_idiv, __divsi3)
DEFINE_COMPILERRT_FUNCTION(__divsi3)
ESTABLISH_FRAME
// Set aside the sign of the quotient.
eor r4, r0, r1
// Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
eor r2, r0, r0, asr #31
eor r3, r1, r1, asr #31
sub r0, r2, r0, asr #31
sub r1, r3, r1, asr #31
// abs(a) / abs(b)
bl SYMBOL_NAME(__udivsi3)
// Apply sign of quotient to result and return.
eor r0, r0, r4, asr #31
sub r0, r0, r4, asr #31
CLEAR_FRAME_AND_RETURN

67
lib/arm/modsi3.S
View File

@ -1,36 +1,39 @@
//===-------- modsi3.S - Implement modsi3 ---------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
/*===-- modsi3.S - 32-bit signed integer modulus --------------------------===//
*
* 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 implements the __modsi3 (32-bit signed integer modulus) function
* for the ARM architecture as a wrapper around the unsigned routine.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
//
// extern int32_t __modsi3(int32_t a, int32_t b);
//
// Returns the remainder when dividing two 32-bit signed integers.
// Conceptually, the function is: { return a - (a / b) * b; }
// But if you write that in C, llvm compiles it to a call to __modsi3...
//
.align 2
#define ESTABLISH_FRAME \
push {r4, r7, lr} ;\
add r7, sp, #4
#define CLEAR_FRAME_AND_RETURN \
pop {r4, r7, pc}
.syntax unified
.align 3
DEFINE_COMPILERRT_FUNCTION(__modsi3)
push {r4, r5, r7, lr}
add r7, sp, #8 // set stack frame
mov r5, r0 // save a
mov r4, r1 // save b
bl ___divsi3 // compute a/b
#if __ARM_ARCH_7A__
mls r0, r4, r0, r5 // mulitple result * b and subtract from a
#else
// before armv7, does not have "mls" instruction
mul r3, r0, r4 // multiple result * b
sub r0, r5, r3 // a - result
#endif
pop {r4, r5, r7, pc}
ESTABLISH_FRAME
// Set aside the sign of the dividend.
mov r4, r0
// Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
eor r2, r0, r0, asr #31
eor r3, r1, r1, asr #31
sub r0, r2, r0, asr #31
sub r1, r3, r1, asr #31
// abs(a) % abs(b)
bl SYMBOL_NAME(__umodsi3)
// Apply sign of dividend to result and return.
eor r0, r0, r4, asr #31
sub r0, r0, r4, asr #31
CLEAR_FRAME_AND_RETURN

80
lib/arm/udivmodsi4.S Normal file
View File

@ -0,0 +1,80 @@
/*===-- udivmodsi4.S - 32-bit unsigned integer divide and modulus ---------===//
*
* 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 implements the __udivmodsi4 (32-bit unsigned integer divide and
* modulus) function for the ARM architecture. A naive digit-by-digit
* computation is employed for simplicity.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
#define ESTABLISH_FRAME \
push {r4, r7, lr} ;\
add r7, sp, #4
#define CLEAR_FRAME_AND_RETURN \
pop {r4, r7, pc}
#define a r0
#define b r1
#define i r3
#define r r4
#define q ip
#define one lr
.syntax unified
.align 3
DEFINE_COMPILERRT_FUNCTION(__udivmodsi4)
// We use a simple digit by digit algorithm; before we get into the actual
// divide loop, we must calculate the left-shift amount necessary to align
// the MSB of the divisor with that of the dividend (If this shift is
// negative, then the result is zero, and we early out). We also conjure a
// bit mask of 1 to use in constructing the quotient, and initialize the
// quotient to zero.
ESTABLISH_FRAME
clz r4, a
tst b, b // detect divide-by-zero
clz r3, b
mov q, #0
beq LOCAL_LABEL(return) // return 0 if b is zero.
mov one, #1
subs i, r3, r4
blt LOCAL_LABEL(return) // return 0 if MSB(a) < MSB(b)
LOCAL_LABEL(mainLoop):
// This loop basically implements the following:
//
// do {
// if (a >= b << i) {
// a -= b << i;
// q |= 1 << i;
// if (a == 0) break;
// }
// } while (--i)
//
// Note that this does not perform the final iteration (i == 0); by doing it
// this way, we can merge the two branches which is a substantial win for
// such a tight loop on current ARM architectures.
subs r, a, b, lsl i
orrhs q, q,one, lsl i
movhs a, r
subsne i, i, #1
bhi LOCAL_LABEL(mainLoop)
// Do the final test subtraction and update of quotient (i == 0), as it is
// not performed in the main loop.
subs r, a, b
orrhs q, #1
movhs a, r
LOCAL_LABEL(return):
// Store the remainder, and move the quotient to r0, then return.
str a, [r2]
mov r0, q
CLEAR_FRAME_AND_RETURN

80
lib/arm/udivsi3.S Normal file
View File

@ -0,0 +1,80 @@
/*===-- udivsi3.S - 32-bit unsigned integer divide ------------------------===//
*
* 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 implements the __udivsi3 (32-bit unsigned integer divide)
* function for the ARM architecture. A naive digit-by-digit computation is
* employed for simplicity.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
#define ESTABLISH_FRAME \
push {r7, lr} ;\
mov r7, sp
#define CLEAR_FRAME_AND_RETURN \
pop {r7, pc}
#define a r0
#define b r1
#define r r2
#define i r3
#define q ip
#define one lr
.syntax unified
.align 3
// Ok, APCS and AAPCS agree on 32 bit args, so it's safe to use the same routine.
DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_uidiv, __udivsi3)
DEFINE_COMPILERRT_FUNCTION(__udivsi3)
// We use a simple digit by digit algorithm; before we get into the actual
// divide loop, we must calculate the left-shift amount necessary to align
// the MSB of the divisor with that of the dividend (If this shift is
// negative, then the result is zero, and we early out). We also conjure a
// bit mask of 1 to use in constructing the quotient, and initialize the
// quotient to zero.
ESTABLISH_FRAME
clz r2, a
tst b, b // detect divide-by-zero
clz r3, b
mov q, #0
beq LOCAL_LABEL(return) // return 0 if b is zero.
mov one, #1
subs i, r3, r2
blt LOCAL_LABEL(return) // return 0 if MSB(a) < MSB(b)
LOCAL_LABEL(mainLoop):
// This loop basically implements the following:
//
// do {
// if (a >= b << i) {
// a -= b << i;
// q |= 1 << i;
// if (a == 0) break;
// }
// } while (--i)
//
// Note that this does not perform the final iteration (i == 0); by doing it
// this way, we can merge the two branches which is a substantial win for
// such a tight loop on current ARM architectures.
subs r, a, b, lsl i
orrhs q, q,one, lsl i
movhs a, r
subsne i, i, #1
bhi LOCAL_LABEL(mainLoop)
// Do the final test subtraction and update of quotient (i == 0), as it is
// not performed in the main loop.
subs r, a, b
orrhs q, #1
LOCAL_LABEL(return):
// Move the quotient to r0 and return.
mov r0, q
CLEAR_FRAME_AND_RETURN

58
lib/arm/umodsi3.S Normal file
View File

@ -0,0 +1,58 @@
/*===-- umodsi3.S - 32-bit unsigned integer modulus -----------------------===//
*
* 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 implements the __umodsi3 (32-bit unsigned integer modulus)
* function for the ARM architecture. A naive digit-by-digit computation is
* employed for simplicity.
*
*===----------------------------------------------------------------------===*/
#include "../assembly.h"
#define a r0
#define b r1
#define r r2
#define i r3
.syntax unified
.align 3
DEFINE_COMPILERRT_FUNCTION(__umodsi3)
// We use a simple digit by digit algorithm; before we get into the actual
// divide loop, we must calculate the left-shift amount necessary to align
// the MSB of the divisor with that of the dividend.
clz r2, a
tst b, b // detect b == 0
clz r3, b
bxeq lr // return a if b == 0
subs i, r3, r2
bxlt lr // return a if MSB(a) < MSB(b)
LOCAL_LABEL(mainLoop):
// This loop basically implements the following:
//
// do {
// if (a >= b << i) {
// a -= b << i;
// if (a == 0) break;
// }
// } while (--i)
//
// Note that this does not perform the final iteration (i == 0); by doing it
// this way, we can merge the two branches which is a substantial win for
// such a tight loop on current ARM architectures.
subs r, a, b, lsl i
movhs a, r
subsne i, i, #1
bhi LOCAL_LABEL(mainLoop)
// Do the final test subtraction and update of remainder (i == 0), as it is
// not performed in the main loop.
subs r, a, b
movhs a, r
bx lr

5
lib/ashldi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,9 @@
/* Precondition: 0 <= b < bits_in_dword */
di_int
ARM_EABI_FNALIAS(llsl, ashldi3);
COMPILER_RT_ABI di_int
__ashldi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);

5
lib/ashrdi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,9 @@
/* Precondition: 0 <= b < bits_in_dword */
di_int
ARM_EABI_FNALIAS(lasr, ashrdi3);
COMPILER_RT_ABI di_int
__ashrdi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);

43
lib/assembly.h
View File

@ -22,33 +22,48 @@
#define SEPARATOR ;
#endif
/* We can't use __USER_LABEL_PREFIX__ here, it isn't possible to concatenate the
*values* of two macros. This is quite brittle, though. */
#if defined(__APPLE__)
#define SYMBOL_NAME(name) _##name
#define HIDDEN_DIRECTIVE .private_extern
#define LOCAL_LABEL(name) L_##name
#else
#define SYMBOL_NAME(name) name
#define HIDDEN_DIRECTIVE .hidden
#define LOCAL_LABEL(name) .L_##name
#endif
#define GLUE2(a, b) a ## b
#define GLUE(a, b) GLUE2(a, b)
#define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
#ifdef VISIBILITY_HIDDEN
#define DEFINE_COMPILERRT_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
.private_extern SYMBOL_NAME(name) SEPARATOR \
#define DEFINE_COMPILERRT_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
HIDDEN_DIRECTIVE SYMBOL_NAME(name) SEPARATOR \
SYMBOL_NAME(name):
#else
#define DEFINE_COMPILERRT_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
#define DEFINE_COMPILERRT_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
SYMBOL_NAME(name):
#endif
#define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
.private_extern SYMBOL_NAME(name) SEPARATOR \
#define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name) \
.globl SYMBOL_NAME(name) SEPARATOR \
HIDDEN_DIRECTIVE SYMBOL_NAME(name) SEPARATOR \
SYMBOL_NAME(name):
#define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name) \
.globl name SEPARATOR \
.private_extern name SEPARATOR \
.globl name SEPARATOR \
HIDDEN_DIRECTIVE name SEPARATOR \
name:
#define DEFINE_COMPILERRT_FUNCTION_ALIAS(name, target) \
.globl SYMBOL_NAME(name) SEPARATOR \
.set SYMBOL_NAME(name), SYMBOL_NAME(target) SEPARATOR
#if defined (__ARM_EABI__)
# define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name) \
DEFINE_COMPILERRT_FUNCTION_ALIAS(aeabi_name, name)
#else
# define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)
#endif
#endif /* COMPILERRT_ASSEMBLY_H */

5
lib/clzdi2.c
View File

@ -1,6 +1,6 @@
/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------===
*
* The LLVM Compiler Infrastructure
* 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.
@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,7 @@
/* Precondition: a != 0 */
si_int
COMPILER_RT_ABI si_int
__clzdi2(di_int a)
{
dwords x;

5
lib/clzsi2.c
View File

@ -1,6 +1,6 @@
/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------===
*
* The LLVM Compiler Infrastructure
* 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.
@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,7 @@
/* Precondition: a != 0 */
si_int
COMPILER_RT_ABI si_int
__clzsi2(si_int a)
{
su_int x = (su_int)a;

7
lib/cmpdi2.c
View File

@ -6,20 +6,21 @@
* Source Licenses. See LICENSE.TXT for details.
*
* ===----------------------------------------------------------------------===
*
*
* This file implements __cmpdi2 for the compiler_rt library.
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: if (a < b) returns 0
/* Returns: if (a < b) returns 0
* if (a == b) returns 1
* if (a > b) returns 2
*/
si_int
COMPILER_RT_ABI si_int
__cmpdi2(di_int a, di_int b)
{
dwords x;

3
lib/ctzdi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,7 @@
/* Precondition: a != 0 */
si_int
COMPILER_RT_ABI si_int
__ctzdi2(di_int a)
{
dwords x;

3
lib/ctzsi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,7 @@
/* Precondition: a != 0 */
si_int
COMPILER_RT_ABI si_int
__ctzsi2(si_int a)
{
su_int x = (su_int)a;

3
lib/divdf3.c
View File

@ -15,10 +15,13 @@
// underflow with correct rounding.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
ARM_EABI_FNALIAS(ddiv, divdf3);
fp_t __divdf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;

5
lib/divdi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
du_int COMPILER_RT_ABI __udivmoddi4(du_int a, du_int b, du_int* rem);
/* Returns: a / b */
di_int
COMPILER_RT_ABI di_int
__divdi3(di_int a, di_int b)
{
const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;

30
lib/divmoddi4.c Normal file
View File

@ -0,0 +1,30 @@
/*===-- divmoddi4.c - Implement __divmoddi4 --------------------------------===
*
* 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 implements __divmoddi4 for the compiler_rt library.
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
extern COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
ARM_EABI_FNALIAS(ldivmod, divmoddi4);
/* Returns: a / b, *rem = a % b */
COMPILER_RT_ABI di_int
__divmoddi4(di_int a, di_int b, di_int* rem)
{
di_int d = __divdi3(a,b);
*rem = a - (d*b);
return d;
}

5
lib/divmodsi4.c
View File

@ -11,15 +11,16 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
extern si_int __divsi3(si_int a, si_int b);
extern COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
/* Returns: a / b, *rem = a % b */
si_int
COMPILER_RT_ABI si_int
__divmodsi4(si_int a, si_int b, si_int* rem)
{
si_int d = __divsi3(a,b);

3
lib/divsf3.c
View File

@ -15,10 +15,13 @@
// underflow with correct rounding.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
ARM_EABI_FNALIAS(fdiv, divsf3);
fp_t __divsf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;

7
lib/divsi3.c
View File

@ -11,14 +11,17 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
su_int __udivsi3(su_int n, su_int d);
su_int COMPILER_RT_ABI __udivsi3(su_int n, su_int d);
/* Returns: a / b */
si_int
ARM_EABI_FNALIAS(idiv, divsi3);
COMPILER_RT_ABI si_int
__divsi3(si_int a, si_int b)
{
const int bits_in_word_m1 = (int)(sizeof(si_int) * CHAR_BIT) - 1;

4
lib/extendsfdf2.c
View File

@ -41,6 +41,8 @@
#include <stdint.h>
#include <limits.h>
#include "abi.h"
typedef float src_t;
typedef uint32_t src_rep_t;
#define SRC_REP_C UINT32_C
@ -67,6 +69,8 @@ static inline dst_t dstFromRep(dst_rep_t x) {
// End helper routines. Conversion implementation follows.
ARM_EABI_FNALIAS(f2d, extendsfdf2);
dst_t __extendsfdf2(src_t a) {
// Various constants whose values follow from the type parameters.

3
lib/ffsdi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,7 @@
* the value zero if a is zero. The least significant bit is index one.
*/
si_int
COMPILER_RT_ABI si_int
__ffsdi2(di_int a)
{
dwords x;

3
lib/fixdfdi.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -23,6 +24,8 @@
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
ARM_EABI_FNALIAS(d2lz, fixdfdi);
di_int
__fixdfdi(double a)
{

5
lib/fixdfsi.c
View File

@ -12,10 +12,15 @@
// conversion is undefined for out of range values in the C standard.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
#include "int_lib.h"
ARM_EABI_FNALIAS(d2iz, fixdfsi);
int __fixdfsi(fp_t a) {
// Break a into sign, exponent, significand

5
lib/fixsfdi.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -23,7 +24,9 @@
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
di_int
ARM_EABI_FNALIAS(d2lz, fixsfdi);
COMPILER_RT_ABI di_int
__fixsfdi(float a)
{
float_bits fb;

7
lib/fixsfsi.c
View File

@ -12,12 +12,15 @@
// conversion is undefined for out of range values in the C standard.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
int __fixsfsi(fp_t a) {
ARM_EABI_FNALIAS(f2iz, fixsfsi);
COMPILER_RT_ABI int
__fixsfsi(fp_t a) {
// Break a into sign, exponent, significand
const rep_t aRep = toRep(a);
const rep_t aAbs = aRep & absMask;

5
lib/fixunsdfdi.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -26,7 +27,9 @@
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
du_int
ARM_EABI_FNALIAS(d2ulz, fixunsdfdi);
COMPILER_RT_ABI du_int
__fixunsdfdi(double a)
{
double_bits fb;

5
lib/fixunsdfsi.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -26,7 +27,9 @@
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
su_int
ARM_EABI_FNALIAS(d2uiz, fixunsdfsi);
COMPILER_RT_ABI su_int
__fixunsdfsi(double a)
{
double_bits fb;

6
lib/fixunssfdi.c
View File

@ -11,9 +11,9 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: convert a to a unsigned long long, rounding toward zero.
* Negative values all become zero.
*/
@ -26,7 +26,9 @@
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
du_int
ARM_EABI_FNALIAS(f2ulz, fixunssfdi);
COMPILER_RT_ABI du_int
__fixunssfdi(float a)
{
float_bits fb;

5
lib/fixunssfsi.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -26,7 +27,9 @@
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
su_int
ARM_EABI_FNALIAS(f2uiz, fixunssfsi);
COMPILER_RT_ABI su_int
__fixunssfsi(float a)
{
float_bits fb;

7
lib/floatdidf.c
View File

@ -11,6 +11,7 @@
*
*===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <float.h>
@ -23,13 +24,15 @@
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
ARM_EABI_FNALIAS(l2d, floatdidf);
#ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; we'll set the inexact flag
* as a side-effect of this computation.
*/
#include <stdint.h>
double
COMPILER_RT_ABI double
__floatdidf(di_int a)
{
static const double twop52 = 0x1.0p52;
@ -49,7 +52,7 @@ __floatdidf(di_int a)
* set, and we don't want to code-gen to an unknown soft-float implementation.
*/
double
COMPILER_RT_ABI double
__floatdidf(di_int a)
{
if (a == 0)

8
lib/floatdisf.c
View File

@ -12,7 +12,7 @@
*===----------------------------------------------------------------------===
*/
#include "int_lib.h"
#include "abi.h"
#include <float.h>
/* Returns: convert a to a float, rounding toward even.*/
@ -23,7 +23,11 @@
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
float
#include "int_lib.h"
ARM_EABI_FNALIAS(l2f, floatdisf);
COMPILER_RT_ABI float
__floatdisf(di_int a)
{
if (a == 0)

5
lib/floatsidf.c
View File

@ -12,10 +12,15 @@
// mode.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
#include "int_lib.h"
ARM_EABI_FNALIAS(i2d, floatsidf);
fp_t __floatsidf(int a) {
const int aWidth = sizeof a * CHAR_BIT;

5
lib/floatsisf.c
View File

@ -12,10 +12,15 @@
// mode.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
#include "int_lib.h"
ARM_EABI_FNALIAS(i2f, floatsisf);
fp_t __floatsisf(int a) {
const int aWidth = sizeof a * CHAR_BIT;

10
lib/floatundidf.c
View File

@ -12,7 +12,7 @@
* ===----------------------------------------------------------------------===
*/
#include "int_lib.h"
#include "abi.h"
#include <float.h>
/* Returns: convert a to a double, rounding toward even. */
@ -23,6 +23,10 @@
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
#include "int_lib.h"
ARM_EABI_FNALIAS(ul2d, floatundidf);
#ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; we'll set the inexact flag
* as a side-effect of this computation.
@ -30,7 +34,7 @@
#include <stdint.h>
double
COMPILER_RT_ABI double
__floatundidf(du_int a)
{
static const double twop52 = 0x1.0p52;
@ -52,7 +56,7 @@ __floatundidf(du_int a)
* set, and we don't want to code-gen to an unknown soft-float implementation.
*/
double
COMPILER_RT_ABI double
__floatundidf(du_int a)
{
if (a == 0)

8
lib/floatundisf.c
View File

@ -12,7 +12,7 @@
*===----------------------------------------------------------------------===
*/
#include "int_lib.h"
#include "abi.h"
#include <float.h>
/* Returns: convert a to a float, rounding toward even. */
@ -23,7 +23,11 @@
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
float
#include "int_lib.h"
ARM_EABI_FNALIAS(ul2f, floatundisf);
COMPILER_RT_ABI float
__floatundisf(du_int a)
{
if (a == 0)

5
lib/floatunsidf.c
View File

@ -12,10 +12,15 @@
// mode.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
#include "int_lib.h"
ARM_EABI_FNALIAS(ui2d, floatunsidf);
fp_t __floatunsidf(unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT;

5
lib/floatunsisf.c
View File

@ -12,10 +12,15 @@
// mode.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
#include "int_lib.h"
ARM_EABI_FNALIAS(ui2f, floatunsisf);
fp_t __floatunsisf(unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT;

5
lib/lshrdi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,9 @@
/* Precondition: 0 <= b < bits_in_dword */
di_int
ARM_EABI_FNALIAS(llsr, lshrdi3);
COMPILER_RT_ABI di_int
__lshrdi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);

5
lib/moddi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
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);
/* Returns: a % b */
di_int
COMPILER_RT_ABI di_int
__moddi3(di_int a, di_int b)
{
const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;

5
lib/modsi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
su_int __divsi3(si_int a, si_int b);
su_int COMPILER_RT_ABI __divsi3(si_int a, si_int b);
/* Returns: a % b */
si_int
COMPILER_RT_ABI si_int
__modsi3(si_int a, si_int b)
{
return a - __divsi3(a, b) * b;

6
lib/muldf3.c
View File

@ -11,11 +11,15 @@
// with the IEEE-754 default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
fp_t __muldf3(fp_t a, fp_t b) {
ARM_EABI_FNALIAS(dmul, muldf3);
COMPILER_RT_ABI fp_t
__muldf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;

7
lib/muldi3.c
View File

@ -10,7 +10,8 @@
* This file implements __muldi3 for the compiler_rt library.
*
* ===----------------------------------------------------------------------===
*/
*/
#include "abi.h"
#include "int_lib.h"
@ -40,7 +41,9 @@ __muldsi3(su_int a, su_int b)
/* Returns: a * b */
di_int
ARM_EABI_FNALIAS(lmul, muldi3);
COMPILER_RT_ABI di_int
__muldi3(di_int a, di_int b)
{
dwords x;

6
lib/mulsf3.c
View File

@ -11,11 +11,15 @@
// with the IEEE-754 default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
fp_t __mulsf3(fp_t a, fp_t b) {
ARM_EABI_FNALIAS(fmul, mulsf3);
COMPILER_RT_ABI fp_t
__mulsf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;

3
lib/negdf2.c
View File

@ -10,10 +10,13 @@
// This file implements double-precision soft-float negation.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
ARM_EABI_FNALIAS(dneg, negdf2);
fp_t __negdf2(fp_t a) {
return fromRep(toRep(a) ^ signBit);
}

6
lib/negsf2.c
View File

@ -10,10 +10,14 @@
// This file implements single-precision soft-float negation.
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
fp_t __negsf2(fp_t a) {
ARM_EABI_FNALIAS(fneg, negsf2);
COMPILER_RT_ABI fp_t
__negsf2(fp_t a) {
return fromRep(toRep(a) ^ signBit);
}

3
lib/negvdi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if -a overflows */
di_int
COMPILER_RT_ABI di_int
__negvdi2(di_int a)
{
const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT)-1);

3
lib/negvsi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if -a overflows */
si_int
COMPILER_RT_ABI si_int
__negvsi2(si_int a)
{
const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT)-1);

5
lib/paritydi2.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: 1 if number of bits is odd else returns 0 */
si_int __paritysi2(si_int a);
si_int COMPILER_RT_ABI __paritysi2(si_int a);
si_int
COMPILER_RT_ABI si_int
__paritydi2(di_int a)
{
dwords x;

3
lib/paritysi2.c
View File

@ -11,12 +11,13 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: 1 if number of bits is odd else returns 0 */
si_int
COMPILER_RT_ABI si_int
__paritysi2(si_int a)
{
su_int x = (su_int)a;

3
lib/popcountdi2.c
View File

@ -11,12 +11,13 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: count of 1 bits */
si_int
COMPILER_RT_ABI si_int
__popcountdi2(di_int a)
{
du_int x2 = (du_int)a;

3
lib/popcountsi2.c
View File

@ -11,12 +11,13 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: count of 1 bits */
si_int
COMPILER_RT_ABI si_int
__popcountsi2(si_int a)
{
su_int x = (su_int)a;

3
lib/powidf2.c
View File

@ -11,12 +11,13 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: a ^ b */
double
COMPILER_RT_ABI double
__powidf2(double a, si_int b)
{
const int recip = b < 0;

3
lib/powisf2.c
View File

@ -11,12 +11,13 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: a ^ b */
float
COMPILER_RT_ABI float
__powisf2(float a, si_int b)
{
const int recip = b < 0;

30
lib/subdf3.c Normal file
View File

@ -0,0 +1,30 @@
//===-- lib/adddf3.c - Double-precision subtraction ---------------*- C -*-===//
//
// 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 implements double-precision soft-float subtraction with the
// IEEE-754 default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define DOUBLE_PRECISION
#include "fp_lib.h"
fp_t COMPILER_RT_ABI __adddf3(fp_t a, fp_t b);
ARM_EABI_FNALIAS(dsub, subdf3);
// Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t
__subdf3(fp_t a, fp_t b) {
return __adddf3(a, fromRep(toRep(b) ^ signBit));
}
/* FIXME: rsub for ARM EABI */

29
lib/subsf3.c Normal file
View File

@ -0,0 +1,29 @@
//===-- lib/subsf3.c - Single-precision subtraction ---------------*- C -*-===//
//
// 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 implements single-precision soft-float subtraction with the
// IEEE-754 default rounding (to nearest, ties to even).
//
//===----------------------------------------------------------------------===//
#include "abi.h"
#define SINGLE_PRECISION
#include "fp_lib.h"
fp_t COMPILER_RT_ABI __addsf3(fp_t a, fp_t b);
ARM_EABI_FNALIAS(fsub, subsf3);
// Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t
__subsf3(fp_t a, fp_t b) {
return __addsf3(a, fromRep(toRep(b) ^ signBit));
}
/* FIXME: rsub for ARM EABI */

5
lib/subvdi3.c
View File

@ -1,6 +1,6 @@
/* ===-- subvdi3.c - Implement __subvdi3 -----------------------------------===
*
* The LLVM Compiler Infrastructure
* 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.
@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if a - b overflows */
di_int
COMPILER_RT_ABI di_int
__subvdi3(di_int a, di_int b)
{
di_int s = a - b;

5
lib/subvsi3.c
View File

@ -1,6 +1,6 @@
/* ===-- subvsi3.c - Implement __subvsi3 -----------------------------------===
*
* The LLVM Compiler Infrastructure
* 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.
@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
#include <stdlib.h>
@ -19,7 +20,7 @@
/* Effects: aborts if a - b overflows */
si_int
COMPILER_RT_ABI si_int
__subvsi3(si_int a, si_int b)
{
si_int s = a - b;

7
lib/truncdfsf2.c
View File

@ -41,6 +41,8 @@
#include <limits.h>
#include <stdbool.h>
#include "abi.h"
typedef double src_t;
typedef uint64_t src_rep_t;
#define SRC_REP_C UINT64_C
@ -66,7 +68,10 @@ static inline dst_t dstFromRep(dst_rep_t x) {
// End helper routines. Conversion implementation follows.
dst_t __truncdfsf2(src_t a) {
ARM_EABI_FNALIAS(d2f, truncdfsf2);
COMPILER_RT_ABI dst_t
__truncdfsf2(src_t a) {
// Various constants whose values follow from the type parameters.
// Any reasonable optimizer will fold and propagate all of these.

3
lib/ucmpdi2.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -19,7 +20,7 @@
* if (a > b) returns 2
*/
si_int
COMPILER_RT_ABI si_int
__ucmpdi2(du_int a, du_int b)
{
udwords x;

5
lib/udivdi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
du_int COMPILER_RT_ABI __udivmoddi4(du_int a, du_int b, du_int* rem);
/* Returns: a / b */
du_int
COMPILER_RT_ABI du_int
__udivdi3(du_int a, du_int b)
{
return __udivmoddi4(a, b, 0);

5
lib/udivmoddi4.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -20,7 +21,9 @@
/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
du_int
ARM_EABI_FNALIAS(uldivmod, udivmoddi4);
COMPILER_RT_ABI du_int
__udivmoddi4(du_int a, du_int b, du_int* rem)
{
const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;

7
lib/udivmodsi4.c
View File

@ -11,20 +11,21 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
extern su_int __udivsi3(su_int n, su_int d);
extern su_int COMPILER_RT_ABI __udivsi3(su_int n, su_int d);
/* Returns: a / b, *rem = a % b */
su_int
COMPILER_RT_ABI su_int
__udivmodsi4(su_int a, su_int b, su_int* rem)
{
si_int d = __udivsi3(a,b);
*rem = a - (d*b);
return d;
return d;
}

5
lib/udivsi3.c
View File

@ -11,6 +11,7 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
@ -18,7 +19,9 @@
/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
su_int
ARM_EABI_FNALIAS(uidiv, udivsi3);
COMPILER_RT_ABI su_int
__udivsi3(su_int n, su_int d)
{
const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;

5
lib/umoddi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
du_int COMPILER_RT_ABI __udivmoddi4(du_int a, du_int b, du_int* rem);
/* Returns: a % b */
du_int
COMPILER_RT_ABI du_int
__umoddi3(du_int a, du_int b)
{
du_int r;

5
lib/umodsi3.c
View File

@ -11,14 +11,15 @@
*
* ===----------------------------------------------------------------------===
*/
#include "abi.h"
#include "int_lib.h"
/* Returns: a % b */
su_int __udivsi3(su_int a, su_int b);
su_int COMPILER_RT_ABI __udivsi3(su_int a, su_int b);
su_int
COMPILER_RT_ABI su_int
__umodsi3(su_int a, su_int b)
{
return a - __udivsi3(a, b) * b;

27
make/AppleBI.mk
View File

@ -19,8 +19,8 @@ else
INSTALL_TARGET = install-iOS
CFLAGS.Release.armv6 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT)
CFLAGS.Release.armv7 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT)
CFLAGS.Static.armv6 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT)
CFLAGS.Static.armv7 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT)
CFLAGS.Static.armv6 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT) -static
CFLAGS.Static.armv7 := $(CFLAGS) -Wall -Os -fomit-frame-pointer -g -isysroot $(SDKROOT) -static
LD_OTHER_FLAGS = -Wl,-alias_list,$(SRCROOT)/lib/arm/softfloat-alias.list -isysroot $(SDKROOT)
endif
@ -43,7 +43,11 @@ installsrc:
install: $(INSTALL_TARGET)
# Copy results to DSTROOT.
install-MacOSX : $(SYMROOT)/libcompiler_rt.dylib
install-MacOSX : $(SYMROOT)/libcompiler_rt.dylib \
$(SYMROOT)/libcompiler_rt-dyld.a
mkdir -p $(DSTROOT)/usr/local/lib/dyld
cp $(SYMROOT)/libcompiler_rt-dyld.a \
$(DSTROOT)/usr/local/lib/dyld/libcompiler_rt.a
mkdir -p $(DSTROOT)/usr/lib/system
strip -S $(SYMROOT)/libcompiler_rt.dylib \
-o $(DSTROOT)/usr/lib/system/libcompiler_rt.dylib
@ -70,10 +74,14 @@ $(SYMROOT)/libcompiler_rt.dylib: $(foreach arch,$(RC_ARCHS), \
# Copy results to DSTROOT.
install-iOS: $(SYMROOT)/libcompiler_rt-static.a \
$(SYMROOT)/libcompiler_rt-dyld.a \
$(SYMROOT)/libcompiler_rt.dylib
mkdir -p $(DSTROOT)/usr/local/lib
cp $(SYMROOT)/libcompiler_rt-static.a \
$(DSTROOT)/usr/local/lib/libcompiler_rt-static.a
mkdir -p $(DSTROOT)/usr/local/lib/dyld
cp $(SYMROOT)/libcompiler_rt-dyld.a \
$(DSTROOT)/usr/local/lib/dyld/libcompiler_rt.a
mkdir -p $(DSTROOT)/usr/lib/system
strip -S $(SYMROOT)/libcompiler_rt.dylib \
-o $(DSTROOT)/usr/lib/system/libcompiler_rt.dylib
@ -84,3 +92,16 @@ $(SYMROOT)/libcompiler_rt-static.a : $(foreach arch,$(RC_ARCHS), \
$(OBJROOT)/darwin_bni/Static/$(arch)/libcompiler_rt.a)
lipo -create $^ -o $@
# rule to make each archive slice for dyld
$(OBJROOT)/libcompiler_rt-dyld-%.a : $(OBJROOT)/darwin_bni/Release/%/libcompiler_rt.a
cp $^ $@
ar -d $@ apple_versioning.o
ar -d $@ gcc_personality_v0.o
ar -d $@ eprintf.o
ranlib $@
# rule to make make archive for dyld
$(SYMROOT)/libcompiler_rt-dyld.a : $(foreach arch,$(RC_ARCHS), \
$(OBJROOT)/libcompiler_rt-dyld-$(arch).a)
lipo -create $^ -o $@

84
make/platform/clang_darwin.mk
View File

@ -6,6 +6,20 @@
Description := Static runtime libraries for clang/Darwin.
# A function that ensures we don't try to build for architectures that we
# don't have working toolchains for.
CheckArches = \
$(shell \
result=""; \
for arch in $(1); do \
if $(CC) -arch $$arch -dumpversion > /dev/null; then \
result="$$result$$arch "; \
fi; \
done; \
echo $$result)
###
Configs :=
UniversalArchs :=
@ -13,22 +27,23 @@ UniversalArchs :=
# still be referenced from Darwin system headers. This symbol is only ever
# needed on i386.
Configs += eprintf
UniversalArchs.eprintf := i386
UniversalArchs.eprintf := $(call CheckArches,i386)
# Configuration for targetting 10.4. We need a few functions missing from
# libgcc_s.10.4.dylib. We only build x86 slices since clang doesn't really
# support targetting PowerPC.
Configs += 10.4
UniversalArchs.10.4 := i386 x86_64
UniversalArchs.10.4 := $(call CheckArches,i386 x86_64)
# Configuration for targetting armv6. We need a few additional functions which
# must be in the same linkage unit.
Configs += armv6
UniversalArchs.armv6 := armv6
# Configuration for targetting iOS, for some ARMv6 functions, which must be
# in the same linkage unit, and for a couple of other functions that didn't
# make it into libSystem.
Configs += ios
UniversalArchs.ios := $(call CheckArches,i386 x86_64 armv6 armv7)
# Configuration for use with kernel/kexts.
Configs += cc_kext
UniversalArchs.cc_kext := armv6 armv7 i386 x86_64
UniversalArchs.cc_kext := $(call CheckArches,armv6 armv7 i386 x86_64)
###
@ -40,10 +55,42 @@ override CC := $(patsubst -arch_%,,$(CC))
CFLAGS := -Wall -Werror -O3 -fomit-frame-pointer
# Always set deployment target arguments for every build, these libraries should
# never depend on the environmental overrides. We simply set them to minimum
# supported deployment target -- nothing in the compiler-rt libraries should
# actually depend on the deployment target.
X86_DEPLOYMENT_ARGS := -mmacosx-version-min=10.4
ARM_DEPLOYMENT_ARGS := -miphoneos-version-min=1.0
# If an explicit ARM_SDK build variable is set, use that as the isysroot.
ifneq ($(ARM_SDK),)
ARM_DEPLOYMENT_ARGS += -isysroot $(ARM_SDK)
endif
CFLAGS.eprintf := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.10.4 := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.ios.i386 := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.ios.x86_64 := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.ios.armv6 := $(CFLAGS) $(ARM_DEPLOYMENT_ARGS)
CFLAGS.ios.armv7 := $(CFLAGS) $(ARM_DEPLOYMENT_ARGS)
CFLAGS.cc_kext.i386 := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.cc_kext.x86_64 := $(CFLAGS) $(X86_DEPLOYMENT_ARGS)
CFLAGS.cc_kext.armv6 := $(CFLAGS) $(ARM_DEPLOYMENT_ARGS) -mthumb
CFLAGS.cc_kext.armv7 := $(CFLAGS) $(ARM_DEPLOYMENT_ARGS) -mthumb
FUNCTIONS.eprintf := eprintf
FUNCTIONS.10.4 := eprintf floatundidf floatundisf floatundixf
FUNCTIONS.armv6 := switch16 switch32 switch8 switchu8 \
save_vfp_d8_d15_regs restore_vfp_d8_d15_regs
FUNCTIONS.ios := divmodsi4 udivmodsi4
# On x86, the divmod functions reference divsi.
FUNCTIONS.ios.i386 := $(FUNCTIONS.ios) \
divsi3 udivsi3
FUNCTIONS.ios.x86_64 := $(FUNCTIONS.ios) \
divsi3 udivsi3
FUNCTIONS.ios.armv6 := $(FUNCTIONS.ios) \
sync_synchronize \
switch16 switch32 switch8 switchu8 \
save_vfp_d8_d15_regs restore_vfp_d8_d15_regs
CCKEXT_COMMON_FUNCTIONS := \
absvdi2 \
@ -62,6 +109,8 @@ CCKEXT_COMMON_FUNCTIONS := \
divdc3 \
divdi3 \
divsc3 \
divmodsi4 \
udivmodsi4 \
do_global_dtors \
eprintf \
ffsdi2 \
@ -135,10 +184,8 @@ CCKEXT_ARM_FUNCTIONS := $(CCKEXT_COMMON_FUNCTIONS) \
floatsisf \
floatunsidf \
floatunsisf \
gtdf2 \
gtsf2 \
ltdf2 \
ltsf2 \
comparedf2 \
comparesf2 \
modsi3 \
muldf3 \
mulsf3 \
@ -159,9 +206,6 @@ CCKEXT_ARM_FUNCTIONS := $(CCKEXT_COMMON_FUNCTIONS) \
FUNCTIONS.cc_kext.armv6 := $(CCKEXT_ARM_FUNCTIONS)
FUNCTIONS.cc_kext.armv7 := $(CCKEXT_ARM_FUNCTIONS)
CFLAGS.cc_kext.armv6 := $(CFLAGS) -mthumb
CFLAGS.cc_kext.armv7 := $(CFLAGS) -mthumb
CCKEXT_X86_FUNCTIONS := $(CCKEXT_COMMON_FUNCTIONS) \
divxc3 \
fixunsxfdi \
@ -221,11 +265,9 @@ FUNCTIONS.cc_kext.x86_64 := $(CCKEXT_X86_FUNCTIONS) \
# FIXME: Currently, compiler-rt is missing implementations for a number of the
# functions that need to go into libcc_kext.a. Filter them out for now.
CCKEXT_MISSING_FUNCTIONS := \
adddf3 addsf3 cmpdf2 cmpsf2 div0 divdf3 divsf3 \
extendsfdf2 ffssi2 fixdfsi fixsfsi floatsidf floatsisf \
floatunsidf floatunsisf gtdf2 gtsf2 ltdf2 ltsf2 \
muldf3 mulsf3 negdf2 negsf2 subdf3 subsf3 \
truncdfsf2 udiv_w_sdiv unorddf2 unordsf2 bswapdi2 \
cmpdf2 cmpsf2 div0 \
ffssi2 \
udiv_w_sdiv unorddf2 unordsf2 bswapdi2 \
bswapsi2 \
gcc_bcmp \
do_global_dtors \

2
make/platform/darwin_bni.mk
View File

@ -9,6 +9,8 @@ Configs := Debug Release Profile Static
UniversalArchs := $(RC_ARCHS)
ifeq (,$(SDKROOT))
CC.Release := $(CC)
CC.Static := $(CC)
else
CC.Release := /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/cc
CC.Static := /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/cc

2
test/Unit/absvti2_test.c
View File

@ -77,6 +77,8 @@ int main()
if (test__absvti2(make_ti(((ti_int)rand() << 32) | rand(),
((ti_int)rand() << 32) | rand())))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/adddf3vfp_test.c
View File

@ -41,6 +41,8 @@ int main()
return 1;
if (test__adddf3vfp(0.0, -0.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/addsf3vfp_test.c
View File

@ -41,6 +41,8 @@ int main()
return 1;
if (test__addsf3vfp(0.0, -0.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/addvti3_test.c
View File

@ -87,6 +87,8 @@ int main()
make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/ashlti3_test.c
View File

@ -168,6 +168,8 @@ int main()
if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 127,
make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/ashrti3_test.c
View File

@ -166,6 +166,8 @@ int main()
if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 127,
make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/bswapdi2_test.c
View File

@ -37,6 +37,8 @@ int main()
return 1;
if (test__bswapdi2(0x0000000100000002LL, 0x0200000001000000LL))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/bswapsi2_test.c
View File

@ -37,6 +37,8 @@ int main()
return 1;
if (test__bswapsi2(0x00000001, 0x01000000))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/clzti2_test.c
View File

@ -83,6 +83,8 @@ int main()
return 1;
if (test__clzti2(make_ti(0x8000000100000000LL, 0x8000000800000000LL), 0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/cmpti2_test.c
View File

@ -105,6 +105,8 @@ int main()
if (test__cmpti2(make_ti(2, 2), make_ti(2, 3), 0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/ctzti2_test.c
View File

@ -76,6 +76,8 @@ int main()
return 1;
if (test__ctzti2(make_ti(0x8000000000000000LL, 0x0000000000000000LL), 127))
return 1;
#else
printf("skipped\n");
#endif
return 0;

2
test/Unit/divdf3vfp_test.c
View File

@ -41,6 +41,8 @@ int main()
return 1;
if (test__divdf3vfp(10.0, -2.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/divsf3vfp_test.c
View File

@ -41,6 +41,8 @@ int main()
return 1;
if (test__divsf3vfp(10.0, -2.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/divtc3_test.c
View File

@ -375,6 +375,8 @@ int main()
// printf("No errors found.\n");
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/divti3_test.c
View File

@ -71,6 +71,8 @@ int main()
if (test__divti3(make_ti(0x8000000000000000LL, 0), 2, make_ti(0xC000000000000000LL, 0)))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/divxc3_test.c
View File

@ -372,6 +372,8 @@ int main()
}
}
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/eqdf2vfp_test.c
View File

@ -48,6 +48,8 @@ int main()
return 1;
if (test__eqdf2vfp(1.0, HUGE_VAL))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/eqsf2vfp_test.c
View File

@ -44,6 +44,8 @@ int main()
return 1;
if (test__eqsf2vfp(1.0, HUGE_VALF))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/extebdsfdf2vfp_test.c
View File

@ -41,6 +41,8 @@ int main()
return 1;
if (test__extendsfdf2vfp(3.1415926535))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/ffsti2_test.c
View File

@ -76,6 +76,8 @@ int main()
if (test__ffsti2(make_ti(0x8000000000000000uLL, 0), 128))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/fixdfsivfp_test.c
View File

@ -43,6 +43,8 @@ int main()
return 1;
if (test__fixdfsivfp(-2147483648.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/fixdfti_test.c
View File

@ -116,6 +116,8 @@ int main()
if (test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, make_ti(0x8000000000000800LL, 0)))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

2
test/Unit/fixsfsivfp_test.c
View File

@ -45,6 +45,8 @@ int main()
return 1;
if (test__fixsfsivfp(65536.0))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}

Some files were not shown because too many files have changed in this diff Show More