This is the mail archive of the glibc-cvs@sourceware.org mailing list for the glibc project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

GNU C Library master sources branch master updated. glibc-2.28.9000-497-g0253580


This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU C Library master sources".

The branch, master has been updated
       via  0253580a75decdaf22b6abce60d8265b2adb7dea (commit)
      from  09104e5ba47de6691a371d214da48dd8493c39bd (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://sourceware.org/git/gitweb.cgi?p=glibc.git;a=commitdiff;h=0253580a75decdaf22b6abce60d8265b2adb7dea

commit 0253580a75decdaf22b6abce60d8265b2adb7dea
Author: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Date:   Fri Dec 21 09:49:37 2018 -0200

    Replace check_mul_overflow_size_t with __builtin_mul_overflow
    
    Checked on x86_64-linux-gnu and i686-linux-gnu.
    
    	* malloc/alloc_buffer_alloc_array.c (__libc_alloc_buffer_alloc_array):
    	Use __builtin_mul_overflow in place of check_mul_overflow_size_t.
    	* malloc/dynarray_emplace_enlarge.c (__libc_dynarray_emplace_enlarge):
    	Likewise.
    	* malloc/dynarray_resize.c (__libc_dynarray_resize): Likewise.
    	* malloc/reallocarray.c (__libc_reallocarray): Likewise.
    	* malloc/malloc-internal.h (check_mul_overflow_size_t): Remove
    	function.
    	* support/blob_repeat.c (check_mul_overflow_size_t,
    	(minimum_stride_size, support_blob_repeat_allocate): Likewise.

diff --git a/ChangeLog b/ChangeLog
index 241f621..86d978c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2018-12-28  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
+
+	* malloc/alloc_buffer_alloc_array.c (__libc_alloc_buffer_alloc_array):
+	Use __builtin_mul_overflow in place of check_mul_overflow_size_t.
+	* malloc/dynarray_emplace_enlarge.c (__libc_dynarray_emplace_enlarge):
+	Likewise.
+	* malloc/dynarray_resize.c (__libc_dynarray_resize): Likewise.
+	* malloc/reallocarray.c (__libc_reallocarray): Likewise.
+	* malloc/malloc-internal.h (check_mul_overflow_size_t): Remove
+	function.
+	* support/blob_repeat.c (check_mul_overflow_size_t,
+	(minimum_stride_size, support_blob_repeat_allocate): Likewise.
+
 2018-12-28  Aurelien Jarno  <aurelien@aurel32.net>
 
 	* sysdeps/alpha/fpu/libm-test-ulps: Regenerated.
diff --git a/malloc/alloc_buffer_alloc_array.c b/malloc/alloc_buffer_alloc_array.c
index 1dd098a..7505422 100644
--- a/malloc/alloc_buffer_alloc_array.c
+++ b/malloc/alloc_buffer_alloc_array.c
@@ -17,7 +17,6 @@
    <http://www.gnu.org/licenses/>.  */
 
 #include <alloc_buffer.h>
-#include <malloc-internal.h>
 #include <libc-pointer-arith.h>
 
 void *
@@ -28,7 +27,7 @@ __libc_alloc_buffer_alloc_array (struct alloc_buffer *buf, size_t element_size,
   /* The caller asserts that align is a power of two.  */
   size_t aligned = ALIGN_UP (current, align);
   size_t size;
-  bool overflow = check_mul_overflow_size_t (element_size, count, &size);
+  bool overflow = __builtin_mul_overflow (element_size, count, &size);
   size_t new_current = aligned + size;
   if (!overflow                /* Multiplication did not overflow.  */
       && aligned >= current    /* No overflow in align step.  */
diff --git a/malloc/dynarray_emplace_enlarge.c b/malloc/dynarray_emplace_enlarge.c
index 0408271..aa8f5fa 100644
--- a/malloc/dynarray_emplace_enlarge.c
+++ b/malloc/dynarray_emplace_enlarge.c
@@ -18,7 +18,6 @@
 
 #include <dynarray.h>
 #include <errno.h>
-#include <malloc-internal.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -52,7 +51,7 @@ __libc_dynarray_emplace_enlarge (struct dynarray_header *list,
     }
 
   size_t new_size;
-  if (check_mul_overflow_size_t (new_allocated, element_size, &new_size))
+  if (__builtin_mul_overflow (new_allocated, element_size, &new_size))
     return false;
   void *new_array;
   if (list->array == scratch)
diff --git a/malloc/dynarray_resize.c b/malloc/dynarray_resize.c
index 0bfca1b..0205cf7 100644
--- a/malloc/dynarray_resize.c
+++ b/malloc/dynarray_resize.c
@@ -18,7 +18,6 @@
 
 #include <dynarray.h>
 #include <errno.h>
-#include <malloc-internal.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -38,7 +37,7 @@ __libc_dynarray_resize (struct dynarray_header *list, size_t size,
      over-allocation here.  */
 
   size_t new_size_bytes;
-  if (check_mul_overflow_size_t (size, element_size, &new_size_bytes))
+  if (__builtin_mul_overflow (size, element_size, &new_size_bytes))
     {
       /* Overflow.  */
       __set_errno (ENOMEM);
diff --git a/malloc/malloc-internal.h b/malloc/malloc-internal.h
index 9cee0fb..70d5b38 100644
--- a/malloc/malloc-internal.h
+++ b/malloc/malloc-internal.h
@@ -74,24 +74,4 @@ void __malloc_fork_unlock_child (void) attribute_hidden;
 /* Called as part of the thread shutdown sequence.  */
 void __malloc_arena_thread_freeres (void) attribute_hidden;
 
-/* Set *RESULT to LEFT * RIGHT.  Return true if the multiplication
-   overflowed.  */
-static inline bool
-check_mul_overflow_size_t (size_t left, size_t right, size_t *result)
-{
-#if __GNUC__ >= 5
-  return __builtin_mul_overflow (left, right, result);
-#else
-  /* size_t is unsigned so the behavior on overflow is defined.  */
-  *result = left * right;
-  size_t half_size_t = ((size_t) 1) << (8 * sizeof (size_t) / 2);
-  if (__glibc_unlikely ((left | right) >= half_size_t))
-    {
-      if (__glibc_unlikely (right != 0 && *result / right != left))
-        return true;
-    }
-  return false;
-#endif
-}
-
 #endif /* _MALLOC_INTERNAL_H */
diff --git a/malloc/reallocarray.c b/malloc/reallocarray.c
index 319eccd..3264230 100644
--- a/malloc/reallocarray.c
+++ b/malloc/reallocarray.c
@@ -18,19 +18,17 @@
 
 #include <errno.h>
 #include <malloc.h>
-#include <malloc/malloc-internal.h>
 
 void *
 __libc_reallocarray (void *optr, size_t nmemb, size_t elem_size)
 {
   size_t bytes;
-  if (check_mul_overflow_size_t (nmemb, elem_size, &bytes))
+  if (__builtin_mul_overflow (nmemb, elem_size, &bytes))
     {
       __set_errno (ENOMEM);
       return 0;
     }
-  else
-    return realloc (optr, bytes);
+  return realloc (optr, bytes);
 }
 libc_hidden_def (__libc_reallocarray)
 
diff --git a/support/blob_repeat.c b/support/blob_repeat.c
index 718846d..daa1b7f 100644
--- a/support/blob_repeat.c
+++ b/support/blob_repeat.c
@@ -34,26 +34,6 @@
    optimization because mappings carry a lot of overhead.  */
 static const size_t maximum_small_size = 4 * 1024 * 1024;
 
-/* Set *RESULT to LEFT * RIGHT.  Return true if the multiplication
-   overflowed.  See <malloc/malloc-internal.h>.  */
-static inline bool
-check_mul_overflow_size_t (size_t left, size_t right, size_t *result)
-{
-#if __GNUC__ >= 5
-  return __builtin_mul_overflow (left, right, result);
-#else
-  /* size_t is unsigned so the behavior on overflow is defined.  */
-  *result = left * right;
-  size_t half_size_t = ((size_t) 1) << (8 * sizeof (size_t) / 2);
-  if (__glibc_unlikely ((left | right) >= half_size_t))
-    {
-      if (__glibc_unlikely (right != 0 && *result / right != left))
-        return true;
-    }
-  return false;
-#endif
-}
-
 /* Internal helper for fill.  */
 static void
 fill0 (char *target, const char *element, size_t element_size,
@@ -138,8 +118,8 @@ minimum_stride_size (size_t page_size, size_t element_size)
      common multiple, it appears only once.  Therefore, shift one
      factor.  */
   size_t multiple;
-  if (check_mul_overflow_size_t (page_size >> common_zeros, element_size,
-                                 &multiple))
+  if (__builtin_mul_overflow (page_size >> common_zeros, element_size,
+			      &multiple))
     return 0;
   return multiple;
 }
@@ -275,7 +255,7 @@ support_blob_repeat_allocate (const void *element, size_t element_size,
                               size_t count)
 {
   size_t total_size;
-  if (check_mul_overflow_size_t (element_size, count, &total_size))
+  if (__builtin_mul_overflow (element_size, count, &total_size))
     {
       errno = EOVERFLOW;
       return (struct support_blob_repeat) { 0 };

-----------------------------------------------------------------------

Summary of changes:
 ChangeLog                         |   13 +++++++++++++
 malloc/alloc_buffer_alloc_array.c |    3 +--
 malloc/dynarray_emplace_enlarge.c |    3 +--
 malloc/dynarray_resize.c          |    3 +--
 malloc/malloc-internal.h          |   20 --------------------
 malloc/reallocarray.c             |    6 ++----
 support/blob_repeat.c             |   26 +++-----------------------
 7 files changed, 21 insertions(+), 53 deletions(-)


hooks/post-receive
-- 
GNU C Library master sources


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]