[PING,BZ,#6803] Set errno for scalbln
diff mbox

Message ID ll20fd$8uf$1@ger.gmane.org
State New
Headers show

Commit Message

Stefan Liebler May 15, 2014, 9:13 a.m. UTC
PING!

This patch introduces a new wrapper for scalbln functions
in order to set errno to ERANGE on overflow and underflow.
The existing aliases that uses __scalbln functions are replaced by 
aliases to the new wrapper.
The corresponding tests in libm-test.inc are updated to check for errno 
via ERRNO_PLUS_OFLOW etc.

Please test and give ok for commit.

This patch only covers the scalbln-part of bug 6803.

(The attached file is identical to the posted one from 08.05.2014)

Bye

On 05/08/2014 04:31 PM, Stefan Liebler wrote:
> For these the behaviour is the same like before.
> Errno is not set and the testcases will fail.
>
> Now the scalbln-aliases are removed in i386/m68
> and the wrappers are used when calling the scalbln-functions.
>
> On ia64 only scalblnf has its own implementation.
> For scalbln and scalblnl the ieee754/dbl-64 and ieee754/ldbl-96 are
> used, thus the wrappers are needed, too.
>
> Bye
>
> ---
> 2014-05-08  Stefan Liebler  <stli@linux.vnet.ibm.com>
>
>      [BZ #6803]
>      * math/libm-test.inc (scalbln_test_date):
>      Add errno expectations.
>      * math/w_scalblnf.c: New File.
>      Add wrapper which checks for setting errno to ERANGE.
>      Add weak_alias for corresponding scalbln function.
>      * math/w_scalbln.c: Likewise.
>      * math/w_scalblnl.c: Likewise.
>      * math/Makefile (libm-calls): Add w_scalbln.
>      * sysdeps/ieee754/flt-32/s_scalblnf.c:
>      Remove weak_alias for corresponding scalbln function.
>      * sysdeps/ieee754/dbl-64/s_scalbln.c: Likewise.
>      * sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c: Likewise.
>      * sysdeps/ieee754/ldbl-96/s_scalblnl.c: Likewise.
>      * sysdeps/ieee754/ldbl-128/s_scalblnl.c: Likewise.
>      * sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c: Likewise.
>      * sysdeps/i386/fpu/s_scalbnf.S: Likewise.
>      * sysdeps/i386/fpu/s_scalbn.S: Likewise.
>      * sysdeps/i386/fpu/s_scalbnl.S: Likewise.
>      * sysdeps/m68k/m680x0/fpu/s_scalbn.c: Likewise.
>      * sysdeps/ieee754/ldbl-64-128/s_scalblnl.c:
>      Remove long_double_symbol for scalblnl function in libm, libc.
>      * sysdeps/ieee754/ldbl-64-128/w_scalblnl.c: New File.
>      Add wrapper which checks for setting errno to ERANGE.
>      Add long_double_symbol for scalblnl function in libm, libc.
>      * sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c:
>      Remove long_double_symbol for scalblnl in libm.
>      * sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c: New File.
>      Add wrapper which checks for setting errno to ERANGE.
>      Add long_double_symbol for scalblnl function in libm.
>      * sysdeps/ia64/fpu/w_scalblnf.c: New File.
>      Do not use wrapper because of own implementation.
> ---
>
>
> On 05/08/2014 12:24 PM, Andreas Schwab wrote:
>> Stefan Liebler <stli@linux.vnet.ibm.com> writes:
>>
>>> In case of sysdeps/i386 and sysdeps/m68k/m680x0, the existing
>>> s_scalbln.c
>>> files are empty, because the scalbln-functions are aliases for the
>>> scalbn-functions, which are not covered by this patch.
>>> Thus the wrapper-function is not used.
>>
>> Does that mean you are introducing a regression?
>>
>> Andreas.
>>

Comments

Stefan Liebler May 22, 2014, 9:03 a.m. UTC | #1
PING

On 05/15/2014 11:13 AM, Stefan Liebler wrote:
> PING!
>
> This patch introduces a new wrapper for scalbln functions
> in order to set errno to ERANGE on overflow and underflow.
> The existing aliases that uses __scalbln functions are replaced by
> aliases to the new wrapper.
> The corresponding tests in libm-test.inc are updated to check for errno
> via ERRNO_PLUS_OFLOW etc.
>
> Please test and give ok for commit.
>
> This patch only covers the scalbln-part of bug 6803.
>
> (The attached file is identical to the posted one from 08.05.2014)
>
> Bye
>
> On 05/08/2014 04:31 PM, Stefan Liebler wrote:
>> For these the behaviour is the same like before.
>> Errno is not set and the testcases will fail.
>>
>> Now the scalbln-aliases are removed in i386/m68
>> and the wrappers are used when calling the scalbln-functions.
>>
>> On ia64 only scalblnf has its own implementation.
>> For scalbln and scalblnl the ieee754/dbl-64 and ieee754/ldbl-96 are
>> used, thus the wrappers are needed, too.
>>
>> Bye
>>
>> ---
>> 2014-05-08  Stefan Liebler  <stli@linux.vnet.ibm.com>
>>
>>      [BZ #6803]
>>      * math/libm-test.inc (scalbln_test_date):
>>      Add errno expectations.
>>      * math/w_scalblnf.c: New File.
>>      Add wrapper which checks for setting errno to ERANGE.
>>      Add weak_alias for corresponding scalbln function.
>>      * math/w_scalbln.c: Likewise.
>>      * math/w_scalblnl.c: Likewise.
>>      * math/Makefile (libm-calls): Add w_scalbln.
>>      * sysdeps/ieee754/flt-32/s_scalblnf.c:
>>      Remove weak_alias for corresponding scalbln function.
>>      * sysdeps/ieee754/dbl-64/s_scalbln.c: Likewise.
>>      * sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c: Likewise.
>>      * sysdeps/ieee754/ldbl-96/s_scalblnl.c: Likewise.
>>      * sysdeps/ieee754/ldbl-128/s_scalblnl.c: Likewise.
>>      * sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c: Likewise.
>>      * sysdeps/i386/fpu/s_scalbnf.S: Likewise.
>>      * sysdeps/i386/fpu/s_scalbn.S: Likewise.
>>      * sysdeps/i386/fpu/s_scalbnl.S: Likewise.
>>      * sysdeps/m68k/m680x0/fpu/s_scalbn.c: Likewise.
>>      * sysdeps/ieee754/ldbl-64-128/s_scalblnl.c:
>>      Remove long_double_symbol for scalblnl function in libm, libc.
>>      * sysdeps/ieee754/ldbl-64-128/w_scalblnl.c: New File.
>>      Add wrapper which checks for setting errno to ERANGE.
>>      Add long_double_symbol for scalblnl function in libm, libc.
>>      * sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c:
>>      Remove long_double_symbol for scalblnl in libm.
>>      * sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c: New File.
>>      Add wrapper which checks for setting errno to ERANGE.
>>      Add long_double_symbol for scalblnl function in libm.
>>      * sysdeps/ia64/fpu/w_scalblnf.c: New File.
>>      Do not use wrapper because of own implementation.
>> ---
>>
>>
>> On 05/08/2014 12:24 PM, Andreas Schwab wrote:
>>> Stefan Liebler <stli@linux.vnet.ibm.com> writes:
>>>
>>>> In case of sysdeps/i386 and sysdeps/m68k/m680x0, the existing
>>>> s_scalbln.c
>>>> files are empty, because the scalbln-functions are aliases for the
>>>> scalbn-functions, which are not covered by this patch.
>>>> Thus the wrapper-function is not used.
>>>
>>> Does that mean you are introducing a regression?
>>>
>>> Andreas.
>>>
Stefan Liebler May 30, 2014, 9:06 a.m. UTC | #2
PING

On 05/22/2014 11:03 AM, Stefan Liebler wrote:
> PING
>
> On 05/15/2014 11:13 AM, Stefan Liebler wrote:
>> PING!
>>
>> This patch introduces a new wrapper for scalbln functions
>> in order to set errno to ERANGE on overflow and underflow.
>> The existing aliases that uses __scalbln functions are replaced by
>> aliases to the new wrapper.
>> The corresponding tests in libm-test.inc are updated to check for errno
>> via ERRNO_PLUS_OFLOW etc.
>>
>> Please test and give ok for commit.
>>
>> This patch only covers the scalbln-part of bug 6803.
>>
>> (The attached file is identical to the posted one from 08.05.2014)
>>
>> Bye
>>
>> On 05/08/2014 04:31 PM, Stefan Liebler wrote:
>>> For these the behaviour is the same like before.
>>> Errno is not set and the testcases will fail.
>>>
>>> Now the scalbln-aliases are removed in i386/m68
>>> and the wrappers are used when calling the scalbln-functions.
>>>
>>> On ia64 only scalblnf has its own implementation.
>>> For scalbln and scalblnl the ieee754/dbl-64 and ieee754/ldbl-96 are
>>> used, thus the wrappers are needed, too.
>>>
>>> Bye
>>>
>>> ---
>>> 2014-05-08  Stefan Liebler  <stli@linux.vnet.ibm.com>
>>>
>>>      [BZ #6803]
>>>      * math/libm-test.inc (scalbln_test_date):
>>>      Add errno expectations.
>>>      * math/w_scalblnf.c: New File.
>>>      Add wrapper which checks for setting errno to ERANGE.
>>>      Add weak_alias for corresponding scalbln function.
>>>      * math/w_scalbln.c: Likewise.
>>>      * math/w_scalblnl.c: Likewise.
>>>      * math/Makefile (libm-calls): Add w_scalbln.
>>>      * sysdeps/ieee754/flt-32/s_scalblnf.c:
>>>      Remove weak_alias for corresponding scalbln function.
>>>      * sysdeps/ieee754/dbl-64/s_scalbln.c: Likewise.
>>>      * sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c: Likewise.
>>>      * sysdeps/ieee754/ldbl-96/s_scalblnl.c: Likewise.
>>>      * sysdeps/ieee754/ldbl-128/s_scalblnl.c: Likewise.
>>>      * sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c: Likewise.
>>>      * sysdeps/i386/fpu/s_scalbnf.S: Likewise.
>>>      * sysdeps/i386/fpu/s_scalbn.S: Likewise.
>>>      * sysdeps/i386/fpu/s_scalbnl.S: Likewise.
>>>      * sysdeps/m68k/m680x0/fpu/s_scalbn.c: Likewise.
>>>      * sysdeps/ieee754/ldbl-64-128/s_scalblnl.c:
>>>      Remove long_double_symbol for scalblnl function in libm, libc.
>>>      * sysdeps/ieee754/ldbl-64-128/w_scalblnl.c: New File.
>>>      Add wrapper which checks for setting errno to ERANGE.
>>>      Add long_double_symbol for scalblnl function in libm, libc.
>>>      * sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c:
>>>      Remove long_double_symbol for scalblnl in libm.
>>>      * sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c: New File.
>>>      Add wrapper which checks for setting errno to ERANGE.
>>>      Add long_double_symbol for scalblnl function in libm.
>>>      * sysdeps/ia64/fpu/w_scalblnf.c: New File.
>>>      Do not use wrapper because of own implementation.
>>> ---
>>>
>>>
>>> On 05/08/2014 12:24 PM, Andreas Schwab wrote:
>>>> Stefan Liebler <stli@linux.vnet.ibm.com> writes:
>>>>
>>>>> In case of sysdeps/i386 and sysdeps/m68k/m680x0, the existing
>>>>> s_scalbln.c
>>>>> files are empty, because the scalbln-functions are aliases for the
>>>>> scalbn-functions, which are not covered by this patch.
>>>>> Thus the wrapper-function is not used.
>>>>
>>>> Does that mean you are introducing a regression?
>>>>
>>>> Andreas.
>>>>
>
>
Joseph Myers June 19, 2014, 9:58 p.m. UTC | #3
On Thu, 15 May 2014, Stefan Liebler wrote:

> PING!
> 
> This patch introduces a new wrapper for scalbln functions
> in order to set errno to ERANGE on overflow and underflow.
> The existing aliases that uses __scalbln functions are replaced by aliases to
> the new wrapper.
> The corresponding tests in libm-test.inc are updated to check for errno via
> ERRNO_PLUS_OFLOW etc.

This patch is OK.
Siddhesh Poyarekar June 20, 2014, 2:34 a.m. UTC | #4
On Thu, Jun 19, 2014 at 09:58:33PM +0000, Joseph S. Myers wrote:
> On Thu, 15 May 2014, Stefan Liebler wrote:
> 
> > PING!
> > 
> > This patch introduces a new wrapper for scalbln functions
> > in order to set errno to ERANGE on overflow and underflow.
> > The existing aliases that uses __scalbln functions are replaced by aliases to
> > the new wrapper.
> > The corresponding tests in libm-test.inc are updated to check for errno via
> > ERRNO_PLUS_OFLOW etc.
> 
> This patch is OK.

Pushed.

Siddhesh
Joseph Myers June 20, 2014, 11:32 a.m. UTC | #5
On Fri, 20 Jun 2014, Siddhesh Poyarekar wrote:

> On Thu, Jun 19, 2014 at 09:58:33PM +0000, Joseph S. Myers wrote:
> > On Thu, 15 May 2014, Stefan Liebler wrote:
> > 
> > > PING!
> > > 
> > > This patch introduces a new wrapper for scalbln functions
> > > in order to set errno to ERANGE on overflow and underflow.
> > > The existing aliases that uses __scalbln functions are replaced by aliases to
> > > the new wrapper.
> > > The corresponding tests in libm-test.inc are updated to check for errno via
> > > ERRNO_PLUS_OFLOW etc.
> > 
> > This patch is OK.
> 
> Pushed.

Bug 6803 should not have been added to NEWS; this patch only fixes the 
scalbln case, not the scalbn one.  (I previously fixed the scalb case.)
Siddhesh Poyarekar June 20, 2014, 11:42 a.m. UTC | #6
Sorry about that, I've reverted the NEWS change and also fixed up the
ChangeLog goof-up with the localedata fix.

Siddhesh

On 20 June 2014 17:02, Joseph S. Myers <joseph@codesourcery.com> wrote:
> On Fri, 20 Jun 2014, Siddhesh Poyarekar wrote:
>
>> On Thu, Jun 19, 2014 at 09:58:33PM +0000, Joseph S. Myers wrote:
>> > On Thu, 15 May 2014, Stefan Liebler wrote:
>> >
>> > > PING!
>> > >
>> > > This patch introduces a new wrapper for scalbln functions
>> > > in order to set errno to ERANGE on overflow and underflow.
>> > > The existing aliases that uses __scalbln functions are replaced by aliases to
>> > > the new wrapper.
>> > > The corresponding tests in libm-test.inc are updated to check for errno via
>> > > ERRNO_PLUS_OFLOW etc.
>> >
>> > This patch is OK.
>>
>> Pushed.
>
> Bug 6803 should not have been added to NEWS; this patch only fixes the
> scalbln case, not the scalbn one.  (I previously fixed the scalb case.)
>
> --
> Joseph S. Myers
> joseph@codesourcery.com

Patch
diff mbox

diff --git a/math/Makefile b/math/Makefile
index c13ca80..f0cafe2 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -48,7 +48,7 @@  libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod	\
 	     k_cos k_rem_pio2 k_sin k_tan s_asinh s_atan s_cbrt		\
 	     s_ceil s_cos s_erf s_expm1 s_fabs				\
 	     s_floor s_log1p s_logb					\
-	     s_nextafter s_nexttoward s_rint s_scalbln			\
+	     s_nextafter s_nexttoward s_rint s_scalbln w_scalbln	\
 	     s_significand s_sin s_tan s_tanh w_acos w_acosh w_asin	\
 	     w_atan2 w_atanh w_cosh w_drem w_exp w_exp2 w_exp10 w_fmod	\
 	     w_tgamma w_hypot w_j0 w_j1 w_jn w_lgamma w_lgamma_r	\
diff --git a/math/libm-test.inc b/math/libm-test.inc
index a4bf0b8..dff16b6 100644
--- a/math/libm-test.inc
+++ b/math/libm-test.inc
@@ -9222,72 +9222,72 @@  ldexp_test (void)
 
 static const struct test_fl_f_data scalbln_test_data[] =
   {
-    TEST_fl_f (scalbln, 0, 0, 0, NO_INEXACT_EXCEPTION),
-    TEST_fl_f (scalbln, minus_zero, 0, minus_zero, NO_INEXACT_EXCEPTION),
-
-    TEST_fl_f (scalbln, plus_infty, 1, plus_infty, NO_INEXACT_EXCEPTION),
-    TEST_fl_f (scalbln, minus_infty, 1, minus_infty, NO_INEXACT_EXCEPTION),
-    TEST_fl_f (scalbln, qnan_value, 1, qnan_value, NO_INEXACT_EXCEPTION),
-
-    TEST_fl_f (scalbln, 0.8L, 4, 12.8L, NO_INEXACT_EXCEPTION),
-    TEST_fl_f (scalbln, -0.854375L, 5, -27.34L, NO_INEXACT_EXCEPTION),
-
-    TEST_fl_f (scalbln, 1, 0L, 1, NO_INEXACT_EXCEPTION),
-
-    TEST_fl_f (scalbln, 1, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, 1, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-
-    TEST_fl_f (scalbln, -1, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -1, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-
-    TEST_fl_f (scalbln, 1, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, 1, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-
-    TEST_fl_f (scalbln, -1, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -1, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
+    TEST_fl_f (scalbln, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+    TEST_fl_f (scalbln, minus_zero, 0, minus_zero, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+
+    TEST_fl_f (scalbln, plus_infty, 1, plus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+    TEST_fl_f (scalbln, minus_infty, 1, minus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+    TEST_fl_f (scalbln, qnan_value, 1, qnan_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+
+    TEST_fl_f (scalbln, 0.8L, 4, 12.8L, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+    TEST_fl_f (scalbln, -0.854375L, 5, -27.34L, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+
+    TEST_fl_f (scalbln, 1, 0L, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
+
+    TEST_fl_f (scalbln, 1, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, 1, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, max_value, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, max_value, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value / 4, INT_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value / 4, INT_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+
+    TEST_fl_f (scalbln, -1, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -1, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -max_value, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -max_value, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, INT_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, INT_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+
+    TEST_fl_f (scalbln, 1, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, 1, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, max_value, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, max_value, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value / 4, LONG_MAX, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value / 4, LONG_MIN, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+
+    TEST_fl_f (scalbln, -1, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -1, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -max_value, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -max_value, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, LONG_MAX, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, LONG_MIN, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
 
 #if LONG_MAX >= 0x100000000
-    TEST_fl_f (scalbln, 1, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, 1, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, max_value, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, min_value / 4, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-
-    TEST_fl_f (scalbln, -1, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -1, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -max_value, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION),
-    TEST_fl_f (scalbln, -min_value / 4, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION),
+    TEST_fl_f (scalbln, 1, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, 1, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, max_value, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, max_value, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+    TEST_fl_f (scalbln, min_value / 4, 0x88000000L, plus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_PLUS_OFLOW),
+    TEST_fl_f (scalbln, min_value / 4, -0x88000000L, plus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_PLUS_UFLOW),
+
+    TEST_fl_f (scalbln, -1, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -1, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -max_value, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -max_value, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, 0x88000000L, minus_oflow, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION|ERRNO_MINUS_OFLOW),
+    TEST_fl_f (scalbln, -min_value / 4, -0x88000000L, minus_uflow, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION|ERRNO_MINUS_UFLOW),
 #endif
   };
 
diff --git a/math/w_scalbln.c b/math/w_scalbln.c
new file mode 100644
index 0000000..7167fdf
--- /dev/null
+++ b/math/w_scalbln.c
@@ -0,0 +1,40 @@ 
+/* Wrapper for __scalbln handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+double
+__w_scalbln (double x, long int n)
+{
+  if (!__finite (x) || x == 0.0)
+    return x;
+
+  x = __scalbln (x, n);
+
+  if (!__finite (x) || x == 0.0)
+    __set_errno (ERANGE);
+
+  return x;
+}
+weak_alias (__w_scalbln, scalbln)
+
+#ifdef NO_LONG_DOUBLE
+weak_alias (__w_scalbln, scalblnl)
+#endif
diff --git a/math/w_scalblnf.c b/math/w_scalblnf.c
new file mode 100644
index 0000000..99a3a87
--- /dev/null
+++ b/math/w_scalblnf.c
@@ -0,0 +1,36 @@ 
+/* Wrapper for __scalblnf handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+float
+__w_scalblnf (float x, long int n)
+{
+  if (!__finitef (x) || x == 0.0f)
+    return x;
+
+  x = __scalblnf (x, n);
+
+  if (!__finitef (x) || x == 0.0f)
+    __set_errno (ERANGE);
+
+  return x;
+}
+weak_alias (__w_scalblnf, scalblnf)
diff --git a/math/w_scalblnl.c b/math/w_scalblnl.c
new file mode 100644
index 0000000..48504e0
--- /dev/null
+++ b/math/w_scalblnl.c
@@ -0,0 +1,36 @@ 
+/* Wrapper for __scalblnl handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+long double
+__w_scalblnl (long double x, long int n)
+{
+  if (!__finitel (x) || x == 0.0L)
+    return x;
+
+  x = __scalblnl (x, n);
+
+  if (!__finitel (x) || x == 0.0L)
+    __set_errno (ERANGE);
+
+  return x;
+}
+weak_alias (__w_scalblnl, scalblnl)
diff --git a/sysdeps/i386/fpu/s_scalbn.S b/sysdeps/i386/fpu/s_scalbn.S
index ea9e25f..548f19f 100644
--- a/sysdeps/i386/fpu/s_scalbn.S
+++ b/sysdeps/i386/fpu/s_scalbn.S
@@ -16,4 +16,3 @@  ENTRY(__scalbn)
 END (__scalbn)
 weak_alias (__scalbn, scalbn)
 strong_alias (__scalbn, __scalbln)
-weak_alias (__scalbn, scalbln)
diff --git a/sysdeps/i386/fpu/s_scalbnf.S b/sysdeps/i386/fpu/s_scalbnf.S
index dc8cfb4..fe6516e 100644
--- a/sysdeps/i386/fpu/s_scalbnf.S
+++ b/sysdeps/i386/fpu/s_scalbnf.S
@@ -16,4 +16,3 @@  ENTRY(__scalbnf)
 END (__scalbnf)
 weak_alias (__scalbnf, scalbnf)
 strong_alias (__scalbnf, __scalblnf)
-weak_alias (__scalbnf, scalblnf)
diff --git a/sysdeps/i386/fpu/s_scalbnl.S b/sysdeps/i386/fpu/s_scalbnl.S
index 295494b..8f65de4 100644
--- a/sysdeps/i386/fpu/s_scalbnl.S
+++ b/sysdeps/i386/fpu/s_scalbnl.S
@@ -17,4 +17,3 @@  ENTRY(__scalbnl)
 END (__scalbnl)
 weak_alias (__scalbnl, scalbnl)
 strong_alias (__scalbnl, __scalblnl)
-weak_alias (__scalbnl, scalblnl)
diff --git a/sysdeps/ia64/fpu/w_scalblnf.c b/sysdeps/ia64/fpu/w_scalblnf.c
new file mode 100644
index 0000000..6026b50
--- /dev/null
+++ b/sysdeps/ia64/fpu/w_scalblnf.c
@@ -0,0 +1,20 @@ 
+/* Wrapper for __scalblnf handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* Nothing to do.
+   The function scalblnf is used without the wrapper function.  */
diff --git a/sysdeps/ieee754/dbl-64/s_scalbln.c b/sysdeps/ieee754/dbl-64/s_scalbln.c
index 874b98e..32cd12e 100644
--- a/sysdeps/ieee754/dbl-64/s_scalbln.c
+++ b/sysdeps/ieee754/dbl-64/s_scalbln.c
@@ -58,8 +58,6 @@  __scalbln (double x, long int n)
   SET_HIGH_WORD (x, (hx & 0x800fffff) | (k << 20));
   return x * twom54;
 }
-weak_alias (__scalbln, scalbln)
 #ifdef NO_LONG_DOUBLE
 strong_alias (__scalbln, __scalblnl)
-weak_alias (__scalbln, scalblnl)
 #endif
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
index c00db68..8dce51e 100644
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
+++ b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
@@ -55,8 +55,6 @@  __scalbln (double x, long int n)
 	INSERT_WORDS64(x,(ix&INT64_C(0x800fffffffffffff))|(k<<52));
 	return x*twom54;
 }
-weak_alias (__scalbln, scalbln)
 #ifdef NO_LONG_DOUBLE
 strong_alias (__scalbln, __scalblnl)
-weak_alias (__scalbln, scalblnl)
 #endif
diff --git a/sysdeps/ieee754/flt-32/s_scalblnf.c b/sysdeps/ieee754/flt-32/s_scalblnf.c
index aa45164..ad3c586 100644
--- a/sysdeps/ieee754/flt-32/s_scalblnf.c
+++ b/sysdeps/ieee754/flt-32/s_scalblnf.c
@@ -50,4 +50,3 @@  __scalblnf (float x, long int n)
 	SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23));
 	return x*twom25;
 }
-weak_alias (__scalblnf, scalblnf)
diff --git a/sysdeps/ieee754/ldbl-128/s_scalblnl.c b/sysdeps/ieee754/ldbl-128/s_scalblnl.c
index f552393..1e24197 100644
--- a/sysdeps/ieee754/ldbl-128/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-128/s_scalblnl.c
@@ -60,4 +60,3 @@  long double __scalblnl (long double x, long int n)
 	SET_LDOUBLE_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48));
         return x*twom114;
 }
-weak_alias (__scalblnl, scalblnl)
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c b/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
index 03d4597..0316352 100644
--- a/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
@@ -102,4 +102,3 @@  long double __scalblnl (long double x, long int n)
 	x = ldbl_pack (xhi, xlo);
 	return x*twolm54;
 }
-long_double_symbol (libm, __scalblnl, scalblnl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c b/sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c
new file mode 100644
index 0000000..24a5461
--- /dev/null
+++ b/sysdeps/ieee754/ldbl-128ibm/w_scalblnl.c
@@ -0,0 +1,23 @@ 
+/* Wrapper for __scalblnl handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math_ldbl_opt.h>
+#undef weak_alias
+#define weak_alias(name, alias)
+#include <math/w_scalblnl.c>
+long_double_symbol (libm, __w_scalblnl, scalblnl);
diff --git a/sysdeps/ieee754/ldbl-64-128/s_scalblnl.c b/sysdeps/ieee754/ldbl-64-128/s_scalblnl.c
index 3143f18..97181d2 100644
--- a/sysdeps/ieee754/ldbl-64-128/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-64-128/s_scalblnl.c
@@ -2,8 +2,3 @@ 
 #undef weak_alias
 #define weak_alias(n,a)
 #include <sysdeps/ieee754/ldbl-128/s_scalblnl.c>
-#ifdef IS_IN_libm
-long_double_symbol (libm, __scalblnl, scalblnl);
-#else
-long_double_symbol (libc, __scalblnl, scalblnl);
-#endif
diff --git a/sysdeps/ieee754/ldbl-64-128/w_scalblnl.c b/sysdeps/ieee754/ldbl-64-128/w_scalblnl.c
new file mode 100644
index 0000000..fc6c4cf
--- /dev/null
+++ b/sysdeps/ieee754/ldbl-64-128/w_scalblnl.c
@@ -0,0 +1,27 @@ 
+/* Wrapper for __scalblnl handles setting errno.
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math_ldbl_opt.h>
+#undef weak_alias
+#define weak_alias(name, alias)
+#include <math/w_scalblnl.c>
+#ifdef IS_IN_libm
+long_double_symbol (libm, __w_scalblnl, scalblnl);
+#else
+long_double_symbol (libc, __w_scalblnl, scalblnl);
+#endif
diff --git a/sysdeps/ieee754/ldbl-96/s_scalblnl.c b/sysdeps/ieee754/ldbl-96/s_scalblnl.c
index 76a4c59..fca8470 100644
--- a/sysdeps/ieee754/ldbl-96/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-96/s_scalblnl.c
@@ -58,4 +58,3 @@  __scalblnl (long double x, long int n)
 	SET_LDOUBLE_EXP(x,(es&0x8000)|k);
 	return x*twom63;
 }
-weak_alias (__scalblnl, scalblnl)
diff --git a/sysdeps/m68k/m680x0/fpu/s_scalbn.c b/sysdeps/m68k/m680x0/fpu/s_scalbn.c
index c56a9ff..f520f7d 100644
--- a/sysdeps/m68k/m680x0/fpu/s_scalbn.c
+++ b/sysdeps/m68k/m680x0/fpu/s_scalbn.c
@@ -47,4 +47,3 @@  __CONCATX(__scalbn,suffix) (x, exp)
 }
 weak_alias (__CONCATX(__scalbn,suffix), __CONCATX(scalbn,suffix))
 strong_alias (__CONCATX(__scalbn,suffix), __CONCATX(__scalbln,suffix))
-weak_alias (__CONCATX(__scalbn,suffix), __CONCATX(scalbln,suffix))
diff --git a/sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c b/sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c
index e07ff62..6d11a3d 100644
--- a/sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c
+++ b/sysdeps/sparc/sparc64/soft-fp/s_scalblnl.c
@@ -50,5 +50,3 @@  long double __scalblnl(long double arg, int exp)
 
   return r;
 }
-
-weak_alias (__scalblnl, scalblnl)