1 /* -*- buffer-read-only: t -*- vi: set ro: */ 2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 3 /* Safe automatic memory allocation. 4 Copyright (C) 2003-2007, 2009-2019 Free Software Foundation, Inc. 5 Written by Bruno Haible <bruno@clisp.org>, 2003. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, see <https://www.gnu.org/licenses/>. */ 19 20 #ifndef _MALLOCA_H 21 #define _MALLOCA_H 22 23 #include <alloca.h> 24 #include <stddef.h> 25 #include <stdlib.h> 26 #include <stdint.h> 27 28 #include "xalloc-oversized.h" 29 30 31 #ifdef __cplusplus 32 extern "C" { 33 #endif 34 35 36 /* safe_alloca(N) is equivalent to alloca(N) when it is safe to call 37 alloca(N); otherwise it returns NULL. It either returns N bytes of 38 memory allocated on the stack, that lasts until the function returns, 39 or NULL. 40 Use of safe_alloca should be avoided: 41 - inside arguments of function calls - undefined behaviour, 42 - in inline functions - the allocation may actually last until the 43 calling function returns. 44 */ 45 #if HAVE_ALLOCA 46 /* The OS usually guarantees only one guard page at the bottom of the stack, 47 and a page size can be as small as 4096 bytes. So we cannot safely 48 allocate anything larger than 4096 bytes. Also care for the possibility 49 of a few compiler-allocated temporary stack slots. 50 This must be a macro, not a function. */ 51 # define safe_alloca(N) ((N) < 4032 ? alloca (N) : NULL) 52 #else 53 # define safe_alloca(N) ((void) (N), NULL) 54 #endif 55 56 /* malloca(N) is a safe variant of alloca(N). It allocates N bytes of 57 memory allocated on the stack, that must be freed using freea() before 58 the function returns. Upon failure, it returns NULL. */ 59 #if HAVE_ALLOCA 60 # define malloca(N) \ 61 ((N) < 4032 - (2 * sa_alignment_max - 1) \ 62 ? (void *) (((uintptr_t) (char *) alloca ((N) + 2 * sa_alignment_max - 1) \ 63 + (2 * sa_alignment_max - 1)) \ 64 & ~(uintptr_t)(2 * sa_alignment_max - 1)) \ 65 : mmalloca (N)) 66 #else 67 # define malloca(N) \ 68 mmalloca (N) 69 #endif 70 extern void * mmalloca (size_t n); 71 72 /* Free a block of memory allocated through malloca(). */ 73 #if HAVE_ALLOCA 74 extern void freea (void *p); 75 #else 76 # define freea free 77 #endif 78 79 /* nmalloca(N,S) is an overflow-safe variant of malloca (N * S). 80 It allocates an array of N objects, each with S bytes of memory, 81 on the stack. S must be positive and N must be nonnegative. 82 The array must be freed using freea() before the function returns. */ 83 #define nmalloca(n, s) (xalloc_oversized (n, s) ? NULL : malloca ((n) * (s))) 84 85 86 #ifdef __cplusplus 87 } 88 #endif 89 90 91 /* ------------------- Auxiliary, non-public definitions ------------------- */ 92 93 /* Determine the alignment of a type at compile time. */ 94 #if defined __GNUC__ || defined __IBM__ALIGNOF__ 95 # define sa_alignof __alignof__ 96 #elif defined __cplusplus 97 template <class type> struct sa_alignof_helper { char __slot1; type __slot2; }; 98 # define sa_alignof(type) offsetof (sa_alignof_helper<type>, __slot2) 99 #elif defined __hpux 100 /* Work around a HP-UX 10.20 cc bug with enums constants defined as offsetof 101 values. */ 102 # define sa_alignof(type) (sizeof (type) <= 4 ? 4 : 8) 103 #elif defined _AIX 104 /* Work around an AIX 3.2.5 xlc bug with enums constants defined as offsetof 105 values. */ 106 # define sa_alignof(type) (sizeof (type) <= 4 ? 4 : 8) 107 #else 108 # define sa_alignof(type) offsetof (struct { char __slot1; type __slot2; }, __slot2) 109 #endif 110 111 enum 112 { 113 /* The desired alignment of memory allocations is the maximum alignment 114 among all elementary types. */ 115 sa_alignment_long = sa_alignof (long), 116 sa_alignment_double = sa_alignof (double), 117 #if HAVE_LONG_LONG_INT 118 sa_alignment_longlong = sa_alignof (long long), 119 #endif 120 sa_alignment_longdouble = sa_alignof (long double), 121 sa_alignment_max = ((sa_alignment_long - 1) | (sa_alignment_double - 1) 122 #if HAVE_LONG_LONG_INT 123 | (sa_alignment_longlong - 1) 124 #endif 125 | (sa_alignment_longdouble - 1) 126 ) + 1 127 }; 128 129 #endif /* _MALLOCA_H */ 130