genautomata.c (DECL_UNIT, [...]): New macros with checking and without it.

2002-06-19  Vladimir Makarov  <vmakarov@redhat.com>

	* genautomata.c (DECL_UNIT, DECL_BYPASS, DECL_AUTOMATON,
	DECL_EXCL, DECL_PRESENCE, DECL_ABSENCE, DECL_RESERV,
	DECL_INSN_RESERV, REGEXP_UNIT, REGEXP_RESERV, REGEXP_SEQUENCE,
	REGEXP_REPEAT, REGEXP_ALLOF, REGEXP_ONEOF): New macros with
	checking and without it.
	(decl_name, decl_mode_check_failed, regexp_name,
	regexp_mode_check_failed): New functions.
	(gen_cpu_unit, gen_query_cpu_unit, gen_bypass, gen_excl_set,
	gen_presence_set, gen_absence_set, gen_automaton,
	gen_regexp_repeat, gen_regexp_allof, gen_regexp_oneof,
	gen_regexp_sequence, gen_reserv, gen_insn_reserv,
	automaton_decl_hash, automaton_decl_eq_p): Use the macros.
	(find_automaton_decl): Ditto.  Set up mode of work_automaton_decl.
	(insn_decl_hash, insn_decl_hash, insn_decl_eq_p): Use the macros.
	(find_insn_decl): Ditto.  Set up mode of work_insn_decl.
	(decl_hash, decl_eq_p): Use the macros.
	(find_decl): Ditto.  Set up mode of work_decl.
	(process_excls, process_presence_absence, process_decls,
	check_automaton_usage, process_regexp, process_regexp_decls,
	check_usage, loop_in_regexp, check_loops_in_regexps,
	process_regexp_cycles, add_advance_cycle_insn_decl,
	initiate_states, initiate_excl_sets,
	initiate_presence_absence_sets, copy_insn_regexp, transform_1,
	transform_2): Use the macros.
	(transform_3): Ditto.  Check mode before making transformations of
	ALLOF.
	(regexp_transform_func, transform_insn_regexps,
	process_unit_to_form_the_same_automaton_unit_lists,
	form_the_same_automaton_unit_lists_from_regexp,
	form_the_same_automaton_unit_lists,
	process_seq_for_forming_states, process_alts_for_forming_states,
	create_alt_states, form_ainsn_with_same_reservs, make_automaton,
	form_arcs_marked_by_insn, NDFA_to_DFA, set_new_cycle_flags,
	estimate_one_automaton_bound, compare_max_occ_cycle_nums,
	units_to_automata_heuristic_distr, create_ainsns,
	units_to_automata_distr, create_automata): Use the macros.
	(form_regexp): Ditto.  Fix typo in access to fields of ALLOF.
	(longest_path_length, min_issue_delay_pass_states,
	output_dead_lock_vect, output_tables, output_insn_code_cases,
	output_internal_insn_latency_func, output_print_reservation_func,
	output_description, output_automaton_units, generate): Use the
	macros.
	(make_insn_alts_attr): Ditto.  Check case when there are not
	alternatives in the reservation.
	(make_internal_dfa_insn_code_attr, make_default_insn_latency_attr,
	make_bypass_attr, form_important_insn_automata_lists,
	expand_automata): Use the macros.

From-SVN: r54802

gcc/ChangeLog

+2002-06-19  Vladimir Makarov  <vmakarov@redhat.com>
+
+	* genautomata.c (DECL_UNIT, DECL_BYPASS, DECL_AUTOMATON,
+	DECL_EXCL, DECL_PRESENCE, DECL_ABSENCE, DECL_RESERV,
+	DECL_INSN_RESERV, REGEXP_UNIT, REGEXP_RESERV, REGEXP_SEQUENCE,
+	REGEXP_REPEAT, REGEXP_ALLOF, REGEXP_ONEOF): New macros with
+	checking and without it.
+	(decl_name, decl_mode_check_failed, regexp_name,
+	regexp_mode_check_failed): New functions.
+	(gen_cpu_unit, gen_query_cpu_unit, gen_bypass, gen_excl_set,
+	gen_presence_set, gen_absence_set, gen_automaton,
+	gen_regexp_repeat, gen_regexp_allof, gen_regexp_oneof,
+	gen_regexp_sequence, gen_reserv, gen_insn_reserv,
+	automaton_decl_hash, automaton_decl_eq_p): Use the macros.
+	(find_automaton_decl): Ditto.  Set up mode of work_automaton_decl.
+	(insn_decl_hash, insn_decl_hash, insn_decl_eq_p): Use the macros.
+	(find_insn_decl): Ditto.  Set up mode of work_insn_decl.
+	(decl_hash, decl_eq_p): Use the macros.
+	(find_decl): Ditto.  Set up mode of work_decl.
+	(process_excls, process_presence_absence, process_decls,
+	check_automaton_usage, process_regexp, process_regexp_decls,
+	check_usage, loop_in_regexp, check_loops_in_regexps,
+	process_regexp_cycles, add_advance_cycle_insn_decl,
+	initiate_states, initiate_excl_sets,
+	initiate_presence_absence_sets, copy_insn_regexp, transform_1,
+	transform_2): Use the macros.
+	(transform_3): Ditto.  Check mode before making transformations of
+	ALLOF.
+	(regexp_transform_func, transform_insn_regexps,
+	process_unit_to_form_the_same_automaton_unit_lists,
+	form_the_same_automaton_unit_lists_from_regexp,
+	form_the_same_automaton_unit_lists,
+	process_seq_for_forming_states, process_alts_for_forming_states,
+	create_alt_states, form_ainsn_with_same_reservs, make_automaton,
+	form_arcs_marked_by_insn, NDFA_to_DFA, set_new_cycle_flags,
+	estimate_one_automaton_bound, compare_max_occ_cycle_nums,
+	units_to_automata_heuristic_distr, create_ainsns,
+	units_to_automata_distr, create_automata): Use the macros.
+	(form_regexp): Ditto.  Fix typo in access to fields of ALLOF.
+	(longest_path_length, min_issue_delay_pass_states,
+	output_dead_lock_vect, output_tables, output_insn_code_cases,
+	output_internal_insn_latency_func, output_print_reservation_func,
+	output_description, output_automaton_units, generate): Use the
+	macros.
+	(make_insn_alts_attr): Ditto.  Check case when there are not
+	alternatives in the reservation.
+	(make_internal_dfa_insn_code_attr, make_default_insn_latency_attr,
+	make_bypass_attr, form_important_insn_automata_lists,
+	expand_automata): Use the macros.
+	
 2002-06-20  Tim Josling  <tej@melbpc.org.au>
 
 	* Makefile.in: Clean up code to check for misspecified languages

gcc/genautomata.c

@@ -1238,6 +1238,228 @@ struct state_ainsn_table
   int min_base_vect_el_value, max_base_vect_el_value;
 };
 
+/* Macros to access members of unions.  Use only them for access to
+   union members of declarations and regexps.  */
+
+#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+
+#define DECL_UNIT(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_unit)					\
+       decl_mode_check_failed (_decl->mode, "dm_unit",			\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.unit; }))
+
+#define DECL_BYPASS(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_bypass)					\
+       decl_mode_check_failed (_decl->mode, "dm_bypass",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.bypass; }))
+
+#define DECL_AUTOMATON(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_automaton)					\
+       decl_mode_check_failed (_decl->mode, "dm_automaton",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.automaton; }))
+
+#define DECL_EXCL(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_excl)					\
+       decl_mode_check_failed (_decl->mode, "dm_excl",			\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.excl; }))
+
+#define DECL_PRESENCE(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_presence)					\
+       decl_mode_check_failed (_decl->mode, "dm_presence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.presence; }))
+
+#define DECL_ABSENCE(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_absence)					\
+       decl_mode_check_failed (_decl->mode, "dm_absence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.absence; }))
+
+#define DECL_RESERV(d) __extension__					\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_reserv)					\
+       decl_mode_check_failed (_decl->mode, "dm_reserv",			\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.reserv; }))
+
+#define DECL_INSN_RESERV(d) __extension__				\
+(({ struct decl *_decl = (d);						\
+     if (_decl->mode != dm_insn_reserv)					\
+       decl_mode_check_failed (_decl->mode, "dm_insn_reserv",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.insn_reserv; }))
+
+static const char *decl_name PARAMS ((enum decl_mode));
+static void decl_mode_check_failed PARAMS ((enum decl_mode, const char *,
+					    const char *, int, const char *));
+
+/* Return string representation of declaration mode MODE.  */
+static const char *
+decl_name (mode)
+     enum decl_mode mode;
+{
+  static char str [100];
+
+  if (mode == dm_unit)
+    return "dm_unit";
+  else if (mode == dm_bypass)
+    return "dm_bypass";
+  else if (mode == dm_automaton)
+    return "dm_automaton";
+  else if (mode == dm_excl)
+    return "dm_excl";
+  else if (mode == dm_presence)
+    return "dm_presence";
+  else if (mode == dm_absence)
+    return "dm_absence";
+  else if (mode == dm_reserv)
+    return "dm_reserv";
+  else if (mode == dm_insn_reserv)
+    return "dm_insn_reserv";
+  else
+    sprintf (str, "unknown (%d)", (int) mode);
+  return str;
+}
+
+/* The function prints message about unexpected declaration and finish
+   the program.  */
+static void
+decl_mode_check_failed (mode, expected_mode_str, file, line, func)
+     enum decl_mode mode;
+     const char *expected_mode_str;
+     const char *file;
+     int line;
+     const char *func;
+{
+  fprintf
+    (stderr,
+     "\n%s: %d: error in %s: DECL check: expected decl %s, have %s\n",
+     file, line, func, expected_mode_str, decl_name (mode));
+  exit (1);
+}
+
+
+#define REGEXP_UNIT(r) __extension__					\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_unit)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_unit",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.unit; }))
+
+#define REGEXP_RESERV(r) __extension__					\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_reserv)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_reserv",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.reserv; }))
+
+#define REGEXP_SEQUENCE(r) __extension__				\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_sequence)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_sequence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.sequence; }))
+
+#define REGEXP_REPEAT(r) __extension__					\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_repeat)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_repeat",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.repeat; }))
+
+#define REGEXP_ALLOF(r) __extension__					\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_allof)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_allof",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.allof; }))
+
+#define REGEXP_ONEOF(r) __extension__					\
+(({ struct regexp *_regexp = (r);					\
+     if (_regexp->mode != rm_oneof)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_oneof",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.oneof; }))
+
+static const char *regexp_name PARAMS ((enum regexp_mode));
+static void regexp_mode_check_failed PARAMS ((enum regexp_mode, const char *,
+					      const char *, int,
+					      const char *));
+
+
+/* Return string representation of regexp mode MODE.  */
+static const char *
+regexp_name (mode)
+     enum regexp_mode mode;
+{
+  static char str [100];
+
+  if (mode == rm_unit)
+    return "rm_unit";
+  else if (mode == rm_reserv)
+    return "rm_reserv";
+  else if (mode == rm_nothing)
+    return "rm_nothing";
+  else if (mode == rm_sequence)
+    return "rm_sequence";
+  else if (mode == rm_repeat)
+    return "rm_repeat";
+  else if (mode == rm_allof)
+    return "rm_allof";
+  else if (mode == rm_oneof)
+    return "rm_oneof";
+  else
+    sprintf (str, "unknown (%d)", (int) mode);
+  return str;
+}
+
+/* The function prints message about unexpected regexp and finish the
+   program.  */
+static void
+regexp_mode_check_failed (mode, expected_mode_str, file, line, func)
+     enum regexp_mode mode;
+     const char *expected_mode_str;
+     const char *file;
+     int line;
+     const char *func;
+{
+  fprintf
+    (stderr,
+     "\n%s: %d: error in %s: REGEXP check: expected decl %s, have %s\n",
+     file, line, func, expected_mode_str, regexp_name (mode));
+  exit (1);
+}
+
+#else /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
+
+#define DECL_UNIT(d) (&(d)->decl.unit)
+#define DECL_BYPASS(d) (&(d)->decl.bypass)
+#define DECL_AUTOMATON(d) (&(d)->decl.automaton)
+#define DECL_EXCL(d) (&(d)->decl.excl)
+#define DECL_PRESENCE(d) (&(d)->decl.presence)
+#define DECL_ABSENCE(d) (&(d)->decl.absence)
+#define DECL_RESERV(d) (&(d)->decl.reserv)
+#define DECL_INSN_RESERV(d) (&(d)->decl.insn_reserv)
+
+#define REGEXP_UNIT(r) (&(r)->regexp.unit)
+#define REGEXP_RESERV(r) (&(r)->regexp.reserv)
+#define REGEXP_SEQUENCE(r) (&(r)->regexp.sequence)
+#define REGEXP_REPEAT(r) (&(r)->regexp.repeat)
+#define REGEXP_ALLOF(r) (&(r)->regexp.allof)
+#define REGEXP_ONEOF(r) (&(r)->regexp.oneof)
+
+#endif /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
+
 /* Create IR structure (node).  */
 static void *
 create_node (size)
@@ -1412,9 +1634,9 @@ gen_cpu_unit (def)
       decl = create_node (sizeof (struct decl));
       decl->mode = dm_unit;
       decl->pos = 0;
-      decl->decl.unit.name = check_name (str_cpu_units [i], decl->pos);
-      decl->decl.unit.automaton_name = (char *) XSTR (def, 1);
-      decl->decl.unit.query_p = 0;
+      DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
+      DECL_UNIT (decl)->automaton_name = (char *) XSTR (def, 1);
+      DECL_UNIT (decl)->query_p = 0;
       VLA_PTR_ADD (decls, decl);
       num_dfa_decls++;
     }
@@ -1441,9 +1663,9 @@ gen_query_cpu_unit (def)
       decl = create_node (sizeof (struct decl));
       decl->mode = dm_unit;
       decl->pos = 0;
-      decl->decl.unit.name = check_name (str_cpu_units [i], decl->pos);
-      decl->decl.unit.automaton_name = (char *) XSTR (def, 1);
-      decl->decl.unit.query_p = 1;
+      DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
+      DECL_UNIT (decl)->automaton_name = (char *) XSTR (def, 1);
+      DECL_UNIT (decl)->query_p = 1;
       VLA_PTR_ADD (decls, decl);
       num_dfa_decls++;
     }
@@ -1477,10 +1699,10 @@ gen_bypass (def)
 	decl = create_node (sizeof (struct decl));
 	decl->mode = dm_bypass;
 	decl->pos = 0;
-	decl->decl.bypass.latency = XINT (def, 0);
-	decl->decl.bypass.out_insn_name = out_insns [i];
-	decl->decl.bypass.in_insn_name = in_insns [j];
-	decl->decl.bypass.bypass_guard_name = (char *) XSTR (def, 3);
+	DECL_BYPASS (decl)->latency = XINT (def, 0);
+	DECL_BYPASS (decl)->out_insn_name = out_insns [i];
+	DECL_BYPASS (decl)->in_insn_name = in_insns [j];
+	DECL_BYPASS (decl)->bypass_guard_name = (char *) XSTR (def, 3);
 	VLA_PTR_ADD (decls, decl);
 	num_dfa_decls++;
       }
@@ -1514,13 +1736,14 @@ gen_excl_set (def)
   decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
   decl->mode = dm_excl;
   decl->pos = 0;
-  decl->decl.excl.names_num = length;
-  decl->decl.excl.first_list_length = first_vect_length;
+  DECL_EXCL (decl)->names_num = length;
+  DECL_EXCL (decl)->first_list_length = first_vect_length;
   for (i = 0; i < length; i++)
     if (i < first_vect_length)
-      decl->decl.excl.names [i] = first_str_cpu_units [i];
+      DECL_EXCL (decl)->names [i] = first_str_cpu_units [i];
     else
-      decl->decl.excl.names [i] = second_str_cpu_units [i - first_vect_length];
+      DECL_EXCL (decl)->names [i]
+	= second_str_cpu_units [i - first_vect_length];
   VLA_PTR_ADD (decls, decl);
   num_dfa_decls++;
 }
@@ -1553,13 +1776,13 @@ gen_presence_set (def)
   decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
   decl->mode = dm_presence;
   decl->pos = 0;
-  decl->decl.presence.names_num = length;
-  decl->decl.presence.first_list_length = first_vect_length;
+  DECL_PRESENCE (decl)->names_num = length;
+  DECL_PRESENCE (decl)->first_list_length = first_vect_length;
   for (i = 0; i < length; i++)
     if (i < first_vect_length)
-      decl->decl.presence.names [i] = first_str_cpu_units [i];
+      DECL_PRESENCE (decl)->names [i] = first_str_cpu_units [i];
     else
-      decl->decl.presence.names [i]
+      DECL_PRESENCE (decl)->names [i]
 	= second_str_cpu_units [i - first_vect_length];
   VLA_PTR_ADD (decls, decl);
   num_dfa_decls++;
@@ -1593,13 +1816,13 @@ gen_absence_set (def)
   decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
   decl->mode = dm_absence;
   decl->pos = 0;
-  decl->decl.absence.names_num = length;
-  decl->decl.absence.first_list_length = first_vect_length;
+  DECL_ABSENCE (decl)->names_num = length;
+  DECL_ABSENCE (decl)->first_list_length = first_vect_length;
   for (i = 0; i < length; i++)
     if (i < first_vect_length)
-      decl->decl.absence.names [i] = first_str_cpu_units [i];
+      DECL_ABSENCE (decl)->names [i] = first_str_cpu_units [i];
     else
-      decl->decl.absence.names [i]
+      DECL_ABSENCE (decl)->names [i]
 	= second_str_cpu_units [i - first_vect_length];
   VLA_PTR_ADD (decls, decl);
   num_dfa_decls++;
@@ -1627,7 +1850,7 @@ gen_automaton (def)
       decl = create_node (sizeof (struct decl));
       decl->mode = dm_automaton;
       decl->pos = 0;
-      decl->decl.automaton.name = check_name (str_automata [i], decl->pos);
+      DECL_AUTOMATON (decl)->name = check_name (str_automata [i], decl->pos);
       VLA_PTR_ADD (decls, decl);
       num_dfa_decls++;
     }
@@ -1687,7 +1910,7 @@ gen_regexp_el (str)
     {
       regexp = create_node (sizeof (struct decl));
       regexp->mode = rm_unit;
-      regexp->regexp.unit.name = str;
+      REGEXP_UNIT (regexp)->name = str;
     }
   return regexp;
 }
@@ -1713,9 +1936,9 @@ gen_regexp_repeat (str)
 	{
 	  repeat = create_node (sizeof (struct regexp));
 	  repeat->mode = rm_repeat;
-	  repeat->regexp.repeat.regexp = regexp;
-	  repeat->regexp.repeat.repeat_num = atoi (repeat_vect [i]);
-          if (repeat->regexp.repeat.repeat_num <= 1)
+	  REGEXP_REPEAT (repeat)->regexp = regexp;
+	  REGEXP_REPEAT (repeat)->repeat_num = atoi (repeat_vect [i]);
+          if (REGEXP_REPEAT (repeat)->repeat_num <= 1)
             fatal ("repetition `%s' <= 1 in reservation `%s'",
                    str, reserv_str);
           regexp = repeat;
@@ -1744,9 +1967,9 @@ gen_regexp_allof (str)
       allof = create_node (sizeof (struct regexp)
 			   + sizeof (regexp_t) * (els_num - 1));
       allof->mode = rm_allof;
-      allof->regexp.allof.regexps_num = els_num;
+      REGEXP_ALLOF (allof)->regexps_num = els_num;
       for (i = 0; i < els_num; i++)
-	allof->regexp.allof.regexps [i] = gen_regexp_repeat (allof_vect [i]);
+	REGEXP_ALLOF (allof)->regexps [i] = gen_regexp_repeat (allof_vect [i]);
       return allof;
     }
   else
@@ -1771,9 +1994,9 @@ gen_regexp_oneof (str)
       oneof = create_node (sizeof (struct regexp)
 			   + sizeof (regexp_t) * (els_num - 1));
       oneof->mode = rm_oneof;
-      oneof->regexp.oneof.regexps_num = els_num;
+      REGEXP_ONEOF (oneof)->regexps_num = els_num;
       for (i = 0; i < els_num; i++)
-	oneof->regexp.oneof.regexps [i] = gen_regexp_allof (oneof_vect [i]);
+	REGEXP_ONEOF (oneof)->regexps [i] = gen_regexp_allof (oneof_vect [i]);
       return oneof;
     }
   else
@@ -1796,9 +2019,9 @@ gen_regexp_sequence (str)
       sequence = create_node (sizeof (struct regexp)
 			      + sizeof (regexp_t) * (els_num - 1));
       sequence->mode = rm_sequence;
-      sequence->regexp.sequence.regexps_num = els_num;
+      REGEXP_SEQUENCE (sequence)->regexps_num = els_num;
       for (i = 0; i < els_num; i++)
-	sequence->regexp.sequence.regexps [i]
+	REGEXP_SEQUENCE (sequence)->regexps [i]
           = gen_regexp_oneof (sequence_vect [i]);
       return sequence;
     }
@@ -1829,8 +2052,8 @@ gen_reserv (def)
   decl = create_node (sizeof (struct decl));
   decl->mode = dm_reserv;
   decl->pos = 0;
-  decl->decl.reserv.name = check_name ((char *) XSTR (def, 0), decl->pos);
-  decl->decl.reserv.regexp = gen_regexp ((char *) XSTR (def, 1));
+  DECL_RESERV (decl)->name = check_name ((char *) XSTR (def, 0), decl->pos);
+  DECL_RESERV (decl)->regexp = gen_regexp ((char *) XSTR (def, 1));
   VLA_PTR_ADD (decls, decl);
   num_dfa_decls++;
 }
@@ -1849,10 +2072,11 @@ gen_insn_reserv (def)
   decl = create_node (sizeof (struct decl));
   decl->mode = dm_insn_reserv;
   decl->pos = 0;
-  decl->decl.insn_reserv.name = check_name ((char *) XSTR (def, 0), decl->pos);
-  decl->decl.insn_reserv.default_latency = XINT (def, 1);
-  decl->decl.insn_reserv.condexp = XEXP (def, 2);
-  decl->decl.insn_reserv.regexp = gen_regexp ((char *) XSTR (def, 3));
+  DECL_INSN_RESERV (decl)->name
+    = check_name ((char *) XSTR (def, 0), decl->pos);
+  DECL_INSN_RESERV (decl)->default_latency = XINT (def, 1);
+  DECL_INSN_RESERV (decl)->condexp = XEXP (def, 2);
+  DECL_INSN_RESERV (decl)->regexp = gen_regexp ((char *) XSTR (def, 3));
   VLA_PTR_ADD (decls, decl);
   num_dfa_decls++;
 }
@@ -1887,9 +2111,9 @@ automaton_decl_hash (automaton_decl)
 {
   const decl_t decl = (decl_t) automaton_decl;
 
-  if (decl->mode == dm_automaton && decl->decl.automaton.name == NULL)
+  if (decl->mode == dm_automaton && DECL_AUTOMATON (decl)->name == NULL)
     abort ();
-  return string_hash (decl->decl.automaton.name);
+  return string_hash (DECL_AUTOMATON (decl)->name);
 }
 
 /* The function tests automaton declarations on equality of their
@@ -1904,10 +2128,11 @@ automaton_decl_eq_p (automaton_decl_1, automaton_decl_2)
   const decl_t decl1 = (decl_t) automaton_decl_1;
   const decl_t decl2 = (decl_t) automaton_decl_2;
 
-  if (decl1->mode != dm_automaton || decl1->decl.automaton.name == NULL
-      || decl2->mode != dm_automaton || decl2->decl.automaton.name == NULL)
+  if (decl1->mode != dm_automaton || DECL_AUTOMATON (decl1)->name == NULL
+      || decl2->mode != dm_automaton || DECL_AUTOMATON (decl2)->name == NULL)
     abort ();
-  return strcmp (decl1->decl.automaton.name, decl2->decl.automaton.name) == 0;
+  return strcmp (DECL_AUTOMATON (decl1)->name,
+		 DECL_AUTOMATON (decl2)->name) == 0;
 }
 
 /* The automaton declaration table itself is represented by the
@@ -1946,7 +2171,8 @@ find_automaton_decl (name)
 {
   void *entry;
 
-  work_automaton_decl.decl.automaton.name = name;
+  work_automaton_decl.mode = dm_automaton;
+  DECL_AUTOMATON (&work_automaton_decl)->name = name;
   entry = htab_find (automaton_decl_table, &work_automaton_decl);
   return (decl_t) entry;
 }
@@ -1989,9 +2215,9 @@ insn_decl_hash (insn_decl)
 {
   const decl_t decl = (decl_t) insn_decl;
 
-  if (decl->mode != dm_insn_reserv || decl->decl.insn_reserv.name == NULL)
+  if (decl->mode != dm_insn_reserv || DECL_INSN_RESERV (decl)->name == NULL)
     abort ();
-  return string_hash (decl->decl.insn_reserv.name);
+  return string_hash (DECL_INSN_RESERV (decl)->name);
 }
 
 /* The function tests insn declarations on equality of their keys.
@@ -2005,11 +2231,12 @@ insn_decl_eq_p (insn_decl_1, insn_decl_2)
   const decl_t decl1 = (decl_t) insn_decl_1;
   const decl_t decl2 = (decl_t) insn_decl_2;
 
-  if (decl1->mode != dm_insn_reserv || decl1->decl.insn_reserv.name == NULL
-      || decl2->mode != dm_insn_reserv || decl2->decl.insn_reserv.name == NULL)
+  if (decl1->mode != dm_insn_reserv || DECL_INSN_RESERV (decl1)->name == NULL
+      || decl2->mode != dm_insn_reserv
+      || DECL_INSN_RESERV (decl2)->name == NULL)
     abort ();
-  return strcmp (decl1->decl.insn_reserv.name,
-                 decl2->decl.insn_reserv.name) == 0;
+  return strcmp (DECL_INSN_RESERV (decl1)->name,
+                 DECL_INSN_RESERV (decl2)->name) == 0;
 }
 
 /* The insn declaration table itself is represented by the following
@@ -2048,7 +2275,8 @@ find_insn_decl (name)
 {
   void *entry;
 
-  work_insn_decl.decl.insn_reserv.name = name;
+  work_insn_decl.mode = dm_insn_reserv;
+  DECL_INSN_RESERV (&work_insn_decl)->name = name;
   entry = htab_find (insn_decl_table, &work_insn_decl);
   return (decl_t) entry;
 }
@@ -2090,11 +2318,11 @@ decl_hash (decl)
 {
   const decl_t d = (const decl_t) decl;
 
-  if ((d->mode != dm_unit || d->decl.unit.name == NULL)
-      && (d->mode != dm_reserv || d->decl.reserv.name == NULL))
+  if ((d->mode != dm_unit || DECL_UNIT (d)->name == NULL)
+      && (d->mode != dm_reserv || DECL_RESERV (d)->name == NULL))
     abort ();
   return string_hash (d->mode == dm_unit
-		      ? d->decl.unit.name : d->decl.reserv.name);
+		      ? DECL_UNIT (d)->name : DECL_RESERV (d)->name);
 }
 
 /* The function tests declarations on equality of their keys.  The
@@ -2108,15 +2336,15 @@ decl_eq_p (decl_1, decl_2)
   const decl_t d1 = (const decl_t) decl_1;
   const decl_t d2 = (const decl_t) decl_2;
 
-  if (((d1->mode != dm_unit || d1->decl.unit.name == NULL)
-       && (d1->mode != dm_reserv || d1->decl.reserv.name == NULL))
-      || ((d2->mode != dm_unit || d2->decl.unit.name == NULL)
-	  && (d2->mode != dm_reserv || d2->decl.reserv.name == NULL)))
+  if (((d1->mode != dm_unit || DECL_UNIT (d1)->name == NULL)
+       && (d1->mode != dm_reserv || DECL_RESERV (d1)->name == NULL))
+      || ((d2->mode != dm_unit || DECL_UNIT (d2)->name == NULL)
+	  && (d2->mode != dm_reserv || DECL_RESERV (d2)->name == NULL)))
     abort ();
   return strcmp ((d1->mode == dm_unit
-                  ? d1->decl.unit.name : d1->decl.reserv.name),
+                  ? DECL_UNIT (d1)->name : DECL_RESERV (d1)->name),
                  (d2->mode == dm_unit
-                  ? d2->decl.unit.name : d2->decl.reserv.name)) == 0;
+                  ? DECL_UNIT (d2)->name : DECL_RESERV (d2)->name)) == 0;
 }
 
 /* The declaration table itself is represented by the following
@@ -2154,7 +2382,8 @@ find_decl (name)
 {
   void *entry;
 
-  work_decl.decl.unit.name = name;
+  work_decl.mode = dm_unit;
+  DECL_UNIT (&work_decl)->name = name;
   entry = htab_find (decl_table, &work_decl);
   return (decl_t) entry;
 }
@@ -2209,7 +2438,7 @@ process_excls (names, num, excl_pos)
       else
 	{
 	  new_el = create_node (sizeof (struct unit_set_el));
-	  new_el->unit_decl = &decl_in_table->decl.unit;
+	  new_el->unit_decl = DECL_UNIT (decl_in_table);
 	  new_el->next_unit_set_el = NULL;
 	  if (last_el == NULL)
 	    el_list = last_el = new_el;
@@ -2305,7 +2534,7 @@ process_presence_absence (names, num, req_pos, presence_p)
       else
 	{
 	  new_el = create_node (sizeof (struct unit_set_el));
-	  new_el->unit_decl = &decl_in_table->decl.unit;
+	  new_el->unit_decl = DECL_UNIT (decl_in_table);
 	  new_el->next_unit_set_el = NULL;
 	  if (last_el == NULL)
 	    el_list = last_el = new_el;
@@ -2471,10 +2700,10 @@ process_decls ()
 	    {
 	      if (!w_flag)
 		error ("repeated declaration of automaton `%s'",
-		       decl->decl.automaton.name);
+		       DECL_AUTOMATON (decl)->name);
 	      else
 		warning ("repeated declaration of automaton `%s'",
-			 decl->decl.automaton.name);
+			 DECL_AUTOMATON (decl)->name);
 	    }
 	}
     }
@@ -2486,64 +2715,64 @@ process_decls ()
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv)
 	{
-          decl->decl.insn_reserv.condexp
-	    = check_attr_test (decl->decl.insn_reserv.condexp, 0, 0);
-	  if (decl->decl.insn_reserv.default_latency < 0)
+          DECL_INSN_RESERV (decl)->condexp
+	    = check_attr_test (DECL_INSN_RESERV (decl)->condexp, 0, 0);
+	  if (DECL_INSN_RESERV (decl)->default_latency < 0)
 	    error ("define_insn_reservation `%s' has negative latency time",
-		   decl->decl.insn_reserv.name);
-	  decl->decl.insn_reserv.insn_num = description->insns_num;
+		   DECL_INSN_RESERV (decl)->name);
+	  DECL_INSN_RESERV (decl)->insn_num = description->insns_num;
 	  description->insns_num++;
 	  decl_in_table = insert_insn_decl (decl);
 	  if (decl_in_table != decl)
 	    error ("`%s' is already used as insn reservation name",
-		   decl->decl.insn_reserv.name);
+		   DECL_INSN_RESERV (decl)->name);
 	}
       else if (decl->mode == dm_bypass)
 	{
-	  if (decl->decl.bypass.latency < 0)
+	  if (DECL_BYPASS (decl)->latency < 0)
 	    error ("define_bypass `%s - %s' has negative latency time",
-		   decl->decl.bypass.out_insn_name,
-		   decl->decl.bypass.in_insn_name);
+		   DECL_BYPASS (decl)->out_insn_name,
+		   DECL_BYPASS (decl)->in_insn_name);
 	}
       else if (decl->mode == dm_unit || decl->mode == dm_reserv)
 	{
 	  if (decl->mode == dm_unit)
 	    {
-	      decl->decl.unit.automaton_decl = NULL;
-	      if (decl->decl.unit.automaton_name != NULL)
+	      DECL_UNIT (decl)->automaton_decl = NULL;
+	      if (DECL_UNIT (decl)->automaton_name != NULL)
 		{
 		  automaton_decl
-                    = find_automaton_decl (decl->decl.unit.automaton_name);
+                    = find_automaton_decl (DECL_UNIT (decl)->automaton_name);
 		  if (automaton_decl == NULL)
 		    error ("automaton `%s' is not declared",
-			   decl->decl.unit.automaton_name);
+			   DECL_UNIT (decl)->automaton_name);
 		  else
 		    {
-		      automaton_decl->decl.automaton.automaton_is_used = 1;
-		      decl->decl.unit.automaton_decl
-			= &automaton_decl->decl.automaton;
+		      DECL_AUTOMATON (automaton_decl)->automaton_is_used = 1;
+		      DECL_UNIT (decl)->automaton_decl
+			= DECL_AUTOMATON (automaton_decl);
 		    }
 		}
 	      else if (automaton_presence)
 		error ("define_unit `%s' without automaton when one defined",
-		       decl->decl.unit.name);
-	      decl->decl.unit.unit_num = description->units_num;
+		       DECL_UNIT (decl)->name);
+	      DECL_UNIT (decl)->unit_num = description->units_num;
 	      description->units_num++;
-	      if (strcmp (decl->decl.unit.name, NOTHING_NAME) == 0)
+	      if (strcmp (DECL_UNIT (decl)->name, NOTHING_NAME) == 0)
 		{
 		  error ("`%s' is declared as cpu unit", NOTHING_NAME);
 		  continue;
 		}
-	      decl_in_table = find_decl (decl->decl.unit.name);
+	      decl_in_table = find_decl (DECL_UNIT (decl)->name);
 	    }
 	  else
 	    {
-	      if (strcmp (decl->decl.reserv.name, NOTHING_NAME) == 0)
+	      if (strcmp (DECL_RESERV (decl)->name, NOTHING_NAME) == 0)
 		{
 		  error ("`%s' is declared as cpu reservation", NOTHING_NAME);
 		  continue;
 		}
-	      decl_in_table = find_decl (decl->decl.reserv.name);
+	      decl_in_table = find_decl (DECL_RESERV (decl)->name);
 	    }
 	  if (decl_in_table == NULL)
 	    decl_in_table = insert_decl (decl);
@@ -2551,10 +2780,10 @@ process_decls ()
 	    {
 	      if (decl->mode == dm_unit)
 		error ("repeated declaration of unit `%s'",
-		       decl->decl.unit.name);
+		       DECL_UNIT (decl)->name);
 	      else
 		error ("repeated declaration of reservation `%s'",
-		       decl->decl.reserv.name);
+		       DECL_RESERV (decl)->name);
 	    }
 	}
     }
@@ -2565,49 +2794,49 @@ process_decls ()
       decl = description->decls [i];
       if (decl->mode == dm_bypass)
 	{
-	  out_insn_reserv = find_insn_decl (decl->decl.bypass.out_insn_name);
-	  in_insn_reserv = find_insn_decl (decl->decl.bypass.in_insn_name);
+	  out_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->out_insn_name);
+	  in_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->in_insn_name);
 	  if (out_insn_reserv == NULL)
 	    error ("there is no insn reservation `%s'",
-		   decl->decl.bypass.out_insn_name);
+		   DECL_BYPASS (decl)->out_insn_name);
 	  else if (in_insn_reserv == NULL)
 	    error ("there is no insn reservation `%s'",
-		   decl->decl.bypass.in_insn_name);
+		   DECL_BYPASS (decl)->in_insn_name);
 	  else
 	    {
-	      decl->decl.bypass.out_insn_reserv
-		= &out_insn_reserv->decl.insn_reserv;
-	      decl->decl.bypass.in_insn_reserv
-		= &in_insn_reserv->decl.insn_reserv;
+	      DECL_BYPASS (decl)->out_insn_reserv
+		= DECL_INSN_RESERV (out_insn_reserv);
+	      DECL_BYPASS (decl)->in_insn_reserv
+		= DECL_INSN_RESERV (in_insn_reserv);
 	      bypass
-		= find_bypass (out_insn_reserv->decl.insn_reserv.bypass_list,
-			       decl->decl.bypass.in_insn_reserv);
+		= find_bypass (DECL_INSN_RESERV (out_insn_reserv)->bypass_list,
+			       DECL_BYPASS (decl)->in_insn_reserv);
 	      if (bypass != NULL)
 		{
-		  if (decl->decl.bypass.latency == bypass->latency)
+		  if (DECL_BYPASS (decl)->latency == bypass->latency)
 		    {
 		      if (!w_flag)
 			error
 			  ("the same bypass `%s - %s' is already defined",
-			   decl->decl.bypass.out_insn_name,
-			   decl->decl.bypass.in_insn_name);
+			   DECL_BYPASS (decl)->out_insn_name,
+			   DECL_BYPASS (decl)->in_insn_name);
 		      else
 			warning
 			  ("the same bypass `%s - %s' is already defined",
-			   decl->decl.bypass.out_insn_name,
-			   decl->decl.bypass.in_insn_name);
+			   DECL_BYPASS (decl)->out_insn_name,
+			   DECL_BYPASS (decl)->in_insn_name);
 		    }
 		  else
 		    error ("bypass `%s - %s' is already defined",
-			   decl->decl.bypass.out_insn_name,
-			   decl->decl.bypass.in_insn_name);
+			   DECL_BYPASS (decl)->out_insn_name,
+			   DECL_BYPASS (decl)->in_insn_name);
 		}
 	      else
 		{
-		  decl->decl.bypass.next
-		    = out_insn_reserv->decl.insn_reserv.bypass_list;
-		  out_insn_reserv->decl.insn_reserv.bypass_list
-		    = &decl->decl.bypass;
+		  DECL_BYPASS (decl)->next
+		    = DECL_INSN_RESERV (out_insn_reserv)->bypass_list;
+		  DECL_INSN_RESERV (out_insn_reserv)->bypass_list
+		    = DECL_BYPASS (decl);
 		}
 	    }
 	}
@@ -2623,13 +2852,13 @@ process_decls ()
 	  unit_set_el_t unit_set_el_list_2;
 	  
 	  unit_set_el_list
-            = process_excls (decl->decl.excl.names,
-			     decl->decl.excl.first_list_length, decl->pos);
+            = process_excls (DECL_EXCL (decl)->names,
+			     DECL_EXCL (decl)->first_list_length, decl->pos);
 	  unit_set_el_list_2
-	    = process_excls (&decl->decl.excl.names
-			     [decl->decl.excl.first_list_length],
-                             decl->decl.excl.names_num
-                             - decl->decl.excl.first_list_length,
+	    = process_excls (&DECL_EXCL (decl)->names
+			     [DECL_EXCL (decl)->first_list_length],
+                             DECL_EXCL (decl)->names_num
+                             - DECL_EXCL (decl)->first_list_length,
                              decl->pos);
 	  add_excls (unit_set_el_list, unit_set_el_list_2, decl->pos);
 	  add_excls (unit_set_el_list_2, unit_set_el_list, decl->pos);
@@ -2647,14 +2876,14 @@ process_decls ()
 	  
 	  unit_set_el_list
             = process_presence_absence
-	      (decl->decl.presence.names,
-	       decl->decl.presence.first_list_length, decl->pos, 1);
+	      (DECL_PRESENCE (decl)->names,
+	       DECL_PRESENCE (decl)->first_list_length, decl->pos, 1);
 	  unit_set_el_list_2
 	    = process_presence_absence
-	      (&decl->decl.presence.names
-	       [decl->decl.presence.first_list_length],
-	       decl->decl.presence.names_num
-	       - decl->decl.presence.first_list_length,
+	      (&DECL_PRESENCE (decl)->names
+	       [DECL_PRESENCE (decl)->first_list_length],
+	       DECL_PRESENCE (decl)->names_num
+	       - DECL_PRESENCE (decl)->first_list_length,
 	       decl->pos, 1);
 	  add_presence_absence (unit_set_el_list, unit_set_el_list_2,
 				decl->pos, 1);
@@ -2672,14 +2901,14 @@ process_decls ()
 	  
 	  unit_set_el_list
             = process_presence_absence
-	      (decl->decl.presence.names,
-	       decl->decl.presence.first_list_length, decl->pos, 0);
+	      (DECL_ABSENCE (decl)->names,
+	       DECL_ABSENCE (decl)->first_list_length, decl->pos, 0);
 	  unit_set_el_list_2
 	    = process_presence_absence
-	      (&decl->decl.presence.names
-	       [decl->decl.presence.first_list_length],
-	       decl->decl.presence.names_num
-	       - decl->decl.presence.first_list_length,
+	      (&DECL_ABSENCE (decl)->names
+	       [DECL_ABSENCE (decl)->first_list_length],
+	       DECL_ABSENCE (decl)->names_num
+	       - DECL_ABSENCE (decl)->first_list_length,
 	       decl->pos, 0);
 	  add_presence_absence (unit_set_el_list, unit_set_el_list_2,
 				decl->pos, 0);
@@ -2700,12 +2929,13 @@ check_automaton_usage ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_automaton
-	  && !decl->decl.automaton.automaton_is_used)
+	  && !DECL_AUTOMATON (decl)->automaton_is_used)
 	{
 	  if (!w_flag)
-	    error ("automaton `%s' is not used", decl->decl.automaton.name);
+	    error ("automaton `%s' is not used", DECL_AUTOMATON (decl)->name);
 	  else
-	    warning ("automaton `%s' is not used", decl->decl.automaton.name);
+	    warning ("automaton `%s' is not used",
+		     DECL_AUTOMATON (decl)->name);
 	}
     }
 }
@@ -2725,43 +2955,44 @@ process_regexp (regexp)
     
   if (regexp->mode == rm_unit)
     {
-      decl_in_table = find_decl (regexp->regexp.unit.name);
+      decl_in_table = find_decl (REGEXP_UNIT (regexp)->name);
       if (decl_in_table == NULL)
         error ("undeclared unit or reservation `%s'",
-	       regexp->regexp.unit.name);
+	       REGEXP_UNIT (regexp)->name);
       else if (decl_in_table->mode == dm_unit)
 	{
-	  decl_in_table->decl.unit.unit_is_used = 1;
-	  regexp->regexp.unit.unit_decl = &decl_in_table->decl.unit;
+	  DECL_UNIT (decl_in_table)->unit_is_used = 1;
+	  REGEXP_UNIT (regexp)->unit_decl = DECL_UNIT (decl_in_table);
 	}
       else if (decl_in_table->mode == dm_reserv)
 	{
-	  decl_in_table->decl.reserv.reserv_is_used = 1;
+	  DECL_RESERV (decl_in_table)->reserv_is_used = 1;
 	  new_regexp = create_node (sizeof (struct regexp));
 	  new_regexp->mode = rm_reserv;
 	  new_regexp->pos = regexp->pos;
-	  new_regexp->regexp.reserv.name = regexp->regexp.unit.name;
-	  new_regexp->regexp.reserv.reserv_decl = &decl_in_table->decl.reserv;
+	  REGEXP_RESERV (new_regexp)->name = REGEXP_UNIT (regexp)->name;
+	  REGEXP_RESERV (new_regexp)->reserv_decl
+	    = DECL_RESERV (decl_in_table);
 	  regexp = new_regexp;
 	}
       else
 	abort ();
     }
   else if (regexp->mode == rm_sequence)
-    for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-      regexp->regexp.sequence.regexps [i]
-	= process_regexp (regexp->regexp.sequence.regexps [i]);
+    for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+     REGEXP_SEQUENCE (regexp)->regexps [i]
+	= process_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
   else if (regexp->mode == rm_allof)
-    for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-      regexp->regexp.allof.regexps [i]
-        = process_regexp (regexp->regexp.allof.regexps [i]);
+    for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+      REGEXP_ALLOF (regexp)->regexps [i]
+        = process_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
   else if (regexp->mode == rm_oneof)
-    for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
-      regexp->regexp.oneof.regexps [i]
-	= process_regexp (regexp->regexp.oneof.regexps [i]);
+    for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+      REGEXP_ONEOF (regexp)->regexps [i]
+	= process_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
   else if (regexp->mode == rm_repeat)
-    regexp->regexp.repeat.regexp
-      = process_regexp (regexp->regexp.repeat.regexp);
+    REGEXP_REPEAT (regexp)->regexp
+      = process_regexp (REGEXP_REPEAT (regexp)->regexp);
   else if (regexp->mode != rm_nothing)
     abort ();
   return regexp;
@@ -2780,10 +3011,11 @@ process_regexp_decls ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_reserv)
-	decl->decl.reserv.regexp = process_regexp (decl->decl.reserv.regexp);
+	DECL_RESERV (decl)->regexp
+	  = process_regexp (DECL_RESERV (decl)->regexp);
       else if (decl->mode == dm_insn_reserv)
-	decl->decl.insn_reserv.regexp
-	  = process_regexp (decl->decl.insn_reserv.regexp);
+	DECL_INSN_RESERV (decl)->regexp
+	  = process_regexp (DECL_INSN_RESERV (decl)->regexp);
     }
 }
 
@@ -2800,19 +3032,19 @@ check_usage ()
   for (i = 0; i < description->decls_num; i++)
     {
       decl = description->decls [i];
-      if (decl->mode == dm_unit && !decl->decl.unit.unit_is_used)
+      if (decl->mode == dm_unit && !DECL_UNIT (decl)->unit_is_used)
 	{
 	  if (!w_flag)
-	    error ("unit `%s' is not used", decl->decl.unit.name);
+	    error ("unit `%s' is not used", DECL_UNIT (decl)->name);
 	  else
-	    warning ("unit `%s' is not used", decl->decl.unit.name);
+	    warning ("unit `%s' is not used", DECL_UNIT (decl)->name);
 	}
-      else if (decl->mode == dm_reserv && !decl->decl.reserv.reserv_is_used)
+      else if (decl->mode == dm_reserv && !DECL_RESERV (decl)->reserv_is_used)
 	{
 	  if (!w_flag)
-	    error ("reservation `%s' is not used", decl->decl.reserv.name);
+	    error ("reservation `%s' is not used", DECL_RESERV (decl)->name);
 	  else
-	    warning ("reservation `%s' is not used", decl->decl.reserv.name);
+	    warning ("reservation `%s' is not used", DECL_RESERV (decl)->name);
 	}
     }
 }
@@ -2838,43 +3070,43 @@ loop_in_regexp (regexp, start_decl)
   else if (regexp->mode == rm_reserv)
     {
       if (start_decl->mode == dm_reserv
-          && regexp->regexp.reserv.reserv_decl == &start_decl->decl.reserv)
+          && REGEXP_RESERV (regexp)->reserv_decl == DECL_RESERV (start_decl))
         return 1;
-      else if (regexp->regexp.reserv.reserv_decl->loop_pass_num
+      else if (REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
 	       == curr_loop_pass_num)
         /* declaration has been processed.  */
         return 0;
       else
         {
-	  regexp->regexp.reserv.reserv_decl->loop_pass_num
+	  REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
             = curr_loop_pass_num;
-          return loop_in_regexp (regexp->regexp.reserv.reserv_decl->regexp,
+          return loop_in_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp,
                                  start_decl);
         }
     }
   else if (regexp->mode == rm_sequence)
     {
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-	if (loop_in_regexp (regexp->regexp.sequence.regexps [i], start_decl))
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_SEQUENCE (regexp)->regexps [i], start_decl))
 	  return 1;
       return 0;
     }
   else if (regexp->mode == rm_allof)
     {
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-	if (loop_in_regexp (regexp->regexp.allof.regexps [i], start_decl))
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_ALLOF (regexp)->regexps [i], start_decl))
 	  return 1;
       return 0;
     }
   else if (regexp->mode == rm_oneof)
     {
-      for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
-	if (loop_in_regexp (regexp->regexp.oneof.regexps [i], start_decl))
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_ONEOF (regexp)->regexps [i], start_decl))
 	  return 1;
       return 0;
     }
   else if (regexp->mode == rm_repeat)
-    return loop_in_regexp (regexp->regexp.repeat.regexp, start_decl);
+    return loop_in_regexp (REGEXP_REPEAT (regexp)->regexp, start_decl);
   else
     {
       if (regexp->mode != rm_nothing)
@@ -2895,7 +3127,7 @@ check_loops_in_regexps ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_reserv)
-	decl->decl.reserv.loop_pass_num = 0;
+	DECL_RESERV (decl)->loop_pass_num = 0;
     }
   for (i = 0; i < description->decls_num; i++)
     {
@@ -2904,13 +3136,13 @@ check_loops_in_regexps ()
       
       if (decl->mode == dm_reserv)
 	  {
-	    decl->decl.reserv.loop_pass_num = curr_loop_pass_num;
-	    if (loop_in_regexp (decl->decl.reserv.regexp, decl))
+	    DECL_RESERV (decl)->loop_pass_num = curr_loop_pass_num;
+	    if (loop_in_regexp (DECL_RESERV (decl)->regexp, decl))
 	      {
-		if (decl->decl.reserv.regexp == NULL)
+		if (DECL_RESERV (decl)->regexp == NULL)
 		  abort ();
 		error ("cycle in definition of reservation `%s'",
-		       decl->decl.reserv.name);
+		       DECL_RESERV (decl)->name);
 	      }
 	  }
     }
@@ -2928,25 +3160,25 @@ process_regexp_cycles (regexp, start_cycle)
 
   if (regexp->mode == rm_unit)
     {
-      if (regexp->regexp.unit.unit_decl->max_occ_cycle_num < start_cycle)
-	regexp->regexp.unit.unit_decl->max_occ_cycle_num = start_cycle;
+      if (REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num < start_cycle)
+	REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num = start_cycle;
       return start_cycle;
     }
   else if (regexp->mode == rm_reserv)
-    return process_regexp_cycles (regexp->regexp.reserv.reserv_decl->regexp,
+    return process_regexp_cycles (REGEXP_RESERV (regexp)->reserv_decl->regexp,
                                   start_cycle);
   else if (regexp->mode == rm_repeat)
     {
-      for (i = 0; i < regexp->regexp.repeat.repeat_num; i++)
-        start_cycle = process_regexp_cycles (regexp->regexp.repeat.regexp,
+      for (i = 0; i < REGEXP_REPEAT (regexp)->repeat_num; i++)
+        start_cycle = process_regexp_cycles (REGEXP_REPEAT (regexp)->regexp,
 					     start_cycle) + 1;
       return start_cycle;
     }
   else if (regexp->mode == rm_sequence)
     {
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
 	start_cycle
-          = process_regexp_cycles (regexp->regexp.sequence.regexps [i],
+          = process_regexp_cycles (REGEXP_SEQUENCE (regexp)->regexps [i],
 				   start_cycle) + 1;
       return start_cycle;
     }
@@ -2955,9 +3187,9 @@ process_regexp_cycles (regexp, start_cycle)
       int finish_cycle = 0;
       int cycle;
 
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
 	{
-	  cycle = process_regexp_cycles (regexp->regexp.allof.regexps [i],
+	  cycle = process_regexp_cycles (REGEXP_ALLOF (regexp)->regexps [i],
 					 start_cycle);
 	  if (finish_cycle < cycle)
 	    finish_cycle = cycle;
@@ -2969,9 +3201,9 @@ process_regexp_cycles (regexp, start_cycle)
       int finish_cycle = 0;
       int cycle;
 
-      for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
 	{
-	  cycle = process_regexp_cycles (regexp->regexp.oneof.regexps [i],
+	  cycle = process_regexp_cycles (REGEXP_ONEOF (regexp)->regexps [i],
 					 start_cycle);
 	  if (finish_cycle < cycle)
 	    finish_cycle = cycle;
@@ -3002,7 +3234,7 @@ evaluate_max_reserv_cycles ()
       if (decl->mode == dm_insn_reserv)
       {
         max_insn_cycles_num
-          = process_regexp_cycles (decl->decl.insn_reserv.regexp, 0);
+          = process_regexp_cycles (DECL_INSN_RESERV (decl)->regexp, 0);
         if (description->max_insn_reserv_cycles < max_insn_cycles_num)
 	  description->max_insn_reserv_cycles = max_insn_cycles_num;
       }
@@ -3148,9 +3380,10 @@ add_advance_cycle_insn_decl ()
   advance_cycle_insn_decl = create_node (sizeof (struct decl));
   advance_cycle_insn_decl->mode = dm_insn_reserv;
   advance_cycle_insn_decl->pos = no_pos;
-  advance_cycle_insn_decl->decl.insn_reserv.regexp = NULL;
-  advance_cycle_insn_decl->decl.insn_reserv.name = (char *) "$advance_cycle";
-  advance_cycle_insn_decl->decl.insn_reserv.insn_num = description->insns_num;
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->regexp = NULL;
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->name = (char *) "$advance_cycle";
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num
+    = description->insns_num;
   description->decls [description->decls_num] = advance_cycle_insn_decl;
   description->decls_num++;
   description->insns_num++;
@@ -3913,7 +4146,7 @@ initiate_states ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_unit)
-	units_array [decl->decl.unit.unit_num] = &decl->decl.unit;
+	units_array [DECL_UNIT (decl)->unit_num] = DECL_UNIT (decl);
     }
   max_cycles_num = description->max_insn_reserv_cycles;
   els_in_cycle_reserv
@@ -4263,11 +4496,11 @@ initiate_excl_sets ()
 	  unit_excl_set = (reserv_sets_t) obstack_base (&irp);
 	  obstack_finish (&irp);
 	  memset (unit_excl_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
-	  for (el = decl->decl.unit.excl_list;
+	  for (el = DECL_UNIT (decl)->excl_list;
 	       el != NULL;
 	       el = el->next_unit_set_el)
             SET_BIT (unit_excl_set, el->unit_decl->unit_num);
-          unit_excl_set_table [decl->decl.unit.unit_num] = unit_excl_set;
+          unit_excl_set_table [DECL_UNIT (decl)->unit_num] = unit_excl_set;
         }
     }
 }
@@ -4349,21 +4582,21 @@ initiate_presence_absence_sets ()
 	  unit_set = (reserv_sets_t) obstack_base (&irp);
 	  obstack_finish (&irp);
 	  memset (unit_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
-	  for (el = decl->decl.unit.presence_list;
+	  for (el = DECL_UNIT (decl)->presence_list;
 	       el != NULL;
 	       el = el->next_unit_set_el)
             SET_BIT (unit_set, el->unit_decl->unit_num);
-          unit_presence_set_table [decl->decl.unit.unit_num] = unit_set;
+          unit_presence_set_table [DECL_UNIT (decl)->unit_num] = unit_set;
 
 	  obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
 	  unit_set = (reserv_sets_t) obstack_base (&irp);
 	  obstack_finish (&irp);
 	  memset (unit_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
-	  for (el = decl->decl.unit.absence_list;
+	  for (el = DECL_UNIT (decl)->absence_list;
 	       el != NULL;
 	       el = el->next_unit_set_el)
             SET_BIT (unit_set, el->unit_decl->unit_num);
-          unit_absence_set_table [decl->decl.unit.unit_num] = unit_set;
+          unit_absence_set_table [DECL_UNIT (decl)->unit_num] = unit_set;
         }
     }
 }
@@ -4426,41 +4659,41 @@ copy_insn_regexp (regexp)
   int i;
 
   if (regexp->mode == rm_reserv)
-    result = copy_insn_regexp (regexp->regexp.reserv.reserv_decl->regexp);
+    result = copy_insn_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp);
   else if (regexp->mode == rm_unit)
     result = copy_node (regexp, sizeof (struct regexp));
   else if (regexp->mode == rm_repeat)
     {
       result = copy_node (regexp, sizeof (struct regexp));
-      result->regexp.repeat.regexp
-        = copy_insn_regexp (regexp->regexp.repeat.regexp);
+      REGEXP_REPEAT (result)->regexp
+        = copy_insn_regexp (REGEXP_REPEAT (regexp)->regexp);
     }
   else if (regexp->mode == rm_sequence)
     {
       result = copy_node (regexp,
                           sizeof (struct regexp) + sizeof (regexp_t)
-			  * (regexp->regexp.sequence.regexps_num - 1));
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-	result->regexp.sequence.regexps [i]
-	  = copy_insn_regexp (regexp->regexp.sequence.regexps [i]);
+			  * (REGEXP_SEQUENCE (regexp)->regexps_num - 1));
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	REGEXP_SEQUENCE (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
     }
   else if (regexp->mode == rm_allof)
     {
       result = copy_node (regexp,
                           sizeof (struct regexp) + sizeof (regexp_t)
-			  * (regexp->regexp.allof.regexps_num - 1));
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-	result->regexp.allof.regexps [i]
-	  = copy_insn_regexp (regexp->regexp.allof.regexps [i]);
+			  * (REGEXP_ALLOF (regexp)->regexps_num - 1));
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	REGEXP_ALLOF (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
     }
   else if (regexp->mode == rm_oneof)
     {
       result = copy_node (regexp,
                           sizeof (struct regexp) + sizeof (regexp_t)
-			  * (regexp->regexp.oneof.regexps_num - 1));
-      for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
-	result->regexp.oneof.regexps [i]
-	  = copy_insn_regexp (regexp->regexp.oneof.regexps [i]);
+			  * (REGEXP_ONEOF (regexp)->regexps_num - 1));
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	REGEXP_ONEOF (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
     }
   else
     {
@@ -4488,18 +4721,18 @@ transform_1 (regexp)
 
   if (regexp->mode == rm_repeat)
     {
-      repeat_num = regexp->regexp.repeat.repeat_num;
+      repeat_num = REGEXP_REPEAT (regexp)->repeat_num;
       if (repeat_num <= 1)
 	abort ();
-      operand = regexp->regexp.repeat.regexp;
+      operand = REGEXP_REPEAT (regexp)->regexp;
       pos = regexp->mode;
       regexp = create_node (sizeof (struct regexp) + sizeof (regexp_t)
 			    * (repeat_num - 1));
       regexp->mode = rm_sequence;
       regexp->pos = pos;
-      regexp->regexp.sequence.regexps_num = repeat_num;
+      REGEXP_SEQUENCE (regexp)->regexps_num = repeat_num;
       for (i = 0; i < repeat_num; i++)
-	regexp->regexp.sequence.regexps [i] = copy_insn_regexp (operand);
+	REGEXP_SEQUENCE (regexp)->regexps [i] = copy_insn_regexp (operand);
       regexp_transformed_p = 1;
     }
   return regexp;
@@ -4520,40 +4753,40 @@ transform_2 (regexp)
       int sequence_index = 0;
       int i, j;
 
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-	if (regexp->regexp.sequence.regexps [i]->mode == rm_sequence)
+      for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_sequence)
 	  {
 	    sequence_index = i;
-	    sequence = regexp->regexp.sequence.regexps [i];
+	    sequence = REGEXP_SEQUENCE (regexp)->regexps [i];
 	    break;
 	  }
-      if (i < regexp->regexp.sequence.regexps_num)
+      if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
 	{
-	  if (sequence->regexp.sequence.regexps_num <= 1
-	      || regexp->regexp.sequence.regexps_num <= 1)
+	  if ( REGEXP_SEQUENCE (sequence)->regexps_num <= 1
+	      || REGEXP_SEQUENCE (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
                                 + sizeof (regexp_t)
-				* (regexp->regexp.sequence.regexps_num
-                                   + sequence->regexp.sequence.regexps_num
+				* (REGEXP_SEQUENCE (regexp)->regexps_num
+                                   + REGEXP_SEQUENCE (sequence)->regexps_num
                                    - 2));
 	  result->mode = rm_sequence;
 	  result->pos = regexp->pos;
-	  result->regexp.sequence.regexps_num
-            = (regexp->regexp.sequence.regexps_num
-               + sequence->regexp.sequence.regexps_num - 1);
-	  for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
+	  REGEXP_SEQUENCE (result)->regexps_num
+            = (REGEXP_SEQUENCE (regexp)->regexps_num
+               + REGEXP_SEQUENCE (sequence)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
             if (i < sequence_index)
-              result->regexp.sequence.regexps [i]
-                = copy_insn_regexp (regexp->regexp.sequence.regexps [i]);
+              REGEXP_SEQUENCE (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
             else if (i > sequence_index)
-              result->regexp.sequence.regexps
-                [i + sequence->regexp.sequence.regexps_num - 1]
-                = copy_insn_regexp (regexp->regexp.sequence.regexps [i]);
+              REGEXP_SEQUENCE (result)->regexps
+                [i + REGEXP_SEQUENCE (sequence)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
             else
-              for (j = 0; j < sequence->regexp.sequence.regexps_num; j++)
-                result->regexp.sequence.regexps [i + j]
-                  = copy_insn_regexp (sequence->regexp.sequence.regexps [j]);
+              for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
+                REGEXP_SEQUENCE (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_SEQUENCE (sequence)->regexps [j]);
 	  regexp_transformed_p = 1;
 	  regexp = result;
 	}
@@ -4565,39 +4798,39 @@ transform_2 (regexp)
       int allof_index = 0;
       int i, j;
 
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-	if (regexp->regexp.allof.regexps [i]->mode == rm_allof)
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_allof)
 	  {
 	    allof_index = i;
-	    allof = regexp->regexp.allof.regexps [i];
+	    allof = REGEXP_ALLOF (regexp)->regexps [i];
 	    break;
 	  }
-      if (i < regexp->regexp.allof.regexps_num)
+      if (i < REGEXP_ALLOF (regexp)->regexps_num)
 	{
-	  if (allof->regexp.allof.regexps_num <= 1
-	      || regexp->regexp.allof.regexps_num <= 1)
+	  if (REGEXP_ALLOF (allof)->regexps_num <= 1
+	      || REGEXP_ALLOF (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
                                 + sizeof (regexp_t)
-				* (regexp->regexp.allof.regexps_num
-                                   + allof->regexp.allof.regexps_num - 2));
+				* (REGEXP_ALLOF (regexp)->regexps_num
+                                   + REGEXP_ALLOF (allof)->regexps_num - 2));
 	  result->mode = rm_allof;
 	  result->pos = regexp->pos;
-	  result->regexp.allof.regexps_num
-            = (regexp->regexp.allof.regexps_num
-               + allof->regexp.allof.regexps_num - 1);
-	  for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
+	  REGEXP_ALLOF (result)->regexps_num
+            = (REGEXP_ALLOF (regexp)->regexps_num
+               + REGEXP_ALLOF (allof)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
             if (i < allof_index)
-              result->regexp.allof.regexps [i]
-                = copy_insn_regexp (regexp->regexp.allof.regexps [i]);
+              REGEXP_ALLOF (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
             else if (i > allof_index)
-              result->regexp.allof.regexps
-                [i + allof->regexp.allof.regexps_num - 1]
-                = copy_insn_regexp (regexp->regexp.allof.regexps [i]);
+              REGEXP_ALLOF (result)->regexps
+                [i + REGEXP_ALLOF (allof)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
             else
-              for (j = 0; j < allof->regexp.allof.regexps_num; j++)
-                result->regexp.allof.regexps [i + j]
-                  = copy_insn_regexp (allof->regexp.allof.regexps [j]);
+              for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
+                REGEXP_ALLOF (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_ALLOF (allof)->regexps [j]);
 	  regexp_transformed_p = 1;
 	  regexp = result;
 	}
@@ -4609,39 +4842,39 @@ transform_2 (regexp)
       int oneof_index = 0;
       int i, j;
 
-      for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
-	if (regexp->regexp.oneof.regexps [i]->mode == rm_oneof)
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	if (REGEXP_ONEOF (regexp)->regexps [i]->mode == rm_oneof)
 	  {
 	    oneof_index = i;
-	    oneof = regexp->regexp.oneof.regexps [i];
+	    oneof = REGEXP_ONEOF (regexp)->regexps [i];
 	    break;
 	  }
-      if (i < regexp->regexp.oneof.regexps_num)
+      if (i < REGEXP_ONEOF (regexp)->regexps_num)
 	{
-	  if (oneof->regexp.oneof.regexps_num <= 1
-	      || regexp->regexp.oneof.regexps_num <= 1)
+	  if (REGEXP_ONEOF (oneof)->regexps_num <= 1
+	      || REGEXP_ONEOF (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
 				+ sizeof (regexp_t)
-				* (regexp->regexp.oneof.regexps_num
-                                   + oneof->regexp.oneof.regexps_num - 2));
+				* (REGEXP_ONEOF (regexp)->regexps_num
+                                   + REGEXP_ONEOF (oneof)->regexps_num - 2));
 	  result->mode = rm_oneof;
 	  result->pos = regexp->pos;
-	  result->regexp.oneof.regexps_num
-	    = (regexp->regexp.oneof.regexps_num
-               + oneof->regexp.oneof.regexps_num - 1);
-	  for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
+	  REGEXP_ONEOF (result)->regexps_num
+	    = (REGEXP_ONEOF (regexp)->regexps_num
+               + REGEXP_ONEOF (oneof)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
             if (i < oneof_index)
-              result->regexp.oneof.regexps [i]
-                = copy_insn_regexp (regexp->regexp.oneof.regexps [i]);
+              REGEXP_ONEOF (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
             else if (i > oneof_index)
-              result->regexp.oneof.regexps
-                [i + oneof->regexp.oneof.regexps_num - 1]
-                = copy_insn_regexp (regexp->regexp.oneof.regexps [i]);
+              REGEXP_ONEOF (result)->regexps
+                [i + REGEXP_ONEOF (oneof)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
             else
-              for (j = 0; j < oneof->regexp.oneof.regexps_num; j++)
-                result->regexp.oneof.regexps [i + j]
-                  = copy_insn_regexp (oneof->regexp.oneof.regexps [j]);
+              for (j = 0; j < REGEXP_ONEOF (oneof)->regexps_num; j++)
+                REGEXP_ONEOF (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [j]);
 	  regexp_transformed_p = 1;
 	  regexp = result;
 	}
@@ -4666,42 +4899,43 @@ transform_3 (regexp)
       regexp_t sequence;
       int i, j;
 
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-	if (regexp->regexp.sequence.regexps [i]->mode == rm_oneof)
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_oneof)
 	  {
 	    oneof_index = i;
-	    oneof = regexp->regexp.sequence.regexps [i];
+	    oneof = REGEXP_SEQUENCE (regexp)->regexps [i];
 	    break;
 	  }
-      if (i < regexp->regexp.sequence.regexps_num)
+      if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
 	{
-	  if (oneof->regexp.oneof.regexps_num <= 1
-	      || regexp->regexp.sequence.regexps_num <= 1)
+	  if (REGEXP_ONEOF (oneof)->regexps_num <= 1
+	      || REGEXP_SEQUENCE (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
 				+ sizeof (regexp_t)
-				* (oneof->regexp.oneof.regexps_num - 1));
+				* (REGEXP_ONEOF (oneof)->regexps_num - 1));
 	  result->mode = rm_oneof;
 	  result->pos = regexp->pos;
-	  result->regexp.oneof.regexps_num = oneof->regexp.oneof.regexps_num;
-	  for (i = 0; i < result->regexp.oneof.regexps_num; i++)
+	  REGEXP_ONEOF (result)->regexps_num
+	    = REGEXP_ONEOF (oneof)->regexps_num;
+	  for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
 	    {
 	      sequence
                 = create_node (sizeof (struct regexp)
                                + sizeof (regexp_t)
-                               * (regexp->regexp.sequence.regexps_num - 1));
+                               * (REGEXP_SEQUENCE (regexp)->regexps_num - 1));
 	      sequence->mode = rm_sequence;
 	      sequence->pos = regexp->pos;
-	      sequence->regexp.sequence.regexps_num
-                = regexp->regexp.sequence.regexps_num;
-              result->regexp.oneof.regexps [i] = sequence;
-	      for (j = 0; j < sequence->regexp.sequence.regexps_num; j++)
+	      REGEXP_SEQUENCE (sequence)->regexps_num
+                = REGEXP_SEQUENCE (regexp)->regexps_num;
+              REGEXP_ONEOF (result)->regexps [i] = sequence;
+	      for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
 		if (j != oneof_index)
-		  sequence->regexp.sequence.regexps [j]
-		    = copy_insn_regexp (regexp->regexp.sequence.regexps [j]);
+		  REGEXP_SEQUENCE (sequence)->regexps [j]
+		    = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [j]);
 		else
-		  sequence->regexp.sequence.regexps [j]
-		    = copy_insn_regexp (oneof->regexp.oneof.regexps [i]);
+		  REGEXP_SEQUENCE (sequence)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
 	    }
 	  regexp_transformed_p = 1;
 	  regexp = result;
@@ -4712,91 +4946,95 @@ transform_3 (regexp)
       regexp_t oneof = NULL, seq;
       int oneof_index = 0, max_seq_length, allof_length;
       regexp_t result;
-      regexp_t allof = NULL, allof_op;
+      regexp_t allof = NULL, allof_op = NULL;
       int i, j;
 
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-	if (regexp->regexp.allof.regexps [i]->mode == rm_oneof)
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_oneof)
 	  {
 	    oneof_index = i;
-	    oneof = regexp->regexp.allof.regexps [i];
+	    oneof = REGEXP_ALLOF (regexp)->regexps [i];
 	    break;
 	  }
-      if (i < regexp->regexp.allof.regexps_num)
+      if (i < REGEXP_ALLOF (regexp)->regexps_num)
 	{
-	  if (oneof->regexp.oneof.regexps_num <= 1
-	      || regexp->regexp.allof.regexps_num <= 1)
+	  if (REGEXP_ONEOF (oneof)->regexps_num <= 1
+	      || REGEXP_ALLOF (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
 				+ sizeof (regexp_t)
-				* (oneof->regexp.oneof.regexps_num - 1));
+				* (REGEXP_ONEOF (oneof)->regexps_num - 1));
 	  result->mode = rm_oneof;
 	  result->pos = regexp->pos;
-	  result->regexp.oneof.regexps_num = oneof->regexp.oneof.regexps_num;
-	  for (i = 0; i < result->regexp.oneof.regexps_num; i++)
+	  REGEXP_ONEOF (result)->regexps_num
+	    = REGEXP_ONEOF (oneof)->regexps_num;
+	  for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
 	    {
 	      allof
 		= create_node (sizeof (struct regexp)
                                + sizeof (regexp_t)
-			       * (regexp->regexp.allof.regexps_num - 1));
+			       * (REGEXP_ALLOF (regexp)->regexps_num - 1));
 	      allof->mode = rm_allof;
 	      allof->pos = regexp->pos;
-	      allof->regexp.allof.regexps_num
-                = regexp->regexp.allof.regexps_num;
-              result->regexp.oneof.regexps [i] = allof;
-	      for (j = 0; j < allof->regexp.allof.regexps_num; j++)
+	      REGEXP_ALLOF (allof)->regexps_num
+                = REGEXP_ALLOF (regexp)->regexps_num;
+              REGEXP_ONEOF (result)->regexps [i] = allof;
+	      for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
 		if (j != oneof_index)
-		  allof->regexp.allof.regexps [j]
-		    = copy_insn_regexp (regexp->regexp.allof.regexps [j]);
+		  REGEXP_ALLOF (allof)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [j]);
 		else
-		  allof->regexp.allof.regexps [j]
-		    = copy_insn_regexp (oneof->regexp.oneof.regexps [i]);
+		  REGEXP_ALLOF (allof)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
 	    }
 	  regexp_transformed_p = 1;
 	  regexp = result;
 	}
       max_seq_length = 0;
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-	if (regexp->regexp.allof.regexps [i]->mode == rm_sequence)
-	  {
-	    seq = regexp->regexp.allof.regexps [i];
-	    if (max_seq_length < seq->regexp.sequence.regexps_num)
-	      max_seq_length = seq->regexp.sequence.regexps_num;
-	  }
-	else if (regexp->regexp.allof.regexps [i]->mode != rm_unit)
-	  {
-	    max_seq_length = 0;
-	    break;
-	  }
+      if (regexp->mode == rm_allof)
+	for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	  if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_sequence)
+	    {
+	      seq = REGEXP_ALLOF (regexp)->regexps [i];
+	      if (max_seq_length < REGEXP_SEQUENCE (seq)->regexps_num)
+	      max_seq_length = REGEXP_SEQUENCE (seq)->regexps_num;
+	    }
+	  else if (REGEXP_ALLOF (regexp)->regexps [i]->mode != rm_unit)
+	    {
+	      max_seq_length = 0;
+	      break;
+	    }
       if (max_seq_length != 0)
 	{
-	  if (max_seq_length == 1 || regexp->regexp.allof.regexps_num <= 1)
+	  if (max_seq_length == 1 || REGEXP_ALLOF (regexp)->regexps_num <= 1)
 	    abort ();
 	  result = create_node (sizeof (struct regexp)
 				+ sizeof (regexp_t) * (max_seq_length - 1));
 	  result->mode = rm_sequence;
 	  result->pos = regexp->pos;
-	  result->regexp.sequence.regexps_num = max_seq_length;
+	  REGEXP_SEQUENCE (result)->regexps_num = max_seq_length;
 	  for (i = 0; i < max_seq_length; i++)
 	    {
 	      allof_length = 0;
-	      for (j = 0; j < regexp->regexp.allof.regexps_num; j++)
-		if (regexp->regexp.allof.regexps [j]->mode == rm_sequence
-		    && (i < (regexp->regexp.allof.regexps [j]
-			     ->regexp.sequence.regexps_num)))
+	      for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
+		if (REGEXP_ALLOF (regexp)->regexps [j]->mode == rm_sequence
+		    && (i < (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+					      ->regexps [j])->regexps_num)))
 		  {
-		    allof_op = (regexp->regexp.allof.regexps [j]
-				->regexp.sequence.regexps [i]);
+		    allof_op
+		      = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)->regexps [j])
+			 ->regexps [i]);
 		    allof_length++;
 		  }
 		else if (i == 0
-			 && regexp->regexp.allof.regexps [j]->mode == rm_unit)
+			 && (REGEXP_ALLOF (regexp)->regexps [j]->mode
+			     == rm_unit))
 		  {
-		    allof_op = regexp->regexp.allof.regexps [j];
+		    allof_op = REGEXP_ALLOF (regexp)->regexps [j];
 		    allof_length++;
 		  }
 	      if (allof_length == 1)
-		result->regexp.sequence.regexps [i] = allof_op;
+		REGEXP_SEQUENCE (result)->regexps [i] = allof_op;
 	      else
 		{
 		  allof = create_node (sizeof (struct regexp)
@@ -4804,26 +5042,29 @@ transform_3 (regexp)
 				       * (allof_length - 1));
 		  allof->mode = rm_allof;
 		  allof->pos = regexp->pos;
-		  allof->regexp.allof.regexps_num = allof_length;
-		  result->regexp.sequence.regexps [i] = allof;
+		  REGEXP_ALLOF (allof)->regexps_num = allof_length;
+		  REGEXP_SEQUENCE (result)->regexps [i] = allof;
 		  allof_length = 0;
-		  for (j = 0; j < regexp->regexp.allof.regexps_num; j++)
-		    if (regexp->regexp.allof.regexps [j]->mode == rm_sequence
-			&& (i < (regexp->regexp.allof.regexps [j]
-				 ->regexp.sequence.regexps_num)))
+		  for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
+		    if (REGEXP_ALLOF (regexp)->regexps [j]->mode == rm_sequence
+			&& (i <
+			    (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+					      ->regexps [j])->regexps_num)))
 		      {
-			allof_op = (regexp->regexp.allof.regexps [j]
-				    ->regexp.sequence.regexps [i]);
-			allof->regexp.allof.regexps [allof_length] = allof_op;
-			
+			allof_op = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+						     ->regexps [j])
+				    ->regexps [i]);
+			REGEXP_ALLOF (allof)->regexps [allof_length]
+			  = allof_op;
 			allof_length++;
 		      }
 		    else if (i == 0
-			     && (regexp->regexp.allof.regexps [j]->mode
+			     && (REGEXP_ALLOF (regexp)->regexps [j]->mode
 				 == rm_unit))
 		      {
-			allof_op = regexp->regexp.allof.regexps [j];
-			allof->regexp.allof.regexps [allof_length] = allof_op;
+			allof_op = REGEXP_ALLOF (regexp)->regexps [j];
+			REGEXP_ALLOF (allof)->regexps [allof_length]
+			  = allof_op;
 			allof_length++;
 		      }
 		}
@@ -4845,20 +5086,20 @@ regexp_transform_func (regexp, func)
   int i;
 
   if (regexp->mode == rm_sequence)
-    for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
-      regexp->regexp.sequence.regexps [i]
-	= regexp_transform_func (regexp->regexp.sequence.regexps [i], func);
+    for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+      REGEXP_SEQUENCE (regexp)->regexps [i]
+	= regexp_transform_func (REGEXP_SEQUENCE (regexp)->regexps [i], func);
   else if (regexp->mode == rm_allof)
-    for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
-      regexp->regexp.allof.regexps [i]
-	= regexp_transform_func (regexp->regexp.allof.regexps [i], func);
+    for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+      REGEXP_ALLOF (regexp)->regexps [i]
+	= regexp_transform_func (REGEXP_ALLOF (regexp)->regexps [i], func);
   else if (regexp->mode == rm_oneof)
-    for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
-      regexp->regexp.oneof.regexps [i]
-	= regexp_transform_func (regexp->regexp.oneof.regexps [i], func);
+    for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+      REGEXP_ONEOF (regexp)->regexps [i]
+	= regexp_transform_func (REGEXP_ONEOF (regexp)->regexps [i], func);
   else if (regexp->mode == rm_repeat)
-    regexp->regexp.repeat.regexp
-      = regexp_transform_func (regexp->regexp.repeat.regexp, func);
+    REGEXP_REPEAT (regexp)->regexp
+      = regexp_transform_func (REGEXP_REPEAT (regexp)->regexp, func);
   else if (regexp->mode != rm_nothing && regexp->mode != rm_unit)
     abort ();
   return (*func) (regexp);
@@ -4897,9 +5138,9 @@ transform_insn_regexps ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
-	decl->decl.insn_reserv.transformed_regexp
+	DECL_INSN_RESERV (decl)->transformed_regexp
 	  = transform_regexp (copy_insn_regexp
-			      (decl->decl.insn_reserv.regexp));
+			      (DECL_INSN_RESERV (decl)->regexp));
     }
   fprintf (stderr, "done\n");
   ticker_off (&transform_time);
@@ -4929,42 +5170,43 @@ process_unit_to_form_the_same_automaton_unit_lists (unit, regexp, cycle)
 
   if (regexp == NULL || regexp->mode != rm_oneof)
     abort ();
-  unit_decl = unit->regexp.unit.unit_decl;
-  for (i = regexp->regexp.oneof.regexps_num - 1; i >= 0; i--)
+  unit_decl = REGEXP_UNIT (unit)->unit_decl;
+  for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
     {
-      seq = regexp->regexp.oneof.regexps [i];
+      seq = REGEXP_ONEOF (regexp)->regexps [i];
       if (seq->mode == rm_sequence)
 	{
-	  if (cycle >= seq->regexp.sequence.regexps_num)
+	  if (cycle >= REGEXP_SEQUENCE (seq)->regexps_num)
 	    break;
-	  allof = seq->regexp.sequence.regexps [cycle];
+	  allof = REGEXP_SEQUENCE (seq)->regexps [cycle];
 	  if (allof->mode == rm_allof)
 	    {
-	      for (k = 0; k < allof->regexp.allof.regexps_num; k++)
-		if (allof->regexp.allof.regexps [k]->mode == rm_unit
-		    && (allof->regexp.allof.regexps [k]->regexp.unit.unit_decl
-			== unit_decl))
+	      for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++)
+		if (REGEXP_ALLOF (allof)->regexps [k]->mode == rm_unit
+		    && (REGEXP_UNIT (REGEXP_ALLOF (allof)->regexps [k])
+			->unit_decl == unit_decl))
 		  break;
-	      if (k >= allof->regexp.allof.regexps_num)
+	      if (k >= REGEXP_ALLOF (allof)->regexps_num)
 		break;
 	    }
 	  else if (allof->mode == rm_unit
-		   && allof->regexp.unit.unit_decl != unit_decl)
+		   && REGEXP_UNIT (allof)->unit_decl != unit_decl)
 	    break;
 	}
       else if (cycle != 0)
 	break;
       else if (seq->mode == rm_allof)
 	{
-	  for (k = 0; k < seq->regexp.allof.regexps_num; k++)
-	    if (seq->regexp.allof.regexps [k]->mode == rm_unit
-		&& (seq->regexp.allof.regexps [k]->regexp.unit.unit_decl
+	  for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
+	    if (REGEXP_ALLOF (seq)->regexps [k]->mode == rm_unit
+		&& (REGEXP_UNIT (REGEXP_ALLOF (seq)->regexps [k])->unit_decl
 		    == unit_decl))
 	      break;
-	  if (k >= seq->regexp.allof.regexps_num)
+	  if (k >= REGEXP_ALLOF (seq)->regexps_num)
 	    break;
 	}
-      else if (seq->mode == rm_unit && seq->regexp.unit.unit_decl != unit_decl)
+      else if (seq->mode == rm_unit
+	       && REGEXP_UNIT (seq)->unit_decl != unit_decl)
 	break;
     }
   if (i >= 0)
@@ -5002,17 +5244,17 @@ form_the_same_automaton_unit_lists_from_regexp (regexp)
     return;
   for (i = 0; i < description->max_insn_reserv_cycles; i++)
     the_same_automaton_lists [i] = NULL;
-  for (i = regexp->regexp.oneof.regexps_num - 1; i >= 0; i--)
+  for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
     {
-      seq = regexp->regexp.oneof.regexps [i];
+      seq = REGEXP_ONEOF (regexp)->regexps [i];
       if (seq->mode == rm_sequence)
-	for (j = 0; j < seq->regexp.sequence.regexps_num; j++)
+	for (j = 0; j < REGEXP_SEQUENCE (seq)->regexps_num; j++)
 	  {
-	    allof = seq->regexp.sequence.regexps [j];
+	    allof = REGEXP_SEQUENCE (seq)->regexps [j];
 	    if (allof->mode == rm_allof)
-	      for (k = 0; k < allof->regexp.allof.regexps_num; k++)
+	      for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++)
 		{
-		  unit = allof->regexp.allof.regexps [k];
+		  unit = REGEXP_ALLOF (allof)->regexps [k];
 		  if (unit->mode == rm_unit)
 		    process_unit_to_form_the_same_automaton_unit_lists
 		      (unit, regexp, j);
@@ -5026,9 +5268,9 @@ form_the_same_automaton_unit_lists_from_regexp (regexp)
 	      abort ();
 	  }
       else if (seq->mode == rm_allof)
-	for (k = 0; k < seq->regexp.allof.regexps_num; k++)
+	for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
 	  {
-	    unit = seq->regexp.allof.regexps [k];
+	    unit = REGEXP_ALLOF (seq)->regexps [k];
 	    if (unit->mode == rm_unit)
 	      process_unit_to_form_the_same_automaton_unit_lists
 		(unit, regexp, 0);
@@ -5060,8 +5302,8 @@ form_the_same_automaton_unit_lists ()
       decl = description->decls [i];
       if (decl->mode == dm_unit)
 	{
-	  decl->decl.unit.the_same_automaton_message_reported_p = FALSE;
-	  decl->decl.unit.the_same_automaton_unit = &decl->decl.unit;
+	  DECL_UNIT (decl)->the_same_automaton_message_reported_p = FALSE;
+	  DECL_UNIT (decl)->the_same_automaton_unit = DECL_UNIT (decl);
 	}
     }
   for (i = 0; i < description->decls_num; i++)
@@ -5069,7 +5311,7 @@ form_the_same_automaton_unit_lists ()
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv)
 	form_the_same_automaton_unit_lists_from_regexp
-	  (decl->decl.insn_reserv.transformed_regexp);
+	  (DECL_INSN_RESERV (decl)->transformed_regexp);
     }
   free (the_same_automaton_lists);
 }
@@ -5089,7 +5331,7 @@ check_unit_distributions_to_automata ()
       decl = description->decls [i];
       if (decl->mode == dm_unit)
 	{
-	  start_unit_decl = &decl->decl.unit;
+	  start_unit_decl = DECL_UNIT (decl);
 	  if (!start_unit_decl->the_same_automaton_message_reported_p)
 	    for (unit_decl = start_unit_decl->the_same_automaton_unit;
 		 unit_decl != start_unit_decl;
@@ -5131,18 +5373,18 @@ process_seq_for_forming_states (regexp, automaton, curr_cycle)
     return curr_cycle;
   else if (regexp->mode == rm_unit)
     {
-      if (regexp->regexp.unit.unit_decl->corresponding_automaton_num
+      if (REGEXP_UNIT (regexp)->unit_decl->corresponding_automaton_num
           == automaton->automaton_order_num)
         set_state_reserv (state_being_formed, curr_cycle,
-                          regexp->regexp.unit.unit_decl->unit_num);
+                          REGEXP_UNIT (regexp)->unit_decl->unit_num);
       return curr_cycle;
     }
   else if (regexp->mode == rm_sequence)
     {
-      for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
+      for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
 	curr_cycle
 	  = process_seq_for_forming_states
-	    (regexp->regexp.sequence.regexps [i], automaton, curr_cycle) + 1;
+	    (REGEXP_SEQUENCE (regexp)->regexps [i], automaton, curr_cycle) + 1;
       return curr_cycle;
     }
   else if (regexp->mode == rm_allof)
@@ -5150,11 +5392,11 @@ process_seq_for_forming_states (regexp, automaton, curr_cycle)
       int finish_cycle = 0;
       int cycle;
 
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
 	{
-	  cycle
-            = process_seq_for_forming_states (regexp->regexp.allof.regexps [i],
-                                              automaton, curr_cycle);
+	  cycle = process_seq_for_forming_states (REGEXP_ALLOF (regexp)
+						  ->regexps [i],
+						  automaton, curr_cycle);
 	  if (finish_cycle < cycle)
 	    finish_cycle = cycle;
 	}
@@ -5222,8 +5464,8 @@ process_alts_for_forming_states (regexp, automaton, inside_oneof_p)
       /* We processes it in reverse order to get list with the same
 	 order as in the description.  See also the previous
 	 commentary.  */
-      for (i = regexp->regexp.oneof.regexps_num - 1; i >= 0; i--)
-	process_alts_for_forming_states (regexp->regexp.oneof.regexps [i],
+      for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
+	process_alts_for_forming_states (REGEXP_ONEOF (regexp)->regexps [i],
 					 automaton, 1);
     }
 }
@@ -5240,7 +5482,7 @@ create_alt_states (automaton)
        curr_ainsn = curr_ainsn->next_ainsn)
     {
       reserv_decl = curr_ainsn->insn_reserv_decl;
-      if (reserv_decl != &advance_cycle_insn_decl->decl.insn_reserv)
+      if (reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
         {
           curr_ainsn->alt_states = NULL;
           process_alts_for_forming_states (reserv_decl->transformed_regexp,
@@ -5273,7 +5515,7 @@ form_ainsn_with_same_reservs (automaton)
        curr_ainsn != NULL;
        curr_ainsn = curr_ainsn->next_ainsn)
     if (curr_ainsn->insn_reserv_decl
-	== &advance_cycle_insn_decl->decl.insn_reserv)
+	== DECL_INSN_RESERV (advance_cycle_insn_decl))
       {
         curr_ainsn->next_same_reservs_insn = NULL;
         curr_ainsn->first_insn_with_same_reservs = 1;
@@ -5337,7 +5579,7 @@ make_automaton (automaton)
         if (ainsn->first_insn_with_same_reservs)
           {
             insn_reserv_decl = ainsn->insn_reserv_decl;
-            if (insn_reserv_decl != &advance_cycle_insn_decl->decl.insn_reserv)
+            if (insn_reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
               {
 		/* We process alt_states in the same order as they are
                    present in the description.  */
@@ -5404,7 +5646,7 @@ form_arcs_marked_by_insn (state)
     {
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv)
-	decl->decl.insn_reserv.arcs_marked_by_insn = NULL;
+	DECL_INSN_RESERV (decl)->arcs_marked_by_insn = NULL;
     }
   for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
     {
@@ -5536,7 +5778,7 @@ NDFA_to_DFA (automaton)
 	  decl = description->decls [i];
 	  if (decl->mode == dm_insn_reserv)
 	    create_composed_state
-              (state, decl->decl.insn_reserv.arcs_marked_by_insn,
+              (state, DECL_INSN_RESERV (decl)->arcs_marked_by_insn,
 	       &state_stack);
 	}
     }
@@ -5917,7 +6159,7 @@ set_new_cycle_flags (state)
 
   for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
     if (arc->insn->insn_reserv_decl
-	== &advance_cycle_insn_decl->decl.insn_reserv)
+	== DECL_INSN_RESERV (advance_cycle_insn_decl))
       arc->to_state->new_cycle_p = 1;
 }
 
@@ -6207,7 +6449,7 @@ estimate_one_automaton_bound ()
       decl = description->decls [i];
       if (decl->mode == dm_unit)
 	{
-	  root_value = exp (log (decl->decl.unit.max_occ_cycle_num + 1.0)
+	  root_value = exp (log (DECL_UNIT (decl)->max_occ_cycle_num + 1.0)
                             / automata_num);
 	  if (MAX_FLOATING_POINT_VALUE_FOR_AUTOMATON_BOUND / root_value
 	      > one_automaton_estimation_bound)
@@ -6224,11 +6466,11 @@ compare_max_occ_cycle_nums (unit_decl_1, unit_decl_2)
      const void *unit_decl_1;
      const void *unit_decl_2;
 {
-  if (((*(decl_t *) unit_decl_1)->decl.unit.max_occ_cycle_num)
-      < ((*(decl_t *) unit_decl_2)->decl.unit.max_occ_cycle_num))
+  if ((DECL_UNIT (*(decl_t *) unit_decl_1)->max_occ_cycle_num)
+      < (DECL_UNIT (*(decl_t *) unit_decl_2)->max_occ_cycle_num))
     return 1;
-  else if (((*(decl_t *) unit_decl_1)->decl.unit.max_occ_cycle_num)
-	   == ((*(decl_t *) unit_decl_2)->decl.unit.max_occ_cycle_num))
+  else if ((DECL_UNIT (*(decl_t *) unit_decl_1)->max_occ_cycle_num)
+	   == (DECL_UNIT (*(decl_t *) unit_decl_2)->max_occ_cycle_num))
     return 0;
   else
     return -1;
@@ -6262,8 +6504,8 @@ units_to_automata_heuristic_distr ()
          sizeof (decl_t), compare_max_occ_cycle_nums);
   automaton_num = 0;
   unit_decl_ptr = VLA_PTR_BEGIN (unit_decls);
-  bound_value = (*unit_decl_ptr)->decl.unit.max_occ_cycle_num;
-  (*unit_decl_ptr)->decl.unit.corresponding_automaton_num = automaton_num;
+  bound_value = DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
+  DECL_UNIT (*unit_decl_ptr)->corresponding_automaton_num = automaton_num;
   for (unit_decl_ptr++;
        unit_decl_ptr <= (decl_t *) VLA_PTR_LAST (unit_decls);
        unit_decl_ptr++)
@@ -6276,14 +6518,14 @@ units_to_automata_heuristic_distr ()
           && ((automata_num - automaton_num - 1 == rest_units_num)
               || (bound_value
                   > (estimation_bound
-		     / ((*unit_decl_ptr)->decl.unit.max_occ_cycle_num)))))
+		     / (DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num)))))
         {
-          bound_value = (*unit_decl_ptr)->decl.unit.max_occ_cycle_num;
+          bound_value = DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
           automaton_num++;
         }
       else
-        bound_value *= (*unit_decl_ptr)->decl.unit.max_occ_cycle_num;
-      (*unit_decl_ptr)->decl.unit.corresponding_automaton_num = automaton_num;
+        bound_value *= DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
+      DECL_UNIT (*unit_decl_ptr)->corresponding_automaton_num = automaton_num;
     }
   if (automaton_num != automata_num - 1)
     abort ();
@@ -6310,7 +6552,7 @@ create_ainsns ()
       if (decl->mode == dm_insn_reserv)
 	{
 	  curr_ainsn = create_node (sizeof (struct ainsn));
-	  curr_ainsn->insn_reserv_decl = &decl->decl.insn_reserv;
+	  curr_ainsn->insn_reserv_decl = DECL_INSN_RESERV (decl);
 	  curr_ainsn->important_p = FALSE;
 	  curr_ainsn->next_ainsn = NULL;
 	  if (prev_ainsn == NULL)
@@ -6336,14 +6578,14 @@ units_to_automata_distr ()
       decl = description->decls [i];
       if (decl->mode == dm_unit)
 	{
-	  if (decl->decl.unit.automaton_decl == NULL
-	      || (decl->decl.unit.automaton_decl->corresponding_automaton
+	  if (DECL_UNIT (decl)->automaton_decl == NULL
+	      || (DECL_UNIT (decl)->automaton_decl->corresponding_automaton
 		  == NULL))
 	    /* Distribute to the first automaton.  */
-	    decl->decl.unit.corresponding_automaton_num = 0;
+	    DECL_UNIT (decl)->corresponding_automaton_num = 0;
 	  else
-	    decl->decl.unit.corresponding_automaton_num
-	      = (decl->decl.unit.automaton_decl
+	    DECL_UNIT (decl)->corresponding_automaton_num
+	      = (DECL_UNIT (decl)->automaton_decl
                  ->corresponding_automaton->automaton_order_num);
 	}
     }
@@ -6386,14 +6628,14 @@ create_automata ()
 	{
 	  decl = description->decls [i];
 	  if (decl->mode == dm_automaton
-	      && decl->decl.automaton.automaton_is_used)
+	      && DECL_AUTOMATON (decl)->automaton_is_used)
 	    {
 	      curr_automaton = create_node (sizeof (struct automaton));
 	      curr_automaton->ainsn_list = create_ainsns ();
 	      curr_automaton->corresponding_automaton_decl
-		= &decl->decl.automaton;
+		= DECL_AUTOMATON (decl);
 	      curr_automaton->next_automaton = NULL;
-	      decl->decl.automaton.corresponding_automaton = curr_automaton;
+	      DECL_AUTOMATON (decl)->corresponding_automaton = curr_automaton;
 	      curr_automaton->automaton_order_num = curr_automaton_num;
 	      if (prev_automaton == NULL)
 		description->first_automaton = curr_automaton;
@@ -6459,60 +6701,60 @@ form_regexp (regexp)
   if (regexp->mode == rm_unit || regexp->mode == rm_reserv)
     {
       const char *name = (regexp->mode == rm_unit
-                          ? regexp->regexp.unit.name
-			  : regexp->regexp.reserv.name);
+                          ? REGEXP_UNIT (regexp)->name
+			  : REGEXP_RESERV (regexp)->name);
 
       obstack_grow (&irp, name, strlen (name));
     }
   else if (regexp->mode == rm_sequence)
-    for (i = 0; i < regexp->regexp.sequence.regexps_num; i++)
+    for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
       {
 	if (i != 0)
           obstack_1grow (&irp, ',');
-	form_regexp (regexp->regexp.sequence.regexps [i]);
+	form_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
       }
   else if (regexp->mode == rm_allof)
     {
       obstack_1grow (&irp, '(');
-      for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
 	{
 	  if (i != 0)
             obstack_1grow (&irp, '+');
-	  if (regexp->regexp.allof.regexps[i]->mode == rm_sequence
-              || regexp->regexp.oneof.regexps[i]->mode == rm_oneof)
+	  if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
+              || REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
             obstack_1grow (&irp, '(');
-	  form_regexp (regexp->regexp.allof.regexps [i]);
-	  if (regexp->regexp.allof.regexps[i]->mode == rm_sequence
-              || regexp->regexp.oneof.regexps[i]->mode == rm_oneof)
+	  form_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+	  if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
+              || REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
             obstack_1grow (&irp, ')');
         }
       obstack_1grow (&irp, ')');
     }
   else if (regexp->mode == rm_oneof)
-    for (i = 0; i < regexp->regexp.oneof.regexps_num; i++)
+    for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
       {
 	if (i != 0)
           obstack_1grow (&irp, '|');
-	if (regexp->regexp.oneof.regexps[i]->mode == rm_sequence)
+	if (REGEXP_ONEOF (regexp)->regexps[i]->mode == rm_sequence)
           obstack_1grow (&irp, '(');
-        form_regexp (regexp->regexp.oneof.regexps [i]);
-	if (regexp->regexp.oneof.regexps[i]->mode == rm_sequence)
+        form_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+	if (REGEXP_ONEOF (regexp)->regexps[i]->mode == rm_sequence)
           obstack_1grow (&irp, ')');
       }
   else if (regexp->mode == rm_repeat)
     {
       char digits [30];
 
-      if (regexp->regexp.repeat.regexp->mode == rm_sequence
-	  || regexp->regexp.repeat.regexp->mode == rm_allof
-	  || regexp->regexp.repeat.regexp->mode == rm_oneof)
+      if (REGEXP_REPEAT (regexp)->regexp->mode == rm_sequence
+	  || REGEXP_REPEAT (regexp)->regexp->mode == rm_allof
+	  || REGEXP_REPEAT (regexp)->regexp->mode == rm_oneof)
         obstack_1grow (&irp, '(');
-      form_regexp (regexp->regexp.repeat.regexp);
-      if (regexp->regexp.repeat.regexp->mode == rm_sequence
-	  || regexp->regexp.repeat.regexp->mode == rm_allof
-	  || regexp->regexp.repeat.regexp->mode == rm_oneof)
+      form_regexp (REGEXP_REPEAT (regexp)->regexp);
+      if (REGEXP_REPEAT (regexp)->regexp->mode == rm_sequence
+	  || REGEXP_REPEAT (regexp)->regexp->mode == rm_allof
+	  || REGEXP_REPEAT (regexp)->regexp->mode == rm_oneof)
         obstack_1grow (&irp, ')');
-      sprintf (digits, "*%d", regexp->regexp.repeat.repeat_num);
+      sprintf (digits, "*%d", REGEXP_REPEAT (regexp)->repeat_num);
       obstack_grow (&irp, digits, strlen (digits));
     }
   else if (regexp->mode == rm_nothing)
@@ -6602,7 +6844,7 @@ longest_path_length (state)
     /* Ignore cycles containing one state and `cycle advance' arcs.  */
     if (arc->to_state != state
 	&& (arc->insn->insn_reserv_decl
-	    != &advance_cycle_insn_decl->decl.insn_reserv))
+	    != DECL_INSN_RESERV (advance_cycle_insn_decl)))
     {
       length = longest_path_length (arc->to_state);
       if (length > result)
@@ -7457,7 +7699,7 @@ min_issue_delay_pass_states (state, ainsn)
 	if (insn_issue_delay != -1)
 	  {
 	    if (arc->insn->insn_reserv_decl
-		== &advance_cycle_insn_decl->decl.insn_reserv)
+		== DECL_INSN_RESERV (advance_cycle_insn_decl))
 	      insn_issue_delay++;
 	    if (min_insn_issue_delay == -1
 		|| min_insn_issue_delay > insn_issue_delay)
@@ -7614,7 +7856,7 @@ output_dead_lock_vect (automaton)
       VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num)
         = (next_out_arc (arc) == NULL
            && (arc->insn->insn_reserv_decl
-               == &advance_cycle_insn_decl->decl.insn_reserv) ? 1 : 0);
+               == DECL_INSN_RESERV (advance_cycle_insn_decl)) ? 1 : 0);
 #ifndef NDEBUG
       if (VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num))
         locked_states_num++;
@@ -7715,7 +7957,7 @@ output_tables ()
 	}
     }
   fprintf (output_file, "\n#define %s %d\n\n", ADVANCE_CYCLE_VALUE_NAME,
-           advance_cycle_insn_decl->decl.insn_reserv.insn_num);
+           DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num);
 }
 
 /* The function outputs definition and value of PHR interface variable
@@ -7739,35 +7981,36 @@ static void
 output_insn_code_cases (output_automata_list_code)
      void (*output_automata_list_code) (automata_list_el_t);
 {
-  decl_t decl, decl_2;
+  decl_t decl, decl2;
   int i, j;
 
   for (i = 0; i < description->decls_num; i++)
     {
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv)
-	decl->decl.insn_reserv.processed_p = FALSE;
+	DECL_INSN_RESERV (decl)->processed_p = FALSE;
     }
   for (i = 0; i < description->decls_num; i++)
     {
       decl = description->decls [i];
-      if (decl->mode == dm_insn_reserv && !decl->decl.insn_reserv.processed_p)
+      if (decl->mode == dm_insn_reserv
+	  && !DECL_INSN_RESERV (decl)->processed_p)
 	{
 	  for (j = i; j < description->decls_num; j++)
 	    {
-	      decl_2 = description->decls [j];
-	      if (decl_2->mode == dm_insn_reserv
-		  && (decl_2->decl.insn_reserv.important_automata_list
-		      == decl->decl.insn_reserv.important_automata_list))
+	      decl2 = description->decls [j];
+	      if (decl2->mode == dm_insn_reserv
+		  && (DECL_INSN_RESERV (decl2)->important_automata_list
+		      == DECL_INSN_RESERV (decl)->important_automata_list))
 		{
-		  decl_2->decl.insn_reserv.processed_p = TRUE;
+		  DECL_INSN_RESERV (decl2)->processed_p = TRUE;
 		  fprintf (output_file, "    case %d: /* %s */\n",
-			   decl_2->decl.insn_reserv.insn_num,
-			   decl_2->decl.insn_reserv.name);
+			   DECL_INSN_RESERV (decl2)->insn_num,
+			   DECL_INSN_RESERV (decl2)->name);
 		}
 	    }
 	  (*output_automata_list_code)
-	    (decl->decl.insn_reserv.important_automata_list);
+	    (DECL_INSN_RESERV (decl)->important_automata_list);
 	}
     }
 }
@@ -8278,16 +8521,16 @@ output_internal_insn_latency_func ()
       if (decl->mode == dm_insn_reserv)
 	{
 	  fprintf (output_file, "    case %d:\n",
-		   decl->decl.insn_reserv.insn_num);
-	  if (decl->decl.insn_reserv.bypass_list == NULL)
+		   DECL_INSN_RESERV (decl)->insn_num);
+	  if (DECL_INSN_RESERV (decl)->bypass_list == NULL)
 	    fprintf (output_file, "      return (%s != %s ? %d : 0);\n",
 		     INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
-		     decl->decl.insn_reserv.default_latency);
+		     DECL_INSN_RESERV (decl)->default_latency);
 	  else
 	    {
 	      fprintf (output_file, "      switch (%s)\n        {\n",
 		       INTERNAL_INSN2_CODE_NAME);
-	      for (bypass = decl->decl.insn_reserv.bypass_list;
+	      for (bypass = DECL_INSN_RESERV (decl)->bypass_list;
 		   bypass != NULL;
 		   bypass = bypass->next)
 		{
@@ -8301,13 +8544,13 @@ output_internal_insn_latency_func ()
 			     "          return (%s (%s, %s) ? %d : %d);\n",
 			     bypass->bypass_guard_name, INSN_PARAMETER_NAME,
 			     INSN2_PARAMETER_NAME, bypass->latency,
-			     decl->decl.insn_reserv.default_latency);
+			     DECL_INSN_RESERV (decl)->default_latency);
 		}
 	      fprintf (output_file, "        default:\n");
 	      fprintf (output_file,
 		       "          return (%s != %s ? %d : 0);\n        }\n",
 		       INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
-		       decl->decl.insn_reserv.default_latency);
+		       DECL_INSN_RESERV (decl)->default_latency);
 	      
 	    }
 	}
@@ -8366,11 +8609,11 @@ output_print_reservation_func ()
       if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
 	{
           fprintf (output_file,
-                   "    case %d:\n", decl->decl.insn_reserv.insn_num);
+                   "    case %d:\n", DECL_INSN_RESERV (decl)->insn_num);
           fprintf (output_file,
                    "      fprintf (%s, \"%s\");\n      break;\n",
                    FILE_PARAMETER_NAME,
-                   regexp_representation (decl->decl.insn_reserv.regexp));
+                   regexp_representation (DECL_INSN_RESERV (decl)->regexp));
           finish_regexp_representation ();
         }
     }
@@ -8557,25 +8800,25 @@ output_description ()
       decl = description->decls [i];
       if (decl->mode == dm_unit)
 	{
-	  if (decl->decl.unit.excl_list != NULL)
+	  if (DECL_UNIT (decl)->excl_list != NULL)
 	    {
 	      fprintf (output_description_file, "unit %s exlusion_set: ",
-		       decl->decl.unit.name);
-	      output_unit_set_el_list (decl->decl.unit.excl_list);
+		       DECL_UNIT (decl)->name);
+	      output_unit_set_el_list (DECL_UNIT (decl)->excl_list);
 	      fprintf (output_description_file, "\n");
 	    }
-	  if (decl->decl.unit.presence_list != NULL)
+	  if (DECL_UNIT (decl)->presence_list != NULL)
 	    {
 	      fprintf (output_description_file, "unit %s presence_set: ",
-		       decl->decl.unit.name);
-	      output_unit_set_el_list (decl->decl.unit.presence_list);
+		       DECL_UNIT (decl)->name);
+	      output_unit_set_el_list (DECL_UNIT (decl)->presence_list);
 	      fprintf (output_description_file, "\n");
 	    }
-	  if (decl->decl.unit.absence_list != NULL)
+	  if (DECL_UNIT (decl)->absence_list != NULL)
 	    {
 	      fprintf (output_description_file, "unit %s absence_set: ",
-		       decl->decl.unit.name);
-	      output_unit_set_el_list (decl->decl.unit.absence_list);
+		       DECL_UNIT (decl)->name);
+	      output_unit_set_el_list (DECL_UNIT (decl)->absence_list);
 	      fprintf (output_description_file, "\n");
 	    }
 	}
@@ -8587,24 +8830,26 @@ output_description ()
       if (decl->mode == dm_reserv)
 	{
           fprintf (output_description_file, "reservation ");
-          fprintf (output_description_file, decl->decl.reserv.name);
+          fprintf (output_description_file, DECL_RESERV (decl)->name);
           fprintf (output_description_file, ": ");
-          output_regexp (decl->decl.reserv.regexp);
+          output_regexp (DECL_RESERV (decl)->regexp);
           fprintf (output_description_file, "\n");
         }
       else if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
         {
           fprintf (output_description_file, "insn reservation %s ",
-		   decl->decl.insn_reserv.name);
-          print_rtl (output_description_file, decl->decl.insn_reserv.condexp);
+		   DECL_INSN_RESERV (decl)->name);
+          print_rtl (output_description_file,
+		     DECL_INSN_RESERV (decl)->condexp);
           fprintf (output_description_file, ": ");
-          output_regexp (decl->decl.insn_reserv.regexp);
+          output_regexp (DECL_INSN_RESERV (decl)->regexp);
           fprintf (output_description_file, "\n");
         }
       else if (decl->mode == dm_bypass)
 	fprintf (output_description_file, "bypass %d %s %s\n",
-		 decl->decl.bypass.latency, decl->decl.bypass.out_insn_name,
-		 decl->decl.bypass.in_insn_name);
+		 DECL_BYPASS (decl)->latency,
+		 DECL_BYPASS (decl)->out_insn_name,
+		 DECL_BYPASS (decl)->in_insn_name);
     }
   fprintf (output_description_file, "\n\f\n");
 }
@@ -8644,11 +8889,11 @@ output_automaton_units (automaton)
     {
       decl = description->decls [i];
       if (decl->mode == dm_unit
-          && (decl->decl.unit.corresponding_automaton_num
+          && (DECL_UNIT (decl)->corresponding_automaton_num
 	      == automaton->automaton_order_num))
 	{
 	  there_is_an_automaton_unit = 1;
-	  name = decl->decl.unit.name;
+	  name = DECL_UNIT (decl)->name;
 	  if (curr_line_length + strlen (name) + 1 > MAX_LINE_LENGTH )
 	    {
 	      curr_line_length = strlen (name) + 4;
@@ -8953,8 +9198,8 @@ generate ()
 
 
 
-/* The following function creates attribute which order number of insn
-   in pipeline hazard description translator.  */
+/* The following function creates insn attribute whose values are
+   number alternatives in insn reservations.  */
 static void
 make_insn_alts_attr ()
 {
@@ -8970,10 +9215,13 @@ make_insn_alts_attr ()
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
 	{
-          XVECEXP (condexp, 0, 2 * insn_num) = decl->decl.insn_reserv.condexp;
+          XVECEXP (condexp, 0, 2 * insn_num)
+	    = DECL_INSN_RESERV (decl)->condexp;
           XVECEXP (condexp, 0, 2 * insn_num + 1)
-            = make_numeric_value (decl->decl.insn_reserv.transformed_regexp
-				  ->regexp.oneof.regexps_num);
+            = make_numeric_value
+	      (DECL_INSN_RESERV (decl)->transformed_regexp->mode != rm_oneof
+	       ? 1 : REGEXP_ONEOF (DECL_INSN_RESERV (decl)
+				   ->transformed_regexp)->regexps_num);
           insn_num++;
         }
     }
@@ -8998,16 +9246,18 @@ make_internal_dfa_insn_code_attr ()
 
   condexp = rtx_alloc (COND);
   XVEC (condexp, 0) = rtvec_alloc ((description->insns_num - 1) * 2);
-  XEXP (condexp, 1) = make_numeric_value (advance_cycle_insn_decl
-					  ->decl.insn_reserv.insn_num + 1);
+  XEXP (condexp, 1)
+    = make_numeric_value (DECL_INSN_RESERV (advance_cycle_insn_decl)
+			  ->insn_num + 1);
   for (i = insn_num = 0; i < description->decls_num; i++)
     {
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
 	{
-          XVECEXP (condexp, 0, 2 * insn_num) = decl->decl.insn_reserv.condexp;
+          XVECEXP (condexp, 0, 2 * insn_num)
+	    = DECL_INSN_RESERV (decl)->condexp;
           XVECEXP (condexp, 0, 2 * insn_num + 1)
-            = make_numeric_value (decl->decl.insn_reserv.insn_num);
+            = make_numeric_value (DECL_INSN_RESERV (decl)->insn_num);
           insn_num++;
         }
     }
@@ -9039,9 +9289,10 @@ make_default_insn_latency_attr ()
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
 	{
-          XVECEXP (condexp, 0, 2 * insn_num) = decl->decl.insn_reserv.condexp;
+          XVECEXP (condexp, 0, 2 * insn_num)
+	    = DECL_INSN_RESERV (decl)->condexp;
           XVECEXP (condexp, 0, 2 * insn_num + 1)
-            = make_numeric_value (decl->decl.insn_reserv.default_latency);
+            = make_numeric_value (DECL_INSN_RESERV (decl)->default_latency);
           insn_num++;
         }
     }
@@ -9069,8 +9320,8 @@ make_bypass_attr ()
     {
       decl = description->decls [i];
       if (decl->mode == dm_insn_reserv
-	  && decl->decl.insn_reserv.condexp != NULL
-	  && decl->decl.insn_reserv.bypass_list != NULL)
+	  && DECL_INSN_RESERV (decl)->condexp != NULL
+	  && DECL_INSN_RESERV (decl)->bypass_list != NULL)
 	bypass_insns_num++;
     }
   if (bypass_insns_num == 0)
@@ -9085,11 +9336,11 @@ make_bypass_attr ()
         {
           decl = description->decls [i];
           if (decl->mode == dm_insn_reserv
-	      && decl->decl.insn_reserv.condexp != NULL
-	      && decl->decl.insn_reserv.bypass_list != NULL)
+	      && DECL_INSN_RESERV (decl)->condexp != NULL
+	      && DECL_INSN_RESERV (decl)->bypass_list != NULL)
 	    {
               XVECEXP (result_rtx, 0, 2 * bypass_insn)
-		= decl->decl.insn_reserv.condexp;
+		= DECL_INSN_RESERV (decl)->condexp;
               XVECEXP (result_rtx, 0, 2 * bypass_insn + 1)
 	        = make_numeric_value (1);
               bypass_insn++;
@@ -9310,12 +9561,12 @@ form_important_insn_automata_lists ()
 		 ainsn != NULL;
 		 ainsn = ainsn->next_ainsn)
 	      if (ainsn->important_p
-		  && ainsn->insn_reserv_decl == &decl->decl.insn_reserv)
+		  && ainsn->insn_reserv_decl == DECL_INSN_RESERV (decl))
 		{
 		  automata_list_add (automaton);
 		  break;
 		}
-	  decl->decl.insn_reserv.important_automata_list
+	  DECL_INSN_RESERV (decl)->important_automata_list
 	    = automata_list_finish ();
 	}
     }
@@ -9338,8 +9589,8 @@ expand_automata ()
     {
       description->decls [i] = VLA_PTR (decls, i);
       if (description->decls [i]->mode == dm_unit
-	  && description->decls [i]->decl.unit.query_p)
-        description->decls [i]->decl.unit.query_num
+	  && DECL_UNIT (description->decls [i])->query_p)
+        DECL_UNIT (description->decls [i])->query_num
 	  = description->query_units_num++;
     }
   all_time = create_ticker ();