Subversion Repositories scarts

/* Pipeline hazard description translator.

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005

   Free Software Foundation, Inc.

   Written by Vladimir Makarov <vmakarov@redhat.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it

under the terms of the GNU General Public License as published by the

Free Software Foundation; either version 2, or (at your option) any

later version.

GCC is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING.  If not, write to the Free

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

/* References:

   1. Detecting pipeline structural hazards quickly. T. Proebsting,

      C. Fraser. Proceedings of ACM SIGPLAN-SIGACT Symposium on

      Principles of Programming Languages, pages 280--286, 1994.

      This article is a good start point to understand usage of finite

      state automata for pipeline hazard recognizers.  But I'd

      recommend the 2nd article for more deep understanding.

   2. Efficient Instruction Scheduling Using Finite State Automata:

      V. Bala and N. Rubin, Proceedings of MICRO-28.  This is the best

      article about usage of finite state automata for pipeline hazard

      recognizers.

   The current implementation is different from the 2nd article in the

   following:

   1. New operator `|' (alternative) is permitted in functional unit

      reservation which can be treated deterministically and

      non-deterministically.

   2. Possibility of usage of nondeterministic automata too.

   3. Possibility to query functional unit reservations for given

      automaton state.

   4. Several constructions to describe impossible reservations

      (`exclusion_set', `presence_set', `final_presence_set',

      `absence_set', and `final_absence_set').

   5. No reverse automata are generated.  Trace instruction scheduling

      requires this.  It can be easily added in the future if we

      really need this.

   6. Union of automaton states are not generated yet.  It is planned

      to be implemented.  Such feature is needed to make more accurate

      interlock insn scheduling to get state describing functional

      unit reservation in a joint CFG point.  */

/* This file code processes constructions of machine description file

   which describes automaton used for recognition of processor pipeline

   hazards by insn scheduler and can be used for other tasks (such as

   VLIW insn packing.

   The translator functions `gen_cpu_unit', `gen_query_cpu_unit',

   `gen_bypass', `gen_excl_set', `gen_presence_set',

   `gen_final_presence_set', `gen_absence_set',

   `gen_final_absence_set', `gen_automaton', `gen_automata_option',

   `gen_reserv', `gen_insn_reserv' are called from file

   `genattrtab.c'.  They transform RTL constructions describing

   automata in .md file into internal representation convenient for

   further processing.

   The translator major function `expand_automata' processes the

   description internal representation into finite state automaton.

   It can be divided on:

     o checking correctness of the automaton pipeline description

       (major function is `check_all_description').

     o generating automaton (automata) from the description (major

       function is `make_automaton').

     o optional transformation of nondeterministic finite state

       automata into deterministic ones if the alternative operator

       `|' is treated nondeterministically in the description (major

       function is NDFA_to_DFA).

     o optional minimization of the finite state automata by merging

       equivalent automaton states (major function is `minimize_DFA').

     o forming tables (some as comb vectors) and attributes

       representing the automata (functions output_..._table).

   Function `write_automata' outputs the created finite state

   automaton as different tables and functions which works with the

   automata to inquire automaton state and to change its state.  These

   function are used by gcc instruction scheduler and may be some

   other gcc code.  */

#include "bconfig.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "obstack.h"

#include "errors.h"

#include <math.h>

#include "hashtab.h"

#include "varray.h"

#ifndef CHAR_BIT

#define CHAR_BIT 8

#endif

#include "genattrtab.h"

/* Positions in machine description file.  Now they are not used.  But

   they could be used in the future for better diagnostic messages.  */

typedef int pos_t;

/* The following is element of vector of current (and planned in the

   future) functional unit reservations.  */

typedef unsigned HOST_WIDE_INT set_el_t;

/* Reservations of function units are represented by value of the following

   type.  */

typedef set_el_t *reserv_sets_t;

/* The following structure represents variable length array (vla) of

   pointers and HOST WIDE INTs.  We could be use only varray.  But we

   add new lay because we add elements very frequently and this could

   stress OS allocator when varray is used only.  */

typedef struct {

  size_t length;      /* current size of vla.  */

  varray_type varray; /* container for vla.  */

} vla_ptr_t;

typedef vla_ptr_t vla_hwint_t;

/* The following structure describes a ticker.  */

struct ticker

{

  /* The following member value is time of the ticker creation with

     taking into account time when the ticker is off.  Active time of

     the ticker is current time minus the value.  */

  int modified_creation_time;

  /* The following member value is time (incremented by one) when the

     ticker was off.  Zero value means that now the ticker is on.  */

  int incremented_off_time;

};

/* The ticker is represented by the following type.  */

typedef struct ticker ticker_t;

/* The following type describes elements of output vectors.  */

typedef HOST_WIDE_INT vect_el_t;

/* Forward declaration of structures of internal representation of

   pipeline description based on NDFA.  */

struct unit_decl;

struct bypass_decl;

struct result_decl;

struct automaton_decl;

struct unit_pattern_rel_decl;

struct reserv_decl;

struct insn_reserv_decl;

struct decl;

struct unit_regexp;

struct result_regexp;

struct reserv_regexp;

struct nothing_regexp;

struct sequence_regexp;

struct repeat_regexp;

struct allof_regexp;

struct oneof_regexp;

struct regexp;

struct description;

struct unit_set_el;

struct pattern_set_el;

struct pattern_reserv;

struct state;

struct alt_state;

struct arc;

struct ainsn;

struct automaton;

struct state_ainsn_table;

/* The following typedefs are for brevity.  */

typedef struct unit_decl *unit_decl_t;

typedef struct decl *decl_t;

typedef struct regexp *regexp_t;

typedef struct unit_set_el *unit_set_el_t;

typedef struct pattern_set_el *pattern_set_el_t;

typedef struct pattern_reserv *pattern_reserv_t;

typedef struct alt_state *alt_state_t;

typedef struct state *state_t;

typedef struct arc *arc_t;

typedef struct ainsn *ainsn_t;

typedef struct automaton *automaton_t;

typedef struct automata_list_el *automata_list_el_t;

typedef struct state_ainsn_table *state_ainsn_table_t;

/* Prototypes of functions gen_cpu_unit, gen_query_cpu_unit,

   gen_bypass, gen_excl_set, gen_presence_set, gen_final_presence_set,

   gen_absence_set, gen_final_absence_set, gen_automaton,

   gen_automata_option, gen_reserv, gen_insn_reserv,

   initiate_automaton_gen, expand_automata, write_automata are

   described on the file top because the functions are called from

   function `main'.  */

static void *create_node             (size_t);

static void *copy_node               (const void *, size_t);

static char *check_name              (char *, pos_t);

static char *next_sep_el             (char **, int, int);

static int n_sep_els                 (char *, int, int);

static char **get_str_vect           (char *, int *, int, int);

static void gen_presence_absence_set (rtx, int, int);

static regexp_t gen_regexp_el        (char *);

static regexp_t gen_regexp_repeat    (char *);

static regexp_t gen_regexp_allof     (char *);

static regexp_t gen_regexp_oneof     (char *);

static regexp_t gen_regexp_sequence  (char *);

static regexp_t gen_regexp           (char *);

static unsigned string_hash          (const char *);

static unsigned automaton_decl_hash  (const void *);

static int automaton_decl_eq_p       (const void *,

                                      const void *);

static decl_t insert_automaton_decl       (decl_t);

static decl_t find_automaton_decl         (char *);

static void initiate_automaton_decl_table (void);

static void finish_automaton_decl_table   (void);

static hashval_t insn_decl_hash           (const void *);

static int insn_decl_eq_p                 (const void *,

                                           const void *);

static decl_t insert_insn_decl            (decl_t);

static decl_t find_insn_decl              (char *);

static void initiate_insn_decl_table      (void);

static void finish_insn_decl_table        (void);

static hashval_t decl_hash                (const void *);

static int decl_eq_p                      (const void *,

                                           const void *);

static decl_t insert_decl                 (decl_t);

static decl_t find_decl                   (char *);

static void initiate_decl_table           (void);

static void finish_decl_table             (void);

static unit_set_el_t process_excls       (char **, int, pos_t);

static void add_excls                    (unit_set_el_t, unit_set_el_t,

                                          pos_t);

static unit_set_el_t process_presence_absence_names

                                         (char **, int, pos_t,

                                          int, int);

static pattern_set_el_t process_presence_absence_patterns

                                         (char ***, int, pos_t,

                                          int, int);

static void add_presence_absence         (unit_set_el_t,

                                          pattern_set_el_t,

                                          pos_t, int, int);

static void process_decls                (void);

static struct bypass_decl *find_bypass   (struct bypass_decl *,

                                          struct insn_reserv_decl *);

static void check_automaton_usage        (void);

static regexp_t process_regexp           (regexp_t);

static void process_regexp_decls         (void);

static void check_usage                  (void);

static int loop_in_regexp                (regexp_t, decl_t);

static void check_loops_in_regexps       (void);

static void process_regexp_cycles        (regexp_t, int, int,

                                          int *, int *);

static void evaluate_max_reserv_cycles   (void);

static void check_all_description        (void);

static ticker_t create_ticker               (void);

static void ticker_off                      (ticker_t *);

static void ticker_on                       (ticker_t *);

static int active_time                      (ticker_t);

static void print_active_time               (FILE *, ticker_t);

static void add_advance_cycle_insn_decl     (void);

static alt_state_t get_free_alt_state (void);

static void free_alt_state              (alt_state_t);

static void free_alt_states             (alt_state_t);

static int alt_state_cmp                (const void *alt_state_ptr_1,

                                         const void *alt_state_ptr_2);

static alt_state_t uniq_sort_alt_states (alt_state_t);

static int alt_states_eq                (alt_state_t, alt_state_t);

static void initiate_alt_states         (void);

static void finish_alt_states           (void);

static reserv_sets_t alloc_empty_reserv_sets (void);

static unsigned reserv_sets_hash_value (reserv_sets_t);

static int reserv_sets_cmp             (reserv_sets_t, reserv_sets_t);

static int reserv_sets_eq              (reserv_sets_t, reserv_sets_t);

static void set_unit_reserv            (reserv_sets_t, int, int);

static int test_unit_reserv            (reserv_sets_t, int, int);

static int it_is_empty_reserv_sets     (reserv_sets_t)

                                            ATTRIBUTE_UNUSED;

static int reserv_sets_are_intersected (reserv_sets_t, reserv_sets_t);

static void reserv_sets_shift          (reserv_sets_t, reserv_sets_t);

static void reserv_sets_or             (reserv_sets_t, reserv_sets_t,

                                        reserv_sets_t);

static void reserv_sets_and            (reserv_sets_t, reserv_sets_t,

                                        reserv_sets_t)

                                            ATTRIBUTE_UNUSED;

static void output_cycle_reservs       (FILE *, reserv_sets_t,

                                        int, int);

static void output_reserv_sets         (FILE *, reserv_sets_t);

static state_t get_free_state          (int, automaton_t);

static void free_state                 (state_t);

static hashval_t state_hash            (const void *);

static int state_eq_p                  (const void *, const void *);

static state_t insert_state            (state_t);

static void set_state_reserv           (state_t, int, int);

static int intersected_state_reservs_p (state_t, state_t);

static state_t states_union            (state_t, state_t, reserv_sets_t);

static state_t state_shift             (state_t, reserv_sets_t);

static void initiate_states            (void);

static void finish_states              (void);

static void free_arc           (arc_t);

static void remove_arc         (state_t, arc_t);

static arc_t find_arc          (state_t, state_t, ainsn_t);

static arc_t add_arc           (state_t, state_t, ainsn_t, int);

static arc_t first_out_arc     (state_t);

static arc_t next_out_arc      (arc_t);

static void initiate_arcs      (void);

static void finish_arcs        (void);

static automata_list_el_t get_free_automata_list_el (void);

static void free_automata_list_el (automata_list_el_t);

static void free_automata_list (automata_list_el_t);

static hashval_t automata_list_hash (const void *);

static int automata_list_eq_p (const void *, const void *);

static void initiate_automata_lists (void);

static void automata_list_start (void);

static void automata_list_add (automaton_t);

static automata_list_el_t automata_list_finish (void);

static void finish_automata_lists (void);

static void initiate_excl_sets             (void);

static reserv_sets_t get_excl_set          (reserv_sets_t);

static pattern_reserv_t form_reserv_sets_list (pattern_set_el_t);

static void initiate_presence_absence_pattern_sets     (void);

static int check_presence_pattern_sets     (reserv_sets_t,

                                            reserv_sets_t, int);

static int check_absence_pattern_sets  (reserv_sets_t, reserv_sets_t,

                                        int);

static regexp_t copy_insn_regexp     (regexp_t);

static regexp_t transform_1          (regexp_t);

static regexp_t transform_2          (regexp_t);

static regexp_t transform_3          (regexp_t);

static regexp_t regexp_transform_func

                       (regexp_t, regexp_t (*) (regexp_t));

static regexp_t transform_regexp            (regexp_t);

static void transform_insn_regexps          (void);

static void store_alt_unit_usage (regexp_t, regexp_t, int, int);

static void check_regexp_units_distribution   (const char *, regexp_t);

static void check_unit_distributions_to_automata (void);

static int process_seq_for_forming_states   (regexp_t, automaton_t,

                                             int);

static void finish_forming_alt_state        (alt_state_t,

                                             automaton_t);

static void process_alts_for_forming_states (regexp_t,

                                             automaton_t, int);

static void create_alt_states               (automaton_t);

static void form_ainsn_with_same_reservs    (automaton_t);

static reserv_sets_t form_reservs_matter (automaton_t);

static void make_automaton           (automaton_t);

static void form_arcs_marked_by_insn (state_t);

static int create_composed_state     (state_t, arc_t, vla_ptr_t *);

static void NDFA_to_DFA              (automaton_t);

static void pass_state_graph         (state_t, void (*) (state_t));

static void pass_states              (automaton_t,

                                      void (*) (state_t));

static void initiate_pass_states       (void);

static void add_achieved_state         (state_t);

static int set_out_arc_insns_equiv_num (state_t, int);

static void clear_arc_insns_equiv_num  (state_t);

static void copy_equiv_class           (vla_ptr_t *to,

                                        const vla_ptr_t *from);

static int first_cycle_unit_presence   (state_t, int);

static int state_is_differed           (state_t, state_t, int, int);

static state_t init_equiv_class        (state_t *states, int);

static int partition_equiv_class       (state_t *, int,

                                        vla_ptr_t *, int *);

static void evaluate_equiv_classes     (automaton_t, vla_ptr_t *);

static void merge_states               (automaton_t, vla_ptr_t *);

static void set_new_cycle_flags        (state_t);

static void minimize_DFA               (automaton_t);

static void incr_states_and_arcs_nums  (state_t);

static void count_states_and_arcs      (automaton_t, int *, int *);

static void build_automaton            (automaton_t);

static void set_order_state_num              (state_t);

static void enumerate_states                 (automaton_t);

static ainsn_t insert_ainsn_into_equiv_class       (ainsn_t, ainsn_t);

static void delete_ainsn_from_equiv_class          (ainsn_t);

static void process_insn_equiv_class               (ainsn_t, arc_t *);

static void process_state_for_insn_equiv_partition (state_t);

static void set_insn_equiv_classes                 (automaton_t);

static double estimate_one_automaton_bound     (void);

static int compare_max_occ_cycle_nums          (const void *,

                                                const void *);

static void units_to_automata_heuristic_distr  (void);

static ainsn_t create_ainsns                   (void);

static void units_to_automata_distr            (void);

static void create_automata                    (void);

static void form_regexp                      (regexp_t);

static const char *regexp_representation     (regexp_t);

static void finish_regexp_representation     (void);

static void output_range_type            (FILE *, long int, long int);

static int longest_path_length           (state_t);

static void process_state_longest_path_length (state_t);

static void output_dfa_max_issue_rate    (void);

static void output_vect                  (vect_el_t *, int);

static void output_chip_member_name      (FILE *, automaton_t);

static void output_temp_chip_member_name (FILE *, automaton_t);

static void output_translate_vect_name   (FILE *, automaton_t);

static void output_trans_full_vect_name  (FILE *, automaton_t);

static void output_trans_comb_vect_name  (FILE *, automaton_t);

static void output_trans_check_vect_name (FILE *, automaton_t);

static void output_trans_base_vect_name  (FILE *, automaton_t);

static void output_state_alts_full_vect_name    (FILE *, automaton_t);

static void output_state_alts_comb_vect_name    (FILE *, automaton_t);

static void output_state_alts_check_vect_name   (FILE *, automaton_t);

static void output_state_alts_base_vect_name    (FILE *, automaton_t);

static void output_min_issue_delay_vect_name    (FILE *, automaton_t);

static void output_dead_lock_vect_name   (FILE *, automaton_t);

static void output_reserved_units_table_name    (FILE *, automaton_t);

static void output_state_member_type     (FILE *, automaton_t);

static void output_chip_definitions      (void);

static void output_translate_vect        (automaton_t);

static int comb_vect_p                   (state_ainsn_table_t);

static state_ainsn_table_t create_state_ainsn_table (automaton_t);

static void output_state_ainsn_table

   (state_ainsn_table_t, char *, void (*) (FILE *, automaton_t),

    void (*) (FILE *, automaton_t), void (*) (FILE *, automaton_t),

    void (*) (FILE *, automaton_t));

static void add_vect                     (state_ainsn_table_t,

                                          int, vect_el_t *, int);

static int out_state_arcs_num            (state_t);

static int compare_transition_els_num    (const void *, const void *);

static void add_vect_el          (vla_hwint_t *,

                                          ainsn_t, int);

static void add_states_vect_el           (state_t);

static void output_trans_table           (automaton_t);

static void output_state_alts_table      (automaton_t);

static int min_issue_delay_pass_states   (state_t, ainsn_t);

static int min_issue_delay               (state_t, ainsn_t);

static void initiate_min_issue_delay_pass_states (void);

static void output_min_issue_delay_table (automaton_t);

static void output_dead_lock_vect        (automaton_t);

static void output_reserved_units_table  (automaton_t);

static void output_tables                (void);

static void output_max_insn_queue_index_def (void);

static void output_insn_code_cases   (void (*) (automata_list_el_t));

static void output_automata_list_min_issue_delay_code (automata_list_el_t);

static void output_internal_min_issue_delay_func (void);

static void output_automata_list_transition_code (automata_list_el_t);

static void output_internal_trans_func   (void);

static void output_internal_insn_code_evaluation (const char *,

                                                  const char *, int);

static void output_dfa_insn_code_func           (void);

static void output_trans_func                   (void);

static void output_automata_list_state_alts_code (automata_list_el_t);

static void output_internal_state_alts_func     (void);

static void output_state_alts_func              (void);

static void output_min_issue_delay_func         (void);

static void output_internal_dead_lock_func      (void);

static void output_dead_lock_func               (void);

static void output_internal_reset_func          (void);

static void output_size_func                    (void);

static void output_reset_func                   (void);

static void output_min_insn_conflict_delay_func (void);

static void output_internal_insn_latency_func   (void);

static void output_insn_latency_func            (void);

static void output_print_reservation_func       (void);

static int units_cmp                            (const void *,

                                                 const void *);

static void output_get_cpu_unit_code_func       (void);

static void output_cpu_unit_reservation_p       (void);

static void output_dfa_clean_insn_cache_func    (void);

static void output_dfa_start_func               (void);

static void output_dfa_finish_func              (void);

static void output_regexp                  (regexp_t );

static void output_unit_set_el_list        (unit_set_el_t);

static void output_pattern_set_el_list     (pattern_set_el_t);

static void output_description             (void);

static void output_automaton_name          (FILE *, automaton_t);

static void output_automaton_units         (automaton_t);

static void add_state_reservs              (state_t);

static void output_state_arcs              (state_t);

static int state_reservs_cmp               (const void *,

                                            const void *);

static void remove_state_duplicate_reservs (void);

static void output_state                   (state_t);

static void output_automaton_descriptions  (void);

static void output_statistics              (FILE *);

static void output_time_statistics         (FILE *);

static void generate                       (void);

static void make_insn_alts_attr                (void);

static void make_internal_dfa_insn_code_attr   (void);

static void make_default_insn_latency_attr     (void);

static void make_bypass_attr                   (void);

static const char *file_name_suffix            (const char *);

static const char *base_file_name              (const char *);

static void check_automata_insn_issues         (void);

static void add_automaton_state                (state_t);

static void form_important_insn_automata_lists (void);

/* Undefined position.  */

static pos_t no_pos = 0;

/* All IR is stored in the following obstack.  */

static struct obstack irp;

/* This page contains code for work with variable length array (vla)

   of pointers.  We could be use only varray.  But we add new lay

   because we add elements very frequently and this could stress OS

   allocator when varray is used only.  */

/* Start work with vla.  */

#define VLA_PTR_CREATE(vla, allocated_length, name)      \

  do                                                                     \

    {    \

      vla_ptr_t *const _vla_ptr = &(vla);                                \

         \

      VARRAY_GENERIC_PTR_INIT (_vla_ptr->varray, allocated_length, name);\

      _vla_ptr->length = 0;                                              \

    }                                                                    \

  while (0)

/* Finish work with the vla.  */

#define VLA_PTR_DELETE(vla) VARRAY_FREE ((vla).varray)

/* Return start address of the vla.  */

#define VLA_PTR_BEGIN(vla) ((void *) &VARRAY_GENERIC_PTR ((vla).varray, 0))

/* Address of the last element of the vla.  Do not use side effects in

   the macro argument.  */

#define VLA_PTR_LAST(vla) (&VARRAY_GENERIC_PTR ((vla).varray,         \

                                                (vla).length - 1))

/* Nullify the vla.  */

#define VLA_PTR_NULLIFY(vla)  ((vla).length = 0)

/* Shorten the vla on given number bytes.  */

#define VLA_PTR_SHORTEN(vla, n)  ((vla).length -= (n))

/* Expand the vla on N elements.  The values of new elements are

   undefined.  */

#define VLA_PTR_EXPAND(vla, n)                                        \

  do {                                                                \

    vla_ptr_t *const _expand_vla_ptr = &(vla);                        \

    const size_t _new_length = (n) + _expand_vla_ptr->length;         \

                                                                      \

    if (VARRAY_SIZE (_expand_vla_ptr->varray) < _new_length)          \

      VARRAY_GROW (_expand_vla_ptr->varray,                           \

                   (_new_length - _expand_vla_ptr->length < 128       \

                    ? _expand_vla_ptr->length + 128 : _new_length));  \

    _expand_vla_ptr->length = _new_length;                            \

  } while (0)

/* Add element to the end of the vla.  */

#define VLA_PTR_ADD(vla, ptr)                                           \

  do {                                                                  \

    vla_ptr_t *const _vla_ptr = &(vla);                                 \

                                                                        \

    VLA_PTR_EXPAND (*_vla_ptr, 1);                                      \

    VARRAY_GENERIC_PTR (_vla_ptr->varray, _vla_ptr->length - 1) = (ptr);\

  } while (0)

/* Length of the vla in elements.  */

#define VLA_PTR_LENGTH(vla) ((vla).length)

/* N-th element of the vla.  */

#define VLA_PTR(vla, n) VARRAY_GENERIC_PTR ((vla).varray, n)

/* The following macros are analogous to the previous ones but for

   VLAs of HOST WIDE INTs.  */

#define VLA_HWINT_CREATE(vla, allocated_length, name)                 \

  do {                                                                \

    vla_hwint_t *const _vla_ptr = &(vla);                             \

                                                                      \

    VARRAY_WIDE_INT_INIT (_vla_ptr->varray, allocated_length, name);  \

    _vla_ptr->length = 0;                                             \

  } while (0)

#define VLA_HWINT_DELETE(vla) VARRAY_FREE ((vla).varray)

#define VLA_HWINT_BEGIN(vla) (&VARRAY_WIDE_INT ((vla).varray, 0))

#define VLA_HWINT_NULLIFY(vla)  ((vla).length = 0)

#define VLA_HWINT_EXPAND(vla, n)                                      \

  do {                                                                \

    vla_hwint_t *const _expand_vla_ptr = &(vla);                      \

    const size_t _new_length = (n) + _expand_vla_ptr->length;         \

                                                                      \

    if (VARRAY_SIZE (_expand_vla_ptr->varray) < _new_length)          \

      VARRAY_GROW (_expand_vla_ptr->varray,                           \

                   (_new_length - _expand_vla_ptr->length < 128       \

                    ? _expand_vla_ptr->length + 128 : _new_length));  \

    _expand_vla_ptr->length = _new_length;                            \

  } while (0)

#define VLA_HWINT_ADD(vla, ptr)                                       \

  do {                                                                \

    vla_hwint_t *const _vla_ptr = &(vla);                             \

                                                                      \

    VLA_HWINT_EXPAND (*_vla_ptr, 1);                                  \

    VARRAY_WIDE_INT (_vla_ptr->varray, _vla_ptr->length - 1) = (ptr); \