Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
obj-coff.c File Reference
#include "as.h"
#include "obstack.h"
#include "subsegs.h"

Go to the source code of this file.

Classes

struct  stack
struct  line_no

Defines

#define OBJ_HEADER   "obj-coff.h"
#define streq(a, b)   (strcmp ((a), (b)) == 0)
#define strneq(a, b, n)   (strncmp ((a), (b), (n)) == 0)
#define KEEP_RELOC_INFO
#define TC_COFF_SECTION_DEFAULT_ATTRIBUTES   (SEC_LOAD | SEC_DATA)
#define GET_FILENAME_STRING(X)   ((char *) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
#define in_function()   (line_fsym != 0)
#define clear_function()   (line_fsym = 0)
#define set_function(F)   (line_fsym = (F), coff_add_linesym (F))
#define SKIP_SEMI_COLON()   while (*input_line_pointer++ != ';')
#define SKIP_WHITESPACES()
#define STAB_SECTION_NAME   ".stab"
#define STAB_STRING_SECTION_NAME   ".stabstr"

Functions

static stackstack_init (unsigned long chunk_size, unsigned long element_size)
static char * stack_push (stack *st, char *element)
static char * stack_pop (stack *st)
static void tag_init (void)
static void tag_insert (const char *name, symbolS *symbolP)
static symbolS * tag_find (char *name)
static symbolS * tag_find_or_make (char *name)
static void obj_coff_bss (int ignore ATTRIBUTE_UNUSED)
static segT fetch_coff_debug_section (void)
void SA_SET_SYM_ENDNDX (symbolS *sym, symbolS *val)
static void SA_SET_SYM_TAGNDX (symbolS *sym, symbolS *val)
static int S_GET_DATA_TYPE (symbolS *sym)
int S_SET_DATA_TYPE (symbolS *sym, int val)
int S_GET_STORAGE_CLASS (symbolS *sym)
int S_SET_STORAGE_CLASS (symbolS *sym, int val)
static void c_symbol_merge (symbolS *debug, symbolS *normal)
void c_dot_file_symbol (const char *filename, int appfile ATTRIBUTE_UNUSED)
void coff_obj_symbol_new_hook (symbolS *symbolP)
void coff_obj_symbol_clone_hook (symbolS *newsymP, symbolS *orgsymP)
static void add_lineno (fragS *frag, addressT offset, int num)
void coff_add_linesym (symbolS *sym)
static void obj_coff_ln (int appline)
static void obj_coff_loc (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_ident (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_def (int what ATTRIBUTE_UNUSED)
static void obj_coff_endef (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_dim (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_line (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_size (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_scl (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_tag (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_type (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_val (int ignore ATTRIBUTE_UNUSED)
static void obj_coff_weak (int ignore ATTRIBUTE_UNUSED)
void coff_obj_read_begin_hook (void)
void coff_frob_symbol (symbolS *symp, int *punt)
void coff_adjust_section_syms (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *x ATTRIBUTE_UNUSED)
void coff_frob_file_after_relocs (void)
void obj_coff_section (int ignore ATTRIBUTE_UNUSED)
void coff_adjust_symtab (void)
void coff_frob_section (segT sec)
void obj_coff_init_stab_section (segT seg)
static void coff_pop_insert (void)
static int coff_separate_stab_sections (void)

Variables

static symbolS * def_symbol_in_progress
static struct hash_controltag_hash
int coff_line_base
static symbolS * line_fsym
static symbolS * current_lineno_sym
static struct line_noline_nos
int coff_n_line_nos
unsigned int dim_index
symbolS * coff_last_function
static symbolS * coff_last_bf
const pseudo_typeS coff_pseudo_table []

Class Documentation

struct stack

Definition at line 56 of file obj-coff.c.

Class Members
unsigned long chunk_size
char * data
unsigned long element_size
unsigned long pointer
unsigned long size
struct line_no

Definition at line 295 of file obj-coff.c.

Collaboration diagram for line_no:
Class Members
fragS * frag
alent l
struct line_no * next

Define Documentation

#define clear_function ( )    (line_fsym = 0)

Definition at line 308 of file obj-coff.c.

#define GET_FILENAME_STRING (   X)    ((char *) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])

Definition at line 172 of file obj-coff.c.

#define in_function ( )    (line_fsym != 0)

Definition at line 307 of file obj-coff.c.

#define KEEP_RELOC_INFO

Definition at line 38 of file obj-coff.c.

#define OBJ_HEADER   "obj-coff.h"

Definition at line 23 of file obj-coff.c.

#define set_function (   F)    (line_fsym = (F), coff_add_linesym (F))

Definition at line 309 of file obj-coff.c.

#define SKIP_SEMI_COLON ( )    while (*input_line_pointer++ != ';')

Definition at line 513 of file obj-coff.c.

#define SKIP_WHITESPACES ( )
Value:
while (*input_line_pointer == ' ' || \
                                   *input_line_pointer == '\t')  \
                                  input_line_pointer++;

Definition at line 514 of file obj-coff.c.

#define STAB_SECTION_NAME   ".stab"
#define STAB_STRING_SECTION_NAME   ".stabstr"
#define streq (   a,
  b 
)    (strcmp ((a), (b)) == 0)

Definition at line 33 of file obj-coff.c.

#define strneq (   a,
  b,
  n 
)    (strncmp ((a), (b), (n)) == 0)

Definition at line 34 of file obj-coff.c.

Definition at line 45 of file obj-coff.c.


Function Documentation

static void add_lineno ( fragS *  frag,
addressT  offset,
int  num 
) [static]

Definition at line 353 of file obj-coff.c.

{
  struct line_no * new_line = xmalloc (sizeof (* new_line));

  if (!current_lineno_sym)
    abort ();

#ifndef OBJ_XCOFF
  /* The native aix assembler accepts negative line number.  */

  if (num <= 0)
    {
      /* Zero is used as an end marker in the file.  */
      as_warn (_("Line numbers must be positive integers\n"));
      num = 1;
    }
#endif /* OBJ_XCOFF */
  new_line->next = line_nos;
  new_line->frag = frag;
  new_line->l.line_number = num;
  new_line->l.u.offset = offset;
  line_nos = new_line;
  coff_n_line_nos++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void c_dot_file_symbol ( const char *  filename,
int appfile  ATTRIBUTE_UNUSED 
)

Definition at line 263 of file obj-coff.c.

{
  symbolS *symbolP;

  /* BFD converts filename to a .file symbol with an aux entry.  It
     also handles chaining.  */
  symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);

  S_SET_STORAGE_CLASS (symbolP, C_FILE);
  S_SET_NUMBER_AUXILIARY (symbolP, 1);

  symbol_get_bfdsym (symbolP)->flags = BSF_DEBUGGING;

#ifndef NO_LISTING
  {
    extern int listing;

    if (listing)
      listing_source_file (filename);
  }
#endif

  /* Make sure that the symbol is first on the symbol chain.  */
  if (symbol_rootP != symbolP)
    {
      symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
      symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void c_symbol_merge ( symbolS *  debug,
symbolS *  normal 
) [static]

Definition at line 243 of file obj-coff.c.

{
  S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
  S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));

  if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
    /* Take the most we have.  */
    S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));

  if (S_GET_NUMBER_AUXILIARY (debug) > 0)
    /* Move all the auxiliary information.  */
    memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
           (S_GET_NUMBER_AUXILIARY (debug)
            * sizeof (*SYM_AUXINFO (debug))));

  /* Move the debug flags.  */
  SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void coff_add_linesym ( symbolS *  sym)

Definition at line 379 of file obj-coff.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void coff_adjust_section_syms ( bfd *abfd  ATTRIBUTE_UNUSED,
asection sec,
void *x  ATTRIBUTE_UNUSED 
)

Definition at line 1417 of file obj-coff.c.

{
  symbolS *secsym;
  segment_info_type *seginfo = seg_info (sec);
  int nlnno, nrelocs = 0;

  /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
     tc-ppc.c.  Do not get confused by it.  */
  if (seginfo == NULL)
    return;

  if (streq (sec->name, ".text"))
    nlnno = coff_n_line_nos;
  else
    nlnno = 0;
  {
    /* @@ Hope that none of the fixups expand to more than one reloc
       entry...  */
    fixS *fixp = seginfo->fix_root;
    while (fixp)
      {
       if (! fixp->fx_done)
         nrelocs++;
       fixp = fixp->fx_next;
      }
  }
  if (bfd_get_section_size (sec) == 0
      && nrelocs == 0
      && nlnno == 0
      && sec != text_section
      && sec != data_section
      && sec != bss_section)
    return;

  secsym = section_symbol (sec);
  /* This is an estimate; we'll plug in the real value using
     SET_SECTION_RELOCS later */
  SA_SET_SCN_NRELOC (secsym, nrelocs);
  SA_SET_SCN_NLINNO (secsym, nlnno);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void coff_adjust_symtab ( void  )

Definition at line 1641 of file obj-coff.c.

Here is the call graph for this function:

void coff_frob_file_after_relocs ( void  )

Definition at line 1461 of file obj-coff.c.

Here is the call graph for this function:

void coff_frob_section ( segT  sec)

Definition at line 1649 of file obj-coff.c.

{
  segT strsec;
  char *p;
  fragS *fragp;
  bfd_vma size, n_entries, mask;
  bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;

  /* The COFF back end in BFD requires that all section sizes be
     rounded up to multiples of the corresponding section alignments,
     supposedly because standard COFF has no other way of encoding alignment
     for sections.  If your COFF flavor has a different way of encoding
     section alignment, then skip this step, as TICOFF does.  */
  size = bfd_get_section_size (sec);
  mask = ((bfd_vma) 1 << align_power) - 1;
#if !defined(TICOFF)
  if (size & mask)
    {
      bfd_vma new_size;
      fragS *last;

      new_size = (size + mask) & ~mask;
      bfd_set_section_size (stdoutput, sec, new_size);

      /* If the size had to be rounded up, add some padding in
         the last non-empty frag.  */
      fragp = seg_info (sec)->frchainP->frch_root;
      last = seg_info (sec)->frchainP->frch_last;
      while (fragp->fr_next != last)
       fragp = fragp->fr_next;
      last->fr_address = size;
      fragp->fr_offset += new_size - size;
    }
#endif

  /* If the section size is non-zero, the section symbol needs an aux
     entry associated with it, indicating the size.  We don't know
     all the values yet; coff_frob_symbol will fill them in later.  */
#ifndef TICOFF
  if (size != 0
      || sec == text_section
      || sec == data_section
      || sec == bss_section)
#endif
    {
      symbolS *secsym = section_symbol (sec);

      S_SET_STORAGE_CLASS (secsym, C_STAT);
      S_SET_NUMBER_AUXILIARY (secsym, 1);
      SF_SET_STATICS (secsym);
      SA_SET_SCN_SCNLEN (secsym, size);
    }

  /* FIXME: These should be in a "stabs.h" file, or maybe as.h.  */
#ifndef STAB_SECTION_NAME
#define STAB_SECTION_NAME ".stab"
#endif
#ifndef STAB_STRING_SECTION_NAME
#define STAB_STRING_SECTION_NAME ".stabstr"
#endif
  if (! streq (STAB_STRING_SECTION_NAME, sec->name))
    return;

  strsec = sec;
  sec = subseg_get (STAB_SECTION_NAME, 0);
  /* size is already rounded up, since other section will be listed first */
  size = bfd_get_section_size (strsec);

  n_entries = bfd_get_section_size (sec) / 12 - 1;

  /* Find first non-empty frag.  It should be large enough.  */
  fragp = seg_info (sec)->frchainP->frch_root;
  while (fragp && fragp->fr_fix == 0)
    fragp = fragp->fr_next;
  assert (fragp != 0 && fragp->fr_fix >= 12);

  /* Store the values.  */
  p = fragp->fr_literal;
  bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
  bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
}

Here is the call graph for this function:

void coff_frob_symbol ( symbolS *  symp,
int punt 
)

Definition at line 1159 of file obj-coff.c.

{
  static symbolS *last_tagP;
  static stack *block_stack;
  static symbolS *set_end;
  symbolS *next_set_end = NULL;

  if (symp == &abs_symbol)
    {
      *punt = 1;
      return;
    }

  if (current_lineno_sym)
    coff_add_linesym (NULL);

  if (!block_stack)
    block_stack = stack_init (512, sizeof (symbolS*));

#ifdef TE_PE
  if (S_GET_STORAGE_CLASS (symp) == C_NT_WEAK
      && ! S_IS_WEAK (symp)
      && weak_is_altname (S_GET_NAME (symp)))
    {
      /* This is a weak alternate symbol.  All processing of
        PECOFFweak symbols is done here, through the alternate.  */
      symbolS *weakp = symbol_find_noref (weak_altname2name
                                     (S_GET_NAME (symp)), 1);

      assert (weakp);
      assert (S_GET_NUMBER_AUXILIARY (weakp) == 1);

      if (! S_IS_WEAK (weakp))
       {
         /* The symbol was turned from weak to strong.  Discard altname.  */
         *punt = 1;
         return;
       }
      else if (symbol_equated_p (weakp))
       {
         /* The weak symbol has an alternate specified; symp is unneeded.  */
         S_SET_STORAGE_CLASS (weakp, C_NT_WEAK);
         SA_SET_SYM_TAGNDX (weakp,
           symbol_get_value_expression (weakp)->X_add_symbol);

         S_CLEAR_EXTERNAL (symp);
         *punt = 1;
         return;
       }
      else
       {
         /* The weak symbol has been assigned an alternate value.
             Copy this value to symp, and set symp as weakp's alternate.  */
         if (S_GET_STORAGE_CLASS (weakp) != C_NT_WEAK)
           {
             S_SET_STORAGE_CLASS (symp, S_GET_STORAGE_CLASS (weakp));
             S_SET_STORAGE_CLASS (weakp, C_NT_WEAK);
           }

         if (S_IS_DEFINED (weakp))
           {
             /* This is a defined weak symbol.  Copy value information
                from the weak symbol itself to the alternate symbol.  */
             symbol_set_value_expression (symp,
                                      symbol_get_value_expression (weakp));
             symbol_set_frag (symp, symbol_get_frag (weakp));
             S_SET_SEGMENT (symp, S_GET_SEGMENT (weakp));
           }
         else
           {
             /* This is an undefined weak symbol.
               Define the alternate symbol to zero.  */
             S_SET_VALUE (symp, 0);
             S_SET_SEGMENT (symp, absolute_section);
           }

         S_SET_NAME (symp, weak_uniquify (S_GET_NAME (symp)));
         S_SET_STORAGE_CLASS (symp, C_EXT);

         S_SET_VALUE (weakp, 0);
         S_SET_SEGMENT (weakp, undefined_section);
       }
    }
#else /* TE_PE */
  if (S_IS_WEAK (symp))
    S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
#endif /* TE_PE */

  if (!S_IS_DEFINED (symp)
      && !S_IS_WEAK (symp)
      && S_GET_STORAGE_CLASS (symp) != C_STAT)
    S_SET_STORAGE_CLASS (symp, C_EXT);

  if (!SF_GET_DEBUG (symp))
    {
      symbolS * real;

      if (!SF_GET_LOCAL (symp)
         && !SF_GET_STATICS (symp)
         && S_GET_STORAGE_CLASS (symp) != C_LABEL
         && symbol_constant_p (symp)
         && (real = symbol_find_noref (S_GET_NAME (symp), 1))
         && S_GET_STORAGE_CLASS (real) == C_NULL
         && real != symp)
       {
         c_symbol_merge (symp, real);
         *punt = 1;
         return;
       }

      if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
       {
         assert (S_GET_VALUE (symp) == 0);
         if (S_IS_WEAKREFD (symp))
           *punt = 1;
         else
           S_SET_EXTERNAL (symp);
       }
      else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
       {
         if (S_GET_SEGMENT (symp) == text_section
             && symp != seg_info (text_section)->sym)
           S_SET_STORAGE_CLASS (symp, C_LABEL);
         else
           S_SET_STORAGE_CLASS (symp, C_STAT);
       }

      if (SF_GET_PROCESS (symp))
       {
         if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
           {
             if (streq (S_GET_NAME (symp), ".bb"))
              stack_push (block_stack, (char *) &symp);
             else
              {
                symbolS *begin;

                begin = *(symbolS **) stack_pop (block_stack);
                if (begin == 0)
                  as_warn (_("mismatched .eb"));
                else
                  next_set_end = begin;
              }
           }

         if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
           {
             union internal_auxent *auxp;

             coff_last_function = symp;
             if (S_GET_NUMBER_AUXILIARY (symp) < 1)
              S_SET_NUMBER_AUXILIARY (symp, 1);
             auxp = SYM_AUXENT (symp);
             memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
                    sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
           }

         if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
           {
             if (coff_last_function == 0)
              as_fatal (_("C_EFCN symbol for %s out of scope"),
                       S_GET_NAME (symp));
             SA_SET_SYM_FSIZE (coff_last_function,
                            (long) (S_GET_VALUE (symp)
                                   - S_GET_VALUE (coff_last_function)));
             next_set_end = coff_last_function;
             coff_last_function = 0;
           }
       }

      if (S_IS_EXTERNAL (symp))
       S_SET_STORAGE_CLASS (symp, C_EXT);
      else if (SF_GET_LOCAL (symp))
       *punt = 1;

      if (SF_GET_FUNCTION (symp))
       symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
    }

  /* Double check weak symbols.  */
  if (S_IS_WEAK (symp) && S_IS_COMMON (symp))
    as_bad (_("Symbol `%s' can not be both weak and common"),
           S_GET_NAME (symp));

  if (SF_GET_TAG (symp))
    last_tagP = symp;
  else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
    next_set_end = last_tagP;

#ifdef OBJ_XCOFF
  /* This is pretty horrible, but we have to set *punt correctly in
     order to call SA_SET_SYM_ENDNDX correctly.  */
  if (! symbol_used_in_reloc_p (symp)
      && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
         || (! (S_IS_EXTERNAL (symp) || S_IS_WEAK (symp))
             && ! symbol_get_tc (symp)->output
             && S_GET_STORAGE_CLASS (symp) != C_FILE)))
    *punt = 1;
#endif

  if (set_end != (symbolS *) NULL
      && ! *punt
      && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
         || (S_IS_DEFINED (symp)
             && ! S_IS_COMMON (symp)
             && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
    {
      SA_SET_SYM_ENDNDX (set_end, symp);
      set_end = NULL;
    }

  if (next_set_end != NULL)
    {
      if (set_end != NULL)
       as_warn ("Warning: internal error: forgetting to set endndx of %s",
               S_GET_NAME (set_end));
      set_end = next_set_end;
    }

#ifndef OBJ_XCOFF
  if (! *punt
      && S_GET_STORAGE_CLASS (symp) == C_FCN
      && streq (S_GET_NAME (symp), ".bf"))
    {
      if (coff_last_bf != NULL)
       SA_SET_SYM_ENDNDX (coff_last_bf, symp);
      coff_last_bf = symp;
    }
#endif
  if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
    {
      int i;
      struct line_no *lptr;
      alent *l;

      lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
      for (i = 0; lptr; lptr = lptr->next)
       i++;
      lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;

      /* We need i entries for line numbers, plus 1 for the first
        entry which BFD will override, plus 1 for the last zero
        entry (a marker for BFD).  */
      l = xmalloc ((i + 2) * sizeof (* l));
      coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
      l[i + 1].line_number = 0;
      l[i + 1].u.sym = NULL;
      for (; i > 0; i--)
       {
         if (lptr->frag)
           lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
         l[i] = lptr->l;
         lptr = lptr->next;
       }
    }
}

Here is the call graph for this function:

void coff_obj_read_begin_hook ( void  )

Definition at line 1145 of file obj-coff.c.

{
  /* These had better be the same.  Usually 18 bytes.  */
  know (sizeof (SYMENT) == sizeof (AUXENT));
  know (SYMESZ == AUXESZ);
  tag_init ();
}

Here is the call graph for this function:

void coff_obj_symbol_clone_hook ( symbolS *  newsymP,
symbolS *  orgsymP 
)

Definition at line 333 of file obj-coff.c.

{
  long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
  combined_entry_type * s = xmalloc (sz);

  memcpy (s, coffsymbol (symbol_get_bfdsym (orgsymP))->native, sz);
  coffsymbol (symbol_get_bfdsym (newsymP))->native = s;

  SF_SET (newsymP, SF_GET (orgsymP));
}

Here is the call graph for this function:

void coff_obj_symbol_new_hook ( symbolS *  symbolP)

Definition at line 313 of file obj-coff.c.

{
  long   sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
  char * s  = xmalloc (sz);

  memset (s, 0, sz);
  coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;

  S_SET_DATA_TYPE (symbolP, T_NULL);
  S_SET_STORAGE_CLASS (symbolP, 0);
  S_SET_NUMBER_AUXILIARY (symbolP, 0);

  if (S_IS_STRING (symbolP))
    SF_SET_STRING (symbolP);

  if (S_IS_LOCAL (symbolP))
    SF_SET_LOCAL (symbolP);
}

Here is the call graph for this function:

static void coff_pop_insert ( void  ) [static]

Definition at line 1813 of file obj-coff.c.

Here is the call graph for this function:

static int coff_separate_stab_sections ( void  ) [static]

Definition at line 1819 of file obj-coff.c.

{
  return 1;
}
static segT fetch_coff_debug_section ( void  ) [static]

Definition at line 177 of file obj-coff.c.

{
  static segT debug_section;

  if (!debug_section)
    {
      const asymbol *s;

      s = bfd_make_debug_symbol (stdoutput, NULL, 0);
      assert (s != 0);
      debug_section = s->section;
    }
  return debug_section;
}

Here is the caller graph for this function:

static void obj_coff_bss ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 164 of file obj-coff.c.

{
  if (*input_line_pointer == '\n')
    subseg_new (".bss", get_absolute_expression ());
  else
    s_lcomm (0);
}

Here is the call graph for this function:

static void obj_coff_def ( int what  ATTRIBUTE_UNUSED) [static]

Definition at line 519 of file obj-coff.c.

{
  char name_end;            /* Char after the end of name.  */
  char *symbol_name;        /* Name of the debug symbol.  */
  char *symbol_name_copy;   /* Temporary copy of the name.  */
  unsigned int symbol_name_length;

  if (def_symbol_in_progress != NULL)
    {
      as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  SKIP_WHITESPACES ();

  symbol_name = input_line_pointer;
  name_end = get_symbol_end ();
  symbol_name_length = strlen (symbol_name);
  symbol_name_copy = xmalloc (symbol_name_length + 1);
  strcpy (symbol_name_copy, symbol_name);
#ifdef tc_canonicalize_symbol_name
  symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
#endif

  /* Initialize the new symbol.  */
  def_symbol_in_progress = symbol_make (symbol_name_copy);
  symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
  S_SET_VALUE (def_symbol_in_progress, 0);

  if (S_IS_STRING (def_symbol_in_progress))
    SF_SET_STRING (def_symbol_in_progress);

  *input_line_pointer = name_end;

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void obj_coff_dim ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 796 of file obj-coff.c.

{
  int dim_index;

  if (def_symbol_in_progress == NULL)
    {
      as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);

  for (dim_index = 0; dim_index < DIMNUM; dim_index++)
    {
      SKIP_WHITESPACES ();
      SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
                     get_absolute_expression ());

      switch (*input_line_pointer)
       {
       case ',':
         input_line_pointer++;
         break;

       default:
         as_warn (_("badly formed .dim directive ignored"));
         /* Fall through.  */
       case '\n':
       case ';':
         dim_index = DIMNUM;
         break;
       }
    }

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void obj_coff_endef ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 560 of file obj-coff.c.

{
  symbolS *symbolP = NULL;

  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;
    }

  /* 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);
      /* Fall through.  */
    case C_FILE:
    case C_TPDEF:
      SF_SET_DEBUG (def_symbol_in_progress);
      S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
      break;

    case C_EFCN:
      SF_SET_LOCAL (def_symbol_in_progress);     /* Do not emit this symbol.  */
      /* Fall through.  */
    case C_BLOCK:
      SF_SET_PROCESS (def_symbol_in_progress);   /* Will need processing before writing.  */
      /* Fall through.  */
    case C_FCN:
      {
       const char *name;

       S_SET_SEGMENT (def_symbol_in_progress, text_section);

       name = S_GET_NAME (def_symbol_in_progress);
       if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
         {
           switch (name[1])
             {
             case 'b':
              /* .bf */
              if (! in_function ())
                as_warn (_("`%s' symbol without preceding function"), name);
              /* Will need relocating.  */
              SF_SET_PROCESS (def_symbol_in_progress);
              clear_function ();
              break;
#ifdef TE_PE
             case 'e':
              /* .ef */
              /* The MS compilers output the actual endline, not the
                 function-relative one... we want to match without
                 changing the assembler input.  */
              SA_SET_SYM_LNNO (def_symbol_in_progress,
                             (SA_GET_SYM_LNNO (def_symbol_in_progress)
                              + coff_line_base));
              break;
#endif
             }
         }
      }
      break;

#ifdef C_AUTOARG
    case C_AUTOARG:
#endif /* C_AUTOARG */
    case C_AUTO:
    case C_REG:
    case C_ARG:
    case C_REGPARM:
    case C_FIELD:

    /* According to the COFF documentation:

       http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html

       A special section number (-2) marks symbolic debugging symbols,
       including structure/union/enumeration tag names, typedefs, and
       the name of the file. A section number of -1 indicates that the
       symbol has a value but is not relocatable. Examples of
       absolute-valued symbols include automatic and register variables,
       function arguments, and .eos symbols.

       But from Ian Lance Taylor:

       http://sources.redhat.com/ml/binutils/2000-08/msg00202.html

       the actual tools all marked them as section -1. So the GNU COFF
       assembler follows historical COFF assemblers.

       However, it causes problems for djgpp

       http://sources.redhat.com/ml/binutils/2000-08/msg00210.html

       By defining STRICTCOFF, a COFF port can make the assembler to
       follow the documented behavior.  */
#ifdef STRICTCOFF
    case C_MOS:
    case C_MOE:
    case C_MOU:
    case C_EOS:
#endif
      SF_SET_DEBUG (def_symbol_in_progress);
      S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
      break;

#ifndef STRICTCOFF
    case C_MOS:
    case C_MOE:
    case C_MOU:
    case C_EOS:
      S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
      break;
#endif

    case C_EXT:
    case C_WEAKEXT:
#ifdef TE_PE
    case C_NT_WEAK:
#endif
    case C_STAT:
    case C_LABEL:
      /* Valid but set somewhere else (s_comm, s_lcomm, colon).  */
      break;

    default:
    case C_USTATIC:
    case C_EXTDEF:
    case C_ULABEL:
      as_warn (_("unexpected storage class %d"),
              S_GET_STORAGE_CLASS (def_symbol_in_progress));
      break;
    }

  /* 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 obj_crawl_symbol_chain() 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
      || (streq (bfd_get_section_name (stdoutput,
                                   S_GET_SEGMENT (def_symbol_in_progress)),
               "*DEBUG*")
         && !SF_GET_TAG (def_symbol_in_progress))
      || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
      || ! symbol_constant_p (def_symbol_in_progress)
      || (symbolP = symbol_find (S_GET_NAME (def_symbol_in_progress))) == NULL
      || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
    {
      /* 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);
       }
    }
  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);
      symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);

      def_symbol_in_progress = symbolP;

      if (SF_GET_FUNCTION (def_symbol_in_progress)
         || SF_GET_TAG (def_symbol_in_progress)
         || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
       {
         /* For functions, and tags, and static symbols, 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 (SF_GET_TAG (def_symbol_in_progress))
    {
      symbolS *oldtag;

      oldtag = symbol_find (S_GET_NAME (def_symbol_in_progress));
      if (oldtag == NULL || ! SF_GET_TAG (oldtag))
       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));
      set_function (def_symbol_in_progress);
      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);

    }

  def_symbol_in_progress = NULL;
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void obj_coff_ident ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 479 of file obj-coff.c.

{
  segT current_seg = now_seg;
  subsegT current_subseg = now_subseg;

#ifdef TE_PE
  {
    segT sec;

    /* We could put it in .comment, but that creates an extra section
       that shouldn't be loaded into memory, which requires linker
       changes...  For now, until proven otherwise, use .rdata.  */
    sec = subseg_new (".rdata$zzz", 0);
    bfd_set_section_flags (stdoutput, sec,
                        ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA)
                         & bfd_applicable_section_flags (stdoutput)));
  }
#else
  subseg_new (".comment", 0);
#endif

  stringer (1);
  subseg_set (current_seg, current_subseg);
}

Here is the call graph for this function:

Definition at line 1732 of file obj-coff.c.

{
  char *file;
  char *p;
  char *stabstr_name;
  unsigned int stroff;

  /* Make space for this first symbol.  */
  p = frag_more (12);
  /* Zero it out.  */
  memset (p, 0, 12);
  as_where (&file, (unsigned int *) NULL);
  stabstr_name = xmalloc (strlen (seg->name) + 4);
  strcpy (stabstr_name, seg->name);
  strcat (stabstr_name, "str");
  stroff = get_stab_string_offset (file, stabstr_name);
  know (stroff == 1);
  md_number_to_chars (p, stroff, 4);
}

Here is the call graph for this function:

static void obj_coff_line ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 835 of file obj-coff.c.

{
  int this_base;

  if (def_symbol_in_progress == NULL)
    {
      /* Probably stabs-style line?  */
      obj_coff_ln (0);
      return;
    }

  this_base = get_absolute_expression ();
  if (streq (".bf", S_GET_NAME (def_symbol_in_progress)))
    coff_line_base = this_base;

  S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
  SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);

  demand_empty_rest_of_line ();

#ifndef NO_LISTING
  if (streq (".bf", S_GET_NAME (def_symbol_in_progress)))
    {
      extern int listing;

      if (listing)
       listing_source_line ((unsigned int) this_base);
    }
#endif
}

Here is the call graph for this function:

static void obj_coff_ln ( int  appline) [static]

Definition at line 392 of file obj-coff.c.

{
  int l;

  if (! appline && def_symbol_in_progress != NULL)
    {
      as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  l = get_absolute_expression ();

  /* If there is no lineno symbol, treat a .ln
     directive as if it were a .appline directive.  */
  if (appline || current_lineno_sym == NULL)
    new_logical_line ((char *) NULL, l - 1);
  else
    add_lineno (frag_now, frag_now_fix (), l);

#ifndef NO_LISTING
  {
    extern int listing;

    if (listing)
      {
       if (! appline)
         l += coff_line_base - 1;
       listing_source_line (l);
      }
  }
#endif

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void obj_coff_loc ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 432 of file obj-coff.c.

{
  int lineno;

  /* FIXME: Why do we need this check?  We need it for ECOFF, but why
     do we need it for COFF?  */
  if (now_seg != text_section)
    {
      as_warn (_(".loc outside of .text"));
      demand_empty_rest_of_line ();
      return;
    }

  if (def_symbol_in_progress != NULL)
    {
      as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  /* Skip the file number.  */
  SKIP_WHITESPACE ();
  get_absolute_expression ();
  SKIP_WHITESPACE ();

  lineno = get_absolute_expression ();

#ifndef NO_LISTING
  {
    extern int listing;

    if (listing)
      {
       lineno += coff_line_base - 1;
       listing_source_line (lineno);
      }
  }
#endif

  demand_empty_rest_of_line ();

  add_lineno (frag_now, frag_now_fix (), lineno);
}

Here is the call graph for this function:

static void obj_coff_scl ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 882 of file obj-coff.c.

{
  if (def_symbol_in_progress == NULL)
    {
      as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void obj_coff_section ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1486 of file obj-coff.c.

{
  /* Strip out the section name.  */
  char *section_name;
  char c;
  char *name;
  unsigned int exp;
  flagword flags, oldflags;
  asection *sec;

  if (flag_mri)
    {
      char type;

      s_mri_sect (&type);
      return;
    }

  section_name = input_line_pointer;
  c = get_symbol_end ();

  name = xmalloc (input_line_pointer - section_name + 1);
  strcpy (name, section_name);

  *input_line_pointer = c;

  SKIP_WHITESPACE ();

  exp = 0;
  flags = SEC_NO_FLAGS;

  if (*input_line_pointer == ',')
    {
      ++input_line_pointer;
      SKIP_WHITESPACE ();
      if (*input_line_pointer != '"')
       exp = get_absolute_expression ();
      else
       {
         unsigned char attr;
         int readonly_removed = 0;
         int load_removed = 0;

         while (attr = *++input_line_pointer,
               attr != '"'
               && ! is_end_of_line[attr])
           {
             switch (attr)
              {
              case 'b':
                /* Uninitialised data section.  */
                flags |= SEC_ALLOC;
                flags &=~ SEC_LOAD;
                break;

              case 'n':
                /* Section not loaded.  */
                flags &=~ SEC_LOAD;
                flags |= SEC_NEVER_LOAD;
                load_removed = 1;
                break;

              case 's':
                /* Shared section.  */
                flags |= SEC_COFF_SHARED;
                /* Fall through.  */
              case 'd':
                /* Data section.  */
                flags |= SEC_DATA;
                if (! load_removed)
                  flags |= SEC_LOAD;
                flags &=~ SEC_READONLY;
                break;

              case 'w':
                /* Writable section.  */
                flags &=~ SEC_READONLY;
                readonly_removed = 1;
                break;

              case 'a':
                /* Ignore.  Here for compatibility with ELF.  */
                break;

              case 'r': /* Read-only section.  Implies a data section.  */
                readonly_removed = 0;
                /* Fall through.  */
              case 'x': /* Executable section.  */
                /* If we are setting the 'x' attribute or if the 'r'
                   attribute is being used to restore the readonly status
                   of a code section (eg "wxr") then set the SEC_CODE flag,
                   otherwise set the SEC_DATA flag.  */
                flags |= (attr == 'x' || (flags & SEC_CODE) ? SEC_CODE : SEC_DATA);
                if (! load_removed)
                  flags |= SEC_LOAD;
                /* Note - the READONLY flag is set here, even for the 'x'
                   attribute in order to be compatible with the MSVC
                   linker.  */
                if (! readonly_removed)
                  flags |= SEC_READONLY;
                break;

              case 'i': /* STYP_INFO */
              case 'l': /* STYP_LIB */
              case 'o': /* STYP_OVER */
                as_warn (_("unsupported section attribute '%c'"), attr);
                break;

              default:
                as_warn (_("unknown section attribute '%c'"), attr);
                break;
              }
           }
         if (attr == '"')
           ++input_line_pointer;
       }
    }

  sec = subseg_new (name, (subsegT) exp);

  oldflags = bfd_get_section_flags (stdoutput, sec);
  if (oldflags == SEC_NO_FLAGS)
    {
      /* Set section flags for a new section just created by subseg_new.
         Provide a default if no flags were parsed.  */
      if (flags == SEC_NO_FLAGS)
       flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;

#ifdef COFF_LONG_SECTION_NAMES
      /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
         sections so adjust_reloc_syms in write.c will correctly handle
         relocs which refer to non-local symbols in these sections.  */
      if (strneq (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1))
       flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
#endif

      if (! bfd_set_section_flags (stdoutput, sec, flags))
       as_warn (_("error setting flags for \"%s\": %s"),
               bfd_section_name (stdoutput, sec),
               bfd_errmsg (bfd_get_error ()));
    }
  else if (flags != SEC_NO_FLAGS)
    {
      /* This section's attributes have already been set.  Warn if the
         attributes don't match.  */
      flagword matchflags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
                          | SEC_DATA | SEC_COFF_SHARED | SEC_NEVER_LOAD);
      if ((flags ^ oldflags) & matchflags)
       as_warn (_("Ignoring changed section attributes for %s"), name);
    }

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void obj_coff_size ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 867 of file obj-coff.c.

Here is the call graph for this function:

static void obj_coff_tag ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 896 of file obj-coff.c.

{
  char *symbol_name;
  char name_end;

  if (def_symbol_in_progress == NULL)
    {
      as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
  symbol_name = input_line_pointer;
  name_end = get_symbol_end ();

#ifdef tc_canonicalize_symbol_name
  symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif

  /* Assume that the symbol referred to by .tag is always defined.
     This was a bad assumption.  I've added find_or_make. xoxorich.  */
  SA_SET_SYM_TAGNDX (def_symbol_in_progress,
                   tag_find_or_make (symbol_name));
  if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
    as_warn (_("tag not found for .tag %s"), symbol_name);

  SF_SET_TAGGED (def_symbol_in_progress);
  *input_line_pointer = name_end;

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void obj_coff_type ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 930 of file obj-coff.c.

Here is the call graph for this function:

static void obj_coff_val ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 949 of file obj-coff.c.

{
  if (def_symbol_in_progress == NULL)
    {
      as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
      demand_empty_rest_of_line ();
      return;
    }

  if (is_name_beginner (*input_line_pointer))
    {
      char *symbol_name = input_line_pointer;
      char name_end = get_symbol_end ();

#ifdef tc_canonicalize_symbol_name
  symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif
      if (streq (symbol_name, "."))
       {
         /* If the .val is != from the .def (e.g. statics).  */
         symbol_set_frag (def_symbol_in_progress, frag_now);
         S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
       }
      else if (! streq (S_GET_NAME (def_symbol_in_progress), symbol_name))
       {
         expressionS exp;

         exp.X_op = O_symbol;
         exp.X_add_symbol = symbol_find_or_make (symbol_name);
         exp.X_op_symbol = NULL;
         exp.X_add_number = 0;
         symbol_set_value_expression (def_symbol_in_progress, &exp);

         /* If the segment is undefined when the forward reference is
            resolved, then copy the segment id from the forward
            symbol.  */
         SF_SET_GET_SEGMENT (def_symbol_in_progress);

         /* FIXME: gcc can generate address expressions here in
            unusual cases (search for "obscure" in sdbout.c).  We
            just ignore the offset here, thus generating incorrect
            debugging information.  We ignore the rest of the line
            just below.  */
       }
      /* Otherwise, it is the name of a non debug symbol and its value
         will be calculated later.  */
      *input_line_pointer = name_end;
    }
  else
    {
      S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
    }

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void obj_coff_weak ( int ignore  ATTRIBUTE_UNUSED) [static]

Definition at line 1108 of file obj-coff.c.

{
  char *name;
  int c;
  symbolS *symbolP;

  do
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      if (*name == 0)
       {
         as_warn (_("badly formed .weak directive ignored"));
         ignore_rest_of_line ();
         return;
       }
      c = 0;
      symbolP = symbol_find_or_make (name);
      *input_line_pointer = c;
      SKIP_WHITESPACE ();
      S_SET_WEAK (symbolP);

      if (c == ',')
       {
         input_line_pointer++;
         SKIP_WHITESPACE ();
         if (*input_line_pointer == '\n')
           c = '\n';
       }

    }
  while (c == ',');

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static int S_GET_DATA_TYPE ( symbolS *  sym) [static]

Definition at line 215 of file obj-coff.c.

{
  return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int S_GET_STORAGE_CLASS ( symbolS *  sym)

Definition at line 228 of file obj-coff.c.

{
  return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int S_SET_DATA_TYPE ( symbolS *  sym,
int  val 
)

Definition at line 221 of file obj-coff.c.

{
  coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
  return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int S_SET_STORAGE_CLASS ( symbolS *  sym,
int  val 
)

Definition at line 234 of file obj-coff.c.

{
  coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
  return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SA_SET_SYM_ENDNDX ( symbolS *  sym,
symbolS *  val 
)

Definition at line 193 of file obj-coff.c.

{
  combined_entry_type *entry, *p;

  entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
  p = coffsymbol (symbol_get_bfdsym (val))->native;
  entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
  entry->fix_end = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void SA_SET_SYM_TAGNDX ( symbolS *  sym,
symbolS *  val 
) [static]

Definition at line 204 of file obj-coff.c.

{
  combined_entry_type *entry, *p;

  entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
  p = coffsymbol (symbol_get_bfdsym (val))->native;
  entry->u.auxent.x_sym.x_tagndx.p = p;
  entry->fix_tag = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static stack* stack_init ( unsigned long  chunk_size,
unsigned long  element_size 
) [static]

Definition at line 70 of file obj-coff.c.

{
  stack *st;

  st = malloc (sizeof (* st));
  if (!st)
    return NULL;
  st->data = malloc (chunk_size);
  if (!st->data)
    {
      free (st);
      return NULL;
    }
  st->pointer = 0;
  st->size = chunk_size;
  st->chunk_size = chunk_size;
  st->element_size = element_size;
  return st;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* stack_pop ( stack st) [static]

Definition at line 106 of file obj-coff.c.

{
  if (st->pointer < st->element_size)
    {
      st->pointer = 0;
      return NULL;
    }
  st->pointer -= st->element_size;
  return st->data + st->pointer;
}

Here is the caller graph for this function:

static char* stack_push ( stack st,
char *  element 
) [static]

Definition at line 92 of file obj-coff.c.

{
  if (st->pointer + st->element_size >= st->size)
    {
      st->size += st->chunk_size;
      if ((st->data = xrealloc (st->data, st->size)) == NULL)
       return NULL;
    }
  memcpy (st->data + st->pointer, element, st->element_size);
  st->pointer += st->element_size;
  return st->data + st->pointer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static symbolS* tag_find ( char *  name) [static]

Definition at line 138 of file obj-coff.c.

{
  return (symbolS *) hash_find (tag_hash, name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static symbolS* tag_find_or_make ( char *  name) [static]

Definition at line 144 of file obj-coff.c.

{
  symbolS *symbolP;

  if ((symbolP = tag_find (name)) == NULL)
    {
      symbolP = symbol_new (name, undefined_section,
                         0, &zero_address_frag);

      tag_insert (S_GET_NAME (symbolP), symbolP);
      symbol_table_insert (symbolP);
    }

  return symbolP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void tag_init ( void  ) [static]

Definition at line 122 of file obj-coff.c.

{
  tag_hash = hash_new ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void tag_insert ( const char *  name,
symbolS *  symbolP 
) [static]

Definition at line 128 of file obj-coff.c.

{
  const char *error_string;

  if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
    as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
             name, error_string);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

symbolS* coff_last_bf [static]

Definition at line 1155 of file obj-coff.c.

Definition at line 1153 of file obj-coff.c.

Definition at line 302 of file obj-coff.c.

Definition at line 350 of file obj-coff.c.

const pseudo_typeS coff_pseudo_table[]

Definition at line 1775 of file obj-coff.c.

symbolS* current_lineno_sym [static]

Definition at line 347 of file obj-coff.c.

symbolS* def_symbol_in_progress [static]

Definition at line 50 of file obj-coff.c.

Definition at line 557 of file obj-coff.c.

symbolS* line_fsym [static]

Definition at line 305 of file obj-coff.c.

struct line_no* line_nos [static]

Definition at line 348 of file obj-coff.c.

Definition at line 119 of file obj-coff.c.