Subversion Repositories Kolibri OS

/* read.c - read a source file -

   Copyright (C) 1986-2015 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   GAS is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with GAS; see the file COPYING.  If not, write to the Free

   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).

   But then, GNU isn't spozed to run on your machine anyway.

   (RMS is so shortsighted sometimes.)  */

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

/* This is the largest known floating point format (for now). It will

   grow when we do 4361 style flonums.  */

#define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)

/* Routines that read assembler source text to build spaghetti in memory.

   Another group of these functions is in the expr.c module.  */

#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"

#include "wchar.h"

#ifndef TC_START_LABEL

#define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')

#endif

/* Set by the object-format or the target.  */

#ifndef TC_IMPLICIT_LCOMM_ALIGNMENT

#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)		\

  do								\

    {								\

      if ((SIZE) >= 8)						\

	(P2VAR) = 3;						\

      else if ((SIZE) >= 4)					\

	(P2VAR) = 2;						\

      else if ((SIZE) >= 2)					\

	(P2VAR) = 1;						\

      else							\

	(P2VAR) = 0;						\

    }								\

  while (0)

#endif

char *input_line_pointer;	/*->next char of source file to parse.  */

#if BITS_PER_CHAR != 8

/*  The following table is indexed by[(char)] and will break if

    a char does not have exactly 256 states (hopefully 0:255!)!  */

die horribly;

#endif

#ifndef LEX_AT

#define LEX_AT 0

#endif

#ifndef LEX_BR

/* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */

#define LEX_BR 0

#endif

#ifndef LEX_PCT

/* The Delta 68k assembler permits % inside label names.  */

#define LEX_PCT 0

#endif

#ifndef LEX_QM

/* The PowerPC Windows NT assemblers permits ? inside label names.  */

#define LEX_QM 0

#endif

#ifndef LEX_HASH

/* The IA-64 assembler uses # as a suffix designating a symbol.  We include

   it in the symbol and strip it out in tc_canonicalize_symbol_name.  */

#define LEX_HASH 0

#endif

#ifndef LEX_DOLLAR

#define LEX_DOLLAR 3

#endif

#ifndef LEX_TILDE

/* The Delta 68k assembler permits ~ at start of label names.  */

#define LEX_TILDE 0

#endif

/* Used by is_... macros. our ctype[].  */

char lex_type[256] = {

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* @ABCDEFGHIJKLMNO */

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ[\]^_ */

  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,	/* 0123456789:;<=>? */

  LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	/* @ABCDEFGHIJKLMNO */

  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */

  0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	/* `abcdefghijklmno */

  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~.  */

  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

};

/* In: a character.

   Out: 1 if this character ends a line.

	2 if this character is a line separator.  */

char is_end_of_line[256] = {

#ifdef CR_EOL

  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,	/* @abcdefghijklmno */

#else

  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,	/* @abcdefghijklmno */

#endif

  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,	/* 0123456789:;<=>? */

  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	/* */

};

#ifndef TC_CASE_SENSITIVE

char original_case_string[128];

#endif

/* Functions private to this file.  */

static char *buffer;	/* 1st char of each buffer of lines is here.  */

static char *buffer_limit;	/*->1 + last char in buffer.  */

/* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1

   in the tc-.h file.  See the "Porting GAS" section of the

   internals manual.  */

int target_big_endian = TARGET_BYTES_BIG_ENDIAN;

/* Variables for handling include file directory table.  */

/* Table of pointers to directories to search for .include's.  */

char **include_dirs;

/* How many are in the table.  */

int include_dir_count;

/* Length of longest in table.  */

int include_dir_maxlen = 1;

#ifndef WORKING_DOT_WORD

struct broken_word *broken_words;

int new_broken_words;

#endif

/* The current offset into the absolute section.  We don't try to

   build frags in the absolute section, since no data can be stored

   there.  We just keep track of the current offset.  */

addressT abs_section_offset;

/* If this line had an MRI style label, it is stored in this variable.

   This is used by some of the MRI pseudo-ops.  */

symbolS *line_label;

/* This global variable is used to support MRI common sections.  We

   translate such sections into a common symbol.  This variable is

   non-NULL when we are in an MRI common section.  */

symbolS *mri_common_symbol;

/* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we

   need to align to an even byte boundary unless the next pseudo-op is

   dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment

   may be needed.  */

static int mri_pending_align;

#ifndef NO_LISTING

#ifdef OBJ_ELF

/* This variable is set to be non-zero if the next string we see might

   be the name of the source file in DWARF debugging information.  See

   the comment in emit_expr for the format we look for.  */

static int dwarf_file_string;

#endif

#endif

/* If the target defines the md_frag_max_var hook then we know

   enough to implement the .bundle_align_mode features.  */

#ifdef md_frag_max_var

# define HANDLE_BUNDLE

#endif

#ifdef HANDLE_BUNDLE

/* .bundle_align_mode sets this.  Normally it's zero.  When nonzero,

   it's the exponent of the bundle size, and aligned instruction bundle

   mode is in effect.  */

static unsigned int bundle_align_p2;

/* These are set by .bundle_lock and .bundle_unlock.  .bundle_lock sets

   bundle_lock_frag to frag_now and then starts a new frag with

   frag_align_code.  At the same time, bundle_lock_frain gets frchain_now,

   so that .bundle_unlock can verify that we didn't change segments.

   .bundle_unlock resets both to NULL.  If we detect a bundling violation,

   then we reset bundle_lock_frchain to NULL as an indicator that we've

   already diagnosed the error with as_bad and don't need a cascade of

   redundant errors, but bundle_lock_frag remains set to indicate that

   we are expecting to see .bundle_unlock.  */

static fragS *bundle_lock_frag;

static frchainS *bundle_lock_frchain;

/* This is incremented by .bundle_lock and decremented by .bundle_unlock,

   to allow nesting.  */

static unsigned int bundle_lock_depth;

#endif

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 size_t get_non_macro_line_sb (sb *);

static void generate_file_debug (void);

static char *_find_end_of_line (char *, int, int, int);

void

read_begin (void)

{

  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 (¬es, chunksize);

  obstack_begin (&cond_obstack, chunksize);

#ifndef tc_line_separator_chars

#define tc_line_separator_chars line_separator_chars

#endif

  /* Use machine dependent syntax.  */

  for (p = tc_line_separator_chars; *p; p++)

    is_end_of_line[(unsigned char) *p] = 2;

  /* Use more.  FIXME-SOMEDAY.  */

  if (flag_mri)

    lex_type['?'] = 3;

}

#ifndef TC_ADDRESS_BYTES

#define TC_ADDRESS_BYTES address_bytes

static inline int

address_bytes (void)

{

  /* 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;

}

#endif

/* Set up pseudo-op tables.  */

static struct hash_control *po_hash;

static const pseudo_typeS potable[] = {

  {"abort", s_abort, 0},

  {"align", s_align_ptwo, 0},

  {"altmacro", s_altmacro, 1},

  {"ascii", stringer, 8+0},

  {"asciz", stringer, 8+1},

  {"balign", s_align_bytes, 0},

  {"balignw", s_align_bytes, -2},

  {"balignl", s_align_bytes, -4},

/* block  */

#ifdef HANDLE_BUNDLE

  {"bundle_align_mode", s_bundle_align_mode, 0},

  {"bundle_lock", s_bundle_lock, 0},

  {"bundle_unlock", s_bundle_unlock, 0},

#endif

  {"byte", cons, 1},

  {"comm", s_comm, 0},

  {"common", s_mri_common, 0},

  {"common.s", s_mri_common, 1},

  {"data", s_data, 0},

  {"dc", cons, 2},

#ifdef TC_ADDRESS_BYTES

  {"dc.a", cons, 0},

#endif

  {"dc.b", cons, 1},

  {"dc.d", float_cons, 'd'},

  {"dc.l", cons, 4},

  {"dc.s", float_cons, 'f'},

  {"dc.w", cons, 2},

  {"dc.x", float_cons, 'x'},

  {"dcb", s_space, 2},

  {"dcb.b", s_space, 1},

  {"dcb.d", s_float_space, 'd'},

  {"dcb.l", s_space, 4},

  {"dcb.s", s_float_space, 'f'},

  {"dcb.w", s_space, 2},

  {"dcb.x", s_float_space, 'x'},

  {"ds", s_space, 2},

  {"ds.b", s_space, 1},

  {"ds.d", s_space, 8},

  {"ds.l", s_space, 4},

  {"ds.p", s_space, 12},

  {"ds.s", s_space, 4},

  {"ds.w", s_space, 2},

  {"ds.x", s_space, 12},

  {"debug", s_ignore, 0},

#ifdef S_SET_DESC

  {"desc", s_desc, 0},

#endif

/* dim  */

  {"double", float_cons, 'd'},

/* dsect  */

  {"eject", listing_eject, 0},	/* Formfeed listing.  */

  {"else", s_else, 0},

  {"elsec", s_else, 0},

  {"elseif", s_elseif, (int) O_ne},

  {"end", s_end, 0},

  {"endc", s_endif, 0},

  {"endfunc", s_func, 1},

  {"endif", s_endif, 0},

  {"endm", s_bad_end, 0},

  {"endr", s_bad_end, 1},

/* endef  */

  {"equ", s_set, 0},

  {"equiv", s_set, 1},

  {"eqv", s_set, -1},

  {"err", s_err, 0},

  {"error", s_errwarn, 1},

  {"exitm", s_mexit, 0},

/* extend  */

  {"extern", s_ignore, 0},	/* We treat all undef as ext.  */

  {"appfile", s_app_file, 1},

  {"appline", s_app_line, 1},

  {"fail", s_fail, 0},

  {"file", s_app_file, 0},

  {"fill", s_fill, 0},

  {"float", float_cons, 'f'},

  {"format", s_ignore, 0},

  {"func", s_func, 0},

  {"global", s_globl, 0},

  {"globl", s_globl, 0},

  {"hword", cons, 2},

  {"if", s_if, (int) O_ne},

  {"ifb", s_ifb, 1},

  {"ifc", s_ifc, 0},

  {"ifdef", s_ifdef, 0},

  {"ifeq", s_if, (int) O_eq},

  {"ifeqs", s_ifeqs, 0},

  {"ifge", s_if, (int) O_ge},

  {"ifgt", s_if, (int) O_gt},

  {"ifle", s_if, (int) O_le},

  {"iflt", s_if, (int) O_lt},

  {"ifnb", s_ifb, 0},

  {"ifnc", s_ifc, 1},

  {"ifndef", s_ifdef, 1},

  {"ifne", s_if, (int) O_ne},

  {"ifnes", s_ifeqs, 1},

  {"ifnotdef", s_ifdef, 1},

  {"incbin", s_incbin, 0},

  {"include", s_include, 0},

  {"int", cons, 4},

  {"irp", s_irp, 0},

  {"irep", s_irp, 0},

  {"irpc", s_irp, 1},

  {"irepc", s_irp, 1},

  {"lcomm", s_lcomm, 0},

  {"lflags", s_ignore, 0},	/* Listing flags.  */

  {"linefile", s_app_line, 0},

  {"linkonce", s_linkonce, 0},

  {"list", listing_list, 1},	/* Turn listing on.  */

  {"llen", listing_psize, 1},

  {"long", cons, 4},

  {"lsym", s_lsym, 0},

  {"macro", s_macro, 0},

  {"mexit", s_mexit, 0},

  {"mri", s_mri, 0},

  {".mri", s_mri, 0},	/* Special case so .mri works in MRI mode.  */

  {"name", s_ignore, 0},

  {"noaltmacro", s_altmacro, 0},

  {"noformat", s_ignore, 0},

  {"nolist", listing_list, 0},	/* Turn listing off.  */

  {"nopage", listing_nopage, 0},

  {"octa", cons, 16},

  {"offset", s_struct, 0},

  {"org", s_org, 0},

  {"p2align", s_align_ptwo, 0},

  {"p2alignw", s_align_ptwo, -2},

  {"p2alignl", s_align_ptwo, -4},

  {"page", listing_eject, 0},

  {"plen", listing_psize, 0},

  {"print", s_print, 0},

  {"psize", listing_psize, 0},	/* Set paper size.  */

  {"purgem", s_purgem, 0},

  {"quad", cons, 8},

  {"reloc", s_reloc, 0},

  {"rep", s_rept, 0},

  {"rept", s_rept, 0},

  {"rva", s_rva, 4},

  {"sbttl", listing_title, 1},	/* Subtitle of listing.  */

/* scl  */

/* sect  */

  {"set", s_set, 0},

  {"short", cons, 2},

  {"single", float_cons, 'f'},

/* size  */

  {"space", s_space, 0},

  {"skip", s_space, 0},

  {"sleb128", s_leb128, 1},

  {"spc", s_ignore, 0},

  {"stabd", s_stab, 'd'},

  {"stabn", s_stab, 'n'},

  {"stabs", s_stab, 's'},

  {"string", stringer, 8+1},

  {"string8", stringer, 8+1},

  {"string16", stringer, 16+1},

  {"string32", stringer, 32+1},

  {"string64", stringer, 64+1},

  {"struct", s_struct, 0},

/* tag  */

  {"text", s_text, 0},

  /* This is for gcc to use.  It's only just been added (2/94), so gcc

     won't be able to use it for a while -- probably a year or more.

     But once this has been released, check with gcc maintainers

     before deleting it or even changing the spelling.  */

  {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},

  /* If we're folding case -- done for some targets, not necessarily

     all -- the above string in an input file will be converted to

     this one.  Match it either way...  */

  {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},

  {"title", listing_title, 0},	/* Listing title.  */

  {"ttl", listing_title, 0},

/* type  */

  {"uleb128", s_leb128, 0},

/* use  */

/* val  */

  {"xcom", s_comm, 0},

  {"xdef", s_globl, 0},

  {"xref", s_ignore, 0},

  {"xstabs", s_xstab, 's'},

  {"warning", s_errwarn, 0},

  {"weakref", s_weakref, 0},

  {"word", cons, 2},

  {"zero", s_space, 0},

  {NULL, NULL, 0}			/* End sentinel.  */

};

static offsetT

get_absolute_expr (expressionS *exp)

{

  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;

}

offsetT

get_absolute_expression (void)

{

  expressionS exp;

  return get_absolute_expr (&exp);

}

static int pop_override_ok = 0;

static const char *pop_table_name;

void

pop_insert (const pseudo_typeS *table)

{

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

    }

}

#ifndef md_pop_insert

#define md_pop_insert()		pop_insert(md_pseudo_table)

#endif

#ifndef obj_pop_insert

#define obj_pop_insert()	pop_insert(obj_pseudo_table)

#endif

#ifndef cfi_pop_insert

#define cfi_pop_insert()	pop_insert(cfi_pseudo_table)

#endif

static void

pobegin (void)

{

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

  /* Now CFI ones.  */

  pop_table_name = "cfi";

  pop_override_ok = 1;

  cfi_pop_insert ();

}

#define HANDLE_CONDITIONAL_ASSEMBLY(num_read)				\

  if (ignore_input ())							\

    {									\

      char *eol = find_end_of_line (input_line_pointer - (num_read),	\

				    flag_m68k_mri);			\

      input_line_pointer = (input_line_pointer <= buffer_limit		\

			    && eol >= buffer_limit)			\

			   ? buffer_limit				\

			   : eol + 1;					\

      continue;								\

    }

/* This function is used when scrubbing the characters between #APP

   and #NO_APP.  */

static char *scrub_string;

static char *scrub_string_end;

static size_t

scrub_from_string (char *buf, size_t buflen)

{

  size_t copy;

  copy = scrub_string_end - scrub_string;

  if (copy > buflen)

    copy = buflen;

  memcpy (buf, scrub_string, copy);

  scrub_string += copy;

  return copy;

}

/* Helper function of read_a_source_file, which tries to expand a macro.  */

static int

try_macro (char term, const char *line)

{

  sb out;

  const char *err;

  macro_entry *macro;

  if (check_macro (line, &out, &err, ¯o))

    {

      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;

}

#ifdef HANDLE_BUNDLE

/* Start a new instruction bundle.  Returns the rs_align_code frag that

   will be used to align the new bundle.  */

static fragS *

start_bundle (void)

{

  fragS *frag = frag_now;

  frag_align_code (0, 0);

  while (frag->fr_type != rs_align_code)

    frag = frag->fr_next;

  gas_assert (frag != frag_now);

  return frag;

}

/* Calculate the maximum size after relaxation of the region starting

   at the given frag and extending through frag_now (which is unfinished).  */

static unsigned int

pending_bundle_size (fragS *frag)

{

  unsigned int offset = frag->fr_fix;

  unsigned int size = 0;

  gas_assert (frag != frag_now);

  gas_assert (frag->fr_type == rs_align_code);

  while (frag != frag_now)

    {

      /* This should only happen in what will later become an error case.  */

      if (frag == NULL)

	return 0;

      size += frag->fr_fix;

      if (frag->fr_type == rs_machine_dependent)

	size += md_frag_max_var (frag);

      frag = frag->fr_next;

    }

  gas_assert (frag == frag_now);

  size += frag_now_fix ();

  if (frag->fr_type == rs_machine_dependent)

    size += md_frag_max_var (frag);

  gas_assert (size >= offset);

  return size - offset;

}

/* Finish off the frag created to ensure bundle alignment.  */

static void

finish_bundle (fragS *frag, unsigned int size)

{

  gas_assert (bundle_align_p2 > 0);

  gas_assert (frag->fr_type == rs_align_code);

  if (size > 1)

    {

      /* If there is more than a single byte, then we need to set up the

	 alignment frag.  Otherwise we leave it at its initial state from

	 calling frag_align_code (0, 0), so that it does nothing.  */

      frag->fr_offset = bundle_align_p2;

      frag->fr_subtype = size - 1;

    }

  /* We do this every time rather than just in s_bundle_align_mode

     so that we catch any affected section without needing hooks all

     over for all paths that do section changes.  It's cheap enough.  */

  record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER);

}

/* Assemble one instruction.  This takes care of the bundle features

   around calling md_assemble.  */

static void

assemble_one (char *line)

{

  fragS *insn_start_frag = NULL;

  if (bundle_lock_frchain != NULL && bundle_lock_frchain != frchain_now)

    {

      as_bad (_("cannot change section or subsection inside .bundle_lock"));

      /* Clearing this serves as a marker that we have already complained.  */

      bundle_lock_frchain = NULL;

    }

  if (bundle_lock_frchain == NULL && bundle_align_p2 > 0)

    insn_start_frag = start_bundle ();

  md_assemble (line);

  if (bundle_lock_frchain != NULL)

    {

      /* Make sure this hasn't pushed the locked sequence

	 past the bundle size.  */

      unsigned int bundle_size = pending_bundle_size (bundle_lock_frag);

      if (bundle_size > (1U << bundle_align_p2))

	as_bad (_("\

.bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"),

		bundle_size, 1U << bundle_align_p2);

    }

  else if (bundle_align_p2 > 0)

    {

      unsigned int insn_size = pending_bundle_size (insn_start_frag);

      if (insn_size > (1U << bundle_align_p2))

	as_bad (_("\

single instruction is %u bytes long but .bundle_align_mode limit is %u"),

		(unsigned int) insn_size, 1U << bundle_align_p2);

      finish_bundle (insn_start_frag, insn_size);

    }

}

#else  /* !HANDLE_BUNDLE */

# define assemble_one(line) md_assemble(line)

#endif  /* HANDLE_BUNDLE */

/* We read the file, putting things into a web that represents what we

   have been reading.  */

void

read_a_source_file (char *name)

{

  char nul_char;

  char next_char;

  char *s;		/* String of symbol, '\0' appended.  */

  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

      while (input_line_pointer < buffer_limit)

	{

	  bfd_boolean was_new_line;

	  /* 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.  */

	  was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];

	  if (was_new_line)

	    {

	      symbol_set_value_now (&dot_symbol);

#ifdef md_start_line_hook

	      md_start_line_hook ();

#endif

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

		bump_line_counters ();

	    }

#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)

		{

		  /* Find the end of the current expanded macro line.  */

		  s = find_end_of_line (input_line_pointer, flag_m68k_mri);

		  if (s != last_eol)

		    {

		      char *copy;

		      int len;

		      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;

		      copy = (char *) xmalloc (len + macro_nest + 2);

		      memset (copy, '>', macro_nest);

		      copy[macro_nest] = ' ';

		      memcpy (copy + macro_nest + 1, input_line_pointer, len);

		      copy[macro_nest + 1 + len] = '\0';

		      /* Install the line with the listing facility.  */

		      listing_newline (copy);

		    }

		}

	      else

		listing_newline (NULL);

	    }

#endif

	  if (was_new_line)

	    {

	      line_label = NULL;

	      if (LABELS_WITHOUT_COLONS || flag_m68k_mri)

		{

		  next_char = * input_line_pointer;

		  /* Text at the start of a line must be a label, we

		     run down and stick a colon in.  */

		  if (is_name_beginner (next_char) || next_char == '"')

		    {

		      char *line_start;

		      int mri_line_macro;

		      HANDLE_CONDITIONAL_ASSEMBLY (0);

		      nul_char = get_symbol_name (& line_start);

		      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);

		      /* 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 (nul_char, next_char)

#endif

			  )

			line_label = colon (line_start);

		      else

			line_label = symbol_create (line_start,

						    absolute_section,

						    (valueT) 0,

						    &zero_address_frag);

		      next_char = restore_line_pointer (nul_char);

		      if (next_char == ':')

			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.  */

	  do

	    nul_char = next_char = *input_line_pointer++;

	  while (next_char == '\t' || next_char == ' ' || next_char == '\f');

	  /* C is the 1st significant character.

	     Input_line_pointer points after that character.  */

	  if (is_name_beginner (next_char) || next_char == '"')

	    {

	      char *rest;

	      /* Want user-defined label or pseudo/opcode.  */

	      HANDLE_CONDITIONAL_ASSEMBLY (1);

	      --input_line_pointer;

	      nul_char = get_symbol_name (& s);	/* name's delimiter.  */

	      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);

	      rest = input_line_pointer + (nul_char == '"' ? 2 : 1);

	      /* NEXT_CHAR is character after symbol.

		 The end of symbol 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 NUL_CHAR was.  */

	      if (TC_START_LABEL (s, nul_char, next_char))

		{

		  if (flag_m68k_mri)

		    {

		      /* 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.  */

		  restore_line_pointer (nul_char);

		  ++ input_line_pointer;

#ifdef tc_check_label

		  tc_check_label (line_label);

#endif

		  /* Input_line_pointer->after ':'.  */

		  SKIP_WHITESPACE ();

		}

	      else if ((next_char == '=' && *rest == '=')

		       || ((next_char == ' ' || next_char == '\t')

			   && rest[0] == '='

			   && rest[1] == '='))

		{

		  equals (s, -1);

		  demand_empty_rest_of_line ();

		}

	      else if ((next_char == '='

		       || ((next_char == ' ' || next_char == '\t')

			    && *rest == '='))

#ifdef TC_EQUAL_IN_INSN

			   && !TC_EQUAL_IN_INSN (next_char, 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: next_char 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;

			  (void) restore_line_pointer (nul_char);

			  s_ignore (0);

			  nul_char = next_char = *--input_line_pointer;

			  *input_line_pointer = '\0';

			  if (! macro_defined || ! try_macro (next_char, s))

			    {

			      *end = '\0';

			      as_bad (_("unknown pseudo-op: `%s'"), s);

			      *input_line_pointer++ = nul_char;

			    }

			  continue;

			}

		      /* Put it back for error messages etc.  */

		      next_char = restore_line_pointer (nul_char);

		      /* The following skip of whitespace is compulsory.

			 A well shaped space is sometimes all that separates

			 keyword from operands.  */

		      if (next_char == ' ' || next_char == '\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: next_char may be end-of-line.  */

		      /* Also: input_line_pointer->`\0` where nul_char was.  */

		      (void) restore_line_pointer (nul_char);

		      input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);

		      next_char = nul_char = *input_line_pointer;

		      *input_line_pointer = '\0';

		      generate_lineno_debug ();

		      if (macro_defined && try_macro (next_char, 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 ());

			    }

			}

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

		      *input_line_pointer++ = nul_char;

		      /* We resume loop AFTER the end-of-line from

			 this instruction.  */

		    }

		}

	      continue;

	    }

	  /* Empty statement?  */

	  if (is_end_of_line[(unsigned char) next_char])