== (unsigned long int)
== (ffetargetOffset)
ffecom_sym_transform_ (ffesymbol s){  tree t;			/* Transformed thingy. */  tree tlen;			/* Length if CHAR*(*). */  bool addr;			/* Is t the address of the thingy? */  ffeinfoBasictype bt;  ffeinfoKindtype kt;  int yes;  int old_lineno = lineno;  char *old_input_filename = input_filename;  if (ffesymbol_sfdummyparent (s) == NULL)    {      input_filename = ffesymbol_where_filename (s);      lineno = ffesymbol_where_filelinenum (s);    }  else    {      ffesymbol sf = ffesymbol_sfdummyparent (s);      input_filename = ffesymbol_where_filename (sf);      lineno = ffesymbol_where_filelinenum (sf);    }  bt = ffeinfo_basictype (ffebld_info (s));  kt = ffeinfo_kindtype (ffebld_info (s));  t = NULL_TREE;  tlen = NULL_TREE;  addr = FALSE;  switch (ffesymbol_kind (s))    {    case FFEINFO_kindNONE:      switch (ffesymbol_where (s))	{	case FFEINFO_whereDUMMY:	/* Subroutine or function. */	  assert (ffecom_transform_only_dummies_);	  /* Before 0.4, this could be ENTITY/DUMMY, but see	     ffestu_sym_end_transition -- no longer true (in particular, if	     it could be an ENTITY, it _will_ be made one, so that	     possibility won't come through here).  So we never make length	     arg for CHARACTER type.  */	  t = build_decl (PARM_DECL,			  ffecom_get_identifier_ (ffesymbol_text (s)),			  ffecom_tree_ptr_to_subr_type);#if BUILT_FOR_270	  DECL_ARTIFICIAL (t) = 1;#endif	  addr = TRUE;	  break;	case FFEINFO_whereGLOBAL:	/* Subroutine or function. */	  assert (!ffecom_transform_only_dummies_);	  yes = suspend_momentary ();	  t = build_decl (FUNCTION_DECL,			  ffecom_get_external_identifier_ (s),			  ffecom_tree_subr_type);	/* Assume subr. */	  DECL_EXTERNAL (t) = 1;	  TREE_PUBLIC (t) = 1;	  t = start_decl (t, FALSE);	  finish_decl (t, NULL_TREE, FALSE);	  if (current_function_decl != NULL_TREE)	    resume_momentary (yes);	  break;	default:	  assert ("NONE where unexpected" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  break;	}      break;    case FFEINFO_kindENTITY:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereCONSTANT:	/* ~~debugging info needed? */	  assert (!ffecom_transform_only_dummies_);	  t = error_mark_node;	/* Shouldn't ever see this in expr. */	  break;	case FFEINFO_whereLOCAL:	  assert (!ffecom_transform_only_dummies_);	  {	    ffestorag st = ffesymbol_storage (s);	    tree type;	    if ((st != NULL)		&& (ffestorag_size (st) == 0))	      {		t = error_mark_node;		break;	      }	    yes = suspend_momentary ();	    type = ffecom_type_localvar_ (s, bt, kt);	    resume_momentary (yes);	    if ((st != NULL)		&& (ffestorag_parent (st) != NULL))	      {			/* Child of EQUIVALENCE parent. */		ffestorag est;		tree et;		int yes;		ffetargetOffset offset;		est = ffestorag_parent (st);		ffecom_transform_equiv_ (est);		et = ffestorag_hook (est);		assert (et != NULL_TREE);		if (! TREE_STATIC (et))		  put_var_into_stack (et);		yes = suspend_momentary ();		offset = ffestorag_modulo (est)		  + ffestorag_offset (ffesymbol_storage (s))		  - ffestorag_offset (est);		ffecom_debug_kludge_ (et, "EQUIVALENCE", s, type, offset);		/* (t_type *) (((char *) &et) + offset) */		t = convert (string_type_node,	/* (char *) */			     ffecom_1 (ADDR_EXPR,				       build_pointer_type (TREE_TYPE (et)),				       et));		t = ffecom_2 (PLUS_EXPR, TREE_TYPE (t),			      t,			      build_int_2 (offset, 0));		t = convert (build_pointer_type (type),			     t);		addr = TRUE;		resume_momentary (yes);	      }	    else	      {		tree initexpr;		bool init = ffesymbol_is_init (s);		yes = suspend_momentary ();		t = build_decl (VAR_DECL,				ffecom_get_identifier_ (ffesymbol_text (s)),				type);		if (init		    || ffesymbol_namelisted (s)#ifdef FFECOM_sizeMAXSTACKITEM		    || ((st != NULL)			&& (ffestorag_size (st) > FFECOM_sizeMAXSTACKITEM))#endif		    || ((ffecom_primary_entry_kind_ != FFEINFO_kindPROGRAM)			&& (ffecom_primary_entry_kind_			    != FFEINFO_kindBLOCKDATA)			&& (ffesymbol_is_save (s) || ffe_is_saveall ())))		  TREE_STATIC (t) = 1;	/* SAVEd in proc, make static. */		else		  TREE_STATIC (t) = 0;	/* No need to make static. */		if (init || ffe_is_init_local_zero ())		  DECL_INITIAL (t) = error_mark_node;		/* Keep -Wunused from complaining about var if it		   is used as sfunc arg or DATA implied-DO.  */		if (ffesymbol_attrs (s) & FFESYMBOL_attrsSFARG)		  DECL_IN_SYSTEM_HEADER (t) = 1;		t = start_decl (t, FALSE);		if (init)		  {		    if (ffesymbol_init (s) != NULL)		      initexpr = ffecom_expr (ffesymbol_init (s));		    else		      initexpr = ffecom_init_zero_ (t);		  }		else if (ffe_is_init_local_zero ())		  initexpr = ffecom_init_zero_ (t);		else		  initexpr = NULL_TREE;	/* Not ref'd if !init. */		finish_decl (t, initexpr, FALSE);		if (st != NULL)		  assert (ffestorag_size (st) * BITS_PER_UNIT			  == (unsigned long int)			  TREE_INT_CST_LOW (DECL_SIZE (t)));		resume_momentary (yes);	      }	  }	  break;	case FFEINFO_whereRESULT:	  assert (!ffecom_transform_only_dummies_);	  if (bt == FFEINFO_basictypeCHARACTER)	    {			/* Result is already in list of dummies, use				   it (& length). */	      t = ffecom_func_result_;	      tlen = ffecom_func_length_;	      addr = TRUE;	      break;	    }	  if ((ffecom_num_entrypoints_ == 0)	      && (bt == FFEINFO_basictypeCOMPLEX)	      && (ffesymbol_is_f2c (ffecom_primary_entry_)))	    {			/* Result is already in list of dummies, use				   it. */	      t = ffecom_func_result_;	      addr = TRUE;	      break;	    }	  if (ffecom_func_result_ != NULL_TREE)	    {	      t = ffecom_func_result_;	      break;	    }	  if ((ffecom_num_entrypoints_ != 0)	      && (ffecom_master_bt_ == FFEINFO_basictypeNONE))	    {	      yes = suspend_momentary ();	      assert (ffecom_multi_retval_ != NULL_TREE);	      t = ffecom_1 (INDIRECT_REF, ffecom_multi_type_node_,			    ffecom_multi_retval_);	      t = ffecom_2 (COMPONENT_REF, ffecom_tree_type[bt][kt],			    t, ffecom_multi_fields_[bt][kt]);	      resume_momentary (yes);	      break;	    }	  yes = suspend_momentary ();	  t = build_decl (VAR_DECL,			  ffecom_get_identifier_ (ffesymbol_text (s)),			  ffecom_tree_type[bt][kt]);	  TREE_STATIC (t) = 0;	/* Put result on stack. */	  t = start_decl (t, FALSE);	  finish_decl (t, NULL_TREE, FALSE);	  ffecom_func_result_ = t;	  resume_momentary (yes);	  break;	case FFEINFO_whereDUMMY:	  {	    tree type;	    ffebld dl;	    ffebld dim;	    tree low;	    tree high;	    tree old_sizes;	    bool adjustable = FALSE;	/* Conditionally adjustable? */	    type = ffecom_tree_type[bt][kt];	    if (ffesymbol_sfdummyparent (s) != NULL)	      {		if (current_function_decl == ffecom_outer_function_decl_)		  {			/* Exec transition before sfunc					   context; get it later. */		    break;		  }		t = ffecom_get_identifier_ (ffesymbol_text					    (ffesymbol_sfdummyparent (s)));	      }	    else	      t = ffecom_get_identifier_ (ffesymbol_text (s));	    assert (ffecom_transform_only_dummies_);	    old_sizes = get_pending_sizes ();	    put_pending_sizes (old_sizes);	    if (bt == FFEINFO_basictypeCHARACTER)	      tlen = ffecom_char_enhance_arg_ (&type, s);	    for (dl = ffesymbol_dims (s); dl != NULL; dl = ffebld_trail (dl))	      {		dim = ffebld_head (dl);		assert (ffebld_op (dim) == FFEBLD_opBOUNDS);		if ((ffebld_left (dim) == NULL) || ffecom_doing_entry_)		  low = ffecom_integer_one_node;		else		  low = ffecom_expr (ffebld_left (dim));		assert (ffebld_right (dim) != NULL);		if ((ffebld_op (ffebld_right (dim)) == FFEBLD_opSTAR)		    || ffecom_doing_entry_)		  /* Used to just do high=low.  But for ffecom_tree_		     canonize_ref_, it probably is important to correctly		     assess the size.  E.g. given COMPLEX C(*),CFUNC and		     C(2)=CFUNC(C), overlap can happen, while it can't		     for, say, C(1)=CFUNC(C(2)).  */		  high = convert (TREE_TYPE (low),				  TYPE_MAX_VALUE (TREE_TYPE (low)));		else		  high = ffecom_expr (ffebld_right (dim));		/* Determine whether array is conditionally adjustable,		   to decide whether back-end magic is needed.		   Normally the front end uses the back-end function		   variable_size to wrap SAVE_EXPR's around expressions		   affecting the size/shape of an array so that the		   size/shape info doesn't change during execution		   of the compiled code even though variables and		   functions referenced in those expressions might.		   variable_size also makes sure those saved expressions		   get evaluated immediately upon entry to the		   compiled procedure -- the front end normally doesn't		   have to worry about that.		   However, there is a problem with this that affects		   g77's implementation of entry points, and that is		   that it is _not_ true that each invocation of the		   compiled procedure is permitted to evaluate		   array size/shape info -- because it is possible		   that, for some invocations, that info is invalid (in		   which case it is "promised" -- i.e. a violation of		   the Fortran standard -- that the compiled code		   won't reference the array or its size/shape		   during that particular invocation).		   To phrase this in C terms, consider this gcc function:		     void foo (int *n, float (*a)[*n])		     {		       // a is "pointer to array ...", fyi.		     }		   Suppose that, for some invocations, it is permitted		   for a caller of foo to do this:		       foo (NULL, NULL);		   Now the _written_ code for foo can take such a call		   into account by either testing explicitly for whether		   (a == NULL) || (n == NULL) -- presumably it is		   not permitted to reference *a in various fashions		   if (n == NULL) I suppose -- or it can avoid it by		   looking at other info (other arguments, static/global		   data, etc.).		   However, this won't work in gcc 2.5.8 because it'll		   automatically emit the code to save the "*n"		   expression, which'll yield a NULL dereference for		   the "foo (NULL, NULL)" call, something the code		   for foo cannot prevent.		   g77 definitely needs to avoid executing such		   code anytime the pointer to the adjustable array		   is NULL, because even if its bounds expressions		   don't have any references to possible "absent"		   variables like "*n" -- say all variable references		   are to COMMON variables, i.e. global (though in C,		   local static could actually make sense) -- the		   expressions could yield other run-time problems		   for allowably "dead" values in those variables.		   For example, let's consider a more complicated		   version of foo:		     extern int i;		     extern int j;		     void foo (float (*a)[i/j])		     {		       ...		     }		   The above is (essentially) quite valid for Fortran		   but, again, for a call like "foo (NULL);", it is		   permitted for i and j to be undefined when the		   call is made.  If j happened to be zero, for		   example, emitting the code to evaluate "i/j"		   could result in a run-time error.		   Offhand, though I don't have my F77 or F90		   standards handy, it might even be valid for a		   bounds expression to contain a function reference,		   in which case I doubt it is permitted for an		   implementation to invoke that function in the		   Fortran case involved here (invocation of an		   alternate ENTRY point that doesn't have the adjustable		   array as one of its arguments).		   So, the code that the compiler would normally emit		   to preevaluate the size/shape info for an		   adjustable array _must not_ be executed at run time		   in certain cases.  Specifically, for Fortran,		   the case is when the pointer to the adjustable		   array == NULL.  (For gnu-ish C, it might be nice		   for the source code itself to specify an expression		   that, if TRUE, inhibits execution of the code.  Or		   reverse the sense for elegance.)		   (Note that g77 could use a different test than NULL,		   actually, since it happens to always pass an		   integer to the called function that specifies which		   entry point is being invoked.  Hmm, this might		   solve the next problem.)		   One way a user could, I suppose, write "foo" so		   it works is to insert COND_EXPR's for the		   size/shape info so the dangerous stuff isn't		   actually done, as in:		     void foo (int *n, float (*a)[(a == NULL) ? 0 : *n])		     {		       ...		     }		   The next problem is that the front end needs to		   be able to tell the back end about the array's		   decl _before_ it tells it about the conditional		   expression to inhibit evaluation of size/shape info,		   as shown above.		   To solve this, the front end needs to be able		   to give the back end the expression to inhibit		   generation of the preevaluation code _after_		   it makes the decl for the adjustable array.		   Until then, the above example using the COND_EXPR		   doesn't pass muster with gcc because the "(a == NULL)"		   part has a reference to "a", which is still		   undefined at that point.		   g77 will therefore use a different mechanism in the		   meantime.  */		if (!adjustable		    && ((TREE_CODE (low) != INTEGER_CST)			|| (TREE_CODE (high) != INTEGER_CST)))		  adjustable = TRUE;#if 0				/* Old approach -- see below. */		if (TREE_CODE (low) != INTEGER_CST)		  low = ffecom_3 (COND_EXPR, integer_type_node,				  ffecom_adjarray_passed_ (s),				  low,				  ffecom_integer_zero_node);		if (TREE_CODE (high) != INTEGER_CST)		  high = ffecom_3 (COND_EXPR, integer_type_node,				   ffecom_adjarray_passed_ (s),				   high,				   ffecom_integer_zero_node);#endif		/* ~~~gcc/stor-layout.c/layout_type should do this,		   probably.  Fixes 950302-1.f.  */		if (TREE_CODE (low) != INTEGER_CST)		  low = variable_size (low);		/* ~~~similarly, this fixes dumb0.f.  The C front end		   does this, which is why dumb0.c would work.  */		if (TREE_CODE (high) != INTEGER_CST)		  high = variable_size (high);		type		  = build_array_type		    (type,		     build_range_type (ffecom_integer_type_node,				       low, high));	      }	    if ((ffesymbol_sfdummyparent (s) == NULL)		|| (ffesymbol_basictype (s) == FFEINFO_basictypeCHARACTER))	      {		type = build_pointer_type (type);		addr = TRUE;	      }	    t = build_decl (PARM_DECL, t, type);#if BUILT_FOR_270	    DECL_ARTIFICIAL (t) = 1;#endif	    /* If this arg is present in every entry point's list of	       dummy args, then we're done.  */	    if (ffesymbol_numentries (s)		== (ffecom_num_entrypoints_ + 1))	      break;#if 1	    /* If variable_size in stor-layout has been called during	       the above, then get_pending_sizes should have the	       yet-to-be-evaluated saved expressions pending.	       Make the whole lot of them get emitted, conditionally	       on whether the array decl ("t" above) is not NULL.  */	    {	      tree sizes = get_pending_sizes ();	      tree tem;	      for (tem = sizes;		   tem != old_sizes;		   tem = TREE_CHAIN (tem))		{		  tree temv = TREE_VALUE (tem);		  if (sizes == tem)		    sizes = temv;		  else		    sizes		      = ffecom_2 (COMPOUND_EXPR,				  TREE_TYPE (sizes),				  temv,				  sizes);		}	      if (sizes != tem)		{		  sizes		    = ffecom_3 (COND_EXPR,				TREE_TYPE (sizes),				ffecom_2 (NE_EXPR,					  integer_type_node,					  t,					  null_pointer_node),				sizes,				convert (TREE_TYPE (sizes),					 integer_zero_node));		  sizes = ffecom_save_tree (sizes);		  sizes		    = tree_cons (NULL_TREE, sizes, tem);		}	      if (sizes)		put_pending_sizes (sizes);	    }#else#if 0	    if (adjustable		&& (ffesymbol_numentries (s)		    != ffecom_num_entrypoints_ + 1))	      DECL_SOMETHING (t)		= ffecom_2 (NE_EXPR, integer_type_node,			    t,			    null_pointer_node);#else#if 0	    if (adjustable		&& (ffesymbol_numentries (s)		    != ffecom_num_entrypoints_ + 1))	      {		ffebad_start (FFEBAD_MISSING_ADJARRAY_UNSUPPORTED);		ffebad_here (0, ffesymbol_where_line (s),			     ffesymbol_where_column (s));		ffebad_string (ffesymbol_text (s));		ffebad_finish ();	      }#endif#endif#endif	  }	  break;	case FFEINFO_whereCOMMON:	  {	    ffesymbol cs;	    ffeglobal cg;	    tree ct;	    ffestorag st = ffesymbol_storage (s);	    tree type;	    int yes;	    cs = ffesymbol_common (s);	/* The COMMON area itself.  */	    if (st != NULL)	/* Else not laid out. */	      {		ffecom_transform_common_ (cs);		st = ffesymbol_storage (s);	      }	    yes = suspend_momentary ();	    type = ffecom_type_localvar_ (s, bt, kt);	    cg = ffesymbol_global (cs);	/* The global COMMON info.  */	    if ((cg == NULL)		|| (ffeglobal_type (cg) != FFEGLOBAL_typeCOMMON))	      ct = NULL_TREE;	    else	      ct = ffeglobal_hook (cg);	/* The common area's tree.  */	    if ((ct == NULL_TREE)		|| (st == NULL))	      t = error_mark_node;	    else	      {		ffetargetOffset offset;		ffestorag cst;		cst = ffestorag_parent (st);		assert (cst == ffesymbol_storage (cs));		offset = ffestorag_modulo (cst)		  + ffestorag_offset (st)		  - ffestorag_offset (cst);		ffecom_debug_kludge_ (ct, "COMMON", s, type, offset);		/* (t_type *) (((char *) &ct) + offset) */		t = convert (string_type_node,	/* (char *) */			     ffecom_1 (ADDR_EXPR,				       build_pointer_type (TREE_TYPE (ct)),				       ct));		t = ffecom_2 (PLUS_EXPR, TREE_TYPE (t),			      t,			      build_int_2 (offset, 0));		t = convert (build_pointer_type (type),			     t);		addr = TRUE;	      }	    resume_momentary (yes);	  }	  break;	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereGLOBAL:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("ENTITY where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindFUNCTION:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	/* Me. */	  assert (!ffecom_transform_only_dummies_);	  t = current_function_decl;	  break;	case FFEINFO_whereGLOBAL:	  assert (!ffecom_transform_only_dummies_);	  yes = suspend_momentary ();	  if (ffesymbol_is_f2c (s)	      && (ffesymbol_where (s) != FFEINFO_whereCONSTANT))	    t = ffecom_tree_fun_type[bt][kt];	  else	    t = build_function_type (ffecom_tree_type[bt][kt], NULL_TREE);	  t = build_decl (FUNCTION_DECL,			  ffecom_get_external_identifier_ (s),			  t);	  DECL_EXTERNAL (t) = 1;	  TREE_PUBLIC (t) = 1;	  t = start_decl (t, FALSE);	  finish_decl (t, NULL_TREE, FALSE);	  if (current_function_decl != NULL_TREE)	    resume_momentary (yes);	  break;	case FFEINFO_whereDUMMY:	  assert (ffecom_transform_only_dummies_);	  if (ffesymbol_is_f2c (s)	      && (ffesymbol_where (s) != FFEINFO_whereCONSTANT))	    t = ffecom_tree_ptr_to_fun_type[bt][kt];	  else	    t = build_pointer_type	      (build_function_type (ffecom_tree_type[bt][kt], NULL_TREE));	  t = build_decl (PARM_DECL,			  ffecom_get_identifier_ (ffesymbol_text (s)),			  t);#if BUILT_FOR_270	  DECL_ARTIFICIAL (t) = 1;#endif	  addr = TRUE;	  break;	case FFEINFO_whereCONSTANT:	/* Statement function. */	  assert (!ffecom_transform_only_dummies_);	  t = ffecom_gen_sfuncdef_ (s, bt, kt);	  break;	case FFEINFO_whereINTRINSIC:	  assert (!ffecom_transform_only_dummies_);	  break;		/* Let actual references generate their				   decls. */	default:	  assert ("FUNCTION where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindSUBROUTINE:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	/* Me. */	  assert (!ffecom_transform_only_dummies_);	  t = current_function_decl;	  break;	case FFEINFO_whereGLOBAL:	  assert (!ffecom_transform_only_dummies_);	  yes = suspend_momentary ();	  t = build_decl (FUNCTION_DECL,			  ffecom_get_external_identifier_ (s),			  ffecom_tree_subr_type);	  DECL_EXTERNAL (t) = 1;	  TREE_PUBLIC (t) = 1;	  t = start_decl (t, FALSE);	  finish_decl (t, NULL_TREE, FALSE);	  if (current_function_decl != NULL_TREE)	    resume_momentary (yes);	  break;	case FFEINFO_whereDUMMY:	  assert (ffecom_transform_only_dummies_);	  t = build_decl (PARM_DECL,			  ffecom_get_identifier_ (ffesymbol_text (s)),			  ffecom_tree_ptr_to_subr_type);#if BUILT_FOR_270	  DECL_ARTIFICIAL (t) = 1;#endif	  addr = TRUE;	  break;	case FFEINFO_whereINTRINSIC:	  assert (!ffecom_transform_only_dummies_);	  break;		/* Let actual references generate their				   decls. */	default:	  assert ("SUBROUTINE where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindPROGRAM:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	/* Me. */	  assert (!ffecom_transform_only_dummies_);	  t = current_function_decl;	  break;	case FFEINFO_whereCOMMON:	case FFEINFO_whereDUMMY:	case FFEINFO_whereGLOBAL:	case FFEINFO_whereRESULT:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("PROGRAM where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindBLOCKDATA:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	/* Me. */	  assert (!ffecom_transform_only_dummies_);	  t = current_function_decl;	  break;	case FFEINFO_whereGLOBAL:	  assert (!ffecom_transform_only_dummies_);	  yes = suspend_momentary ();	  t = build_decl (FUNCTION_DECL,			  ffecom_get_external_identifier_ (s),			  ffecom_tree_blockdata_type);	  DECL_EXTERNAL (t) = 1;	  TREE_PUBLIC (t) = 1;	  t = start_decl (t, FALSE);	  finish_decl (t, NULL_TREE, FALSE);	  if (current_function_decl != NULL_TREE)	    resume_momentary (yes);	  break;	case FFEINFO_whereCOMMON:	case FFEINFO_whereDUMMY:	case FFEINFO_whereRESULT:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("BLOCKDATA where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindCOMMON:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	  assert (!ffecom_transform_only_dummies_);	  ffecom_transform_common_ (s);	  break;	case FFEINFO_whereNONE:	case FFEINFO_whereCOMMON:	case FFEINFO_whereDUMMY:	case FFEINFO_whereGLOBAL:	case FFEINFO_whereRESULT:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("COMMON where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindCONSTRUCT:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	  assert (!ffecom_transform_only_dummies_);	  break;	case FFEINFO_whereNONE:	case FFEINFO_whereCOMMON:	case FFEINFO_whereDUMMY:	case FFEINFO_whereGLOBAL:	case FFEINFO_whereRESULT:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("CONSTRUCT where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    case FFEINFO_kindNAMELIST:      switch (ffeinfo_where (ffesymbol_info (s)))	{	case FFEINFO_whereLOCAL:	  assert (!ffecom_transform_only_dummies_);	  t = ffecom_transform_namelist_ (s);	  break;	case FFEINFO_whereNONE:	case FFEINFO_whereCOMMON:	case FFEINFO_whereDUMMY:	case FFEINFO_whereGLOBAL:	case FFEINFO_whereRESULT:	case FFEINFO_whereFLEETING:	case FFEINFO_whereFLEETING_CADDR:	case FFEINFO_whereFLEETING_IADDR:	case FFEINFO_whereIMMEDIATE:	case FFEINFO_whereINTRINSIC:	case FFEINFO_whereCONSTANT:	case FFEINFO_whereCONSTANT_SUBOBJECT:	default:	  assert ("NAMELIST where unheard of" == NULL);	  /* Fall through. */	case FFEINFO_whereANY:	  t = error_mark_node;	  break;	}      break;    default:      assert ("kind unheard of" == NULL);      /* Fall through. */    case FFEINFO_kindANY:      t = error_mark_node;      break;    }  ffesymbol_hook (s).decl_tree = t;  ffesymbol_hook (s).length_tree = tlen;  ffesymbol_hook (s).addr = addr;  lineno = old_lineno;  input_filename = old_input_filename;  return s;}