SF_SET_ADJ_LNNOPTR (last_line_symbol); SF_SET_PROCESS (def_symbol_in_progress);
obj_coff_endef (ignore)     int ignore;{  symbolS *symbolP = 0;  /* DIM BUG FIX sac@cygnus.com */  dim_index = 0;  if (def_symbol_in_progress == NULL)    {      as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");      demand_empty_rest_of_line ();      return;    }				/* if not inside .def/.endef */  /* Set the section number according to storage class. */  switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))    {    case C_STRTAG:    case C_ENTAG:    case C_UNTAG:      SF_SET_TAG (def_symbol_in_progress);      /* intentional fallthrough */    case C_FILE:    case C_TPDEF:      SF_SET_DEBUG (def_symbol_in_progress);      S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);      break;    case C_EFCN:      SF_SET_LOCAL (def_symbol_in_progress);	/* Do not emit this symbol. */      /* intentional fallthrough */    case C_BLOCK:      SF_SET_PROCESS (def_symbol_in_progress);	/* Will need processing before writing */      /* intentional fallthrough */    case C_FCN:      S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);      if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)	{			/* .bf */	  if (function_lineoff < 0)	    {	      fprintf (stderr, "`.bf' symbol without preceding function\n");	    }			/* missing function symbol */	  SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;	  SF_SET_PROCESS (last_line_symbol);	  function_lineoff = -1;	}      /* Value is always set to . */      def_symbol_in_progress->sy_frag = frag_now;      S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());      break;#ifdef C_AUTOARG    case C_AUTOARG:#endif /* C_AUTOARG */    case C_AUTO:    case C_REG:    case C_MOS:    case C_MOE:    case C_MOU:    case C_ARG:    case C_REGPARM:    case C_FIELD:    case C_EOS:      SF_SET_DEBUG (def_symbol_in_progress);      S_SET_SEGMENT (def_symbol_in_progress, absolute_section);      break;    case C_EXT:    case C_STAT:    case C_LABEL:      /* Valid but set somewhere else (s_comm, s_lcomm, colon) */      break;    case C_USTATIC:    case C_EXTDEF:    case C_ULABEL:      as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));      break;    }				/* switch on storage class */  /* Now that we have built a debug symbol, try to find if we should     merge with an existing symbol or not.  If a symbol is C_EFCN or     absolute_section or untagged SEG_DEBUG it never merges.  We also     don't merge labels, which are in a different namespace, nor     symbols which have not yet been defined since they are typically     unique, nor do we merge tags with non-tags.  */  /* Two cases for functions.  Either debug followed by definition or     definition followed by debug.  For definition first, we will     merge the debug symbol into the definition.  For debug first, the     lineno entry MUST point to the definition function or else it     will point off into space when crawl_symbols() merges the debug     symbol into the real symbol.  Therefor, let's presume the debug     symbol is a real function reference. */  /* FIXME-SOON If for some reason the definition label/symbol is     never seen, this will probably leave an undefined symbol at link     time. */  if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN      || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL      || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG	  && !SF_GET_TAG (def_symbol_in_progress))      || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section      || def_symbol_in_progress->sy_value.X_op != O_constant      || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL      || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))    {      symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,		     &symbol_lastP);    }  else    {      /* This symbol already exists, merge the newly created symbol	 into the old one.  This is not mandatory. The linker can	 handle duplicate symbols correctly. But I guess that it save	 a *lot* of space if the assembly file defines a lot of	 symbols. [loic] */      /* The debug entry (def_symbol_in_progress) is merged into the	 previous definition.  */      c_symbol_merge (def_symbol_in_progress, symbolP);      /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */      def_symbol_in_progress = symbolP;      if (SF_GET_FUNCTION (def_symbol_in_progress)	  || SF_GET_TAG (def_symbol_in_progress))	{	  /* For functions, and tags, the symbol *must* be where the	     debug symbol appears.  Move the existing symbol to the	     current place. */	  /* If it already is at the end of the symbol list, do nothing */	  if (def_symbol_in_progress != symbol_lastP)	    {	      symbol_remove (def_symbol_in_progress, &symbol_rootP,			     &symbol_lastP);	      symbol_append (def_symbol_in_progress, symbol_lastP,			     &symbol_rootP, &symbol_lastP);	    }			/* if not already in place */	}			/* if function */    }				/* normal or mergable */  if (SF_GET_TAG (def_symbol_in_progress)      && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)    {      tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);    }  if (SF_GET_FUNCTION (def_symbol_in_progress))    {      know (sizeof (def_symbol_in_progress) <= sizeof (long));      function_lineoff	= c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);      SF_SET_PROCESS (def_symbol_in_progress);      if (symbolP == NULL)	{	  /* That is, if this is the first time we've seen the	     function... */	  symbol_table_insert (def_symbol_in_progress);	}			/* definition follows debug */    }				/* Create the line number entry pointing to the function being defined */  def_symbol_in_progress = NULL;  demand_empty_rest_of_line ();}