From patchwork Wed Jan 13 16:58:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 41710 X-Patchwork-Delegate: azanella@linux.vnet.ibm.com Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 771F73939C08; Wed, 13 Jan 2021 16:58:38 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 771F73939C08 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1610557118; bh=W0iPY8MXfOZDq7vxMA1Dx/K+GgOjUVegfSXlVKQQaEo=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=rfxx4NIGRlZ+Iy3yCF7L9wpRzna8GDTR0/qU4Ei50Tf7WHIPcHWP/xHAmDQ9/5nh+ maJJ6sCBS4Pc7kWqmL4dpf3jHw5Pffjf8vsewkJIe8UtrTBLBpipaO+fihQKBVqeRY rlbcKLkCDEqM7QlFBjzOMcIjdB5u33g2DKKjJNJE= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-qt1-x82e.google.com (mail-qt1-x82e.google.com [IPv6:2607:f8b0:4864:20::82e]) by sourceware.org (Postfix) with ESMTPS id 9D7443938C33 for ; Wed, 13 Jan 2021 16:58:34 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 9D7443938C33 Received: by mail-qt1-x82e.google.com with SMTP id 2so1532339qtt.10 for ; Wed, 13 Jan 2021 08:58:34 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=W0iPY8MXfOZDq7vxMA1Dx/K+GgOjUVegfSXlVKQQaEo=; b=hDfg05uiDlucwtVJST560ZNWNToS32OTayUINFLpr+eKYPRybr0sTgWELFy0pEPU6i fBflFxj+Ni3mOLhK9Y+1uZ3Y9alo2gIQqxbfcMxuasobUIj/BojtoliD8i36d6+KCtYE pBIQQSuzCeVKSsnwFE9w4I65WTTp7nutMWqXLfqctuu7I53ak+VLhXGrzUvCzADR+1R2 j61GyXAFp57GDc108Fxd76bHdXAQeFVETsGhJsDSl6yhJgpge2XeGwmm0TcbaYTYmLgG kTRgst5ui8y7o3fCQII3UupI4qJFFNOek9lK97mhe9qcqp1pF6wj3UGHMmdhzjqIjrVF 94DA== X-Gm-Message-State: AOAM531UlxeVU7H8g9vlJOCJIfwESwg7UfrsTY51G7kG61B7EykKS9kK q3syOtHp1U4zTmL9gaE8rJLBQNFK9AV6FQ== X-Google-Smtp-Source: ABdhPJwbuPYuVsRACa7G46wkjLTJdFs8dOzBtIUxwR6LGmcBu+mC4o+W/bVdQle32PNt7DlRPFk9dQ== X-Received: by 2002:aed:29a5:: with SMTP id o34mr2946177qtd.379.1610557113459; Wed, 13 Jan 2021 08:58:33 -0800 (PST) Received: from localhost.localdomain ([177.194.48.209]) by smtp.googlemail.com with ESMTPSA id y26sm1303501qth.53.2021.01.13.08.58.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Jan 2021 08:58:33 -0800 (PST) To: libc-alpha@sourceware.org Subject: [PATCH 2/5] malloc: Sync dynarray with gnulib Date: Wed, 13 Jan 2021 13:58:23 -0300 Message-Id: <20210113165826.1014708-2-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210113165826.1014708-1-adhemerval.zanella@linaro.org> References: <20210113165826.1014708-1-adhemerval.zanella@linaro.org> MIME-Version: 1.0 X-Spam-Status: No, score=-13.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Adhemerval Zanella via Libc-alpha From: Adhemerval Zanella Reply-To: Adhemerval Zanella Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" It syncs with gnulib version a8bac4d49. The main changes are: - Remove the usage of anonymous union within DYNARRAY_STRUCT. - Use DYNARRAY_FREE instead of DYNARRAY_NAME (free) so that Gnulib does not change 'free' to 'rpl_free'. - Use __nonnull instead of __attribute__ ((nonnull ())). - Use __attribute_maybe_unused__ instead of __attribute__ ((unused, nonnull (1))). - Use of _Noreturn instead of _attribute__ ((noreturn)). The only difference with gnulib is: --- ../../gnulib/gnulib-lib/lib/malloc/dynarray_at_failure.c +++ malloc/dynarray_at_failure.c @@ -18,7 +18,6 @@ #include #include -#include void __libc_dynarray_at_failure (size_t size, size_t index) @@ -28,6 +27,7 @@ __snprintf (buf, sizeof (buf), "Fatal glibc error: " "array index %zu not less than array length %zu\n", index, size); + __libc_fatal (buf); #else abort (); #endif It seems a wrong sync from gnulib. Checked on x86_64-linux-gnu. --- malloc/dynarray-skeleton.c | 128 +++++++++++++++--------------- malloc/dynarray.h | 3 +- malloc/dynarray_at_failure.c | 4 + malloc/dynarray_emplace_enlarge.c | 3 +- malloc/dynarray_resize.c | 3 +- malloc/dynarray_resize_clear.c | 4 +- malloc/tst-dynarray-fail.c | 8 +- malloc/tst-dynarray-shared.h | 4 +- malloc/tst-dynarray.c | 22 ++--- 9 files changed, 95 insertions(+), 84 deletions(-) diff --git a/malloc/dynarray-skeleton.c b/malloc/dynarray-skeleton.c index e552664bc5..5b9f37bdd6 100644 --- a/malloc/dynarray-skeleton.c +++ b/malloc/dynarray-skeleton.c @@ -135,7 +135,7 @@ struct DYNARRAY_STRUCT size_t allocated; DYNARRAY_ELEMENT *array; } dynarray_header; - }; + } u; #if DYNARRAY_HAVE_SCRATCH /* Initial inline allocation. */ @@ -150,6 +150,10 @@ struct DYNARRAY_STRUCT #define DYNARRAY_CONCAT1(prefix, name) DYNARRAY_CONCAT0(prefix, name) #define DYNARRAY_NAME(name) DYNARRAY_CONCAT1(DYNARRAY_PREFIX, name) +/* Use DYNARRAY_FREE instead of DYNARRAY_NAME (free), + so that Gnulib does not change 'free' to 'rpl_free'. */ +#define DYNARRAY_FREE DYNARRAY_CONCAT1 (DYNARRAY_NAME (f), ree) + /* Address of the scratch buffer if any. */ #if DYNARRAY_HAVE_SCRATCH # define DYNARRAY_SCRATCH(list) (list)->scratch @@ -177,10 +181,10 @@ static inline void DYNARRAY_NAME (free__array__) (struct DYNARRAY_STRUCT *list) { #if DYNARRAY_HAVE_SCRATCH - if (list->dynarray_header.array != list->scratch) - free (list->dynarray_header.array); + if (list->u.dynarray_header.array != list->scratch) + free (list->u.dynarray_header.array); #else - free (list->dynarray_header.array); + free (list->u.dynarray_header.array); #endif } @@ -188,86 +192,86 @@ DYNARRAY_NAME (free__array__) (struct DYNARRAY_STRUCT *list) /* Initialize a dynamic array object. This must be called before any use of the object. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static void DYNARRAY_NAME (init) (struct DYNARRAY_STRUCT *list) { - list->dynarray_header.used = 0; - list->dynarray_header.allocated = DYNARRAY_INITIAL_SIZE; - list->dynarray_header.array = DYNARRAY_SCRATCH (list); + list->u.dynarray_header.used = 0; + list->u.dynarray_header.allocated = DYNARRAY_INITIAL_SIZE; + list->u.dynarray_header.array = DYNARRAY_SCRATCH (list); } /* Deallocate the dynamic array and its elements. */ -__attribute__ ((unused, nonnull (1))) +__attribute_maybe_unused__ __nonnull ((1)) static void -DYNARRAY_NAME (free) (struct DYNARRAY_STRUCT *list) +DYNARRAY_FREE (struct DYNARRAY_STRUCT *list) { DYNARRAY_NAME (free__elements__) - (list->dynarray_header.array, list->dynarray_header.used); + (list->u.dynarray_header.array, list->u.dynarray_header.used); DYNARRAY_NAME (free__array__) (list); DYNARRAY_NAME (init) (list); } /* Return true if the dynamic array is in an error state. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static inline bool DYNARRAY_NAME (has_failed) (const struct DYNARRAY_STRUCT *list) { - return list->dynarray_header.allocated == __dynarray_error_marker (); + return list->u.dynarray_header.allocated == __dynarray_error_marker (); } /* Mark the dynamic array as failed. All elements are deallocated as a side effect. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static void DYNARRAY_NAME (mark_failed) (struct DYNARRAY_STRUCT *list) { DYNARRAY_NAME (free__elements__) - (list->dynarray_header.array, list->dynarray_header.used); + (list->u.dynarray_header.array, list->u.dynarray_header.used); DYNARRAY_NAME (free__array__) (list); - list->dynarray_header.array = DYNARRAY_SCRATCH (list); - list->dynarray_header.used = 0; - list->dynarray_header.allocated = __dynarray_error_marker (); + list->u.dynarray_header.array = DYNARRAY_SCRATCH (list); + list->u.dynarray_header.used = 0; + list->u.dynarray_header.allocated = __dynarray_error_marker (); } /* Return the number of elements which have been added to the dynamic array. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static inline size_t DYNARRAY_NAME (size) (const struct DYNARRAY_STRUCT *list) { - return list->dynarray_header.used; + return list->u.dynarray_header.used; } /* Return a pointer to the array element at INDEX. Terminate the process if INDEX is out of bounds. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static inline DYNARRAY_ELEMENT * DYNARRAY_NAME (at) (struct DYNARRAY_STRUCT *list, size_t index) { if (__glibc_unlikely (index >= DYNARRAY_NAME (size) (list))) __libc_dynarray_at_failure (DYNARRAY_NAME (size) (list), index); - return list->dynarray_header.array + index; + return list->u.dynarray_header.array + index; } /* Return a pointer to the first array element, if any. For a zero-length array, the pointer can be NULL even though the dynamic array has not entered the failure state. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static inline DYNARRAY_ELEMENT * DYNARRAY_NAME (begin) (struct DYNARRAY_STRUCT *list) { - return list->dynarray_header.array; + return list->u.dynarray_header.array; } /* Return a pointer one element past the last array element. For a zero-length array, the pointer can be NULL even though the dynamic array has not entered the failure state. */ -__attribute__ ((nonnull (1))) +__nonnull ((1)) static inline DYNARRAY_ELEMENT * DYNARRAY_NAME (end) (struct DYNARRAY_STRUCT *list) { - return list->dynarray_header.array + list->dynarray_header.used; + return list->u.dynarray_header.array + list->u.dynarray_header.used; } /* Internal function. Slow path for the add function below. */ @@ -275,7 +279,7 @@ static void DYNARRAY_NAME (add__) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) { if (__glibc_unlikely - (!__libc_dynarray_emplace_enlarge (&list->dynarray_abstract, + (!__libc_dynarray_emplace_enlarge (&list->u.dynarray_abstract, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)))) { @@ -284,13 +288,13 @@ DYNARRAY_NAME (add__) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) } /* Copy the new element and increase the array length. */ - list->dynarray_header.array[list->dynarray_header.used++] = item; + list->u.dynarray_header.array[list->u.dynarray_header.used++] = item; } /* Add ITEM at the end of the array, enlarging it by one element. Mark *LIST as failed if the dynamic array allocation size cannot be increased. */ -__attribute__ ((unused, nonnull (1))) +__nonnull ((1)) static inline void DYNARRAY_NAME (add) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) { @@ -299,15 +303,15 @@ DYNARRAY_NAME (add) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) return; /* Enlarge the array if necessary. */ - if (__glibc_unlikely (list->dynarray_header.used - == list->dynarray_header.allocated)) + if (__glibc_unlikely (list->u.dynarray_header.used + == list->u.dynarray_header.allocated)) { DYNARRAY_NAME (add__) (list, item); return; } /* Copy the new element and increase the array length. */ - list->dynarray_header.array[list->dynarray_header.used++] = item; + list->u.dynarray_header.array[list->u.dynarray_header.used++] = item; } /* Internal function. Building block for the emplace functions below. @@ -316,8 +320,8 @@ static inline DYNARRAY_ELEMENT * DYNARRAY_NAME (emplace__tail__) (struct DYNARRAY_STRUCT *list) { DYNARRAY_ELEMENT *result - = &list->dynarray_header.array[list->dynarray_header.used]; - ++list->dynarray_header.used; + = &list->u.dynarray_header.array[list->u.dynarray_header.used]; + ++list->u.dynarray_header.used; #if defined (DYNARRAY_ELEMENT_INIT) DYNARRAY_ELEMENT_INIT (result); #elif defined (DYNARRAY_ELEMENT_FREE) @@ -331,7 +335,7 @@ static DYNARRAY_ELEMENT * DYNARRAY_NAME (emplace__) (struct DYNARRAY_STRUCT *list) { if (__glibc_unlikely - (!__libc_dynarray_emplace_enlarge (&list->dynarray_abstract, + (!__libc_dynarray_emplace_enlarge (&list->u.dynarray_abstract, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)))) { @@ -344,7 +348,7 @@ DYNARRAY_NAME (emplace__) (struct DYNARRAY_STRUCT *list) /* Allocate a place for a new element in *LIST and return a pointer to it. The pointer can be NULL if the dynamic array cannot be enlarged due to a memory allocation failure. */ -__attribute__ ((unused, warn_unused_result, nonnull (1))) +__attribute_maybe_unused__ __attribute_warn_unused_result__ __nonnull ((1)) static /* Avoid inlining with the larger initialization code. */ #if !(defined (DYNARRAY_ELEMENT_INIT) || defined (DYNARRAY_ELEMENT_FREE)) @@ -358,8 +362,8 @@ DYNARRAY_NAME (emplace) (struct DYNARRAY_STRUCT *list) return NULL; /* Enlarge the array if necessary. */ - if (__glibc_unlikely (list->dynarray_header.used - == list->dynarray_header.allocated)) + if (__glibc_unlikely (list->u.dynarray_header.used + == list->u.dynarray_header.allocated)) return (DYNARRAY_NAME (emplace__) (list)); return DYNARRAY_NAME (emplace__tail__) (list); } @@ -368,32 +372,32 @@ DYNARRAY_NAME (emplace) (struct DYNARRAY_STRUCT *list) existing size, new elements are added (which can be initialized). Otherwise, the list is truncated, and elements are freed. Return false on memory allocation failure (and mark *LIST as failed). */ -__attribute__ ((unused, nonnull (1))) +__attribute_maybe_unused__ __nonnull ((1)) static bool DYNARRAY_NAME (resize) (struct DYNARRAY_STRUCT *list, size_t size) { - if (size > list->dynarray_header.used) + if (size > list->u.dynarray_header.used) { bool ok; #if defined (DYNARRAY_ELEMENT_INIT) /* The new elements have to be initialized. */ - size_t old_size = list->dynarray_header.used; - ok = __libc_dynarray_resize (&list->dynarray_abstract, + size_t old_size = list->u.dynarray_header.used; + ok = __libc_dynarray_resize (&list->u.dynarray_abstract, size, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)); if (ok) for (size_t i = old_size; i < size; ++i) { - DYNARRAY_ELEMENT_INIT (&list->dynarray_header.array[i]); + DYNARRAY_ELEMENT_INIT (&list->u.dynarray_header.array[i]); } #elif defined (DYNARRAY_ELEMENT_FREE) /* Zero initialization is needed so that the elements can be safely freed. */ ok = __libc_dynarray_resize_clear - (&list->dynarray_abstract, size, + (&list->u.dynarray_abstract, size, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)); #else - ok = __libc_dynarray_resize (&list->dynarray_abstract, + ok = __libc_dynarray_resize (&list->u.dynarray_abstract, size, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)); #endif @@ -405,40 +409,40 @@ DYNARRAY_NAME (resize) (struct DYNARRAY_STRUCT *list, size_t size) { /* The list has shrunk in size. Free the removed elements. */ DYNARRAY_NAME (free__elements__) - (list->dynarray_header.array + size, - list->dynarray_header.used - size); - list->dynarray_header.used = size; + (list->u.dynarray_header.array + size, + list->u.dynarray_header.used - size); + list->u.dynarray_header.used = size; return true; } } /* Remove the last element of LIST if it is present. */ -__attribute__ ((unused, nonnull (1))) +__attribute_maybe_unused__ __nonnull ((1)) static void DYNARRAY_NAME (remove_last) (struct DYNARRAY_STRUCT *list) { /* used > 0 implies that the array is the non-failed state. */ - if (list->dynarray_header.used > 0) + if (list->u.dynarray_header.used > 0) { - size_t new_length = list->dynarray_header.used - 1; + size_t new_length = list->u.dynarray_header.used - 1; #ifdef DYNARRAY_ELEMENT_FREE - DYNARRAY_ELEMENT_FREE (&list->dynarray_header.array[new_length]); + DYNARRAY_ELEMENT_FREE (&list->u.dynarray_header.array[new_length]); #endif - list->dynarray_header.used = new_length; + list->u.dynarray_header.used = new_length; } } /* Remove all elements from the list. The elements are freed, but the list itself is not. */ -__attribute__ ((unused, nonnull (1))) +__attribute_maybe_unused__ __nonnull ((1)) static void DYNARRAY_NAME (clear) (struct DYNARRAY_STRUCT *list) { /* free__elements__ does nothing if the list is in the failed state. */ DYNARRAY_NAME (free__elements__) - (list->dynarray_header.array, list->dynarray_header.used); - list->dynarray_header.used = 0; + (list->u.dynarray_header.array, list->u.dynarray_header.used); + list->u.dynarray_header.used = 0; } #ifdef DYNARRAY_FINAL_TYPE @@ -448,13 +452,13 @@ DYNARRAY_NAME (clear) (struct DYNARRAY_STRUCT *list) stored in *RESULT if LIST refers to an empty list. On success, the pointer in *RESULT is heap-allocated and must be deallocated using free. */ -__attribute__ ((unused, warn_unused_result, nonnull (1, 2))) +__attribute_maybe_unused__ __attribute_warn_unused_result__ __nonnull ((1, 2)) static bool DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, DYNARRAY_FINAL_TYPE *result) { struct dynarray_finalize_result res; - if (__libc_dynarray_finalize (&list->dynarray_abstract, + if (__libc_dynarray_finalize (&list->u.dynarray_abstract, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT), &res)) { @@ -466,7 +470,7 @@ DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, else { /* On error, we need to free all data. */ - DYNARRAY_NAME (free) (list); + DYNARRAY_FREE (list); errno = ENOMEM; return false; } @@ -479,12 +483,12 @@ DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, have a sentinel at the end). If LENGTHP is not NULL, the array length is written to *LENGTHP. *LIST is re-initialized and can be reused. */ -__attribute__ ((unused, warn_unused_result, nonnull (1))) +__attribute_maybe_unused__ __attribute_warn_unused_result__ __nonnull ((1)) static DYNARRAY_ELEMENT * DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, size_t *lengthp) { struct dynarray_finalize_result res; - if (__libc_dynarray_finalize (&list->dynarray_abstract, + if (__libc_dynarray_finalize (&list->u.dynarray_abstract, DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT), &res)) { @@ -497,7 +501,7 @@ DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, size_t *lengthp) else { /* On error, we need to free all data. */ - DYNARRAY_NAME (free) (list); + DYNARRAY_FREE (list); errno = ENOMEM; return NULL; } diff --git a/malloc/dynarray.h b/malloc/dynarray.h index 24ca1620d2..638c33f986 100644 --- a/malloc/dynarray.h +++ b/malloc/dynarray.h @@ -165,8 +165,7 @@ bool __libc_dynarray_finalize (struct dynarray_header *list, void *scratch, /* Internal function. Terminate the process after an index error. SIZE is the number of elements of the dynamic array. INDEX is the lookup index which triggered the failure. */ -void __libc_dynarray_at_failure (size_t size, size_t index) - __attribute__ ((noreturn)); +_Noreturn void __libc_dynarray_at_failure (size_t size, size_t index); #ifndef _ISOMAC libc_hidden_proto (__libc_dynarray_emplace_enlarge) diff --git a/malloc/dynarray_at_failure.c b/malloc/dynarray_at_failure.c index d27c0aebbc..88d9ee7f50 100644 --- a/malloc/dynarray_at_failure.c +++ b/malloc/dynarray_at_failure.c @@ -22,10 +22,14 @@ void __libc_dynarray_at_failure (size_t size, size_t index) { +#ifdef _LIBC char buf[200]; __snprintf (buf, sizeof (buf), "Fatal glibc error: " "array index %zu not less than array length %zu\n", index, size); __libc_fatal (buf); +#else + abort (); +#endif } libc_hidden_def (__libc_dynarray_at_failure) diff --git a/malloc/dynarray_emplace_enlarge.c b/malloc/dynarray_emplace_enlarge.c index f98b0328df..ddfe306fcd 100644 --- a/malloc/dynarray_emplace_enlarge.c +++ b/malloc/dynarray_emplace_enlarge.c @@ -18,6 +18,7 @@ #include #include +#include #include #include @@ -51,7 +52,7 @@ __libc_dynarray_emplace_enlarge (struct dynarray_header *list, } size_t new_size; - if (__builtin_mul_overflow (new_allocated, element_size, &new_size)) + if (INT_MULTIPLY_WRAPV (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 bb50e32f9a..5c60927f37 100644 --- a/malloc/dynarray_resize.c +++ b/malloc/dynarray_resize.c @@ -18,6 +18,7 @@ #include #include +#include #include #include @@ -37,7 +38,7 @@ __libc_dynarray_resize (struct dynarray_header *list, size_t size, over-allocation here. */ size_t new_size_bytes; - if (__builtin_mul_overflow (size, element_size, &new_size_bytes)) + if (INT_MULTIPLY_WRAPV (size, element_size, &new_size_bytes)) { /* Overflow. */ __set_errno (ENOMEM); diff --git a/malloc/dynarray_resize_clear.c b/malloc/dynarray_resize_clear.c index 51d64fea5c..e893d1d58e 100644 --- a/malloc/dynarray_resize_clear.c +++ b/malloc/dynarray_resize_clear.c @@ -17,7 +17,6 @@ . */ #include -#include #include bool @@ -28,7 +27,8 @@ __libc_dynarray_resize_clear (struct dynarray_header *list, size_t size, if (!__libc_dynarray_resize (list, size, scratch, element_size)) return false; /* __libc_dynarray_resize already checked for overflow. */ - memset (list->array + (old_size * element_size), 0, + char *array = list->array; + memset (array + (old_size * element_size), 0, (size - old_size) * element_size); return true; } diff --git a/malloc/tst-dynarray-fail.c b/malloc/tst-dynarray-fail.c index 1db3a00b34..9252586e79 100644 --- a/malloc/tst-dynarray-fail.c +++ b/malloc/tst-dynarray-fail.c @@ -249,9 +249,9 @@ test_str_fail (void) else dynarray_str_free (&dyn); TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); - TEST_VERIFY_EXIT (dyn.dynarray_header.array == dyn.scratch); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.array == dyn.scratch); TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == 0); - TEST_VERIFY_EXIT (dyn.dynarray_header.allocated > 0); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated > 0); } /* Exercise failure in finalize. */ @@ -278,9 +278,9 @@ test_str_fail (void) TEST_VERIFY_EXIT (result.array == (char **) (uintptr_t) -1); TEST_VERIFY_EXIT (result.length == (size_t) -1); TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); - TEST_VERIFY_EXIT (dyn.dynarray_header.array == dyn.scratch); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.array == dyn.scratch); TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == 0); - TEST_VERIFY_EXIT (dyn.dynarray_header.allocated > 0); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated > 0); free_fill_heap (heap_filler); } diff --git a/malloc/tst-dynarray-shared.h b/malloc/tst-dynarray-shared.h index fbbbef2eab..c3d63c87c6 100644 --- a/malloc/tst-dynarray-shared.h +++ b/malloc/tst-dynarray-shared.h @@ -48,9 +48,9 @@ struct str_array ({ \ TEST_VERIFY_EXIT (!dynarray_##type##_has_failed (dyn)); \ TEST_VERIFY_EXIT (dynarray_##type##_size (dyn) == 0); \ - TEST_VERIFY_EXIT ((dyn)->dynarray_header.array \ + TEST_VERIFY_EXIT ((dyn)->u.dynarray_header.array \ == (dyn)->scratch); \ - TEST_VERIFY_EXIT ((dyn)->dynarray_header.allocated > 0); \ + TEST_VERIFY_EXIT ((dyn)->u.dynarray_header.allocated > 0); \ (void) 0; \ }) diff --git a/malloc/tst-dynarray.c b/malloc/tst-dynarray.c index 6c6437b12a..c33505711f 100644 --- a/malloc/tst-dynarray.c +++ b/malloc/tst-dynarray.c @@ -110,10 +110,10 @@ test_int (void) TEST_VERIFY_EXIT (!dynarray_int_has_failed (&dyn)); TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == i + 1); TEST_VERIFY_EXIT (dynarray_int_size (&dyn) - <= dyn.dynarray_header.allocated); + <= dyn.u.dynarray_header.allocated); } TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == count); - TEST_VERIFY_EXIT (count <= dyn.dynarray_header.allocated); + TEST_VERIFY_EXIT (count <= dyn.u.dynarray_header.allocated); if (count > 0) { TEST_VERIFY (dynarray_int_begin (&dyn) @@ -122,7 +122,7 @@ test_int (void) == dynarray_int_at (&dyn, count - 1) + 1); } unsigned final_count; - bool heap_array = dyn.dynarray_header.array != dyn.scratch; + bool heap_array = dyn.u.dynarray_header.array != dyn.scratch; if (do_remove_last) { dynarray_int_remove_last (&dyn); @@ -146,10 +146,11 @@ test_int (void) final_count = 0; } TEST_VERIFY_EXIT (!dynarray_int_has_failed (&dyn)); - TEST_VERIFY_EXIT ((dyn.dynarray_header.array != dyn.scratch) + TEST_VERIFY_EXIT ((dyn.u.dynarray_header.array != dyn.scratch) == heap_array); TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == final_count); - TEST_VERIFY_EXIT (dyn.dynarray_header.allocated >= final_count); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated + >= final_count); if (!do_clear) for (unsigned int i = 0; i < final_count; ++i) TEST_VERIFY_EXIT (*dynarray_int_at (&dyn, i) == base + i); @@ -238,10 +239,10 @@ test_str (void) TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == i + 1); TEST_VERIFY_EXIT (dynarray_str_size (&dyn) - <= dyn.dynarray_header.allocated); + <= dyn.u.dynarray_header.allocated); } TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == count); - TEST_VERIFY_EXIT (count <= dyn.dynarray_header.allocated); + TEST_VERIFY_EXIT (count <= dyn.u.dynarray_header.allocated); if (count > 0) { TEST_VERIFY (dynarray_str_begin (&dyn) @@ -250,7 +251,7 @@ test_str (void) == dynarray_str_at (&dyn, count - 1) + 1); } unsigned final_count; - bool heap_array = dyn.dynarray_header.array != dyn.scratch; + bool heap_array = dyn.u.dynarray_header.array != dyn.scratch; if (do_remove_last) { dynarray_str_remove_last (&dyn); @@ -274,10 +275,11 @@ test_str (void) final_count = 0; } TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); - TEST_VERIFY_EXIT ((dyn.dynarray_header.array != dyn.scratch) + TEST_VERIFY_EXIT ((dyn.u.dynarray_header.array != dyn.scratch) == heap_array); TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == final_count); - TEST_VERIFY_EXIT (dyn.dynarray_header.allocated >= final_count); + TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated + >= final_count); if (!do_clear) for (unsigned int i = 0; i < count - do_remove_last; ++i) {