/* read.c - read a source file -

   Copyright (C) 1986-2026 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 supposed 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 "scfidw2gen.h"

#include "codeview.h"

#include "wchar.h"

#include "filenames.h"

#include "ginsn.h"

#include <limits.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.  */

bool input_from_string = false;

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

#define LEX_CR LEX_WHITE

#else

#define LEX_CR LEX_EOL

#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] = {

  0x20, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0x20, 0, 0, LEX_CR, 0, 0, /* @ABCDEFGHIJKLMNO */

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

  8, 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

};

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

const char **include_dirs;

/* How many are in the table.  */

size_t include_dir_count;

/* Length of longest in table.  */

size_t include_dir_maxlen;

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

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

#ifndef NO_LISTING

#ifdef OBJ_ELF

static int dwarf_file;

static int dwarf_line;

/* 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 s_altmacro (int);

static void s_bad_end (int);

static void s_errwarn_if (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 void poend (void);

static size_t get_macro_line_sb (sb *);

static void generate_file_debug (void);

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

#if defined (TE_PE) && defined (O_secrel)

static void s_cv_comp (int sign);

#endif

void

read_begin (void)

{

  const char *p;

  pobegin ();

  obj_read_begin_hook ();

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

    lex_type[(unsigned char) *p] = LEX_EOS;

  if (flag_mri)

    lex_type['?'] = LEX_BEGIN_NAME | LEX_NAME;

  stabs_begin ();

#ifndef WORKING_DOT_WORD

  broken_words = NULL;

  new_broken_words = 0;

#endif

  abs_section_offset = 0;

  line_label = NULL;

  mri_common_symbol = NULL;

  mri_pending_align = 0;

  current_name = NULL;

  current_label = NULL;

#ifndef NO_LISTING

#ifdef OBJ_ELF

  dwarf_file = 0;

  dwarf_line = -1;

  dwarf_file_string = 0;

#endif

#endif

#ifdef HANDLE_BUNDLE

  bundle_align_p2 = 0;

  bundle_lock_frag = NULL;

  bundle_lock_frchain = NULL;

  bundle_lock_depth = 0;

#endif

}

void

read_end (void)

{

  if (!ENABLE_LEAK_CHECK)

    return;

  stabs_end ();

  poend ();

  _obstack_free (&cond_obstack, NULL);

  free (current_name);

  free (current_label);

  free (include_dirs);

}

#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 htab_t 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},

  {"base64", s_base64, 0},

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

#if defined (TE_PE) && defined (O_secrel)

  {"cv_scomp", s_cv_comp, 1},

  {"cv_ucomp", s_cv_comp, 0},

#endif

  {"data", s_data, 0},

  {"dc", cons, 2},

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

  {"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, 'p'},

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

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

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

  {"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},

  {"errif", s_errwarn_if, 1},

  {"error", s_errwarn, 1},

  {"exitm", s_mexit, 0},

/* extend  */

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

  {"fail", s_fail, 0},

  {"file", s_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_linefile, 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},

  {"nop", s_nop, 0},

  {"nops", s_nops, 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, 1},

  {"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'},

  {"warnif", s_errwarn_if, 0},

  {"warning", s_errwarn, 0},

  {"weakref", s_weakref, 0},

  {"word", cons, 2},

  {"zero", s_space, 0},

  {"2byte", cons, 2},

  {"4byte", cons, 4},

  {"8byte", cons, 8},

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

static const char *pop_table_name;

void

pop_insert (const pseudo_typeS *table)

{

  const pseudo_typeS *pop;

  for (pop = table; pop->poc_name; pop++)

    {

      if (str_hash_insert (po_hash, pop->poc_name, pop, 0) != NULL)

  {

    if (!pop_override_ok)

      as_fatal (_("error constructing %s pseudo-op table"),

          pop_table_name);

  }

    }

}

#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

#ifndef scfi_pop_insert

#define scfi_pop_insert() pop_insert(scfi_pseudo_table)

#endif

static void

pobegin (void)

{

  po_hash = str_htab_create ();

  /* Do the target-specific pseudo ops.  */

  pop_table_name = "md";

  pop_override_ok = 0;

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

#if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)

  if (flag_synth_cfi)

    {

      pop_table_name = "scfi";

      scfi_pop_insert ();

    }

  else

#endif

    {

      pop_table_name = "cfi";

      cfi_pop_insert ();

    }

}

static void

poend (void)

{

  if (ENABLE_LEAK_CHECK)

    htab_delete (po_hash);

}

#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;               \

    }

/* 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, &macro))

    {

      if (err != NULL)

  as_bad ("%s", err);

      *input_line_pointer++ = term;

      input_scrub_include_sb (&out,

            input_line_pointer, expanding_macro);

      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 (bundle_align_p2, 0);

  while (frag->fr_type != rs_align_code)

    frag = frag->fr_next;

  gas_assert (frag != frag_now);

  /* Set initial alignment to zero.  */

  frag->fr_offset = 0;

  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 valueT

pending_bundle_size (fragS *frag)

{

  valueT offset = frag->fr_fix;

  valueT 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 || now_seg == absolute_section);

  return size - offset;

}

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

static void

finish_bundle (fragS *frag, valueT 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 with zero alignment 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.  */

  if (bundle_align_p2 > OCTETS_PER_BYTE_POWER)

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

      valueT bundle_size = pending_bundle_size (bundle_lock_frag);

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

  as_bad (_ (".bundle_lock sequence at %" PRIu64 " bytes, "

       "but .bundle_align_mode limit is %" PRIu64 " bytes"),

    (uint64_t) bundle_size, (uint64_t) 1 << bundle_align_p2);

    }

  else if (bundle_align_p2 > 0)

    {

      valueT insn_size = pending_bundle_size (insn_start_frag);

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

  as_bad (_("single instruction is %" PRIu64 " bytes long, "

      "but .bundle_align_mode limit is %" PRIu64 " bytes"),

    (uint64_t) insn_size, (uint64_t) 1 << bundle_align_p2);

      finish_bundle (insn_start_frag, insn_size);

    }

}

#else  /* !HANDLE_BUNDLE */

# define assemble_one(line) md_assemble(line)

#endif  /* HANDLE_BUNDLE */

static bool

in_bss (void)

{

  flagword flags = bfd_section_flags (now_seg);

  return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS));

}

/* Guts of .align directive:

   N is the power of two to which to align.  A value of zero is accepted but

    ignored: the default alignment of the section will be at least this.

   FILL may be NULL, or it may point to the bytes of the fill pattern.

   LEN is the length of whatever FILL points to, if anything.  If LEN is zero

    but FILL is not NULL then LEN is treated as if it were one.

   MAX is the maximum number of characters to skip when doing the alignment,

    or 0 if there is no maximum.  */

void

do_align (unsigned int n, char *fill, unsigned int len, unsigned int max)

{

  if (now_seg == absolute_section || in_bss ())

    {

      if (fill != NULL)

  while (len-- > 0)

    if (*fill++ != '\0')

      {

        if (now_seg == absolute_section)

    as_warn (_("ignoring fill value in absolute section"));

        else

    as_warn (_("ignoring fill value in section `%s'"),

       segment_name (now_seg));

        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 > OCTETS_PER_BYTE_POWER) && !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

  if (n > OCTETS_PER_BYTE_POWER)

    record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);

}

/* Find first <eol><next_char>NO_APP<eol>, if any, in the supplied buffer.

   Return NULL if there's none, or else the position of <next_char>.

   Note: the S parameter to this function is typed as CHAR* rather than

   CONST CHAR* because if it is const then the strstr() function will return

   a const pointer, which in turn means that the END local would need to be

   const, which would mean that the function itself would have to return a

   const pointer, which means that input_line_pointer would have to become

   const, which would break lots of things.  (See PR 33696).  */

static char *

find_no_app (char *s, char next_char)

{

  const char *start = s;

  const char srch[] = { next_char, 'N', 'O', '_', 'A', 'P', 'P', '\0' };

  for (;;)

    {

      char * ends = strstr (s, srch);

      if (ends == NULL)

  break;

      if (is_end_of_line (ends[sizeof (srch) - 1])

    && (ends == start || is_end_of_line (ends[-1])))

  return ends;

      s = ends + sizeof (srch) - 1;

    }

  return NULL;

}

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

   have been reading.  */

void

read_a_source_file (const char *name)

{

  char nul_char;

  char next_char;

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

  long temp;

  const pseudo_typeS *pop;

#ifdef WARN_COMMENTS

  found_comment = 0;

#endif

  set_identify_name (name);

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

      char *last_eol = NULL;

#endif

      while (input_line_pointer < buffer_limit)

  {

    char 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 = lex_type[(unsigned char) input_line_pointer[-1]]

       & (LEX_EOL | LEX_EOS);

    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

          && !startswith (input_line_pointer,

              !flag_m68k_mri ? " .linefile "

                 : " linefile "))

        {

          char *copy;

          size_t 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 = XNEWVEC (char, 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

    next_char = *input_line_pointer;

    if ((was_new_line & LEX_EOL)

             && (strchr (line_comment_chars, '#')

      ? next_char == '#'

      : next_char && strchr (line_comment_chars, next_char)))

      {

        /* Its a comment.  Check for APP followed by NO_APP.  */

        sb sbuf;

        char *ends;

        size_t len;

        s = input_line_pointer + 1;

        if (!startswith (s, "APP") || !is_end_of_line (s[3]))

    {

      /* We ignore it.  Note: Not ignore_rest_of_line ()!  */

      while (s <= buffer_limit)

        if (is_end_of_line (*s++))

          break;

      input_line_pointer = s;

      continue;

    }

        s += 4;

        ends = find_no_app (s, next_char);

        len = ends ? ends - s : buffer_limit - s;

        sb_build (&sbuf, len + 100);

        sb_add_buffer (&sbuf, s, len);

        if (!ends)

    {

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

      do

        {

          buffer_limit = input_scrub_next_buffer (&buffer);

          if (!buffer_limit)

      break;

          ends = find_no_app (buffer, next_char);

          len = ends ? ends - buffer : buffer_limit - buffer;

          sb_add_buffer (&sbuf, buffer, len);

        }

      while (!ends);

    }

        sb_add_char (&sbuf, '\n');

        input_line_pointer = ends ? ends + 8 : NULL;

        input_scrub_include_sb (&sbuf, input_line_pointer, expanding_app);

        sb_kill (&sbuf);

        buffer_limit = input_scrub_next_buffer (&input_line_pointer);

        continue;

      }

    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;