maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Switch to using DEFINE_COMPILERRT_[PRIVATE_]FUNCTION to define function symbols inside .S files. 

llvm-svn: 85264
This commit is contained in:
Daniel Dunbar 2009-10-27 17:50:21 +00:00
parent 7d50478889
commit 9ff9371bb7
56 changed files with 66 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler-rt/lib/arm/adddf3vfp.S
View File

@ -15,8 +15,7 @@
// Adds two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs
//
.globl ___adddf3vfp
___adddf3vfp:
DEFINE_COMPILERRT_FUNCTION(__adddf3vfp)
fmdrr d6, r0, r1 // move first param from r0/r1 pair into d6
fmdrr d7, r2, r3 // move second param from r2/r3 pair into d7
faddd d6, d6, d7

3
compiler-rt/lib/arm/addsf3vfp.S
View File

@ -15,8 +15,7 @@
// Adds two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed in GPRs
//
.globl ___addsf3vfp
___addsf3vfp:
DEFINE_COMPILERRT_FUNCTION(__addsf3vfp)
fmsr s14, r0 // move first param from r0 into float register
fmsr s15, r1 // move second param from r1 into float register
fadds s14, s14, s15

3
compiler-rt/lib/arm/bswapdi2.S
View File

@ -14,8 +14,7 @@
//
// Reverse all the bytes in a 64-bit integer.
//
.globl ___bswapdi2
___bswapdi2:
DEFINE_COMPILERRT_FUNCTION(__bswapdi2)
rev r2, r1 // reverse bytes in high 32-bits into temp2
rev r3, r0 // reverse bytes in low 32-bit into temp3
mov r0, r2 // set low 32-bits of result to temp2

3
compiler-rt/lib/arm/bswapsi2.S
View File

@ -14,7 +14,6 @@
//
// Reverse all the bytes in a 32-bit integer.
//
.globl ___bswapsi2
___bswapsi2:
DEFINE_COMPILERRT_FUNCTION(__bswapsi2)
rev r0, r0 // reverse bytes in parameter and put into result register
bx lr

3
compiler-rt/lib/arm/divdf3vfp.S
View File

@ -15,8 +15,7 @@
// Divides two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs
//
.globl ___divdf3vfp
___divdf3vfp:
DEFINE_COMPILERRT_FUNCTION(__divdf3vfp)
fmdrr d6, r0, r1 // move first param from r0/r1 pair into d6
fmdrr d7, r2, r3 // move second param from r2/r3 pair into d7
fdivd d5, d6, d7

3
compiler-rt/lib/arm/divsf3vfp.S
View File

@ -15,8 +15,7 @@
// Divides two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints.
//
.globl ___divsf3vfp
___divsf3vfp:
DEFINE_COMPILERRT_FUNCTION(__divsf3vfp)
fmsr s14, r0 // move first param from r0 into float register
fmsr s15, r1 // move second param from r1 into float register
fdivs s13, s14, s15

3
compiler-rt/lib/arm/eqdf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___eqdf2vfp
___eqdf2vfp:
DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/eqsf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___eqsf2vfp
___eqsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/extendsfdf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a single precision parameter is
// passed in a GPR and a double precision result is returned in R0/R1 pair.
//
.globl ___extendsfdf2vfp
___extendsfdf2vfp:
DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp)
fmsr s15, r0 // load float register from R0
fcvtds d7, s15 // convert single to double
fmrrd r0, r1, d7 // return result in r0/r1 pair

3
compiler-rt/lib/arm/fixdfsivfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair.
//
.globl ___fixdfsivfp
___fixdfsivfp:
DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp)
fmdrr d7, r0, r1 // load double register from R0/R1
ftosizd s15, d7 // convert double to 32-bit int into s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/fixsfsivfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a single precision parameter is
// passed in a GPR..
//
.globl ___fixsfsivfp
___fixsfsivfp:
DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp)
fmsr s15, r0 // load float register from R0
ftosizs s15, s15 // convert single to 32-bit int into s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/fixunsdfsivfp.S
View File

@ -17,8 +17,7 @@
// Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair.
//
.globl ___fixunsdfsivfp
___fixunsdfsivfp:
DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp)
fmdrr d7, r0, r1 // load double register from R0/R1
ftouizd s15, d7 // convert double to 32-bit int into s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/fixunssfsivfp.S
View File

@ -17,8 +17,7 @@
// Uses Darwin calling convention where a single precision parameter is
// passed in a GPR..
//
.globl ___fixunssfsivfp
___fixunssfsivfp:
DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp)
fmsr s15, r0 // load float register from R0
ftouizs s15, s15 // convert single to 32-bit unsigned into s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/floatsidfvfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a double precision result is
// return in GPR register pair.
//
.globl ___floatsidfvfp
___floatsidfvfp:
DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp)
fmsr s15, r0 // move int to float register s15
fsitod d7, s15 // convert 32-bit int in s15 to double in d7
fmrrd r0, r1, d7 // move d7 to result register pair r0/r1

3
compiler-rt/lib/arm/floatsisfvfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a single precision result is
// return in a GPR..
//
.globl ___floatsisfvfp
___floatsisfvfp:
DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp)
fmsr s15, r0 // move int to float register s15
fsitos s15, s15 // convert 32-bit int in s15 to float in s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/floatunssidfvfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a double precision result is
// return in GPR register pair.
//
.globl ___floatunssidfvfp
___floatunssidfvfp:
DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp)
fmsr s15, r0 // move int to float register s15
fuitod d7, s15 // convert 32-bit int in s15 to double in d7
fmrrd r0, r1, d7 // move d7 to result register pair r0/r1

3
compiler-rt/lib/arm/floatunssisfvfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a single precision result is
// return in a GPR..
//
.globl ___floatunssisfvfp
___floatunssisfvfp:
DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp)
fmsr s15, r0 // move int to float register s15
fuitos s15, s15 // convert 32-bit int in s15 to float in s15
fmrs r0, s15 // move s15 to result register

3
compiler-rt/lib/arm/gedf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___gedf2vfp
___gedf2vfp:
DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/gesf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___gesf2vfp
___gesf2vfp:
DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/gtdf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___gtdf2vfp
___gtdf2vfp:
DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/gtsf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___gtsf2vfp
___gtsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/ledf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___ledf2vfp
___ledf2vfp:
DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/lesf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___lesf2vfp
___lesf2vfp:
DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/ltdf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___ltdf2vfp
___ltdf2vfp:
DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/ltsf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___ltsf2vfp
___ltsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/muldf3vfp.S
View File

@ -15,8 +15,7 @@
// Multiplies two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs
//
.globl ___muldf3vfp
___muldf3vfp:
DEFINE_COMPILERRT_FUNCTION(__muldf3vfp)
fmdrr d6, r0, r1 // move first param from r0/r1 pair into d6
fmdrr d7, r2, r3 // move second param from r2/r3 pair into d7
fmuld d6, d6, d7

3
compiler-rt/lib/arm/mulsf3vfp.S
View File

@ -15,8 +15,7 @@
// Multiplies two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints.
//
.globl ___mulsf3vfp
___mulsf3vfp:
DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp)
fmsr s14, r0 // move first param from r0 into float register
fmsr s15, r1 // move second param from r1 into float register
fmuls s13, s14, s15

3
compiler-rt/lib/arm/nedf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___nedf2vfp
___nedf2vfp:
DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/negdf2vfp.S
View File

@ -15,7 +15,6 @@
// Returns the negation a double precision floating point numbers using the
// Darwin calling convention where double arguments are passsed in GPR pairs.
//
.globl ___negdf2vfp
___negdf2vfp:
DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair
bx lr

3
compiler-rt/lib/arm/negsf2vfp.S
View File

@ -15,7 +15,6 @@
// Returns the negation of a single precision floating point numbers using the
// Darwin calling convention where single arguments are passsed like 32-bit ints
//
.globl ___negsf2vfp
___negsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
eor r0, r0, #-2147483648 // flip sign bit on float in r0
bx lr

3
compiler-rt/lib/arm/nesf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___nesf2vfp
___nesf2vfp:
DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

3
compiler-rt/lib/arm/subdf3vfp.S
View File

@ -15,8 +15,7 @@
// Returns difference between two double precision floating point numbers using
// the Darwin calling convention where double arguments are passsed in GPR pairs
//
.globl ___subdf3vfp
___subdf3vfp:
DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
fmdrr d6, r0, r1 // move first param from r0/r1 pair into d6
fmdrr d7, r2, r3 // move second param from r2/r3 pair into d7
fsubd d6, d6, d7

3
compiler-rt/lib/arm/subsf3vfp.S
View File

@ -16,8 +16,7 @@
// using the Darwin calling convention where single arguments are passsed
// like 32-bit ints.
//
.globl ___subsf3vfp
___subsf3vfp:
DEFINE_COMPILERRT_FUNCTION(__subsf3vfp)
fmsr s14, r0 // move first param from r0 into float register
fmsr s15, r1 // move second param from r1 into float register
fsubs s14, s14, s15

16
compiler-rt/lib/arm/switch.S
View File

@ -29,9 +29,7 @@
// The table contains unsigned byte sized elements which are 1/2 the distance
// from lr to the target label.
//
.globl ___switchu8
.private_extern ___switchu8
___switchu8:
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switchu8)
ldrb ip, [lr, #-1] // get first byte in table
cmp r0, ip // compare with index
ldrbcc r0, [lr, r0] // get indexed byte out of table
@ -45,9 +43,7 @@ ___switchu8:
// The table contains signed byte sized elements which are 1/2 the distance
// from lr to the target label.
//
.globl ___switch8
.private_extern ___switch8
___switch8:
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch8)
ldrb ip, [lr, #-1] // get first byte in table
cmp r0, ip // signed compare with index
ldrsbcc r0, [lr, r0] // get indexed byte out of table
@ -60,9 +56,7 @@ ___switch8:
// The table contains signed 2-byte sized elements which are 1/2 the distance
// from lr to the target label.
//
.globl ___switch16
.private_extern ___switch16
___switch16:
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch16)
ldrh ip, [lr, #-1] // get first 16-bit word in table
cmp r0, ip // compare with index
add r0, lr, r0, lsl #1 // compute address of element in table
@ -77,9 +71,7 @@ ___switch16:
// The table contains signed 4-byte sized elements which are the distance
// from lr to the target label.
//
.globl ___switch32
.private_extern ___switch32
___switch32:
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch32)
ldr ip, [lr, #-1] // get first 32-bit word in table
cmp r0, ip // compare with index
add r0, lr, r0, lsl #2 // compute address of element in table

3
compiler-rt/lib/arm/truncdfsf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where a double precision parameter is
// passed in a R0/R1 pair and a signle precision result is returned in R0.
//
.globl ___truncdfsf2vfp
___truncdfsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
fmdrr d7, r0, r1 // load double from r0/r1 pair
fcvtsd s15, d7 // convert double to single (trucate precision)
fmrs r0, s15 // return result in r0

3
compiler-rt/lib/arm/unorddf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.globl ___unorddf2vfp
___unorddf2vfp:
DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
fmdrr d6, r0, r1 // load r0/r1 pair in double register
fmdrr d7, r2, r3 // load r2/r3 pair in double register
fcmpd d6, d7

3
compiler-rt/lib/arm/unordsf2vfp.S
View File

@ -16,8 +16,7 @@
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.globl ___unordsf2vfp
___unordsf2vfp:
DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
fmsr s14, r0 // move from GPR 0 to float register
fmsr s15, r1 // move from GPR 1 to float register
fcmps s14, s15

6
compiler-rt/lib/i386/ashldi3.S
View File

@ -17,8 +17,7 @@
.text
.align 4
.globl ___ashldi3
___ashldi3:
DEFINE_COMPILERRT_FUNCTION(__ashldi3)
movd 12(%esp), %xmm2 // Load count
#ifndef TRUST_CALLERS_USE_64_BIT_STORES
movd 4(%esp), %xmm0
@ -37,8 +36,7 @@ ___ashldi3:
.text
.align 4
.globl ___ashldi3
___ashldi3:
DEFINE_COMPILERRT_FUNCTION(__ashldi3)
movl 12(%esp), %ecx // Load count
movl 8(%esp), %edx // Load high
movl 4(%esp), %eax // Load low

6
compiler-rt/lib/i386/ashrdi3.S
View File

@ -10,8 +10,7 @@
.text
.align 4
.globl ___ashrdi3
___ashrdi3:
DEFINE_COMPILERRT_FUNCTION(__ashrdi3)
movd 12(%esp), %xmm2 // Load count
movl 8(%esp), %eax
#ifndef TRUST_CALLERS_USE_64_BIT_STORES
@ -47,8 +46,7 @@ ___ashrdi3:
.text
.align 4
.globl ___ashrdi3
___ashrdi3:
DEFINE_COMPILERRT_FUNCTION(__ashrdi3)
movl 12(%esp), %ecx // Load count
movl 8(%esp), %edx // Load high
movl 4(%esp), %eax // Load low

3
compiler-rt/lib/i386/divdi3.S
View File

@ -20,8 +20,7 @@
.text
.align 4
.globl ___divdi3
___divdi3:
DEFINE_COMPILERRT_FUNCTION(__divdi3)
/* This is currently implemented by wrapping the unsigned divide up in an absolute
value, then restoring the correct sign at the end of the computation. This could

3
compiler-rt/lib/i386/floatdidf.S
View File

@ -16,8 +16,7 @@ twop32: .quad 0x41f0000000000000
.text
.align 4
.globl ___floatdidf
___floatdidf:
DEFINE_COMPILERRT_FUNCTION(__floatdidf)
cvtsi2sd 8(%esp), %xmm1
movss 4(%esp), %xmm0 // low 32 bits of a
calll 0f

3
compiler-rt/lib/i386/floatdisf.S
View File

@ -16,8 +16,7 @@
.text
.align 4
.globl ___floatdisf
___floatdisf:
DEFINE_COMPILERRT_FUNCTION(__floatdisf)
#ifndef TRUST_CALLERS_USE_64_BIT_STORES
movd 4(%esp), %xmm0
movd 8(%esp), %xmm1

3
compiler-rt/lib/i386/floatdixf.S
View File

@ -16,8 +16,7 @@
.text
.align 4
.globl ___floatdixf
___floatdixf:
DEFINE_COMPILERRT_FUNCTION(__floatdixf)
#ifndef TRUST_CALLERS_USE_64_BIT_STORES
movd 4(%esp), %xmm0
movd 8(%esp), %xmm1

3
compiler-rt/lib/i386/floatundidf.S
View File

@ -28,8 +28,7 @@ twop84: .quad 0x4530000000000000
.text
.align 4
.globl ___floatundidf
___floatundidf:
DEFINE_COMPILERRT_FUNCTION(__floatundidf)
movss 8(%esp), %xmm1 // high 32 bits of a
movss 4(%esp), %xmm0 // low 32 bits of a
calll 0f

6
compiler-rt/lib/i386/floatundisf.S
View File

@ -28,8 +28,7 @@ twop64: .quad 0x0000000000000000
.text
.align 4
.globl ___floatundisf
___floatundisf:
DEFINE_COMPILERRT_FUNCTION(__floatundisf)
movl 8(%esp), %eax
movd 8(%esp), %xmm1
movd 4(%esp), %xmm0
@ -65,8 +64,7 @@ twelve: .long 0x00000000
.text
.align 4
.globl ___floatundisf
___floatundisf:
DEFINE_COMPILERRT_FUNCTION(__floatundisf)
movl 8(%esp), %eax
movd 8(%esp), %xmm1
movd 4(%esp), %xmm0

3
compiler-rt/lib/i386/floatundixf.S
View File

@ -18,8 +18,7 @@ twop84: .quad 0x4530000000000000
.text
.align 4
.globl ___floatundixf
___floatundixf:
DEFINE_COMPILERRT_FUNCTION(__floatundixf)
calll 0f
0: popl %eax
movss 8(%esp), %xmm0 // hi 32 bits of input

6
compiler-rt/lib/i386/lshrdi3.S
View File

@ -17,8 +17,7 @@
.text
.align 4
.globl ___lshrdi3
___lshrdi3:
DEFINE_COMPILERRT_FUNCTION(__lshrdi3)
movd 12(%esp), %xmm2 // Load count
#ifndef TRUST_CALLERS_USE_64_BIT_STORES
movd 4(%esp), %xmm0
@ -37,8 +36,7 @@ ___lshrdi3:
.text
.align 4
.globl ___lshrdi3
___lshrdi3:
DEFINE_COMPILERRT_FUNCTION(__lshrdi3)
movl 12(%esp), %ecx // Load count
movl 8(%esp), %edx // Load high
movl 4(%esp), %eax // Load low

3
compiler-rt/lib/i386/moddi3.S
View File

@ -21,8 +21,7 @@
.text
.align 4
.globl ___moddi3
___moddi3:
DEFINE_COMPILERRT_FUNCTION(__moddi3)
/* This is currently implemented by wrapping the unsigned modulus up in an absolute
value. This could certainly be improved upon. */

3
compiler-rt/lib/i386/muldi3.S
View File

@ -9,8 +9,7 @@
.text
.align 4
.globl ___muldi3
___muldi3:
DEFINE_COMPILERRT_FUNCTION(__muldi3)
pushl %ebx
movl 16(%esp), %eax // b.lo
movl 12(%esp), %ecx // a.hi

3
compiler-rt/lib/i386/udivdi3.S
View File

@ -20,8 +20,7 @@
.text
.align 4
.globl ___udivdi3
___udivdi3:
DEFINE_COMPILERRT_FUNCTION(__udivdi3)
pushl %ebx
movl 20(%esp), %ebx // Find the index i of the leading bit in b.

3
compiler-rt/lib/i386/umoddi3.S
View File

@ -21,8 +21,7 @@
.text
.align 4
.globl ___umoddi3
___umoddi3:
DEFINE_COMPILERRT_FUNCTION(__umoddi3)
pushl %ebx
movl 20(%esp), %ebx // Find the index i of the leading bit in b.

5
compiler-rt/lib/ppc/restFP.S
View File

@ -19,9 +19,8 @@
// This function should never be exported by a shared library. Each linkage
// unit carries its own copy of this function.
//
.globl restFP
.private_extern restFP
restFP: stfd f14,-144(r1)
DEFINE_COMPILERRT_PRIVATE_FUNCTION(restFP)
stfd f14,-144(r1)
stfd f15,-136(r1)
stfd f16,-128(r1)
stfd f17,-120(r1)

5
compiler-rt/lib/ppc/saveFP.S
View File

@ -17,9 +17,8 @@
// This function should never be exported by a shared library. Each linkage
// unit carries its own copy of this function.
//
.globl saveFP
.private_extern saveFP
saveFP: stfd f14,-144(r1)
DEFINE_COMPILERRT_PRIVATE_FUNCTION(saveFP)
stfd f14,-144(r1)
stfd f15,-136(r1)
stfd f16,-128(r1)
stfd f17,-120(r1)

3
compiler-rt/lib/x86_64/floatundidf.S
View File

@ -28,8 +28,7 @@ twop84: .quad 0x4530000000000000
.text
.align 4
.globl ___floatundidf
___floatundidf:
DEFINE_COMPILERRT_FUNCTION(__floatundidf)
movd %edi, %xmm0 // low 32 bits of a
shrq $32, %rdi // high 32 bits of a
orq REL_ADDR(twop84), %rdi // 0x1p84 + a_hi (no rounding occurs)

3
compiler-rt/lib/x86_64/floatundisf.S
View File

@ -14,8 +14,7 @@ two: .single 2.0
.text
.align 4
.globl ___floatundisf
___floatundisf:
DEFINE_COMPILERRT_FUNCTION(__floatundisf)
movq $1, %rsi
testq %rdi, %rdi
js 1f

6
compiler-rt/lib/x86_64/floatundixf.S
View File

@ -15,8 +15,7 @@ twop64: .quad 0x43f0000000000000
.text
.align 4
.globl ___floatundixf
___floatundixf:
DEFINE_COMPILERRT_FUNCTION(__floatundixf)
movq %rdi, -8(%rsp)
fildq -8(%rsp)
test %rdi, %rdi
@ -44,8 +43,7 @@ twop84: .quad 0x4530000000000000
.text
.align 4
.globl ___floatundixf
___floatundixf:
DEFINE_COMPILERRT_FUNCTION(__floatundixf)
movl %edi, %esi // low 32 bits of input
shrq $32, %rdi // hi 32 bits of input
orq REL_ADDR(twop84), %rdi // 2^84 + hi (as a double)