[multiple changes]

Fri Oct 29 15:25:07 1999  Arnaud Charlet  <charlet@ACT-Europe.FR>

	* gcov.c (DIR_SEPARATOR): Provide default.
	(output_data): Add test for MS-DOS format absolute filename.
	(fancy_abort): Correct program name.
	(open_files): Open all files in binary mode.
	* libgcc2.c (__bb_exit_func): Likewise.

	* profile.c (init_branch_prob): Specify binary when opening files.

	* flags.h (flag_unwind_tables): New decl.
	* toplev.c (flag_unwind_table): New definition.
	(f_options): Add -funwind-tables.
	(decode_g_option): Clarify warning when unknown -g option is given.
	(rest_of_compilation): If inside an inlined external function,
	pretend we are just being declared.

	* dwarf2out.c (dwarf2out_do_frame): Check -funwind_tables.
	(dwarf2out_frame_finish): Likewise.

Fri Oct 29 06:32:44 1999  Geoffrey Keating  <geoffk@cygnus.com>

	* flow.c (propagate_block): When the last reference to a label
 	before an ADDR_VEC is deleted because the reference is a dead
 	store, delete the ADDR_VEC.

Fri Oct 29 07:44:26 1999  Vasco Pedro  <vp@di.fct.unl.pt>

	* fold-const.c (merge_ranges): In not in0, but in1, handle
	upper bounds equal like subset case.

Thu Oct 28 19:22:24 1999  Douglas Rupp <rupp@gnat.com>

	* dbxout.c (dbxout_parms): Generate a second stabs line for parameters
	passed in a register but moved to the stack.

Thu Oct 28 19:12:57 1999  Sam Tardieu  <tardieu@act-europe.fr>

	* gcc.c (pass_exit_codes, greatest_status): New variables.
	(struct option_map): Add entry for "--pass-exit-codes".
	(execute): Update greatest_status if error.
	(display_help): Add documentation for -pass-exit-codes.
	(process_command): Handle -pass-exit-codes.
	(main): Look at pass_exit_codes and greatest_status on call to exit.

Thu Oct 28 18:06:50 1999  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>

	* reload.c (find_reloads): Refine test for no input reload
	case to not includes reloads emitted after insn.

	* function.c (find_temp_slots_from_address): Handle sum involving
	a register that points to a temp slot.
	(update_temp_slot_address): Make recursive call if both old and
	new are PLUS with a common operand.
	* calls.c (expand_call): Mark temp slot for result as having
	address taken.

	* rtlanal.c (reg_referenced_p, case IF_THEN_ELSE): New case.

	* gcc.c (process_command): Add standard_exec_prefix with "GCC"
	component as well as "BINUTILS".

	* integrate.h (copy_rtx_and_substitute): New arg, FOR_LHS.
	* integrate.c (copy_rtx_and_substitute): Likewise.
	(expand_inline_function, integrate_parm_decls, integrate_decl_tree):
	All callers changed.
	* unroll.c (inital_reg_note_copy, copy_loop_body): Likewise.

	* dbxout.c (dbxout_type, case INTEGER_TYPE_NODE): If can use
	gdb extensions, write size of type; also be more consistent
	in using references when this is a subtype.

	* pa.md (extv, extzv, insv): Use define_expand to reject constant
	that is out of range.

	* loop.c (unknown_constant_address_altered): New variable.
	(prescan_loop): Initialize it.
	(note_addr_stored): Set it for RTX_UNCHANGING_P MEM.
	(invariant_p, case MEM): Remove handling for volatile and readony;
	check new variable if readonly.
	(check_dbra_loop): Chdeck unknown_constant_address_altered.

	* cse.c (canon_hash, case MEM): Do not record if BLKmode.
	(addr_affects_sp_p): Removed from note_mem_written and only
	define #ifdef AUTO_INC_DEC.

	* alpha.c (input_operand, case ADDRESSOF): Treat as REG.

	* regclass.c (record_reg_classes): Properly handle register move
	directions.

	* varasm.c (initializer_constant_valid_p, case MINUS_EXPR):
	Don't think valid if both operands are invalid.
	(struct constant_descriptor): New field RTL.
	(mark_const_hash_entry): Mark it.
	(record_constant{,_rtx}): Initialize it.
	(output_constant_def): Allocate RTL in permanent obstack and
	save in table.
	({record,compare}_constant_1): Modes must match for
	CONSTRUCTOR of ARRAY_TYPE.

	* c-common.h (initializer_constant_valid_p): Delete decl from here.
	* output.h (initializer_constant_valid_p): Move decl to here.
	* c-common.c (initializer_constant_valid_p): Delete function from here.
	* varasm.c (initializer_constant_valid_p): Move function to here.

	* tree.h (STRIP_SIGN_NOPS): New macro.
	* fold-const.c (optimize_minmax_comparison): New function.
	(invert_truthvalue, case WITH_RECORD_EXPR): New case.
	(fold): Use STRIP_SIGN_NOPS instead of STRIP_TYPE_NOPS.
	(fold, case EQ_EXPR): Call optimize_minmax_comparison and add
	cases with ABS_EXPR, NEGATE_EXPR, PLUS_EXPR, MINUS_EXPR, and
	widening conversions.
	(fold, case LE_EXPR): Rework changing unsigned to signed comparisons
	to look at size of mode, not precision of type; also add missing cases.
	(optimize_bit_field_compare, decode_field_reference): Don't try to
	optimize COMPONENT_REF of a PLACEHOLDER_EXPR.

	* dwarf2out.c (ctype.h): Include.
	(dwarf2out_set_demangle_name_func): New function.
	(size_of_line_info): Deleted.
	(output_line_info): Compute size of line info table from difference
	of labels.
	(base_type_die, add_name_attribute): Call demangle function, if any.
	(field_byte_offset): Use bits per word for variable length fields.
	(gen_array_type_die): Add array name.
	(gen_subprogram_die): Ignore DECL_INLINE if -fno-inline.
	(dwarf2out_add_library_unit_info): New function.

	* explow.c (set_stack_check_libfunc): New function.
	(stack_check_libfunc): New static variable.
	(probe_stack_range): Allow front-end to set up a libfunc to call.

	* combine.c (simplify_comparison): When making comparison in wider
	mode, check for having commuted an AND and a SUBREG.
	(contains_muldiv): New function.
	(try_combine): Call it when dividing a PARALLEL.
	(simplify_rtx, case TRUNCATE): Don't remove for umulsi3_highpart.
	(simplify_comparison, case ASHIFTRT): Recognize sign-extension of
	a PLUS.
	(record_value_for_reg): If TEM is a binary operation with two CLOBBERs,
	use one of the CLOBBERs instead.
	(if_then_else_cond): If comparing against zero, just return thing
	being compared.

	* optabs.c (expand_abs): If machine has MAX, ABS (x) is MAX (x, -x).
	Don't generate shifts and subtract if have conditional arithmetic.

	* rtl.h (delete_barrier): New declaration.
	* jump.c (jump_optimize): Set up to handle conditional call.
	In conditional arithmetic case, handle CALL_INSN followed by a BARRIER.
	(delete_barrier): New function.

	* rtl.c (read_rtx): Call fatal if bad RTL code; check for bad mode.

	* recog.c (nonmemory_operand): Accept ADDRESSOF.

	* tree.c (build_type_attribute_variant): Push to obstack of
	ttype around type_hash_canon call.

	* expr.c (placeholder_list): Move decl to file scope.
	(expand_expr): Don't force access to volatile just because its
	address is taken.
	If ignoring reference operations, just expand the operands.
	(expand_expr, case COMPONENT_REF): Propagate
	EXPAND_CONST_ADDRESS to recursive call when expanding inner.
	Refine test for using bitfield operations vs pointer punning.
	(expand_expr, case CONVERT_EXPR): If converting to
	BLKmode UNION_TYPE from BLKmode, just return inner object.
	Use proper mode in store_field call.
	Properly set sizes of object to store and total size in store_field
	call for convert to union.
	(expand_expr, case ARRAY_REF): If OP0 is in a register, put it in
	memory (like for ADDR_EXPR).  Also, don't put constant in register if
	we'll want it in memory.
	(readonly_fields_p): New function.
	(expand_expr, case INDIRECT_REF): Call it if LHS.
	(expand_assignment): Handle a RESULT_DECL where
	DECL_RTL is a PARALLEL.
	(do_jump, case WITH_RECORD_EXPR): New case.
	(get_inner_reference): Always go inside a CONVERT_EXPR
	and NOP_EXPR if both modes are the same.
	(store_field): Use bitfield operations if size of bitsize is not same
	as size of RHS's type.
	Check for bitpos not a multiple of alignment in BLKmode case.
	Do block move in largest possible alignment.
	(store_constructor): Set BITSIZE to -1 for variable size and properly
 	in case of array of BLKmode.
	(expand_expr_unaligned): New function.
	(do_compare_and_jump): Call it.

	* mips/iris5.h (SWITCHES_NEED_SPACES): New macro.
	* collect2.c (main): Only allow -ofoo if SWITCHES_NEED_SPACES
	does not include 'o'.

	* function.c (instantiate_virtual_regs_1, case SET): Handle case where
	both SET_DEST and SET_SRC reference a virtual register.
	(gen_mem_addressof): Copy RTX_UNCHANGING_P from new REG to old REG.

	* integrate.c (expand_inline_function): Handle case of setting
	virtual stack vars register (from built in setjmp); when parameter
	lives in memory, expand virtual_{stack_vars,incoming_args}_rtx early.
	(subst_constant): Add new parm, MEMONLY.
	(expand_inline_function, integrate_parm_decls): Pass new parm.
	(integrate_decl_tree): Likewise.
	(copy_rtx_and_substitute, case MEM): Do copy RTX_UNCHANGING_P.
	(try_constants): Call subst_constants twice, with MEMONLY 0 and 1.
	(copy_rtx_and_substitute, case SET): Add explicit calls to
	copy_rtx_and_substitute for both sides.

	* stmt.c (expand_asm_operands): Don't use TREE_STRING_LENGTH for
	constraints.
	(pushcase{,_range}): Convert to NOMINAL_TYPE after checking for
	within INDEX_TYPE, instead of before.
	(fixup_gotos): Use f->target_rtl, not the next insn,
	since latter may be from a later fixup.
	(expand_value_return): Correctly convert VAL when promoting function
	return; support RETURN_REG being a PARALLEL.
	(expand_return): When checking for result in regs and having
	cleanup, consider PARALLEL in DECL_RTL as being in regs.

From-SVN: r30299

1 files changed, 204 insertions, 26 deletions

diff --git a/gcc/varasm.c b/gcc/varasm.c
index 9eb92bc..e88f0cb 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -2343,6 +2343,7 @@ struct constant_descriptor
 {
   struct constant_descriptor *next;
   char *label;
+  rtx rtl;
   char contents[1];
 };
 
@@ -2361,6 +2362,7 @@ mark_const_hash_entry (ptr)
   while (desc)
     {
       ggc_mark_string (desc->label);
+      ggc_mark_rtx (desc->rtl);
       desc = desc->next;
     }
 }
@@ -2576,6 +2578,7 @@ compare_constant_1 (exp, p)
 	  register tree link;
 	  int length = list_length (CONSTRUCTOR_ELTS (exp));
 	  tree type;
+	  enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 	  int have_purpose = 0;
 
 	  for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
@@ -2599,6 +2602,14 @@ compare_constant_1 (exp, p)
 	  if (bcmp ((char *) &type, p, sizeof type))
 	    return 0;
 
+	  if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+	    {
+	      if (bcmp ((char *) &mode, p, sizeof mode))
+		return 0;
+
+	      p += sizeof mode;
+	    }
+
 	  p += sizeof type;
 
 	  if (bcmp ((char *) &have_purpose, p, sizeof have_purpose))
@@ -2715,12 +2726,14 @@ record_constant (exp)
 {
   struct constant_descriptor *next = 0;
   char *label = 0;
+  rtx rtl = 0;
 
-  /* Make a struct constant_descriptor.  The first two pointers will
+  /* Make a struct constant_descriptor.  The first three pointers will
      be filled in later.  Here we just leave space for them.  */
 
   obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
   obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
+  obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
   record_constant_1 (exp);
   return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
 }
@@ -2785,6 +2798,7 @@ record_constant_1 (exp)
 	{
 	  register tree link;
 	  int length = list_length (CONSTRUCTOR_ELTS (exp));
+	  enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 	  tree type;
 	  int have_purpose = 0;
 
@@ -2795,14 +2809,18 @@ record_constant_1 (exp)
 	  obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
 
 	  /* For record constructors, insist that the types match.
-	     For arrays, just verify both constructors are for arrays. 
-	     Then insist that either both or none have any TREE_PURPOSE
-	     values.  */
+	     For arrays, just verify both constructors are for arrays
+	     of the same mode.  Then insist that either both or none
+	     have any TREE_PURPOSE values.  */
 	  if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
 	    type = TREE_TYPE (exp);
 	  else
 	    type = 0;
+
 	  obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
+	  if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+	    obstack_grow (&permanent_obstack, &mode, sizeof mode);
+			  
 	  obstack_grow (&permanent_obstack, (char *) &have_purpose,
 			sizeof have_purpose);
 
@@ -3027,9 +3045,8 @@ output_constant_def (exp)
   register int hash;
   register struct constant_descriptor *desc;
   char label[256];
-  char *found = 0;
   int reloc;
-  register rtx def;
+  int found = 1;
 
   if (TREE_CST_RTL (exp))
     return TREE_CST_RTL (exp);
@@ -3047,12 +3064,9 @@ output_constant_def (exp)
       
   for (desc = const_hash_table[hash]; desc; desc = desc->next)
     if (compare_constant (exp, desc))
-      {
-	found = desc->label;
-	break;
-      }
+      break;
       
-  if (found == 0)
+  if (desc == 0)
     {
       /* No constant equal to EXP is known to have been output.
 	 Make a constant descriptor to enter EXP in the hash table.
@@ -3066,23 +3080,30 @@ output_constant_def (exp)
       desc->next = const_hash_table[hash];
       desc->label = ggc_alloc_string (label, -1);
       const_hash_table[hash] = desc;
-    }
   
-  /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
+      /* We have a symbol name; construct the SYMBOL_REF and the MEM
+	 in the permanent obstack.  We could also construct this in the
+	 obstack of EXP and put it into TREE_CST_RTL, but we have no way
+	 of knowing what obstack it is (e.g., it might be in a function
+	 obstack of a function we are nested inside).  */
 
-  push_obstacks_nochange ();
-  if (TREE_PERMANENT (exp))
-    end_temporary_allocation ();
+      push_obstacks_nochange ();
+      end_temporary_allocation ();
 
-  def = gen_rtx_SYMBOL_REF (Pmode, desc->label);
-      
-  TREE_CST_RTL (exp)
-    = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), def);
-  RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
-  if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
-    MEM_SET_IN_STRUCT_P (TREE_CST_RTL (exp), 1);
+      desc->rtl
+	= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
+		       gen_rtx_SYMBOL_REF (Pmode, desc->label));
 
-  pop_obstacks ();
+      RTX_UNCHANGING_P (desc->rtl) = 1;
+      if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
+	MEM_SET_IN_STRUCT_P (desc->rtl, 1);
+
+      pop_obstacks ();
+
+      found = 0;
+    }
+
+  TREE_CST_RTL (exp) = desc->rtl;
 
   /* Optionally set flags or add text to the name to record information
      such as that it is a function name.  If the name is changed, the macro
@@ -3093,7 +3114,7 @@ output_constant_def (exp)
 
   /* If this is the first time we've seen this particular constant,
      output it (or defer its output for later).  */
-  if (found == 0)
+  if (! found)
     {
       int after_function = 0;
 
@@ -3482,6 +3503,7 @@ record_constant_rtx (mode, x)
 {
   struct constant_descriptor *ptr;
   char *label;
+  rtx rtl;
   struct rtx_const value;
 
   decode_rtx_const (mode, x, &value);
@@ -3491,6 +3513,7 @@ record_constant_rtx (mode, x)
      memory allocated from function_obstack (current_obstack).  */
   obstack_grow (saveable_obstack, &ptr, sizeof ptr);
   obstack_grow (saveable_obstack, &label, sizeof label);
+  obstack_grow (saveable_obstack, &rtl, sizeof rtl);
 
   /* Record constant contents.  */
   obstack_grow (saveable_obstack, &value, sizeof value);
@@ -3988,6 +4011,161 @@ output_addressed_constants (exp)
   return reloc;
 }
 
+/* Return nonzero if VALUE is a valid constant-valued expression
+   for use in initializing a static variable; one that can be an
+   element of a "constant" initializer.
+
+   Return null_pointer_node if the value is absolute;
+   if it is relocatable, return the variable that determines the relocation.
+   We assume that VALUE has been folded as much as possible;
+   therefore, we do not need to check for such things as
+   arithmetic-combinations of integers.  */
+
+tree
+initializer_constant_valid_p (value, endtype)
+     tree value;
+     tree endtype;
+{
+  switch (TREE_CODE (value))
+    {
+    case CONSTRUCTOR:
+      if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
+	   || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
+	  && TREE_CONSTANT (value)
+	  && CONSTRUCTOR_ELTS (value))
+	return
+	  initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
+					endtype);
+	
+      return TREE_STATIC (value) ? null_pointer_node : 0;
+
+    case INTEGER_CST:
+    case REAL_CST:
+    case STRING_CST:
+    case COMPLEX_CST:
+      return null_pointer_node;
+
+    case ADDR_EXPR:
+      return TREE_OPERAND (value, 0);
+
+    case NON_LVALUE_EXPR:
+      return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+
+    case CONVERT_EXPR:
+    case NOP_EXPR:
+      /* Allow conversions between pointer types.  */
+      if (POINTER_TYPE_P (TREE_TYPE (value))
+	  && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+
+      /* Allow conversions between real types.  */
+      if (FLOAT_TYPE_P (TREE_TYPE (value))
+	  && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+
+      /* Allow length-preserving conversions between integer types.  */
+      if (INTEGRAL_TYPE_P (TREE_TYPE (value))
+	  && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
+	  && (TYPE_PRECISION (TREE_TYPE (value))
+	      == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+
+      /* Allow conversions between other integer types only if
+	 explicit value.  */
+      if (INTEGRAL_TYPE_P (TREE_TYPE (value))
+	  && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
+	{
+	  tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						     endtype);
+	  if (inner == null_pointer_node)
+	    return null_pointer_node;
+	  break;
+	}
+
+      /* Allow (int) &foo provided int is as wide as a pointer.  */
+      if (INTEGRAL_TYPE_P (TREE_TYPE (value))
+	  && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
+	  && (TYPE_PRECISION (TREE_TYPE (value))
+	      >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+					     endtype);
+
+      /* Likewise conversions from int to pointers, but also allow
+	 conversions from 0.  */
+      if (POINTER_TYPE_P (TREE_TYPE (value))
+	  && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
+	{
+	  if (integer_zerop (TREE_OPERAND (value, 0)))
+	    return null_pointer_node;
+	  else if (TYPE_PRECISION (TREE_TYPE (value))
+		   <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
+	    return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						 endtype);
+	}
+
+      /* Allow conversions to union types if the value inside is okay.  */
+      if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+					     endtype);
+      break;
+
+    case PLUS_EXPR:
+      if (! INTEGRAL_TYPE_P (endtype)
+	  || TYPE_PRECISION (endtype) >= POINTER_SIZE)
+        {
+	  tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						      endtype);
+	  tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+						      endtype);
+	  /* If either term is absolute, use the other terms relocation.  */
+	  if (valid0 == null_pointer_node)
+	    return valid1;
+	  if (valid1 == null_pointer_node)
+	    return valid0;
+        }
+      break;
+
+    case MINUS_EXPR:
+      if (! INTEGRAL_TYPE_P (endtype)
+	  || TYPE_PRECISION (endtype) >= POINTER_SIZE)
+	{
+	  tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						      endtype);
+	  tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+						      endtype);
+	  /* Win if second argument is absolute.  */
+	  if (valid1 == null_pointer_node)
+	    return valid0;
+	  /* Win if both arguments have the same relocation.
+	     Then the value is absolute.  */
+	  if (valid0 == valid1 && valid0 != 0)
+	    return null_pointer_node;
+	}
+
+      /* Support differences between labels.  */
+      if (INTEGRAL_TYPE_P (endtype))
+	{
+	  tree op0, op1;
+	  op0 = TREE_OPERAND (value, 0);
+	  op1 = TREE_OPERAND (value, 1);
+	  STRIP_NOPS (op0);
+	  STRIP_NOPS (op1);
+
+	  if (TREE_CODE (op0) == ADDR_EXPR
+	      && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
+	      && TREE_CODE (op1) == ADDR_EXPR
+	      && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
+	    return null_pointer_node;
+	}
+      break;
+
+    default:
+      break;
+    }
+
+  return 0;
+}
+
 /* Output assembler code for constant EXP to FILE, with no label.
    This includes the pseudo-op such as ".int" or ".byte", and a newline.
    Assumes output_addressed_constants has been done on EXP already.
@@ -4608,7 +4786,7 @@ make_decl_one_only (decl)
 void
 init_varasm_once ()
 {
-  ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof(const_hash_table[0]),
+  ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
 		mark_const_hash_entry);
   ggc_add_string_root (&in_named_name, 1);
 }