This is an archive of the discontinued LLVM Phabricator instance.

Differential D3731

[compiler-rt] Move arm vfp builtins to their own folder
AbandonedPublic

Authored by jroelofs on May 12 2014, 1:31 PM.

Details

Reviewers
compnerd
Summary

This makes armv4 platform support easier.

Diff Detail

Event Timeline

jroelofs updated this revision to Diff 9324.May 12 2014, 1:31 PM
jroelofs retitled this revision from to [compiler-rt] Move arm vfp builtins to their own folder.
jroelofs updated this object.
jroelofs edited the test plan for this revision. (Show Details)
jroelofs added a reviewer: compnerd.
jroelofs added subscribers: Unknown Object (MLST), Unknown Object (MLST).
Herald added a subscriber: aemerson. · View Herald TranscriptMay 12 2014, 1:31 PM
jroelofs updated this revision to Diff 9326.May 12 2014, 2:29 PM

Forgot to svn add lib/builtins/arm/vfp/Makefile.mk before diffing.

compnerd added inline comments.May 12 2014, 5:29 PM
lib/builtins/arm/vfp/adddf3vfp.S
10

Im tempted to say that we should adjust the CPPFLAGS to include $(top_srcdir)/lib/builtins in the include search path and make this into:

#include "assembly.h"

We certainly do similar things on the LLVM side where we assume that $(top_srcdir)/include is in the search path for headers. I don't think that the minor discomfort of gf no longer working in vim is a huge loss.

jroelofs added inline comments.May 12 2014, 5:45 PM
lib/builtins/arm/vfp/adddf3vfp.S
10

Yeah, I'm not a huge fan of '../' in include paths either, but I don't feel comfortable enough with compiler-rt's makefiles to make that change.... they're quite complicated :)

rengolin added a subscriber: rengolin.May 13 2014, 12:54 AM

The change looks good, though I agree we should change the include path, this is getting out of hand.

cheers,
--renato

jroelofs added a comment.May 13 2014, 6:31 PM

Compnerd made an interesting point yesterday that maybe the new folder ought to be named 'softfp'. That way we aren't naming it off of an ISA feature, but rather an ABI. Thoughts?

Also, what are your thoughts on dropping the 'vfp' from the filenames in the move?

rengolin added a comment.May 14 2014, 12:48 AM

I agree softfp is a good idea. Also, to remove the vfp from the name.

cheers,
--renato

jroelofs abandoned this revision.Aug 27 2015, 8:27 AM

Revision Contents

Diff 9326

lib/builtins/arm/Makefile.mk

Context not available.
#===------------------------------------------------------------------------===# #===------------------------------------------------------------------------===#
ModuleName := builtins ModuleName := builtins
SubDirs := SubDirs := vfp
OnlyArchs := armv5 armv6 armv7 armv7k armv7m armv7em armv7s OnlyArchs := armv5 armv6 armv7 armv7k armv7m armv7em armv7s
AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file))) AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
Context not available.

lib/builtins/arm/addsf3vfp.S

//===-- addsf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __addsf3vfp(float a, float b);
//
// Adds two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed in GPRs
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__addsf3vfp)
vmov s14, r0 // move first param from r0 into float register
vmov s15, r1 // move second param from r1 into float register
vadd.f32 s14, s14, s15
vmov r0, s14 // move result back to r0
bx lr
END_COMPILERRT_FUNCTION(__addsf3vfp)

lib/builtins/arm/divdf3vfp.S

//===-- divdf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __divdf3vfp(double a, double b);
//
// Divides two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__divdf3vfp)
vmov d6, r0, r1 // move first param from r0/r1 pair into d6
vmov d7, r2, r3 // move second param from r2/r3 pair into d7
vdiv.f64 d5, d6, d7
vmov r0, r1, d5 // move result back to r0/r1 pair
bx lr
END_COMPILERRT_FUNCTION(__divdf3vfp)

lib/builtins/arm/divsf3vfp.S

//===-- divsf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __divsf3vfp(float a, float b);
//
// Divides two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__divsf3vfp)
vmov s14, r0 // move first param from r0 into float register
vmov s15, r1 // move second param from r1 into float register
vdiv.f32 s13, s14, s15
vmov r0, s13 // move result back to r0
bx lr
END_COMPILERRT_FUNCTION(__divsf3vfp)

lib/builtins/arm/eqdf2vfp.S

//===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __eqdf2vfp(double a, double b);
//
// Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
moveq r0, #1 // set result register to 1 if equal
movne r0, #0
bx lr
END_COMPILERRT_FUNCTION(__eqdf2vfp)

lib/builtins/arm/eqsf2vfp.S

//===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __eqsf2vfp(float a, float b);
//
// Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
moveq r0, #1 // set result register to 1 if equal
movne r0, #0
bx lr
END_COMPILERRT_FUNCTION(__eqsf2vfp)

lib/builtins/arm/extendsfdf2vfp.S

//===-- extendsfdf2vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __extendsfdf2vfp(float a);
//
// Converts single precision float to double precision result.
// 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.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp)
vmov s15, r0 // load float register from R0
vcvt.f64.f32 d7, s15 // convert single to double
vmov r0, r1, d7 // return result in r0/r1 pair
bx lr
END_COMPILERRT_FUNCTION(__extendsfdf2vfp)

lib/builtins/arm/fixdfsivfp.S

//===-- fixdfsivfp.S - Implement fixdfsivfp -----------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __fixdfsivfp(double a);
//
// Converts double precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp)
vmov d7, r0, r1 // load double register from R0/R1
vcvt.s32.f64 s15, d7 // convert double to 32-bit int into s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__fixdfsivfp)

lib/builtins/arm/fixsfsivfp.S

//===-- fixsfsivfp.S - Implement fixsfsivfp -----------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __fixsfsivfp(float a);
//
// Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision parameter is
// passed in a GPR..
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp)
vmov s15, r0 // load float register from R0
vcvt.s32.f32 s15, s15 // convert single to 32-bit int into s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__fixsfsivfp)

lib/builtins/arm/fixunsdfsivfp.S

//===-- fixunsdfsivfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern unsigned int __fixunsdfsivfp(double a);
//
// Converts double precision float to a 32-bit unsigned int rounding towards
// zero. All negative values become zero.
// Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp)
vmov d7, r0, r1 // load double register from R0/R1
vcvt.u32.f64 s15, d7 // convert double to 32-bit int into s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__fixunsdfsivfp)

lib/builtins/arm/fixunssfsivfp.S

//===-- fixunssfsivfp.S - Implement fixunssfsivfp -------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern unsigned int __fixunssfsivfp(float a);
//
// Converts single precision float to a 32-bit unsigned int rounding towards
// zero. All negative values become zero.
// Uses Darwin calling convention where a single precision parameter is
// passed in a GPR..
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp)
vmov s15, r0 // load float register from R0
vcvt.u32.f32 s15, s15 // convert single to 32-bit unsigned into s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__fixunssfsivfp)

lib/builtins/arm/floatsidfvfp.S

//===-- floatsidfvfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __floatsidfvfp(int a);
//
// Converts a 32-bit int to a double precision float.
// Uses Darwin calling convention where a double precision result is
// return in GPR register pair.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp)
vmov s15, r0 // move int to float register s15
vcvt.f64.s32 d7, s15 // convert 32-bit int in s15 to double in d7
vmov r0, r1, d7 // move d7 to result register pair r0/r1
bx lr
END_COMPILERRT_FUNCTION(__floatsidfvfp)

lib/builtins/arm/floatsisfvfp.S

//===-- floatsisfvfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __floatsisfvfp(int a);
//
// Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision result is
// return in a GPR..
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp)
vmov s15, r0 // move int to float register s15
vcvt.f32.s32 s15, s15 // convert 32-bit int in s15 to float in s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__floatsisfvfp)

lib/builtins/arm/floatunssidfvfp.S

//===-- floatunssidfvfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __floatunssidfvfp(unsigned int a);
//
// Converts a 32-bit int to a double precision float.
// Uses Darwin calling convention where a double precision result is
// return in GPR register pair.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp)
vmov s15, r0 // move int to float register s15
vcvt.f64.u32 d7, s15 // convert 32-bit int in s15 to double in d7
vmov r0, r1, d7 // move d7 to result register pair r0/r1
bx lr
END_COMPILERRT_FUNCTION(__floatunssidfvfp)

lib/builtins/arm/floatunssisfvfp.S

//===-- floatunssisfvfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __floatunssisfvfp(unsigned int a);
//
// Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision result is
// return in a GPR..
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp)
vmov s15, r0 // move int to float register s15
vcvt.f32.u32 s15, s15 // convert 32-bit int in s15 to float in s15
vmov r0, s15 // move s15 to result register
bx lr
END_COMPILERRT_FUNCTION(__floatunssisfvfp)

lib/builtins/arm/gedf2vfp.S

//===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __gedf2vfp(double a, double b);
//
// Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movge r0, #1 // set result register to 1 if greater than or equal
movlt r0, #0
bx lr
END_COMPILERRT_FUNCTION(__gedf2vfp)

lib/builtins/arm/gesf2vfp.S

//===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __gesf2vfp(float a, float b);
//
// Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movge r0, #1 // set result register to 1 if greater than or equal
movlt r0, #0
bx lr
END_COMPILERRT_FUNCTION(__gesf2vfp)

lib/builtins/arm/gtdf2vfp.S

//===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __gtdf2vfp(double a, double b);
//
// Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movgt r0, #1 // set result register to 1 if equal
movle r0, #0
bx lr
END_COMPILERRT_FUNCTION(__gtdf2vfp)

lib/builtins/arm/gtsf2vfp.S

//===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __gtsf2vfp(float a, float b);
//
// Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movgt r0, #1 // set result register to 1 if equal
movle r0, #0
bx lr
END_COMPILERRT_FUNCTION(__gtsf2vfp)

lib/builtins/arm/ledf2vfp.S

//===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __ledf2vfp(double a, double b);
//
// Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movls r0, #1 // set result register to 1 if equal
movhi r0, #0
bx lr
END_COMPILERRT_FUNCTION(__ledf2vfp)

lib/builtins/arm/lesf2vfp.S

//===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __lesf2vfp(float a, float b);
//
// Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movls r0, #1 // set result register to 1 if equal
movhi r0, #0
bx lr
END_COMPILERRT_FUNCTION(__lesf2vfp)

lib/builtins/arm/ltdf2vfp.S

//===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __ltdf2vfp(double a, double b);
//
// Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movmi r0, #1 // set result register to 1 if equal
movpl r0, #0
bx lr
END_COMPILERRT_FUNCTION(__ltdf2vfp)

lib/builtins/arm/ltsf2vfp.S

//===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __ltsf2vfp(float a, float b);
//
// Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movmi r0, #1 // set result register to 1 if equal
movpl r0, #0
bx lr
END_COMPILERRT_FUNCTION(__ltsf2vfp)

lib/builtins/arm/muldf3vfp.S

//===-- muldf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __muldf3vfp(double a, double b);
//
// Multiplies two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__muldf3vfp)
vmov d6, r0, r1 // move first param from r0/r1 pair into d6
vmov d7, r2, r3 // move second param from r2/r3 pair into d7
vmul.f64 d6, d6, d7
vmov r0, r1, d6 // move result back to r0/r1 pair
bx lr
END_COMPILERRT_FUNCTION(__muldf3vfp)

lib/builtins/arm/mulsf3vfp.S

//===-- mulsf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __mulsf3vfp(float a, float b);
//
// Multiplies two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp)
vmov s14, r0 // move first param from r0 into float register
vmov s15, r1 // move second param from r1 into float register
vmul.f32 s13, s14, s15
vmov r0, s13 // move result back to r0
bx lr
END_COMPILERRT_FUNCTION(__mulsf3vfp)

lib/builtins/arm/nedf2vfp.S

//===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __nedf2vfp(double a, double b);
//
// Returns zero if a and b are unequal and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movne r0, #1 // set result register to 0 if unequal
moveq r0, #0
bx lr
END_COMPILERRT_FUNCTION(__nedf2vfp)

lib/builtins/arm/negdf2vfp.S

//===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __negdf2vfp(double a, double b);
//
// Returns the negation a double precision floating point numbers using the
// Darwin calling convention where double arguments are passsed in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair
bx lr
END_COMPILERRT_FUNCTION(__negdf2vfp)

lib/builtins/arm/negsf2vfp.S

//===-- negsf2vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __negsf2vfp(float a);
//
// Returns the negation of a single precision floating point numbers using the
// Darwin calling convention where single arguments are passsed like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
eor r0, r0, #-2147483648 // flip sign bit on float in r0
bx lr
END_COMPILERRT_FUNCTION(__negsf2vfp)

lib/builtins/arm/nesf2vfp.S

//===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __nesf2vfp(float a, float b);
//
// Returns one iff a != b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movne r0, #1 // set result register to 1 if unequal
moveq r0, #0
bx lr
END_COMPILERRT_FUNCTION(__nesf2vfp)

lib/builtins/arm/restore_vfp_d8_d15_regs.S

//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// When compiling C++ functions that need to handle thrown exceptions the
// compiler is required to save all registers and call __Unwind_SjLj_Register
// in the function prolog. But when compiling for thumb1, there are
// no instructions to access the floating point registers, so the
// compiler needs to add a call to the helper function _save_vfp_d8_d15_regs
// written in ARM to save the float registers. In the epilog, the compiler
// must also add a call to __restore_vfp_d8_d15_regs to restore those registers.
//
.text
.syntax unified
//
// Restore registers d8-d15 from stack
//
.p2align 2
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__restore_vfp_d8_d15_regs)
vldmia sp!, {d8-d15} // pop registers d8-d15 off stack
bx lr // return to prolog
END_COMPILERRT_FUNCTION(__restore_vfp_d8_d15_regs)

lib/builtins/arm/save_vfp_d8_d15_regs.S

//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// When compiling C++ functions that need to handle thrown exceptions the
// compiler is required to save all registers and call __Unwind_SjLj_Register
// in the function prolog. But when compiling for thumb1, there are
// no instructions to access the floating point registers, so the
// compiler needs to add a call to the helper function _save_vfp_d8_d15_regs
// written in ARM to save the float registers. In the epilog, the compiler
// must also add a call to __restore_vfp_d8_d15_regs to restore those registers.
//
.text
.syntax unified
//
// Save registers d8-d15 onto stack
//
.p2align 2
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__save_vfp_d8_d15_regs)
vstmdb sp!, {d8-d15} // push registers d8-d15 onto stack
bx lr // return to prolog
END_COMPILERRT_FUNCTION(__save_vfp_d8_d15_regs)

lib/builtins/arm/subdf3vfp.S

//===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern double __subdf3vfp(double a, double b);
//
// Returns difference between two double precision floating point numbers using
// the Darwin calling convention where double arguments are passsed in GPR pairs
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
vmov d6, r0, r1 // move first param from r0/r1 pair into d6
vmov d7, r2, r3 // move second param from r2/r3 pair into d7
vsub.f64 d6, d6, d7
vmov r0, r1, d6 // move result back to r0/r1 pair
bx lr
END_COMPILERRT_FUNCTION(__subdf3vfp)

lib/builtins/arm/subsf3vfp.S

//===-- subsf3vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __subsf3vfp(float a, float b);
//
// Returns the difference between two single precision floating point numbers
// using the Darwin calling convention where single arguments are passsed
// like 32-bit ints.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__subsf3vfp)
vmov s14, r0 // move first param from r0 into float register
vmov s15, r1 // move second param from r1 into float register
vsub.f32 s14, s14, s15
vmov r0, s14 // move result back to r0
bx lr
END_COMPILERRT_FUNCTION(__subsf3vfp)

lib/builtins/arm/truncdfsf2vfp.S

//===-- truncdfsf2vfp.S - Implement 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern float __truncdfsf2vfp(double a);
//
// Converts double precision float to signle precision result.
// 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.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
vmov d7, r0, r1 // load double from r0/r1 pair
vcvt.f32.f64 s15, d7 // convert double to single (trucate precision)
vmov r0, s15 // return result in r0
bx lr
END_COMPILERRT_FUNCTION(__truncdfsf2vfp)

lib/builtins/arm/unorddf2vfp.S

//===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __unorddf2vfp(double a, double b);
//
// Returns one iff a or b is NaN
// Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs.
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7
vmrs apsr_nzcv, fpscr
movvs r0, #1 // set result register to 1 if "overflow" (any NaNs)
movvc r0, #0
bx lr
END_COMPILERRT_FUNCTION(__unorddf2vfp)

lib/builtins/arm/unordsf2vfp.S

//===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "../assembly.h"
//
// extern int __unordsf2vfp(float a, float b);
//
// Returns one iff a or b is NaN
// Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints
//
.syntax unified
.p2align 2
DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
vmov s14, r0 // move from GPR 0 to float register
vmov s15, r1 // move from GPR 1 to float register
vcmp.f32 s14, s15
vmrs apsr_nzcv, fpscr
movvs r0, #1 // set result register to 1 if "overflow" (any NaNs)
movvc r0, #0
bx lr
END_COMPILERRT_FUNCTION(__unordsf2vfp)

lib/builtins/arm/vfp/Makefile.mk

#===- lib/builtins/arm/Makefile.mk -------------------------*- Makefile -*--===#
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===------------------------------------------------------------------------===#
ModuleName := builtins
SubDirs :=
OnlyArchs := armv5 armv6 armv7 armv7k armv7m armv7em armv7s
AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
Implementation := Optimized
# FIXME: use automatic dependencies?
Dependencies := $(wildcard lib/*.h $(Dir)/*.h)

lib/builtins/arm/vfp/adddf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
compnerdUnsubmitted
Not Done
ReplyInline Actions

Im tempted to say that we should adjust the CPPFLAGS to include $(top_srcdir)/lib/builtins in the include search path and make this into:

#include "assembly.h"

We certainly do similar things on the LLVM side where we assume that $(top_srcdir)/include is in the search path for headers. I don't think that the minor discomfort of gf no longer working in vim is a huge loss.

compnerd: Im tempted to say that we should adjust the CPPFLAGS to include $(top_srcdir)/lib/builtins in…
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

Yeah, I'm not a huge fan of '../' in include paths either, but I don't feel comfortable enough with compiler-rt's makefiles to make that change.... they're quite complicated :)

jroelofs: Yeah, I'm not a huge fan of '../' in include paths either, but I don't feel comfortable enough…
// //
// double __adddf3vfp(double a, double b) { return a + b; } // double __adddf3vfp(double a, double b) { return a + b; }
Context not available.

lib/builtins/arm/vfp/addsf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __addsf3vfp(float a, float b); // extern float __addsf3vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/divdf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __divdf3vfp(double a, double b); // extern double __divdf3vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/divsf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __divsf3vfp(float a, float b); // extern float __divsf3vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/eqdf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __eqdf2vfp(double a, double b); // extern int __eqdf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/eqsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __eqsf2vfp(float a, float b); // extern int __eqsf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/extendsfdf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __extendsfdf2vfp(float a); // extern double __extendsfdf2vfp(float a);
Context not available.

lib/builtins/arm/vfp/fixdfsivfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __fixdfsivfp(double a); // extern int __fixdfsivfp(double a);
Context not available.

lib/builtins/arm/vfp/fixsfsivfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __fixsfsivfp(float a); // extern int __fixsfsivfp(float a);
Context not available.

lib/builtins/arm/vfp/fixunsdfsivfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern unsigned int __fixunsdfsivfp(double a); // extern unsigned int __fixunsdfsivfp(double a);
Context not available.

lib/builtins/arm/vfp/fixunssfsivfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern unsigned int __fixunssfsivfp(float a); // extern unsigned int __fixunssfsivfp(float a);
Context not available.

lib/builtins/arm/vfp/floatsidfvfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __floatsidfvfp(int a); // extern double __floatsidfvfp(int a);
Context not available.

lib/builtins/arm/vfp/floatsisfvfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __floatsisfvfp(int a); // extern float __floatsisfvfp(int a);
Context not available.

lib/builtins/arm/vfp/floatunssidfvfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __floatunssidfvfp(unsigned int a); // extern double __floatunssidfvfp(unsigned int a);
Context not available.

lib/builtins/arm/vfp/floatunssisfvfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __floatunssisfvfp(unsigned int a); // extern float __floatunssisfvfp(unsigned int a);
Context not available.

lib/builtins/arm/vfp/gedf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __gedf2vfp(double a, double b); // extern int __gedf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/gesf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __gesf2vfp(float a, float b); // extern int __gesf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/gtdf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __gtdf2vfp(double a, double b); // extern double __gtdf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/gtsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __gtsf2vfp(float a, float b); // extern int __gtsf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/ledf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __ledf2vfp(double a, double b); // extern double __ledf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/lesf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __lesf2vfp(float a, float b); // extern int __lesf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/ltdf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __ltdf2vfp(double a, double b); // extern double __ltdf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/ltsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __ltsf2vfp(float a, float b); // extern int __ltsf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/muldf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __muldf3vfp(double a, double b); // extern double __muldf3vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/mulsf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __mulsf3vfp(float a, float b); // extern float __mulsf3vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/nedf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __nedf2vfp(double a, double b); // extern double __nedf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/negdf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __negdf2vfp(double a, double b); // extern double __negdf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/negsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __negsf2vfp(float a); // extern float __negsf2vfp(float a);
Context not available.

lib/builtins/arm/vfp/nesf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __nesf2vfp(float a, float b); // extern int __nesf2vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/restore_vfp_d8_d15_regs.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// When compiling C++ functions that need to handle thrown exceptions the // When compiling C++ functions that need to handle thrown exceptions the
Context not available.

lib/builtins/arm/vfp/save_vfp_d8_d15_regs.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// When compiling C++ functions that need to handle thrown exceptions the // When compiling C++ functions that need to handle thrown exceptions the
Context not available.

lib/builtins/arm/vfp/subdf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern double __subdf3vfp(double a, double b); // extern double __subdf3vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/subsf3vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __subsf3vfp(float a, float b); // extern float __subsf3vfp(float a, float b);
Context not available.

lib/builtins/arm/vfp/truncdfsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern float __truncdfsf2vfp(double a); // extern float __truncdfsf2vfp(double a);
Context not available.

lib/builtins/arm/vfp/unorddf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __unorddf2vfp(double a, double b); // extern int __unorddf2vfp(double a, double b);
Context not available.

lib/builtins/arm/vfp/unordsf2vfp.S

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../../assembly.h"
// //
// extern int __unordsf2vfp(float a, float b); // extern int __unordsf2vfp(float a, float b);
Context not available.
lib/builtins/arm/unorddf2vfp.S