Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
read.c File Reference
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "sb.h"
#include "macro.h"
#include "obstack.h"
#include "ecoff.h"
#include "dw2gencfi.h"

Go to the source code of this file.

Defines

#define MASK_CHAR   ((int)(unsigned char) -1)
#define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT   (16)
#define TC_START_LABEL(x, y)   (x == ':')
#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)
#define LEX_AT   0
#define LEX_BR   0
#define LEX_PCT   0
#define LEX_QM   0
#define LEX_HASH   0
#define LEX_DOLLAR   3
#define LEX_TILDE   0
#define TC_ADDRESS_BYTES   address_bytes
#define md_pop_insert()   pop_insert(md_pseudo_table)
#define obj_pop_insert()   pop_insert(obj_pseudo_table)
#define cfi_pop_insert()   pop_insert(cfi_pseudo_table)
#define HANDLE_CONDITIONAL_ASSEMBLY()
#define ALIGN_LIMIT   (stdoutput->arch_info->bits_per_address - 1)
#define BSD_FILL_SIZE_CROCK_8   (8)
#define BSD_FILL_SIZE_CROCK_4   (4)
#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES)   expression (EXP)

Functions

static void do_s_func (int end_p, const char *default_prefix)
static void do_align (int, char *, int, int)
static void s_align (int, int)
static void s_altmacro (int)
static void s_bad_end (int)
static void s_reloc (int)
static int hex_float (int, char *)
static segT get_known_segmented_expression (expressionS *expP)
static void pobegin (void)
static int get_line_sb (sb *)
static void generate_file_debug (void)
static char * _find_end_of_line (char *, int, int)
void read_begin (void)
static int address_bytes (void)
static offsetT get_absolute_expr (expressionS *exp)
offsetT get_absolute_expression (void)
void pop_insert (const pseudo_typeS *table)
static int scrub_from_string (char *buf, int buflen)
static int try_macro (char term, const char *line)
void read_a_source_file (char *name)
static void convert_to_bignum (expressionS *exp)
char * mri_comment_field (char *stopcp)
void mri_comment_end (char *stop, int stopc)
void s_abort (int ignore ATTRIBUTE_UNUSED)
void s_align_bytes (int arg)
void s_align_ptwo (int arg)
symbolS * s_comm_internal (int param, symbolS *(*comm_parse_extra)(int, symbolS *, addressT))
void s_comm (int ignore)
void s_mri_common (int small ATTRIBUTE_UNUSED)
void s_data (int ignore ATTRIBUTE_UNUSED)
void s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
void s_app_file (int appfile)
static int get_linefile_number (int *flag)
void s_app_line (int appline)
void s_end (int ignore ATTRIBUTE_UNUSED)
void s_err (int ignore ATTRIBUTE_UNUSED)
void s_errwarn (int err)
void s_fail (int ignore ATTRIBUTE_UNUSED)
void s_fill (int ignore ATTRIBUTE_UNUSED)
void s_globl (int ignore ATTRIBUTE_UNUSED)
void s_irp (int irpc)
void s_linkonce (int ignore ATTRIBUTE_UNUSED)
void bss_alloc (symbolS *symbolP, addressT size, int align)
offsetT parse_align (int align_bytes)
symbolS * s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
void s_lcomm (int needs_align)
void s_lcomm_bytes (int needs_align)
void s_lsym (int ignore ATTRIBUTE_UNUSED)
void s_macro (int ignore ATTRIBUTE_UNUSED)
void s_mexit (int ignore ATTRIBUTE_UNUSED)
void s_mri (int ignore ATTRIBUTE_UNUSED)
static void do_org (segT segment, expressionS *exp, int fill)
void s_org (int ignore ATTRIBUTE_UNUSED)
void s_mri_sect (char *type ATTRIBUTE_UNUSED)
void s_print (int ignore ATTRIBUTE_UNUSED)
void s_purgem (int ignore ATTRIBUTE_UNUSED)
void s_rept (int ignore ATTRIBUTE_UNUSED)
void do_repeat (int count, const char *start, const char *end)
void end_repeat (int extra)
static void assign_symbol (char *name, int mode)
void s_set (int equiv)
void s_space (int mult)
void s_float_space (int float_type)
void s_struct (int ignore ATTRIBUTE_UNUSED)
void s_text (int ignore ATTRIBUTE_UNUSED)
void s_weakref (int ignore ATTRIBUTE_UNUSED)
void demand_empty_rest_of_line (void)
void ignore_rest_of_line (void)
static void set_zero_frag (symbolS *symbolP)
void pseudo_set (symbolS *symbolP)
void do_parse_cons_expression (expressionS *exp, int nbytes ATTRIBUTE_UNUSED)
static void cons_worker (register int nbytes, int rva)
void cons (int size)
void s_rva (int size)
void s_reloc (int ignore ATTRIBUTE_UNUSED)
void emit_expr (expressionS *exp, unsigned int nbytes)
void float_cons (register int float_type)
static int sizeof_sleb128 (offsetT value)
static int sizeof_uleb128 (valueT value)
int sizeof_leb128 (valueT value, int sign)
static int output_sleb128 (char *p, offsetT value)
static int output_uleb128 (char *p, valueT value)
int output_leb128 (char *p, valueT value, int sign)
static int output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
static int output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
static int output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
static void emit_leb128_expr (expressionS *exp, int sign)
void s_leb128 (int sign)
void stringer (register int append_zero)
unsigned int next_char_of_string (void)
static segT get_segmented_expression (register expressionS *expP)
static segT get_known_segmented_expression (register expressionS *expP)
char get_absolute_expression_and_terminator (long *val_pointer)
char * demand_copy_C_string (int *len_pointer)
char * demand_copy_string (int *lenP)
int is_it_end_of_statement (void)
void equals (char *sym_name, int reassign)
void s_incbin (int x ATTRIBUTE_UNUSED)
void s_include (int arg ATTRIBUTE_UNUSED)
void add_include_dir (char *path)
void generate_lineno_debug (void)
void s_func (int end_p)
void s_ignore (int arg ATTRIBUTE_UNUSED)
void read_print_statistics (FILE *file)
void input_scrub_insert_line (const char *line)
void input_scrub_insert_file (char *path)
static char * _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
char * find_end_of_line (char *s, int mri_string)

Variables

char * input_line_pointer
char lex_type [256]
char is_end_of_line [256]
char original_case_string [128]
static char * buffer
static char * buffer_limit
int target_big_endian = TARGET_BYTES_BIG_ENDIAN
char ** include_dirs
int include_dir_count
int include_dir_maxlen = 1
struct broken_wordbroken_words
int new_broken_words
addressT abs_section_offset
symbolS * line_label
symbolS * mri_common_symbol
static int mri_pending_align
static struct hash_controlpo_hash
static const pseudo_typeS potable []
static int pop_override_ok = 0
static const char * pop_table_name
static char * scrub_string
static char * scrub_string_end

Define Documentation

#define ALIGN_LIMIT   (stdoutput->arch_info->bits_per_address - 1)

Definition at line 1280 of file read.c.

#define BSD_FILL_SIZE_CROCK_4   (4)
#define BSD_FILL_SIZE_CROCK_8   (8)

Definition at line 492 of file read.c.

Value:
if (ignore_input ())                                           \
    {                                                          \
      char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri);      \
      input_line_pointer = (input_line_pointer <= buffer_limit        \
                         && eol >= buffer_limit)               \
                        ? buffer_limit                         \
                        : eol + 1;                             \
      continue;                                                       \
    }

Definition at line 520 of file read.c.

#define LEX_AT   0

Definition at line 74 of file read.c.

#define LEX_BR   0

Definition at line 79 of file read.c.

#define LEX_DOLLAR   3

Definition at line 99 of file read.c.

#define LEX_HASH   0

Definition at line 95 of file read.c.

#define LEX_PCT   0

Definition at line 84 of file read.c.

#define LEX_QM   0

Definition at line 89 of file read.c.

#define LEX_TILDE   0

Definition at line 104 of file read.c.

#define MASK_CHAR   ((int)(unsigned char) -1)

Definition at line 26 of file read.c.

Definition at line 30 of file read.c.

Definition at line 484 of file read.c.

Definition at line 488 of file read.c.

Definition at line 247 of file read.c.

#define TC_IMPLICIT_LCOMM_ALIGNMENT (   SIZE,
  P2VAR 
)
Value:
do                                                      \
    {                                                   \
      if ((SIZE) >= 8)                                         \
       (P2VAR) = 3;                                     \
      else if ((SIZE) >= 4)                             \
       (P2VAR) = 2;                                     \
      else if ((SIZE) >= 2)                             \
       (P2VAR) = 1;                                     \
      else                                              \
       (P2VAR) = 0;                                     \
    }                                                   \
  while (0)

Definition at line 50 of file read.c.

#define TC_PARSE_CONS_EXPRESSION (   EXP,
  NBYTES 
)    expression (EXP)

Definition at line 3578 of file read.c.

#define TC_START_LABEL (   x,
  y 
)    (x == ':')

Definition at line 45 of file read.c.


Function Documentation

static char* _find_end_of_line ( char *  ,
int  ,
int   
) [static]

Here is the caller graph for this function:

static char* _find_end_of_line ( char *  s,
int  mri_string,
int insn  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5601 of file read.c.

{
  char inquote = '\0';
  int inescape = 0;

  while (!is_end_of_line[(unsigned char) *s]
        || (inquote && !ISCNTRL (*s))
        || (inquote == '\'' && flag_mri)
#ifdef TC_EOL_IN_INSN
        || (insn && TC_EOL_IN_INSN (s))
#endif
       )
    {
      if (mri_string && *s == '\'')
       inquote ^= *s;
      else if (inescape)
       inescape = 0;
      else if (*s == '\\')
       inescape = 1;
      else if (!inquote
              ? *s == '"'
#ifdef TC_SINGLE_QUOTE_STRINGS
               || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
#endif
              : *s == inquote)
       inquote ^= *s;
      ++s;
    }
  if (inquote)
    as_warn (_("missing closing `%c'"), inquote);
  if (inescape)
    as_warn (_("stray `\\'"));
  return s;
}

Here is the call graph for this function:

void add_include_dir ( char *  path)

Definition at line 5405 of file read.c.

{
  int i;

  if (include_dir_count == 0)
    {
      include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
      include_dirs[0] = ".";       /* Current dir.  */
      include_dir_count = 2;
    }
  else
    {
      include_dir_count++;
      include_dirs =
       (char **) realloc (include_dirs,
                        include_dir_count * sizeof (*include_dirs));
    }

  include_dirs[include_dir_count - 1] = path;    /* New one.  */

  i = strlen (path);
  if (i > include_dir_maxlen)
    include_dir_maxlen = i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int address_bytes ( void  ) [inline, static]

Definition at line 250 of file read.c.

{
  /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
     contain an address.  */
  int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
  n |= n >> 1;
  n |= n >> 2;
  n += 1;
  return n;
}
static void assign_symbol ( char *  name,
int  mode 
) [static]

Definition at line 2845 of file read.c.

{
  symbolS *symbolP;

  if (name[0] == '.' && name[1] == '\0')
    {
      /* Turn '. = mumble' into a .org mumble.  */
      segT segment;
      expressionS exp;

      segment = get_known_segmented_expression (&exp);

      if (!need_pass_2)
       do_org (segment, &exp, 0);

      return;
    }

  if ((symbolP = symbol_find (name)) == NULL
      && (symbolP = md_undefined_symbol (name)) == NULL)
    {
      symbolP = symbol_find_or_make (name);
#ifndef NO_LISTING
      /* When doing symbol listings, play games with dummy fragments living
        outside the normal fragment chain to record the file and line info
        for this symbol.  */
      if (listing & LISTING_SYMBOLS)
       {
         extern struct list_info_struct *listing_tail;
         fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
         dummy_frag->line = listing_tail;
         dummy_frag->fr_symbol = symbolP;
         symbol_set_frag (symbolP, dummy_frag);
       }
#endif
#ifdef OBJ_COFF
      /* "set" symbols are local unless otherwise specified.  */
      SF_SET_LOCAL (symbolP);
#endif
    }

  if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
    {
      /* Permit register names to be redefined.  */
      if ((mode != 0 || !S_IS_VOLATILE (symbolP))
         && S_GET_SEGMENT (symbolP) != reg_section)
       {
         as_bad (_("symbol `%s' is already defined"), name);
         symbolP = symbol_clone (symbolP, 0);
       }
      /* If the symbol is volatile, copy the symbol and replace the
        original with the copy, so that previous uses of the symbol will
        retain the value of the symbol at the point of use.  */
      else if (S_IS_VOLATILE (symbolP))
       symbolP = symbol_clone (symbolP, 1);
    }

  if (mode == 0)
    S_SET_VOLATILE (symbolP);
  else if (mode < 0)
    S_SET_FORWARD_REF (symbolP);

  pseudo_set (symbolP);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bss_alloc ( symbolS *  symbolP,
addressT  size,
int  align 
)

Definition at line 2150 of file read.c.

{
  char *pfrag;
  segT current_seg = now_seg;
  subsegT current_subseg = now_subseg;
  segT bss_seg = bss_section;

#if defined (TC_MIPS) || defined (TC_ALPHA)
  if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
      || OUTPUT_FLAVOR == bfd_target_elf_flavour)
    {
      /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
      if (size <= bfd_get_gp_size (stdoutput))
       {
         bss_seg = subseg_new (".sbss", 1);
         seg_info (bss_seg)->bss = 1;
         if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
           as_warn (_("error setting flags for \".sbss\": %s"),
                   bfd_errmsg (bfd_get_error ()));
       }
    }
#endif
  subseg_set (bss_seg, 1);

  if (align)
    {
      record_alignment (bss_seg, align);
      frag_align (align, 0, 0);
    }

  /* Detach from old frag.  */
  if (S_GET_SEGMENT (symbolP) == bss_seg)
    symbol_get_frag (symbolP)->fr_symbol = NULL;

  symbol_set_frag (symbolP, frag_now);
  pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
  *pfrag = 0;

#ifdef S_SET_SIZE
  S_SET_SIZE (symbolP, size);
#endif
  S_SET_SEGMENT (symbolP, bss_seg);

#ifdef OBJ_COFF
  /* The symbol may already have been created with a preceding
     ".globl" directive -- be careful not to step on storage class
     in that case.  Otherwise, set it to static.  */
  if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
    S_SET_STORAGE_CLASS (symbolP, C_STAT);
#endif /* OBJ_COFF */

  subseg_set (current_seg, current_subseg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cons ( int  size)

Definition at line 3663 of file read.c.

{
  cons_worker (size, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cons_worker ( register int  nbytes,
int  rva 
) [static]

Definition at line 3594 of file read.c.

{
  int c;
  expressionS exp;
  char *stop = NULL;
  char stopc = 0;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  if (is_it_end_of_statement ())
    {
      demand_empty_rest_of_line ();
      if (flag_mri)
       mri_comment_end (stop, stopc);
      return;
    }

#ifdef TC_ADDRESS_BYTES
  if (nbytes == 0)
    nbytes = TC_ADDRESS_BYTES ();
#endif

#ifdef md_cons_align
  md_cons_align (nbytes);
#endif

  c = 0;
  do
    {
#ifdef TC_M68K
      if (flag_m68k_mri)
       parse_mri_cons (&exp, (unsigned int) nbytes);
      else
#endif
       TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);

      if (rva)
       {
         if (exp.X_op == O_symbol)
           exp.X_op = O_symbol_rva;
         else
           as_fatal (_("rva without symbol"));
       }
      emit_expr (&exp, (unsigned int) nbytes);
      ++c;
    }
  while (*input_line_pointer++ == ',');

  /* In MRI mode, after an odd number of bytes, we must align to an
     even word boundary, unless the next instruction is a dc.b, ds.b
     or dcb.b.  */
  if (flag_mri && nbytes == 1 && (c & 1) != 0)
    mri_pending_align = 1;

  input_line_pointer--;            /* Put terminator back into stream.  */

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void convert_to_bignum ( expressionS exp) [static]

Definition at line 1148 of file read.c.

{
  valueT value;
  unsigned int i;

  value = exp->X_add_number;
  for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
    {
      generic_bignum[i] = value & LITTLENUM_MASK;
      value >>= LITTLENUM_NUMBER_OF_BITS;
    }
  /* Add a sequence of sign bits if the top bit of X_add_number is not
     the sign of the original value.  */
  if ((exp->X_add_number < 0) != !exp->X_unsigned)
    generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
  exp->X_op = O_big;
  exp->X_add_number = i;
}

Here is the caller graph for this function:

char* demand_copy_C_string ( int len_pointer)

Definition at line 5127 of file read.c.

{
  register char *s;

  if ((s = demand_copy_string (len_pointer)) != 0)
    {
      register int len;

      for (len = *len_pointer; len > 0; len--)
       {
         if (*s == 0)
           {
             s = 0;
             len = 1;
             *len_pointer = 0;
             as_bad (_("this string may not contain \'\\0\'"));
           }
       }
    }

  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* demand_copy_string ( int lenP)

Definition at line 5154 of file read.c.

{
  register unsigned int c;
  register int len;
  char *retval;

  len = 0;
  SKIP_WHITESPACE ();
  if (*input_line_pointer == '\"')
    {
      input_line_pointer++; /* Skip opening quote.  */

      while (is_a_char (c = next_char_of_string ()))
       {
         obstack_1grow (&notes, c);
         len++;
       }
      /* JF this next line is so demand_copy_C_string will return a
        null terminated string.  */
      obstack_1grow (&notes, '\0');
      retval = obstack_finish (&notes);
    }
  else
    {
      as_bad (_("missing string"));
      retval = NULL;
      ignore_rest_of_line ();
    }
  *lenP = len;
  return (retval);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void demand_empty_rest_of_line ( void  )

Definition at line 3383 of file read.c.

{
  SKIP_WHITESPACE ();
  if (is_end_of_line[(unsigned char) *input_line_pointer])
    input_line_pointer++;
  else
    {
      if (ISPRINT (*input_line_pointer))
       as_bad (_("junk at end of line, first unrecognized character is `%c'"),
               *input_line_pointer);
      else
       as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
               *input_line_pointer);
      ignore_rest_of_line ();
    }
  
  /* Return pointing just after end-of-line.  */
  know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
}

Here is the call graph for this function:

static void do_align ( int  n,
char *  fill,
int  len,
int  max 
) [static]

Definition at line 1230 of file read.c.

{
  if (now_seg == absolute_section)
    {
      if (fill != NULL)
       while (len-- > 0)
         if (*fill++ != '\0')
           {
             as_warn (_("ignoring fill value in absolute section"));
             break;
           }
      fill = NULL;
      len = 0;
    }

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif
#ifdef md_do_align
  md_do_align (n, fill, len, max, just_record_alignment);
#endif

  /* Only make a frag if we HAVE to...  */
  if (n != 0 && !need_pass_2)
    {
      if (fill == NULL)
       {
         if (subseg_text_p (now_seg))
           frag_align_code (n, max);
         else
           frag_align (n, 0, max);
       }
      else if (len <= 1)
       frag_align (n, *fill, max);
      else
       frag_align_pattern (n, fill, len, max);
    }

#ifdef md_do_align
 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
#endif

  record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void do_org ( segT  segment,
expressionS exp,
int  fill 
) [static]

Definition at line 2487 of file read.c.

{
  if (segment != now_seg && segment != absolute_section)
    as_bad (_("invalid segment \"%s\""), segment_name (segment));

  if (now_seg == absolute_section)
    {
      if (fill != 0)
       as_warn (_("ignoring fill value in absolute section"));
      if (exp->X_op != O_constant)
       {
         as_bad (_("only constant offsets supported in absolute section"));
         exp->X_add_number = 0;
       }
      abs_section_offset = exp->X_add_number;
    }
  else
    {
      char *p;
      symbolS *sym = exp->X_add_symbol;
      offsetT off = exp->X_add_number * OCTETS_PER_BYTE;

      if (exp->X_op != O_constant && exp->X_op != O_symbol)
       {
         /* Handle complex expressions.  */
         sym = make_expr_symbol (exp);
         off = 0;
       }

      p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
      *p = fill;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void do_parse_cons_expression ( expressionS exp,
int nbytes  ATTRIBUTE_UNUSED 
)

Definition at line 3583 of file read.c.

{
  TC_PARSE_CONS_EXPRESSION (exp, nbytes);
}

Here is the caller graph for this function:

void do_repeat ( int  count,
const char *  start,
const char *  end 
)

Definition at line 2805 of file read.c.

{
  sb one;
  sb many;

  sb_new (&one);
  if (!buffer_and_nest (start, end, &one, get_line_sb))
    {
      as_bad (_("%s without %s"), start, end);
      return;
    }

  sb_new (&many);
  while (count-- > 0)
    sb_add_sb (&many, &one);

  sb_kill (&one);

  input_scrub_include_sb (&many, input_line_pointer, 1);
  sb_kill (&many);
  buffer_limit = input_scrub_next_buffer (&input_line_pointer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void do_s_func ( int  end_p,
const char *  default_prefix 
) [static]

Definition at line 5478 of file read.c.

{
  /* Record the current function so that we can issue an error message for
     misplaced .func,.endfunc, and also so that .endfunc needs no
     arguments.  */
  static char *current_name;
  static char *current_label;

  if (end_p)
    {
      if (current_name == NULL)
       {
         as_bad (_("missing .func"));
         ignore_rest_of_line ();
         return;
       }

      if (debug_type == DEBUG_STABS)
       stabs_generate_asm_endfunc (current_name, current_label);

      current_name = current_label = NULL;
    }
  else /* ! end_p */
    {
      char *name, *label;
      char delim1, delim2;

      if (current_name != NULL)
       {
         as_bad (_(".endfunc missing for previous .func"));
         ignore_rest_of_line ();
         return;
       }

      name = input_line_pointer;
      delim1 = get_symbol_end ();
      name = xstrdup (name);
      *input_line_pointer = delim1;
      SKIP_WHITESPACE ();
      if (*input_line_pointer != ',')
       {
         if (default_prefix)
           asprintf (&label, "%s%s", default_prefix, name);
         else
           {
             char leading_char = bfd_get_symbol_leading_char (stdoutput);
             /* Missing entry point, use function's name with the leading
               char prepended.  */
             if (leading_char)
              asprintf (&label, "%c%s", leading_char, name);
             else
              label = name;
           }
       }
      else
       {
         ++input_line_pointer;
         SKIP_WHITESPACE ();
         label = input_line_pointer;
         delim2 = get_symbol_end ();
         label = xstrdup (label);
         *input_line_pointer = delim2;
       }

      if (debug_type == DEBUG_STABS)
       stabs_generate_asm_func (name, label);

      current_name = name;
      current_label = label;
    }

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void emit_expr ( expressionS exp,
unsigned int  nbytes 
)

Definition at line 3785 of file read.c.

{
  operatorT op;
  register char *p;
  valueT extra_digit = 0;

  /* Don't do anything if we are going to make another pass.  */
  if (need_pass_2)
    return;

  dot_value = frag_now_fix ();

#ifndef NO_LISTING
#ifdef OBJ_ELF
  /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
     appear as a four byte positive constant in the .line section,
     followed by a 2 byte 0xffff.  Look for that case here.  */
  {
    static int dwarf_line = -1;

    if (strcmp (segment_name (now_seg), ".line") != 0)
      dwarf_line = -1;
    else if (dwarf_line >= 0
            && nbytes == 2
            && exp->X_op == O_constant
            && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
      listing_source_line ((unsigned int) dwarf_line);
    else if (nbytes == 4
            && exp->X_op == O_constant
            && exp->X_add_number >= 0)
      dwarf_line = exp->X_add_number;
    else
      dwarf_line = -1;
  }

  /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
     appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
     AT_sibling (0x12) followed by a four byte address of the sibling
     followed by a 2 byte AT_name (0x38) followed by the name of the
     file.  We look for that case here.  */
  {
    static int dwarf_file = 0;

    if (strcmp (segment_name (now_seg), ".debug") != 0)
      dwarf_file = 0;
    else if (dwarf_file == 0
            && nbytes == 2
            && exp->X_op == O_constant
            && exp->X_add_number == 0x11)
      dwarf_file = 1;
    else if (dwarf_file == 1
            && nbytes == 2
            && exp->X_op == O_constant
            && exp->X_add_number == 0x12)
      dwarf_file = 2;
    else if (dwarf_file == 2
            && nbytes == 4)
      dwarf_file = 3;
    else if (dwarf_file == 3
            && nbytes == 2
            && exp->X_op == O_constant
            && exp->X_add_number == 0x38)
      dwarf_file = 4;
    else
      dwarf_file = 0;

    /* The variable dwarf_file_string tells stringer that the string
       may be the name of the source file.  */
    if (dwarf_file == 4)
      dwarf_file_string = 1;
    else
      dwarf_file_string = 0;
  }
#endif
#endif

  if (check_eh_frame (exp, &nbytes))
    return;

  op = exp->X_op;

  /* Allow `.word 0' in the absolute section.  */
  if (now_seg == absolute_section)
    {
      if (op != O_constant || exp->X_add_number != 0)
       as_bad (_("attempt to store value in absolute section"));
      abs_section_offset += nbytes;
      return;
    }

  /* Handle a negative bignum.  */
  if (op == O_uminus
      && exp->X_add_number == 0
      && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
      && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
    {
      int i;
      unsigned long carry;

      exp = symbol_get_value_expression (exp->X_add_symbol);

      /* Negate the bignum: one's complement each digit and add 1.  */
      carry = 1;
      for (i = 0; i < exp->X_add_number; i++)
       {
         unsigned long next;

         next = (((~(generic_bignum[i] & LITTLENUM_MASK))
                 & LITTLENUM_MASK)
                + carry);
         generic_bignum[i] = next & LITTLENUM_MASK;
         carry = next >> LITTLENUM_NUMBER_OF_BITS;
       }

      /* We can ignore any carry out, because it will be handled by
        extra_digit if it is needed.  */

      extra_digit = (valueT) -1;
      op = O_big;
    }

  if (op == O_absent || op == O_illegal)
    {
      as_warn (_("zero assumed for missing expression"));
      exp->X_add_number = 0;
      op = O_constant;
    }
  else if (op == O_big && exp->X_add_number <= 0)
    {
      as_bad (_("floating point number invalid"));
      exp->X_add_number = 0;
      op = O_constant;
    }
  else if (op == O_register)
    {
      as_warn (_("register value used as expression"));
      op = O_constant;
    }

  p = frag_more ((int) nbytes);

#ifndef WORKING_DOT_WORD
  /* If we have the difference of two symbols in a word, save it on
     the broken_words list.  See the code in write.c.  */
  if (op == O_subtract && nbytes == 2)
    {
      struct broken_word *x;

      x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
      x->next_broken_word = broken_words;
      broken_words = x;
      x->seg = now_seg;
      x->subseg = now_subseg;
      x->frag = frag_now;
      x->word_goes_here = p;
      x->dispfrag = 0;
      x->add = exp->X_add_symbol;
      x->sub = exp->X_op_symbol;
      x->addnum = exp->X_add_number;
      x->added = 0;
      x->use_jump = 0;
      new_broken_words++;
      return;
    }
#endif

  /* If we have an integer, but the number of bytes is too large to
     pass to md_number_to_chars, handle it as a bignum.  */
  if (op == O_constant && nbytes > sizeof (valueT))
    {
      extra_digit = exp->X_unsigned ? 0 : -1;
      convert_to_bignum (exp);
      op = O_big;
    }

  if (op == O_constant)
    {
      register valueT get;
      register valueT use;
      register valueT mask;
      valueT hibit;
      register valueT unmask;

      /* JF << of >= number of bits in the object is undefined.  In
        particular SPARC (Sun 4) has problems.  */
      if (nbytes >= sizeof (valueT))
       {
         mask = 0;
         if (nbytes > sizeof (valueT))
           hibit = 0;
         else
           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
       }
      else
       {
         /* Don't store these bits.  */
         mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
         hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
       }

      unmask = ~mask;              /* Do store these bits.  */

#ifdef NEVER
      "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
      mask = ~(unmask >> 1);       /* Includes sign bit now.  */
#endif

      get = exp->X_add_number;
      use = get & unmask;
      if ((get & mask) != 0
         && ((get & mask) != mask
             || (get & hibit) == 0))
       {             /* Leading bits contain both 0s & 1s.  */
         as_warn (_("value 0x%lx truncated to 0x%lx"),
                 (unsigned long) get, (unsigned long) use);
       }
      /* Put bytes in right order.  */
      md_number_to_chars (p, use, (int) nbytes);
    }
  else if (op == O_big)
    {
      unsigned int size;
      LITTLENUM_TYPE *nums;

      know (nbytes % CHARS_PER_LITTLENUM == 0);

      size = exp->X_add_number * CHARS_PER_LITTLENUM;
      if (nbytes < size)
       {
         as_warn (_("bignum truncated to %d bytes"), nbytes);
         size = nbytes;
       }

      if (target_big_endian)
       {
         while (nbytes > size)
           {
             md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
             nbytes -= CHARS_PER_LITTLENUM;
             p += CHARS_PER_LITTLENUM;
           }

         nums = generic_bignum + size / CHARS_PER_LITTLENUM;
         while (size >= CHARS_PER_LITTLENUM)
           {
             --nums;
             md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
             size -= CHARS_PER_LITTLENUM;
             p += CHARS_PER_LITTLENUM;
           }
       }
      else
       {
         nums = generic_bignum;
         while (size >= CHARS_PER_LITTLENUM)
           {
             md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
             ++nums;
             size -= CHARS_PER_LITTLENUM;
             p += CHARS_PER_LITTLENUM;
             nbytes -= CHARS_PER_LITTLENUM;
           }

         while (nbytes >= CHARS_PER_LITTLENUM)
           {
             md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
             nbytes -= CHARS_PER_LITTLENUM;
             p += CHARS_PER_LITTLENUM;
           }
       }
    }
  else
    {
      memset (p, 0, nbytes);

      /* Now we need to generate a fixS to record the symbol value.  */

#ifdef TC_CONS_FIX_NEW
      TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
#else
      {
       bfd_reloc_code_real_type r;

       switch (nbytes)
         {
         case 1:
           r = BFD_RELOC_8;
           break;
         case 2:
           r = BFD_RELOC_16;
           break;
         case 4:
           r = BFD_RELOC_32;
           break;
         case 8:
           r = BFD_RELOC_64;
           break;
         default:
           as_bad (_("unsupported BFD relocation size %u"), nbytes);
           r = BFD_RELOC_32;
           break;
         }
       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
                   0, r);
      }
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void emit_leb128_expr ( expressionS exp,
int  sign 
) [static]

Definition at line 4749 of file read.c.

{
  operatorT op = exp->X_op;
  unsigned int nbytes;

  if (op == O_absent || op == O_illegal)
    {
      as_warn (_("zero assumed for missing expression"));
      exp->X_add_number = 0;
      op = O_constant;
    }
  else if (op == O_big && exp->X_add_number <= 0)
    {
      as_bad (_("floating point number invalid"));
      exp->X_add_number = 0;
      op = O_constant;
    }
  else if (op == O_register)
    {
      as_warn (_("register value used as expression"));
      op = O_constant;
    }
  else if (op == O_constant
          && sign
          && (exp->X_add_number < 0) != !exp->X_unsigned)
    {
      /* We're outputting a signed leb128 and the sign of X_add_number
        doesn't reflect the sign of the original value.  Convert EXP
        to a correctly-extended bignum instead.  */
      convert_to_bignum (exp);
      op = O_big;
    }

  /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
     a signal that this is leb128 data.  It shouldn't optimize this away.  */
  nbytes = (unsigned int) -1;
  if (check_eh_frame (exp, &nbytes))
    abort ();

  /* Let the backend know that subsequent data may be byte aligned.  */
#ifdef md_cons_align
  md_cons_align (1);
#endif

  if (op == O_constant)
    {
      /* If we've got a constant, emit the thing directly right now.  */

      valueT value = exp->X_add_number;
      int size;
      char *p;

      size = sizeof_leb128 (value, sign);
      p = frag_more (size);
      output_leb128 (p, value, sign);
    }
  else if (op == O_big)
    {
      /* O_big is a different sort of constant.  */

      int size;
      char *p;

      size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
      p = frag_more (size);
      output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
    }
  else
    {
      /* Otherwise, we have to create a variable sized fragment and
        resolve things later.  */

      frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
              make_expr_symbol (exp), 0, (char *) NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void end_repeat ( int  extra)

Definition at line 2837 of file read.c.

Here is the call graph for this function:

void equals ( char *  sym_name,
int  reassign 
)

Definition at line 5200 of file read.c.

{
  char *stop = NULL;
  char stopc = 0;

  input_line_pointer++;
  if (*input_line_pointer == '=')
    input_line_pointer++;
  if (reassign < 0 && *input_line_pointer == '=')
    input_line_pointer++;

  while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
    input_line_pointer++;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);

  if (flag_mri)
    {
      demand_empty_rest_of_line ();
      mri_comment_end (stop, stopc);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* find_end_of_line ( char *  s,
int  mri_string 
)

Definition at line 5637 of file read.c.

{
  return _find_end_of_line (s, mri_string, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void float_cons ( register int  float_type)

Definition at line 4438 of file read.c.

{
  register char *p;
  int length;               /* Number of chars in an object.  */
  register char *err;              /* Error from scanning floating literal.  */
  char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];

  if (is_it_end_of_statement ())
    {
      demand_empty_rest_of_line ();
      return;
    }

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  do
    {
      /* input_line_pointer->1st char of a flonum (we hope!).  */
      SKIP_WHITESPACE ();

      /* Skip any 0{letter} that may be present. Don't even check if the
        letter is legal. Someone may invent a "z" format and this routine
        has no use for such information. Lusers beware: you get
        diagnostics if your input is ill-conditioned.  */
      if (input_line_pointer[0] == '0'
         && ISALPHA (input_line_pointer[1]))
       input_line_pointer += 2;

      /* Accept :xxxx, where the x's are hex digits, for a floating
        point with the exact digits specified.  */
      if (input_line_pointer[0] == ':')
       {
         ++input_line_pointer;
         length = hex_float (float_type, temp);
         if (length < 0)
           {
             ignore_rest_of_line ();
             return;
           }
       }
      else
       {
         err = md_atof (float_type, temp, &length);
         know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
         know (length > 0);
         if (err)
           {
             as_bad (_("bad floating literal: %s"), err);
             ignore_rest_of_line ();
             return;
           }
       }

      if (!need_pass_2)
       {
         int count;

         count = 1;

#ifdef REPEAT_CONS_EXPRESSIONS
         if (*input_line_pointer == ':')
           {
             expressionS count_exp;

             ++input_line_pointer;
             expression (&count_exp);

             if (count_exp.X_op != O_constant
                || count_exp.X_add_number <= 0)
              as_warn (_("unresolvable or nonpositive repeat count; using 1"));
             else
              count = count_exp.X_add_number;
           }
#endif

         while (--count >= 0)
           {
             p = frag_more (length);
             memcpy (p, temp, (unsigned int) length);
           }
       }
      SKIP_WHITESPACE ();
    }
  while (*input_line_pointer++ == ',');

  /* Put terminator back into stream.  */
  --input_line_pointer;
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void generate_file_debug ( void  ) [static]

Definition at line 5433 of file read.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void generate_lineno_debug ( void  )

Definition at line 5442 of file read.c.

{
  switch (debug_type)
    {
    case DEBUG_UNSPECIFIED:
    case DEBUG_NONE:
    case DEBUG_DWARF:
      break;
    case DEBUG_STABS:
      stabs_generate_asm_lineno ();
      break;
    case DEBUG_ECOFF:
      ecoff_generate_asm_lineno ();
      break;
    case DEBUG_DWARF2:
      /* ??? We could here indicate to dwarf2dbg.c that something
        has changed.  However, since there is additional backend
        support that is required (calling dwarf2_emit_insn), we
        let dwarf2dbg.c call as_where on its own.  */
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static offsetT get_absolute_expr ( expressionS exp) [static]

Definition at line 446 of file read.c.

{
  expression_and_evaluate (exp);
  if (exp->X_op != O_constant)
    {
      if (exp->X_op != O_absent)
       as_bad (_("bad or irreducible absolute expression"));
      exp->X_add_number = 0;
    }
  return exp->X_add_number;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 459 of file read.c.

{
  expressionS exp;

  return get_absolute_expr (&exp);
}

Here is the call graph for this function:

Definition at line 5116 of file read.c.

{
  /* FIXME: val_pointer should probably be offsetT *.  */
  *val_pointer = (long) get_absolute_expression ();
  return (*input_line_pointer++);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static segT get_known_segmented_expression ( expressionS expP) [static]

Here is the caller graph for this function:

static segT get_known_segmented_expression ( register expressionS expP) [static]

Definition at line 5093 of file read.c.

{
  register segT retval;

  if ((retval = get_segmented_expression (expP)) == undefined_section)
    {
      /* There is no easy way to extract the undefined symbol from the
        expression.  */
      if (expP->X_add_symbol != NULL
         && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
       as_warn (_("symbol \"%s\" undefined; zero assumed"),
               S_GET_NAME (expP->X_add_symbol));
      else
       as_warn (_("some symbol undefined; zero assumed"));
      retval = absolute_section;
      expP->X_op = O_constant;
      expP->X_add_number = 0;
    }
  know (retval == absolute_section || SEG_NORMAL (retval));
  return (retval);
}

Here is the call graph for this function:

static int get_line_sb ( sb line) [static]

Definition at line 2356 of file read.c.

{
  char *eol;

  if (input_line_pointer[-1] == '\n')
    bump_line_counters ();

  if (input_line_pointer >= buffer_limit)
    {
      buffer_limit = input_scrub_next_buffer (&input_line_pointer);
      if (buffer_limit == 0)
       return 0;
    }

  eol = find_end_of_line (input_line_pointer, flag_m68k_mri);
  sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
  input_line_pointer = eol;

  /* Don't skip multiple end-of-line characters, because that breaks support
     for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
     characters but isn't.  Instead just skip one end of line character and
     return the character skipped so that the caller can re-insert it if
     necessary.   */
  return *input_line_pointer++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_linefile_number ( int flag) [static]

Definition at line 1704 of file read.c.

{
  SKIP_WHITESPACE ();

  if (*input_line_pointer < '0' || *input_line_pointer > '9')
    return 0;

  *flag = get_absolute_expression ();

  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static segT get_segmented_expression ( register expressionS expP) [static]

Definition at line 5075 of file read.c.

{
  register segT retval;

  retval = expression (expP);
  if (expP->X_op == O_illegal
      || expP->X_op == O_absent
      || expP->X_op == O_big)
    {
      as_bad (_("expected address expression"));
      expP->X_op = O_constant;
      expP->X_add_number = 0;
      retval = absolute_section;
    }
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int hex_float ( int  float_type,
char *  bytes 
) [static]

Definition at line 4336 of file read.c.

{
  int length;
  int i;

  switch (float_type)
    {
    case 'f':
    case 'F':
    case 's':
    case 'S':
      length = 4;
      break;

    case 'd':
    case 'D':
    case 'r':
    case 'R':
      length = 8;
      break;

    case 'x':
    case 'X':
      length = 12;
      break;

    case 'p':
    case 'P':
      length = 12;
      break;

    default:
      as_bad (_("unknown floating type type '%c'"), float_type);
      return -1;
    }

  /* It would be nice if we could go through expression to parse the
     hex constant, but if we get a bignum it's a pain to sort it into
     the buffer correctly.  */
  i = 0;
  while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
    {
      int d;

      /* The MRI assembler accepts arbitrary underscores strewn about
        through the hex constant, so we ignore them as well.  */
      if (*input_line_pointer == '_')
       {
         ++input_line_pointer;
         continue;
       }

      if (i >= length)
       {
         as_warn (_("floating point constant too large"));
         return -1;
       }
      d = hex_value (*input_line_pointer) << 4;
      ++input_line_pointer;
      while (*input_line_pointer == '_')
       ++input_line_pointer;
      if (hex_p (*input_line_pointer))
       {
         d += hex_value (*input_line_pointer);
         ++input_line_pointer;
       }
      if (target_big_endian)
       bytes[i] = d;
      else
       bytes[length - i - 1] = d;
      ++i;
    }

  if (i < length)
    {
      if (target_big_endian)
       memset (bytes + i, 0, length - i);
      else
       memset (bytes, 0, length - i);
    }

  return length;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ignore_rest_of_line ( void  )

Definition at line 3407 of file read.c.

{
  while (input_line_pointer < buffer_limit
        && !is_end_of_line[(unsigned char) *input_line_pointer])
    input_line_pointer++;

  input_line_pointer++;

  /* Return pointing just after end-of-line.  */
  know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
}
void input_scrub_insert_file ( char *  path)

Definition at line 5588 of file read.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void input_scrub_insert_line ( const char *  line)

Definition at line 5574 of file read.c.

Here is the call graph for this function:

Definition at line 5193 of file read.c.

{
  SKIP_WHITESPACE ();
  return (is_end_of_line[(unsigned char) *input_line_pointer]);
}

Here is the caller graph for this function:

void mri_comment_end ( char *  stop,
int  stopc 
)

Definition at line 1207 of file read.c.

Here is the caller graph for this function:

char* mri_comment_field ( char *  stopcp)

Definition at line 1176 of file read.c.

{
  char *s;
#ifdef TC_M68K
  int inquote = 0;

  know (flag_m68k_mri);

  for (s = input_line_pointer;
       ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
       || inquote);
       s++)
    {
      if (*s == '\'')
       inquote = !inquote;
    }
#else
  for (s = input_line_pointer;
       !is_end_of_line[(unsigned char) *s];
       s++)
    ;
#endif
  *stopcp = *s;
  *s = '\0';

  return s;
}

Here is the caller graph for this function:

Definition at line 4953 of file read.c.

{
  register unsigned int c;

  c = *input_line_pointer++ & CHAR_MASK;
  switch (c)
    {
    case '\"':
      c = NOT_A_CHAR;
      break;

    case '\n':
      as_warn (_("unterminated string; newline inserted"));
      bump_line_counters ();
      break;

#ifndef NO_STRING_ESCAPES
    case '\\':
      switch (c = *input_line_pointer++)
       {
       case 'b':
         c = '\b';
         break;

       case 'f':
         c = '\f';
         break;

       case 'n':
         c = '\n';
         break;

       case 'r':
         c = '\r';
         break;

       case 't':
         c = '\t';
         break;

       case 'v':
         c = '\013';
         break;

       case '\\':
       case '"':
         break;             /* As itself.  */

       case '0':
       case '1':
       case '2':
       case '3':
       case '4':
       case '5':
       case '6':
       case '7':
       case '8':
       case '9':
         {
           long number;
           int i;

           for (i = 0, number = 0;
               ISDIGIT (c) && i < 3;
               c = *input_line_pointer++, i++)
             {
              number = number * 8 + c - '0';
             }

           c = number & 0xff;
         }
         --input_line_pointer;
         break;

       case 'x':
       case 'X':
         {
           long number;

           number = 0;
           c = *input_line_pointer++;
           while (ISXDIGIT (c))
             {
              if (ISDIGIT (c))
                number = number * 16 + c - '0';
              else if (ISUPPER (c))
                number = number * 16 + c - 'A' + 10;
              else
                number = number * 16 + c - 'a' + 10;
              c = *input_line_pointer++;
             }
           c = number & 0xff;
           --input_line_pointer;
         }
         break;

       case '\n':
         /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
         as_warn (_("unterminated string; newline inserted"));
         c = '\n';
         bump_line_counters ();
         break;

       default:

#ifdef ONLY_STANDARD_ESCAPES
         as_bad (_("bad escaped character in string"));
         c = '?';
#endif /* ONLY_STANDARD_ESCAPES */

         break;
       }
      break;
#endif /* ! defined (NO_STRING_ESCAPES) */

    default:
      break;
    }
  return (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int output_big_leb128 ( char *  p,
LITTLENUM_TYPE bignum,
int  size,
int  sign 
) [static]

Definition at line 4737 of file read.c.

{
  if (sign)
    return output_big_sleb128 (p, bignum, size);
  else
    return output_big_uleb128 (p, bignum, size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int output_big_sleb128 ( char *  p,
LITTLENUM_TYPE bignum,
int  size 
) [inline, static]

Definition at line 4643 of file read.c.

{
  char *orig = p;
  valueT val = 0;
  int loaded = 0;
  unsigned byte;

  /* Strip leading sign extensions off the bignum.  */
  while (size > 1
        && bignum[size - 1] == LITTLENUM_MASK
        && bignum[size - 2] > LITTLENUM_MASK / 2)
    size--;

  do
    {
      /* OR in the next part of the littlenum.  */
      val |= (*bignum << loaded);
      loaded += LITTLENUM_NUMBER_OF_BITS;
      size--;
      bignum++;

      /* Add bytes until there are less than 7 bits left in VAL
        or until every non-sign bit has been written.  */
      do
       {
         byte = val & 0x7f;
         loaded -= 7;
         val >>= 7;
         if (size > 0
             || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
           byte |= 0x80;

         if (orig)
           *p = byte;
         p++;
       }
      while ((byte & 0x80) != 0 && loaded >= 7);
    }
  while (size > 0);

  /* Mop up any left-over bits (of which there will be less than 7).  */
  if ((byte & 0x80) != 0)
    {
      /* Sign-extend VAL.  */
      if (val & (1 << (loaded - 1)))
       val |= ~0 << loaded;
      if (orig)
       *p = val & 0x7f;
      p++;
    }

  return p - orig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int output_big_uleb128 ( char *  p,
LITTLENUM_TYPE bignum,
int  size 
) [inline, static]

Definition at line 4698 of file read.c.

{
  char *orig = p;
  valueT val = 0;
  int loaded = 0;
  unsigned byte;

  /* Strip leading zeros off the bignum.  */
  /* XXX: Is this needed?  */
  while (size > 0 && bignum[size - 1] == 0)
    size--;

  do
    {
      if (loaded < 7 && size > 0)
       {
         val |= (*bignum << loaded);
         loaded += 8 * CHARS_PER_LITTLENUM;
         size--;
         bignum++;
       }

      byte = val & 0x7f;
      loaded -= 7;
      val >>= 7;

      if (size > 0 || val)
       byte |= 0x80;

      if (orig)
       *p = byte;
      p++;
    }
  while (byte & 0x80);

  return p - orig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int output_leb128 ( char *  p,
valueT  value,
int  sign 
)

Definition at line 4630 of file read.c.

{
  if (sign)
    return output_sleb128 (p, (offsetT) value);
  else
    return output_uleb128 (p, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int output_sleb128 ( char *  p,
offsetT  value 
) [inline, static]

Definition at line 4583 of file read.c.

{
  register char *orig = p;
  register int more;

  do
    {
      unsigned byte = (value & 0x7f);

      /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
        Fortunately, we can structure things so that the extra work reduces
        to a noop on systems that do things "properly".  */
      value = (value >> 7) | ~(-(offsetT)1 >> 7);

      more = !((((value == 0) && ((byte & 0x40) == 0))
              || ((value == -1) && ((byte & 0x40) != 0))));
      if (more)
       byte |= 0x80;

      *p++ = byte;
    }
  while (more);

  return p - orig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int output_uleb128 ( char *  p,
valueT  value 
) [inline, static]

Definition at line 4610 of file read.c.

{
  char *orig = p;

  do
    {
      unsigned byte = (value & 0x7f);
      value >>= 7;
      if (value != 0)
       /* More bytes to follow.  */
       byte |= 0x80;

      *p++ = byte;
    }
  while (value != 0);

  return p - orig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

offsetT parse_align ( int  align_bytes)

Definition at line 2205 of file read.c.

{
  expressionS exp;
  addressT align;

  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
    no_align:
      as_bad (_("expected alignment after size"));
      ignore_rest_of_line ();
      return -1;
    }

  input_line_pointer++;
  SKIP_WHITESPACE ();

  align = get_absolute_expr (&exp);
  if (exp.X_op == O_absent)
    goto no_align;

  if (!exp.X_unsigned)
    {
      as_warn (_("alignment negative; 0 assumed"));
      align = 0;
    }

  if (align_bytes && align != 0)
    {
      /* convert to a power of 2 alignment */
      unsigned int alignp2 = 0;
      while ((align & 1) == 0)
       align >>= 1, ++alignp2;
      if (align != 1)
       {
         as_bad (_("alignment not a power of 2"));
         ignore_rest_of_line ();
         return -1;
       }
      align = alignp2;
    }
  return align;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pobegin ( void  ) [static]

Definition at line 496 of file read.c.

{
  po_hash = hash_new ();

  /* Do the target-specific pseudo ops.  */
  pop_table_name = "md";
  md_pop_insert ();

  /* Now object specific.  Skip any that were in the target table.  */
  pop_table_name = "obj";
  pop_override_ok = 1;
  obj_pop_insert ();

  /* Now portable ones.  Skip any that we've seen already.  */
  pop_table_name = "standard";
  pop_insert (potable);

#ifdef TARGET_USE_CFIPOP
  pop_table_name = "cfi";
  pop_override_ok = 1;
  cfi_pop_insert ();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pop_insert ( const pseudo_typeS *  table)

Definition at line 470 of file read.c.

{
  const char *errtxt;
  const pseudo_typeS *pop;
  for (pop = table; pop->poc_name; pop++)
    {
      errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
      if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
       as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
                errtxt);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pseudo_set ( symbolS *  symbolP)

Definition at line 3437 of file read.c.

{
  expressionS exp;
  segT seg;

  know (symbolP);           /* NULL pointer is logic error.  */

  if (!S_IS_FORWARD_REF (symbolP))
    (void) expression (&exp);
  else
    (void) deferred_expression (&exp);

  if (exp.X_op == O_illegal)
    as_bad (_("illegal expression"));
  else if (exp.X_op == O_absent)
    as_bad (_("missing expression"));
  else if (exp.X_op == O_big)
    {
      if (exp.X_add_number > 0)
       as_bad (_("bignum invalid"));
      else
       as_bad (_("floating point number invalid"));
    }
  else if (exp.X_op == O_subtract
          && !S_IS_FORWARD_REF (symbolP)
          && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
          && (symbol_get_frag (exp.X_add_symbol)
              == symbol_get_frag (exp.X_op_symbol)))
    {
      exp.X_op = O_constant;
      exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
                       - S_GET_VALUE (exp.X_op_symbol));
    }

  if (symbol_section_p (symbolP))
    {
      as_bad ("attempt to set value of section symbol");
      return;
    }

  switch (exp.X_op)
    {
    case O_illegal:
    case O_absent:
    case O_big:
      exp.X_add_number = 0;
      /* Fall through.  */
    case O_constant:
      S_SET_SEGMENT (symbolP, absolute_section);
      S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
      set_zero_frag (symbolP);
      break;

    case O_register:
      S_SET_SEGMENT (symbolP, reg_section);
      S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
      set_zero_frag (symbolP);
      break;

    case O_symbol:
      seg = S_GET_SEGMENT (exp.X_add_symbol);
      /* For x=undef+const, create an expression symbol.
        For x=x+const, just update x except when x is an undefined symbol
        For x=defined+const, evaluate x.  */
      if (symbolP == exp.X_add_symbol
         && (seg != undefined_section
             || !symbol_constant_p (symbolP)))
       {
         *symbol_X_add_number (symbolP) += exp.X_add_number;
         break;
       }
      else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
       {
         symbolS *s = exp.X_add_symbol;

         if (S_IS_COMMON (s))
           as_bad (_("`%s' can't be equated to common symbol '%s'"),
                  S_GET_NAME (symbolP), S_GET_NAME (s));

         S_SET_SEGMENT (symbolP, seg);
         S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
         symbol_set_frag (symbolP, symbol_get_frag (s));
         copy_symbol_attributes (symbolP, s);
         break;
       }
      S_SET_SEGMENT (symbolP, undefined_section);
      symbol_set_value_expression (symbolP, &exp);
      set_zero_frag (symbolP);
      break;

    default:
      /* The value is some complex expression.  */
      S_SET_SEGMENT (symbolP, expr_section);
      symbol_set_value_expression (symbolP, &exp);
      set_zero_frag (symbolP);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_a_source_file ( char *  name)

Definition at line 579 of file read.c.

{
  register char c;
  register char *s;         /* String of symbol, '\0' appended.  */
  register int temp;
  pseudo_typeS *pop;

#ifdef WARN_COMMENTS
  found_comment = 0;
#endif

  buffer = input_scrub_new_file (name);

  listing_file (name);
  listing_newline (NULL);
  register_dependency (name);

  /* Generate debugging information before we've read anything in to denote
     this file as the "main" source file and not a subordinate one
     (e.g. N_SO vs N_SOL in stabs).  */
  generate_file_debug ();

  while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
    {                       /* We have another line to parse.  */
#ifndef NO_LISTING
      /* In order to avoid listing macro expansion lines with labels
        multiple times, keep track of which line was last issued.  */
      static char *last_eol;

      last_eol = NULL;
#endif
      know (buffer_limit[-1] == '\n');    /* Must have a sentinel.  */

      while (input_line_pointer < buffer_limit)
       {
         /* We have more of this buffer to parse.  */

         /* We now have input_line_pointer->1st char of next line.
            If input_line_pointer [-1] == '\n' then we just
            scanned another line: so bump line counters.  */
         if (is_end_of_line[(unsigned char) input_line_pointer[-1]])
           {
#ifdef md_start_line_hook
             md_start_line_hook ();
#endif
             if (input_line_pointer[-1] == '\n')
              bump_line_counters ();

             line_label = NULL;

             if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
              {
                /* Text at the start of a line must be a label, we
                   run down and stick a colon in.  */
                if (is_name_beginner (*input_line_pointer))
                  {
                    char *line_start = input_line_pointer;
                    char c;
                    int mri_line_macro;

                    LISTING_NEWLINE ();
                    HANDLE_CONDITIONAL_ASSEMBLY ();

                    c = get_symbol_end ();

                    /* In MRI mode, the EQU and MACRO pseudoops must
                      be handled specially.  */
                    mri_line_macro = 0;
                    if (flag_m68k_mri)
                     {
                       char *rest = input_line_pointer + 1;

                       if (*rest == ':')
                         ++rest;
                       if (*rest == ' ' || *rest == '\t')
                         ++rest;
                       if ((strncasecmp (rest, "EQU", 3) == 0
                            || strncasecmp (rest, "SET", 3) == 0)
                           && (rest[3] == ' ' || rest[3] == '\t'))
                         {
                           input_line_pointer = rest + 3;
                           equals (line_start,
                                  strncasecmp (rest, "SET", 3) == 0);
                           continue;
                         }
                       if (strncasecmp (rest, "MACRO", 5) == 0
                           && (rest[5] == ' '
                              || rest[5] == '\t'
                              || is_end_of_line[(unsigned char) rest[5]]))
                         mri_line_macro = 1;
                     }

                    /* In MRI mode, we need to handle the MACRO
                      pseudo-op specially: we don't want to put the
                      symbol in the symbol table.  */
                    if (!mri_line_macro
#ifdef TC_START_LABEL_WITHOUT_COLON
                       && TC_START_LABEL_WITHOUT_COLON(c,
                                                   input_line_pointer)
#endif
                       )
                     line_label = colon (line_start);
                    else
                     line_label = symbol_create (line_start,
                                              absolute_section,
                                              (valueT) 0,
                                              &zero_address_frag);

                    *input_line_pointer = c;
                    if (c == ':')
                     input_line_pointer++;
                  }
              }
           }

         /* We are at the beginning of a line, or similar place.
            We expect a well-formed assembler statement.
            A "symbol-name:" is a statement.

            Depending on what compiler is used, the order of these tests
            may vary to catch most common case 1st.
            Each test is independent of all other tests at the (top) level.
            PLEASE make a compiler that doesn't use this assembler.
            It is crufty to waste a compiler's time encoding things for this
            assembler, which then wastes more time decoding it.
            (And communicating via (linear) files is silly!
            If you must pass stuff, please pass a tree!)  */
         if ((c = *input_line_pointer++) == '\t'
             || c == ' '
             || c == '\f'
             || c == 0)
           c = *input_line_pointer++;

         know (c != ' ');   /* No further leading whitespace.  */

#ifndef NO_LISTING
         /* If listing is on, and we are expanding a macro, then give
            the listing code the contents of the expanded line.  */
         if (listing)
           {
             if ((listing & LISTING_MACEXP) && macro_nest > 0)
              {
                char *copy;
                int len;

                /* Find the end of the current expanded macro line.  */
                s = find_end_of_line (input_line_pointer - 1, flag_m68k_mri);

                if (s != last_eol)
                  {
                    last_eol = s;
                    /* Copy it for safe keeping.  Also give an indication of
                      how much macro nesting is involved at this point.  */
                    len = s - (input_line_pointer - 1);
                    copy = (char *) xmalloc (len + macro_nest + 2);
                    memset (copy, '>', macro_nest);
                    copy[macro_nest] = ' ';
                    memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
                    copy[macro_nest + 1 + len] = '\0';

                    /* Install the line with the listing facility.  */
                    listing_newline (copy);
                  }
              }
             else
              listing_newline (NULL);
           }
#endif
         /* C is the 1st significant character.
            Input_line_pointer points after that character.  */
         if (is_name_beginner (c))
           {
             /* Want user-defined label or pseudo/opcode.  */
             HANDLE_CONDITIONAL_ASSEMBLY ();

             s = --input_line_pointer;
             c = get_symbol_end ();       /* name's delimiter.  */

             /* C is character after symbol.
               That character's place in the input line is now '\0'.
               S points to the beginning of the symbol.
                 [In case of pseudo-op, s->'.'.]
               Input_line_pointer->'\0' where c was.  */
             if (TC_START_LABEL (c, input_line_pointer))
              {
                if (flag_m68k_mri)
                  {
                    char *rest = input_line_pointer + 1;

                    /* In MRI mode, \tsym: set 0 is permitted.  */
                    if (*rest == ':')
                     ++rest;

                    if (*rest == ' ' || *rest == '\t')
                     ++rest;

                    if ((strncasecmp (rest, "EQU", 3) == 0
                        || strncasecmp (rest, "SET", 3) == 0)
                       && (rest[3] == ' ' || rest[3] == '\t'))
                     {
                       input_line_pointer = rest + 3;
                       equals (s, 1);
                       continue;
                     }
                  }

                line_label = colon (s);   /* User-defined label.  */
                /* Put ':' back for error messages' sake.  */
                *input_line_pointer++ = ':';
#ifdef tc_check_label
                tc_check_label (line_label);
#endif
                /* Input_line_pointer->after ':'.  */
                SKIP_WHITESPACE ();
              }
              else if (input_line_pointer[1] == '='
                     && (c == '='
                        || ((c == ' ' || c == '\t')
                            && input_line_pointer[2] == '=')))
              {
                equals (s, -1);
                demand_empty_rest_of_line ();
              }
              else if ((c == '='
                       || ((c == ' ' || c == '\t')
                            && input_line_pointer[1] == '='))
#ifdef TC_EQUAL_IN_INSN
                           && !TC_EQUAL_IN_INSN (c, s)
#endif
                           )
              {
                equals (s, 1);
                demand_empty_rest_of_line ();
              }
             else
              {
                /* Expect pseudo-op or machine instruction.  */
                pop = NULL;

#ifndef TC_CASE_SENSITIVE
                {
                  char *s2 = s;

                  strncpy (original_case_string, s2, sizeof (original_case_string));
                  original_case_string[sizeof (original_case_string) - 1] = 0;

                  while (*s2)
                    {
                     *s2 = TOLOWER (*s2);
                     s2++;
                    }
                }
#endif
                if (NO_PSEUDO_DOT || flag_m68k_mri)
                  {
                    /* The MRI assembler uses pseudo-ops without
                      a period.  */
                    pop = (pseudo_typeS *) hash_find (po_hash, s);
                    if (pop != NULL && pop->poc_handler == NULL)
                     pop = NULL;
                  }

                if (pop != NULL
                    || (!flag_m68k_mri && *s == '.'))
                  {
                    /* PSEUDO - OP.

                      WARNING: c has next char, which may be end-of-line.
                      We lookup the pseudo-op table with s+1 because we
                      already know that the pseudo-op begins with a '.'.  */

                    if (pop == NULL)
                     pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
                    if (pop && !pop->poc_handler)
                     pop = NULL;

                    /* In MRI mode, we may need to insert an
                      automatic alignment directive.  What a hack
                      this is.  */
                    if (mri_pending_align
                       && (pop == NULL
                           || !((pop->poc_handler == cons
                                && pop->poc_val == 1)
                               || (pop->poc_handler == s_space
                                   && pop->poc_val == 1)
#ifdef tc_conditional_pseudoop
                               || tc_conditional_pseudoop (pop)
#endif
                               || pop->poc_handler == s_if
                               || pop->poc_handler == s_ifdef
                               || pop->poc_handler == s_ifc
                               || pop->poc_handler == s_ifeqs
                               || pop->poc_handler == s_else
                               || pop->poc_handler == s_endif
                               || pop->poc_handler == s_globl
                               || pop->poc_handler == s_ignore)))
                     {
                       do_align (1, (char *) NULL, 0, 0);
                       mri_pending_align = 0;

                       if (line_label != NULL)
                         {
                           symbol_set_frag (line_label, frag_now);
                           S_SET_VALUE (line_label, frag_now_fix ());
                         }
                     }

                    /* Print the error msg now, while we still can.  */
                    if (pop == NULL)
                     {
                       char *end = input_line_pointer;

                       *input_line_pointer = c;
                       s_ignore (0);
                       c = *--input_line_pointer;
                       *input_line_pointer = '\0';
                       if (! macro_defined || ! try_macro (c, s))
                         {
                           *end = '\0';
                           as_bad (_("unknown pseudo-op: `%s'"), s);
                           *input_line_pointer++ = c;
                         }
                       continue;
                     }

                    /* Put it back for error messages etc.  */
                    *input_line_pointer = c;
                    /* The following skip of whitespace is compulsory.
                      A well shaped space is sometimes all that separates
                      keyword from operands.  */
                    if (c == ' ' || c == '\t')
                     input_line_pointer++;

                    /* Input_line is restored.
                      Input_line_pointer->1st non-blank char
                      after pseudo-operation.  */
                    (*pop->poc_handler) (pop->poc_val);

                    /* If that was .end, just get out now.  */
                    if (pop->poc_handler == s_end)
                     goto quit;
                  }
                else
                  {
                    /* WARNING: c has char, which may be end-of-line.  */
                    /* Also: input_line_pointer->`\0` where c was.  */
                    *input_line_pointer = c;
                    input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1);
                    c = *input_line_pointer;
                    *input_line_pointer = '\0';

                    generate_lineno_debug ();

                    if (macro_defined && try_macro (c, s))
                     continue;

                    if (mri_pending_align)
                     {
                       do_align (1, (char *) NULL, 0, 0);
                       mri_pending_align = 0;
                       if (line_label != NULL)
                         {
                           symbol_set_frag (line_label, frag_now);
                           S_SET_VALUE (line_label, frag_now_fix ());
                         }
                     }

                    md_assemble (s);      /* Assemble 1 instruction.  */

                    *input_line_pointer++ = c;

                    /* We resume loop AFTER the end-of-line from
                      this instruction.  */
                  }
              }
             continue;
           }

         /* Empty statement?  */
         if (is_end_of_line[(unsigned char) c])
           continue;

         if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
           {
             /* local label  ("4:")  */
             char *backup = input_line_pointer;

             HANDLE_CONDITIONAL_ASSEMBLY ();

             temp = c - '0';

             /* Read the whole number.  */
             while (ISDIGIT (*input_line_pointer))
              {
                temp = (temp * 10) + *input_line_pointer - '0';
                ++input_line_pointer;
              }

             if (LOCAL_LABELS_DOLLAR
                && *input_line_pointer == '$'
                && *(input_line_pointer + 1) == ':')
              {
                input_line_pointer += 2;

                if (dollar_label_defined (temp))
                  {
                    as_fatal (_("label \"%d$\" redefined"), temp);
                  }

                define_dollar_label (temp);
                colon (dollar_label_name (temp, 0));
                continue;
              }

             if (LOCAL_LABELS_FB
                && *input_line_pointer++ == ':')
              {
                fb_label_instance_inc (temp);
                colon (fb_label_name (temp, 0));
                continue;
              }

             input_line_pointer = backup;
           }                /* local label  ("4:") */

         if (c && strchr (line_comment_chars, c))
           {                /* Its a comment.  Better say APP or NO_APP.  */
             sb sbuf;
             char *ends;
             char *new_buf;
             char *new_tmp;
             unsigned int new_length;
             char *tmp_buf = 0;

             s = input_line_pointer;
             if (strncmp (s, "APP\n", 4))
              {
                /* We ignore it.  */
                ignore_rest_of_line ();
                continue;
              }
             bump_line_counters ();
             s += 4;

             sb_new (&sbuf);
             ends = strstr (s, "#NO_APP\n");

             if (!ends)
              {
                unsigned int tmp_len;
                unsigned int num;

                /* The end of the #APP wasn't in this buffer.  We
                   keep reading in buffers until we find the #NO_APP
                   that goes with this #APP  There is one.  The specs
                   guarantee it...  */
                tmp_len = buffer_limit - s;
                tmp_buf = xmalloc (tmp_len + 1);
                memcpy (tmp_buf, s, tmp_len);
                do
                  {
                    new_tmp = input_scrub_next_buffer (&buffer);
                    if (!new_tmp)
                     break;
                    else
                     buffer_limit = new_tmp;
                    input_line_pointer = buffer;
                    ends = strstr (buffer, "#NO_APP\n");
                    if (ends)
                     num = ends - buffer;
                    else
                     num = buffer_limit - buffer;

                    tmp_buf = xrealloc (tmp_buf, tmp_len + num);
                    memcpy (tmp_buf + tmp_len, buffer, num);
                    tmp_len += num;
                  }
                while (!ends);

                input_line_pointer = ends ? ends + 8 : NULL;

                s = tmp_buf;
                ends = s + tmp_len;

              }
             else
              {
                input_line_pointer = ends + 8;
              }

             scrub_string = s;
             scrub_string_end = ends;

             new_length = ends - s;
             new_buf = (char *) xmalloc (new_length);
             new_tmp = new_buf;
             for (;;)
              {
                int space;
                int size;

                space = (new_buf + new_length) - new_tmp;
                size = do_scrub_chars (scrub_from_string, new_tmp, space);

                if (size < space)
                  {
                    new_tmp[size] = 0;
                    break;
                  }

                new_buf = xrealloc (new_buf, new_length + 100);
                new_tmp = new_buf + new_length;
                new_length += 100;
              }

             if (tmp_buf)
              free (tmp_buf);

             /* We've "scrubbed" input to the preferred format.  In the
               process we may have consumed the whole of the remaining
               file (and included files).  We handle this formatted
               input similar to that of macro expansion, letting
               actual macro expansion (possibly nested) and other
               input expansion work.  Beware that in messages, line
               numbers and possibly file names will be incorrect.  */
             sb_add_string (&sbuf, new_buf);
             input_scrub_include_sb (&sbuf, input_line_pointer, 0);
             sb_kill (&sbuf);
             buffer_limit = input_scrub_next_buffer (&input_line_pointer);
             free (new_buf);
             continue;
           }

         HANDLE_CONDITIONAL_ASSEMBLY ();

#ifdef tc_unrecognized_line
         if (tc_unrecognized_line (c))
           continue;
#endif
         input_line_pointer--;
         /* Report unknown char as error.  */
         demand_empty_rest_of_line ();
       }

#ifdef md_after_pass_hook
      md_after_pass_hook ();
#endif
    }

 quit:

#ifdef md_cleanup
  md_cleanup ();
#endif
  /* Close the input file.  */
  input_scrub_close ();
#ifdef WARN_COMMENTS
  {
    if (warn_comment && found_comment)
      as_warn_where (found_comment_file, found_comment,
                   "first comment found here");
  }
#endif
}

Here is the caller graph for this function:

void read_begin ( void  )

Definition at line 225 of file read.c.

{
  const char *p;

  pobegin ();
  obj_read_begin_hook ();

  /* Something close -- but not too close -- to a multiple of 1024.
     The debugging malloc I'm using has 24 bytes of overhead.  */
  obstack_begin (&notes, chunksize);
  obstack_begin (&cond_obstack, chunksize);

  /* Use machine dependent syntax.  */
  for (p = line_separator_chars; *p; p++)
    is_end_of_line[(unsigned char) *p] = 1;
  /* Use more.  FIXME-SOMEDAY.  */

  if (flag_mri)
    lex_type['?'] = 3;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_print_statistics ( FILE *  file)

Definition at line 5559 of file read.c.

{
  hash_print_statistics (file, "pseudo-op table", po_hash);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_abort ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1218 of file read.c.

{
  as_fatal (_(".abort detected.  Abandoning ship."));
}

Here is the call graph for this function:

static void s_align ( int  arg,
int  bytes_p 
) [static]

Definition at line 1283 of file read.c.

{
  unsigned int align_limit = ALIGN_LIMIT;
  unsigned int align;
  char *stop = NULL;
  char stopc = 0;
  offsetT fill = 0;
  int max;
  int fill_p;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  if (is_end_of_line[(unsigned char) *input_line_pointer])
    {
      if (arg < 0)
       align = 0;
      else
       align = arg;  /* Default value from pseudo-op table.  */
    }
  else
    {
      align = get_absolute_expression ();
      SKIP_WHITESPACE ();
    }

  if (bytes_p)
    {
      /* Convert to a power of 2.  */
      if (align != 0)
       {
         unsigned int i;

         for (i = 0; (align & 1) == 0; align >>= 1, ++i)
           ;
         if (align != 1)
           as_bad (_("alignment not a power of 2"));

         align = i;
       }
    }

  if (align > align_limit)
    {
      align = align_limit;
      as_warn (_("alignment too large: %u assumed"), align);
    }

  if (*input_line_pointer != ',')
    {
      fill_p = 0;
      max = 0;
    }
  else
    {
      ++input_line_pointer;
      if (*input_line_pointer == ',')
       fill_p = 0;
      else
       {
         fill = get_absolute_expression ();
         SKIP_WHITESPACE ();
         fill_p = 1;
       }

      if (*input_line_pointer != ',')
       max = 0;
      else
       {
         ++input_line_pointer;
         max = get_absolute_expression ();
       }
    }

  if (!fill_p)
    {
      if (arg < 0)
       as_warn (_("expected fill pattern missing"));
      do_align (align, (char *) NULL, 0, max);
    }
  else
    {
      int fill_len;

      if (arg >= 0)
       fill_len = 1;
      else
       fill_len = -arg;
      if (fill_len <= 1)
       {
         char fill_char;

         fill_char = fill;
         do_align (align, &fill_char, fill_len, max);
       }
      else
       {
         char ab[16];

         if ((size_t) fill_len > sizeof ab)
           abort ();
         md_number_to_chars (ab, fill, fill_len);
         do_align (align, ab, fill_len, max);
       }
    }

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_align_bytes ( int  arg)

Definition at line 1399 of file read.c.

{
  s_align (arg, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_align_ptwo ( int  arg)

Definition at line 1408 of file read.c.

{
  s_align (arg, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_altmacro ( int  on) [static]

Definition at line 1416 of file read.c.

Here is the call graph for this function:

void s_app_file ( int  appfile)

Definition at line 1679 of file read.c.

{
  register char *s;
  int length;

  /* Some assemblers tolerate immediately following '"'.  */
  if ((s = demand_copy_string (&length)) != 0)
    {
      int may_omit
       = (!new_logical_line_flags (s, -1, 1) && appfile);

      /* In MRI mode, the preprocessor may have inserted an extraneous
        backquote.  */
      if (flag_m68k_mri
         && *input_line_pointer == '\''
         && is_end_of_line[(unsigned char) input_line_pointer[1]])
       ++input_line_pointer;

      demand_empty_rest_of_line ();
      if (!may_omit)
       s_app_file_string (s, appfile);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_app_file_string ( char *  file,
int appfile  ATTRIBUTE_UNUSED 
)

Definition at line 1666 of file read.c.

{
#ifdef LISTING
  if (listing)
    listing_source_file (file);
#endif
  register_dependency (file);
#ifdef obj_app_file
  obj_app_file (file, appfile);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_app_line ( int  appline)

Definition at line 1722 of file read.c.

{
  char *file = NULL;
  int l;

  /* The given number is that of the next line.  */
  if (appline)
    l = get_absolute_expression ();
  else if (!get_linefile_number (&l))
    {
      ignore_rest_of_line ();
      return;
    }

  l--;

  if (l < -1)
    /* Some of the back ends can't deal with non-positive line numbers.
       Besides, it's silly.  GCC however will generate a line number of
       zero when it is pre-processing builtins for assembler-with-cpp files:

          # 0 "<built-in>"

       We do not want to barf on this, especially since such files are used
       in the GCC and GDB testsuites.  So we check for negative line numbers
       rather than non-positive line numbers.  */
    as_warn (_("line numbers must be positive; line number %d rejected"),
            l + 1);
  else
    {
      int flags = 0;
      int length = 0;

      if (!appline)
       {
         SKIP_WHITESPACE ();

         if (*input_line_pointer == '"')
           file = demand_copy_string (&length);

         if (file)
           {
             int this_flag;

             while (get_linefile_number (&this_flag))
              switch (this_flag)
                {
                  /* From GCC's cpp documentation:
                     1: start of a new file.
                     2: returning to a file after having included
                        another file.
                     3: following text comes from a system header file.
                     4: following text should be treated as extern "C".

                     4 is nonsensical for the assembler; 3, we don't
                     care about, so we ignore it just in case a
                     system header file is included while
                     preprocessing assembly.  So 1 and 2 are all we
                     care about, and they are mutually incompatible.
                     new_logical_line_flags() demands this.  */
                case 1:
                case 2:
                  if (flags && flags != (1 << this_flag))
                    as_warn (_("incompatible flag %i in line directive"),
                            this_flag);
                  else
                    flags |= 1 << this_flag;
                  break;

                case 3:
                case 4:
                  /* We ignore these.  */
                  break;

                default:
                  as_warn (_("unsupported flag %i in line directive"),
                          this_flag);
                  break;
                }

             if (!is_end_of_line[(unsigned char)*input_line_pointer])
              file = 0;
           }
       }

      if (appline || file)
       {
         new_logical_line_flags (file, l, flags);
#ifdef LISTING
         if (listing)
           listing_source_line (l);
#endif
       }
    }
  if (appline || file)
    demand_empty_rest_of_line ();
  else
    ignore_rest_of_line ();
}

Here is the call graph for this function:

static void s_bad_end ( int  endr) [static]

Definition at line 2781 of file read.c.

{
  as_warn (_(".end%c encountered without preceeding %s"),
          endr ? 'r' : 'm',
          endr ? ".rept, .irp, or .irpc" : ".macro");
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_comm ( int  ignore)

Definition at line 1526 of file read.c.

{
  s_comm_internal (ignore, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

symbolS* s_comm_internal ( int  param,
symbolS *(*)(int, symbolS *, addressT comm_parse_extra 
)

Definition at line 1423 of file read.c.

{
  char *name;
  char c;
  char *p;
  offsetT temp, size;
  symbolS *symbolP = NULL;
  char *stop = NULL;
  char stopc = 0;
  expressionS exp;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  name = input_line_pointer;
  c = get_symbol_end ();
  /* Just after name is now '\0'.  */
  p = input_line_pointer;
  *p = c;

  if (name == p)
    {
      as_bad (_("expected symbol name"));
      ignore_rest_of_line ();
      goto out;
    }

  SKIP_WHITESPACE ();

  /* Accept an optional comma after the name.  The comma used to be
     required, but Irix 5 cc does not generate it for .lcomm.  */
  if (*input_line_pointer == ',')
    input_line_pointer++;

  temp = get_absolute_expr (&exp);
  size = temp;
  size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
  if (exp.X_op == O_absent)
    {
      as_bad (_("missing size expression"));
      ignore_rest_of_line ();
      goto out;
    }
  else if (temp != size || !exp.X_unsigned)
    {
      as_warn (_("size (%ld) out of range, ignored"), (long) temp);
      ignore_rest_of_line ();
      goto out;
    }

  *p = 0;
  symbolP = symbol_find_or_make (name);
  if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
      && !S_IS_COMMON (symbolP))
    {
      if (!S_IS_VOLATILE (symbolP))
       {
         symbolP = NULL;
         as_bad (_("symbol `%s' is already defined"), name);
         *p = c;
         ignore_rest_of_line ();
         goto out;
       }
      symbolP = symbol_clone (symbolP, 1);
      S_SET_SEGMENT (symbolP, undefined_section);
      S_SET_VALUE (symbolP, 0);
      symbol_set_frag (symbolP, &zero_address_frag);
      S_CLEAR_VOLATILE (symbolP);
    }

  size = S_GET_VALUE (symbolP);
  if (size == 0)
    size = temp;
  else if (size != temp)
    as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
            name, (long) size, (long) temp);

  *p = c;
  if (comm_parse_extra != NULL)
    symbolP = (*comm_parse_extra) (param, symbolP, size);
  else
    {
      S_SET_VALUE (symbolP, (valueT) size);
      S_SET_EXTERNAL (symbolP);
      S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
#ifdef OBJ_VMS
      {
       extern int flag_one;
       if (size == 0 || !flag_one)
         S_GET_OTHER (symbolP) = const_flag;
      }
#endif
    }

  demand_empty_rest_of_line ();
 out:
  if (flag_mri)
    mri_comment_end (stop, stopc);
  return symbolP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_data ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1636 of file read.c.

{
  segT section;
  register int temp;

  temp = get_absolute_expression ();
  if (flag_readonly_data_in_text)
    {
      section = text_section;
      temp += 1000;
    }
  else
    section = data_section;

  subseg_set (section, (subsegT) temp);

#ifdef OBJ_VMS
  const_flag = 0;
#endif
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_end ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1826 of file read.c.

{
  if (flag_mri)
    {
      /* The MRI assembler permits the start symbol to follow .end,
        but we don't support that.  */
      SKIP_WHITESPACE ();
      if (!is_end_of_line[(unsigned char) *input_line_pointer]
         && *input_line_pointer != '*'
         && *input_line_pointer != '!')
       as_warn (_("start address not supported"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_err ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1843 of file read.c.

{
  as_bad (_(".err encountered"));
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_errwarn ( int  err)

Definition at line 1852 of file read.c.

{
  int len;
  /* The purpose for the conditional assignment is not to
     internationalize the directive itself, but that we need a
     self-contained message, one that can be passed like the
     demand_copy_C_string return value, and with no assumption on the
     location of the name of the directive within the message.  */
  char *msg
    = (err ? _(".error directive invoked in source file")
       : _(".warning directive invoked in source file"));

  if (!is_it_end_of_statement ())
    {
      if (*input_line_pointer != '\"')
       {
         as_bad (_("%s argument must be a string"),
                err ? ".error" : ".warning");
         ignore_rest_of_line ();
         return;
       }

      msg = demand_copy_C_string (&len);
      if (msg == NULL)
       return;
    }

  if (err)
    as_bad ("%s", msg);
  else
    as_warn ("%s", msg);
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_fail ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1889 of file read.c.

{
  offsetT temp;
  char *stop = NULL;
  char stopc = 0;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  temp = get_absolute_expression ();
  if (temp >= 500)
    as_warn (_(".fail %ld encountered"), (long) temp);
  else
    as_bad (_(".fail %ld encountered"), (long) temp);

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

void s_fill ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 1911 of file read.c.

{
  expressionS rep_exp;
  long size = 1;
  register long fill = 0;
  char *p;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  get_known_segmented_expression (&rep_exp);
  if (*input_line_pointer == ',')
    {
      input_line_pointer++;
      size = get_absolute_expression ();
      if (*input_line_pointer == ',')
       {
         input_line_pointer++;
         fill = get_absolute_expression ();
       }
    }

  /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
#define BSD_FILL_SIZE_CROCK_8 (8)
  if (size > BSD_FILL_SIZE_CROCK_8)
    {
      as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
      size = BSD_FILL_SIZE_CROCK_8;
    }
  if (size < 0)
    {
      as_warn (_("size negative; .fill ignored"));
      size = 0;
    }
  else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
    {
      if (rep_exp.X_add_number < 0)
       as_warn (_("repeat < 0; .fill ignored"));
      size = 0;
    }

  if (size && !need_pass_2)
    {
      if (rep_exp.X_op == O_constant)
       {
         p = frag_var (rs_fill, (int) size, (int) size,
                     (relax_substateT) 0, (symbolS *) 0,
                     (offsetT) rep_exp.X_add_number,
                     (char *) 0);
       }
      else
       {
         /* We don't have a constant repeat count, so we can't use
            rs_fill.  We can get the same results out of rs_space,
            but its argument is in bytes, so we must multiply the
            repeat count by size.  */

         symbolS *rep_sym;
         rep_sym = make_expr_symbol (&rep_exp);
         if (size != 1)
           {
             expressionS size_exp;
             size_exp.X_op = O_constant;
             size_exp.X_add_number = size;

             rep_exp.X_op = O_multiply;
             rep_exp.X_add_symbol = rep_sym;
             rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
             rep_exp.X_add_number = 0;
             rep_sym = make_expr_symbol (&rep_exp);
           }

         p = frag_var (rs_space, (int) size, (int) size,
                     (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
       }

      memset (p, 0, (unsigned int) size);

      /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
        flavoured AS.  The following bizarre behaviour is to be
        compatible with above.  I guess they tried to take up to 8
        bytes from a 4-byte expression and they forgot to sign
        extend.  */
#define BSD_FILL_SIZE_CROCK_4 (4)
      md_number_to_chars (p, (valueT) fill,
                       (size > BSD_FILL_SIZE_CROCK_4
                        ? BSD_FILL_SIZE_CROCK_4
                        : (int) size));
      /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
        but emits no error message because it seems a legal thing to do.
        It is a degenerate case of .fill but could be emitted by a
        compiler.  */
    }
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_float_space ( int  float_type)

Definition at line 3134 of file read.c.

{
  offsetT count;
  int flen;
  char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  char *stop = NULL;
  char stopc = 0;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  count = get_absolute_expression ();

  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      as_bad (_("missing value"));
      ignore_rest_of_line ();
      if (flag_mri)
       mri_comment_end (stop, stopc);
      return;
    }

  ++input_line_pointer;

  SKIP_WHITESPACE ();

  /* Skip any 0{letter} that may be present.  Don't even check if the
   * letter is legal.  */
  if (input_line_pointer[0] == '0'
      && ISALPHA (input_line_pointer[1]))
    input_line_pointer += 2;

  /* Accept :xxxx, where the x's are hex digits, for a floating point
     with the exact digits specified.  */
  if (input_line_pointer[0] == ':')
    {
      flen = hex_float (float_type, temp);
      if (flen < 0)
       {
         ignore_rest_of_line ();
         if (flag_mri)
           mri_comment_end (stop, stopc);
         return;
       }
    }
  else
    {
      char *err;

      err = md_atof (float_type, temp, &flen);
      know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
      know (flen > 0);
      if (err)
       {
         as_bad (_("bad floating literal: %s"), err);
         ignore_rest_of_line ();
         if (flag_mri)
           mri_comment_end (stop, stopc);
         return;
       }
    }

  while (--count >= 0)
    {
      char *p;

      p = frag_more (flen);
      memcpy (p, temp, (unsigned int) flen);
    }

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

void s_func ( int  end_p)

Definition at line 5469 of file read.c.

{
  do_s_func (end_p, NULL);
}

Here is the call graph for this function:

void s_globl ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2009 of file read.c.

{
  char *name;
  int c;
  symbolS *symbolP;
  char *stop = NULL;
  char stopc = 0;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  do
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      symbolP = symbol_find_or_make (name);
      S_SET_EXTERNAL (symbolP);

      *input_line_pointer = c;
      SKIP_WHITESPACE ();
      c = *input_line_pointer;
      if (c == ',')
       {
         input_line_pointer++;
         SKIP_WHITESPACE ();
         if (is_end_of_line[(unsigned char) *input_line_pointer])
           c = '\n';
       }
    }
  while (c == ',');

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_ignore ( int arg  ATTRIBUTE_UNUSED)

Definition at line 5553 of file read.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void s_incbin ( int x  ATTRIBUTE_UNUSED)

Definition at line 5229 of file read.c.

{
  FILE * binfile;
  char * path;
  char * filename;
  char * binfrag;
  long   skip = 0;
  long   count = 0;
  long   bytes;
  int    len;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  SKIP_WHITESPACE ();
  filename = demand_copy_string (& len);
  if (filename == NULL)
    return;

  SKIP_WHITESPACE ();

  /* Look for optional skip and count.  */
  if (* input_line_pointer == ',')
    {
      ++ input_line_pointer;
      skip = get_absolute_expression ();

      SKIP_WHITESPACE ();

      if (* input_line_pointer == ',')
       {
         ++ input_line_pointer;

         count = get_absolute_expression ();
         if (count == 0)
           as_warn (_(".incbin count zero, ignoring `%s'"), filename);

         SKIP_WHITESPACE ();
       }
    }

  demand_empty_rest_of_line ();

  /* Try opening absolute path first, then try include dirs.  */
  binfile = fopen (filename, FOPEN_RB);
  if (binfile == NULL)
    {
      int i;

      path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);

      for (i = 0; i < include_dir_count; i++)
       {
         sprintf (path, "%s/%s", include_dirs[i], filename);

         binfile = fopen (path, FOPEN_RB);
         if (binfile != NULL)
           break;
       }

      if (binfile == NULL)
       as_bad (_("file not found: %s"), filename);
    }
  else
    path = xstrdup (filename);

  if (binfile)
    {
      long   file_len;

      register_dependency (path);

      /* Compute the length of the file.  */
      if (fseek (binfile, 0, SEEK_END) != 0)
       {
         as_bad (_("seek to end of .incbin file failed `%s'"), path);
         goto done;
       }
      file_len = ftell (binfile);

      /* If a count was not specified use the remainder of the file.  */
      if (count == 0)
       count = file_len - skip;

      if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
       {
         as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
                skip, count, file_len);
         goto done;
       }

      if (fseek (binfile, skip, SEEK_SET) != 0)
       {
         as_bad (_("could not skip to %ld in file `%s'"), skip, path);
         goto done;
       }

      /* Allocate frag space and store file contents in it.  */
      binfrag = frag_more (count);

      bytes = fread (binfrag, 1, count, binfile);
      if (bytes < count)
       as_warn (_("truncated file `%s', %ld of %ld bytes read"),
               path, bytes, count);
    }
done:
  if (binfile != NULL)
    fclose (binfile);
  if (path)
    free (path);
}

Here is the call graph for this function:

void s_include ( int arg  ATTRIBUTE_UNUSED)

Definition at line 5345 of file read.c.

{
  char *filename;
  int i;
  FILE *try;
  char *path;

  if (!flag_m68k_mri)
    {
      filename = demand_copy_string (&i);
      if (filename == NULL)
       {
         /* demand_copy_string has already printed an error and
            called ignore_rest_of_line.  */
         return;
       }
    }
  else
    {
      SKIP_WHITESPACE ();
      i = 0;
      while (!is_end_of_line[(unsigned char) *input_line_pointer]
            && *input_line_pointer != ' '
            && *input_line_pointer != '\t')
       {
         obstack_1grow (&notes, *input_line_pointer);
         ++input_line_pointer;
         ++i;
       }

      obstack_1grow (&notes, '\0');
      filename = obstack_finish (&notes);
      while (!is_end_of_line[(unsigned char) *input_line_pointer])
       ++input_line_pointer;
    }

  demand_empty_rest_of_line ();
  path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );

  for (i = 0; i < include_dir_count; i++)
    {
      strcpy (path, include_dirs[i]);
      strcat (path, "/");
      strcat (path, filename);
      if (0 != (try = fopen (path, FOPEN_RT)))
       {
         fclose (try);
         goto gotit;
       }
    }

  free (path);
  path = filename;
gotit:
  /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
  register_dependency (path);
  input_scrub_insert_file (path);
}

Here is the call graph for this function:

void s_irp ( int  irpc)

Definition at line 2049 of file read.c.

{
  char *file, *eol;
  unsigned int line;
  sb s;
  const char *err;
  sb out;

  as_where (&file, &line);

  sb_new (&s);
  eol = find_end_of_line (input_line_pointer, 0);
  sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
  input_line_pointer = eol;

  sb_new (&out);

  err = expand_irp (irpc, 0, &s, &out, get_line_sb);
  if (err != NULL)
    as_bad_where (file, line, "%s", err);

  sb_kill (&s);

  input_scrub_include_sb (&out, input_line_pointer, 1);
  sb_kill (&out);
  buffer_limit = input_scrub_next_buffer (&input_line_pointer);
}

Here is the call graph for this function:

void s_lcomm ( int  needs_align)

Definition at line 2275 of file read.c.

{
  s_comm_internal (needs_align, s_lcomm_internal);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_lcomm_bytes ( int  needs_align)

Definition at line 2281 of file read.c.

{
  s_comm_internal (needs_align * 2, s_lcomm_internal);
}

Here is the call graph for this function:

Here is the caller graph for this function:

symbolS* s_lcomm_internal ( int  needs_align,
symbolS *  symbolP,
addressT  size 
)

Definition at line 2256 of file read.c.

{
  addressT align = 0;

  if (needs_align)
    {
      align = parse_align (needs_align - 1);
      if (align == (addressT) -1)
       return NULL;
    }
  else
    /* Assume some objects may require alignment on some systems.  */
    TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);

  bss_alloc (symbolP, size, align);
  return symbolP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_leb128 ( int  sign)

Definition at line 4829 of file read.c.

{
  expressionS exp;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  do
    {
      expression (&exp);
      emit_leb128_expr (&exp, sign);
    }
  while (*input_line_pointer++ == ',');

  input_line_pointer--;
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_linkonce ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2083 of file read.c.

{
  enum linkonce_type type;

  SKIP_WHITESPACE ();

  type = LINKONCE_DISCARD;

  if (!is_end_of_line[(unsigned char) *input_line_pointer])
    {
      char *s;
      char c;

      s = input_line_pointer;
      c = get_symbol_end ();
      if (strcasecmp (s, "discard") == 0)
       type = LINKONCE_DISCARD;
      else if (strcasecmp (s, "one_only") == 0)
       type = LINKONCE_ONE_ONLY;
      else if (strcasecmp (s, "same_size") == 0)
       type = LINKONCE_SAME_SIZE;
      else if (strcasecmp (s, "same_contents") == 0)
       type = LINKONCE_SAME_CONTENTS;
      else
       as_warn (_("unrecognized .linkonce type `%s'"), s);

      *input_line_pointer = c;
    }

#ifdef obj_handle_link_once
  obj_handle_link_once (type);
#else /* ! defined (obj_handle_link_once) */
  {
    flagword flags;

    if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
      as_warn (_(".linkonce is not supported for this object file format"));

    flags = bfd_get_section_flags (stdoutput, now_seg);
    flags |= SEC_LINK_ONCE;
    switch (type)
      {
      default:
       abort ();
      case LINKONCE_DISCARD:
       flags |= SEC_LINK_DUPLICATES_DISCARD;
       break;
      case LINKONCE_ONE_ONLY:
       flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
       break;
      case LINKONCE_SAME_SIZE:
       flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
       break;
      case LINKONCE_SAME_CONTENTS:
       flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
       break;
      }
    if (!bfd_set_section_flags (stdoutput, now_seg, flags))
      as_bad (_("bfd_set_section_flags: %s"),
             bfd_errmsg (bfd_get_error ()));
  }
#endif /* ! defined (obj_handle_link_once) */

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_lsym ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2287 of file read.c.

{
  register char *name;
  register char c;
  register char *p;
  expressionS exp;
  register symbolS *symbolP;

  /* We permit ANY defined expression: BSD4.2 demands constants.  */
  name = input_line_pointer;
  c = get_symbol_end ();
  p = input_line_pointer;
  *p = c;

  if (name == p)
    {
      as_bad (_("expected symbol name"));
      ignore_rest_of_line ();
      return;
    }

  SKIP_WHITESPACE ();

  if (*input_line_pointer != ',')
    {
      *p = 0;
      as_bad (_("expected comma after \"%s\""), name);
      *p = c;
      ignore_rest_of_line ();
      return;
    }

  input_line_pointer++;
  expression_and_evaluate (&exp);

  if (exp.X_op != O_constant
      && exp.X_op != O_register)
    {
      as_bad (_("bad expression"));
      ignore_rest_of_line ();
      return;
    }

  *p = 0;
  symbolP = symbol_find_or_make (name);

  if (S_GET_SEGMENT (symbolP) == undefined_section)
    {
      /* The name might be an undefined .global symbol; be sure to
        keep the "external" bit.  */
      S_SET_SEGMENT (symbolP,
                   (exp.X_op == O_constant
                    ? absolute_section
                    : reg_section));
      S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
    }
  else
    {
      as_bad (_("symbol `%s' is already defined"), name);
    }

  *p = c;
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_macro ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2385 of file read.c.

{
  char *file, *eol;
  unsigned int line;
  sb s;
  const char *err;
  const char *name;

  as_where (&file, &line);

  sb_new (&s);
  eol = find_end_of_line (input_line_pointer, 0);
  sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
  input_line_pointer = eol;

  if (line_label != NULL)
    {
      sb label;

      sb_new (&label);
      sb_add_string (&label, S_GET_NAME (line_label));
      err = define_macro (0, &s, &label, get_line_sb, file, line, &name);
      sb_kill (&label);
    }
  else
    err = define_macro (0, &s, NULL, get_line_sb, file, line, &name);
  if (err != NULL)
    as_bad_where (file, line, err, name);
  else
    {
      if (line_label != NULL)
       {
         S_SET_SEGMENT (line_label, absolute_section);
         S_SET_VALUE (line_label, 0);
         symbol_set_frag (line_label, &zero_address_frag);
       }

      if (((NO_PSEUDO_DOT || flag_m68k_mri)
          && hash_find (po_hash, name) != NULL)
         || (!flag_m68k_mri
             && *name == '.'
             && hash_find (po_hash, name + 1) != NULL))
       as_warn_where (file,
               line,
               _("attempt to redefine pseudo-op `%s' ignored"),
               name);
    }

  sb_kill (&s);
}

Here is the call graph for this function:

void s_mexit ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2440 of file read.c.

Here is the call graph for this function:

void s_mri ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2449 of file read.c.

{
  int on, old_flag;

  on = get_absolute_expression ();
  old_flag = flag_mri;
  if (on != 0)
    {
      flag_mri = 1;
#ifdef TC_M68K
      flag_m68k_mri = 1;
#endif
      macro_mri_mode (1);
    }
  else
    {
      flag_mri = 0;
#ifdef TC_M68K
      flag_m68k_mri = 0;
#endif
      macro_mri_mode (0);
    }

  /* Operator precedence changes in m68k MRI mode, so we need to
     update the operator rankings.  */
  expr_set_precedence ();

#ifdef MRI_MODE_CHANGE
  if (on != old_flag)
    MRI_MODE_CHANGE (on);
#endif

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_mri_common ( int small  ATTRIBUTE_UNUSED)

Definition at line 1536 of file read.c.

{
  char *name;
  char c;
  char *alc = NULL;
  symbolS *sym;
  offsetT align;
  char *stop = NULL;
  char stopc = 0;

  if (!flag_mri)
    {
      s_comm (0);
      return;
    }

  stop = mri_comment_field (&stopc);

  SKIP_WHITESPACE ();

  name = input_line_pointer;
  if (!ISDIGIT (*name))
    c = get_symbol_end ();
  else
    {
      do
       {
         ++input_line_pointer;
       }
      while (ISDIGIT (*input_line_pointer));

      c = *input_line_pointer;
      *input_line_pointer = '\0';

      if (line_label != NULL)
       {
         alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
                              + (input_line_pointer - name)
                              + 1);
         sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
         name = alc;
       }
    }

  sym = symbol_find_or_make (name);
  *input_line_pointer = c;
  if (alc != NULL)
    free (alc);

  if (*input_line_pointer != ',')
    align = 0;
  else
    {
      ++input_line_pointer;
      align = get_absolute_expression ();
    }

  if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
    {
      as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
      ignore_rest_of_line ();
      mri_comment_end (stop, stopc);
      return;
    }

  S_SET_EXTERNAL (sym);
  S_SET_SEGMENT (sym, bfd_com_section_ptr);
  mri_common_symbol = sym;

#ifdef S_SET_ALIGN
  if (align != 0)
    S_SET_ALIGN (sym, align);
#endif

  if (line_label != NULL)
    {
      expressionS exp;
      exp.X_op = O_symbol;
      exp.X_add_symbol = sym;
      exp.X_add_number = 0;
      symbol_set_value_expression (line_label, &exp);
      symbol_set_frag (line_label, &zero_address_frag);
      S_SET_SEGMENT (line_label, expr_section);
    }

  /* FIXME: We just ignore the small argument, which distinguishes
     COMMON and COMMON.S.  I don't know what we can do about it.  */

  /* Ignore the type and hptype.  */
  if (*input_line_pointer == ',')
    input_line_pointer += 2;
  if (*input_line_pointer == ',')
    input_line_pointer += 2;

  demand_empty_rest_of_line ();

  mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_mri_sect ( char *type  ATTRIBUTE_UNUSED)

Definition at line 2576 of file read.c.

{
#ifdef TC_M68K

  char *name;
  char c;
  segT seg;

  SKIP_WHITESPACE ();

  name = input_line_pointer;
  if (!ISDIGIT (*name))
    c = get_symbol_end ();
  else
    {
      do
       {
         ++input_line_pointer;
       }
      while (ISDIGIT (*input_line_pointer));

      c = *input_line_pointer;
      *input_line_pointer = '\0';
    }

  name = xstrdup (name);

  *input_line_pointer = c;

  seg = subseg_new (name, 0);

  if (*input_line_pointer == ',')
    {
      int align;

      ++input_line_pointer;
      align = get_absolute_expression ();
      record_alignment (seg, align);
    }

  *type = 'C';
  if (*input_line_pointer == ',')
    {
      c = *++input_line_pointer;
      c = TOUPPER (c);
      if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
       *type = c;
      else
       as_bad (_("unrecognized section type"));
      ++input_line_pointer;

      {
       flagword flags;

       flags = SEC_NO_FLAGS;
       if (*type == 'C')
         flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
       else if (*type == 'D' || *type == 'M')
         flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
       else if (*type == 'R')
         flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
       if (flags != SEC_NO_FLAGS)
         {
           if (!bfd_set_section_flags (stdoutput, seg, flags))
             as_warn (_("error setting flags for \"%s\": %s"),
                     bfd_section_name (stdoutput, seg),
                     bfd_errmsg (bfd_get_error ()));
         }
      }
    }

  /* Ignore the HP type.  */
  if (*input_line_pointer == ',')
    input_line_pointer += 2;

  demand_empty_rest_of_line ();

#else /* ! TC_M68K */
#ifdef TC_I960

  char *name;
  char c;
  segT seg;

  SKIP_WHITESPACE ();

  name = input_line_pointer;
  c = get_symbol_end ();

  name = xstrdup (name);

  *input_line_pointer = c;

  seg = subseg_new (name, 0);

  if (*input_line_pointer != ',')
    *type = 'C';
  else
    {
      char *sectype;

      ++input_line_pointer;
      SKIP_WHITESPACE ();
      sectype = input_line_pointer;
      c = get_symbol_end ();
      if (*sectype == '\0')
       *type = 'C';
      else if (strcasecmp (sectype, "text") == 0)
       *type = 'C';
      else if (strcasecmp (sectype, "data") == 0)
       *type = 'D';
      else if (strcasecmp (sectype, "romdata") == 0)
       *type = 'R';
      else
       as_warn (_("unrecognized section type `%s'"), sectype);
      *input_line_pointer = c;
    }

  if (*input_line_pointer == ',')
    {
      char *seccmd;

      ++input_line_pointer;
      SKIP_WHITESPACE ();
      seccmd = input_line_pointer;
      c = get_symbol_end ();
      if (strcasecmp (seccmd, "absolute") == 0)
       {
         as_bad (_("absolute sections are not supported"));
         *input_line_pointer = c;
         ignore_rest_of_line ();
         return;
       }
      else if (strcasecmp (seccmd, "align") == 0)
       {
         int align;

         *input_line_pointer = c;
         align = get_absolute_expression ();
         record_alignment (seg, align);
       }
      else
       {
         as_warn (_("unrecognized section command `%s'"), seccmd);
         *input_line_pointer = c;
       }
    }

  demand_empty_rest_of_line ();

#else /* ! TC_I960 */
  /* The MRI assembler seems to use different forms of .sect for
     different targets.  */
  as_bad ("MRI mode not supported for this target");
  ignore_rest_of_line ();
#endif /* ! TC_I960 */
#endif /* ! TC_M68K */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_org ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2522 of file read.c.

{
  register segT segment;
  expressionS exp;
  register long temp_fill;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  /* The m68k MRI assembler has a different meaning for .org.  It
     means to create an absolute section at a given address.  We can't
     support that--use a linker script instead.  */
  if (flag_m68k_mri)
    {
      as_bad (_("MRI style ORG pseudo-op not supported"));
      ignore_rest_of_line ();
      return;
    }

  /* Don't believe the documentation of BSD 4.2 AS.  There is no such
     thing as a sub-segment-relative origin.  Any absolute origin is
     given a warning, then assumed to be segment-relative.  Any
     segmented origin expression ("foo+42") had better be in the right
     segment or the .org is ignored.

     BSD 4.2 AS warns if you try to .org backwards. We cannot because
     we never know sub-segment sizes when we are reading code.  BSD
     will crash trying to emit negative numbers of filler bytes in
     certain .orgs. We don't crash, but see as-write for that code.

     Don't make frag if need_pass_2==1.  */
  segment = get_known_segmented_expression (&exp);
  if (*input_line_pointer == ',')
    {
      input_line_pointer++;
      temp_fill = get_absolute_expression ();
    }
  else
    temp_fill = 0;

  if (!need_pass_2)
    do_org (segment, &exp, temp_fill);

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_print ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2738 of file read.c.

{
  char *s;
  int len;

  s = demand_copy_C_string (&len);
  if (s != NULL)
    printf ("%s\n", s);
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

void s_purgem ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2752 of file read.c.

Here is the call graph for this function:

static void s_reloc ( int  ) [static]
void s_reloc ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 3677 of file read.c.

{
  char *stop = NULL;
  char stopc = 0;
  expressionS exp;
  char *r_name;
  int c;
  struct reloc_list *reloc;

  reloc = xmalloc (sizeof (*reloc));

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  expression (&exp);
  switch (exp.X_op)
    {
    case O_illegal:
    case O_absent:
    case O_big:
    case O_register:
      as_bad (_("missing or bad offset expression"));
      goto err_out;
    case O_constant:
      exp.X_add_symbol = section_symbol (now_seg);
      exp.X_op = O_symbol;
      /* Fall thru */
    case O_symbol:
      if (exp.X_add_number == 0)
       {
         reloc->u.a.offset_sym = exp.X_add_symbol;
         break;
       }
      /* Fall thru */
    default:
      reloc->u.a.offset_sym = make_expr_symbol (&exp);
      break;
    }

  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      as_bad (_("missing reloc type"));
      goto err_out;
    }

  ++input_line_pointer;
  SKIP_WHITESPACE ();
  r_name = input_line_pointer;
  c = get_symbol_end ();
  reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
  *input_line_pointer = c;
  if (reloc->u.a.howto == NULL)
    {
      as_bad (_("unrecognized reloc type"));
      goto err_out;
    }

  exp.X_op = O_absent;
  SKIP_WHITESPACE ();
  if (*input_line_pointer == ',')
    {
      ++input_line_pointer;
      expression_and_evaluate (&exp);
    }
  switch (exp.X_op)
    {
    case O_illegal:
    case O_big:
    case O_register:
      as_bad (_("bad reloc expression"));
    err_out:
      ignore_rest_of_line ();
      free (reloc);
      if (flag_mri)
       mri_comment_end (stop, stopc);
      return;
    case O_absent:
      reloc->u.a.sym = NULL;
      reloc->u.a.addend = 0;
      break;
    case O_constant:
      reloc->u.a.sym = NULL;
      reloc->u.a.addend = exp.X_add_number;
      break;
    case O_symbol:
      reloc->u.a.sym = exp.X_add_symbol;
      reloc->u.a.addend = exp.X_add_number;
      break;
    default:
      reloc->u.a.sym = make_expr_symbol (&exp);
      reloc->u.a.addend = 0;
      break;
    }

  as_where (&reloc->file, &reloc->line);
  reloc->next = reloc_list;
  reloc_list = reloc;

  demand_empty_rest_of_line ();
  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

void s_rept ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 2792 of file read.c.

{
  int count;

  count = get_absolute_expression ();

  do_repeat (count, "REPT", "ENDR");
}

Here is the call graph for this function:

void s_rva ( int  size)

Definition at line 3669 of file read.c.

{
  cons_worker (size, 1);
}

Here is the call graph for this function:

void s_set ( int  equiv)

Definition at line 2916 of file read.c.

{
  char *name;
  char delim;
  char *end_name;

  /* Especial apologies for the random logic:
     this just grew, and could be parsed much more simply!
     Dean in haste.  */
  name = input_line_pointer;
  delim = get_symbol_end ();
  end_name = input_line_pointer;
  *end_name = delim;

  if (name == end_name)
    {
      as_bad (_("expected symbol name"));
      ignore_rest_of_line ();
      return;
    }

  SKIP_WHITESPACE ();

  if (*input_line_pointer != ',')
    {
      *end_name = 0;
      as_bad (_("expected comma after \"%s\""), name);
      *end_name = delim;
      ignore_rest_of_line ();
      return;
    }

  input_line_pointer++;
  *end_name = 0;

  assign_symbol (name, equiv);
  *end_name = delim;

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_space ( int  mult)

Definition at line 2958 of file read.c.

{
  expressionS exp;
  expressionS val;
  char *p = 0;
  char *stop = NULL;
  char stopc = 0;
  int bytes;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  /* In m68k MRI mode, we need to align to a word boundary, unless
     this is ds.b.  */
  if (flag_m68k_mri && mult > 1)
    {
      if (now_seg == absolute_section)
       {
         abs_section_offset += abs_section_offset & 1;
         if (line_label != NULL)
           S_SET_VALUE (line_label, abs_section_offset);
       }
      else if (mri_common_symbol != NULL)
       {
         valueT val;

         val = S_GET_VALUE (mri_common_symbol);
         if ((val & 1) != 0)
           {
             S_SET_VALUE (mri_common_symbol, val + 1);
             if (line_label != NULL)
              {
                expressionS *symexp;

                symexp = symbol_get_value_expression (line_label);
                know (symexp->X_op == O_symbol);
                know (symexp->X_add_symbol == mri_common_symbol);
                symexp->X_add_number += 1;
              }
           }
       }
      else
       {
         do_align (1, (char *) NULL, 0, 0);
         if (line_label != NULL)
           {
             symbol_set_frag (line_label, frag_now);
             S_SET_VALUE (line_label, frag_now_fix ());
           }
       }
    }

  bytes = mult;

  expression (&exp);

  SKIP_WHITESPACE ();
  if (*input_line_pointer == ',')
    {
      ++input_line_pointer;
      expression (&val);
    }
  else
    {
      val.X_op = O_constant;
      val.X_add_number = 0;
    }

  if (val.X_op != O_constant
      || val.X_add_number < - 0x80
      || val.X_add_number > 0xff
      || (mult != 0 && mult != 1 && val.X_add_number != 0))
    {
      resolve_expression (&exp);
      if (exp.X_op != O_constant)
       as_bad (_("unsupported variable size or fill value"));
      else
       {
         offsetT i;

         if (mult == 0)
           mult = 1;
         bytes = mult * exp.X_add_number;
         for (i = 0; i < exp.X_add_number; i++)
           emit_expr (&val, mult);
       }
    }
  else
    {
      if (now_seg == absolute_section || mri_common_symbol != NULL)
       resolve_expression (&exp);

      if (exp.X_op == O_constant)
       {
         long repeat;

         repeat = exp.X_add_number;
         if (mult)
           repeat *= mult;
         bytes = repeat;
         if (repeat <= 0)
           {
             if (!flag_mri)
              as_warn (_(".space repeat count is zero, ignored"));
             else if (repeat < 0)
              as_warn (_(".space repeat count is negative, ignored"));
             goto getout;
           }

         /* If we are in the absolute section, just bump the offset.  */
         if (now_seg == absolute_section)
           {
             abs_section_offset += repeat;
             goto getout;
           }

         /* If we are secretly in an MRI common section, then
            creating space just increases the size of the common
            symbol.  */
         if (mri_common_symbol != NULL)
           {
             S_SET_VALUE (mri_common_symbol,
                        S_GET_VALUE (mri_common_symbol) + repeat);
             goto getout;
           }

         if (!need_pass_2)
           p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
                       (offsetT) repeat, (char *) 0);
       }
      else
       {
         if (now_seg == absolute_section)
           {
             as_bad (_("space allocation too complex in absolute section"));
             subseg_set (text_section, 0);
           }

         if (mri_common_symbol != NULL)
           {
             as_bad (_("space allocation too complex in common section"));
             mri_common_symbol = NULL;
           }

         if (!need_pass_2)
           p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
                       make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
       }

      if (p)
       *p = val.X_add_number;
    }

 getout:

  /* In MRI mode, after an odd number of bytes, we must align to an
     even word boundary, unless the next instruction is a dc.b, ds.b
     or dcb.b.  */
  if (flag_mri && (bytes & 1) != 0)
    mri_pending_align = 1;

  demand_empty_rest_of_line ();

  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_struct ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 3214 of file read.c.

{
  char *stop = NULL;
  char stopc = 0;

  if (flag_mri)
    stop = mri_comment_field (&stopc);
  abs_section_offset = get_absolute_expression ();
#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
  /* The ELF backend needs to know that we are changing sections, so
     that .previous works correctly. */
  if (IS_ELF)
    obj_elf_section_change_hook ();
#endif
  subseg_set (absolute_section, 0);
  demand_empty_rest_of_line ();
  if (flag_mri)
    mri_comment_end (stop, stopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_text ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 3235 of file read.c.

{
  register int temp;

  temp = get_absolute_expression ();
  subseg_set (text_section, (subsegT) temp);
  demand_empty_rest_of_line ();
#ifdef OBJ_VMS
  const_flag &= ~IN_DEFAULT_SECTION;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s_weakref ( int ignore  ATTRIBUTE_UNUSED)

Definition at line 3250 of file read.c.

{
  char *name;
  char delim;
  char *end_name;
  symbolS *symbolP;
  symbolS *symbolP2;
  expressionS exp;

  name = input_line_pointer;
  delim = get_symbol_end ();
  end_name = input_line_pointer;

  if (name == end_name)
    {
      as_bad (_("expected symbol name"));
      *end_name = delim;
      ignore_rest_of_line ();
      return;
    }

  symbolP = symbol_find_or_make (name);

  if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
    {
      if (!S_IS_VOLATILE (symbolP))
       {
         as_bad (_("symbol `%s' is already defined"), name);
         *end_name = delim;
         ignore_rest_of_line ();
         return;
       }
      symbolP = symbol_clone (symbolP, 1);
      S_CLEAR_VOLATILE (symbolP);
    }

  *end_name = delim;

  SKIP_WHITESPACE ();

  if (*input_line_pointer != ',')
    {
      *end_name = 0;
      as_bad (_("expected comma after \"%s\""), name);
      *end_name = delim;
      ignore_rest_of_line ();
      return;
    }

  input_line_pointer++;

  SKIP_WHITESPACE ();

  name = input_line_pointer;
  delim = get_symbol_end ();
  end_name = input_line_pointer;

  if (name == end_name)
    {
      as_bad (_("expected symbol name"));
      ignore_rest_of_line ();
      return;
    }

  if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
      && (symbolP2 = md_undefined_symbol (name)) == NULL)
    {
      symbolP2 = symbol_find_or_make (name);
      S_SET_WEAKREFD (symbolP2);
    }
  else
    {
      symbolS *symp = symbolP2;

      while (S_IS_WEAKREFR (symp) && symp != symbolP)
       {
         expressionS *expP = symbol_get_value_expression (symp);

         assert (expP->X_op == O_symbol
                && expP->X_add_number == 0);
         symp = expP->X_add_symbol;
       }
      if (symp == symbolP)
       {
         char *loop;

         loop = concat (S_GET_NAME (symbolP),
                      " => ", S_GET_NAME (symbolP2), NULL);

         symp = symbolP2;
         while (symp != symbolP)
           {
             char *old_loop = loop;
             symp = symbol_get_value_expression (symp)->X_add_symbol;
             loop = concat (loop, " => ", S_GET_NAME (symp), NULL);
             free (old_loop);
           }

         as_bad (_("%s: would close weakref loop: %s"),
                S_GET_NAME (symbolP), loop);

         free (loop);

         *end_name = delim;
         ignore_rest_of_line ();
         return;
       }

      /* Short-circuiting instead of just checking here might speed
        things up a tiny little bit, but loop error messages would
        miss intermediate links.  */
      /* symbolP2 = symp; */
    }

  *end_name = delim;

  memset (&exp, 0, sizeof (exp));
  exp.X_op = O_symbol;
  exp.X_add_symbol = symbolP2;

  S_SET_SEGMENT (symbolP, undefined_section);
  symbol_set_value_expression (symbolP, &exp);
  symbol_set_frag (symbolP, &zero_address_frag);
  S_SET_WEAKREFR (symbolP);

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static int scrub_from_string ( char *  buf,
int  buflen 
) [static]

Definition at line 538 of file read.c.

{
  int copy;

  copy = scrub_string_end - scrub_string;
  if (copy > buflen)
    copy = buflen;
  memcpy (buf, scrub_string, copy);
  scrub_string += copy;
  return copy;
}

Here is the caller graph for this function:

static void set_zero_frag ( symbolS *  symbolP) [static]

Definition at line 3423 of file read.c.

{
  if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
    symbol_set_frag (symbolP, &zero_address_frag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sizeof_leb128 ( valueT  value,
int  sign 
)

Definition at line 4572 of file read.c.

{
  if (sign)
    return sizeof_sleb128 ((offsetT) value);
  else
    return sizeof_uleb128 (value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sizeof_sleb128 ( offsetT  value) [inline, static]

Definition at line 4534 of file read.c.

{
  register int size = 0;
  register unsigned byte;

  do
    {
      byte = (value & 0x7f);
      /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
        Fortunately, we can structure things so that the extra work reduces
        to a noop on systems that do things "properly".  */
      value = (value >> 7) | ~(-(offsetT)1 >> 7);
      size += 1;
    }
  while (!(((value == 0) && ((byte & 0x40) == 0))
          || ((value == -1) && ((byte & 0x40) != 0))));

  return size;
}

Here is the caller graph for this function:

static int sizeof_uleb128 ( valueT  value) [inline, static]

Definition at line 4555 of file read.c.

{
  register int size = 0;
  register unsigned byte;

  do
    {
      byte = (value & 0x7f);
      value >>= 7;
      size += 1;
    }
  while (value != 0);

  return size;
}

Here is the caller graph for this function:

void stringer ( register int  append_zero)

Definition at line 4853 of file read.c.

{
  register unsigned int c;
  char *start;

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  /* The following awkward logic is to parse ZERO or more strings,
     comma separated. Recall a string expression includes spaces
     before the opening '\"' and spaces after the closing '\"'.
     We fake a leading ',' if there is (supposed to be)
     a 1st, expression. We keep demanding expressions for each ','.  */
  if (is_it_end_of_statement ())
    {
      c = 0;                /* Skip loop.  */
      ++input_line_pointer; /* Compensate for end of loop.  */
    }
  else
    {
      c = ',';                     /* Do loop.  */
    }
  /* If we have been switched into the abs_section then we
     will not have an obstack onto which we can hang strings.  */
  if (now_seg == absolute_section)
    {
      as_bad (_("strings must be placed into a section"));
      c = 0;
      ignore_rest_of_line ();
    }

  while (c == ',' || c == '<' || c == '"')
    {
      SKIP_WHITESPACE ();
      switch (*input_line_pointer)
       {
       case '\"':
         ++input_line_pointer;     /*->1st char of string.  */
         start = input_line_pointer;
         while (is_a_char (c = next_char_of_string ()))
           {
             FRAG_APPEND_1_CHAR (c);
           }
         if (append_zero)
           {
             FRAG_APPEND_1_CHAR (0);
           }
         know (input_line_pointer[-1] == '\"');

#ifndef NO_LISTING
#ifdef OBJ_ELF
         /* In ELF, when gcc is emitting DWARF 1 debugging output, it
            will emit .string with a filename in the .debug section
            after a sequence of constants.  See the comment in
            emit_expr for the sequence.  emit_expr will set
            dwarf_file_string to non-zero if this string might be a
            source file name.  */
         if (strcmp (segment_name (now_seg), ".debug") != 0)
           dwarf_file_string = 0;
         else if (dwarf_file_string)
           {
             c = input_line_pointer[-1];
             input_line_pointer[-1] = '\0';
             listing_source_file (start);
             input_line_pointer[-1] = c;
           }
#endif
#endif

         break;
       case '<':
         input_line_pointer++;
         c = get_single_number ();
         FRAG_APPEND_1_CHAR (c);
         if (*input_line_pointer != '>')
           {
             as_bad (_("expected <nn>"));
           }
         input_line_pointer++;
         break;
       case ',':
         input_line_pointer++;
         break;
       }
      SKIP_WHITESPACE ();
      c = *input_line_pointer;
    }

  demand_empty_rest_of_line ();
}                           /* stringer() */

Here is the call graph for this function:

Here is the caller graph for this function:

static int try_macro ( char  term,
const char *  line 
) [static]

Definition at line 552 of file read.c.

{
  sb out;
  const char *err;
  macro_entry *macro;

  if (check_macro (line, &out, &err, &macro))
    {
      if (err != NULL)
       as_bad ("%s", err);
      *input_line_pointer++ = term;
      input_scrub_include_sb (&out,
                           input_line_pointer, 1);
      sb_kill (&out);
      buffer_limit =
       input_scrub_next_buffer (&input_line_pointer);
#ifdef md_macro_info
      md_macro_info (macro);
#endif
      return 1;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 185 of file read.c.

Definition at line 178 of file read.c.

char* buffer [static]

Definition at line 158 of file read.c.

char* buffer_limit [static]

Definition at line 159 of file read.c.

Definition at line 172 of file read.c.

Definition at line 175 of file read.c.

char** include_dirs

Definition at line 169 of file read.c.

Definition at line 65 of file read.c.

char is_end_of_line[256]
Initial value:
 {



  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,       

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
}

Definition at line 129 of file read.c.

char lex_type[256]
Initial value:
 {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       
  0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  
  LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, 
  0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
}

Definition at line 108 of file read.c.

symbolS* line_label

Definition at line 189 of file read.c.

Definition at line 194 of file read.c.

Definition at line 200 of file read.c.

Definition at line 179 of file read.c.

Definition at line 153 of file read.c.

Definition at line 264 of file read.c.

int pop_override_ok = 0 [static]

Definition at line 466 of file read.c.

const char* pop_table_name [static]

Definition at line 467 of file read.c.

const pseudo_typeS potable[] [static]

Definition at line 266 of file read.c.

char* scrub_string [static]

Definition at line 534 of file read.c.

char* scrub_string_end [static]

Definition at line 535 of file read.c.

Definition at line 164 of file read.c.