/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/gas/read.c
Warning:	line 1824, column 5 2nd function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name read.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/gas -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/gas -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/gas -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/gas/config -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../include -I /usr/src/gnu/usr.bin/binutils-2.17/gas/.. -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../intl -I ../intl -D LOCALEDIR="/usr/share/locale" -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-null-pointer-arithmetic -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/gas -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/gas/read.c
1/* read.c - read a source file -
 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
 Free Software Foundation, Inc.

6This file is part of GAS, the GNU Assembler.

8GAS is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2, or (at your option)
11any later version.

13GAS is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16GNU General Public License for more details.

18You should have received a copy of the GNU General Public License
19along with GAS; see the file COPYING.  If not, write to the Free
20Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
2102110-1301, USA.  */

23/* 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.)  */
26#define MASK_CHAR((int)(unsigned char) -1) ((int)(unsigned char) -1)

28/* This is the largest known floating point format (for now). It will
 grow when we do 4361 style flonums.  */
30#define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT(16) (16)

32/* Routines that read assembler source text to build spaghetti in memory.
 Another group of these functions is in the expr.c module.  */

35#include "as.h"
36#include "safe-ctype.h"
37#include "subsegs.h"
38#include "sb.h"
39#include "macro.h"
40#include "obstack.h"
41#include "listing.h"
42#include "ecoff.h"
43#include "dw2gencfi.h"

45#ifndef TC_START_LABEL
46#define TC_START_LABEL(x,y)(x == ':') (x == ':')
47#endif

49/* Set by the object-format or the target.  */
50#ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51#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)		\
do								\
  {								\
    if ((SIZE) >= 8)						\
(P2VAR) = 3;						\
    else if ((SIZE) >= 4)					\
(P2VAR) = 2;						\
    else if ((SIZE) >= 2)					\
(P2VAR) = 1;						\
    else							\
(P2VAR) = 0;						\
  }								\
while (0)
64#endif

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

68#if BITS_PER_CHAR(8) != 8
69/*  The following table is indexed by[(char)] and will break if
  a char does not have exactly 256 states (hopefully 0:255!)!  */
71die horribly;
72#endif

74#ifndef LEX_AT0
75#define LEX_AT0 0
76#endif

78#ifndef LEX_BR0
79/* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
80#define LEX_BR0 0
81#endif

83#ifndef LEX_PCT0
84/* The Delta 68k assembler permits % inside label names.  */
85#define LEX_PCT0 0
86#endif

88#ifndef LEX_QM0
89/* The PowerPC Windows NT assemblers permits ? inside label names.  */
90#define LEX_QM0 0
91#endif

93#ifndef LEX_HASH0
94/* 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.  */
96#define LEX_HASH0 0
97#endif

99#ifndef LEX_DOLLAR3
100#define LEX_DOLLAR3 3
101#endif

103#ifndef LEX_TILDE0
104/* The Delta 68k assembler permits ~ at start of label names.  */
105#define LEX_TILDE0 0
106#endif

108/* Used by is_... macros. our ctype[].  */
109char 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_HASH0, LEX_DOLLAR3, LEX_PCT0, 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_QM0,	/* 0123456789:;<=>? */
LEX_AT0, 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_BR0, 0, LEX_BR0, 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_BR0, 0, LEX_BR0, LEX_TILDE0, 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
126};

128/* In: a character.
 Out: 1 if this character ends a line.  */
130char is_end_of_line[256] = {
131#ifdef CR_EOL
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,	/* @abcdefghijklmno */
133#else
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,	/* @abcdefghijklmno */
135#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	/* */
151};

153#ifndef TC_CASE_SENSITIVE
154char original_case_string[128];
155#endif

157/* Functions private to this file.  */

159static char *buffer;	/* 1st char of each buffer of lines is here.  */
160static char *buffer_limit;	/*->1 + last char in buffer.  */

162/* 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.  */
165int target_big_endian = TARGET_BYTES_BIG_ENDIAN0;

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

169/* Table of pointers to directories to search for .include's.  */
170char **include_dirs;

172/* How many are in the table.  */
173int include_dir_count;

175/* Length of longest in table.  */
176int include_dir_maxlen = 1;

178#ifndef WORKING_DOT_WORD
179struct broken_word *broken_words;
180int new_broken_words;
181#endif

183/* 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.  */
186addressT abs_section_offset;

188/* If this line had an MRI style label, it is stored in this variable.
 This is used by some of the MRI pseudo-ops.  */
190symbolS *line_label;

192/* 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.  */
195symbolS *mri_common_symbol;

197/* 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.  */
201static int mri_pending_align;

203#ifndef NO_LISTING
204#ifdef OBJ_ELF1
205/* 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.  */
208static int dwarf_file_string;
209#endif
210#endif

212static void do_s_func (int end_p, const char *default_prefix);
213static void do_align (int, char *, int, int);
214static void s_align (int, int);
215static void s_altmacro (int);
216static void s_bad_end (int);
217static int hex_float (int, char *);
218static segT get_known_segmented_expression (expressionS * expP);
219static void pobegin (void);
220static int get_line_sb (sb *);
221static void generate_file_debug (void);
222static char *_find_end_of_line (char *, int, int);
223
224void
225read_begin (void)
226{
const char *p;

pobegin ();
obj_read_begin_hookelf_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 ((&notes), (chunksize), 0, (void *(*) (long
)) xmalloc, (void (*) (void *)) free);
obstack_begin (&cond_obstack, chunksize)_obstack_begin ((&cond_obstack), (chunksize), 0, (void *(
*) (long)) xmalloc, (void (*) (void *)) free);

/* 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;
244}
245
246#ifndef TC_ADDRESS_BYTESaddress_bytes
247#define TC_ADDRESS_BYTESaddress_bytes address_bytes

249static inline int
250address_bytes (void)
251{
/* 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;
259}
260#endif

262/* Set up pseudo-op tables.  */

264static struct hash_control *po_hash;

266static const pseudo_typeS potable[] = {
{"abort", s_abort, 0},
{"align", s_align_ptwo, 0},
{"altmacro", s_altmacro, 1},
{"ascii", stringer, 0},
{"asciz", stringer, 1},
{"balign", s_align_bytes, 0},
{"balignw", s_align_bytes, -2},
{"balignl", s_align_bytes, -4},
275/* block  */
{"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},
282#ifdef TC_ADDRESS_BYTESaddress_bytes
{"dc.a", cons, 0},
284#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},
307#ifdef S_SET_DESC
{"desc", s_desc, 0},
309#endif
310/* dim  */
{"double", float_cons, 'd'},
312/* 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},
323/* 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},
330/* extend  */
{"extern", s_ignore, 0},	/* We treat all undef as ext.  */
{"appfile", s_app_file, 1},
{"appline", s_app_line, 0},
{"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", listing_flags, 0},	/* Listing flags.  */
{"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},
{"rep", s_rept, 0},
{"rept", s_rept, 0},
{"rva", s_rva, 4},
{"sbttl", listing_title, 1},	/* Subtitle of listing.  */
398/* scl  */
399/* sect  */
{"set", s_set, 0},
{"short", cons, 2},
{"single", float_cons, 'f'},
403/* 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, 1},
{"struct", s_struct, 0},
413/* 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},
428/* type  */
{"uleb128", s_leb128, 0},
430/* use  */
431/* 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((void*)0), NULL((void*)0), 0}			/* End sentinel.  */
441};

443static offsetT
444get_absolute_expr (expressionS *exp)
445{
expression_and_evaluate (exp)expr (0, exp, expr_evaluate);
if (exp->X_op != O_constant)
  {
    if (exp->X_op != O_absent)
as_bad (_("bad or irreducible absolute expression")("bad or irreducible absolute expression"));
    exp->X_add_number = 0;
  }
return exp->X_add_number;
454}

456offsetT
457get_absolute_expression (void)
458{
expressionS exp;

return get_absolute_expr (&exp);
462}

464static int pop_override_ok = 0;
465static const char *pop_table_name;

467void
468pop_insert (const pseudo_typeS *table)
469{
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")("error constructing %s pseudo-op table: %s"), pop_table_name,
  errtxt);
  }
479}

481#ifndef md_pop_insert
482#define md_pop_insert()pop_insert(md_pseudo_table)		pop_insert(md_pseudo_table)
483#endif

485#ifndef obj_pop_insert
486#define obj_pop_insert()elf_pop_insert()	pop_insert(obj_pseudo_table)
487#endif

489#ifndef cfi_pop_insert
490#define cfi_pop_insert()pop_insert(cfi_pseudo_table)	pop_insert(cfi_pseudo_table)
491#endif

493static void
494pobegin (void)
495{
po_hash = hash_new ();

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

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

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

511#ifdef TARGET_USE_CFIPOP1
pop_table_name = "cfi";
pop_override_ok = 1;
cfi_pop_insert ()pop_insert(cfi_pseudo_table);
515#endif
516}
517
518#define HANDLE_CONDITIONAL_ASSEMBLY()if (ignore_input ()) { char *eol = find_end_of_line (input_line_pointer
, 0); input_line_pointer = (input_line_pointer <= buffer_limit
 && eol >= buffer_limit) ? buffer_limit : eol + 1;
 continue; }					\
if (ignore_input ())							\
  {									\
    char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri0);	\
    input_line_pointer = (input_line_pointer <= buffer_limit		\
	    && eol >= buffer_limit)			\
	   ? buffer_limit				\
	   : eol + 1;					\
    continue;								\
  }

529/* This function is used when scrubbing the characters between #APP
 and #NO_APP.  */

532static char *scrub_string;
533static char *scrub_string_end;

535static int
536scrub_from_string (char *buf, int buflen)
537{
int copy;

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

548/* Helper function of read_a_source_file, which tries to expand a macro.  */
549static int
550try_macro (char term, const char *line)
551{
sb out;
const char *err;
macro_entry *macro;

if (check_macro (line, &out, &err, &macro))
  {
    if (err != NULL((void*)0))
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);
566#ifdef md_macro_info
    md_macro_info (macro);
568#endif
    return 1;
  }
return 0;
572}

574/* We read the file, putting things into a web that represents what we
 have been reading.  */
576void
577read_a_source_file (char *name)
578{
register char c;
register char *s;		/* String of symbol, '\0' appended.  */
register int temp;
pseudo_typeS *pop;

584#ifdef WARN_COMMENTS
found_comment = 0;
586#endif

buffer = input_scrub_new_file (name);

listing_file (name);
listing_newline (NULL((void*)0));
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.  */
601#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((void*)0);
607#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]])
   {
619#ifdef md_start_line_hook
     md_start_line_hook ();
621#endif
     if (input_line_pointer[-1] == '\n')
bump_line_counters ();

     line_label = NULL((void*)0);

     if (LABELS_WITHOUT_COLONS0 || flag_m68k_mri0)
{
  /* 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)( lex_type[(unsigned char) (*input_line_pointer)] & (2) ))
    {
      char *line_start = input_line_pointer;
      char c;
      int mri_line_macro;

      LISTING_NEWLINE (){ if (listing) listing_newline(((void*)0)); };
      HANDLE_CONDITIONAL_ASSEMBLY ()if (ignore_input ()) { char *eol = find_end_of_line (input_line_pointer
, 0); input_line_pointer = (input_line_pointer <= buffer_limit
 && eol >= buffer_limit) ? buffer_limit : eol + 1;
 continue; };

      c = get_symbol_end ();

      /* In MRI mode, the EQU and MACRO pseudoops must
	 be handled specially.  */
      mri_line_macro = 0;
      if (flag_m68k_mri0)
	{
	  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
673#ifdef TC_START_LABEL_WITHOUT_COLON
	  && TC_START_LABEL_WITHOUT_COLON(c,
					  input_line_pointer)
676#endif
	  )
	line_label = colon (line_start);
      else
	line_label = symbol_create (line_start,
				    absolute_section((asection *) &bfd_abs_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.  */

712#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_MACEXP64) && 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_mri0);

  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((void*)0));
   }
744#endif
 /* C is the 1st significant character.
    Input_line_pointer points after that character.  */
 if (is_name_beginner (c)( lex_type[(unsigned char) (c)] & (2) ))
   {
     /* Want user-defined label or pseudo/opcode.  */
     HANDLE_CONDITIONAL_ASSEMBLY ()if (ignore_input ()) { char *eol = find_end_of_line (input_line_pointer
, 0); input_line_pointer = (input_line_pointer <= buffer_limit
 && eol >= buffer_limit) ? buffer_limit : eol + 1;
 continue; };

     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)(c == ':'))
{
  if (flag_m68k_mri0)
    {
      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++ = ':';
786#ifdef tc_check_label
  tc_check_label (line_label);
788#endif
  /* Input_line_pointer->after ':'.  */
  SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
}
            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] == '='))
803#ifdef TC_EQUAL_IN_INSN
                         && !TC_EQUAL_IN_INSN (c, s)
805#endif
                         )
{
  equals (s, 1);
  demand_empty_rest_of_line ();
}
     else
{
  /* Expect pseudo-op or machine instruction.  */
  pop = NULL((void*)0);

816#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)_sch_tolower[(*s2) & 0xff];
	s2++;
      }
  }
829#endif
  if (NO_PSEUDO_DOT0 || flag_m68k_mri0)
    {
      /* The MRI assembler uses pseudo-ops without
	 a period.  */
      pop = (pseudo_typeS *) hash_find (po_hash, s);
      if (pop != NULL((void*)0) && pop->poc_handler == NULL((void*)0))
	pop = NULL((void*)0);
    }

  if (pop != NULL((void*)0)
      || (!flag_m68k_mri0 && *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((void*)0))
	pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
      if (pop && !pop->poc_handler)
	pop = NULL((void*)0);

      /* In MRI mode, we may need to insert an
	 automatic alignment directive.  What a hack
	 this is.  */
      if (mri_pending_align
	  && (pop == NULL((void*)0)
	      || !((pop->poc_handler == cons
		    && pop->poc_val == 1)
		   || (pop->poc_handler == s_space
		       && pop->poc_val == 1)
862#ifdef tc_conditional_pseudoop
		   || tc_conditional_pseudoop (pop)
864#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((void*)0), 0, 0);
	  mri_pending_align = 0;

	  if (line_label != NULL((void*)0))
	    {
	      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((void*)0))
	{
	  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'")("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_mri0, 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((void*)0), 0, 0);
	  mri_pending_align = 0;
	  if (line_label != NULL((void*)0))
	    {
	      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_DOLLAR0 || LOCAL_LABELS_FB1) && ISDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isdigit
)))
   {
     /* local label  ("4:")  */
     char *backup = input_line_pointer;

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

     temp = c - '0';

     /* Read the whole number.  */
     while (ISDIGIT (*input_line_pointer)(_sch_istable[(*input_line_pointer) & 0xff] & (unsigned
 short)(_sch_isdigit)))
{
  temp = (temp * 10) + *input_line_pointer - '0';
  ++input_line_pointer;
}

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

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

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

     if (LOCAL_LABELS_FB1
  && *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;

     bump_line_counters ();
     s = input_line_pointer;
     if (strncmp (s, "APP\n", 4))
continue;	/* We ignore it */
     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((void*)0);

  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 ()if (ignore_input ()) { char *eol = find_end_of_line (input_line_pointer
, 0); input_line_pointer = (input_line_pointer <= buffer_limit
 && eol >= buffer_limit) ? buffer_limit : eol + 1;
 continue; };

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

1117#ifdef md_after_pass_hook
    md_after_pass_hook ();
1119#endif
  }

quit:

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

1138/* Convert O_constant expression EXP into the equivalent O_big representation.
 Take the sign of the number from X_unsigned rather than X_add_number.  */

1141static void
1142convert_to_bignum (expressionS *exp)
1143{
valueT value;
unsigned int i;

value = exp->X_add_number;
for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM(1 << (1)); i++)
  {
    generic_bignum[i] = value & LITTLENUM_MASK(0xFFFF);
    value >>= LITTLENUM_NUMBER_OF_BITS(16);
  }
/* 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(0xFFFF);
exp->X_op = O_big;
exp->X_add_number = i;
1159}

1161/* For most MRI pseudo-ops, the line actually ends at the first
 nonquoted space.  This function looks for that point, stuffs a null
 in, and sets *STOPCP to the character that used to be there, and
 returns the location.

 Until I hear otherwise, I am going to assume that this is only true
 for the m68k MRI assembler.  */

1169char *
1170mri_comment_field (char *stopcp)
1171{
char *s;
1173#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;
  }
1186#else
for (s = input_line_pointer;
     !is_end_of_line[(unsigned char) *s];
     s++)
  ;
1191#endif
*stopcp = *s;
*s = '\0';

return s;
1196}

1198/* Skip to the end of an MRI comment field.  */

1200void
1201mri_comment_end (char *stop, int stopc)
1202{
know (flag_mri);

input_line_pointer = stop;
*stop = stopc;
while (!is_end_of_line[(unsigned char) *input_line_pointer])
  ++input_line_pointer;
1209}

1211void
1212s_abort (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1213{
as_fatal (_(".abort detected.  Abandoning ship.")(".abort detected.  Abandoning ship."));
1215}

1217/* Guts of .align directive.  N is the power of two to which to align.
 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.  MAX is
 the maximum number of characters to skip when doing the alignment,
 or 0 if there is no maximum.  */

1223static void
1224do_align (int n, char *fill, int len, int max)
1225{
if (now_seg == absolute_section((asection *) &bfd_abs_section))
  {
    if (fill != NULL((void*)0))
while (len-- > 0)
 if (*fill++ != '\0')
   {
     as_warn (_("ignoring fill value in absolute section")("ignoring fill value in absolute section"));
     break;
   }
    fill = NULL((void*)0);
    len = 0;
  }

1239#ifdef md_flush_pending_output
md_flush_pending_output ();
1241#endif
1242#ifdef md_do_align
md_do_align (n, fill, len, max, just_record_alignment)if ((n) && !need_pass_2 && optimize_align_code
 && (!(fill) || ((char)*(fill) == (char)0x90 &&
 (len) == 1)) && subseg_text_p (now_seg)) { frag_align_code
 ((n), (max)); goto just_record_alignment; };
1244#endif

/* Only make a frag if we HAVE to...  */
if (n != 0 && !need_pass_2)
  {
    if (fill == NULL((void*)0))
{
 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);
  }

1262#ifdef md_do_align
just_record_alignment: ATTRIBUTE_UNUSED_LABEL__attribute__ ((__unused__))
1264#endif

record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER0);
1267}

1269/* Handle the .align pseudo-op.  A positive ARG is a default alignment
 (in bytes).  A negative ARG is the negative of the length of the
 fill pattern.  BYTES_P is non-zero if the alignment value should be
 interpreted as the byte boundary, rather than the power of 2.  */

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

1276static void
1277s_align (int arg, int bytes_p)
1278{
unsigned int align_limit = ALIGN_LIMIT(stdoutput->arch_info->bits_per_address - 1);
unsigned int align;
char *stop = NULL((void*)0);
char stopc;
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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
  }

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")("alignment not a power of 2"));

 align = i;
}
  }

if (align > align_limit)
  {
    align = align_limit;
    as_warn (_("alignment too large: %u assumed")("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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
 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")("expected fill pattern missing"));
    do_align (align, (char *) NULL((void*)0), 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 ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c", 1377
, __PRETTY_FUNCTION__);
 md_number_to_charsnumber_to_chars_littleendian (ab, fill, fill_len);
 do_align (align, ab, fill_len, max);
}
  }

demand_empty_rest_of_line ();

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

1389/* Handle the .align pseudo-op on machines where ".align 4" means
 align to a 4 byte boundary.  */

1392void
1393s_align_bytes (int arg)
1394{
s_align (arg, 1);
1396}

1398/* Handle the .align pseudo-op on machines where ".align 4" means align
 to a 2**4 boundary.  */

1401void
1402s_align_ptwo (int arg)
1403{
s_align (arg, 0);
1405}

1407/* Switch in and out of alternate macro mode.  */

1409void
1410s_altmacro (int on)
1411{
demand_empty_rest_of_line ();
macro_set_alternate (on);
1414}

1416symbolS *
1417s_comm_internal (int param,
 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1419{
char *name;
char c;
char *p;
offsetT temp, size;
symbolS *symbolP = NULL((void*)0);
char *stop = NULL((void*)0);
char stopc;
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")("expected symbol name"));
    ignore_rest_of_line ();
    goto out;
  }

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

/* 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")("missing size expression"));
    ignore_rest_of_line ();
    goto out;
  }
else if (temp != size || !exp.X_unsigned)
  {
    as_warn (_("size (%ld) out of range, ignored")("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((void*)0);
 as_bad (_("symbol `%s' is already defined")("symbol `%s' is already defined"), name);
 *p = c;
 ignore_rest_of_line ();
 goto out;
}
    /* This could be avoided when the symbol wasn't used so far, but
the comment in struc-symbol.h says this flag isn't reliable.  */
    if (1 || !symbol_used_p (symbolP))
symbolP = symbol_clone (symbolP, 1);
    S_SET_SEGMENT (symbolP, undefined_section((asection *) &bfd_und_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")("size of \"%s\" is already %ld; not changing to %ld"),
    name, (long) size, (long) temp);

*p = c;
if (comm_parse_extra != NULL((void*)0))
  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((asection *) &bfd_com_section));
1506#ifdef OBJ_VMS
    {
extern int flag_one;
if (size == 0 || !flag_one)
 S_GET_OTHER (symbolP)(elf_s_get_other (symbolP)) = const_flag;
    }
1512#endif
  }

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

1522void
1523s_comm (int ignore)
1524{
s_comm_internal (ignore, NULL((void*)0));
1526}

1528/* The MRI COMMON pseudo-op.  We handle this by creating a common
 symbol with the appropriate name.  We make s_space do the right
 thing by increasing the size.  */

1532void
1533s_mri_common (int small ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1534{
char *name;
char c;
char *alc = NULL((void*)0);
symbolS *sym;
offsetT align;
char *stop = NULL((void*)0);
char stopc;

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

stop = mri_comment_field (&stopc);

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

name = input_line_pointer;
if (!ISDIGIT (*name)(_sch_istable[(*name) & 0xff] & (unsigned short)(_sch_isdigit
)))
  c = get_symbol_end ();
else
  {
    do
{
 ++input_line_pointer;
}
    while (ISDIGIT (*input_line_pointer)(_sch_istable[(*input_line_pointer) & 0xff] & (unsigned
 short)(_sch_isdigit)));

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

    if (line_label != NULL((void*)0))
{
 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((void*)0))
  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")("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((asection *) &bfd_com_section));
mri_common_symbol = sym;

1602#ifdef S_SET_ALIGN
if (align != 0)
  S_SET_ALIGN (sym, align)(((elf_symbol_type *) (&(symbol_get_bfdsym (sym))->the_bfd
))->internal_elf_sym.st_value = (align));
1605#endif

if (line_label != NULL((void*)0))
  {
    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);
1630}

1632void
1633s_data (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1634{
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);

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

1655/* Handle the .appfile pseudo-op.  This is automatically generated by
 do_scrub_chars when a preprocessor # line comment is seen with a
 file name.  This default definition may be overridden by the object
 or CPU specific pseudo-ops.  This function is also the default
 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
 .file.  */

1662void
1663s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1664{
1665#ifdef LISTING
if (listing)
  listing_source_file (file);
1668#endif
register_dependency (file);
1670#ifdef obj_app_fileelf_file_symbol
obj_app_fileelf_file_symbol (file, appfile);
1672#endif
1673}

1675void
1676s_app_file (int appfile)
1677{
register char *s;
int length;

/* Some assemblers tolerate immediately following '"'.  */
if ((s = demand_copy_string (&length)) != 0)
  {
    /* If this is a fake .appfile, a fake newline was inserted into
the buffer.  Passing -2 to new_logical_line tells it to
account for it.  */
    int may_omit
= (!new_logical_line (s, appfile ? -2 : -1) && appfile);

    /* In MRI mode, the preprocessor may have inserted an extraneous
backquote.  */
    if (flag_m68k_mri0
 && *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);
  }
1701}

1703/* Handle the .appline pseudo-op.  This is automatically generated by
 do_scrub_chars when a preprocessor # line comment is seen.  This
 default definition may be overridden by the object or CPU specific
 pseudo-ops.  */

1708void
1709s_app_line (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1710{
int l;

/* The given number is that of the next line.  */
l = get_absolute_expression () - 1;

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")("line numbers must be positive; line number %d rejected"),
    l + 1);
else
  {
    new_logical_line ((char *) NULL((void*)0), l);
1731#ifdef LISTING
    if (listing)
listing_source_line (l);
1734#endif
  }
demand_empty_rest_of_line ();
1737}

1739/* Handle the .end pseudo-op.  Actually, the real work is done in
 read_a_source_file.  */

1742void
1743s_end (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1744{
if (flag_mri)
  {
    /* The MRI assembler permits the start symbol to follow .end,
but we don't support that.  */
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    if (!is_end_of_line[(unsigned char) *input_line_pointer]
 && *input_line_pointer != '*'
 && *input_line_pointer != '!')
as_warn (_("start address not supported")("start address not supported"));
  }
1755}

1757/* Handle the .err pseudo-op.  */

1759void
1760s_err (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1761{
as_bad (_(".err encountered")(".err encountered"));
demand_empty_rest_of_line ();
1764}

1766/* Handle the .error and .warning pseudo-ops.  */

1768void
1769s_errwarn (int err)
1770{
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")(".error directive invoked in source file")
     : _(".warning 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")("%s argument must be a string"),
  err ? ".error" : ".warning");
 ignore_rest_of_line ();
 return;
}

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

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

1803/* Handle the MRI fail pseudo-op.  */

1805void
1806s_fail (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1807{
offsetT temp;
char *stop = NULL((void*)0);
char stopc;
1
'stopc' declared without an initial value→

if (flag_mri)
2
←
Assuming 'flag_mri' is 0→
3
←
Taking false branch→
  stop = mri_comment_field (&stopc);

temp = get_absolute_expression ();
if (temp >= 500)
4
←
Assuming 'temp' is < 500→
5
←
Taking false branch→
  as_warn (_(".fail %ld encountered")(".fail %ld encountered"), (long) temp);
else
  as_bad (_(".fail %ld encountered")(".fail %ld encountered"), (long) temp);

demand_empty_rest_of_line ();

if (flag_mri)
6
←
Assuming 'flag_mri' is not equal to 0→
7
←
Taking true branch→
  mri_comment_end (stop, stopc);
8
←
2nd function call argument is an uninitialized value
1825}

1827void
1828s_fill (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1829{
expressionS rep_exp;
long size = 1;
register long fill = 0;
char *p;

1835#ifdef md_flush_pending_output
md_flush_pending_output ();
1837#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.  */
1852#define BSD_FILL_SIZE_CROCK_8(8) (8)
if (size > BSD_FILL_SIZE_CROCK_8(8))
  {
    as_warn (_(".fill size clamped to %d")(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8(8));
    size = BSD_FILL_SIZE_CROCK_8(8);
  }
if (size < 0)
  {
    as_warn (_("size negative; .fill ignored")("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")("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.  */
1912#define BSD_FILL_SIZE_CROCK_4(4) (4)
    md_number_to_charsnumber_to_chars_littleendian (p, (valueT) fill,
	  (size > BSD_FILL_SIZE_CROCK_4(4)
	   ? BSD_FILL_SIZE_CROCK_4(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 ();
1923}

1925void
1926s_globl (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1927{
char *name;
int c;
symbolS *symbolP;
char *stop = NULL((void*)0);
char stopc;

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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    c = *input_line_pointer;
    if (c == ',')
{
 input_line_pointer++;
 SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
 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);
1961}

1963/* Handle the MRI IRP and IRPC pseudo-ops.  */

1965void
1966s_irp (int irpc)
1967{
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((void*)0))
  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);
1992}

1994/* Handle the .linkonce pseudo-op.  This tells the assembler to mark
 the section to only be linked once.  However, this is not supported
 by most object file formats.  This takes an optional argument,
 which is what to do about duplicates.  */

1999void
2000s_linkonce (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2001{
enum linkonce_type type;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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'")("unrecognized .linkonce type `%s'"), s);

    *input_line_pointer = c;
  }

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

  if ((bfd_applicable_section_flags (stdoutput)((stdoutput)->xvec->section_flags) & SEC_LINK_ONCE0x20000) == 0)
    as_warn (_(".linkonce is not supported for this object file format")(".linkonce is not supported for this object file format"));

  flags = bfd_get_section_flags (stdoutput, now_seg)((now_seg)->flags + 0);
  flags |= SEC_LINK_ONCE0x20000;
  switch (type)
    {
    default:
abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c", 2043
, __PRETTY_FUNCTION__);
    case LINKONCE_DISCARD:
flags |= SEC_LINK_DUPLICATES_DISCARD0x0;
break;
    case LINKONCE_ONE_ONLY:
flags |= SEC_LINK_DUPLICATES_ONE_ONLY0x80000;
break;
    case LINKONCE_SAME_SIZE:
flags |= SEC_LINK_DUPLICATES_SAME_SIZE0x100000;
break;
    case LINKONCE_SAME_CONTENTS:
flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS(0x80000 | 0x100000);
break;
    }
  if (!bfd_set_section_flags (stdoutput, now_seg, flags))
    as_bad (_("bfd_set_section_flags: %s")("bfd_set_section_flags: %s"),
     bfd_errmsg (bfd_get_error ()));
}
2061#endif /* ! defined (obj_handle_link_once) */

demand_empty_rest_of_line ();
2064}

2066void
2067bss_alloc (symbolS *symbolP, addressT size, int align)
2068{
char *pfrag;
segT current_seg = now_seg;
subsegT current_subseg = now_subseg;
segT bss_seg = bss_section;

2074#if defined (TC_MIPS) || defined (TC_ALPHA)
if (OUTPUT_FLAVORbfd_target_elf_flavour == bfd_target_ecoff_flavour
    || OUTPUT_FLAVORbfd_target_elf_flavour == 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_ALLOC0x001))
   as_warn (_("error setting flags for \".sbss\": %s")("error setting flags for \".sbss\": %s"),
     bfd_errmsg (bfd_get_error ()));
}
  }
2088#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((void*)0);

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

2105#ifdef S_SET_SIZE
S_SET_SIZE (symbolP, size)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))->
the_bfd))->internal_elf_sym.st_size = (size));
2107#endif
S_SET_SEGMENT (symbolP, bss_seg);

2110#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);
2116#endif /* OBJ_COFF */

subseg_set (current_seg, current_subseg);
2119}

2121offsetT
2122parse_align (int align_bytes)
2123{
expressionS exp;
addressT align;

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

input_line_pointer++;
SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

if (!exp.X_unsigned)
  {
    as_warn (_("alignment negative; 0 assumed")("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")("alignment not a power of 2"));
 ignore_rest_of_line ();
 return -1;
}
    align = alignp2;
  }
return align;
2164}

2166/* Called from s_comm_internal after symbol name and size have been
 parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
 1 if this was a ".bss" directive which has a 3rd argument
 (alignment as a power of 2), or 2 if this was a ".bss" directive
 with alignment in bytes.  */

2172symbolS *
2173s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2174{
addressT align = 0;

if (needs_align)
  {
    align = parse_align (needs_align - 1);
    if (align == (addressT) -1)
return NULL((void*)0);
  }
else
  /* Assume some objects may require alignment on some systems.  */
  TC_IMPLICIT_LCOMM_ALIGNMENT (size, align)do { if ((size) >= 8) (align) = 3; else if ((size) >= 4
) (align) = 2; else if ((size) >= 2) (align) = 1; else (align
) = 0; } while (0);

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

2191void
2192s_lcomm (int needs_align)
2193{
s_comm_internal (needs_align, s_lcomm_internal);
2195}

2197void
2198s_lcomm_bytes (int needs_align)
2199{
s_comm_internal (needs_align * 2, s_lcomm_internal);
2201}

2203void
2204s_lsym (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2205{
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")("expected symbol name"));
    ignore_rest_of_line ();
    return;
  }

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

input_line_pointer++;
expression_and_evaluate (&exp)expr (0, &exp, expr_evaluate);

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

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

if (S_GET_SEGMENT (symbolP) == undefined_section((asection *) &bfd_und_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((asection *) &bfd_abs_section)
      : reg_section));
    S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
  }
else
  {
    as_bad (_("symbol `%s' is already defined")("symbol `%s' is already defined"), name);
  }

*p = c;
demand_empty_rest_of_line ();
2267}

2269/* Read a line into an sb.  Returns the character that ended the line
 or zero if there are no more lines.  */

2272static int
2273get_line_sb (sb *line)
2274{
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_mri0);
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++;
2297}

2299/* Define a macro.  This is an interface to macro.c.  */

2301void
2302s_macro (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2303{
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((void*)0))
  {
    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((void*)0), get_line_sb, file, line, &name);
if (err != NULL((void*)0))
  as_bad_where (file, line, err, name);
else
  {
    if (line_label != NULL((void*)0))
{
 S_SET_SEGMENT (line_label, absolute_section((asection *) &bfd_abs_section));
 S_SET_VALUE (line_label, 0);
 symbol_set_frag (line_label, &zero_address_frag);
}

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

sb_kill (&s);
2351}

2353/* Handle the .mexit pseudo-op, which immediately exits a macro
 expansion.  */

2356void
2357s_mexit (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2358{
cond_exit_macro (macro_nest);
buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2361}

2363/* Switch in and out of MRI mode.  */

2365void
2366s_mri (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2367{
int on, old_flag;

on = get_absolute_expression ();
old_flag = flag_mri;
if (on != 0)
  {
    flag_mri = 1;
2375#ifdef TC_M68K
    flag_m68k_mri0 = 1;
2377#endif
    macro_mri_mode (1);
  }
else
  {
    flag_mri = 0;
2383#ifdef TC_M68K
    flag_m68k_mri0 = 0;
2385#endif
    macro_mri_mode (0);
  }

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

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

demand_empty_rest_of_line ();
2399}

2401/* Handle changing the location counter.  */

2403static void
2404do_org (segT segment, expressionS *exp, int fill)
2405{
if (segment != now_seg && segment != absolute_section((asection *) &bfd_abs_section))
  as_bad (_("invalid segment \"%s\"")("invalid segment \"%s\""), segment_name (segment)((segment)->name + 0));

if (now_seg == absolute_section((asection *) &bfd_abs_section))
  {
    if (fill != 0)
as_warn (_("ignoring fill value in absolute section")("ignoring fill value in absolute section"));
    if (exp->X_op != O_constant)
{
 as_bad (_("only constant offsets supported in absolute section")("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(1<<0);

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

2438void
2439s_org (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2440{
register segT segment;
expressionS exp;
register long temp_fill;

2445#ifdef md_flush_pending_output
md_flush_pending_output ();
2447#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_mri0)
  {
    as_bad (_("MRI style ORG pseudo-op not supported")("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 ();
2484}

2486/* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
 called by the obj-format routine which handles section changing
 when in MRI mode.  It will create a new section, and return it.  It
 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
 'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */

2492void
2493s_mri_sect (char *type ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2494{
2495#ifdef TC_M68K

char *name;
char c;
segT seg;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

name = input_line_pointer;
if (!ISDIGIT (*name)(_sch_istable[(*name) & 0xff] & (unsigned short)(_sch_isdigit
)))
  c = get_symbol_end ();
else
  {
    do
{
 ++input_line_pointer;
}
    while (ISDIGIT (*input_line_pointer)(_sch_istable[(*input_line_pointer) & 0xff] & (unsigned
 short)(_sch_isdigit)));

    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)_sch_toupper[(c) & 0xff];
    if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
*type = c;
    else
as_bad (_("unrecognized section type")("unrecognized section type"));
    ++input_line_pointer;

    {
flagword flags;

flags = SEC_NO_FLAGS0x000;
if (*type == 'C')
 flags = SEC_ALLOC0x001 | SEC_LOAD0x002 | SEC_READONLY0x008 | SEC_CODE0x010;
else if (*type == 'D' || *type == 'M')
 flags = SEC_ALLOC0x001 | SEC_LOAD0x002 | SEC_DATA0x020;
else if (*type == 'R')
 flags = SEC_ALLOC0x001 | SEC_LOAD0x002 | SEC_DATA0x020 | SEC_READONLY0x008 | SEC_ROM0x040;
if (flags != SEC_NO_FLAGS0x000)
 {
   if (!bfd_set_section_flags (stdoutput, seg, flags))
     as_warn (_("error setting flags for \"%s\": %s")("error setting flags for \"%s\": %s"),
       bfd_section_name (stdoutput, seg)((seg)->name),
       bfd_errmsg (bfd_get_error ()));
 }
    }
  }

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

demand_empty_rest_of_line ();

2570#else /* ! TC_M68K */
2571#ifdef TC_I960

char *name;
char c;
segT seg;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    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'")("unrecognized section type `%s'"), sectype);
    *input_line_pointer = c;
  }

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

    ++input_line_pointer;
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    seccmd = input_line_pointer;
    c = get_symbol_end ();
    if (strcasecmp (seccmd, "absolute") == 0)
{
 as_bad (_("absolute sections are not supported")("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'")("unrecognized section command `%s'"), seccmd);
 *input_line_pointer = c;
}
  }

demand_empty_rest_of_line ();

2643#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 ();
2648#endif /* ! TC_I960 */
2649#endif /* ! TC_M68K */
2650}

2652/* Handle the .print pseudo-op.  */

2654void
2655s_print (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2656{
char *s;
int len;

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

2666/* Handle the .purgem pseudo-op.  */

2668void
2669s_purgem (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2670{
if (is_it_end_of_statement ())
  {
    demand_empty_rest_of_line ();
    return;
  }

do
  {
    char *name;
    char c;

    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    name = input_line_pointer;
    c = get_symbol_end ();
    delete_macro (name);
    *input_line_pointer = c;
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
  }
while (*input_line_pointer++ == ',');

--input_line_pointer;
demand_empty_rest_of_line ();
2693}

2695/* Handle the .endm/.endr pseudo-ops.  */

2697static void
2698s_bad_end (int endr)
2699{
as_warn (_(".end%c encountered without preceeding %s")(".end%c encountered without preceeding %s"),
  endr ? 'r' : 'm',
  endr ? ".rept, .irp, or .irpc" : ".macro");
demand_empty_rest_of_line ();
2704}

2706/* Handle the .rept pseudo-op.  */

2708void
2709s_rept (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2710{
int count;

count = get_absolute_expression ();

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

2718/* This function provides a generic repeat block implementation.   It allows
 different directives to be used as the start/end keys.  */

2721void
2722do_repeat (int count, const char *start, const char *end)
2723{
sb one;
sb many;

sb_new (&one);
if (!buffer_and_nest (start, end, &one, get_line_sb))
  {
    as_bad (_("%s without %s")("%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);
2743}

2745/* Skip to end of current repeat loop; EXTRA indicates how many additional
 input buffers to skip.  Assumes that conditionals preceding the loop end
 are properly nested.

 This function makes it easier to implement a premature "break" out of the
 loop.  The EXTRA arg accounts for other buffers we might have inserted,
 such as line substitutions.  */

2753void
2754end_repeat (int extra)
2755{
cond_exit_macro (macro_nest);
while (extra-- >= 0)
  buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2759}

2761static void
2762assign_symbol (char *name, int mode)
2763{
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((void*)0)
    && (symbolP = md_undefined_symbol (name)) == NULL((void*)0))
  {
    symbolP = symbol_find_or_make (name);
2784#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_SYMBOLS2)
{
 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);
}
2796#endif
2797#ifdef OBJ_COFF
    /* "set" symbols are local unless otherwise specified.  */
    SF_SET_LOCAL (symbolP);
2800#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")("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)
 /* This could be avoided when the symbol wasn't used so far, but
    the comment in struc-symbol.h says this flag isn't reliable.  */
 && (1 || symbol_used_p (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);
2828}

2830/* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
 then this is .equiv, and it is an error if the symbol is already
 defined.  If EQUIV is -1, the symbol additionally is a forward
 reference.  */

2835void
2836s_set (int equiv)
2837{
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")("expected symbol name"));
    ignore_rest_of_line ();
    return;
  }

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

if (*input_line_pointer != ',')
  {
    *end_name = 0;
    as_bad (_("expected comma after \"%s\"")("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 ();
2875}

2877void
2878s_space (int mult)
2879{
expressionS exp;
expressionS val;
char *p = 0;
char *stop = NULL((void*)0);
char stopc;
int bytes;

2887#ifdef md_flush_pending_output
md_flush_pending_output ();
2889#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_mri0 && mult > 1)
  {
    if (now_seg == absolute_section((asection *) &bfd_abs_section))
{
 abs_section_offset += abs_section_offset & 1;
 if (line_label != NULL((void*)0))
   S_SET_VALUE (line_label, abs_section_offset);
}
    else if (mri_common_symbol != NULL((void*)0))
{
 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((void*)0))
{
  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((void*)0), 0, 0);
 if (line_label != NULL((void*)0))
   {
     symbol_set_frag (line_label, frag_now);
     S_SET_VALUE (line_label, frag_now_fix ());
   }
}
  }

bytes = mult;

expression (&exp)expr (0, &exp, expr_normal);

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
if (*input_line_pointer == ',')
  {
    ++input_line_pointer;
    expression (&val)expr (0, &val, expr_normal);
  }
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")("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((asection *) &bfd_abs_section) || mri_common_symbol != NULL((void*)0))
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")(".space repeat count is zero, ignored"));
     else if (repeat < 0)
as_warn (_(".space repeat count is negative, ignored")(".space repeat count is negative, ignored"));
     goto getout;
   }

 /* If we are in the absolute section, just bump the offset.  */
 if (now_seg == absolute_section((asection *) &bfd_abs_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((void*)0))
   {
     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((asection *) &bfd_abs_section))
   {
     as_bad (_("space allocation too complex in absolute section")("space allocation too complex in absolute section"));
     subseg_set (text_section, 0);
   }

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

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

3049/* This is like s_space, but the value is a floating point number with
 the given precision.  This is for the MRI dcb.s pseudo-op and
 friends.  */

3053void
3054s_float_space (int float_type)
3055{
offsetT count;
int flen;
char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT(16)];
char *stop = NULL((void*)0);
char stopc;

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

count = get_absolute_expression ();

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

++input_line_pointer;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

/* 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])(_sch_istable[(input_line_pointer[1]) & 0xff] & (unsigned
 short)(_sch_isalpha)))
  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")("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);
3129}

3131/* Handle the .struct pseudo-op, as found in MIPS assemblers.  */

3133void
3134s_struct (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3135{
char *stop = NULL((void*)0);
char stopc;

if (flag_mri)
  stop = mri_comment_field (&stopc);
abs_section_offset = get_absolute_expression ();
subseg_set (absolute_section((asection *) &bfd_abs_section), 0);
demand_empty_rest_of_line ();
if (flag_mri)
  mri_comment_end (stop, stopc);
3146}

3148void
3149s_text (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3150{
register int temp;

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

3161/* .weakref x, y sets x as an alias to y that, as long as y is not
 referenced directly, will cause y to become a weak symbol.  */
3163void
3164s_weakref (int ignore ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3165{
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")("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")("symbol `%s' is already defined"), name);
 *end_name = delim;
 ignore_rest_of_line ();
 return;
}
    /* This could be avoided when the symbol wasn't used so far, but
the comment in struc-symbol.h says this flag isn't reliable.  */
    if (1 || !symbol_used_p (symbolP))
symbolP = symbol_clone (symbolP, 1);
    S_CLEAR_VOLATILE (symbolP);
  }

*end_name = delim;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

input_line_pointer++;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

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

if ((symbolP2 = symbol_find_noref (name, 1)) == NULL((void*)0)
    && (symbolP2 = md_undefined_symbol (name)) == NULL((void*)0))
  {
    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((void) ((expP->X_op == O_symbol && expP->X_add_number
 == 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c"
, 3246, __PRETTY_FUNCTION__), 0)))
  && expP->X_add_number == 0)((void) ((expP->X_op == O_symbol && expP->X_add_number
 == 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c"
, 3246, __PRETTY_FUNCTION__), 0)));
 symp = expP->X_add_symbol;
}
    if (symp == symbolP)
{
 char *loop;

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

 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((void*)0));
     free (old_loop);
   }

 as_bad (_("%s: would close weakref loop: %s")("%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((asection *) &bfd_und_section));
symbol_set_value_expression (symbolP, &exp);
symbol_set_frag (symbolP, &zero_address_frag);
S_SET_WEAKREFR (symbolP);

demand_empty_rest_of_line ();
3293}
3294

3296/* Verify that we are at the end of a line.  If not, issue an error and
 skip to EOL.  */

3299void
3300demand_empty_rest_of_line (void)
3301{
SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
if (is_end_of_line[(unsigned char) *input_line_pointer])
  input_line_pointer++;
else
  {
    if (ISPRINT (*input_line_pointer)(_sch_istable[(*input_line_pointer) & 0xff] & (unsigned
 short)(_sch_isprint)))
as_bad (_("junk at end of line, first unrecognized character is `%c'")("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")("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]]);
3318}

3320/* Silently advance to the end of line.  Use this after already having
 issued an error about something bad.  */

3323void
3324ignore_rest_of_line (void)
3325{
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]]);
3334}

3336/* Sets frag for given symbol to zero_address_frag, except when the
 symbol frag is already set to a dummy listing frag.  */

3339static void
3340set_zero_frag (symbolS *symbolP)
3341{
if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
  symbol_set_frag (symbolP, &zero_address_frag);
3344}

3346/* In:	Pointer to a symbol.
Input_line_pointer->expression.

 Out:	Input_line_pointer->just after any whitespace after expression.
Tried to set symbol to value of expression.
Will change symbols type, value, and frag;  */

3353void
3354pseudo_set (symbolS *symbolP)
3355{
expressionS exp;
segT seg;

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

if (!S_IS_FORWARD_REF (symbolP))
  (void) expression (&exp)expr (0, &exp, expr_normal);
else
  (void) deferred_expression (&exp)expr (0, &exp, expr_defer);

if (exp.X_op == O_illegal)
  as_bad (_("illegal expression")("illegal expression"));
else if (exp.X_op == O_absent)
  as_bad (_("missing expression")("missing expression"));
else if (exp.X_op == O_big)
  {
    if (exp.X_add_number > 0)
as_bad (_("bignum invalid")("bignum invalid"));
    else
as_bad (_("floating point number invalid")("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))( (S_GET_SEGMENT (exp.X_add_symbol)) != ((asection *) &bfd_abs_section
) && (S_GET_SEGMENT (exp.X_add_symbol)) != ((asection
 *) &bfd_und_section) && (S_GET_SEGMENT (exp.X_add_symbol
)) != reg_section && (S_GET_SEGMENT (exp.X_add_symbol
)) != expr_section)
  && (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((asection *) &bfd_abs_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((asection *) &bfd_und_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((asection *) &bfd_und_section))
{
 symbolS *s = exp.X_add_symbol;

 if (S_IS_COMMON (s))
   as_bad (_("`%s' can't be equated to common symbol '%s'")("`%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((asection *) &bfd_und_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;
  }
3451}
3452
3453/*			cons()

 CONStruct more frag of .bytes, or .words etc.
 Should need_pass_2 be 1 then emit no frag(s).
 This understands EXPRESSIONS.

 Bug (?)

 This has a split personality. We use expression() to read the
 value. We can detect if the value won't fit in a byte or word.
 But we can't detect if expression() discarded significant digits
 in the case of a long. Not worth the crocks required to fix it.  */

3466/* Select a parser for cons expressions.  */

3468/* Some targets need to parse the expression in various fancy ways.
 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
 (for example, the HPPA does this).  Otherwise, you can define
 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
 REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
 are defined, which is the normal case, then only simple expressions
 are permitted.  */

3476#ifdef TC_M68K
3477static void
3478parse_mri_cons (expressionS *exp, unsigned int nbytes);
3479#endif

3481#ifndef TC_PARSE_CONS_EXPRESSION
3482#ifdef BITFIELD_CONS_EXPRESSIONS
3483#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES)x86_cons (EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3484static void
3485parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3486#endif
3487#ifdef REPEAT_CONS_EXPRESSIONS
3488#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES)x86_cons (EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3489static void
3490parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3491#endif

3493/* If we haven't gotten one yet, just call expression.  */
3494#ifndef TC_PARSE_CONS_EXPRESSION
3495#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES)x86_cons (EXP, NBYTES) expression (EXP)expr (0, EXP, expr_normal)
3496#endif
3497#endif

3499void
3500do_parse_cons_expression (expressionS *exp,
	  int nbytes ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3502{
TC_PARSE_CONS_EXPRESSION (exp, nbytes)x86_cons (exp, nbytes);
3504}


3507/* Worker to do .byte etc statements.
 Clobbers input_line_pointer and checks end-of-line.  */

3510static void
3511cons_worker (register int nbytes,	/* 1=.byte, 2=.word, 4=.long.  */
    int rva)
3513{
int c;
expressionS exp;
char *stop = NULL((void*)0);
char stopc;

3519#ifdef md_flush_pending_output
md_flush_pending_output ();
3521#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;
  }

3534#ifdef TC_ADDRESS_BYTESaddress_bytes
if (nbytes == 0)
  nbytes = TC_ADDRESS_BYTESaddress_bytes ();
3537#endif

3539#ifdef md_cons_align
md_cons_align (nbytes);
3541#endif

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

    if (rva)
{
 if (exp.X_op == O_symbol)
   exp.X_op = O_symbol_rva;
 else
   as_fatal (_("rva without symbol")("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);
3577}

3579void
3580cons (int size)
3581{
cons_worker (size, 0);
3583}

3585void
3586s_rva (int size)
3587{
cons_worker (size, 1);
3589}

3591/* Put the contents of expression EXP into the object file using
 NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */

3594void
3595emit_expr (expressionS *exp, unsigned int nbytes)
3596{
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 ();

3607#ifndef NO_LISTING
3608#ifdef OBJ_ELF1
/* 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)((now_seg)->name + 0), ".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)((now_seg)->name + 0), ".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;
}
3668#endif
3669#endif

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

op = exp->X_op;

/* Allow `.word 0' in the absolute section.  */
if (now_seg == absolute_section((asection *) &bfd_abs_section))
  {
    if (op != O_constant || exp->X_add_number != 0)
as_bad (_("attempt to store value in absolute section")("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(0xFFFF)))
   & LITTLENUM_MASK(0xFFFF))
  + carry);
 generic_bignum[i] = next & LITTLENUM_MASK(0xFFFF);
 carry = next >> LITTLENUM_NUMBER_OF_BITS(16);
}

    /* 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")("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")("floating point number invalid"));
    exp->X_add_number = 0;
    op = O_constant;
  }
else if (op == O_register)
  {
    as_warn (_("register value used as expression")("register value used as expression"));
    op = O_constant;
  }

p = frag_more ((int) nbytes);

3736#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;
  }
3759#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(8) - 1);
}
    else
{
 /* Don't store these bits.  */
 mask = ~(valueT) 0 << (BITS_PER_CHAR(8) * nbytes);
 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR(8) - 1);
}

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

3797#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.  */
3800#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")("value 0x%lx truncated to 0x%lx"),
   (unsigned long) get, (unsigned long) use);
}
    /* Put bytes in right order.  */
    md_number_to_charsnumber_to_chars_littleendian (p, use, (int) nbytes);
  }
else if (op == O_big)
  {
    unsigned int size;
    LITTLENUM_TYPE *nums;

    size = exp->X_add_number * CHARS_PER_LITTLENUM(1 << (1));
    if (nbytes < size)
{
 int i = nbytes / CHARS_PER_LITTLENUM(1 << (1));
 if (i != 0)
   {
     LITTLENUM_TYPE sign = 0;
     if ((generic_bignum[--i]
   & (1 << (LITTLENUM_NUMBER_OF_BITS(16) - 1))) != 0)
sign = ~(LITTLENUM_TYPE) 0;
     while (++i < exp->X_add_number)
if (generic_bignum[i] != sign)
  break;
   }
 if (i < exp->X_add_number)
   as_warn (_("bignum truncated to %d bytes")("bignum truncated to %d bytes"), nbytes);
 size = nbytes;
}

    if (nbytes == 1)
{
 md_number_to_charsnumber_to_chars_littleendian (p, (valueT) generic_bignum[0], 1);
 return;
}
    know (nbytes % CHARS_PER_LITTLENUM == 0);

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

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

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

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

3889#ifdef TC_CONS_FIX_NEW
    TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp)x86_cons_fix_new(frag_now, p - frag_now->fr_literal, nbytes
, exp);
3891#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")("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);
    }
3917#endif
  }
3919}
3920
3921#ifdef BITFIELD_CONS_EXPRESSIONS

3923/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
 w:x,y:z, where w and y are bitwidths and x and y are values.  They
 then pack them all together. We do a little better in that we allow
 them in words, longs, etc. and we'll pack them in target byte order
 for you.

 The rules are: pack least significant bit first, if a field doesn't
 entirely fit, put it in the next unit.  Overflowing the bitfield is
 explicitly *not* even a warning.  The bitwidth should be considered
 a "mask".

 To use this function the tc-XXX.h file should define
 BITFIELD_CONS_EXPRESSIONS.  */

3937static void
3938parse_bitfield_cons (exp, nbytes)
   expressionS *exp;
   unsigned int nbytes;
3941{
unsigned int bits_available = BITS_PER_CHAR(8) * nbytes;
char *hold = input_line_pointer;

(void) expression (exp)expr (0, exp, expr_normal);

if (*input_line_pointer == ':')
  {
    /* Bitfields.  */
    long value = 0;

    for (;;)
{
 unsigned long width;

 if (*input_line_pointer != ':')
   {
     input_line_pointer = hold;
     break;
   }			/* Next piece is not a bitfield.  */

 /* In the general case, we can't allow
    full expressions with symbol
    differences and such.  The relocation
    entries for symbols not defined in this
    assembly would require arbitrary field
    widths, positions, and masks which most
    of our current object formats don't
    support.

    In the specific case where a symbol
    *is* defined in this assembly, we
    *could* build fixups and track it, but
    this could lead to confusion for the
    backends.  I'm lazy. I'll take any
    SEG_ABSOLUTE. I think that means that
    you can use a previous .set or
    .equ type symbol.  xoxorich.  */

 if (exp->X_op == O_absent)
   {
     as_warn (_("using a bit field width of zero")("using a bit field width of zero"));
     exp->X_add_number = 0;
     exp->X_op = O_constant;
   }			/* Implied zero width bitfield.  */

 if (exp->X_op != O_constant)
   {
     *input_line_pointer = '\0';
     as_bad (_("field width \"%s\" too complex for a bitfield")("field width \"%s\" too complex for a bitfield"), hold);
     *input_line_pointer = ':';
     demand_empty_rest_of_line ();
     return;
   }			/* Too complex.  */

 if ((width = exp->X_add_number) > (BITS_PER_CHAR(8) * nbytes))
   {
     as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits")("field width %lu too big to fit in %d bytes: truncated to %d bits"
),
       width, nbytes, (BITS_PER_CHAR(8) * nbytes));
     width = BITS_PER_CHAR(8) * nbytes;
   }			/* Too big.  */

 if (width > bits_available)
   {
     /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
     input_line_pointer = hold;
     exp->X_add_number = value;
     break;
   }			/* Won't fit.  */

 /* Skip ':'.  */
 hold = ++input_line_pointer;

 (void) expression (exp)expr (0, exp, expr_normal);
 if (exp->X_op != O_constant)
   {
     char cache = *input_line_pointer;

     *input_line_pointer = '\0';
     as_bad (_("field value \"%s\" too complex for a bitfield")("field value \"%s\" too complex for a bitfield"), hold);
     *input_line_pointer = cache;
     demand_empty_rest_of_line ();
     return;
   }			/* Too complex.  */

 value |= ((~(-1 << width) & exp->X_add_number)
    << ((BITS_PER_CHAR(8) * nbytes) - bits_available));

 if ((bits_available -= width) == 0
     || is_it_end_of_statement ()
     || *input_line_pointer != ',')
   {
     break;
   }			/* All the bitfields we're gonna get.  */

 hold = ++input_line_pointer;
 (void) expression (exp)expr (0, exp, expr_normal);
}

    exp->X_add_number = value;
    exp->X_op = O_constant;
    exp->X_unsigned = 1;
  }
4044}

4046#endif /* BITFIELD_CONS_EXPRESSIONS */
4047
4048/* Handle an MRI style string expression.  */

4050#ifdef TC_M68K
4051static void
4052parse_mri_cons (exp, nbytes)
   expressionS *exp;
   unsigned int nbytes;
4055{
if (*input_line_pointer != '\''
    && (input_line_pointer[1] != '\''
 || (*input_line_pointer != 'A'
     && *input_line_pointer != 'E')))
  TC_PARSE_CONS_EXPRESSION (exp, nbytes)x86_cons (exp, nbytes);
else
  {
    unsigned int scan;
    unsigned int result = 0;

    /* An MRI style string.  Cut into as many bytes as will fit into
a nbyte chunk, left justify if necessary, and separate with
commas so we can try again later.  */
    if (*input_line_pointer == 'A')
++input_line_pointer;
    else if (*input_line_pointer == 'E')
{
 as_bad (_("EBCDIC constants are not supported")("EBCDIC constants are not supported"));
 ++input_line_pointer;
}

    input_line_pointer++;
    for (scan = 0; scan < nbytes; scan++)
{
 if (*input_line_pointer == '\'')
   {
     if (input_line_pointer[1] == '\'')
{
  input_line_pointer++;
}
     else
break;
   }
 result = (result << 8) | (*input_line_pointer++);
}

    /* Left justify.  */
    while (scan < nbytes)
{
 result <<= 8;
 scan++;
}

    /* Create correct expression.  */
    exp->X_op = O_constant;
    exp->X_add_number = result;

    /* Fake it so that we can read the next char too.  */
    if (input_line_pointer[0] != '\'' ||
 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
{
 input_line_pointer -= 2;
 input_line_pointer[0] = ',';
 input_line_pointer[1] = '\'';
}
    else
input_line_pointer++;
  }
4114}
4115#endif /* TC_M68K */
4116
4117#ifdef REPEAT_CONS_EXPRESSIONS

4119/* Parse a repeat expression for cons.  This is used by the MIPS
 assembler.  The format is NUMBER:COUNT; NUMBER appears in the
 object file COUNT times.

 To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */

4125static void
4126parse_repeat_cons (exp, nbytes)
   expressionS *exp;
   unsigned int nbytes;
4129{
expressionS count;
register int i;

expression (exp)expr (0, exp, expr_normal);

if (*input_line_pointer != ':')
  {
    /* No repeat count.  */
    return;
  }

++input_line_pointer;
expression (&count)expr (0, &count, expr_normal);
if (count.X_op != O_constant
    || count.X_add_number <= 0)
  {
    as_warn (_("unresolvable or nonpositive repeat count; using 1")("unresolvable or nonpositive repeat count; using 1"));
    return;
  }

/* The cons function is going to output this expression once.  So we
   output it count - 1 times.  */
for (i = count.X_add_number - 1; i > 0; i--)
  emit_expr (exp, nbytes);
4154}

4156#endif /* REPEAT_CONS_EXPRESSIONS */
4157
4158/* Parse a floating point number represented as a hex constant.  This
 permits users to specify the exact bits they want in the floating
 point number.  */

4162static int
4163hex_float (int float_type, char *bytes)
4164{
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'")("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)(((unsigned int) _hex_value[(unsigned char) (*input_line_pointer
)]) != 99) || *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")("floating point constant too large"));
 return -1;
}
    d = hex_value (*input_line_pointer)((unsigned int) _hex_value[(unsigned char) (*input_line_pointer
)]) << 4;
    ++input_line_pointer;
    while (*input_line_pointer == '_')
++input_line_pointer;
    if (hex_p (*input_line_pointer)(((unsigned int) _hex_value[(unsigned char) (*input_line_pointer
)]) != 99))
{
 d += hex_value (*input_line_pointer)((unsigned int) _hex_value[(unsigned char) (*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;
4245}

4247/*			float_cons()

 CONStruct some more frag chars of .floats .ffloats etc.
 Makes 0 or more new frags.
 If need_pass_2 == 1, no frags are emitted.
 This understands only floating literals, not expressions. Sorry.

 A floating constant is defined by atof_generic(), except it is preceded
 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
 reading, I decided to be incompatible. This always tries to give you
 rounded bits to the precision of the pseudo-op. Former AS did premature
 truncation, restored noisy bits instead of trailing 0s AND gave you
 a choice of 2 flavours of noise according to which of 2 floating-point
 scanners you directed AS to use.

 In:	input_line_pointer->whitespace before, or '0' of flonum.  */

4264void
4265float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
   register int float_type	/* 'f':.ffloat ... 'F':.float ...  */)
4267{
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(16)];

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

4279#ifdef md_flush_pending_output
md_flush_pending_output ();
4281#endif

do
  {
    /* input_line_pointer->1st char of a flonum (we hope!).  */
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

    /* 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])(_sch_istable[(input_line_pointer[1]) & 0xff] & (unsigned
 short)(_sch_isalpha)))
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")("bad floating literal: %s"), err);
     ignore_rest_of_line ();
     return;
   }
}

    if (!need_pass_2)
{
 int count;

 count = 1;

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

     ++input_line_pointer;
     expression (&count_exp)expr (0, &count_exp, expr_normal);

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

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

/* Put terminator back into stream.  */
--input_line_pointer;
demand_empty_rest_of_line ();
4356}
4357
4358/* Return the size of a LEB128 value.  */

4360static inline int
4361sizeof_sleb128 (offsetT value)
4362{
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;
4379}

4381static inline int
4382sizeof_uleb128 (valueT value)
4383{
register int size = 0;
register unsigned byte;

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

return size;
4396}

4398int
4399sizeof_leb128 (valueT value, int sign)
4400{
if (sign)
  return sizeof_sleb128 ((offsetT) value);
else
  return sizeof_uleb128 (value);
4405}

4407/* Output a LEB128 value.  */

4409static inline int
4410output_sleb128 (char *p, offsetT value)
4411{
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;
4434}

4436static inline int
4437output_uleb128 (char *p, valueT value)
4438{
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;
4454}

4456int
4457output_leb128 (char *p, valueT value, int sign)
4458{
if (sign)
  return output_sleb128 (p, (offsetT) value);
else
  return output_uleb128 (p, value);
4463}

4465/* Do the same for bignums.  We combine sizeof with output here in that
 we don't output for NULL values of P.  It isn't really as critical as
 for "normal" values that this be streamlined.  */

4469static inline int
4470output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4471{
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(0xFFFF)
&& bignum[size - 2] > LITTLENUM_MASK(0xFFFF) / 2)
  size--;

do
  {
    /* OR in the next part of the littlenum.  */
    val |= (*bignum << loaded);
    loaded += LITTLENUM_NUMBER_OF_BITS(16);
    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;
4522}

4524static inline int
4525output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4526{
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(1 << (1));
 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;
4561}

4563static int
4564output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4565{
if (sign)
  return output_big_sleb128 (p, bignum, size);
else
  return output_big_uleb128 (p, bignum, size);
4570}

4572/* Generate the appropriate fragments for a given expression to emit a
 leb128 value.  */

4575static void
4576emit_leb128_expr (expressionS *exp, int sign)
4577{
operatorT op = exp->X_op;
unsigned int nbytes;

if (op == O_absent || op == O_illegal)
  {
    as_warn (_("zero assumed for missing expression")("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")("floating point number invalid"));
    exp->X_add_number = 0;
    op = O_constant;
  }
else if (op == O_register)
  {
    as_warn (_("register value used as expression")("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 ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/read.c", 4613
, __PRETTY_FUNCTION__);

/* Let the backend know that subsequent data may be byte aligned.  */
4616#ifdef md_cons_align
md_cons_align (1);
4618#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((void*)0), 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((void*)0));
  }
4651}

4653/* Parse the .sleb128 and .uleb128 pseudos.  */

4655void
4656s_leb128 (int sign)
4657{
expressionS exp;

4660#ifdef md_flush_pending_output
md_flush_pending_output ();
4662#endif

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

input_line_pointer--;
demand_empty_rest_of_line ();
4673}
4674
4675/* We read 0 or more ',' separated, double-quoted strings.
 Caller should have checked need_pass_2 is FALSE because we don't
 check it.  */

4679void
4680stringer (/* Worker to do .ascii etc statements.  */
 /* Checks end-of-line.  */
 register int append_zero	/* 0: don't append '\0', else 1.  */)
4683{
register unsigned int c;
char *start;

4687#ifdef md_flush_pending_output
md_flush_pending_output ();
4689#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((asection *) &bfd_abs_section))
  {
    as_bad (_("strings must be placed into a section")("strings must be placed into a section"));
    c = 0;
    ignore_rest_of_line ();
  }

while (c == ',' || c == '<' || c == '"')
  {
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    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 ())(((unsigned) (c = next_char_of_string ())) <= (0xff)))
   {
     FRAG_APPEND_1_CHAR (c)frag_append_1_char (c);
   }
 if (append_zero)
   {
     FRAG_APPEND_1_CHAR (0)frag_append_1_char (0);
   }
 know (input_line_pointer[-1] == '\"');

4732#ifndef NO_LISTING
4733#ifdef OBJ_ELF1
 /* 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)((now_seg)->name + 0), ".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;
   }
4749#endif
4750#endif

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

demand_empty_rest_of_line ();
4772}				/* stringer() */
4773
4774/* FIXME-SOMEDAY: I had trouble here on characters with the
  high bits set.  We'll probably also have trouble with
  multibyte chars, wide chars, etc.  Also be careful about
  returning values bigger than 1 byte.  xoxorich.  */

4779unsigned int
4780next_char_of_string (void)
4781{
register unsigned int c;

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

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

4796#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;
 i < 3 && ISDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isdigit
));
 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)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isxdigit
)))
     {
if (ISDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isdigit
)))
  number = number * 16 + c - '0';
else if (ISUPPER (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isupper
)))
  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")("unterminated string; newline inserted"));
 c = '\n';
 bump_line_counters ();
 break;

default:

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

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

  default:
    break;
  }
return (c);
4899}
4900
4901static segT
4902get_segmented_expression (register expressionS *expP)
4903{
register segT retval;

retval = expression (expP)expr (0, expP, expr_normal);
if (expP->X_op == O_illegal
    || expP->X_op == O_absent
    || expP->X_op == O_big)
  {
    as_bad (_("expected address expression")("expected address expression"));
    expP->X_op = O_constant;
    expP->X_add_number = 0;
    retval = absolute_section((asection *) &bfd_abs_section);
  }
return retval;
4917}

4919static segT
4920get_known_segmented_expression (register expressionS *expP)
4921{
register segT retval;

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

4942char				/* Return terminator.  */
4943get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
4944{
/* FIXME: val_pointer should probably be offsetT *.  */
*val_pointer = (long) get_absolute_expression ();
return (*input_line_pointer++);
4948}
4949
4950/* Like demand_copy_string, but return NULL if the string contains any '\0's.
 Give a warning if that happens.  */

4953char *
4954demand_copy_C_string (int *len_pointer)
4955{
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\'")("this string may not contain \'\\0\'"));
   }
}
  }

return s;
4975}
4976
4977/* Demand string, but return a safe (=private) copy of the string.
 Return NULL if we can't read a string here.  */

4980char *
4981demand_copy_string (int *lenP)
4982{
register unsigned int c;
register int len;
char *retval;

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

    while (is_a_char (c = next_char_of_string ())(((unsigned) (c = next_char_of_string ())) <= (0xff)))
{
 obstack_1grow (&notes, c)__extension__ ({ struct obstack *__o = (&notes); if (__o->
next_free + 1 > __o->chunk_limit) _obstack_newchunk (__o
, 1); (*((__o)->next_free)++ = (c)); (void) 0; });
 len++;
}
    /* JF this next line is so demand_copy_C_string will return a
null terminated string.  */
    obstack_1grow (&notes, '\0')__extension__ ({ struct obstack *__o = (&notes); if (__o->
next_free + 1 > __o->chunk_limit) _obstack_newchunk (__o
, 1); (*((__o)->next_free)++ = ('\0')); (void) 0; });
    retval = obstack_finish (&notes)__extension__ ({ struct obstack *__o1 = (&notes); void *value
; value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; });
  }
else
  {
    as_bad (_("missing string")("missing string"));
    retval = NULL((void*)0);
    ignore_rest_of_line ();
  }
*lenP = len;
return (retval);
5011}
5012
5013/* In:	Input_line_pointer->next character.

 Do:	Skip input_line_pointer over all whitespace.

 Out:	1 if input_line_pointer->end-of-line.  */

5019int
5020is_it_end_of_statement (void)
5021{
SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
return (is_end_of_line[(unsigned char) *input_line_pointer]);
5024}

5026void
5027equals (char *sym_name, int reassign)
5028{
char *stop = NULL((void*)0);
char stopc;

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

5053/* .incbin -- include a file verbatim at the current location.  */

5055void
5056s_incbin (int x ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5057{
FILE * binfile;
char * path;
char * filename;
char * binfrag;
long   skip = 0;
long   count = 0;
long   bytes;
int    len;

5067#ifdef md_flush_pending_output
md_flush_pending_output ();
5069#endif

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
filename = demand_copy_string (& len);
if (filename == NULL((void*)0))
  return;

SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);

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

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

 SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
}
  }

demand_empty_rest_of_line ();

/* Try opening absolute path first, then try include dirs.  */
binfile = fopen (filename, FOPEN_RB"r");
if (binfile == NULL((void*)0))
  {
    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"r");
 if (binfile != NULL((void*)0))
   break;
}

    if (binfile == NULL((void*)0))
as_bad (_("file not found: %s")("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_END2) != 0)
{
 as_bad (_("seek to end of .incbin file failed `%s'")("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 (%ld) or count (%ld) invalid for file size (%ld)"),
  skip, count, file_len);
 goto done;
}

    if (fseek (binfile, skip, SEEK_SET0) != 0)
{
 as_bad (_("could not skip to %ld in file `%s'")("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")("truncated file `%s', %ld of %ld bytes read"),
 path, bytes, count);
  }
5162done:
if (binfile != NULL((void*)0))
  fclose (binfile);
if (path)
  free (path);
5167}

5169/* .include -- include a file at this point.  */

5171void
5172s_include (int arg ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5173{
char *filename;
int i;
FILE *try;
char *path;

if (!flag_m68k_mri0)
  {
    filename = demand_copy_string (&i);
    if (filename == NULL((void*)0))
{
 /* demand_copy_string has already printed an error and
    called ignore_rest_of_line.  */
 return;
}
  }
else
  {
    SKIP_WHITESPACE ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    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)__extension__ ({ struct obstack *__o = (&notes); if (__o->
next_free + 1 > __o->chunk_limit) _obstack_newchunk (__o
, 1); (*((__o)->next_free)++ = (*input_line_pointer)); (void
) 0; });
 ++input_line_pointer;
 ++i;
}

    obstack_1grow (&notes, '\0')__extension__ ({ struct obstack *__o = (&notes); if (__o->
next_free + 1 > __o->chunk_limit) _obstack_newchunk (__o
, 1); (*((__o)->next_free)++ = ('\0')); (void) 0; });
    filename = obstack_finish (&notes)__extension__ ({ struct obstack *__o1 = (&notes); void *value
; value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; });
    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"r")))
{
 fclose (try);
 goto gotit;
}
  }

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

5231void
5232add_include_dir (char *path)
5233{
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;
5255}
5256
5257/* Output debugging information to denote the source file.  */

5259static void
5260generate_file_debug (void)
5261{
if (debug_type == DEBUG_STABS)
  stabs_generate_asm_file ();
5264}

5266/* Output line number debugging information for the current source line.  */

5268void
5269generate_lineno_debug (void)
5270{
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;
  }
5290}

5292/* Output debugging information to mark a function entry point or end point.
 END_P is zero for .func, and non-zero for .endfunc.  */

5295void
5296s_func (int end_p)
5297{
do_s_func (end_p, NULL((void*)0));
5299}

5301/* Subroutine of s_func so targets can choose a different default prefix.
 If DEFAULT_PREFIX is NULL, use the target's "leading char".  */

5304static void
5305do_s_func (int end_p, const char *default_prefix)
5306{
/* 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((void*)0))
{
 as_bad (_("missing .func")("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((void*)0);
  }
else /* ! end_p */
  {
    char *name, *label;
    char delim1, delim2;

    if (current_name != NULL((void*)0))
{
 as_bad (_(".endfunc missing for previous .func")(".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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
    if (*input_line_pointer != ',')
{
 if (default_prefix)
   asprintf (&label, "%s%s", default_prefix, name);
 else
   {
     char leading_char = bfd_get_symbol_leading_char (stdoutput)((stdoutput)->xvec->symbol_leading_char);
     /* 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 ()((*input_line_pointer == ' ') ? ++input_line_pointer : 0);
 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 ();
5377}
5378
5379void
5380s_ignore (int arg ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5381{
ignore_rest_of_line ();
5383}

5385void
5386read_print_statistics (FILE *file)
5387{
hash_print_statistics (file, "pseudo-op table", po_hash);
5389}

5391/* Inserts the given line into the input stream.

 This call avoids macro/conditionals nesting checking, since the contents of
 the line are assumed to replace the contents of a line already scanned.

 An appropriate use of this function would be substitution of input lines when
 called by md_start_line_hook().  The given line is assumed to already be
 properly scrubbed.  */

5400void
5401input_scrub_insert_line (const char *line)
5402{
sb newline;
sb_new (&newline);
sb_add_string (&newline, line);
input_scrub_include_sb (&newline, input_line_pointer, 0);
sb_kill (&newline);
buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5409}

5411/* Insert a file into the input stream; the path must resolve to an actual
 file; no include path searching or dependency registering is performed.  */

5414void
5415input_scrub_insert_file (char *path)
5416{
input_scrub_include_file (path, input_line_pointer);
buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5419}

5421/* Find the end of a line, considering quotation and escaping of quotes.  */

5423#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5424# define TC_SINGLE_QUOTE_STRINGS 1
5425#endif

5427static char *
5428_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5429{
char inquote = '\0';
int inescape = 0;

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

5463char *
5464find_end_of_line (char *s, int mri_string)
5465{
return _find_end_of_line (s, mri_string, 0);
5467}