diff -rNu compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/libc-diag.h compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/libc-diag.h

--- compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/libc-diag.h	1970-01-01 01:00:00.000000000 +0100

+++ compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/libc-diag.h	2018-01-10 07:36:33.762358809 +0100

@@ -0,0 +1,74 @@

+/* Macros for controlling diagnostic output from the compiler.

+   Copyright (C) 2014-2018 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/>.  */

+

+#ifndef _LIBC_DIAG_H

+#define _LIBC_DIAG_H 1

+

+/* Ignore the value of an expression when a cast to void does not

+   suffice (in particular, for a call to a function declared with

+   attribute warn_unused_result).  */

+#define ignore_value(x) \

+  ({ __typeof__ (x) __ignored_value = (x); (void) __ignored_value; })

+

+/* The macros to control diagnostics are structured like this, rather

+   than a single macro that both pushes and pops diagnostic state and

+   takes the affected code as an argument, because the GCC pragmas

+   work by disabling the diagnostic for a range of source locations

+   and do not work when all the pragmas and the affected code are in a

+   single macro expansion.  */

+

+/* Push diagnostic state.  */

+#define DIAG_PUSH_NEEDS_COMMENT _Pragma ("GCC diagnostic push")

+

+/* Pop diagnostic state.  */

+#define DIAG_POP_NEEDS_COMMENT _Pragma ("GCC diagnostic pop")

+

+#define _DIAG_STR1(s) #s

+#define _DIAG_STR(s) _DIAG_STR1(s)

+

+/* Ignore the diagnostic OPTION.  VERSION is the most recent GCC

+   version for which the diagnostic has been confirmed to appear in

+   the absence of the pragma (in the form MAJOR.MINOR for GCC 4.x,

+   just MAJOR for GCC 5 and later).  Uses of this pragma should be

+   reviewed when the GCC version given is no longer supported for

+   building glibc; the version number should always be on the same

+   source line as the macro name, so such uses can be found with grep.

+   Uses should come with a comment giving more details of the

+   diagnostic, and an architecture on which it is seen if possibly

+   optimization-related and not in architecture-specific code.  This

+   macro should only be used if the diagnostic seems hard to fix (for

+   example, optimization-related false positives).  */

+#define DIAG_IGNORE_NEEDS_COMMENT(version, option)     \

+  _Pragma (_DIAG_STR (GCC diagnostic ignored option))

+

+/* Similar to DIAG_IGNORE_NEEDS_COMMENT the following macro ignores the

+   diagnostic OPTION but only if optimizations for size are enabled.

+   This is required because different warnings may be generated for

+   different optimization levels.  For example a key piece of code may

+   only generate a warning when compiled at -Os, but at -O2 you could

+   still want the warning to be enabled to catch errors.  In this case

+   you would use DIAG_IGNORE_Os_NEEDS_COMMENT to disable the warning

+   only for -Os.  */

+#ifdef __OPTIMIZE_SIZE__

+# define DIAG_IGNORE_Os_NEEDS_COMMENT(version, option) \

+  _Pragma (_DIAG_STR (GCC diagnostic ignored option))

+#else

+# define DIAG_IGNORE_Os_NEEDS_COMMENT(version, option)

+#endif

+

+#endif /* libc-diag.h */

diff -rNu compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/loop.c compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/loop.c

--- compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/loop.c	2018-01-09 12:42:01.393580878 +0100

+++ compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/loop.c	2018-01-09 12:42:28.069281608 +0100

@@ -1,5 +1,5 @@

 /* Conversion loop frame work.

-   Copyright (C) 1998-2002, 2003, 2005, 2008 Free Software Foundation, Inc.

+   Copyright (C) 1998-2018 Free Software Foundation, Inc.

    This file is part of the GNU C Library.

    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.

@@ -14,9 +14,8 @@

    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, write to the Free

-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

-   02111-1307 USA.  */

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

 /* This file provides a frame for the reader loop in all conversion modules.

    The actual code must (of course) be provided in the actual module source

@@ -39,7 +38,7 @@

      BODY		this is supposed to expand to the body of the loop.

 			The user must provide this.

-     EXTRA_LOOP_DECLS	extra arguments passed from converion loop call.

+     EXTRA_LOOP_DECLS	extra arguments passed from conversion loop call.

      INIT_PARAMS	code to define and initialize variables from params.

      UPDATE_PARAMS	code to store result in params.

@@ -57,17 +56,17 @@

 #include <sys/param.h>		/* For MIN.  */

 #define __need_size_t

 #include <stddef.h>

-

+#include <libc-diag.h>

 /* We have to provide support for machines which are not able to handled

    unaligned memory accesses.  Some of the character encodings have

    representations with a fixed width of 2 or 4 bytes.  But if we cannot

    access unaligned memory we still have to read byte-wise.  */

 #undef FCTNAME2

-#if defined _STRING_ARCH_unaligned || !defined DEFINE_UNALIGNED

+#if _STRING_ARCH_unaligned || !defined DEFINE_UNALIGNED

 /* We can handle unaligned memory access.  */

-# define get16(addr) *((__const uint16_t *) (addr))

-# define get32(addr) *((__const uint32_t *) (addr))

+# define get16(addr) *((const uint16_t *) (addr))

+# define get32(addr) *((const uint32_t *) (addr))

 /* We need no special support for writing values either.  */

 # define put16(addr, val) *((uint16_t *) (addr)) = (val)

@@ -78,13 +77,13 @@

 /* Distinguish between big endian and little endian.  */

 # if __BYTE_ORDER == __LITTLE_ENDIAN

 #  define get16(addr) \

-     (((__const unsigned char *) (addr))[1] << 8			      \

-      | ((__const unsigned char *) (addr))[0])

+     (((const unsigned char *) (addr))[1] << 8				      \

+      | ((const unsigned char *) (addr))[0])

 #  define get32(addr) \

-     (((((__const unsigned char *) (addr))[3] << 8			      \

-	| ((__const unsigned char *) (addr))[2]) << 8			      \

-       | ((__const unsigned char *) (addr))[1]) << 8			      \

-      | ((__const unsigned char *) (addr))[0])

+     (((((const unsigned char *) (addr))[3] << 8			      \

+	| ((const unsigned char *) (addr))[2]) << 8			      \

+       | ((const unsigned char *) (addr))[1]) << 8			      \

+      | ((const unsigned char *) (addr))[0])

 #  define put16(addr, val) \

      ({ uint16_t __val = (val);						      \

@@ -103,13 +102,13 @@

 	(void) 0; })

 # else

 #  define get16(addr) \

-     (((__const unsigned char *) (addr))[0] << 8			      \

-      | ((__const unsigned char *) (addr))[1])

+     (((const unsigned char *) (addr))[0] << 8				      \

+      | ((const unsigned char *) (addr))[1])

 #  define get32(addr) \

-     (((((__const unsigned char *) (addr))[0] << 8			      \

-	| ((__const unsigned char *) (addr))[1]) << 8			      \

-       | ((__const unsigned char *) (addr))[2]) << 8			      \

-      | ((__const unsigned char *) (addr))[3])

+     (((((const unsigned char *) (addr))[0] << 8			      \

+	| ((const unsigned char *) (addr))[1]) << 8			      \

+       | ((const unsigned char *) (addr))[2]) << 8			      \

+      | ((const unsigned char *) (addr))[3])

 #  define put16(addr, val) \

      ({ uint16_t __val = (val);						      \

@@ -214,8 +213,6 @@

    points.  */

 #define STANDARD_TO_LOOP_ERR_HANDLER(Incr) \

   {									      \

-    struct __gconv_trans_data *trans;					      \

-									      \

     result = __GCONV_ILLEGAL_INPUT;					      \

 									      \

     if (irreversible == NULL)						      \

@@ -228,21 +225,17 @@

     UPDATE_PARAMS;							      \

 									      \

     /* First try the transliteration methods.  */			      \

-    for (trans = step_data->__trans; trans != NULL; trans = trans->__next)    \

-      {									      \

-	result = DL_CALL_FCT (trans->__trans_fct,			      \

-			      (step, step_data, trans->__data, *inptrp,	      \

-			       &inptr, inend, &outptr, irreversible));	      \

-	if (result != __GCONV_ILLEGAL_INPUT)				      \

-	  break;							      \

-      }									      \

+    if ((step_data->__flags & __GCONV_TRANSLIT) != 0)			      \

+      result = __gconv_transliterate					      \

+	(step, step_data, *inptrp,					      \

+	 &inptr, inend, &outptr, irreversible);			      \

 									      \

     REINIT_PARAMS;							      \

 									      \

     /* If any of them recognized the input continue with the loop.  */	      \

     if (result != __GCONV_ILLEGAL_INPUT)				      \

       {									      \

-	if (__builtin_expect (result == __GCONV_FULL_OUTPUT, 0))	      \

+	if (__glibc_unlikely (result == __GCONV_FULL_OUTPUT))		      \

 	  break;							      \

 									      \

 	continue;							      \

@@ -343,7 +336,7 @@

 /* Include the file a second time to define the function to handle

    unaligned access.  */

-#if !defined DEFINE_UNALIGNED && !defined _STRING_ARCH_unaligned \

+#if !defined DEFINE_UNALIGNED && !_STRING_ARCH_unaligned \

     && MIN_NEEDED_INPUT != 1 && MAX_NEEDED_INPUT % MIN_NEEDED_INPUT == 0 \

     && MIN_NEEDED_OUTPUT != 1 && MAX_NEEDED_OUTPUT % MIN_NEEDED_OUTPUT == 0

 # undef get16

@@ -355,12 +348,10 @@

 # define DEFINE_UNALIGNED

 # include "loop.c"

 # undef DEFINE_UNALIGNED

-#endif

-

-

-#if MAX_NEEDED_INPUT > 1

-# define SINGLE(fct) SINGLE2 (fct)

-# define SINGLE2(fct) fct##_single

+#else

+# if MAX_NEEDED_INPUT > 1

+#  define SINGLE(fct) SINGLE2 (fct)

+#  define SINGLE2(fct) fct##_single

 static inline int

 __attribute ((always_inline))

 SINGLE(LOOPFCT) (struct __gconv_step *step,

@@ -370,46 +361,57 @@

 		 size_t *irreversible EXTRA_LOOP_DECLS)

 {

   mbstate_t *state = step_data->__statep;

-#ifdef LOOP_NEED_FLAGS

+#  ifdef LOOP_NEED_FLAGS

   int flags = step_data->__flags;

-#endif

-#ifdef LOOP_NEED_DATA

+#  endif

+#  ifdef LOOP_NEED_DATA

   void *data = step->__data;

-#endif

+#  endif

   int result = __GCONV_OK;

   unsigned char bytebuf[MAX_NEEDED_INPUT];

   const unsigned char *inptr = *inptrp;

   unsigned char *outptr = *outptrp;

   size_t inlen;

-#ifdef INIT_PARAMS

+#  ifdef INIT_PARAMS

   INIT_PARAMS;

-#endif

+#  endif

-#ifdef UNPACK_BYTES

+#  ifdef UNPACK_BYTES

   UNPACK_BYTES

-#else

+#  else

   /* Add the bytes from the state to the input buffer.  */

+  assert ((state->__count & 7) <= sizeof (state->__value));

   for (inlen = 0; inlen < (size_t) (state->__count & 7); ++inlen)

     bytebuf[inlen] = state->__value.__wchb[inlen];

-#endif

+#  endif

   /* Are there enough bytes in the input buffer?  */

-  if (__builtin_expect (inptr + (MIN_NEEDED_INPUT - inlen) > inend, 0))

+  if (MIN_NEEDED_INPUT > 1

+      && __builtin_expect (inptr + (MIN_NEEDED_INPUT - inlen) > inend, 0))

     {

       *inptrp = inend;

-#ifdef STORE_REST

+#  ifdef STORE_REST

+

+      /* Building with -O3 GCC emits a `array subscript is above array

+	 bounds' warning.  GCC BZ #64739 has been opened for this.  */

+      DIAG_PUSH_NEEDS_COMMENT;

+      DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Warray-bounds");

+      while (inptr < inend)

+	bytebuf[inlen++] = *inptr++;

+      DIAG_POP_NEEDS_COMMENT;

+

       inptr = bytebuf;

       inptrp = &inptr;

       inend = &bytebuf[inlen];

       STORE_REST

-#else

+#  else

       /* We don't have enough input for another complete input

 	 character.  */

       while (inptr < inend)

 	state->__value.__wchb[inlen++] = *inptr++;

-#endif

+#  endif

       return __GCONV_INCOMPLETE_INPUT;

     }

@@ -438,7 +440,7 @@

      bytes from the state and at least one more, or the character is still

      incomplete, or we have some other error (like illegal input character,

      no space in output buffer).  */

-  if (__builtin_expect (inptr != bytebuf, 1))

+  if (__glibc_likely (inptr != bytebuf))

     {

       /* We found a new character.  */

       assert (inptr - bytebuf > (state->__count & 7));

@@ -449,11 +451,11 @@

       result = __GCONV_OK;

       /* Clear the state buffer.  */

-#ifdef CLEAR_STATE

+#  ifdef CLEAR_STATE

       CLEAR_STATE;

-#else

+#  else

       state->__count &= ~7;

-#endif

+#  endif

     }

   else if (result == __GCONV_INCOMPLETE_INPUT)

     {

@@ -462,37 +464,38 @@

       assert (inend != &bytebuf[MAX_NEEDED_INPUT]);

       *inptrp += inend - bytebuf - (state->__count & 7);

-#ifdef STORE_REST

+#  ifdef STORE_REST

       inptrp = &inptr;

       STORE_REST

-#else

+#  else

       /* We don't have enough input for another complete input

 	 character.  */

       assert (inend - inptr > (state->__count & ~7));

-      assert (inend - inptr <= 7);

+      assert (inend - inptr <= sizeof (state->__value));

       state->__count = (state->__count & ~7) | (inend - inptr);

       inlen = 0;

       while (inptr < inend)

 	state->__value.__wchb[inlen++] = *inptr++;

-#endif

+#  endif

     }

   return result;

 }

-# undef SINGLE

-# undef SINGLE2

-#endif

+#  undef SINGLE

+#  undef SINGLE2

+# endif

-#ifdef ONEBYTE_BODY

+# ifdef ONEBYTE_BODY

 /* Define the shortcut function for btowc.  */

 static wint_t

 gconv_btowc (struct __gconv_step *step, unsigned char c)

   ONEBYTE_BODY

-# define FROM_ONEBYTE gconv_btowc

-#endif

+#  define FROM_ONEBYTE gconv_btowc

+# endif

+#endif

 /* We remove the macro definitions so that we can include this file again

    for the definition of another function.  */

diff -rNu compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/skeleton.c compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/skeleton.c

--- compat-locales-sap-1.0.10.orig/saplocales-2.2.5/iconv/skeleton.c	2018-01-09 12:42:01.394580867 +0100

+++ compat-locales-sap-1.0.10/saplocales-2.2.5/iconv/skeleton.c	2018-01-10 07:58:37.922439161 +0100

@@ -1,5 +1,5 @@

 /* Skeleton for a conversion module.

-   Copyright (C) 1998-2002, 2005 Free Software Foundation, Inc.

+   Copyright (C) 1998-2018 Free Software Foundation, Inc.

    This file is part of the GNU C Library.

    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.

@@ -14,9 +14,8 @@

    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, write to the Free

-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

-   02111-1307 USA.  */

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

 /* This file can be included to provide definitions of several things

    many modules have in common.  It can be customized using the following

@@ -39,24 +38,24 @@

      FROM_LOOP_MIN_NEEDED_FROM

      FROM_LOOP_MAX_NEEDED_FROM

-                        minimal/maximal number of bytes needed on input

-                        of one round through the FROM_LOOP.  Defaults

-                        to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.

+			minimal/maximal number of bytes needed on input

+			of one round through the FROM_LOOP.  Defaults

+			to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.

      FROM_LOOP_MIN_NEEDED_TO

      FROM_LOOP_MAX_NEEDED_TO

-                        minimal/maximal number of bytes needed on output

-                        of one round through the FROM_LOOP.  Defaults

-                        to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.

+			minimal/maximal number of bytes needed on output

+			of one round through the FROM_LOOP.  Defaults

+			to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.

      TO_LOOP_MIN_NEEDED_FROM

      TO_LOOP_MAX_NEEDED_FROM

-                        minimal/maximal number of bytes needed on input

-                        of one round through the TO_LOOP.  Defaults

-                        to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.

+			minimal/maximal number of bytes needed on input

+			of one round through the TO_LOOP.  Defaults

+			to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.

      TO_LOOP_MIN_NEEDED_TO

      TO_LOOP_MAX_NEEDED_TO

-                        minimal/maximal number of bytes needed on output

-                        of one round through the TO_LOOP.  Defaults

-                        to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.

+			minimal/maximal number of bytes needed on output

+			of one round through the TO_LOOP.  Defaults

+			to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.

      FROM_DIRECTION	this macro is supposed to return a value != 0

 			if we convert from the current character set,

@@ -145,6 +144,7 @@

 #endif

 #include <sysdep.h>

+#include <stdint.h>

 #ifndef DL_CALL_FCT

 # define DL_CALL_FCT(fct, args) fct args

@@ -163,7 +163,6 @@

 # endif

 #endif

-

 /* How many bytes are needed at most for the from-charset.  */

 #ifndef MAX_NEEDED_FROM

 # define MAX_NEEDED_FROM	MIN_NEEDED_FROM

@@ -204,10 +203,10 @@

 /* Define macros which can access unaligned buffers.  These macros are

    supposed to be used only in code outside the inner loops.  For the inner

    loops we have other definitions which allow optimized access.  */

-#ifdef _STRING_ARCH_unaligned

+#if _STRING_ARCH_unaligned

 /* We can handle unaligned memory access.  */

-# define get16u(addr) *((__const uint16_t *) (addr))

-# define get32u(addr) *((__const uint32_t *) (addr))

+# define get16u(addr) *((const uint16_t *) (addr))

+# define get32u(addr) *((const uint32_t *) (addr))

 /* We need no special support for writing values either.  */

 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)

@@ -216,13 +215,13 @@

 /* Distinguish between big endian and little endian.  */

 # if __BYTE_ORDER == __LITTLE_ENDIAN

 #  define get16u(addr) \

-     (((__const unsigned char *) (addr))[1] << 8			      \

-      | ((__const unsigned char *) (addr))[0])

+     (((const unsigned char *) (addr))[1] << 8				      \

+      | ((const unsigned char *) (addr))[0])

 #  define get32u(addr) \

-     (((((__const unsigned char *) (addr))[3] << 8			      \

-	| ((__const unsigned char *) (addr))[2]) << 8			      \

-       | ((__const unsigned char *) (addr))[1]) << 8			      \

-      | ((__const unsigned char *) (addr))[0])

+     (((((const unsigned char *) (addr))[3] << 8			      \

+	| ((const unsigned char *) (addr))[2]) << 8			      \

+       | ((const unsigned char *) (addr))[1]) << 8			      \

+      | ((const unsigned char *) (addr))[0])

 #  define put16u(addr, val) \

      ({ uint16_t __val = (val);						      \

@@ -241,13 +240,13 @@

 	(void) 0; })

 # else

 #  define get16u(addr) \

-     (((__const unsigned char *) (addr))[0] << 8			      \

-      | ((__const unsigned char *) (addr))[1])

+     (((const unsigned char *) (addr))[0] << 8				      \

+      | ((const unsigned char *) (addr))[1])

 #  define get32u(addr) \

-     (((((__const unsigned char *) (addr))[0] << 8			      \

-	| ((__const unsigned char *) (addr))[1]) << 8			      \

-       | ((__const unsigned char *) (addr))[2]) << 8			      \

-      | ((__const unsigned char *) (addr))[3])

+     (((((const unsigned char *) (addr))[0] << 8			      \

+	| ((const unsigned char *) (addr))[1]) << 8			      \

+       | ((const unsigned char *) (addr))[2]) << 8			      \

+      | ((const unsigned char *) (addr))[3])

 #  define put16u(addr, val) \

      ({ uint16_t __val = (val);						      \

@@ -410,7 +409,7 @@

   /* If the function is called with no input this means we have to reset

      to the initial state.  The possibly partly converted input is

      dropped.  */

-  if (__builtin_expect (do_flush, 0))

+  if (__glibc_unlikely (do_flush))

     {

       /* This should never happen during error handling.  */

       assert (outbufstart == NULL);

@@ -461,7 +460,7 @@

 		      if (result != __GCONV_EMPTY_INPUT)

 			{

-			  if (__builtin_expect (outerr != outbuf, 0))

+			  if (__glibc_unlikely (outerr != outbuf))

 			    {

 			      /* We have a problem.  Undo the conversion.  */

 			      outbuf = outstart;

@@ -502,8 +501,9 @@

     }

   else

     {

-      /* We preserve the initial values of the pointer variables.  */

-      const unsigned char *inptr = *inptrp;

+      /* We preserve the initial values of the pointer variables,

+	 but only some conversion modules need it.  */

+      const unsigned char *inptr __attribute__ ((__unused__)) = *inptrp;

       unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)

 			       ? data->__outbuf : *outbufstart);

       unsigned char *outend = data->__outbufend;

@@ -514,7 +514,7 @@

       size_t *lirreversiblep = irreversible ? &lirreversible : NULL;

       /* The following assumes that encodings, which have a variable length

-	 what might unalign a buffer even though it is a aligned in the

+	 what might unalign a buffer even though it is an aligned in the

 	 beginning, either don't have the minimal number of bytes as a divisor

 	 of the maximum length or have a minimum length of 1.  This is true

 	 for all known and supported encodings.

@@ -523,7 +523,7 @@

 	 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL

 	 buffers are always aligned correctly.  */

 #define POSSIBLY_UNALIGNED \

-  (!defined _STRING_ARCH_unaligned					      \

+  (!_STRING_ARCH_unaligned					              \

    && (((FROM_LOOP_MIN_NEEDED_FROM != 1					      \

 	 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0)	      \

 	&& (FROM_LOOP_MIN_NEEDED_TO != 1				      \

@@ -554,8 +554,8 @@

 	  && consume_incomplete && (data->__statep->__count & 7) != 0)

 	{

 	  /* Yep, we have some bytes left over.  Process them now.

-             But this must not happen while we are called from an

-             error handler.  */

+	     But this must not happen while we are called from an

+	     error handler.  */

 	  assert (outbufstart == NULL);

 # if FROM_LOOP_MAX_NEEDED_FROM > 1

@@ -593,8 +593,6 @@

       while (1)

 	{

-	  struct __gconv_trans_data *trans;

-

 	  /* Remember the start value for this round.  */

 	  inptr = *inptrp;

 	  /* The outbuf buffer is empty.  */

@@ -604,7 +602,7 @@

 	  SAVE_RESET_STATE (1);

 #endif

-	  if (__builtin_expect (!unaligned, 1))

+	  if (__glibc_likely (!unaligned))

 	    {

 	      if (FROM_DIRECTION)

 		/* Run the conversion loop.  */

@@ -635,38 +633,31 @@

 	  /* If we were called as part of an error handling module we

 	     don't do anything else here.  */

-	  if (__builtin_expect (outbufstart != NULL, 0))

+	  if (__glibc_unlikely (outbufstart != NULL))

 	    {

 	      *outbufstart = outbuf;

 	      return status;

 	    }

-	  /* Give the transliteration module the chance to store the

-	     original text and the result in case it needs a context.  */

-	  for (trans = data->__trans; trans != NULL; trans = trans->__next)

-	    if (trans->__trans_context_fct != NULL)

-	      DL_CALL_FCT (trans->__trans_context_fct,

-			   (trans->__data, inptr, *inptrp, outstart, outbuf));

-

 	  /* We finished one use of the loops.  */

 	  ++data->__invocation_counter;

 	  /* If this is the last step leave the loop, there is nothing

-             we can do.  */

-	  if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))

+	     we can do.  */

+	  if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))

 	    {

 	      /* Store information about how many bytes are available.  */

 	      data->__outbuf = outbuf;

 	      /* Remember how many non-identical characters we

-                 converted in a irreversible way.  */

+		 converted in an irreversible way.  */

 	      *irreversible += lirreversible;

 	      break;

 	    }

 	  /* Write out all output which was produced.  */

-	  if (__builtin_expect (outbuf > outstart, 1))

+	  if (__glibc_likely (outbuf > outstart))

 	    {

 	      const unsigned char *outerr = data->__outbuf;

 	      int result;

@@ -677,14 +668,14 @@

 	      if (result != __GCONV_EMPTY_INPUT)

 		{

-		  if (__builtin_expect (outerr != outbuf, 0))

+		  if (__glibc_unlikely (outerr != outbuf))

 		    {

 #ifdef RESET_INPUT_BUFFER

 		      RESET_INPUT_BUFFER;

 #else

 		      /* We have a problem in one of the functions below.

 			 Undo the conversion upto the error point.  */

-		      size_t nstatus;

+		      size_t nstatus __attribute__ ((unused));

 		      /* Reload the pointers.  */

 		      *inptrp = inptr;

@@ -695,7 +686,7 @@

 		      SAVE_RESET_STATE (0);

 # endif

-		      if (__builtin_expect (!unaligned, 1))

+		      if (__glibc_likely (!unaligned))

 			{

 			  if (FROM_DIRECTION)

 			    /* Run the conversion loop.  */

@@ -738,7 +729,7 @@

 		      /* If we haven't consumed a single byte decrement

 			 the invocation counter.  */

-		      if (__builtin_expect (outbuf == outstart, 0))

+		      if (__glibc_unlikely (outbuf == outstart))

 			--data->__invocation_counter;

 #endif	/* reset input buffer */

 		    }

@@ -782,7 +773,7 @@

 	  STORE_REST

 # else

 	  /* Make sure the remaining bytes fit into the state objects

-             buffer.  */

+	     buffer.  */

 	  assert (inend - *inptrp < 4);

 	  size_t cnt;