From 6d292502e138b5c73705f0df8095ded3f1df956f Mon Sep 17 00:00:00 2001
From: Matthijs Kooijman <matthijs@stdin.nl>
Date: Thu, 17 Sep 2020 19:43:09 +0200
Subject: Use std::size_t in new/delete

The standard dictates that `std::size_t` is used, rather than the plain
`size_t` type.

Even though these types are usually, if not always, exactly the same
type, other code might assume that `std::size_t` is actually used and thus
also available under that name after including `<new>`.

This fixes that by using the right type. One challenge is that it is
usually declared in headers that we do not have available, so this just
defines the `std::size_t` type in the `<new>` header to work around
that.
---
 cores/arduino/new     | 22 ++++++++++++++--------
 cores/arduino/new.cpp | 18 +++++++++---------
 2 files changed, 23 insertions(+), 17 deletions(-)

(limited to 'cores')

diff --git a/cores/arduino/new b/cores/arduino/new
index fb60927..8cf2103 100644
--- a/cores/arduino/new
+++ b/cores/arduino/new
@@ -31,23 +31,29 @@ namespace std {
   typedef void (*new_handler)();
   new_handler set_new_handler(new_handler new_p) noexcept;
   new_handler get_new_handler() noexcept;
+
+  // This is normally declared in various headers that we do not have
+  // available, so just define it here. We could also use ::size_t
+  // below, but then anyone including <new> can no longer assume
+  // std::size_t is available.
+  using size_t = ::size_t;
 } // namespace std
 
-[[gnu::weak]] void * operator new(size_t size);
-[[gnu::weak]] void * operator new[](size_t size);
+[[gnu::weak]] void * operator new(std::size_t size);
+[[gnu::weak]] void * operator new[](std::size_t size);
 
-[[gnu::weak]] void * operator new(size_t size, const std::nothrow_t tag) noexcept;
-[[gnu::weak]] void * operator new[](size_t size, const std::nothrow_t& tag) noexcept;
+[[gnu::weak]] void * operator new(std::size_t size, const std::nothrow_t tag) noexcept;
+[[gnu::weak]] void * operator new[](std::size_t size, const std::nothrow_t& tag) noexcept;
 
-void * operator new(size_t size, void *place) noexcept;
-void * operator new[](size_t size, void *place) noexcept;
+void * operator new(std::size_t size, void *place) noexcept;
+void * operator new[](std::size_t size, void *place) noexcept;
 
 [[gnu::weak]] void operator delete(void * ptr) noexcept;
 [[gnu::weak]] void operator delete[](void * ptr) noexcept;
 
 #if __cplusplus >= 201402L
-[[gnu::weak]] void operator delete(void* ptr, size_t size) noexcept;
-[[gnu::weak]] void operator delete[](void * ptr, size_t size) noexcept;
+[[gnu::weak]] void operator delete(void* ptr, std::size_t size) noexcept;
+[[gnu::weak]] void operator delete[](void * ptr, std::size_t size) noexcept;
 #endif // __cplusplus >= 201402L
 
 [[gnu::weak]] void operator delete(void* ptr, const std::nothrow_t& tag) noexcept;
diff --git a/cores/arduino/new.cpp b/cores/arduino/new.cpp
index 19d80b6..9047b2d 100644
--- a/cores/arduino/new.cpp
+++ b/cores/arduino/new.cpp
@@ -36,7 +36,7 @@ namespace std {
   const nothrow_t nothrow;
 }
 
-static void * new_helper(size_t size) {
+static void * new_helper(std::size_t size) {
   // Even zero-sized allocations should return a unique pointer, but
   // malloc does not guarantee this
   if (size == 0)
@@ -44,7 +44,7 @@ static void * new_helper(size_t size) {
   return malloc(size);
 }
 
-void * operator new(size_t size) {
+void * operator new(std::size_t size) {
   void *res = new_helper(size);
 #if defined(NEW_TERMINATES_ON_FAILURE)
   if (!res)
@@ -52,11 +52,11 @@ void * operator new(size_t size) {
 #endif
   return res;
 }
-void * operator new[](size_t size) {
+void * operator new[](std::size_t size) {
   return operator new(size);
 }
 
-void * operator new(size_t size, const std::nothrow_t tag) noexcept {
+void * operator new(std::size_t size, const std::nothrow_t tag) noexcept {
 #if defined(NEW_TERMINATES_ON_FAILURE)
   // Cannot call throwing operator new as standard suggests, so call
   // new_helper directly then
@@ -65,7 +65,7 @@ void * operator new(size_t size, const std::nothrow_t tag) noexcept {
   return operator new(size);
 #endif
 }
-void * operator new[](size_t size, const std::nothrow_t& tag) noexcept {
+void * operator new[](std::size_t size, const std::nothrow_t& tag) noexcept {
 #if defined(NEW_TERMINATES_ON_FAILURE)
   // Cannot call throwing operator new[] as standard suggests, so call
   // malloc directly then
@@ -75,12 +75,12 @@ void * operator new[](size_t size, const std::nothrow_t& tag) noexcept {
 #endif
 }
 
-void * operator new(size_t size, void *place) noexcept {
+void * operator new(std::size_t size, void *place) noexcept {
   // Nothing to do
   (void)size; // unused
   return place;
 }
-void * operator new[](size_t size, void *place) noexcept {
+void * operator new[](std::size_t size, void *place) noexcept {
   return operator new(size, place);
 }
 
@@ -92,10 +92,10 @@ void operator delete[](void * ptr) noexcept {
 }
 
 #if __cplusplus >= 201402L
-void operator delete(void* ptr, size_t size) noexcept {
+void operator delete(void* ptr, std::size_t size) noexcept {
   operator delete(ptr);
 }
-void operator delete[](void * ptr, size_t size) noexcept {
+void operator delete[](void * ptr, std::size_t size) noexcept {
   operator delete[](ptr);
 }
 #endif // __cplusplus >= 201402L
-- 
cgit v1.2.3-18-g5258