Mark as 'protected' all the routines from the quad/ and softfloat/ subdirs,

as well as those in arch/arm/gen/divsi3.S.  This cleans up the PLTs on the
32bit archs.

luna88k testing by aoyama@

"looks good" kettenis@, testing and ok deraadt@

1 files changed, 95 insertions, 95 deletions

diff --git a/lib/libc/softfloat/softfloat.h b/lib/libc/softfloat/softfloat.h
index 19b6908751a..815ae8d4a91 100644
--- a/lib/libc/softfloat/softfloat.h
+++ b/lib/libc/softfloat/softfloat.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: softfloat.h,v 1.2 2011/07/05 05:13:21 drahn Exp $	*/
+/*	$OpenBSD: softfloat.h,v 1.3 2019/11/10 22:23:29 guenther Exp $	*/
 /*	$NetBSD: softfloat.h,v 1.6 2002/05/12 13:12:46 bjh21 Exp $	*/
 
 /* This is a derivative work. */
@@ -121,22 +121,22 @@ void float_raise( fp_except );
 Software IEC/IEEE integer-to-floating-point conversion routines.
 -------------------------------------------------------------------------------
 */
-float32 int32_to_float32( int );
-float64 int32_to_float64( int );
+float32 int32_to_float32( int ) __dso_protected;
+float64 int32_to_float64( int ) __dso_protected;
 #ifdef FLOATX80
-floatx80 int32_to_floatx80( int );
+floatx80 int32_to_floatx80( int ) __dso_protected;
 #endif
 #ifdef FLOAT128
-float128 int32_to_float128( int );
+float128 int32_to_float128( int ) __dso_protected;
 #endif
 #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */
-float32 int64_to_float32( long long );
-float64 int64_to_float64( long long );
+float32 int64_to_float32( long long ) __dso_protected;
+float64 int64_to_float64( long long ) __dso_protected;
 #ifdef FLOATX80
-floatx80 int64_to_floatx80( long long );
+floatx80 int64_to_floatx80( long long ) __dso_protected;
 #endif
 #ifdef FLOAT128
-float128 int64_to_float128( long long );
+float128 int64_to_float128( long long ) __dso_protected;
 #endif
 #endif
 
@@ -145,21 +145,21 @@ float128 int64_to_float128( long long );
 Software IEC/IEEE single-precision conversion routines.
 -------------------------------------------------------------------------------
 */
-int float32_to_int32( float32 );
-int float32_to_int32_round_to_zero( float32 );
+int float32_to_int32( float32 ) __dso_protected;
+int float32_to_int32_round_to_zero( float32 ) __dso_protected;
 #if defined(SOFTFLOAT_FOR_GCC) && defined(SOFTFLOAT_NEED_FIXUNS)
-unsigned int float32_to_uint32_round_to_zero( float32 );
+unsigned int float32_to_uint32_round_to_zero( float32 ) __dso_protected;
 #endif
 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */
-long long float32_to_int64( float32 );
-long long float32_to_int64_round_to_zero( float32 );
+long long float32_to_int64( float32 ) __dso_protected;
+long long float32_to_int64_round_to_zero( float32 ) __dso_protected;
 #endif
-float64 float32_to_float64( float32 );
+float64 float32_to_float64( float32 ) __dso_protected;
 #ifdef FLOATX80
-floatx80 float32_to_floatx80( float32 );
+floatx80 float32_to_floatx80( float32 ) __dso_protected;
 #endif
 #ifdef FLOAT128
-float128 float32_to_float128( float32 );
+float128 float32_to_float128( float32 ) __dso_protected;
 #endif
 
 /*
@@ -167,21 +167,21 @@ float128 float32_to_float128( float32 );
 Software IEC/IEEE single-precision operations.
 -------------------------------------------------------------------------------
 */
-float32 float32_round_to_int( float32 );
-float32 float32_add( float32, float32 );
-float32 float32_sub( float32, float32 );
-float32 float32_mul( float32, float32 );
-float32 float32_div( float32, float32 );
-float32 float32_rem( float32, float32 );
-float32 float32_sqrt( float32 );
-int float32_eq( float32, float32 );
-int float32_le( float32, float32 );
-int float32_lt( float32, float32 );
-int float32_eq_signaling( float32, float32 );
-int float32_le_quiet( float32, float32 );
-int float32_lt_quiet( float32, float32 );
+float32 float32_round_to_int( float32 ) __dso_protected;
+float32 float32_add( float32, float32 ) __dso_protected;
+float32 float32_sub( float32, float32 ) __dso_protected;
+float32 float32_mul( float32, float32 ) __dso_protected;
+float32 float32_div( float32, float32 ) __dso_protected;
+float32 float32_rem( float32, float32 ) __dso_protected;
+float32 float32_sqrt( float32 ) __dso_protected;
+int float32_eq( float32, float32 ) __dso_protected;
+int float32_le( float32, float32 ) __dso_protected;
+int float32_lt( float32, float32 ) __dso_protected;
+int float32_eq_signaling( float32, float32 ) __dso_protected;
+int float32_le_quiet( float32, float32 ) __dso_protected;
+int float32_lt_quiet( float32, float32 ) __dso_protected;
 #ifndef SOFTFLOAT_FOR_GCC
-int float32_is_signaling_nan( float32 );
+int float32_is_signaling_nan( float32 ) __dso_protected;
 #endif
 
 /*
@@ -189,21 +189,21 @@ int float32_is_signaling_nan( float32 );
 Software IEC/IEEE double-precision conversion routines.
 -------------------------------------------------------------------------------
 */
-int float64_to_int32( float64 );
-int float64_to_int32_round_to_zero( float64 );
+int float64_to_int32( float64 ) __dso_protected;
+int float64_to_int32_round_to_zero( float64 ) __dso_protected;
 #if defined(SOFTFLOAT_FOR_GCC) && defined(SOFTFLOAT_NEED_FIXUNS)
-unsigned int float64_to_uint32_round_to_zero( float64 );
+unsigned int float64_to_uint32_round_to_zero( float64 ) __dso_protected;
 #endif
 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */
-long long float64_to_int64( float64 );
-long long float64_to_int64_round_to_zero( float64 );
+long long float64_to_int64( float64 ) __dso_protected;
+long long float64_to_int64_round_to_zero( float64 ) __dso_protected;
 #endif
-float32 float64_to_float32( float64 );
+float32 float64_to_float32( float64 ) __dso_protected;
 #ifdef FLOATX80
-floatx80 float64_to_floatx80( float64 );
+floatx80 float64_to_floatx80( float64 ) __dso_protected;
 #endif
 #ifdef FLOAT128
-float128 float64_to_float128( float64 );
+float128 float64_to_float128( float64 ) __dso_protected;
 #endif
 
 /*
@@ -211,21 +211,21 @@ float128 float64_to_float128( float64 );
 Software IEC/IEEE double-precision operations.
 -------------------------------------------------------------------------------
 */
-float64 float64_round_to_int( float64 );
-float64 float64_add( float64, float64 );
-float64 float64_sub( float64, float64 );
-float64 float64_mul( float64, float64 );
-float64 float64_div( float64, float64 );
-float64 float64_rem( float64, float64 );
-float64 float64_sqrt( float64 );
-int float64_eq( float64, float64 );
-int float64_le( float64, float64 );
-int float64_lt( float64, float64 );
-int float64_eq_signaling( float64, float64 );
-int float64_le_quiet( float64, float64 );
-int float64_lt_quiet( float64, float64 );
+float64 float64_round_to_int( float64 ) __dso_protected;
+float64 float64_add( float64, float64 ) __dso_protected;
+float64 float64_sub( float64, float64 ) __dso_protected;
+float64 float64_mul( float64, float64 ) __dso_protected;
+float64 float64_div( float64, float64 ) __dso_protected;
+float64 float64_rem( float64, float64 ) __dso_protected;
+float64 float64_sqrt( float64 ) __dso_protected;
+int float64_eq( float64, float64 ) __dso_protected;
+int float64_le( float64, float64 ) __dso_protected;
+int float64_lt( float64, float64 ) __dso_protected;
+int float64_eq_signaling( float64, float64 ) __dso_protected;
+int float64_le_quiet( float64, float64 ) __dso_protected;
+int float64_lt_quiet( float64, float64 ) __dso_protected;
 #ifndef SOFTFLOAT_FOR_GCC
-int float64_is_signaling_nan( float64 );
+int float64_is_signaling_nan( float64 ) __dso_protected;
 #endif
 
 #ifdef FLOATX80
@@ -235,14 +235,14 @@ int float64_is_signaling_nan( float64 );
 Software IEC/IEEE extended double-precision conversion routines.
 -------------------------------------------------------------------------------
 */
-int floatx80_to_int32( floatx80 );
-int floatx80_to_int32_round_to_zero( floatx80 );
-long long floatx80_to_int64( floatx80 );
-long long floatx80_to_int64_round_to_zero( floatx80 );
-float32 floatx80_to_float32( floatx80 );
-float64 floatx80_to_float64( floatx80 );
+int floatx80_to_int32( floatx80 ) __dso_protected;
+int floatx80_to_int32_round_to_zero( floatx80 ) __dso_protected;
+long long floatx80_to_int64( floatx80 ) __dso_protected;
+long long floatx80_to_int64_round_to_zero( floatx80 ) __dso_protected;
+float32 floatx80_to_float32( floatx80 ) __dso_protected;
+float64 floatx80_to_float64( floatx80 ) __dso_protected;
 #ifdef FLOAT128
-float128 floatx80_to_float128( floatx80 );
+float128 floatx80_to_float128( floatx80 ) __dso_protected;
 #endif
 
 /*
@@ -258,20 +258,20 @@ extern int floatx80_rounding_precision;
 Software IEC/IEEE extended double-precision operations.
 -------------------------------------------------------------------------------
 */
-floatx80 floatx80_round_to_int( floatx80 );
-floatx80 floatx80_add( floatx80, floatx80 );
-floatx80 floatx80_sub( floatx80, floatx80 );
-floatx80 floatx80_mul( floatx80, floatx80 );
-floatx80 floatx80_div( floatx80, floatx80 );
-floatx80 floatx80_rem( floatx80, floatx80 );
-floatx80 floatx80_sqrt( floatx80 );
-int floatx80_eq( floatx80, floatx80 );
-int floatx80_le( floatx80, floatx80 );
-int floatx80_lt( floatx80, floatx80 );
-int floatx80_eq_signaling( floatx80, floatx80 );
-int floatx80_le_quiet( floatx80, floatx80 );
-int floatx80_lt_quiet( floatx80, floatx80 );
-int floatx80_is_signaling_nan( floatx80 );
+floatx80 floatx80_round_to_int( floatx80 ) __dso_protected;
+floatx80 floatx80_add( floatx80, floatx80 ) __dso_protected;
+floatx80 floatx80_sub( floatx80, floatx80 ) __dso_protected;
+floatx80 floatx80_mul( floatx80, floatx80 ) __dso_protected;
+floatx80 floatx80_div( floatx80, floatx80 ) __dso_protected;
+floatx80 floatx80_rem( floatx80, floatx80 ) __dso_protected;
+floatx80 floatx80_sqrt( floatx80 ) __dso_protected;
+int floatx80_eq( floatx80, floatx80 ) __dso_protected;
+int floatx80_le( floatx80, floatx80 ) __dso_protected;
+int floatx80_lt( floatx80, floatx80 ) __dso_protected;
+int floatx80_eq_signaling( floatx80, floatx80 ) __dso_protected;
+int floatx80_le_quiet( floatx80, floatx80 ) __dso_protected;
+int floatx80_lt_quiet( floatx80, floatx80 ) __dso_protected;
+int floatx80_is_signaling_nan( floatx80 ) __dso_protected;
 
 #endif
 
@@ -282,14 +282,14 @@ int floatx80_is_signaling_nan( floatx80 );
 Software IEC/IEEE quadruple-precision conversion routines.
 -------------------------------------------------------------------------------
 */
-int float128_to_int32( float128 );
-int float128_to_int32_round_to_zero( float128 );
-long long float128_to_int64( float128 );
-long long float128_to_int64_round_to_zero( float128 );
-float32 float128_to_float32( float128 );
-float64 float128_to_float64( float128 );
+int float128_to_int32( float128 ) __dso_protected;
+int float128_to_int32_round_to_zero( float128 ) __dso_protected;
+long long float128_to_int64( float128 ) __dso_protected;
+long long float128_to_int64_round_to_zero( float128 ) __dso_protected;
+float32 float128_to_float32( float128 ) __dso_protected;
+float64 float128_to_float64( float128 ) __dso_protected;
 #ifdef FLOATX80
-floatx80 float128_to_floatx80( float128 );
+floatx80 float128_to_floatx80( float128 ) __dso_protected;
 #endif
 
 /*
@@ -297,20 +297,20 @@ floatx80 float128_to_floatx80( float128 );
 Software IEC/IEEE quadruple-precision operations.
 -------------------------------------------------------------------------------
 */
-float128 float128_round_to_int( float128 );
-float128 float128_add( float128, float128 );
-float128 float128_sub( float128, float128 );
-float128 float128_mul( float128, float128 );
-float128 float128_div( float128, float128 );
-float128 float128_rem( float128, float128 );
-float128 float128_sqrt( float128 );
-int float128_eq( float128, float128 );
-int float128_le( float128, float128 );
-int float128_lt( float128, float128 );
-int float128_eq_signaling( float128, float128 );
-int float128_le_quiet( float128, float128 );
-int float128_lt_quiet( float128, float128 );
-int float128_is_signaling_nan( float128 );
+float128 float128_round_to_int( float128 ) __dso_protected;
+float128 float128_add( float128, float128 ) __dso_protected;
+float128 float128_sub( float128, float128 ) __dso_protected;
+float128 float128_mul( float128, float128 ) __dso_protected;
+float128 float128_div( float128, float128 ) __dso_protected;
+float128 float128_rem( float128, float128 ) __dso_protected;
+float128 float128_sqrt( float128 ) __dso_protected;
+int float128_eq( float128, float128 ) __dso_protected;
+int float128_le( float128, float128 ) __dso_protected;
+int float128_lt( float128, float128 ) __dso_protected;
+int float128_eq_signaling( float128, float128 ) __dso_protected;
+int float128_le_quiet( float128, float128 ) __dso_protected;
+int float128_lt_quiet( float128, float128 ) __dso_protected;
+int float128_is_signaling_nan( float128 ) __dso_protected;
 
 #endif