[svn-r27031] Fix warnings in H5detect and clean up code, use unsigned variables

Use H5_GCC_DIAG_ON/OFF to suppress larger-than and float-equal warnings

Variables used with sigsetjmp/siglongjmp must be declared as volatile

Remove unnecessary use of volatile after r24171 fix and fix prototypes

Tested in release mode on:
- jam (CentOS 5.11 i386 GCC 4.1.2)
- ostrich (RHEL 6.6 ppc64 GCC 4.4.7)
- local linux (OpenSuSE 13.2 x86_64 GCC 4.8.3)
- local linux (Fedora 21 x86_64 GCC 4.9.2)
- local linux (Fedora 21 x86_64 ICC 15.0.2)
- local windows (Windows 8.1 x86_64 MSVC 2013 update 4)
- lemur (MacOSX 10.10.3 x86_64 clang-602.0.49 Xcode 6.3.1)
- ibm p95a07 (Ubuntu 14.10 ppc64le GCC 4.9.1)
- ibm p95a07 (Ubuntu 14.10 ppc64le IBM XL C V13.1.1)
- bluewaters (Cray PE 2.2.1 x86_64 GCC 4.8.2)
- bluewaters (Cray PE 2.2.1 x86_64 Cray C 8.3.3)
- bluewaters (Cray PE 2.2.1 x86_64 PGCC 14.2)

1 files changed, 152 insertions, 149 deletions

diff --git a/src/H5detect.c b/src/H5detect.c
index 9947b48..15736bd 100644
--- a/src/H5detect.c
+++ b/src/H5detect.c
@@ -90,41 +90,41 @@ static const char *FileHeader = "\n\
  * was detected.
  */
 typedef struct detected_t {
-    const char		*varname;
-    int			size;		/*total byte size		*/
-    int			precision;	/*meaningful bits		*/
-    int			offset;		/*bit offset to meaningful bits	*/
-    int			perm[32];	/*for detection of byte order	*/
-    int                 is_vax;         /*for vax (float & double) only */
-    int			sign;		/*location of sign bit		*/
-    int			mpos, msize, imp;/*information about mantissa	*/
-    int			epos, esize;	/*information about exponent	*/
-    unsigned long	bias;		/*exponent bias for floating pt.*/
-    size_t		align;		/*required byte alignment	*/
-    size_t		comp_align;	/*alignment for structure       */
+    const char *varname;
+    unsigned int size;                  /* total byte size                  */
+    unsigned int precision;             /* meaningful bits                  */
+    unsigned int offset;                /* bit offset to meaningful bits    */
+    int perm[32];                       /* for detection of byte order      */
+    hbool_t is_vax;                     /* for vax (float & double) only    */
+    unsigned int sign;                  /* location of sign bit             */
+    unsigned int mpos, msize, imp;      /* information about mantissa       */
+    unsigned int epos, esize;           /* information about exponent       */
+    unsigned long bias;                 /* exponent bias for floating pt    */
+    unsigned int align;                 /* required byte alignment          */
+    unsigned int comp_align;            /* alignment for structure          */
 } detected_t;
 
 /* This structure holds structure alignment for pointers, hvl_t, hobj_ref_t,
  * hdset_reg_ref_t */
 typedef struct malign_t {
     const char          *name;
-    size_t              comp_align;         /*alignment for structure   */
+    unsigned int         comp_align;    /* alignment for structure          */
 } malign_t;
 
 /* global variables types detection code */
-static detected_t	d_g[MAXDETECT];
-static malign_t        m_g[MAXDETECT];
-static volatile int	nd_g = 0, na_g = 0;
+H5_GCC_DIAG_OFF(larger-than=)
+static detected_t d_g[MAXDETECT];
+H5_GCC_DIAG_ON(larger-than=)
+static malign_t m_g[MAXDETECT];
+static volatile int nd_g = 0, na_g = 0;
 
 static void print_results(int nd, detected_t *d, int na, malign_t *m);
 static void iprint(detected_t *);
 static int byte_cmp(int, const void *, const void *, const unsigned char *);
-static int bit_cmp(int, int *, volatile void *, volatile void *,
-    const unsigned char *);
+static unsigned int bit_cmp(unsigned int, int *, void *, void *, const unsigned char *);
 static void fix_order(int, int, int *, const char **);
-static int imp_bit(int, int *, volatile void *, volatile void *,
-    const unsigned char *);
-static unsigned long find_bias(int, int, int *, volatile void *);
+static unsigned int imp_bit(unsigned int, int *, void *, void *, const unsigned char *);
+static unsigned int find_bias(unsigned int, unsigned int, int *, void *);
 static void precision (detected_t*);
 static void print_header(void);
 static void detect_C89_integers(void);
@@ -136,7 +136,7 @@ static void detect_C99_integers16(void);
 static void detect_C99_integers32(void);
 static void detect_C99_integers64(void);
 static void detect_alignments(void);
-static size_t align_g[] = {1, 2, 4, 8, 16};
+static unsigned int align_g[] = {1, 2, 4, 8, 16};
 static int align_status_g = 0;		/* ALIGNMENT Signal Status */
 static int sigbus_handler_called_g = 0;	/* how many times called */
 static int sigsegv_handler_called_g = 0;/* how many times called */
@@ -167,39 +167,41 @@ static H5JMP_BUF jbuf_g;
 static void
 precision (detected_t *d)
 {
-    int		n;
+    unsigned int n;
 
-    if (0==d->msize) {
-	/*
-	 * An integer.	The permutation can have negative values at the
-	 * beginning or end which represent padding of bytes.  We must adjust
-	 * the precision and offset accordingly.
-	 */
-	if (d->perm[0] < 0) {
-	    /*
-	     * Lower addresses are padded.
-	     */
-	    for (n=0; n<d->size && d->perm[n]<0; n++) /*void*/;
-	    d->precision = 8*(d->size-n);
-	    d->offset = 0;
-	} else if (d->perm[d->size - 1] < 0) {
-	    /*
-	     * Higher addresses are padded.
-	     */
-	    for (n=0; n<d->size && d->perm[d->size-(n+1)]; n++) /*void*/;
-	    d->precision = 8*(d->size-n);
-	    d->offset = 8*n;
-	} else {
-	    /*
-	     * No padding.
-	     */
-	    d->precision = 8*d->size;
-	    d->offset = 0;
-	}
+    if (0 == d->msize) {
+        /*
+         * An integer.	The permutation can have negative values at the
+         * beginning or end which represent padding of bytes.  We must adjust
+         * the precision and offset accordingly.
+         */
+        if (d->perm[0] < 0) {
+            /*
+             * Lower addresses are padded.
+             */
+            for (n = 0; n < d->size && d->perm[n] < 0; n++)
+                /*void*/;
+            d->precision = 8 * (d->size - n);
+            d->offset = 0;
+        } else if (d->perm[d->size - 1] < 0) {
+            /*
+             * Higher addresses are padded.
+             */
+            for (n = 0; n < d->size && d->perm[d->size - (n + 1)]; n++)
+                /*void*/;
+            d->precision = 8 * (d->size - n);
+            d->offset = 8 * n;
+        } else {
+            /*
+             * No padding.
+             */
+            d->precision = 8 * d->size;
+            d->offset = 0;
+        }
     } else {
-	/* A floating point */
-	d->offset = MIN3 (d->mpos, d->epos, d->sign);
-	d->precision = d->msize + d->esize + 1;
+        /* A floating point */
+        d->offset = MIN3(d->mpos, d->epos, d->sign);
+        d->precision = d->msize + d->esize + 1;
     }
 }
 
@@ -251,7 +253,8 @@ precision (detected_t *d)
     INFO.size = sizeof(TYPE);                                                 \
                                                                               \
     for(_i = sizeof(DETECT_TYPE), _v = 0; _i > 0; --_i)                       \
-        _v = (_v << 8) + _i;                                                  \
+        _v = (DETECT_TYPE) ((DETECT_TYPE) (_v << 8) + (DETECT_TYPE) _i);      \
+                                                                              \
     for(_i = 0, _x = (unsigned char *)&_v; _i < (signed)sizeof(DETECT_TYPE); _i++) { \
         _j = (*_x++) - 1;                                                     \
         HDassert(_j < (signed)sizeof(DETECT_TYPE));                           \
@@ -290,9 +293,6 @@ precision (detected_t *d)
  *		absence of implicit mantissa bit, and exponent bias and
  *		initializes a detected_t structure with those properties.
  *
- * Note:	'volatile' is used for the variables below to prevent the
- *		compiler from optimizing them away.
- *
  * Return:	void
  *
  * Programmer:	Robb Matzke
@@ -302,12 +302,12 @@ precision (detected_t *d)
  *-------------------------------------------------------------------------
  */
 #define DETECT_F(TYPE,VAR,INFO) {                                             \
-    volatile TYPE _v1, _v2, _v3;                                              \
+    TYPE _v1, _v2, _v3;                                                       \
     unsigned char _buf1[sizeof(TYPE)], _buf3[sizeof(TYPE)];                   \
     unsigned char _pad_mask[sizeof(TYPE)];                                    \
     unsigned char _byte_mask;                                                 \
     int _i, _j, _last = (-1);                                                 \
-    char *_mesg;                                                              \
+    const char *_mesg;                                                        \
                                                                               \
     HDmemset(&INFO, 0, sizeof(INFO));                                         \
     INFO.varname = #VAR;                                                      \
@@ -326,11 +326,13 @@ precision (detected_t *d)
     _v1 = (TYPE)4.0L;                                                         \
     HDmemcpy(_buf1, (const void *)&_v1, sizeof(TYPE));                        \
     for(_i = 0; _i < (int)sizeof(TYPE); _i++)                                 \
-        for(_byte_mask = (unsigned char)1; _byte_mask; _byte_mask <<= 1) {    \
+        for(_byte_mask = (unsigned char)1; _byte_mask; _byte_mask = (unsigned char) (_byte_mask << 1)) {    \
             _buf1[_i] ^= _byte_mask;                                          \
             HDmemcpy((void *)&_v2, (const void *)_buf1, sizeof(TYPE));        \
+            H5_GCC_DIAG_OFF(float-equal)                                      \
             if(_v1 != _v2)                                                    \
                 _pad_mask[_i] |= _byte_mask;                                  \
+            H5_GCC_DIAG_ON(float-equal)                                       \
             _buf1[_i] ^= _byte_mask;                                          \
         } /* end for */                                                       \
                                                                               \
@@ -368,7 +370,7 @@ precision (detected_t *d)
     _v1 = (TYPE)1.0L;                                                         \
     _v2 = (TYPE)1.5L;                                                         \
     INFO.msize = bit_cmp (sizeof(TYPE), INFO.perm, &_v1, &_v2, _pad_mask);    \
-    INFO.msize += 1 + (INFO.imp?0:1) - INFO.mpos;                             \
+    INFO.msize += 1 + (unsigned int) (INFO.imp ? 0 : 1) - INFO.mpos;          \
                                                                               \
     /* Exponent */                                                            \
     INFO.epos = INFO.mpos + INFO.msize;                                       \
@@ -415,14 +417,13 @@ precision (detected_t *d)
         TYPE    x;                                                            \
     } s;                                                                      \
                                                                               \
-    COMP_ALIGN = (size_t)((char*)(&(s.x)) - (char*)(&s));                     \
+    COMP_ALIGN = (unsigned int)((char*)(&(s.x)) - (char*)(&s));               \
 }
 
 #if defined(H5SETJMP) && defined(H5_HAVE_SIGNAL)
 #define ALIGNMENT(TYPE,INFO) {						      \
-    char		*volatile _buf = NULL;				      \
-    volatile TYPE	_val = 1;						      \
-    volatile TYPE	_val2;						      \
+    char *volatile _buf = NULL;   					      \
+    TYPE _val = 1, _val2;						      \
     volatile size_t	_ano = 0;					      \
     void		(*_handler)(int) = HDsignal(SIGBUS, sigbus_handler);  \
     void		(*_handler2)(int) = HDsignal(SIGSEGV, sigsegv_handler);\
@@ -445,8 +446,10 @@ precision (detected_t *d)
 	else /* Little-Endian */					      \
 	    HDmemcpy(_buf+align_g[_ano]+(INFO.offset/8),((char *)&_val)+(INFO.offset/8),(size_t)(INFO.precision/8)); \
 	_val2 = *((TYPE*)(_buf+align_g[_ano]));				      \
+    H5_GCC_DIAG_OFF(float-equal)					      \
 	if(_val!=_val2)							      \
 	    H5LONGJMP(jbuf_g, 1);		        		      \
+    H5_GCC_DIAG_ON(float-equal) 					      \
 	/* End Cray Check */						      \
 	(INFO.align)=align_g[_ano];					      \
     } else {								      \
@@ -881,63 +884,69 @@ done:\n\
 static void
 iprint(detected_t *d)
 {
-    int		i, j, k, pass;
+    unsigned int pass;
 
-    for (pass=(d->size-1)/4; pass>=0; --pass) {
-	/*
-	 * Print the byte ordering above the bit fields.
-	 */
-	printf("    * ");
-	for (i=MIN(pass*4+3,d->size-1); i>=pass*4; --i) {
-	    printf ("%4d", d->perm[i]);
-	    if (i>pass*4) HDfputs ("     ", stdout);
-	}
+    for (pass = (d->size - 1) / 4; ; --pass) {
+        unsigned int i, k;
+        /*
+         * Print the byte ordering above the bit fields.
+         */
+        printf("    * ");
+        for (i = MIN(pass * 4 + 3, d->size - 1); i >= pass * 4; --i) {
+            printf("%4d", d->perm[i]);
+            if (i > pass * 4) HDfputs("     ", stdout);
+            if (!i) break;
+        }
 
-	/*
-	 * Print the bit fields
-	 */
-	printf("\n    * ");
-	for (i=MIN(pass*4+3,d->size-1),
-	     k=MIN(pass*32+31,8*d->size-1);
-	     i>=pass*4; --i) {
-	    for (j=7; j>=0; --j) {
-		if (k==d->sign && d->msize) {
-		    HDputchar('S');
-		} else if (k>=d->epos && k<d->epos+d->esize) {
-		    HDputchar('E');
-		} else if (k>=d->mpos && k<d->mpos+d->msize) {
-		    HDputchar('M');
-		} else if (d->msize) {
-		    HDputchar('?');   /*unknown floating point bit */
-		} else if (d->sign) {
-		    HDputchar('I');
-		} else {
-		    HDputchar('U');
-		}
-		--k;
-	    }
-	    if (i>pass*4) HDputchar(' ');
-	}
-	HDputchar('\n');
+        /*
+         * Print the bit fields
+         */
+        printf("\n    * ");
+        for (i = MIN(pass * 4 + 3, d->size - 1), k = MIN(pass * 32 + 31,
+                8 * d->size - 1); i >= pass * 4; --i) {
+            unsigned int j;
+
+            for (j = 8; j > 0; --j) {
+                if (k == d->sign && d->msize) {
+                    HDputchar('S');
+                } else if (k >= d->epos && k < d->epos + d->esize) {
+                    HDputchar('E');
+                } else if (k >= d->mpos && k < d->mpos + d->msize) {
+                    HDputchar('M');
+                } else if (d->msize) {
+                    HDputchar('?'); /*unknown floating point bit */
+                } else if (d->sign) {
+                    HDputchar('I');
+                } else {
+                    HDputchar('U');
+                }
+                --k;
+            }
+            if (i > pass * 4) HDputchar(' ');
+            if (!i) break;
+        }
+        HDputchar('\n');
+        if (!pass) break;
     }
 
     /*
      * Is there an implicit bit in the mantissa.
      */
     if (d->msize) {
-	printf("    * Implicit bit? %s\n", d->imp ? "yes" : "no");
+        printf("    * Implicit bit? %s\n", d->imp ? "yes" : "no");
     }
 
     /*
      * Alignment
      */
-    if (0==d->align) {
-	printf("    * Alignment: NOT CALCULATED\n");
-    } else if (1==d->align) {
-	printf("    * Alignment: none\n");
+    if (0 == d->align) {
+        printf("    * Alignment: NOT CALCULATED\n");
+    } else if (1 == d->align) {
+        printf("    * Alignment: none\n");
     } else {
-	printf("    * Alignment: %lu\n", (unsigned long)(d->align));
+        printf("    * Alignment: %lu\n", (unsigned long) (d->align));
     }
+
 }
 
 
@@ -985,31 +994,25 @@ byte_cmp(int n, const void *_a, const void *_b, const unsigned char *pad_mask)
  *		actual order to little endian.  Ignores differences where
  *              the corresponding bit in pad_mask is set to 0.
  *
- * Return:	Success:	Index of first differing bit.
- *
- *		Failure:	-1
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 13, 1996
- *
- * Modifications:
+ * Return:	Index of first differing bit.
  *
  *-------------------------------------------------------------------------
  */
-static int
-bit_cmp(int nbytes, int *perm, volatile void *_a, volatile void *_b,
-    const unsigned char *pad_mask)
+static unsigned int
+bit_cmp(unsigned int nbytes, int *perm, void *_a, void *_b,
+        const unsigned char *pad_mask)
 {
-    int                 i, j;
-    volatile unsigned char      *a = (volatile unsigned char *) _a;
-    volatile unsigned char      *b = (volatile unsigned char *) _b;
-    unsigned char       aa, bb;
+    unsigned int i;
+    unsigned char *a = (unsigned char *) _a;
+    unsigned char *b = (unsigned char *) _b;
+    unsigned char aa, bb;
 
     for (i = 0; i < nbytes; i++) {
-        HDassert(perm[i] < nbytes);
-        if ((aa = a[perm[i]] & pad_mask[perm[i]])
-                != (bb = b[perm[i]] & pad_mask[perm[i]])) {
+        HDassert(perm[i] < (int) nbytes);
+        if ((aa = (unsigned char) (a[perm[i]] & pad_mask[perm[i]]))
+                != (bb = (unsigned char) (b[perm[i]] & pad_mask[perm[i]]))) {
+            unsigned int j;
+
             for (j = 0; j < 8; j++, aa >>= 1, bb >>= 1) {
                 if ((aa & 1) != (bb & 1)) return i * 8 + j;
             }
@@ -1017,7 +1020,9 @@ bit_cmp(int nbytes, int *perm, volatile void *_a, volatile void *_b,
             HDabort();
         }
     }
-    return -1;
+    fprintf(stderr, "INTERNAL ERROR");
+    HDabort();
+    return 0;
 }
 
 
@@ -1123,21 +1128,19 @@ fix_order(int n, int last, int *perm, const char **mesg)
  *
  *-------------------------------------------------------------------------
  */
-static int
-imp_bit(int n, int *perm, volatile void *_a, volatile void *_b,
-    const unsigned char *pad_mask)
+static unsigned int
+imp_bit(unsigned int n, int *perm, void *_a, void *_b, const unsigned char *pad_mask)
 {
-    volatile unsigned char      *a = (volatile unsigned char *) _a;
-    volatile unsigned char      *b = (volatile unsigned char *) _b;
-    int                 changed, major, minor;
-    int                 msmb;   /*most significant mantissa bit */
+    unsigned char *a = (unsigned char *) _a;
+    unsigned char *b = (unsigned char *) _b;
+    unsigned int changed, major, minor;
+    unsigned int msmb; /* most significant mantissa bit */
 
     /*
      * Look for the least significant bit that has changed between
      * A and B.  This is the least significant bit of the exponent.
      */
     changed = bit_cmp(n, perm, a, b, pad_mask);
-    HDassert(changed >= 0);
 
     /*
      * The bit to the right (less significant) of the changed bit should
@@ -1174,22 +1177,22 @@ imp_bit(int n, int *perm, volatile void *_a, volatile void *_b,
  *
  *-------------------------------------------------------------------------
  */
-static unsigned long
-find_bias(int epos, int esize, int *perm, volatile void *_a)
+static unsigned int
+find_bias(unsigned int epos, unsigned int esize, int *perm, void *_a)
 {
-    unsigned char	*a = (unsigned char *) _a;
-    unsigned char	mask;
-    unsigned long	b, shift = 0, nbits, bias = 0;
+    unsigned char *a = (unsigned char *) _a;
+    unsigned char mask;
+    unsigned int b, shift = 0, nbits, bias = 0;
 
     while (esize > 0) {
-	nbits = MIN(esize, (8 - epos % 8));
-	mask = (1 << nbits) - 1;
-	b = (a[perm[epos / 8]] >> (epos % 8)) & mask;
-	bias |= b << shift;
-
-	shift += nbits;
-	esize -= nbits;
-	epos += nbits;
+        nbits = MIN(esize, (8 - epos % 8));
+        mask = (unsigned char) ((1 << nbits) - 1);
+        b = (unsigned int) (a[perm[epos / 8]] >> (epos % 8)) & mask;
+        bias |= b << shift;
+
+        shift += nbits;
+        esize -= nbits;
+        epos += nbits;
     }
     return bias;
 }
@@ -1667,7 +1670,7 @@ detect_alignments(void)
 static int verify_signal_handlers(int signum, void (*handler)(int))
 {						      
     void	(*save_handler)(int) = HDsignal(signum, handler);    
-    int i, val;
+    volatile int i, val;
     int ntries=5;
     volatile int nfailures=0;
     volatile int nsuccesses=0;