Define _STRING_ARCH_unaligned unconditionally

This patch defines _STRING_ARCH_unaligned to 0 on default bits/string.h
header to avoid undefined compiler warnings on platforms that do not
define it.  It also make adjustments in code where tests checked if macro
existed or not.

diff --git a/ChangeLog b/ChangeLog
index 414e04356d35615a3a8e21ad76930de93fe4b43a..4598b6064834200aca538f546170c244d8a73d6d 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2014-04-09  Adhemerval Zanella  <azanella@linux.vnet.ibm.com>
+
+       * bits/string.h (_STRING_ARCH_unaligned): Define it to 0.
+       * crypt/sha256.c (_STRING_ARCH_unaligned): Check its value instead of its
+       definition.
+       * iconv/gconv_simple.c (_STRING_ARCH_unaligned): Likewise.
+       * iconv/loop.c (_STRING_ARCH_unaligned): Likewise.
+       * iconv/skeleton.c (_STRING_ARCH_unaligned): Likewise.
+       * nscd/nscd_gethst_r.c (_STRING_ARCH_unaligned): Likewise.
+       * nscd/nscd_getserv_r.c (_STRING_ARCH_unaligned): Likewise.
+       * nscd/nscd_helper.c (_STRING_ARCH_unaligned): Likewise.
+       * resolv/res_send.c (_STRING_ARCH_unaligned): Likewise.
+
 2014-04-09  Peter Brett  <peter@peter-b.co.uk>
 
        [BZ #15514]

diff --git a/bits/string.h b/bits/string.h
index f8630d2c52a9298ae3d5ab7392d49e2c36c97af7..b88a6bc601803f68a19531d86ce7acdaec65b93b 100644 (file)
--- a/bits/string.h
+++ b/bits/string.h
@@ -8,5 +8,7 @@
 #ifndef _BITS_STRING_H
 #define _BITS_STRING_H 1
 
+/* Define if architecture can access unaligned multi-byte variables.  */
+#define _STRING_ARCH_unaligned   0
 
 #endif /* bits/string.h */

diff --git a/crypt/sha256.c b/crypt/sha256.c
index a5df83e23ab2f4b6f2b7d3267ec2f2851f5ecc43..4e1b504c9920adbd5f148daf5e2de032caef9038 100644 (file)
--- a/crypt/sha256.c
+++ b/crypt/sha256.c
@@ -125,7 +125,7 @@ __sha256_finish_ctx (ctx, resbuf)
   memcpy (&ctx->buffer[bytes], fillbuf, pad);
 
   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
-#ifdef _STRING_ARCH_unaligned
+#if _STRING_ARCH_unaligned
   ctx->buffer64[(bytes + pad) / 8] = SWAP64 (ctx->total64 << 3);
 #else
   ctx->buffer32[(bytes + pad + 4) / 4] = SWAP (ctx->total[TOTAL64_low] << 3);

diff --git a/iconv/gconv_simple.c b/iconv/gconv_simple.c
index e11e2eea2dd583440c9342f95e888e81ffb39999..f357713d9381d7815acd744cc55250c75c7b94fc 100644 (file)
--- a/iconv/gconv_simple.c
+++ b/iconv/gconv_simple.c
@@ -112,7 +112,7 @@ internal_ucs4_loop (struct __gconv_step *step,
   return result;
 }
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
 static inline int
 __attribute ((always_inline))
 internal_ucs4_loop_unaligned (struct __gconv_step *step,
@@ -289,7 +289,7 @@ ucs4_internal_loop (struct __gconv_step *step,
   return result;
 }
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
 static inline int
 __attribute ((always_inline))
 ucs4_internal_loop_unaligned (struct __gconv_step *step,
@@ -478,7 +478,7 @@ internal_ucs4le_loop (struct __gconv_step *step,
   return result;
 }
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
 static inline int
 __attribute ((always_inline))
 internal_ucs4le_loop_unaligned (struct __gconv_step *step,
@@ -658,7 +658,7 @@ ucs4le_internal_loop (struct __gconv_step *step,
   return result;
 }
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
 static inline int
 __attribute ((always_inline))
 ucs4le_internal_loop_unaligned (struct __gconv_step *step,

diff --git a/iconv/loop.c b/iconv/loop.c
index f836d08c37ea6ce745565491f9f6c9c244ba9bb7..f86f62747aef60eafdcd538a957178e777ea711b 100644 (file)
--- a/iconv/loop.c
+++ b/iconv/loop.c
@@ -63,7 +63,7 @@
    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))
@@ -342,7 +342,7 @@ FCTNAME (LOOPFCT) (struct __gconv_step *step,
 
 /* 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

diff --git a/iconv/skeleton.c b/iconv/skeleton.c
index 14318a6a5303ebf9343c210c63e0e56fe5d55fac..c3f161ad013fcf0ec08a75ddcbfbb83a24a4030e 100644 (file)
--- a/iconv/skeleton.c
+++ b/iconv/skeleton.c
@@ -204,7 +204,7 @@
 /* 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))
@@ -523,7 +523,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
         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                                      \

diff --git a/nscd/nscd_gethst_r.c b/nscd/nscd_gethst_r.c
index fe885ee320b0ed7011c4376bcb4f39c51cc7af23..265f4d0c24815c755959dd1696ecc0ec16d99089 100644 (file)
--- a/nscd/nscd_gethst_r.c
+++ b/nscd/nscd_gethst_r.c
@@ -191,7 +191,7 @@ nscd_gethst_r (const char *key, size_t keylen, request_type type,
              goto out;
            }
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
          /* The aliases_len array in the mapped database might very
             well be unaligned.  We will access it word-wise so on
             platforms which do not tolerate unaligned accesses we

diff --git a/nscd/nscd_getserv_r.c b/nscd/nscd_getserv_r.c
index 4e3f702b84690275944d5165dad2378e34f10aae..f079a77aa70aa2185a3992957143b526eab109fa 100644 (file)
--- a/nscd/nscd_getserv_r.c
+++ b/nscd/nscd_getserv_r.c
@@ -141,7 +141,7 @@ nscd_getserv_r (const char *crit, size_t critlen, const char *proto,
                                > recend, 0))
            goto out;
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
          /* The aliases_len array in the mapped database might very
             well be unaligned.  We will access it word-wise so on
             platforms which do not tolerate unaligned accesses we

diff --git a/nscd/nscd_helper.c b/nscd/nscd_helper.c
index 0d61643f10d9de6f82e286316e84bd939e67a0d7..9fe1f46156b06b587fdf97b8166a67fa2acfd03f 100644 (file)
--- a/nscd/nscd_helper.c
+++ b/nscd/nscd_helper.c
@@ -490,7 +490,7 @@ __nscd_cache_search (request_type type, const char *key, size_t keylen,
       struct hashentry *here = (struct hashentry *) (mapped->data + work);
       ref_t here_key, here_packet;
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
       /* Although during garbage collection when moving struct hashentry
         records around we first copy from old to new location and then
         adjust pointer from previous hashentry to it, there is no barrier
@@ -512,7 +512,7 @@ __nscd_cache_search (request_type type, const char *key, size_t keylen,
          struct datahead *dh
            = (struct datahead *) (mapped->data + here_packet);
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
          if ((uintptr_t) dh & (__alignof__ (*dh) - 1))
            return NULL;
 #endif
@@ -536,7 +536,7 @@ __nscd_cache_search (request_type type, const char *key, size_t keylen,
          struct hashentry *trailelem;
          trailelem = (struct hashentry *) (mapped->data + trail);
 
-#ifndef _STRING_ARCH_unaligned
+#if !_STRING_ARCH_unaligned
          /* We have to redo the checks.  Maybe the data changed.  */
          if ((uintptr_t) trailelem & (__alignof__ (*trailelem) - 1))
            return NULL;

diff --git a/resolv/res_send.c b/resolv/res_send.c
index ce7127e1b16950758ee7bb7d11b4e2184317cee5..60743dfa8c60c219270edfd33760d96c1993291d 100644 (file)
--- a/resolv/res_send.c
+++ b/resolv/res_send.c
@@ -787,7 +787,7 @@ send_vc(res_state statp,
                        /* No buffer allocated for the first
                           reply.  We can try to use the rest
                           of the user-provided buffer.  */
-#ifdef _STRING_ARCH_unaligned
+#if _STRING_ARCH_unaligned
                        *anssizp2 = orig_anssizp - resplen;
                        *ansp2 = *ansp + resplen;
 #else
@@ -1205,7 +1205,7 @@ send_dg(res_state statp,
                                /* No buffer allocated for the first
                                   reply.  We can try to use the rest
                                   of the user-provided buffer.  */
-#ifdef _STRING_ARCH_unaligned
+#if _STRING_ARCH_unaligned
                                *anssizp2 = orig_anssizp - resplen;
                                *ansp2 = *ansp + resplen;
 #else