make SENTRY_MAKE zero-initialize and drop SENTRY_MAKE_0

jpnurmi · claude · jpnurmi · commit abc6ffd3a90f · 2026-04-13T10:28:50.000+02:00
Collapse the two allocation macros into one. All SENTRY_MAKE call sites
are small control structs where the memset cost is negligible, and
zero-init by default eliminates a class of uninitialized-read footguns
when struct fields are added later. On the signal-handler path the page
allocator already returns zeroed mmap pages, so behavior is unchanged
there.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/backends/native/sentry_crash_ipc.c b/src/backends/native/sentry_crash_ipc.c
@@ -19,7 +19,7 @@
 sentry_crash_ipc_t *
 sentry__crash_ipc_init_app(sem_t *init_sem)
 {
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
@@ -174,7 +174,7 @@ sentry_crash_ipc_t *
 sentry__crash_ipc_init_daemon(
     pid_t app_pid, uint64_t app_tid, int notify_eventfd, int ready_eventfd)
 {
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
@@ -310,7 +310,7 @@ sentry__crash_ipc_free(sentry_crash_ipc_t *ipc)
 sentry_crash_ipc_t *
 sentry__crash_ipc_init_app(sem_t *init_sem)
 {
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
@@ -467,7 +467,7 @@ sentry_crash_ipc_t *
 sentry__crash_ipc_init_daemon(
     pid_t app_pid, uint64_t app_tid, int notify_pipe_read, int ready_pipe_write)
 {
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
@@ -600,7 +600,7 @@ sentry__crash_ipc_free(sentry_crash_ipc_t *ipc)
 sentry_crash_ipc_t *
 sentry__crash_ipc_init_app(HANDLE init_mutex)
 {
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
@@ -729,7 +729,7 @@ sentry__crash_ipc_init_daemon(pid_t app_pid, uint64_t app_tid,
     (void)event_handle;
     (void)ready_event_handle;
 
-    sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);
+    sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);
     if (!ipc) {
         return NULL;
     }
diff --git a/src/backends/sentry_backend_breakpad.cpp b/src/backends/sentry_backend_breakpad.cpp
@@ -331,7 +331,7 @@ sentry__backend_preload(void)
 sentry_backend_t *
 sentry__backend_new(void)
 {
-    auto *backend = SENTRY_MAKE_0(sentry_backend_t);
+    auto *backend = SENTRY_MAKE(sentry_backend_t);
     if (!backend) {
         return nullptr;
     }
diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp
@@ -1037,7 +1037,7 @@ sentry__backend_preload(void)
 sentry_backend_t *
 sentry__backend_new(void)
 {
-    auto *backend = SENTRY_MAKE_0(sentry_backend_t);
+    auto *backend = SENTRY_MAKE(sentry_backend_t);
     if (!backend) {
         return nullptr;
     }
diff --git a/src/backends/sentry_backend_inproc.c b/src/backends/sentry_backend_inproc.c
@@ -1810,7 +1810,7 @@ sentry__backend_preload(void)
 sentry_backend_t *
 sentry__backend_new(void)
 {
-    sentry_backend_t *backend = SENTRY_MAKE_0(sentry_backend_t);
+    sentry_backend_t *backend = SENTRY_MAKE(sentry_backend_t);
     if (!backend) {
         return NULL;
     }
diff --git a/src/backends/sentry_backend_native.c b/src/backends/sentry_backend_native.c
@@ -117,7 +117,7 @@ native_backend_startup(
     sentry__mutex_unlock(&g_ipc_init_mutex);
 #endif
 
-    native_backend_state_t *state = SENTRY_MAKE_0(native_backend_state_t);
+    native_backend_state_t *state = SENTRY_MAKE(native_backend_state_t);
     if (!state) {
         return 1;
     }
@@ -929,7 +929,7 @@ sentry__backend_preload(void)
 sentry_backend_t *
 sentry__backend_new(void)
 {
-    sentry_backend_t *backend = SENTRY_MAKE_0(sentry_backend_t);
+    sentry_backend_t *backend = SENTRY_MAKE(sentry_backend_t);
     if (!backend) {
         return NULL;
     }
diff --git a/src/sentry_alloc.h b/src/sentry_alloc.h
@@ -3,15 +3,11 @@
 
 #include "sentry_boot.h"
 
-/**
- * This is a shortcut for a typed `malloc`.
- */
-#define SENTRY_MAKE(Type) (Type *)sentry_malloc(sizeof(Type))
+void *sentry__calloc(size_t count, size_t size);
 
 /**
- * This is a typed `calloc` that zero-initializes the allocation.
+ * This is a shortcut for a typed `calloc` that zero-initializes the allocation.
  */
-void *sentry__calloc(size_t count, size_t size);
-#define SENTRY_MAKE_0(Type) (Type *)sentry__calloc(1, sizeof(Type))
+#define SENTRY_MAKE(Type) (Type *)sentry__calloc(1, sizeof(Type))
 
 #endif
diff --git a/src/sentry_attachment.c b/src/sentry_attachment.c
@@ -74,7 +74,7 @@ sentry__attachment_from_path(sentry_path_t *path)
     if (!path) {
         return NULL;
     }
-    sentry_attachment_t *attachment = SENTRY_MAKE_0(sentry_attachment_t);
+    sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);
     if (!attachment) {
         sentry__path_free(path);
         return NULL;
@@ -94,7 +94,7 @@ sentry__attachment_from_buffer(
         sentry__path_free(filename);
         return NULL;
     }
-    sentry_attachment_t *attachment = SENTRY_MAKE_0(sentry_attachment_t);
+    sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);
     if (!attachment) {
         sentry__path_free(filename);
         return NULL;
@@ -214,7 +214,7 @@ attachment_clone(const sentry_attachment_t *attachment)
         return NULL;
     }
 
-    sentry_attachment_t *clone = SENTRY_MAKE_0(sentry_attachment_t);
+    sentry_attachment_t *clone = SENTRY_MAKE(sentry_attachment_t);
     if (!clone) {
         return NULL;
     }
diff --git a/src/sentry_batcher.c b/src/sentry_batcher.c
@@ -23,7 +23,7 @@ sentry_batcher_t *
 sentry__batcher_new(
     sentry_batch_func_t batch_func, sentry_data_category_t data_category)
 {
-    sentry_batcher_t *batcher = SENTRY_MAKE_0(sentry_batcher_t);
+    sentry_batcher_t *batcher = SENTRY_MAKE(sentry_batcher_t);
     if (!batcher) {
         return NULL;
     }
diff --git a/src/sentry_hint.c b/src/sentry_hint.c
@@ -10,7 +10,7 @@
 sentry_hint_t *
 sentry_hint_new(void)
 {
-    sentry_hint_t *hint = SENTRY_MAKE_0(sentry_hint_t);
+    sentry_hint_t *hint = SENTRY_MAKE(sentry_hint_t);
     if (!hint) {
         return NULL;
     }
diff --git a/src/sentry_options.c b/src/sentry_options.c
@@ -14,7 +14,7 @@
 sentry_options_t *
 sentry_options_new(void)
 {
-    sentry_options_t *opts = SENTRY_MAKE_0(sentry_options_t);
+    sentry_options_t *opts = SENTRY_MAKE(sentry_options_t);
     if (!opts) {
         return NULL;
     }
diff --git a/src/sentry_retry.c b/src/sentry_retry.c
@@ -40,7 +40,7 @@ struct sentry_retry_s {
 sentry_retry_t *
 sentry__retry_new(const sentry_options_t *options)
 {
-    sentry_retry_t *retry = SENTRY_MAKE_0(sentry_retry_t);
+    sentry_retry_t *retry = SENTRY_MAKE(sentry_retry_t);
     if (!retry) {
         return NULL;
     }
diff --git a/src/sentry_scope.c b/src/sentry_scope.c
@@ -169,7 +169,7 @@ sentry__scope_flush_unlock(void)
 sentry_scope_t *
 sentry_local_scope_new(void)
 {
-    sentry_scope_t *scope = SENTRY_MAKE_0(sentry_scope_t);
+    sentry_scope_t *scope = SENTRY_MAKE(sentry_scope_t);
     if (!scope) {
         return NULL;
     }
diff --git a/src/sentry_sync.c b/src/sentry_sync.c
@@ -176,7 +176,7 @@ struct sentry_bgworker_s {
 sentry_bgworker_t *
 sentry__bgworker_new(void *state, void (*free_state)(void *state))
 {
-    sentry_bgworker_t *bgw = SENTRY_MAKE_0(sentry_bgworker_t);
+    sentry_bgworker_t *bgw = SENTRY_MAKE(sentry_bgworker_t);
     if (!bgw) {
         if (free_state) {
             free_state(state);
@@ -368,7 +368,7 @@ sentry__bgworker_flush(sentry_bgworker_t *bgw, uint64_t timeout)
     }
     SENTRY_DEBUG("flushing background worker thread");
 
-    sentry_flush_task_t *flush_task = SENTRY_MAKE_0(sentry_flush_task_t);
+    sentry_flush_task_t *flush_task = SENTRY_MAKE(sentry_flush_task_t);
     if (!flush_task) {
         return 1;
     }
diff --git a/src/sentry_transport.c b/src/sentry_transport.c
@@ -20,7 +20,7 @@ sentry_transport_t *
 sentry_transport_new(
     void (*send_func)(sentry_envelope_t *envelope, void *state))
 {
-    sentry_transport_t *transport = SENTRY_MAKE_0(sentry_transport_t);
+    sentry_transport_t *transport = SENTRY_MAKE(sentry_transport_t);
     if (!transport) {
         return NULL;
     }
diff --git a/src/sentry_utils.c b/src/sentry_utils.c
@@ -234,7 +234,7 @@ sentry__dsn_new_n(const char *raw_dsn, size_t raw_dsn_len)
     // org_id is u64 in relay, so needs 20 characters + null termination
     char org_id[21] = "";
 
-    sentry_dsn_t *dsn = SENTRY_MAKE_0(sentry_dsn_t);
+    sentry_dsn_t *dsn = SENTRY_MAKE(sentry_dsn_t);
     if (!dsn) {
         return NULL;
     }
diff --git a/src/sentry_value.c b/src/sentry_value.c
@@ -390,7 +390,7 @@ sentry_value_new_string(const char *value)
 sentry_value_t
 sentry_value_new_list(void)
 {
-    list_t *l = SENTRY_MAKE_0(list_t);
+    list_t *l = SENTRY_MAKE(list_t);
     if (l) {
         sentry_value_t rv = new_thing_value(l, THING_TYPE_LIST);
         if (sentry_value_is_null(rv)) {
@@ -405,7 +405,7 @@ sentry_value_new_list(void)
 sentry_value_t
 sentry__value_new_list_with_size(size_t size)
 {
-    list_t *l = SENTRY_MAKE_0(list_t);
+    list_t *l = SENTRY_MAKE(list_t);
     if (l) {
         l->allocated = size;
         if (size) {
@@ -429,7 +429,7 @@ sentry__value_new_list_with_size(size_t size)
 sentry_value_t
 sentry_value_new_object(void)
 {
-    obj_t *o = SENTRY_MAKE_0(obj_t);
+    obj_t *o = SENTRY_MAKE(obj_t);
     if (o) {
         sentry_value_t rv = new_thing_value(o, THING_TYPE_OBJECT);
         if (sentry_value_is_null(rv)) {
@@ -444,7 +444,7 @@ sentry_value_new_object(void)
 sentry_value_t
 sentry__value_new_object_with_size(size_t size)
 {
-    obj_t *o = SENTRY_MAKE_0(obj_t);
+    obj_t *o = SENTRY_MAKE(obj_t);
     if (o) {
         o->allocated = size;
         if (size) {
diff --git a/src/transports/sentry_http_transport.c b/src/transports/sentry_http_transport.c
@@ -470,7 +470,7 @@ http_transport_submit_cleanup(
 sentry_transport_t *
 sentry__http_transport_new(void *client, sentry_http_send_func_t send_func)
 {
-    http_transport_state_t *state = SENTRY_MAKE_0(http_transport_state_t);
+    http_transport_state_t *state = SENTRY_MAKE(http_transport_state_t);
     if (!state) {
         return NULL;
     }
diff --git a/src/transports/sentry_http_transport_curl.c b/src/transports/sentry_http_transport_curl.c
@@ -30,7 +30,7 @@ typedef struct {
 static curl_client_t *
 curl_client_new(void)
 {
-    curl_client_t *client = SENTRY_MAKE_0(curl_client_t);
+    curl_client_t *client = SENTRY_MAKE(curl_client_t);
     if (!client) {
         return NULL;
     }
diff --git a/src/transports/sentry_http_transport_winhttp.c b/src/transports/sentry_http_transport_winhttp.c
@@ -28,7 +28,7 @@ typedef struct {
 static winhttp_client_t *
 winhttp_client_new(void)
 {
-    winhttp_client_t *client = SENTRY_MAKE_0(winhttp_client_t);
+    winhttp_client_t *client = SENTRY_MAKE(winhttp_client_t);
     if (!client) {
         return NULL;
     }

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`sentry_crash_ipc_t *`
`20`	`20`	`sentry__crash_ipc_init_app(sem_t *init_sem)`
`21`	`21`	`{`
`22`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`22`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`23`	`23`	`if (!ipc) {`
`24`	`24`	`return NULL;`
`25`	`25`	`}`
`@@ -174,7 +174,7 @@ sentry_crash_ipc_t *`
`174`	`174`	`sentry__crash_ipc_init_daemon(`
`175`	`175`	`pid_t app_pid, uint64_t app_tid, int notify_eventfd, int ready_eventfd)`
`176`	`176`	`{`
`177`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`177`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`178`	`178`	`if (!ipc) {`
`179`	`179`	`return NULL;`
`180`	`180`	`}`
`@@ -310,7 +310,7 @@ sentry__crash_ipc_free(sentry_crash_ipc_t *ipc)`
`310`	`310`	`sentry_crash_ipc_t *`
`311`	`311`	`sentry__crash_ipc_init_app(sem_t *init_sem)`
`312`	`312`	`{`
`313`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`313`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`314`	`314`	`if (!ipc) {`
`315`	`315`	`return NULL;`
`316`	`316`	`}`
`@@ -467,7 +467,7 @@ sentry_crash_ipc_t *`
`467`	`467`	`sentry__crash_ipc_init_daemon(`
`468`	`468`	`pid_t app_pid, uint64_t app_tid, int notify_pipe_read, int ready_pipe_write)`
`469`	`469`	`{`
`470`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`470`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`471`	`471`	`if (!ipc) {`
`472`	`472`	`return NULL;`
`473`	`473`	`}`
`@@ -600,7 +600,7 @@ sentry__crash_ipc_free(sentry_crash_ipc_t *ipc)`
`600`	`600`	`sentry_crash_ipc_t *`
`601`	`601`	`sentry__crash_ipc_init_app(HANDLE init_mutex)`
`602`	`602`	`{`
`603`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`603`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`604`	`604`	`if (!ipc) {`
`605`	`605`	`return NULL;`
`606`	`606`	`}`
`@@ -729,7 +729,7 @@ sentry__crash_ipc_init_daemon(pid_t app_pid, uint64_t app_tid,`
`729`	`729`	`(void)event_handle;`
`730`	`730`	`(void)ready_event_handle;`
`731`	`731`
`732`		`- sentry_crash_ipc_t *ipc = SENTRY_MAKE_0(sentry_crash_ipc_t);`
	`732`	`+ sentry_crash_ipc_t *ipc = SENTRY_MAKE(sentry_crash_ipc_t);`
`733`	`733`	`if (!ipc) {`
`734`	`734`	`return NULL;`
`735`	`735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -331,7 +331,7 @@ sentry__backend_preload(void)`
`331`	`331`	`sentry_backend_t *`
`332`	`332`	`sentry__backend_new(void)`
`333`	`333`	`{`
`334`		`- auto *backend = SENTRY_MAKE_0(sentry_backend_t);`
	`334`	`+ auto *backend = SENTRY_MAKE(sentry_backend_t);`
`335`	`335`	`if (!backend) {`
`336`	`336`	`return nullptr;`
`337`	`337`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1037,7 +1037,7 @@ sentry__backend_preload(void)`
`1037`	`1037`	`sentry_backend_t *`
`1038`	`1038`	`sentry__backend_new(void)`
`1039`	`1039`	`{`
`1040`		`- auto *backend = SENTRY_MAKE_0(sentry_backend_t);`
	`1040`	`+ auto *backend = SENTRY_MAKE(sentry_backend_t);`
`1041`	`1041`	`if (!backend) {`
`1042`	`1042`	`return nullptr;`
`1043`	`1043`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1810,7 +1810,7 @@ sentry__backend_preload(void)`
`1810`	`1810`	`sentry_backend_t *`
`1811`	`1811`	`sentry__backend_new(void)`
`1812`	`1812`	`{`
`1813`		`- sentry_backend_t *backend = SENTRY_MAKE_0(sentry_backend_t);`
	`1813`	`+ sentry_backend_t *backend = SENTRY_MAKE(sentry_backend_t);`
`1814`	`1814`	`if (!backend) {`
`1815`	`1815`	`return NULL;`
`1816`	`1816`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ native_backend_startup(`
`117`	`117`	`sentry__mutex_unlock(&g_ipc_init_mutex);`
`118`	`118`	`#endif`
`119`	`119`
`120`		`- native_backend_state_t *state = SENTRY_MAKE_0(native_backend_state_t);`
	`120`	`+ native_backend_state_t *state = SENTRY_MAKE(native_backend_state_t);`
`121`	`121`	`if (!state) {`
`122`	`122`	`return 1;`
`123`	`123`	`}`
`@@ -929,7 +929,7 @@ sentry__backend_preload(void)`
`929`	`929`	`sentry_backend_t *`
`930`	`930`	`sentry__backend_new(void)`
`931`	`931`	`{`
`932`		`- sentry_backend_t *backend = SENTRY_MAKE_0(sentry_backend_t);`
	`932`	`+ sentry_backend_t *backend = SENTRY_MAKE(sentry_backend_t);`
`933`	`933`	`if (!backend) {`
`934`	`934`	`return NULL;`
`935`	`935`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ sentry__attachment_from_path(sentry_path_t *path)`
`74`	`74`	`if (!path) {`
`75`	`75`	`return NULL;`
`76`	`76`	`}`
`77`		`- sentry_attachment_t *attachment = SENTRY_MAKE_0(sentry_attachment_t);`
	`77`	`+ sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);`
`78`	`78`	`if (!attachment) {`
`79`	`79`	`sentry__path_free(path);`
`80`	`80`	`return NULL;`
`@@ -94,7 +94,7 @@ sentry__attachment_from_buffer(`
`94`	`94`	`sentry__path_free(filename);`
`95`	`95`	`return NULL;`
`96`	`96`	`}`
`97`		`- sentry_attachment_t *attachment = SENTRY_MAKE_0(sentry_attachment_t);`
	`97`	`+ sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);`
`98`	`98`	`if (!attachment) {`
`99`	`99`	`sentry__path_free(filename);`
`100`	`100`	`return NULL;`
`@@ -214,7 +214,7 @@ attachment_clone(const sentry_attachment_t *attachment)`
`214`	`214`	`return NULL;`
`215`	`215`	`}`
`216`	`216`
`217`		`- sentry_attachment_t *clone = SENTRY_MAKE_0(sentry_attachment_t);`
	`217`	`+ sentry_attachment_t *clone = SENTRY_MAKE(sentry_attachment_t);`
`218`	`218`	`if (!clone) {`
`219`	`219`	`return NULL;`
`220`	`220`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ sentry_batcher_t *`
`23`	`23`	`sentry__batcher_new(`
`24`	`24`	`sentry_batch_func_t batch_func, sentry_data_category_t data_category)`
`25`	`25`	`{`
`26`		`- sentry_batcher_t *batcher = SENTRY_MAKE_0(sentry_batcher_t);`
	`26`	`+ sentry_batcher_t *batcher = SENTRY_MAKE(sentry_batcher_t);`
`27`	`27`	`if (!batcher) {`
`28`	`28`	`return NULL;`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`sentry_hint_t *`
`11`	`11`	`sentry_hint_new(void)`
`12`	`12`	`{`
`13`		`- sentry_hint_t *hint = SENTRY_MAKE_0(sentry_hint_t);`
	`13`	`+ sentry_hint_t *hint = SENTRY_MAKE(sentry_hint_t);`
`14`	`14`	`if (!hint) {`
`15`	`15`	`return NULL;`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@`
`14`	`14`	`sentry_options_t *`
`15`	`15`	`sentry_options_new(void)`
`16`	`16`	`{`
`17`		`- sentry_options_t *opts = SENTRY_MAKE_0(sentry_options_t);`
	`17`	`+ sentry_options_t *opts = SENTRY_MAKE(sentry_options_t);`
`18`	`18`	`if (!opts) {`
`19`	`19`	`return NULL;`
`20`	`20`	`}`