[PATCH v5] algol68: Add allocation function for leaf objects
Jose E. Marchesi
jemarch@gnu.org
Sun Jan 18 16:34:58 GMT 2026
Hi Pietro.
Thanks for the updated patch.
> Now a68_lower_malloc only uses HAS_REFS to decide which malloc to use.
> And I merged the loops to set HAS_ROWS and HAS_REFS in compute_derived_modes
> -- >8 --
> Boehm GC has a malloc_atomic function that doesn't clear the new
> allocation and doesn't scan it for pointers.
>
> Add a wrapper for the GC malloc_atomic in the run-time library and use it to
> allocate GC-collectable strings in the library.
>
> Change the lowering of malloc on the front end to select the run-time GC malloc
> function to be used based on the mode having pointers or not. Use leaf
> allocations for modes that are not refs or that don't contain refs.
>
> A boolean `has_refs' member was added to MOID_T and the computation of the
> atrribute is done by the parser when generating the mode list.
>
> gcc/algol68/ChangeLog:
>
> * a68-low-clauses.cc (a68_lower_collateral_clause): Update
> call to a68_lower_alloca.
> * a68-low-coercions.cc (a68_lower_widening): Likewise.
> * a68-low-generator.cc (allocator_t): Adjust typedef.
> (fill_in_buffer): Adjust call to allocator.
> (gen_mode): Likewise.
> * a68-low-multiples.cc (a68_row_malloc): Change type parameter to MOID_T
> from tree. Adjust call to a68_lower_malloc.
> * a68-low-posix.cc (a68_posix_fgets): Adjust call to a68_row_malloc.
> (a68_posix_gets): Likewise.
> * a68-low-runtime.def (MALLOC_LEAF): Add definition for
> _libga68_malloc_leaf.
> * a68-low-strings.cc (a68_string_concat): Adjust call to
> a68_lower_malloc.
> (a68_string_from_char): Likewise.
> * a68-low-units.cc (a68_lower_slice): Likewise.
> * a68-low.cc (a68_low_dup): Adjust calls to a68_lower_malloc
> and a68_lower_alloca.
> (a68_lower_alloca): Change type parameter to MOID_T from tree.
> (a68_lower_malloc): Likewise. Use _libga68_malloc_leaf if the MOID_T
> doesn't have refs, use _libga68_malloc otherwise.
> * a68-parser-modes.cc (a68_create_mode): Set has_refs on the new mode.
> (is_mode_has_refs): New function.
> (compute_derived_modes): Set has_refs on the chain of modes.
> * a68-parser.cc (a68_new_moid):
> * a68-types.h (struct MOID_T): Add member `has_refs`.
> (HAS_REFS): New macro.
> * a68.h (a68_row_malloc): Update prototype.
> (a68_lower_alloca): Likewise.
> (a68_lower_malloc): Likewise.
>
> libga68/ChangeLog:
>
> * ga68-alloc.c (_libga68_malloc_leaf): New function.
> * ga68-posix.c (_libga68_posixfgets): Use _libga68_malloc_leaf
> instead of _libga68_malloc.
> * ga68-unistr.c (_libga68_u32_to_u8): Likewise.
> (_libga68_u8_to_u32): Likewise.
> * ga68.h (_libga68_malloc_leaf): New prototype.
> * ga68.map: Add _libga68_malloc_leaf to the global map.
>
> Signed-off-by: Pietro Monteiro <pietro@sociotechnical.xyz>
> ---
> gcc/algol68/a68-low-clauses.cc | 3 ++-
> gcc/algol68/a68-low-coercions.cc | 2 +-
> gcc/algol68/a68-low-generator.cc | 6 +++---
> gcc/algol68/a68-low-multiples.cc | 5 +++--
> gcc/algol68/a68-low-posix.cc | 4 ++--
> gcc/algol68/a68-low-runtime.def | 1 +
> gcc/algol68/a68-low-strings.cc | 4 ++--
> gcc/algol68/a68-low-units.cc | 2 +-
> gcc/algol68/a68-low.cc | 20 +++++++++++++-------
> gcc/algol68/a68-parser-modes.cc | 29 +++++++++++++++++++++++++++--
> gcc/algol68/a68-parser.cc | 1 +
> gcc/algol68/a68-types.h | 6 +++++-
> gcc/algol68/a68.h | 8 ++++----
> libga68/ga68-alloc.c | 15 +++++++++++++++
> libga68/ga68-posix.c | 4 ++--
> libga68/ga68-unistr.c | 8 ++++----
> libga68/ga68.h | 1 +
> libga68/ga68.map | 1 +
> 18 files changed, 88 insertions(+), 32 deletions(-)
>
> diff --git a/gcc/algol68/a68-low-clauses.cc b/gcc/algol68/a68-low-clauses.cc
> index 20ab22929bc..26607d7f422 100644
> --- a/gcc/algol68/a68-low-clauses.cc
> +++ b/gcc/algol68/a68-low-clauses.cc
> @@ -1246,6 +1246,7 @@ a68_lower_collateral_clause (NODE_T *p ATTRIBUTE_UNUSED,
> tree sub_multiple_elements = a68_multiple_elements (sub_multiple);
> tree elements_pointer_type = TREE_TYPE (sub_multiple_elements);
> tree elements_type = TREE_TYPE (elements_pointer_type);
> + MOID_T *elements_moid = a68_type_moid (elements_type);
> multiple_elements_size = fold_build2 (MULT_EXPR, sizetype,
> size_int (num_units),
> size_in_bytes (elements_type));
> @@ -1254,7 +1255,7 @@ a68_lower_collateral_clause (NODE_T *p ATTRIBUTE_UNUSED,
> a68_multiple_num_elems (sub_multiple));
> multiple_elements = a68_lower_tmpvar ("multiple_elements%",
> elements_pointer_type,
> - a68_lower_alloca (elements_type,
> + a68_lower_alloca (elements_moid,
> multiple_elements_size));
>
> /* We can also now calculate the bounds of the new multiple.
> diff --git a/gcc/algol68/a68-low-coercions.cc b/gcc/algol68/a68-low-coercions.cc
> index b9e1acee9ce..3941917223f 100644
> --- a/gcc/algol68/a68-low-coercions.cc
> +++ b/gcc/algol68/a68-low-coercions.cc
> @@ -350,7 +350,7 @@ a68_lower_widening (NODE_T *p, LOW_CTX_T ctx)
> /* First allocate space for the elements. */
> tree elements = a68_lower_tmpvar ("elements%",
> pointer_to_bool_type,
> - a68_lower_alloca (a68_bool_type,
> + a68_lower_alloca (M_BOOL,
> fold_build2 (MULT_EXPR,
> sizetype,
> size_int (bits_size),
> diff --git a/gcc/algol68/a68-low-generator.cc b/gcc/algol68/a68-low-generator.cc
> index 5c4d65569b3..e321b7d5ec2 100644
> --- a/gcc/algol68/a68-low-generator.cc
> +++ b/gcc/algol68/a68-low-generator.cc
> @@ -43,7 +43,7 @@
> #include "a68.h"
>
>
> -typedef tree (*allocator_t) (tree, tree);
> +typedef tree (*allocator_t) (MOID_T*, tree);
>
> /* Lower to code that fill in BOUNDS and elements pointers in the given buffer
> pointed by BUFFER at offset OFFSET according to the mode MODE, and evals to
> @@ -205,7 +205,7 @@ fill_in_buffer (tree buffer, tree offset, tree_stmt_iterator *bounds, MOID_T *m,
> MOID_T *elem_mode = SUB (m);
> tree elem_size = fold_convert (sizetype, size_in_bytes (CTYPE (elem_mode)));
> tree elems_size = save_expr (fold_build2 (MULT_EXPR, sizetype, elem_size, num_elems));
> - tree elemsptr = (*allocator) (CTYPE (elem_mode), elems_size);
> + tree elemsptr = (*allocator) (elem_mode, elems_size);
> elemsptr = save_expr (elemsptr);
>
> /* And initialize them. */
> @@ -337,7 +337,7 @@ static tree
> gen_mode (MOID_T *m, tree_stmt_iterator *bounds, allocator_t allocator)
> {
> /* Allocate space for the value and fill it. */
> - tree buffer = (*allocator) (CTYPE (m), size_in_bytes (CTYPE (m)));
> + tree buffer = (*allocator) (m, size_in_bytes (CTYPE (m)));
> buffer = save_expr (buffer);
> return fill_in_buffer (buffer, size_zero_node, bounds, m, allocator);
> }
> diff --git a/gcc/algol68/a68-low-multiples.cc b/gcc/algol68/a68-low-multiples.cc
> index 572162e30ac..bcaa4c28074 100644
> --- a/gcc/algol68/a68-low-multiples.cc
> +++ b/gcc/algol68/a68-low-multiples.cc
> @@ -1074,16 +1074,17 @@ a68_multiple_bounds_check_equal (NODE_T *p, tree m1, tree m2)
> *LOWER_BOUND and *UPPER_BOUND are the bounds for the DIM dimensions. */
>
> tree
> -a68_row_malloc (tree type, int dim, tree elems, tree elems_size,
> +a68_row_malloc (MOID_T *m, int dim, tree elems, tree elems_size,
> tree *lower_bound, tree *upper_bound)
> {
> + tree type = CTYPE (m);
> tree ptr_to_type = build_pointer_type (type);
>
> a68_push_range (NULL);
>
> /* Allocate space for the descriptor. */
> tree ptr_to_multiple = a68_lower_tmpvar ("ptr_to_multiple%", ptr_to_type,
> - a68_lower_malloc (type, size_in_bytes (type)));
> + a68_lower_malloc (m, size_in_bytes (type)));
> tree multiple = a68_row_value (type, dim,
> elems, elems_size,
> lower_bound, upper_bound);
> diff --git a/gcc/algol68/a68-low-posix.cc b/gcc/algol68/a68-low-posix.cc
> index 1a9d5eb1b63..c0fd947fdb4 100644
> --- a/gcc/algol68/a68-low-posix.cc
> +++ b/gcc/algol68/a68-low-posix.cc
> @@ -503,7 +503,7 @@ a68_posix_fgets (void)
> tree upper_bound = fold_convert (ssizetype, len);
> tree elems_size = fold_build2 (MULT_EXPR, sizetype,
> len, size_in_bytes (a68_char_type));
> - tree body = a68_row_malloc (CTYPE (M_STRING), 1 /* dim */,
> + tree body = a68_row_malloc (M_STRING, 1 /* dim */,
> elems, elems_size,
> &lower_bound, &upper_bound);
> a68_pop_function_range (body);
> @@ -545,7 +545,7 @@ a68_posix_gets (void)
> tree upper_bound = fold_convert (ssizetype, len);
> tree elems_size = fold_build2 (MULT_EXPR, sizetype,
> len, size_in_bytes (a68_char_type));
> - tree body = a68_row_malloc (CTYPE (M_STRING), 1 /* dim */,
> + tree body = a68_row_malloc (M_STRING, 1 /* dim */,
> elems, elems_size,
> &lower_bound, &upper_bound);
> a68_pop_function_range (body);
> diff --git a/gcc/algol68/a68-low-runtime.def b/gcc/algol68/a68-low-runtime.def
> index ecb8553238d..326e4d00bc9 100644
> --- a/gcc/algol68/a68-low-runtime.def
> +++ b/gcc/algol68/a68-low-runtime.def
> @@ -43,6 +43,7 @@ along with GCC; see the file COPYING3. If not see
>
> DEF_A68_RUNTIME (ASSERT, "_libga68_assert", RT(VOID), P2(CONSTCHARPTR, UINT), ECF_NORETURN)
> DEF_A68_RUNTIME (MALLOC, "_libga68_malloc", RT(VOIDPTR), P1(SIZE), ECF_NOTHROW | ECF_LEAF | ECF_MALLOC)
> +DEF_A68_RUNTIME (MALLOC_LEAF, "_libga68_malloc_leaf", RT(VOIDPTR), P1(SIZE), ECF_NOTHROW | ECF_LEAF | ECF_MALLOC)
> DEF_A68_RUNTIME (DEREFNIL, "_libga68_derefnil", RT(VOID), P2(CONSTCHARPTR, UINT), ECF_NORETURN)
> DEF_A68_RUNTIME (UNREACHABLE, "_libga68_unreachable", RT(VOID), P2(CONSTCHARPTR, UINT), ECF_NORETURN)
> DEF_A68_RUNTIME (INVALIDCHARERROR, "_libga68_invalidcharerror", RT(VOID), P3(CONSTCHARPTR,UINT,INT), ECF_NORETURN)
> diff --git a/gcc/algol68/a68-low-strings.cc b/gcc/algol68/a68-low-strings.cc
> index f5822037e33..5af83bf944d 100644
> --- a/gcc/algol68/a68-low-strings.cc
> +++ b/gcc/algol68/a68-low-strings.cc
> @@ -149,7 +149,7 @@ a68_string_concat (tree str1, tree str2)
> size_in_bytes (a68_char_type),
> num_elems);
> tree elements = a68_lower_tmpvar ("elements%", char_pointer_type,
> - a68_lower_malloc (a68_char_type, elements_size));
> + a68_lower_malloc (M_CHAR, elements_size));
>
> /* Copy elements. */
> tree to_index = a68_lower_tmpvar ("to_index%", sizetype, size_zero_node);
> @@ -234,7 +234,7 @@ a68_string_from_char (tree c)
> a68_push_range (M_STRING);
>
> tree elements = a68_lower_tmpvar ("elements%", char_pointer_type,
> - a68_lower_malloc (a68_char_type,
> + a68_lower_malloc (M_CHAR,
> size_one_node));
> a68_add_stmt (fold_build2 (MODIFY_EXPR,
> void_type_node,
> diff --git a/gcc/algol68/a68-low-units.cc b/gcc/algol68/a68-low-units.cc
> index 9802468873b..caaa5bb27ac 100644
> --- a/gcc/algol68/a68-low-units.cc
> +++ b/gcc/algol68/a68-low-units.cc
> @@ -778,7 +778,7 @@ a68_lower_slice (NODE_T *p, LOW_CTX_T ctx)
> {
> tree ptrtype = CTYPE (orig_sliced_multiple_mode);
> tree slice_addr = fold_build1 (ADDR_EXPR, ptrtype, slice);
> - tree alloc = a68_lower_malloc (ptrtype, size_in_bytes (TREE_TYPE (slice)));
> + tree alloc = a68_lower_malloc (orig_sliced_multiple_mode, size_in_bytes (TREE_TYPE (slice)));
> alloc = save_expr (alloc);
> tree copy = a68_lower_memcpy (alloc, slice_addr, size_in_bytes (TREE_TYPE (slice)));
>
> diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc
> index ac603ef13e7..2f37a6964f3 100644
> --- a/gcc/algol68/a68-low.cc
> +++ b/gcc/algol68/a68-low.cc
> @@ -741,12 +741,14 @@ a68_low_dup (tree expr, bool use_heap)
> tree element_pointer_type = TREE_TYPE (elements);
> tree element_type = TREE_TYPE (element_pointer_type);
> tree new_elements_size = save_expr (a68_multiple_elements_size (expr));
> + tree new_elements_type = TREE_TYPE (TREE_TYPE (elements));
> + MOID_T *new_elements_moid = a68_type_moid (new_elements_type);
> tree new_elements = a68_lower_tmpvar ("new_elements%",
> TREE_TYPE (elements),
> (use_heap
> - ? a68_lower_malloc (TREE_TYPE (TREE_TYPE (elements)),
> + ? a68_lower_malloc (new_elements_moid,
> new_elements_size)
> - : a68_lower_alloca (TREE_TYPE (TREE_TYPE (elements)),
> + : a68_lower_alloca (new_elements_moid,
> new_elements_size)));
>
> /* Then copy the elements.
> @@ -1110,8 +1112,9 @@ a68_lower_memcpy (tree dst, tree src, tree size)
> pointer to it. */
>
> tree
> -a68_lower_alloca (tree type, tree size)
> +a68_lower_alloca (MOID_T *m, tree size)
> {
> + tree type = CTYPE (m);
> tree call = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
> call = build_call_expr_loc (UNKNOWN_LOCATION, call, 2,
> size,
> @@ -1121,14 +1124,17 @@ a68_lower_alloca (tree type, tree size)
> }
>
>
> -/* Build a tree that allocates SIZE bytes on the heap and returns a *TYPE
> - pointer to it. */
> +/* Build a tree that allocates SIZE bytes on the heap and returns a pointer to
> + a tree with type equivalent to mode M. */
>
> tree
> -a68_lower_malloc (tree type, tree size)
> +a68_lower_malloc (MOID_T *m, tree size)
> {
> + tree type = CTYPE (m);
> + a68_libcall_fn libcall
> + = HAS_REFS (m) ? A68_LIBCALL_MALLOC : A68_LIBCALL_MALLOC_LEAF;
Row descriptors also have pointers.
I think you want:
HAS_REFS (m) || HAS_ROWS (m) ? A68_LIBCALL_MALLOC : A68_LIBCALL_MALLOC_LEAF
> return fold_convert (build_pointer_type (type),
> - a68_build_libcall (A68_LIBCALL_MALLOC, ptr_type_node,
> + a68_build_libcall (libcall, ptr_type_node,
> 1, size));
> }
>
> diff --git a/gcc/algol68/a68-parser-modes.cc b/gcc/algol68/a68-parser-modes.cc
> index 6b96fa2033b..f231100f727 100644
> --- a/gcc/algol68/a68-parser-modes.cc
> +++ b/gcc/algol68/a68-parser-modes.cc
> @@ -175,6 +175,7 @@ a68_create_mode (int att, int dim, NODE_T *node, MOID_T *sub, PACK_T *pack)
> DIM (new_mode) = dim;
> NODE (new_mode) = node;
> HAS_ROWS (new_mode) = (att == ROW_SYMBOL);
> + HAS_REFS (new_mode) = (att == REF_SYMBOL);
> SUB (new_mode) = sub;
> PACK (new_mode) = pack;
> NEXT (new_mode) = NO_MOID;
> @@ -1033,6 +1034,27 @@ is_mode_has_row (MOID_T *m)
> return (HAS_ROWS (m) || IS_ROW (m) || IS_FLEX (m));
> }
>
> +/* Whether mode has ref. */
> +
> +static bool
> +is_mode_has_refs (MOID_T *m)
> +{
> + if (IS_ROW (m) || IS_FLEX (m))
> + return HAS_REFS (m) = is_mode_has_refs (SUB (m));
I would prefer:
{
HAS_REFS (m) = is_mode_has_refs (m);
return HAS_REFS (m);
}
But if you must, please use parentheses:
return (HAS_REFS (m) = is_mode_has_refs (SUB (m)));
The GCS requires this, and in fact I expect GCC will give you a warning
otherwise..
> + else if (IS_STRUCT (m) || IS_UNION (m))
> + {
> + bool has_refs = false;
> + for (PACK_T *p = PACK (m); p != NO_PACK; FORWARD (p))
> + {
> + HAS_REFS (MOID (p)) = is_mode_has_refs (MOID (p));
> + has_refs |= HAS_REFS (MOID (p));
> + }
> + return has_refs;
> + }
> + else
> + return HAS_REFS (m);
> +}
> +
> /* Compute derived modes. */
>
> static void
> @@ -1181,9 +1203,12 @@ compute_derived_modes (MODULE_T *mod)
>
> gcc_assert (M_STRING == M_FLEX_ROW_CHAR);
>
> - /* Find out what modes contain rows. */
> + /* Find out what modes contain rows, and refs. */
> for (z = TOP_MOID (mod); z != NO_MOID; FORWARD (z))
> - HAS_ROWS (z) = is_mode_has_row (z);
> + {
> + HAS_ROWS (z) = is_mode_has_row (z);
> + HAS_REFS (z) = is_mode_has_refs (z);
> + }
>
> /* Check flexible modes. */
> for (z = TOP_MOID (mod); z != NO_MOID; FORWARD (z))
> diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc
> index 725a8fc44de..1504e4dc25b 100644
> --- a/gcc/algol68/a68-parser.cc
> +++ b/gcc/algol68/a68-parser.cc
> @@ -726,6 +726,7 @@ a68_new_moid (void)
> DIM (z) = 0;
> USE (z) = false;
> HAS_ROWS (z) = false;
> + HAS_REFS (z) = false;
> PORTABLE (z) = true;
> DERIVATE (z) = false;
> NODE (z) = NO_NODE;
> diff --git a/gcc/algol68/a68-types.h b/gcc/algol68/a68-types.h
> index 788e7230f92..f18d3501799 100644
> --- a/gcc/algol68/a68-types.h
> +++ b/gcc/algol68/a68-types.h
> @@ -187,6 +187,9 @@ struct GTY((chain_next ("%h.more"), chain_prev ("%h.less"))) KEYWORD_T
> HAS_ROWS is true if the mode contains rows somewhere in its internal
> structure.
>
> + HAS_REFS is true if the mode contains refs somewhere in its internal
> + structure.
> +
> The interpretation of SUB depends on the kind of mode:
> - For REF modes it is the referred mode.
> - For FLEX modes it is the referred mode.
> @@ -244,7 +247,7 @@ struct GTY((chain_next ("%h.next"))) MOID_T
> int number;
> int attribute;
> int dim;
> - bool has_rows, use, portable, derivate;
> + bool has_rows, has_refs, use, portable, derivate;
> NODE_T *node;
> PACK_T *pack;
> MOID_T *sub, *equivalent_mode, *slice, *deflexed_mode, *name, *multiple_mode, *next, *rowed, *trim;
> @@ -950,6 +953,7 @@ struct GTY(()) A68_T
> #define GREEN(p) ((p)->green)
> #define H(p) ((p)->h)
> #define HANDLE(p) ((p)->handle)
> +#define HAS_REFS(p) ((p)->has_refs)
> #define HAS_ROWS(p) ((p)->has_rows)
> #define HEAP(p) ((p)->heap)
> #define ID(p) ((p)->id)
> diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h
> index 7c6d51bd064..34090d12c05 100644
> --- a/gcc/algol68/a68.h
> +++ b/gcc/algol68/a68.h
> @@ -699,9 +699,9 @@ tree a68_row_value (tree type, size_t dim,
> tree *lower_bound, tree *upper_bound);
> tree a68_row_value_raw (tree type, tree descriptor,
> tree elements, tree elements_size);
> -tree a68_row_malloc (tree type, int dim,
> +tree a68_row_malloc (MOID_T *m, int dim,
> tree elements, tree elements_size,
> - tree *lower_bound, tree *upper_bound);
> + tree *lower_bound, tree *upper_bound);
> tree a68_multiple_slice (NODE_T *p, tree multiple, bool slicing_name,
> int num_indexes, tree *indexes);
> tree a68_multiple_copy_elems (MOID_T *to_mode, tree to, tree from);
> @@ -815,8 +815,8 @@ tree a68_get_skip_tree (MOID_T *m);
> tree a68_get_empty (void);
> void a68_ref_counts (tree exp, MOID_T *m, int *num_refs, int *num_pointers);
> tree a68_consolidate_ref (MOID_T *m, tree expr);
> -tree a68_lower_alloca (tree type, tree size);
> -tree a68_lower_malloc (tree type, tree size);
> +tree a68_lower_alloca (MOID_T *m, tree size);
> +tree a68_lower_malloc (MOID_T *m, tree size);
> tree a68_checked_indirect_ref (NODE_T *p, tree exp, MOID_T *exp_mode);
> tree a68_low_deref (tree exp, NODE_T *p);
> tree a68_low_dup (tree exp, bool use_heap = false);
> diff --git a/libga68/ga68-alloc.c b/libga68/ga68-alloc.c
> index 1a0b25a098c..df8a8956c52 100644
> --- a/libga68/ga68-alloc.c
> +++ b/libga68/ga68-alloc.c
> @@ -80,6 +80,15 @@ _libga68_malloc (size_t size)
> return res;
> }
>
> +void *
> +_libga68_malloc_leaf (size_t size)
> +{
> + void *res = (void *) GC_MALLOC_ATOMIC (size);
> + if (!res)
> + _libga68_abort ("Virtual memory exhausted\n");
> + return res;
> +}
> +
> #else
>
> void
> @@ -112,4 +121,10 @@ _libga68_malloc (size_t size)
> return res;
> }
>
> +void *
> +_libga68_malloc_leaf (size_t size)
> +{
> + return _libga68_malloc (size);
> +}
> +
> #endif /* !LIBGA68_WITH_GC */
> diff --git a/libga68/ga68-posix.c b/libga68/ga68-posix.c
> index a671dd61d16..b6fba202497 100644
> --- a/libga68/ga68-posix.c
> +++ b/libga68/ga68-posix.c
> @@ -322,7 +322,7 @@ _libga68_posixfgets (int fd, int nchars, size_t *len)
> if (nchars > 0)
> {
> /* Read exactly nchar or until EOF. */
> - res = _libga68_malloc (nchars * sizeof (uint32_t));
> + res = _libga68_malloc_leaf (nchars * sizeof (uint32_t));
> do
> {
> uc = _libga68_posixfgetc (fd);
> @@ -336,7 +336,7 @@ _libga68_posixfgets (int fd, int nchars, size_t *len)
> {
> /* Read until newline or EOF. */
> size_t allocated = 80 * sizeof (uint32_t);
> - res = _libga68_malloc (allocated);
> + res = _libga68_malloc_leaf (allocated);
> do
> {
> uc = _libga68_posixfgetc (fd);
> diff --git a/libga68/ga68-unistr.c b/libga68/ga68-unistr.c
> index 2cdf732a6b2..2a71313c181 100644
> --- a/libga68/ga68-unistr.c
> +++ b/libga68/ga68-unistr.c
> @@ -363,7 +363,7 @@ _libga68_u32_to_u8 (const uint32_t *s, size_t n, size_t stride,
> if (length + 6 > allocated)
> allocated = length + 6;
> if (result == resultbuf || result == NULL)
> - memory = (uint8_t *) _libga68_malloc (allocated * sizeof (uint8_t));
> + memory = (uint8_t *) _libga68_malloc_leaf (allocated * sizeof (uint8_t));
> else
> memory =
> (uint8_t *) _libga68_realloc (result, allocated * sizeof (uint8_t));
> @@ -384,7 +384,7 @@ _libga68_u32_to_u8 (const uint32_t *s, size_t n, size_t stride,
> if (result == NULL)
> {
> /* Return a non-NULL value. NULL means error. */
> - result = (uint8_t *) _libga68_malloc (1);
> + result = (uint8_t *) _libga68_malloc_leaf (1);
> if (result == NULL)
> {
> errno = ENOMEM;
> @@ -580,7 +580,7 @@ _libga68_u8_to_u32 (const uint8_t *s, size_t n, uint32_t *resultbuf, size_t *len
> if (length + 1 > allocated)
> allocated = length + 1;
> if (result == resultbuf || result == NULL)
> - memory = (uint32_t *) _libga68_malloc (allocated * sizeof (uint32_t));
> + memory = (uint32_t *) _libga68_malloc_leaf (allocated * sizeof (uint32_t));
> else
> memory =
> (uint32_t *) _libga68_realloc (result, allocated * sizeof (uint32_t));
> @@ -598,7 +598,7 @@ _libga68_u8_to_u32 (const uint8_t *s, size_t n, uint32_t *resultbuf, size_t *len
> if (result == NULL)
> {
> /* Return a non-NULL value. NULL means error. */
> - result = (uint32_t *) _libga68_malloc (1);
> + result = (uint32_t *) _libga68_malloc_leaf (1);
> }
> }
> else if (result != resultbuf && length < allocated)
> diff --git a/libga68/ga68.h b/libga68/ga68.h
> index 008ce05282a..8d1cf20c162 100644
> --- a/libga68/ga68.h
> +++ b/libga68/ga68.h
> @@ -70,6 +70,7 @@ void _libga68_bounds_mismatch (const char *filename, unsigned int lineno,
>
> void _libga68_init_heap (void) GA68_HIDDEN;
> void *_libga68_malloc (size_t size);
> +void *_libga68_malloc_leaf (size_t size);
> void *_libga68_malloc_internal (size_t size) GA68_HIDDEN;
> void *_libga68_realloc (void *ptr, size_t size) GA68_HIDDEN;
> void *_libga68_realloc_unchecked (void *ptr, size_t size) GA68_HIDDEN;
> diff --git a/libga68/ga68.map b/libga68/ga68.map
> index 6917e7905ae..6ee93228358 100644
> --- a/libga68/ga68.map
> +++ b/libga68/ga68.map
> @@ -11,6 +11,7 @@ LIBGA68_2.0 {
> _libga68_longrandom;
> _libga68_lower_bound;
> _libga68_malloc;
> + _libga68_malloc_leaf;
> _libga68_posixargc;
> _libga68_posixargv;
> _libga68_posixclose;
More information about the Algol68
mailing list