[PATCH RFC v3] algol68: Add allocation function for leaf objects

[Jose E. Marchesi]

> On Wed, Jan 14, 2026, at 5:54 PM, Pietro Monteiro wrote:
>>>
>>> Then use leaf malloc if the mode !HAS_ROWS && !HAS_REFS.
>>>
>>> HAS_REFS will be useful for other purposes too...
>>
>> I'm going to try doing that. I'll scream for help if I get stuck :P
>>
>> pietro
>
> This seems to work:

Very nice, this covers all possibilities.

I think at this point the IS_LEAF macro could probably be removed.  In
the few places where it is used, IMHO it is good to see the logic
!HAS_REFS && HAS_ROWS..


>>From 409f48556e07c501ad766059f82502837ee15d40 Mon Sep 17 00:00:00 2001
> From: Pietro Monteiro <pietro@sociotechnical.xyz>
> Date: Wed, 14 Jan 2026 21:37:41 -0500
> Subject: [PATCH] Track if the mode has references
>
> Signed-off-by: Pietro Monteiro <pietro@sociotechnical.xyz>
> ---
>  gcc/algol68/a68-low.cc          |  2 +-
>  gcc/algol68/a68-parser-modes.cc | 25 +++++++++++++++++++++++++
>  gcc/algol68/a68-parser.cc       |  1 +
>  gcc/algol68/a68-types.h         |  8 ++++++--
>  4 files changed, 33 insertions(+), 3 deletions(-)
>
> diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc
> index 57e2cb44847..94af7a3f453 100644
> --- a/gcc/algol68/a68-low.cc
> +++ b/gcc/algol68/a68-low.cc
> @@ -1131,7 +1131,7 @@ tree
>  a68_lower_malloc (MOID_T *m, tree size)
>  {
>    tree type = CTYPE (m);
> -  a68_libcall_fn libcall = LEAF_P (m) ? A68_LIBCALL_MALLOC_LEAF : A68_LIBCALL_MALLOC;
> +  a68_libcall_fn libcall = IS_LEAF (m) ? A68_LIBCALL_MALLOC_LEAF : A68_LIBCALL_MALLOC;
>    return fold_convert (build_pointer_type (type),
>  		       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..e4fd4f141cf 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,26 @@ 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_ref (MOID_T *m)
> +{
> +  if (IS_STRUCT (m) || IS_UNION(m))
> +    {
> +      bool k = false;
> +
> +      for (PACK_T *p = PACK (m); p != NO_PACK && k == false; FORWARD (p))
> +	{
> +	  HAS_REFS (MOID (p)) = is_mode_has_ref (MOID (p));
> +	  k |= (HAS_REFS (MOID (p)));
> +	}
> +      return k;
> +    }
> +  else
> +    return (HAS_REFS (m) || IS_REF (m));
> +}
> +
>  /* Compute derived modes.  */
>  
>  static void
> @@ -1185,6 +1206,10 @@ compute_derived_modes (MODULE_T *mod)
>    for (z = TOP_MOID (mod); z != NO_MOID; FORWARD (z))
>      HAS_ROWS (z) = is_mode_has_row (z);
>  
> +  /* Find out what modes contain refs.  */
> +  for (z = TOP_MOID (mod); z != NO_MOID; FORWARD (z))
> +    HAS_REFS (z) = is_mode_has_ref (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 dd3210d6bb5..f76d908eb21 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)
> @@ -978,7 +982,6 @@ struct GTY(()) A68_T
>  #define LABELS(p) ((p)->labels)
>  #define LAST(p) ((p)->last)
>  #define LAST_LINE(p) ((p)->last_line)
> -#define LEAF_P(m) ((!IS_REF (m) && !HAS_ROWS (m)) ? true : false)
>  #define LESS(p) ((p)->less)
>  #define LEVEL(p) ((p)->level)
>  #define LEX_LEVEL(p) (LEVEL (TABLE (p)))
> @@ -1110,6 +1113,7 @@ struct GTY(()) A68_T
>  #define IS_LITERALLY(p, s) (strcmp (NSYMBOL (p), s) == 0)
>  #define ISNT(p, s) (! IS (p, s))
>  #define IS(p, s) (ATTRIBUTE (p) == (s))
> +#define IS_LEAF(m) (!HAS_REFS (m) && !HAS_ROWS (m))
>  #define IS_REF_FLEX(m) (IS (m, REF_SYMBOL) && IS (SUB (m), FLEX_SYMBOL))
>  #define IS_REF(m) IS ((m), REF_SYMBOL)
>  #define IS_INTEGRAL(m)					  \