Take care of two Clang warnings.

source/i18n/decNumber.c

 /* ------------------------------------------------------------------ */
 /* Decimal Number arithmetic module                                   */
 /* ------------------------------------------------------------------ */
 /* Copyright (c) IBM Corporation, 2000-2010.  All rights reserved.    */
 /*                                                                    */
 /* This software is made available under the terms of the             */
 /* ICU License -- ICU 1.8.1 and later.                                */
 /*                                                                    */
 /* The description and User's Guide ("The decNumber C Library") for   */
 /* this software is called decNumber.pdf.  This document is           */
@@ skipping 1374 matching lines @@
 /* almost always be correctly rounded, but may be up to 1 ulp in      */
 /* error in rare cases.                                               */
 /* ------------------------------------------------------------------ */
 /* This calculates ln(A)/ln(10) using appropriate precision.  For     */
 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
 /* requested digits and t is the number of digits in the exponent     */
 /* (maximum 6).  For ln(10) it is p + 3; this is often handled by the */
 /* fastpath in decLnOp.  The final division is done to the requested  */
 /* precision.                                                         */
 /* ------------------------------------------------------------------ */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warray-bounds"
 U_CAPI decNumber * U_EXPORT2 uprv_decNumberLog10(decNumber *res, const decNumber *rhs,
                           decContext *set) {
   uInt status=0, ignore=0;         /* status accumulators  */
   uInt needbytes;                  /* for space calculations  */
   Int p;                           /* working precision  */
   Int t;                           /* digits in exponent of A  */
 
   /* buffers for a and b working decimals  */
   /* (adjustment calculator, same size)  */
   decNumber bufa[D2N(DECBUFFER+2)];
@@ skipping 115 matching lines @@
   #if DECSUBSET
   if (allocrhs !=NULL) free(allocrhs);  /* ..  */
   #endif
   /* apply significant status  */
   if (status!=0) decStatus(res, status, set);
   #if DECCHECK
   decCheckInexact(res, set);
   #endif
   return res;
   } /* decNumberLog10  */
+#pragma clang diagnostic pop
 
 /* ------------------------------------------------------------------ */
 /* decNumberMax -- compare two Numbers and return the maximum         */
 /*                                                                    */
 /*   This computes C = A ? B, returning the maximum by 754 rules      */
 /*                                                                    */
 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 /*   lhs is A                                                         */
 /*   rhs is B                                                         */
 /*   set is the context                                               */
@@ skipping 1253 matching lines @@
 /*   else                                                             */
 /*     const approxaddhalf := approx + setexp(.5, -p)                 */
 /*     if mulrd(approxaddhalf, approxaddhalf) < f then                */
 /*       approx := approx + setexp(.l, -p + 1)                        */
 /*     end if                                                         */
 /*   end if                                                           */
 /* end                                                                */
 /* result setexp(approx, e div 2)  % fix exponent                     */
 /* end sqrt                                                           */
 /* ------------------------------------------------------------------ */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warray-bounds"
 U_CAPI decNumber * U_EXPORT2 uprv_decNumberSquareRoot(decNumber *res, const decNumber *rhs,
                                 decContext *set) {
   decContext workset, approxset;   /* work contexts  */
   decNumber dzero;                 /* used for constant zero  */
   Int  maxp;                       /* largest working precision  */
   Int  workp;                      /* working precision  */
   Int  residue=0;                  /* rounding residue  */
   uInt status=0, ignore=0;         /* status accumulators  */
   uInt rstatus;                    /* ..  */
   Int  exp;                        /* working exponent  */
@@ skipping 309 matching lines @@
   if (allocbufb!=NULL) free(allocbufb);      /* ..  */
   #if DECSUBSET
   if (allocrhs !=NULL) free(allocrhs);       /* ..  */
   #endif
   if (status!=0) decStatus(res, status, set);/* then report status  */
   #if DECCHECK
   decCheckInexact(res, set);
   #endif
   return res;
   } /* decNumberSquareRoot  */
+#pragma clang diagnostic pop
 
 /* ------------------------------------------------------------------ */
 /* decNumberSubtract -- subtract two Numbers                          */
 /*                                                                    */
 /*   This computes C = A - B                                          */
 /*                                                                    */
 /*   res is C, the result.  C may be A and/or B (e.g., X=X-X)         */
 /*   lhs is A                                                         */
 /*   rhs is B                                                         */
 /*   set is the context                                               */
@@ skipping 2435 matching lines @@
 /*    would certainly save at least one if it were made ten times     */
 /*    bigger, too (for truncated fractions 0.100 through 0.999).      */
 /*    However, for most practical evaluations, at least four or five  */
 /*    iterations will be neede -- so this would only speed up by      */
 /*    20-25% and that probably does not justify increasing the table  */
 /*    size.                                                           */
 /*                                                                    */
 /* 5. The static buffers are larger than might be expected to allow   */
 /*    for calls from decNumberPower.                                  */
 /* ------------------------------------------------------------------ */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warray-bounds"
 decNumber * decLnOp(decNumber *res, const decNumber *rhs,
                     decContext *set, uInt *status) {
   uInt ignore=0;                   /* working status accumulator  */
   uInt needbytes;                  /* for space calculations  */
   Int residue;                     /* rounding residue  */
   Int r;                           /* rhs=f*10**r [see below]  */
   Int p;                           /* working precision  */
   Int pp;                          /* precision for iteration  */
   Int t;                           /* work  */
 
@@ skipping 201 matching lines @@
     aset.digits=set->digits;            /* [use default rounding]  */
     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten  */
     decFinish(res, set, &residue, status);       /* cleanup/set flags  */
     } while(0);                         /* end protected  */
 
   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used  */
   if (allocbufb!=NULL) free(allocbufb); /* ..  */
   /* [status is handled by caller]  */
   return res;
   } /* decLnOp  */
+#pragma clang diagnostic pop
 
 /* ------------------------------------------------------------------ */
 /* decQuantizeOp  -- force exponent to requested value                */
 /*                                                                    */
 /*   This computes C = op(A, B), where op adjusts the coefficient     */
 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
 /*   of C has the value B or matches the exponent of B.               */
 /*   The numerical value of C will equal A, except for the effects of */
 /*   any rounding that occurred.                                      */
 /*                                                                    */
@@ skipping 2316 matching lines @@
   for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
     printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
            b-b0-8, (LI)b0, (LI)n);
   free(b0);                        /* drop the storage  */
   decAllocBytes-=n;                /* account for storage  */
   /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n);  */
   } /* decFree  */
 #define malloc(a) decMalloc(a)
 #define free(a) decFree(a)
 #endif