contrib/binutils-2.21/gas/read.c

   1 /* read.c - read a source file -
   2    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   4    2010, 2011  Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
  24    But then, GNU isn't spozed to run on your machine anyway.
  25    (RMS is so shortsighted sometimes.)  */
  26 #define MASK_CHAR ((int)(unsigned char) -1)
  27
  28 /* This is the largest known floating point format (for now). It will
  29    grow when we do 4361 style flonums.  */
  30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  31
  32 /* Routines that read assembler source text to build spaghetti in memory.
  33    Another group of these functions is in the expr.c module.  */
  34
  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 "ecoff.h"
  42 #include "dw2gencfi.h"
  43
  44 #ifndef TC_START_LABEL
  45 #define TC_START_LABEL(x,y,z) (x == ':')
  46 #endif
  47
  48 /* Set by the object-format or the target.  */
  49 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
  50 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)                \
  51   do                                                            \
  52     {                                                           \
  53       if ((SIZE) >= 8)                                          \
  54         (P2VAR) = 3;                                            \
  55       else if ((SIZE) >= 4)                                     \
  56         (P2VAR) = 2;                                            \
  57       else if ((SIZE) >= 2)                                     \
  58         (P2VAR) = 1;                                            \
  59       else                                                      \
  60         (P2VAR) = 0;                                            \
  61     }                                                           \
  62   while (0)
  63 #endif
  64
  65 char *input_line_pointer;       /*->next char of source file to parse.  */
  66
  67 #if BITS_PER_CHAR != 8
  68 /*  The following table is indexed by[(char)] and will break if
  69     a char does not have exactly 256 states (hopefully 0:255!)!  */
  70 die horribly;
  71 #endif
  72
  73 #ifndef LEX_AT
  74 #define LEX_AT 0
  75 #endif
  76
  77 #ifndef LEX_BR
  78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
  79 #define LEX_BR 0
  80 #endif
  81
  82 #ifndef LEX_PCT
  83 /* The Delta 68k assembler permits % inside label names.  */
  84 #define LEX_PCT 0
  85 #endif
  86
  87 #ifndef LEX_QM
  88 /* The PowerPC Windows NT assemblers permits ? inside label names.  */
  89 #define LEX_QM 0
  90 #endif
  91
  92 #ifndef LEX_HASH
  93 /* The IA-64 assembler uses # as a suffix designating a symbol.  We include
  94    it in the symbol and strip it out in tc_canonicalize_symbol_name.  */
  95 #define LEX_HASH 0
  96 #endif
  97
  98 #ifndef LEX_DOLLAR
  99 #define LEX_DOLLAR 3
 100 #endif
 101
 102 #ifndef LEX_TILDE
 103 /* The Delta 68k assembler permits ~ at start of label names.  */
 104 #define LEX_TILDE 0
 105 #endif
 106
 107 /* Used by is_... macros. our ctype[].  */
 108 char lex_type[256] = {
 109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
 110   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
 111   0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
 112   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  /* 0123456789:;<=>? */
 113   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  /* @ABCDEFGHIJKLMNO */
 114   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
 115   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
 116   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~.  */
 117   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 118   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 119   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 120   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 121   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 122   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 123   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 124   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
 125 };
 126
 127 /* In: a character.
 128    Out: 1 if this character ends a line.
 129         2 if this character is a line separator.  */
 130 char is_end_of_line[256] = {
 131 #ifdef CR_EOL
 132   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,       /* @abcdefghijklmno */
 133 #else
 134   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,       /* @abcdefghijklmno */
 135 #endif
 136   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 137   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* _!"#$%&'()*+,-./ */
 138   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
 139   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 140   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 141   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 142   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 143   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 144   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 145   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 146   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 147   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 148   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 149   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 150   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0        /* */
 151 };
 152
 153 #ifndef TC_CASE_SENSITIVE
 154 char original_case_string[128];
 155 #endif
 156
 157 /* Functions private to this file.  */
 158
 159 static char *buffer;    /* 1st char of each buffer of lines is here.  */
 160 static char *buffer_limit;      /*->1 + last char in buffer.  */
 161
 162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
 163    in the tc-<CPU>.h file.  See the "Porting GAS" section of the
 164    internals manual.  */
 165 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 166
 167 /* Variables for handling include file directory table.  */
 168
 169 /* Table of pointers to directories to search for .include's.  */
 170 char **include_dirs;
 171
 172 /* How many are in the table.  */
 173 int include_dir_count;
 174
 175 /* Length of longest in table.  */
 176 int include_dir_maxlen = 1;
 177
 178 #ifndef WORKING_DOT_WORD
 179 struct broken_word *broken_words;
 180 int new_broken_words;
 181 #endif
 182
 183 /* The current offset into the absolute section.  We don't try to
 184    build frags in the absolute section, since no data can be stored
 185    there.  We just keep track of the current offset.  */
 186 addressT abs_section_offset;
 187
 188 /* If this line had an MRI style label, it is stored in this variable.
 189    This is used by some of the MRI pseudo-ops.  */
 190 symbolS *line_label;
 191
 192 /* This global variable is used to support MRI common sections.  We
 193    translate such sections into a common symbol.  This variable is
 194    non-NULL when we are in an MRI common section.  */
 195 symbolS *mri_common_symbol;
 196
 197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
 198    need to align to an even byte boundary unless the next pseudo-op is
 199    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
 200    may be needed.  */
 201 static int mri_pending_align;
 202
 203 #ifndef NO_LISTING
 204 #ifdef OBJ_ELF
 205 /* This variable is set to be non-zero if the next string we see might
 206    be the name of the source file in DWARF debugging information.  See
 207    the comment in emit_expr for the format we look for.  */
 208 static int dwarf_file_string;
 209 #endif
 210 #endif
 211
 212 static void do_s_func (int end_p, const char *default_prefix);
 213 static void do_align (int, char *, int, int);
 214 static void s_align (int, int);
 215 static void s_altmacro (int);
 216 static void s_bad_end (int);
 217 #ifdef OBJ_ELF
 218 static void s_gnu_attribute (int);
 219 #endif
 220 static void s_reloc (int);
 221 static int hex_float (int, char *);
 222 static segT get_known_segmented_expression (expressionS * expP);
 223 static void pobegin (void);
 224 static int get_non_macro_line_sb (sb *);
 225 static void generate_file_debug (void);
 226 static char *_find_end_of_line (char *, int, int, int);
 227 \f
 228 void
 229 read_begin (void)
 230 {
 231   const char *p;
 232
 233   pobegin ();
 234   obj_read_begin_hook ();
 235
 236   /* Something close -- but not too close -- to a multiple of 1024.
 237      The debugging malloc I'm using has 24 bytes of overhead.  */
 238   obstack_begin (&notes, chunksize);
 239   obstack_begin (&cond_obstack, chunksize);
 240
 241   /* Use machine dependent syntax.  */
 242   for (p = line_separator_chars; *p; p++)
 243     is_end_of_line[(unsigned char) *p] = 2;
 244   /* Use more.  FIXME-SOMEDAY.  */
 245
 246   if (flag_mri)
 247     lex_type['?'] = 3;
 248 }
 249 \f
 250 #ifndef TC_ADDRESS_BYTES
 251 #define TC_ADDRESS_BYTES address_bytes
 252
 253 static inline int
 254 address_bytes (void)
 255 {
 256   /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
 257      contain an address.  */
 258   int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
 259   n |= n >> 1;
 260   n |= n >> 2;
 261   n += 1;
 262   return n;
 263 }
 264 #endif
 265
 266 /* Set up pseudo-op tables.  */
 267
 268 static struct hash_control *po_hash;
 269
 270 static const pseudo_typeS potable[] = {
 271   {"abort", s_abort, 0},
 272   {"align", s_align_ptwo, 0},
 273   {"altmacro", s_altmacro, 1},
 274   {"ascii", stringer, 8+0},
 275   {"asciz", stringer, 8+1},
 276   {"balign", s_align_bytes, 0},
 277   {"balignw", s_align_bytes, -2},
 278   {"balignl", s_align_bytes, -4},
 279 /* block  */
 280   {"byte", cons, 1},
 281   {"comm", s_comm, 0},
 282   {"common", s_mri_common, 0},
 283   {"common.s", s_mri_common, 1},
 284   {"data", s_data, 0},
 285   {"dc", cons, 2},
 286 #ifdef TC_ADDRESS_BYTES
 287   {"dc.a", cons, 0},
 288 #endif
 289   {"dc.b", cons, 1},
 290   {"dc.d", float_cons, 'd'},
 291   {"dc.l", cons, 4},
 292   {"dc.s", float_cons, 'f'},
 293   {"dc.w", cons, 2},
 294   {"dc.x", float_cons, 'x'},
 295   {"dcb", s_space, 2},
 296   {"dcb.b", s_space, 1},
 297   {"dcb.d", s_float_space, 'd'},
 298   {"dcb.l", s_space, 4},
 299   {"dcb.s", s_float_space, 'f'},
 300   {"dcb.w", s_space, 2},
 301   {"dcb.x", s_float_space, 'x'},
 302   {"ds", s_space, 2},
 303   {"ds.b", s_space, 1},
 304   {"ds.d", s_space, 8},
 305   {"ds.l", s_space, 4},
 306   {"ds.p", s_space, 12},
 307   {"ds.s", s_space, 4},
 308   {"ds.w", s_space, 2},
 309   {"ds.x", s_space, 12},
 310   {"debug", s_ignore, 0},
 311 #ifdef S_SET_DESC
 312   {"desc", s_desc, 0},
 313 #endif
 314 /* dim  */
 315   {"double", float_cons, 'd'},
 316 /* dsect  */
 317   {"eject", listing_eject, 0},  /* Formfeed listing.  */
 318   {"else", s_else, 0},
 319   {"elsec", s_else, 0},
 320   {"elseif", s_elseif, (int) O_ne},
 321   {"end", s_end, 0},
 322   {"endc", s_endif, 0},
 323   {"endfunc", s_func, 1},
 324   {"endif", s_endif, 0},
 325   {"endm", s_bad_end, 0},
 326   {"endr", s_bad_end, 1},
 327 /* endef  */
 328   {"equ", s_set, 0},
 329   {"equiv", s_set, 1},
 330   {"eqv", s_set, -1},
 331   {"err", s_err, 0},
 332   {"error", s_errwarn, 1},
 333   {"exitm", s_mexit, 0},
 334 /* extend  */
 335   {"extern", s_ignore, 0},      /* We treat all undef as ext.  */
 336   {"appfile", s_app_file, 1},
 337   {"appline", s_app_line, 1},
 338   {"fail", s_fail, 0},
 339   {"file", s_app_file, 0},
 340   {"fill", s_fill, 0},
 341   {"float", float_cons, 'f'},
 342   {"format", s_ignore, 0},
 343   {"func", s_func, 0},
 344   {"global", s_globl, 0},
 345   {"globl", s_globl, 0},
 346 #ifdef OBJ_ELF
 347   {"gnu_attribute", s_gnu_attribute, 0},
 348 #endif
 349   {"hword", cons, 2},
 350   {"if", s_if, (int) O_ne},
 351   {"ifb", s_ifb, 1},
 352   {"ifc", s_ifc, 0},
 353   {"ifdef", s_ifdef, 0},
 354   {"ifeq", s_if, (int) O_eq},
 355   {"ifeqs", s_ifeqs, 0},
 356   {"ifge", s_if, (int) O_ge},
 357   {"ifgt", s_if, (int) O_gt},
 358   {"ifle", s_if, (int) O_le},
 359   {"iflt", s_if, (int) O_lt},
 360   {"ifnb", s_ifb, 0},
 361   {"ifnc", s_ifc, 1},
 362   {"ifndef", s_ifdef, 1},
 363   {"ifne", s_if, (int) O_ne},
 364   {"ifnes", s_ifeqs, 1},
 365   {"ifnotdef", s_ifdef, 1},
 366   {"incbin", s_incbin, 0},
 367   {"include", s_include, 0},
 368   {"int", cons, 4},
 369   {"irp", s_irp, 0},
 370   {"irep", s_irp, 0},
 371   {"irpc", s_irp, 1},
 372   {"irepc", s_irp, 1},
 373   {"lcomm", s_lcomm, 0},
 374   {"lflags", s_ignore, 0},      /* Listing flags.  */
 375   {"linefile", s_app_line, 0},
 376   {"linkonce", s_linkonce, 0},
 377   {"list", listing_list, 1},    /* Turn listing on.  */
 378   {"llen", listing_psize, 1},
 379   {"long", cons, 4},
 380   {"lsym", s_lsym, 0},
 381   {"macro", s_macro, 0},
 382   {"mexit", s_mexit, 0},
 383   {"mri", s_mri, 0},
 384   {".mri", s_mri, 0},   /* Special case so .mri works in MRI mode.  */
 385   {"name", s_ignore, 0},
 386   {"noaltmacro", s_altmacro, 0},
 387   {"noformat", s_ignore, 0},
 388   {"nolist", listing_list, 0},  /* Turn listing off.  */
 389   {"nopage", listing_nopage, 0},
 390   {"octa", cons, 16},
 391   {"offset", s_struct, 0},
 392   {"org", s_org, 0},
 393   {"p2align", s_align_ptwo, 0},
 394   {"p2alignw", s_align_ptwo, -2},
 395   {"p2alignl", s_align_ptwo, -4},
 396   {"page", listing_eject, 0},
 397   {"plen", listing_psize, 0},
 398   {"print", s_print, 0},
 399   {"psize", listing_psize, 0},  /* Set paper size.  */
 400   {"purgem", s_purgem, 0},
 401   {"quad", cons, 8},
 402   {"reloc", s_reloc, 0},
 403   {"rep", s_rept, 0},
 404   {"rept", s_rept, 0},
 405   {"rva", s_rva, 4},
 406   {"sbttl", listing_title, 1},  /* Subtitle of listing.  */
 407 /* scl  */
 408 /* sect  */
 409   {"set", s_set, 0},
 410   {"short", cons, 2},
 411   {"single", float_cons, 'f'},
 412 /* size  */
 413   {"space", s_space, 0},
 414   {"skip", s_space, 0},
 415   {"sleb128", s_leb128, 1},
 416   {"spc", s_ignore, 0},
 417   {"stabd", s_stab, 'd'},
 418   {"stabn", s_stab, 'n'},
 419   {"stabs", s_stab, 's'},
 420   {"string", stringer, 8+1},
 421   {"string8", stringer, 8+1},
 422   {"string16", stringer, 16+1},
 423   {"string32", stringer, 32+1},
 424   {"string64", stringer, 64+1},
 425   {"struct", s_struct, 0},
 426 /* tag  */
 427   {"text", s_text, 0},
 428
 429   /* This is for gcc to use.  It's only just been added (2/94), so gcc
 430      won't be able to use it for a while -- probably a year or more.
 431      But once this has been released, check with gcc maintainers
 432      before deleting it or even changing the spelling.  */
 433   {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
 434   /* If we're folding case -- done for some targets, not necessarily
 435      all -- the above string in an input file will be converted to
 436      this one.  Match it either way...  */
 437   {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
 438
 439   {"title", listing_title, 0},  /* Listing title.  */
 440   {"ttl", listing_title, 0},
 441 /* type  */
 442   {"uleb128", s_leb128, 0},
 443 /* use  */
 444 /* val  */
 445   {"xcom", s_comm, 0},
 446   {"xdef", s_globl, 0},
 447   {"xref", s_ignore, 0},
 448   {"xstabs", s_xstab, 's'},
 449   {"warning", s_errwarn, 0},
 450   {"weakref", s_weakref, 0},
 451   {"word", cons, 2},
 452   {"zero", s_space, 0},
 453   {NULL, NULL, 0}                       /* End sentinel.  */
 454 };
 455
 456 static offsetT
 457 get_absolute_expr (expressionS *exp)
 458 {
 459   expression_and_evaluate (exp);
 460   if (exp->X_op != O_constant)
 461     {
 462       if (exp->X_op != O_absent)
 463         as_bad (_("bad or irreducible absolute expression"));
 464       exp->X_add_number = 0;
 465     }
 466   return exp->X_add_number;
 467 }
 468
 469 offsetT
 470 get_absolute_expression (void)
 471 {
 472   expressionS exp;
 473
 474   return get_absolute_expr (&exp);
 475 }
 476
 477 static int pop_override_ok = 0;
 478 static const char *pop_table_name;
 479
 480 void
 481 pop_insert (const pseudo_typeS *table)
 482 {
 483   const char *errtxt;
 484   const pseudo_typeS *pop;
 485   for (pop = table; pop->poc_name; pop++)
 486     {
 487       errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
 488       if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
 489         as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
 490                   errtxt);
 491     }
 492 }
 493
 494 #ifndef md_pop_insert
 495 #define md_pop_insert()         pop_insert(md_pseudo_table)
 496 #endif
 497
 498 #ifndef obj_pop_insert
 499 #define obj_pop_insert()        pop_insert(obj_pseudo_table)
 500 #endif
 501
 502 #ifndef cfi_pop_insert
 503 #define cfi_pop_insert()        pop_insert(cfi_pseudo_table)
 504 #endif
 505
 506 static void
 507 pobegin (void)
 508 {
 509   po_hash = hash_new ();
 510
 511   /* Do the target-specific pseudo ops.  */
 512   pop_table_name = "md";
 513   md_pop_insert ();
 514
 515   /* Now object specific.  Skip any that were in the target table.  */
 516   pop_table_name = "obj";
 517   pop_override_ok = 1;
 518   obj_pop_insert ();
 519
 520   /* Now portable ones.  Skip any that we've seen already.  */
 521   pop_table_name = "standard";
 522   pop_insert (potable);
 523
 524 #ifdef TARGET_USE_CFIPOP
 525   pop_table_name = "cfi";
 526   pop_override_ok = 1;
 527   cfi_pop_insert ();
 528 #endif
 529 }
 530 \f
 531 #define HANDLE_CONDITIONAL_ASSEMBLY()                                   \
 532   if (ignore_input ())                                                  \
 533     {                                                                   \
 534       char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
 535       input_line_pointer = (input_line_pointer <= buffer_limit          \
 536                             && eol >= buffer_limit)                     \
 537                            ? buffer_limit                               \
 538                            : eol + 1;                                   \
 539       continue;                                                         \
 540     }
 541
 542 /* This function is used when scrubbing the characters between #APP
 543    and #NO_APP.  */
 544
 545 static char *scrub_string;
 546 static char *scrub_string_end;
 547
 548 static int
 549 scrub_from_string (char *buf, int buflen)
 550 {
 551   int copy;
 552
 553   copy = scrub_string_end - scrub_string;
 554   if (copy > buflen)
 555     copy = buflen;
 556   memcpy (buf, scrub_string, copy);
 557   scrub_string += copy;
 558   return copy;
 559 }
 560
 561 /* Helper function of read_a_source_file, which tries to expand a macro.  */
 562 static int
 563 try_macro (char term, const char *line)
 564 {
 565   sb out;
 566   const char *err;
 567   macro_entry *macro;
 568
 569   if (check_macro (line, &out, &err, &macro))
 570     {
 571       if (err != NULL)
 572         as_bad ("%s", err);
 573       *input_line_pointer++ = term;
 574       input_scrub_include_sb (&out,
 575                               input_line_pointer, 1);
 576       sb_kill (&out);
 577       buffer_limit =
 578         input_scrub_next_buffer (&input_line_pointer);
 579 #ifdef md_macro_info
 580       md_macro_info (macro);
 581 #endif
 582       return 1;
 583     }
 584   return 0;
 585 }
 586
 587 /* We read the file, putting things into a web that represents what we
 588    have been reading.  */
 589 void
 590 read_a_source_file (char *name)
 591 {
 592   char c;
 593   char *s;              /* String of symbol, '\0' appended.  */
 594   int temp;
 595   pseudo_typeS *pop;
 596
 597 #ifdef WARN_COMMENTS
 598   found_comment = 0;
 599 #endif
 600
 601   buffer = input_scrub_new_file (name);
 602
 603   listing_file (name);
 604   listing_newline (NULL);
 605   register_dependency (name);
 606
 607   /* Generate debugging information before we've read anything in to denote
 608      this file as the "main" source file and not a subordinate one
 609      (e.g. N_SO vs N_SOL in stabs).  */
 610   generate_file_debug ();
 611
 612   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
 613     {                           /* We have another line to parse.  */
 614 #ifndef NO_LISTING
 615       /* In order to avoid listing macro expansion lines with labels
 616          multiple times, keep track of which line was last issued.  */
 617       static char *last_eol;
 618
 619       last_eol = NULL;
 620 #endif
 621       while (input_line_pointer < buffer_limit)
 622         {
 623           bfd_boolean was_new_line;
 624           /* We have more of this buffer to parse.  */
 625
 626           /* We now have input_line_pointer->1st char of next line.
 627              If input_line_pointer [-1] == '\n' then we just
 628              scanned another line: so bump line counters.  */
 629           was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
 630           if (was_new_line)
 631             {
 632               symbol_set_value_now (&dot_symbol);
 633 #ifdef md_start_line_hook
 634               md_start_line_hook ();
 635 #endif
 636               if (input_line_pointer[-1] == '\n')
 637                 bump_line_counters ();
 638             }
 639
 640 #ifndef NO_LISTING
 641           /* If listing is on, and we are expanding a macro, then give
 642              the listing code the contents of the expanded line.  */
 643           if (listing)
 644             {
 645               if ((listing & LISTING_MACEXP) && macro_nest > 0)
 646                 {
 647                   /* Find the end of the current expanded macro line.  */
 648                   s = find_end_of_line (input_line_pointer, flag_m68k_mri);
 649
 650                   if (s != last_eol)
 651                     {
 652                       char *copy;
 653                       int len;
 654
 655                       last_eol = s;
 656                       /* Copy it for safe keeping.  Also give an indication of
 657                          how much macro nesting is involved at this point.  */
 658                       len = s - input_line_pointer;
 659                       copy = (char *) xmalloc (len + macro_nest + 2);
 660                       memset (copy, '>', macro_nest);
 661                       copy[macro_nest] = ' ';
 662                       memcpy (copy + macro_nest + 1, input_line_pointer, len);
 663                       copy[macro_nest + 1 + len] = '\0';
 664
 665                       /* Install the line with the listing facility.  */
 666                       listing_newline (copy);
 667                     }
 668                 }
 669               else
 670                 listing_newline (NULL);
 671             }
 672 #endif
 673           if (was_new_line)
 674             {
 675               line_label = NULL;
 676
 677               if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
 678                 {
 679                   /* Text at the start of a line must be a label, we
 680                      run down and stick a colon in.  */
 681                   if (is_name_beginner (*input_line_pointer))
 682                     {
 683                       char *line_start = input_line_pointer;
 684                       int mri_line_macro;
 685
 686                       HANDLE_CONDITIONAL_ASSEMBLY ();
 687
 688                       c = get_symbol_end ();
 689
 690                       /* In MRI mode, the EQU and MACRO pseudoops must
 691                          be handled specially.  */
 692                       mri_line_macro = 0;
 693                       if (flag_m68k_mri)
 694                         {
 695                           char *rest = input_line_pointer + 1;
 696
 697                           if (*rest == ':')
 698                             ++rest;
 699                           if (*rest == ' ' || *rest == '\t')
 700                             ++rest;
 701                           if ((strncasecmp (rest, "EQU", 3) == 0
 702                                || strncasecmp (rest, "SET", 3) == 0)
 703                               && (rest[3] == ' ' || rest[3] == '\t'))
 704                             {
 705                               input_line_pointer = rest + 3;
 706                               equals (line_start,
 707                                       strncasecmp (rest, "SET", 3) == 0);
 708                               continue;
 709                             }
 710                           if (strncasecmp (rest, "MACRO", 5) == 0
 711                               && (rest[5] == ' '
 712                                   || rest[5] == '\t'
 713                                   || is_end_of_line[(unsigned char) rest[5]]))
 714                             mri_line_macro = 1;
 715                         }
 716
 717                       /* In MRI mode, we need to handle the MACRO
 718                          pseudo-op specially: we don't want to put the
 719                          symbol in the symbol table.  */
 720                       if (!mri_line_macro
 721 #ifdef TC_START_LABEL_WITHOUT_COLON
 722                           && TC_START_LABEL_WITHOUT_COLON(c,
 723                                                           input_line_pointer)
 724 #endif
 725                           )
 726                         line_label = colon (line_start);
 727                       else
 728                         line_label = symbol_create (line_start,
 729                                                     absolute_section,
 730                                                     (valueT) 0,
 731                                                     &zero_address_frag);
 732
 733                       *input_line_pointer = c;
 734                       if (c == ':')
 735                         input_line_pointer++;
 736                     }
 737                 }
 738             }
 739
 740           /* We are at the beginning of a line, or similar place.
 741              We expect a well-formed assembler statement.
 742              A "symbol-name:" is a statement.
 743
 744              Depending on what compiler is used, the order of these tests
 745              may vary to catch most common case 1st.
 746              Each test is independent of all other tests at the (top)
 747              level.  */
 748           do
 749             c = *input_line_pointer++;
 750           while (c == '\t' || c == ' ' || c == '\f');
 751
 752           /* C is the 1st significant character.
 753              Input_line_pointer points after that character.  */
 754           if (is_name_beginner (c))
 755             {
 756               /* Want user-defined label or pseudo/opcode.  */
 757               HANDLE_CONDITIONAL_ASSEMBLY ();
 758
 759               s = --input_line_pointer;
 760               c = get_symbol_end ();    /* name's delimiter.  */
 761
 762               /* C is character after symbol.
 763                  That character's place in the input line is now '\0'.
 764                  S points to the beginning of the symbol.
 765                    [In case of pseudo-op, s->'.'.]
 766                  Input_line_pointer->'\0' where c was.  */
 767               if (TC_START_LABEL (c, s, input_line_pointer))
 768                 {
 769                   if (flag_m68k_mri)
 770                     {
 771                       char *rest = input_line_pointer + 1;
 772
 773                       /* In MRI mode, \tsym: set 0 is permitted.  */
 774                       if (*rest == ':')
 775                         ++rest;
 776
 777                       if (*rest == ' ' || *rest == '\t')
 778                         ++rest;
 779
 780                       if ((strncasecmp (rest, "EQU", 3) == 0
 781                            || strncasecmp (rest, "SET", 3) == 0)
 782                           && (rest[3] == ' ' || rest[3] == '\t'))
 783                         {
 784                           input_line_pointer = rest + 3;
 785                           equals (s, 1);
 786                           continue;
 787                         }
 788                     }
 789
 790                   line_label = colon (s);       /* User-defined label.  */
 791                   /* Put ':' back for error messages' sake.  */
 792                   *input_line_pointer++ = ':';
 793 #ifdef tc_check_label
 794                   tc_check_label (line_label);
 795 #endif
 796                   /* Input_line_pointer->after ':'.  */
 797                   SKIP_WHITESPACE ();
 798                 }
 799               else if ((c == '=' && input_line_pointer[1] == '=')
 800                        || ((c == ' ' || c == '\t')
 801                            && input_line_pointer[1] == '='
 802                            && input_line_pointer[2] == '='))
 803                 {
 804                   equals (s, -1);
 805                   demand_empty_rest_of_line ();
 806                 }
 807               else if ((c == '='
 808                        || ((c == ' ' || c == '\t')
 809                             && input_line_pointer[1] == '='))
 810 #ifdef TC_EQUAL_IN_INSN
 811                            && !TC_EQUAL_IN_INSN (c, s)
 812 #endif
 813                            )
 814                 {
 815                   equals (s, 1);
 816                   demand_empty_rest_of_line ();
 817                 }
 818               else
 819                 {
 820                   /* Expect pseudo-op or machine instruction.  */
 821                   pop = NULL;
 822
 823 #ifndef TC_CASE_SENSITIVE
 824                   {
 825                     char *s2 = s;
 826
 827                     strncpy (original_case_string, s2, sizeof (original_case_string));
 828                     original_case_string[sizeof (original_case_string) - 1] = 0;
 829
 830                     while (*s2)
 831                       {
 832                         *s2 = TOLOWER (*s2);
 833                         s2++;
 834                       }
 835                   }
 836 #endif
 837                   if (NO_PSEUDO_DOT || flag_m68k_mri)
 838                     {
 839                       /* The MRI assembler uses pseudo-ops without
 840                          a period.  */
 841                       pop = (pseudo_typeS *) hash_find (po_hash, s);
 842                       if (pop != NULL && pop->poc_handler == NULL)
 843                         pop = NULL;
 844                     }
 845
 846                   if (pop != NULL
 847                       || (!flag_m68k_mri && *s == '.'))
 848                     {
 849                       /* PSEUDO - OP.
 850
 851                          WARNING: c has next char, which may be end-of-line.
 852                          We lookup the pseudo-op table with s+1 because we
 853                          already know that the pseudo-op begins with a '.'.  */
 854
 855                       if (pop == NULL)
 856                         pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
 857                       if (pop && !pop->poc_handler)
 858                         pop = NULL;
 859
 860                       /* In MRI mode, we may need to insert an
 861                          automatic alignment directive.  What a hack
 862                          this is.  */
 863                       if (mri_pending_align
 864                           && (pop == NULL
 865                               || !((pop->poc_handler == cons
 866                                     && pop->poc_val == 1)
 867                                    || (pop->poc_handler == s_space
 868                                        && pop->poc_val == 1)
 869 #ifdef tc_conditional_pseudoop
 870                                    || tc_conditional_pseudoop (pop)
 871 #endif
 872                                    || pop->poc_handler == s_if
 873                                    || pop->poc_handler == s_ifdef
 874                                    || pop->poc_handler == s_ifc
 875                                    || pop->poc_handler == s_ifeqs
 876                                    || pop->poc_handler == s_else
 877                                    || pop->poc_handler == s_endif
 878                                    || pop->poc_handler == s_globl
 879                                    || pop->poc_handler == s_ignore)))
 880                         {
 881                           do_align (1, (char *) NULL, 0, 0);
 882                           mri_pending_align = 0;
 883
 884                           if (line_label != NULL)
 885                             {
 886                               symbol_set_frag (line_label, frag_now);
 887                               S_SET_VALUE (line_label, frag_now_fix ());
 888                             }
 889                         }
 890
 891                       /* Print the error msg now, while we still can.  */
 892                       if (pop == NULL)
 893                         {
 894                           char *end = input_line_pointer;
 895
 896                           *input_line_pointer = c;
 897                           s_ignore (0);
 898                           c = *--input_line_pointer;
 899                           *input_line_pointer = '\0';
 900                           if (! macro_defined || ! try_macro (c, s))
 901                             {
 902                               *end = '\0';
 903                               as_bad (_("unknown pseudo-op: `%s'"), s);
 904                               *input_line_pointer++ = c;
 905                             }
 906                           continue;
 907                         }
 908
 909                       /* Put it back for error messages etc.  */
 910                       *input_line_pointer = c;
 911                       /* The following skip of whitespace is compulsory.
 912                          A well shaped space is sometimes all that separates
 913                          keyword from operands.  */
 914                       if (c == ' ' || c == '\t')
 915                         input_line_pointer++;
 916
 917                       /* Input_line is restored.
 918                          Input_line_pointer->1st non-blank char
 919                          after pseudo-operation.  */
 920                       (*pop->poc_handler) (pop->poc_val);
 921
 922                       /* If that was .end, just get out now.  */
 923                       if (pop->poc_handler == s_end)
 924                         goto quit;
 925                     }
 926                   else
 927                     {
 928                       /* WARNING: c has char, which may be end-of-line.  */
 929                       /* Also: input_line_pointer->`\0` where c was.  */
 930                       *input_line_pointer = c;
 931                       input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
 932                       c = *input_line_pointer;
 933                       *input_line_pointer = '\0';
 934
 935                       generate_lineno_debug ();
 936
 937                       if (macro_defined && try_macro (c, s))
 938                         continue;
 939
 940                       if (mri_pending_align)
 941                         {
 942                           do_align (1, (char *) NULL, 0, 0);
 943                           mri_pending_align = 0;
 944                           if (line_label != NULL)
 945                             {
 946                               symbol_set_frag (line_label, frag_now);
 947                               S_SET_VALUE (line_label, frag_now_fix ());
 948                             }
 949                         }
 950
 951                       md_assemble (s);  /* Assemble 1 instruction.  */
 952
 953                       *input_line_pointer++ = c;
 954
 955                       /* We resume loop AFTER the end-of-line from
 956                          this instruction.  */
 957                     }
 958                 }
 959               continue;
 960             }
 961
 962           /* Empty statement?  */
 963           if (is_end_of_line[(unsigned char) c])
 964             continue;
 965
 966           if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
 967             {
 968               /* local label  ("4:")  */
 969               char *backup = input_line_pointer;
 970
 971               HANDLE_CONDITIONAL_ASSEMBLY ();
 972
 973               temp = c - '0';
 974
 975               /* Read the whole number.  */
 976               while (ISDIGIT (*input_line_pointer))
 977                 {
 978                   temp = (temp * 10) + *input_line_pointer - '0';
 979                   ++input_line_pointer;
 980                 }
 981
 982               if (LOCAL_LABELS_DOLLAR
 983                   && *input_line_pointer == '$'
 984                   && *(input_line_pointer + 1) == ':')
 985                 {
 986                   input_line_pointer += 2;
 987
 988                   if (dollar_label_defined (temp))
 989                     {
 990                       as_fatal (_("label \"%d$\" redefined"), temp);
 991                     }
 992
 993                   define_dollar_label (temp);
 994                   colon (dollar_label_name (temp, 0));
 995                   continue;
 996                 }
 997
 998               if (LOCAL_LABELS_FB
 999                   && *input_line_pointer++ == ':')
1000                 {
1001                   fb_label_instance_inc (temp);
1002                   colon (fb_label_name (temp, 0));
1003                   continue;
1004                 }
1005
1006               input_line_pointer = backup;
1007             }                   /* local label  ("4:") */
1008
1009           if (c && strchr (line_comment_chars, c))
1010             {                   /* Its a comment.  Better say APP or NO_APP.  */
1011               sb sbuf;
1012               char *ends;
1013               char *new_buf;
1014               char *new_tmp;
1015               unsigned int new_length;
1016               char *tmp_buf = 0;
1017
1018               s = input_line_pointer;
1019               if (strncmp (s, "APP\n", 4))
1020                 {
1021                   /* We ignore it.  */
1022                   ignore_rest_of_line ();
1023                   continue;
1024                 }
1025               bump_line_counters ();
1026               s += 4;
1027
1028               sb_new (&sbuf);
1029               ends = strstr (s, "#NO_APP\n");
1030
1031               if (!ends)
1032                 {
1033                   unsigned int tmp_len;
1034                   unsigned int num;
1035
1036                   /* The end of the #APP wasn't in this buffer.  We
1037                      keep reading in buffers until we find the #NO_APP
1038                      that goes with this #APP  There is one.  The specs
1039                      guarantee it...  */
1040                   tmp_len = buffer_limit - s;
1041                   tmp_buf = (char *) xmalloc (tmp_len + 1);
1042                   memcpy (tmp_buf, s, tmp_len);
1043                   do
1044                     {
1045                       new_tmp = input_scrub_next_buffer (&buffer);
1046                       if (!new_tmp)
1047                         break;
1048                       else
1049                         buffer_limit = new_tmp;
1050                       input_line_pointer = buffer;
1051                       ends = strstr (buffer, "#NO_APP\n");
1052                       if (ends)
1053                         num = ends - buffer;
1054                       else
1055                         num = buffer_limit - buffer;
1056
1057                       tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
1058                       memcpy (tmp_buf + tmp_len, buffer, num);
1059                       tmp_len += num;
1060                     }
1061                   while (!ends);
1062
1063                   input_line_pointer = ends ? ends + 8 : NULL;
1064
1065                   s = tmp_buf;
1066                   ends = s + tmp_len;
1067
1068                 }
1069               else
1070                 {
1071                   input_line_pointer = ends + 8;
1072                 }
1073
1074               scrub_string = s;
1075               scrub_string_end = ends;
1076
1077               new_length = ends - s;
1078               new_buf = (char *) xmalloc (new_length);
1079               new_tmp = new_buf;
1080               for (;;)
1081                 {
1082                   int space;
1083                   int size;
1084
1085                   space = (new_buf + new_length) - new_tmp;
1086                   size = do_scrub_chars (scrub_from_string, new_tmp, space);
1087
1088                   if (size < space)
1089                     {
1090                       new_tmp[size] = 0;
1091                       break;
1092                     }
1093
1094                   new_buf = (char *) xrealloc (new_buf, new_length + 100);
1095                   new_tmp = new_buf + new_length;
1096                   new_length += 100;
1097                 }
1098
1099               if (tmp_buf)
1100                 free (tmp_buf);
1101
1102               /* We've "scrubbed" input to the preferred format.  In the
1103                  process we may have consumed the whole of the remaining
1104                  file (and included files).  We handle this formatted
1105                  input similar to that of macro expansion, letting
1106                  actual macro expansion (possibly nested) and other
1107                  input expansion work.  Beware that in messages, line
1108                  numbers and possibly file names will be incorrect.  */
1109               sb_add_string (&sbuf, new_buf);
1110               input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1111               sb_kill (&sbuf);
1112               buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1113               free (new_buf);
1114               continue;
1115             }
1116
1117           HANDLE_CONDITIONAL_ASSEMBLY ();
1118
1119 #ifdef tc_unrecognized_line
1120           if (tc_unrecognized_line (c))
1121             continue;
1122 #endif
1123           input_line_pointer--;
1124           /* Report unknown char as error.  */
1125           demand_empty_rest_of_line ();
1126         }
1127     }
1128
1129  quit:
1130   symbol_set_value_now (&dot_symbol);
1131
1132 #ifdef md_cleanup
1133   md_cleanup ();
1134 #endif
1135   /* Close the input file.  */
1136   input_scrub_close ();
1137 #ifdef WARN_COMMENTS
1138   {
1139     if (warn_comment && found_comment)
1140       as_warn_where (found_comment_file, found_comment,
1141                      "first comment found here");
1142   }
1143 #endif
1144 }
1145
1146 /* Convert O_constant expression EXP into the equivalent O_big representation.
1147    Take the sign of the number from X_unsigned rather than X_add_number.  */
1148
1149 static void
1150 convert_to_bignum (expressionS *exp)
1151 {
1152   valueT value;
1153   unsigned int i;
1154
1155   value = exp->X_add_number;
1156   for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1157     {
1158       generic_bignum[i] = value & LITTLENUM_MASK;
1159       value >>= LITTLENUM_NUMBER_OF_BITS;
1160     }
1161   /* Add a sequence of sign bits if the top bit of X_add_number is not
1162      the sign of the original value.  */
1163   if ((exp->X_add_number < 0) != !exp->X_unsigned)
1164     generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1165   exp->X_op = O_big;
1166   exp->X_add_number = i;
1167 }
1168
1169 /* For most MRI pseudo-ops, the line actually ends at the first
1170    nonquoted space.  This function looks for that point, stuffs a null
1171    in, and sets *STOPCP to the character that used to be there, and
1172    returns the location.
1173
1174    Until I hear otherwise, I am going to assume that this is only true
1175    for the m68k MRI assembler.  */
1176
1177 char *
1178 mri_comment_field (char *stopcp)
1179 {
1180   char *s;
1181 #ifdef TC_M68K
1182   int inquote = 0;
1183
1184   know (flag_m68k_mri);
1185
1186   for (s = input_line_pointer;
1187        ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1188         || inquote);
1189        s++)
1190     {
1191       if (*s == '\'')
1192         inquote = !inquote;
1193     }
1194 #else
1195   for (s = input_line_pointer;
1196        !is_end_of_line[(unsigned char) *s];
1197        s++)
1198     ;
1199 #endif
1200   *stopcp = *s;
1201   *s = '\0';
1202
1203   return s;
1204 }
1205
1206 /* Skip to the end of an MRI comment field.  */
1207
1208 void
1209 mri_comment_end (char *stop, int stopc)
1210 {
1211   know (flag_mri);
1212
1213   input_line_pointer = stop;
1214   *stop = stopc;
1215   while (!is_end_of_line[(unsigned char) *input_line_pointer])
1216     ++input_line_pointer;
1217 }
1218
1219 void
1220 s_abort (int ignore ATTRIBUTE_UNUSED)
1221 {
1222   as_fatal (_(".abort detected.  Abandoning ship."));
1223 }
1224
1225 /* Guts of .align directive.  N is the power of two to which to align.
1226    FILL may be NULL, or it may point to the bytes of the fill pattern.
1227    LEN is the length of whatever FILL points to, if anything.  MAX is
1228    the maximum number of characters to skip when doing the alignment,
1229    or 0 if there is no maximum.  */
1230
1231 static void
1232 do_align (int n, char *fill, int len, int max)
1233 {
1234   if (now_seg == absolute_section)
1235     {
1236       if (fill != NULL)
1237         while (len-- > 0)
1238           if (*fill++ != '\0')
1239             {
1240               as_warn (_("ignoring fill value in absolute section"));
1241               break;
1242             }
1243       fill = NULL;
1244       len = 0;
1245     }
1246
1247 #ifdef md_flush_pending_output
1248   md_flush_pending_output ();
1249 #endif
1250 #ifdef md_do_align
1251   md_do_align (n, fill, len, max, just_record_alignment);
1252 #endif
1253
1254   /* Only make a frag if we HAVE to...  */
1255   if (n != 0 && !need_pass_2)
1256     {
1257       if (fill == NULL)
1258         {
1259           if (subseg_text_p (now_seg))
1260             frag_align_code (n, max);
1261           else
1262             frag_align (n, 0, max);
1263         }
1264       else if (len <= 1)
1265         frag_align (n, *fill, max);
1266       else
1267         frag_align_pattern (n, fill, len, max);
1268     }
1269
1270 #ifdef md_do_align
1271  just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1272 #endif
1273
1274   record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1275 }
1276
1277 /* Handle the .align pseudo-op.  A positive ARG is a default alignment
1278    (in bytes).  A negative ARG is the negative of the length of the
1279    fill pattern.  BYTES_P is non-zero if the alignment value should be
1280    interpreted as the byte boundary, rather than the power of 2.  */
1281 #ifndef TC_ALIGN_LIMIT
1282 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1283 #endif
1284
1285 static void
1286 s_align (int arg, int bytes_p)
1287 {
1288   unsigned int align_limit = TC_ALIGN_LIMIT;
1289   unsigned int align;
1290   char *stop = NULL;
1291   char stopc = 0;
1292   offsetT fill = 0;
1293   int max;
1294   int fill_p;
1295
1296   if (flag_mri)
1297     stop = mri_comment_field (&stopc);
1298
1299   if (is_end_of_line[(unsigned char) *input_line_pointer])
1300     {
1301       if (arg < 0)
1302         align = 0;
1303       else
1304         align = arg;    /* Default value from pseudo-op table.  */
1305     }
1306   else
1307     {
1308       align = get_absolute_expression ();
1309       SKIP_WHITESPACE ();
1310     }
1311
1312   if (bytes_p)
1313     {
1314       /* Convert to a power of 2.  */
1315       if (align != 0)
1316         {
1317           unsigned int i;
1318
1319           for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1320             ;
1321           if (align != 1)
1322             as_bad (_("alignment not a power of 2"));
1323
1324           align = i;
1325         }
1326     }
1327
1328   if (align > align_limit)
1329     {
1330       align = align_limit;
1331       as_warn (_("alignment too large: %u assumed"), align);
1332     }
1333
1334   if (*input_line_pointer != ',')
1335     {
1336       fill_p = 0;
1337       max = 0;
1338     }
1339   else
1340     {
1341       ++input_line_pointer;
1342       if (*input_line_pointer == ',')
1343         fill_p = 0;
1344       else
1345         {
1346           fill = get_absolute_expression ();
1347           SKIP_WHITESPACE ();
1348           fill_p = 1;
1349         }
1350
1351       if (*input_line_pointer != ',')
1352         max = 0;
1353       else
1354         {
1355           ++input_line_pointer;
1356           max = get_absolute_expression ();
1357         }
1358     }
1359
1360   if (!fill_p)
1361     {
1362       if (arg < 0)
1363         as_warn (_("expected fill pattern missing"));
1364       do_align (align, (char *) NULL, 0, max);
1365     }
1366   else
1367     {
1368       int fill_len;
1369
1370       if (arg >= 0)
1371         fill_len = 1;
1372       else
1373         fill_len = -arg;
1374       if (fill_len <= 1)
1375         {
1376           char fill_char;
1377
1378           fill_char = fill;
1379           do_align (align, &fill_char, fill_len, max);
1380         }
1381       else
1382         {
1383           char ab[16];
1384
1385           if ((size_t) fill_len > sizeof ab)
1386             abort ();
1387           md_number_to_chars (ab, fill, fill_len);
1388           do_align (align, ab, fill_len, max);
1389         }
1390     }
1391
1392   demand_empty_rest_of_line ();
1393
1394   if (flag_mri)
1395     mri_comment_end (stop, stopc);
1396 }
1397
1398 /* Handle the .align pseudo-op on machines where ".align 4" means
1399    align to a 4 byte boundary.  */
1400
1401 void
1402 s_align_bytes (int arg)
1403 {
1404   s_align (arg, 1);
1405 }
1406
1407 /* Handle the .align pseudo-op on machines where ".align 4" means align
1408    to a 2**4 boundary.  */
1409
1410 void
1411 s_align_ptwo (int arg)
1412 {
1413   s_align (arg, 0);
1414 }
1415
1416 /* Switch in and out of alternate macro mode.  */
1417
1418 void
1419 s_altmacro (int on)
1420 {
1421   demand_empty_rest_of_line ();
1422   macro_set_alternate (on);
1423 }
1424
1425 symbolS *
1426 s_comm_internal (int param,
1427                  symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1428 {
1429   char *name;
1430   char c;
1431   char *p;
1432   offsetT temp, size;
1433   symbolS *symbolP = NULL;
1434   char *stop = NULL;
1435   char stopc = 0;
1436   expressionS exp;
1437
1438   if (flag_mri)
1439     stop = mri_comment_field (&stopc);
1440
1441   name = input_line_pointer;
1442   c = get_symbol_end ();
1443   /* Just after name is now '\0'.  */
1444   p = input_line_pointer;
1445   *p = c;
1446
1447   if (name == p)
1448     {
1449       as_bad (_("expected symbol name"));
1450       ignore_rest_of_line ();
1451       goto out;
1452     }
1453
1454   SKIP_WHITESPACE ();
1455
1456   /* Accept an optional comma after the name.  The comma used to be
1457      required, but Irix 5 cc does not generate it for .lcomm.  */
1458   if (*input_line_pointer == ',')
1459     input_line_pointer++;
1460
1461   temp = get_absolute_expr (&exp);
1462   size = temp;
1463   size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1464   if (exp.X_op == O_absent)
1465     {
1466       as_bad (_("missing size expression"));
1467       ignore_rest_of_line ();
1468       goto out;
1469     }
1470   else if (temp != size || !exp.X_unsigned)
1471     {
1472       as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1473       ignore_rest_of_line ();
1474       goto out;
1475     }
1476
1477   *p = 0;
1478   symbolP = symbol_find_or_make (name);
1479   if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
1480       && !S_IS_COMMON (symbolP))
1481     {
1482       if (!S_IS_VOLATILE (symbolP))
1483         {
1484           symbolP = NULL;
1485           as_bad (_("symbol `%s' is already defined"), name);
1486           *p = c;
1487           ignore_rest_of_line ();
1488           goto out;
1489         }
1490       symbolP = symbol_clone (symbolP, 1);
1491       S_SET_SEGMENT (symbolP, undefined_section);
1492       S_SET_VALUE (symbolP, 0);
1493       symbol_set_frag (symbolP, &zero_address_frag);
1494       S_CLEAR_VOLATILE (symbolP);
1495     }
1496
1497   size = S_GET_VALUE (symbolP);
1498   if (size == 0)
1499     size = temp;
1500   else if (size != temp)
1501     as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1502              name, (long) size, (long) temp);
1503
1504   *p = c;
1505   if (comm_parse_extra != NULL)
1506     symbolP = (*comm_parse_extra) (param, symbolP, size);
1507   else
1508     {
1509       S_SET_VALUE (symbolP, (valueT) size);
1510       S_SET_EXTERNAL (symbolP);
1511       S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
1512 #ifdef OBJ_VMS
1513       {
1514         extern int flag_one;
1515         if (size == 0 || !flag_one)
1516           S_GET_OTHER (symbolP) = const_flag;
1517       }
1518 #endif
1519     }
1520
1521   demand_empty_rest_of_line ();
1522  out:
1523   if (flag_mri)
1524     mri_comment_end (stop, stopc);
1525   return symbolP;
1526 }
1527
1528 void
1529 s_comm (int ignore)
1530 {
1531   s_comm_internal (ignore, NULL);
1532 }
1533
1534 /* The MRI COMMON pseudo-op.  We handle this by creating a common
1535    symbol with the appropriate name.  We make s_space do the right
1536    thing by increasing the size.  */
1537
1538 void
1539 s_mri_common (int small ATTRIBUTE_UNUSED)
1540 {
1541   char *name;
1542   char c;
1543   char *alc = NULL;
1544   symbolS *sym;
1545   offsetT align;
1546   char *stop = NULL;
1547   char stopc = 0;
1548
1549   if (!flag_mri)
1550     {
1551       s_comm (0);
1552       return;
1553     }
1554
1555   stop = mri_comment_field (&stopc);
1556
1557   SKIP_WHITESPACE ();
1558
1559   name = input_line_pointer;
1560   if (!ISDIGIT (*name))
1561     c = get_symbol_end ();
1562   else
1563     {
1564       do
1565         {
1566           ++input_line_pointer;
1567         }
1568       while (ISDIGIT (*input_line_pointer));
1569
1570       c = *input_line_pointer;
1571       *input_line_pointer = '\0';
1572
1573       if (line_label != NULL)
1574         {
1575           alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1576                                   + (input_line_pointer - name)
1577                                   + 1);
1578           sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1579           name = alc;
1580         }
1581     }
1582
1583   sym = symbol_find_or_make (name);
1584   *input_line_pointer = c;
1585   if (alc != NULL)
1586     free (alc);
1587
1588   if (*input_line_pointer != ',')
1589     align = 0;
1590   else
1591     {
1592       ++input_line_pointer;
1593       align = get_absolute_expression ();
1594     }
1595
1596   if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1597     {
1598       as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1599       ignore_rest_of_line ();
1600       mri_comment_end (stop, stopc);
1601       return;
1602     }
1603
1604   S_SET_EXTERNAL (sym);
1605   S_SET_SEGMENT (sym, bfd_com_section_ptr);
1606   mri_common_symbol = sym;
1607
1608 #ifdef S_SET_ALIGN
1609   if (align != 0)
1610     S_SET_ALIGN (sym, align);
1611 #else
1612   (void) align;
1613 #endif
1614
1615   if (line_label != NULL)
1616     {
1617       expressionS exp;
1618       exp.X_op = O_symbol;
1619       exp.X_add_symbol = sym;
1620       exp.X_add_number = 0;
1621       symbol_set_value_expression (line_label, &exp);
1622       symbol_set_frag (line_label, &zero_address_frag);
1623       S_SET_SEGMENT (line_label, expr_section);
1624     }
1625
1626   /* FIXME: We just ignore the small argument, which distinguishes
1627      COMMON and COMMON.S.  I don't know what we can do about it.  */
1628
1629   /* Ignore the type and hptype.  */
1630   if (*input_line_pointer == ',')
1631     input_line_pointer += 2;
1632   if (*input_line_pointer == ',')
1633     input_line_pointer += 2;
1634
1635   demand_empty_rest_of_line ();
1636
1637   mri_comment_end (stop, stopc);
1638 }
1639
1640 void
1641 s_data (int ignore ATTRIBUTE_UNUSED)
1642 {
1643   segT section;
1644   int temp;
1645
1646   temp = get_absolute_expression ();
1647   if (flag_readonly_data_in_text)
1648     {
1649       section = text_section;
1650       temp += 1000;
1651     }
1652   else
1653     section = data_section;
1654
1655   subseg_set (section, (subsegT) temp);
1656
1657 #ifdef OBJ_VMS
1658   const_flag = 0;
1659 #endif
1660   demand_empty_rest_of_line ();
1661 }
1662
1663 /* Handle the .appfile pseudo-op.  This is automatically generated by
1664    do_scrub_chars when a preprocessor # line comment is seen with a
1665    file name.  This default definition may be overridden by the object
1666    or CPU specific pseudo-ops.  This function is also the default
1667    definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1668    .file.  */
1669
1670 void
1671 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1672 {
1673 #ifdef LISTING
1674   if (listing)
1675     listing_source_file (file);
1676 #endif
1677   register_dependency (file);
1678 #ifdef obj_app_file
1679   obj_app_file (file, appfile);
1680 #endif
1681 }
1682
1683 void
1684 s_app_file (int appfile)
1685 {
1686   char *s;
1687   int length;
1688
1689   /* Some assemblers tolerate immediately following '"'.  */
1690   if ((s = demand_copy_string (&length)) != 0)
1691     {
1692       int may_omit
1693         = (!new_logical_line_flags (s, -1, 1) && appfile);
1694
1695       /* In MRI mode, the preprocessor may have inserted an extraneous
1696          backquote.  */
1697       if (flag_m68k_mri
1698           && *input_line_pointer == '\''
1699           && is_end_of_line[(unsigned char) input_line_pointer[1]])
1700         ++input_line_pointer;
1701
1702       demand_empty_rest_of_line ();
1703       if (!may_omit)
1704         s_app_file_string (s, appfile);
1705     }
1706 }
1707
1708 static int
1709 get_linefile_number (int *flag)
1710 {
1711   SKIP_WHITESPACE ();
1712
1713   if (*input_line_pointer < '0' || *input_line_pointer > '9')
1714     return 0;
1715
1716   *flag = get_absolute_expression ();
1717
1718   return 1;
1719 }
1720
1721 /* Handle the .appline pseudo-op.  This is automatically generated by
1722    do_scrub_chars when a preprocessor # line comment is seen.  This
1723    default definition may be overridden by the object or CPU specific
1724    pseudo-ops.  */
1725
1726 void
1727 s_app_line (int appline)
1728 {
1729   char *file = NULL;
1730   int l;
1731
1732   /* The given number is that of the next line.  */
1733   if (appline)
1734     l = get_absolute_expression ();
1735   else if (!get_linefile_number (&l))
1736     {
1737       ignore_rest_of_line ();
1738       return;
1739     }
1740
1741   l--;
1742
1743   if (l < -1)
1744     /* Some of the back ends can't deal with non-positive line numbers.
1745        Besides, it's silly.  GCC however will generate a line number of
1746        zero when it is pre-processing builtins for assembler-with-cpp files:
1747
1748           # 0 "<built-in>"
1749
1750        We do not want to barf on this, especially since such files are used
1751        in the GCC and GDB testsuites.  So we check for negative line numbers
1752        rather than non-positive line numbers.  */
1753     as_warn (_("line numbers must be positive; line number %d rejected"),
1754              l + 1);
1755   else
1756     {
1757       int flags = 0;
1758       int length = 0;
1759
1760       if (!appline)
1761         {
1762           SKIP_WHITESPACE ();
1763
1764           if (*input_line_pointer == '"')
1765             file = demand_copy_string (&length);
1766
1767           if (file)
1768             {
1769               int this_flag;
1770
1771               while (get_linefile_number (&this_flag))
1772                 switch (this_flag)
1773                   {
1774                     /* From GCC's cpp documentation:
1775                        1: start of a new file.
1776                        2: returning to a file after having included
1777                           another file.
1778                        3: following text comes from a system header file.
1779                        4: following text should be treated as extern "C".
1780
1781                        4 is nonsensical for the assembler; 3, we don't
1782                        care about, so we ignore it just in case a
1783                        system header file is included while
1784                        preprocessing assembly.  So 1 and 2 are all we
1785                        care about, and they are mutually incompatible.
1786                        new_logical_line_flags() demands this.  */
1787                   case 1:
1788                   case 2:
1789                     if (flags && flags != (1 << this_flag))
1790                       as_warn (_("incompatible flag %i in line directive"),
1791                                this_flag);
1792                     else
1793                       flags |= 1 << this_flag;
1794                     break;
1795
1796                   case 3:
1797                   case 4:
1798                     /* We ignore these.  */
1799                     break;
1800
1801                   default:
1802                     as_warn (_("unsupported flag %i in line directive"),
1803                              this_flag);
1804                     break;
1805                   }
1806
1807               if (!is_end_of_line[(unsigned char)*input_line_pointer])
1808                 file = 0;
1809             }
1810         }
1811
1812       if (appline || file)
1813         {
1814           new_logical_line_flags (file, l, flags);
1815 #ifdef LISTING
1816           if (listing)
1817             listing_source_line (l);
1818 #endif
1819         }
1820     }
1821   if (appline || file)
1822     demand_empty_rest_of_line ();
1823   else
1824     ignore_rest_of_line ();
1825 }
1826
1827 /* Handle the .end pseudo-op.  Actually, the real work is done in
1828    read_a_source_file.  */
1829
1830 void
1831 s_end (int ignore ATTRIBUTE_UNUSED)
1832 {
1833   if (flag_mri)
1834     {
1835       /* The MRI assembler permits the start symbol to follow .end,
1836          but we don't support that.  */
1837       SKIP_WHITESPACE ();
1838       if (!is_end_of_line[(unsigned char) *input_line_pointer]
1839           && *input_line_pointer != '*'
1840           && *input_line_pointer != '!')
1841         as_warn (_("start address not supported"));
1842     }
1843 }
1844
1845 /* Handle the .err pseudo-op.  */
1846
1847 void
1848 s_err (int ignore ATTRIBUTE_UNUSED)
1849 {
1850   as_bad (_(".err encountered"));
1851   demand_empty_rest_of_line ();
1852 }
1853
1854 /* Handle the .error and .warning pseudo-ops.  */
1855
1856 void
1857 s_errwarn (int err)
1858 {
1859   int len;
1860   /* The purpose for the conditional assignment is not to
1861      internationalize the directive itself, but that we need a
1862      self-contained message, one that can be passed like the
1863      demand_copy_C_string return value, and with no assumption on the
1864      location of the name of the directive within the message.  */
1865   char *msg
1866     = (err ? _(".error directive invoked in source file")
1867        : _(".warning directive invoked in source file"));
1868
1869   if (!is_it_end_of_statement ())
1870     {
1871       if (*input_line_pointer != '\"')
1872         {
1873           as_bad (_("%s argument must be a string"),
1874                   err ? ".error" : ".warning");
1875           ignore_rest_of_line ();
1876           return;
1877         }
1878
1879       msg = demand_copy_C_string (&len);
1880       if (msg == NULL)
1881         return;
1882     }
1883
1884   if (err)
1885     as_bad ("%s", msg);
1886   else
1887     as_warn ("%s", msg);
1888   demand_empty_rest_of_line ();
1889 }
1890
1891 /* Handle the MRI fail pseudo-op.  */
1892
1893 void
1894 s_fail (int ignore ATTRIBUTE_UNUSED)
1895 {
1896   offsetT temp;
1897   char *stop = NULL;
1898   char stopc = 0;
1899
1900   if (flag_mri)
1901     stop = mri_comment_field (&stopc);
1902
1903   temp = get_absolute_expression ();
1904   if (temp >= 500)
1905     as_warn (_(".fail %ld encountered"), (long) temp);
1906   else
1907     as_bad (_(".fail %ld encountered"), (long) temp);
1908
1909   demand_empty_rest_of_line ();
1910
1911   if (flag_mri)
1912     mri_comment_end (stop, stopc);
1913 }
1914
1915 void
1916 s_fill (int ignore ATTRIBUTE_UNUSED)
1917 {
1918   expressionS rep_exp;
1919   long size = 1;
1920   long fill = 0;
1921   char *p;
1922
1923 #ifdef md_flush_pending_output
1924   md_flush_pending_output ();
1925 #endif
1926
1927 #ifdef md_cons_align
1928   md_cons_align (1);
1929 #endif
1930
1931   get_known_segmented_expression (&rep_exp);
1932   if (*input_line_pointer == ',')
1933     {
1934       input_line_pointer++;
1935       size = get_absolute_expression ();
1936       if (*input_line_pointer == ',')
1937         {
1938           input_line_pointer++;
1939           fill = get_absolute_expression ();
1940         }
1941     }
1942
1943   /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
1944 #define BSD_FILL_SIZE_CROCK_8 (8)
1945   if (size > BSD_FILL_SIZE_CROCK_8)
1946     {
1947       as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1948       size = BSD_FILL_SIZE_CROCK_8;
1949     }
1950   if (size < 0)
1951     {
1952       as_warn (_("size negative; .fill ignored"));
1953       size = 0;
1954     }
1955   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1956     {
1957       if (rep_exp.X_add_number < 0)
1958         as_warn (_("repeat < 0; .fill ignored"));
1959       size = 0;
1960     }
1961
1962   if (size && !need_pass_2)
1963     {
1964       if (rep_exp.X_op == O_constant)
1965         {
1966           p = frag_var (rs_fill, (int) size, (int) size,
1967                         (relax_substateT) 0, (symbolS *) 0,
1968                         (offsetT) rep_exp.X_add_number,
1969                         (char *) 0);
1970         }
1971       else
1972         {
1973           /* We don't have a constant repeat count, so we can't use
1974              rs_fill.  We can get the same results out of rs_space,
1975              but its argument is in bytes, so we must multiply the
1976              repeat count by size.  */
1977
1978           symbolS *rep_sym;
1979           rep_sym = make_expr_symbol (&rep_exp);
1980           if (size != 1)
1981             {
1982               expressionS size_exp;
1983               size_exp.X_op = O_constant;
1984               size_exp.X_add_number = size;
1985
1986               rep_exp.X_op = O_multiply;
1987               rep_exp.X_add_symbol = rep_sym;
1988               rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1989               rep_exp.X_add_number = 0;
1990               rep_sym = make_expr_symbol (&rep_exp);
1991             }
1992
1993           p = frag_var (rs_space, (int) size, (int) size,
1994                         (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1995         }
1996
1997       memset (p, 0, (unsigned int) size);
1998
1999       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2000          flavoured AS.  The following bizarre behaviour is to be
2001          compatible with above.  I guess they tried to take up to 8
2002          bytes from a 4-byte expression and they forgot to sign
2003          extend.  */
2004 #define BSD_FILL_SIZE_CROCK_4 (4)
2005       md_number_to_chars (p, (valueT) fill,
2006                           (size > BSD_FILL_SIZE_CROCK_4
2007                            ? BSD_FILL_SIZE_CROCK_4
2008                            : (int) size));
2009       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2010          but emits no error message because it seems a legal thing to do.
2011          It is a degenerate case of .fill but could be emitted by a
2012          compiler.  */
2013     }
2014   demand_empty_rest_of_line ();
2015 }
2016
2017 void
2018 s_globl (int ignore ATTRIBUTE_UNUSED)
2019 {
2020   char *name;
2021   int c;
2022   symbolS *symbolP;
2023   char *stop = NULL;
2024   char stopc = 0;
2025
2026   if (flag_mri)
2027     stop = mri_comment_field (&stopc);
2028
2029   do
2030     {
2031       name = input_line_pointer;
2032       c = get_symbol_end ();
2033       symbolP = symbol_find_or_make (name);
2034       S_SET_EXTERNAL (symbolP);
2035
2036       *input_line_pointer = c;
2037       SKIP_WHITESPACE ();
2038       c = *input_line_pointer;
2039       if (c == ',')
2040         {
2041           input_line_pointer++;
2042           SKIP_WHITESPACE ();
2043           if (is_end_of_line[(unsigned char) *input_line_pointer])
2044             c = '\n';
2045         }
2046     }
2047   while (c == ',');
2048
2049   demand_empty_rest_of_line ();
2050
2051   if (flag_mri)
2052     mri_comment_end (stop, stopc);
2053 }
2054
2055 #ifdef OBJ_ELF
2056 #define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
2057
2058 static inline int
2059 skip_past_char (char ** str, char c)
2060 {
2061   if (**str == c)
2062     {
2063       (*str)++;
2064       return 0;
2065     }
2066   else
2067     return -1;
2068 }
2069 #define skip_past_comma(str) skip_past_char (str, ',')
2070
2071 /* Parse an attribute directive for VENDOR.
2072    Returns the attribute number read, or zero on error.  */
2073 int
2074 s_vendor_attribute (int vendor)
2075 {
2076   expressionS exp;
2077   int type;
2078   int tag;
2079   unsigned int i = 0;
2080   char *s = NULL;
2081
2082   /* Read the first number or name.  */
2083   skip_whitespace (input_line_pointer);
2084   s = input_line_pointer;
2085   if (ISDIGIT (*input_line_pointer))
2086     {
2087       expression (& exp);
2088       if (exp.X_op != O_constant)
2089         goto bad;
2090       tag = exp.X_add_number;
2091     }
2092   else
2093     {
2094       char *name;
2095
2096       /* A name may contain '_', but no other punctuation.  */
2097       for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2098            ++input_line_pointer)
2099         i++;
2100       if (i == 0)
2101         goto bad;
2102
2103       name = (char *) alloca (i + 1);
2104       memcpy (name, s, i);
2105       name[i] = '\0';
2106
2107 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2108 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2109 #endif
2110
2111       tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2112       if (tag == -1)
2113         {
2114           as_bad (_("Attribute name not recognised: %s"), name);
2115           ignore_rest_of_line ();
2116           return 0;
2117         }
2118     }
2119
2120   type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2121
2122   if (skip_past_comma (&input_line_pointer) == -1)
2123     goto bad;
2124   if (type & 1)
2125     {
2126       expression (& exp);
2127       if (exp.X_op != O_constant)
2128         {
2129           as_bad (_("expected numeric constant"));
2130           ignore_rest_of_line ();
2131           return 0;
2132         }
2133       i = exp.X_add_number;
2134     }
2135   if ((type & 3) == 3
2136       && skip_past_comma (&input_line_pointer) == -1)
2137     {
2138       as_bad (_("expected comma"));
2139       ignore_rest_of_line ();
2140       return 0;
2141     }
2142   if (type & 2)
2143     {
2144       int len;
2145
2146       skip_whitespace (input_line_pointer);
2147       if (*input_line_pointer != '"')
2148         goto bad_string;
2149       s = demand_copy_C_string (&len);
2150     }
2151
2152   switch (type & 3)
2153     {
2154     case 3:
2155       bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2156       break;
2157     case 2:
2158       bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2159       break;
2160     case 1:
2161       bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2162       break;
2163     default:
2164       abort ();
2165     }
2166
2167   demand_empty_rest_of_line ();
2168   return tag;
2169 bad_string:
2170   as_bad (_("bad string constant"));
2171   ignore_rest_of_line ();
2172   return 0;
2173 bad:
2174   as_bad (_("expected <tag> , <value>"));
2175   ignore_rest_of_line ();
2176   return 0;
2177 }
2178
2179 /* Parse a .gnu_attribute directive.  */
2180
2181 static void
2182 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2183 {
2184   s_vendor_attribute (OBJ_ATTR_GNU);
2185 }
2186 #endif /* OBJ_ELF */
2187
2188 /* Handle the MRI IRP and IRPC pseudo-ops.  */
2189
2190 void
2191 s_irp (int irpc)
2192 {
2193   char *file, *eol;
2194   unsigned int line;
2195   sb s;
2196   const char *err;
2197   sb out;
2198
2199   as_where (&file, &line);
2200
2201   sb_new (&s);
2202   eol = find_end_of_line (input_line_pointer, 0);
2203   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2204   input_line_pointer = eol;
2205
2206   sb_new (&out);
2207
2208   err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2209   if (err != NULL)
2210     as_bad_where (file, line, "%s", err);
2211
2212   sb_kill (&s);
2213
2214   input_scrub_include_sb (&out, input_line_pointer, 1);
2215   sb_kill (&out);
2216   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2217 }
2218
2219 /* Handle the .linkonce pseudo-op.  This tells the assembler to mark
2220    the section to only be linked once.  However, this is not supported
2221    by most object file formats.  This takes an optional argument,
2222    which is what to do about duplicates.  */
2223
2224 void
2225 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2226 {
2227   enum linkonce_type type;
2228
2229   SKIP_WHITESPACE ();
2230
2231   type = LINKONCE_DISCARD;
2232
2233   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2234     {
2235       char *s;
2236       char c;
2237
2238       s = input_line_pointer;
2239       c = get_symbol_end ();
2240       if (strcasecmp (s, "discard") == 0)
2241         type = LINKONCE_DISCARD;
2242       else if (strcasecmp (s, "one_only") == 0)
2243         type = LINKONCE_ONE_ONLY;
2244       else if (strcasecmp (s, "same_size") == 0)
2245         type = LINKONCE_SAME_SIZE;
2246       else if (strcasecmp (s, "same_contents") == 0)
2247         type = LINKONCE_SAME_CONTENTS;
2248       else
2249         as_warn (_("unrecognized .linkonce type `%s'"), s);
2250
2251       *input_line_pointer = c;
2252     }
2253
2254 #ifdef obj_handle_link_once
2255   obj_handle_link_once (type);
2256 #else /* ! defined (obj_handle_link_once) */
2257   {
2258     flagword flags;
2259
2260     if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2261       as_warn (_(".linkonce is not supported for this object file format"));
2262
2263     flags = bfd_get_section_flags (stdoutput, now_seg);
2264     flags |= SEC_LINK_ONCE;
2265     switch (type)
2266       {
2267       default:
2268         abort ();
2269       case LINKONCE_DISCARD:
2270         flags |= SEC_LINK_DUPLICATES_DISCARD;
2271         break;
2272       case LINKONCE_ONE_ONLY:
2273         flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2274         break;
2275       case LINKONCE_SAME_SIZE:
2276         flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2277         break;
2278       case LINKONCE_SAME_CONTENTS:
2279         flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2280         break;
2281       }
2282     if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2283       as_bad (_("bfd_set_section_flags: %s"),
2284               bfd_errmsg (bfd_get_error ()));
2285   }
2286 #endif /* ! defined (obj_handle_link_once) */
2287
2288   demand_empty_rest_of_line ();
2289 }
2290
2291 void
2292 bss_alloc (symbolS *symbolP, addressT size, int align)
2293 {
2294   char *pfrag;
2295   segT current_seg = now_seg;
2296   subsegT current_subseg = now_subseg;
2297   segT bss_seg = bss_section;
2298
2299 #if defined (TC_MIPS) || defined (TC_ALPHA)
2300   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2301       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2302     {
2303       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
2304       if (size <= bfd_get_gp_size (stdoutput))
2305         {
2306           bss_seg = subseg_new (".sbss", 1);
2307           seg_info (bss_seg)->bss = 1;
2308           if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2309             as_warn (_("error setting flags for \".sbss\": %s"),
2310                      bfd_errmsg (bfd_get_error ()));
2311         }
2312     }
2313 #endif
2314   subseg_set (bss_seg, 1);
2315
2316   if (align)
2317     {
2318       record_alignment (bss_seg, align);
2319       frag_align (align, 0, 0);
2320     }
2321
2322   /* Detach from old frag.  */
2323   if (S_GET_SEGMENT (symbolP) == bss_seg)
2324     symbol_get_frag (symbolP)->fr_symbol = NULL;
2325
2326   symbol_set_frag (symbolP, frag_now);
2327   pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2328   *pfrag = 0;
2329
2330 #ifdef S_SET_SIZE
2331   S_SET_SIZE (symbolP, size);
2332 #endif
2333   S_SET_SEGMENT (symbolP, bss_seg);
2334
2335 #ifdef OBJ_COFF
2336   /* The symbol may already have been created with a preceding
2337      ".globl" directive -- be careful not to step on storage class
2338      in that case.  Otherwise, set it to static.  */
2339   if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2340     S_SET_STORAGE_CLASS (symbolP, C_STAT);
2341 #endif /* OBJ_COFF */
2342
2343   subseg_set (current_seg, current_subseg);
2344 }
2345
2346 offsetT
2347 parse_align (int align_bytes)
2348 {
2349   expressionS exp;
2350   addressT align;
2351
2352   SKIP_WHITESPACE ();
2353   if (*input_line_pointer != ',')
2354     {
2355     no_align:
2356       as_bad (_("expected alignment after size"));
2357       ignore_rest_of_line ();
2358       return -1;
2359     }
2360
2361   input_line_pointer++;
2362   SKIP_WHITESPACE ();
2363
2364   align = get_absolute_expr (&exp);
2365   if (exp.X_op == O_absent)
2366     goto no_align;
2367
2368   if (!exp.X_unsigned)
2369     {
2370       as_warn (_("alignment negative; 0 assumed"));
2371       align = 0;
2372     }
2373
2374   if (align_bytes && align != 0)
2375     {
2376       /* convert to a power of 2 alignment */
2377       unsigned int alignp2 = 0;
2378       while ((align & 1) == 0)
2379         align >>= 1, ++alignp2;
2380       if (align != 1)
2381         {
2382           as_bad (_("alignment not a power of 2"));
2383           ignore_rest_of_line ();
2384           return -1;
2385         }
2386       align = alignp2;
2387     }
2388   return align;
2389 }
2390
2391 /* Called from s_comm_internal after symbol name and size have been
2392    parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2393    1 if this was a ".bss" directive which has a 3rd argument
2394    (alignment as a power of 2), or 2 if this was a ".bss" directive
2395    with alignment in bytes.  */
2396
2397 symbolS *
2398 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2399 {
2400   addressT align = 0;
2401
2402   if (needs_align)
2403     {
2404       align = parse_align (needs_align - 1);
2405       if (align == (addressT) -1)
2406         return NULL;
2407     }
2408   else
2409     /* Assume some objects may require alignment on some systems.  */
2410     TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2411
2412   bss_alloc (symbolP, size, align);
2413   return symbolP;
2414 }
2415
2416 void
2417 s_lcomm (int needs_align)
2418 {
2419   s_comm_internal (needs_align, s_lcomm_internal);
2420 }
2421
2422 void
2423 s_lcomm_bytes (int needs_align)
2424 {
2425   s_comm_internal (needs_align * 2, s_lcomm_internal);
2426 }
2427
2428 void
2429 s_lsym (int ignore ATTRIBUTE_UNUSED)
2430 {
2431   char *name;
2432   char c;
2433   char *p;
2434   expressionS exp;
2435   symbolS *symbolP;
2436
2437   /* We permit ANY defined expression: BSD4.2 demands constants.  */
2438   name = input_line_pointer;
2439   c = get_symbol_end ();
2440   p = input_line_pointer;
2441   *p = c;
2442
2443   if (name == p)
2444     {
2445       as_bad (_("expected symbol name"));
2446       ignore_rest_of_line ();
2447       return;
2448     }
2449
2450   SKIP_WHITESPACE ();
2451
2452   if (*input_line_pointer != ',')
2453     {
2454       *p = 0;
2455       as_bad (_("expected comma after \"%s\""), name);
2456       *p = c;
2457       ignore_rest_of_line ();
2458       return;
2459     }
2460
2461   input_line_pointer++;
2462   expression_and_evaluate (&exp);
2463
2464   if (exp.X_op != O_constant
2465       && exp.X_op != O_register)
2466     {
2467       as_bad (_("bad expression"));
2468       ignore_rest_of_line ();
2469       return;
2470     }
2471
2472   *p = 0;
2473   symbolP = symbol_find_or_make (name);
2474
2475   if (S_GET_SEGMENT (symbolP) == undefined_section)
2476     {
2477       /* The name might be an undefined .global symbol; be sure to
2478          keep the "external" bit.  */
2479       S_SET_SEGMENT (symbolP,
2480                      (exp.X_op == O_constant
2481                       ? absolute_section
2482                       : reg_section));
2483       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2484     }
2485   else
2486     {
2487       as_bad (_("symbol `%s' is already defined"), name);
2488     }
2489
2490   *p = c;
2491   demand_empty_rest_of_line ();
2492 }
2493
2494 /* Read a line into an sb.  Returns the character that ended the line
2495    or zero if there are no more lines.  */
2496
2497 static int
2498 get_line_sb (sb *line, int in_macro)
2499 {
2500   char *eol;
2501
2502   if (input_line_pointer[-1] == '\n')
2503     bump_line_counters ();
2504
2505   if (input_line_pointer >= buffer_limit)
2506     {
2507       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2508       if (buffer_limit == 0)
2509         return 0;
2510     }
2511
2512   eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2513   sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2514   input_line_pointer = eol;
2515
2516   /* Don't skip multiple end-of-line characters, because that breaks support
2517      for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2518      characters but isn't.  Instead just skip one end of line character and
2519      return the character skipped so that the caller can re-insert it if
2520      necessary.   */
2521   return *input_line_pointer++;
2522 }
2523
2524 static int
2525 get_non_macro_line_sb (sb *line)
2526 {
2527   return get_line_sb (line, 0);
2528 }
2529
2530 static int
2531 get_macro_line_sb (sb *line)
2532 {
2533   return get_line_sb (line, 1);
2534 }
2535
2536 /* Define a macro.  This is an interface to macro.c.  */
2537
2538 void
2539 s_macro (int ignore ATTRIBUTE_UNUSED)
2540 {
2541   char *file, *eol;
2542   unsigned int line;
2543   sb s;
2544   const char *err;
2545   const char *name;
2546
2547   as_where (&file, &line);
2548
2549   sb_new (&s);
2550   eol = find_end_of_line (input_line_pointer, 0);
2551   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2552   input_line_pointer = eol;
2553
2554   if (line_label != NULL)
2555     {
2556       sb label;
2557
2558       sb_new (&label);
2559       sb_add_string (&label, S_GET_NAME (line_label));
2560       err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2561       sb_kill (&label);
2562     }
2563   else
2564     err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2565   if (err != NULL)
2566     as_bad_where (file, line, err, name);
2567   else
2568     {
2569       if (line_label != NULL)
2570         {
2571           S_SET_SEGMENT (line_label, absolute_section);
2572           S_SET_VALUE (line_label, 0);
2573           symbol_set_frag (line_label, &zero_address_frag);
2574         }
2575
2576       if (((NO_PSEUDO_DOT || flag_m68k_mri)
2577            && hash_find (po_hash, name) != NULL)
2578           || (!flag_m68k_mri
2579               && *name == '.'
2580               && hash_find (po_hash, name + 1) != NULL))
2581         as_warn_where (file,
2582                  line,
2583                  _("attempt to redefine pseudo-op `%s' ignored"),
2584                  name);
2585     }
2586
2587   sb_kill (&s);
2588 }
2589
2590 /* Handle the .mexit pseudo-op, which immediately exits a macro
2591    expansion.  */
2592
2593 void
2594 s_mexit (int ignore ATTRIBUTE_UNUSED)
2595 {
2596   if (macro_nest)
2597     {
2598       cond_exit_macro (macro_nest);
2599       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2600     }
2601   else
2602     as_warn (_("ignoring macro exit outside a macro definition."));
2603 }
2604
2605 /* Switch in and out of MRI mode.  */
2606
2607 void
2608 s_mri (int ignore ATTRIBUTE_UNUSED)
2609 {
2610   int on;
2611 #ifdef MRI_MODE_CHANGE
2612   int old_flag;
2613 #endif
2614
2615   on = get_absolute_expression ();
2616 #ifdef MRI_MODE_CHANGE
2617   old_flag = flag_mri;
2618 #endif
2619   if (on != 0)
2620     {
2621       flag_mri = 1;
2622 #ifdef TC_M68K
2623       flag_m68k_mri = 1;
2624 #endif
2625       macro_mri_mode (1);
2626     }
2627   else
2628     {
2629       flag_mri = 0;
2630 #ifdef TC_M68K
2631       flag_m68k_mri = 0;
2632 #endif
2633       macro_mri_mode (0);
2634     }
2635
2636   /* Operator precedence changes in m68k MRI mode, so we need to
2637      update the operator rankings.  */
2638   expr_set_precedence ();
2639
2640 #ifdef MRI_MODE_CHANGE
2641   if (on != old_flag)
2642     MRI_MODE_CHANGE (on);
2643 #endif
2644
2645   demand_empty_rest_of_line ();
2646 }
2647
2648 /* Handle changing the location counter.  */
2649
2650 static void
2651 do_org (segT segment, expressionS *exp, int fill)
2652 {
2653   if (segment != now_seg
2654       && segment != absolute_section
2655       && segment != expr_section)
2656     as_bad (_("invalid segment \"%s\""), segment_name (segment));
2657
2658   if (now_seg == absolute_section)
2659     {
2660       if (fill != 0)
2661         as_warn (_("ignoring fill value in absolute section"));
2662       if (exp->X_op != O_constant)
2663         {
2664           as_bad (_("only constant offsets supported in absolute section"));
2665           exp->X_add_number = 0;
2666         }
2667       abs_section_offset = exp->X_add_number;
2668     }
2669   else
2670     {
2671       char *p;
2672       symbolS *sym = exp->X_add_symbol;
2673       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2674
2675       if (exp->X_op != O_constant && exp->X_op != O_symbol)
2676         {
2677           /* Handle complex expressions.  */
2678           sym = make_expr_symbol (exp);
2679           off = 0;
2680         }
2681
2682       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2683       *p = fill;
2684     }
2685 }
2686
2687 void
2688 s_org (int ignore ATTRIBUTE_UNUSED)
2689 {
2690   segT segment;
2691   expressionS exp;
2692   long temp_fill;
2693
2694 #ifdef md_flush_pending_output
2695   md_flush_pending_output ();
2696 #endif
2697
2698   /* The m68k MRI assembler has a different meaning for .org.  It
2699      means to create an absolute section at a given address.  We can't
2700      support that--use a linker script instead.  */
2701   if (flag_m68k_mri)
2702     {
2703       as_bad (_("MRI style ORG pseudo-op not supported"));
2704       ignore_rest_of_line ();
2705       return;
2706     }
2707
2708   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2709      thing as a sub-segment-relative origin.  Any absolute origin is
2710      given a warning, then assumed to be segment-relative.  Any
2711      segmented origin expression ("foo+42") had better be in the right
2712      segment or the .org is ignored.
2713
2714      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2715      we never know sub-segment sizes when we are reading code.  BSD
2716      will crash trying to emit negative numbers of filler bytes in
2717      certain .orgs. We don't crash, but see as-write for that code.
2718
2719      Don't make frag if need_pass_2==1.  */
2720   segment = get_known_segmented_expression (&exp);
2721   if (*input_line_pointer == ',')
2722     {
2723       input_line_pointer++;
2724       temp_fill = get_absolute_expression ();
2725     }
2726   else
2727     temp_fill = 0;
2728
2729   if (!need_pass_2)
2730     do_org (segment, &exp, temp_fill);
2731
2732   demand_empty_rest_of_line ();
2733 }
2734
2735 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2736    called by the obj-format routine which handles section changing
2737    when in MRI mode.  It will create a new section, and return it.  It
2738    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2739    'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */
2740
2741 void
2742 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2743 {
2744 #ifdef TC_M68K
2745
2746   char *name;
2747   char c;
2748   segT seg;
2749
2750   SKIP_WHITESPACE ();
2751
2752   name = input_line_pointer;
2753   if (!ISDIGIT (*name))
2754     c = get_symbol_end ();
2755   else
2756     {
2757       do
2758         {
2759           ++input_line_pointer;
2760         }
2761       while (ISDIGIT (*input_line_pointer));
2762
2763       c = *input_line_pointer;
2764       *input_line_pointer = '\0';
2765     }
2766
2767   name = xstrdup (name);
2768
2769   *input_line_pointer = c;
2770
2771   seg = subseg_new (name, 0);
2772
2773   if (*input_line_pointer == ',')
2774     {
2775       int align;
2776
2777       ++input_line_pointer;
2778       align = get_absolute_expression ();
2779       record_alignment (seg, align);
2780     }
2781
2782   *type = 'C';
2783   if (*input_line_pointer == ',')
2784     {
2785       c = *++input_line_pointer;
2786       c = TOUPPER (c);
2787       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2788         *type = c;
2789       else
2790         as_bad (_("unrecognized section type"));
2791       ++input_line_pointer;
2792
2793       {
2794         flagword flags;
2795
2796         flags = SEC_NO_FLAGS;
2797         if (*type == 'C')
2798           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2799         else if (*type == 'D' || *type == 'M')
2800           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2801         else if (*type == 'R')
2802           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2803         if (flags != SEC_NO_FLAGS)
2804           {
2805             if (!bfd_set_section_flags (stdoutput, seg, flags))
2806               as_warn (_("error setting flags for \"%s\": %s"),
2807                        bfd_section_name (stdoutput, seg),
2808                        bfd_errmsg (bfd_get_error ()));
2809           }
2810       }
2811     }
2812
2813   /* Ignore the HP type.  */
2814   if (*input_line_pointer == ',')
2815     input_line_pointer += 2;
2816
2817   demand_empty_rest_of_line ();
2818
2819 #else /* ! TC_M68K */
2820 #ifdef TC_I960
2821
2822   char *name;
2823   char c;
2824   segT seg;
2825
2826   SKIP_WHITESPACE ();
2827
2828   name = input_line_pointer;
2829   c = get_symbol_end ();
2830
2831   name = xstrdup (name);
2832
2833   *input_line_pointer = c;
2834
2835   seg = subseg_new (name, 0);
2836
2837   if (*input_line_pointer != ',')
2838     *type = 'C';
2839   else
2840     {
2841       char *sectype;
2842
2843       ++input_line_pointer;
2844       SKIP_WHITESPACE ();
2845       sectype = input_line_pointer;
2846       c = get_symbol_end ();
2847       if (*sectype == '\0')
2848         *type = 'C';
2849       else if (strcasecmp (sectype, "text") == 0)
2850         *type = 'C';
2851       else if (strcasecmp (sectype, "data") == 0)
2852         *type = 'D';
2853       else if (strcasecmp (sectype, "romdata") == 0)
2854         *type = 'R';
2855       else
2856         as_warn (_("unrecognized section type `%s'"), sectype);
2857       *input_line_pointer = c;
2858     }
2859
2860   if (*input_line_pointer == ',')
2861     {
2862       char *seccmd;
2863
2864       ++input_line_pointer;
2865       SKIP_WHITESPACE ();
2866       seccmd = input_line_pointer;
2867       c = get_symbol_end ();
2868       if (strcasecmp (seccmd, "absolute") == 0)
2869         {
2870           as_bad (_("absolute sections are not supported"));
2871           *input_line_pointer = c;
2872           ignore_rest_of_line ();
2873           return;
2874         }
2875       else if (strcasecmp (seccmd, "align") == 0)
2876         {
2877           int align;
2878
2879           *input_line_pointer = c;
2880           align = get_absolute_expression ();
2881           record_alignment (seg, align);
2882         }
2883       else
2884         {
2885           as_warn (_("unrecognized section command `%s'"), seccmd);
2886           *input_line_pointer = c;
2887         }
2888     }
2889
2890   demand_empty_rest_of_line ();
2891
2892 #else /* ! TC_I960 */
2893   /* The MRI assembler seems to use different forms of .sect for
2894      different targets.  */
2895   as_bad ("MRI mode not supported for this target");
2896   ignore_rest_of_line ();
2897 #endif /* ! TC_I960 */
2898 #endif /* ! TC_M68K */
2899 }
2900
2901 /* Handle the .print pseudo-op.  */
2902
2903 void
2904 s_print (int ignore ATTRIBUTE_UNUSED)
2905 {
2906   char *s;
2907   int len;
2908
2909   s = demand_copy_C_string (&len);
2910   if (s != NULL)
2911     printf ("%s\n", s);
2912   demand_empty_rest_of_line ();
2913 }
2914
2915 /* Handle the .purgem pseudo-op.  */
2916
2917 void
2918 s_purgem (int ignore ATTRIBUTE_UNUSED)
2919 {
2920   if (is_it_end_of_statement ())
2921     {
2922       demand_empty_rest_of_line ();
2923       return;
2924     }
2925
2926   do
2927     {
2928       char *name;
2929       char c;
2930
2931       SKIP_WHITESPACE ();
2932       name = input_line_pointer;
2933       c = get_symbol_end ();
2934       delete_macro (name);
2935       *input_line_pointer = c;
2936       SKIP_WHITESPACE ();
2937     }
2938   while (*input_line_pointer++ == ',');
2939
2940   --input_line_pointer;
2941   demand_empty_rest_of_line ();
2942 }
2943
2944 /* Handle the .endm/.endr pseudo-ops.  */
2945
2946 static void
2947 s_bad_end (int endr)
2948 {
2949   as_warn (_(".end%c encountered without preceeding %s"),
2950            endr ? 'r' : 'm',
2951            endr ? ".rept, .irp, or .irpc" : ".macro");
2952   demand_empty_rest_of_line ();
2953 }
2954
2955 /* Handle the .rept pseudo-op.  */
2956
2957 void
2958 s_rept (int ignore ATTRIBUTE_UNUSED)
2959 {
2960   int count;
2961
2962   count = get_absolute_expression ();
2963
2964   do_repeat (count, "REPT", "ENDR");
2965 }
2966
2967 /* This function provides a generic repeat block implementation.   It allows
2968    different directives to be used as the start/end keys.  */
2969
2970 void
2971 do_repeat (int count, const char *start, const char *end)
2972 {
2973   sb one;
2974   sb many;
2975
2976   sb_new (&one);
2977   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2978     {
2979       as_bad (_("%s without %s"), start, end);
2980       return;
2981     }
2982
2983   sb_new (&many);
2984   while (count-- > 0)
2985     sb_add_sb (&many, &one);
2986
2987   sb_kill (&one);
2988
2989   input_scrub_include_sb (&many, input_line_pointer, 1);
2990   sb_kill (&many);
2991   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2992 }
2993
2994 /* Like do_repeat except that any text matching EXPANDER in the
2995    block is replaced by the itteration count.  */
2996
2997 void
2998 do_repeat_with_expander (int count,
2999                          const char * start,
3000                          const char * end,
3001                          const char * expander)
3002 {
3003   sb one;
3004   sb many;
3005
3006   sb_new (&one);
3007   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3008     {
3009       as_bad (_("%s without %s"), start, end);
3010       return;
3011     }
3012
3013   sb_new (&many);
3014
3015   if (expander != NULL && strstr (one.ptr, expander) != NULL)
3016     {
3017       while (count -- > 0)
3018         {
3019           int len;
3020           char * sub;
3021           sb processed;
3022
3023           sb_new (& processed);
3024           sb_add_sb (& processed, & one);
3025           sub = strstr (processed.ptr, expander);
3026           len = sprintf (sub, "%d", count);
3027           gas_assert (len < 8);
3028           strcpy (sub + len, sub + 8);
3029           processed.len -= (8 - len);
3030           sb_add_sb (& many, & processed);
3031           sb_kill (& processed);
3032         }
3033     }
3034   else
3035     while (count-- > 0)
3036       sb_add_sb (&many, &one);
3037
3038   sb_kill (&one);
3039
3040   input_scrub_include_sb (&many, input_line_pointer, 1);
3041   sb_kill (&many);
3042   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3043 }
3044
3045 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3046    input buffers to skip.  Assumes that conditionals preceding the loop end
3047    are properly nested.
3048
3049    This function makes it easier to implement a premature "break" out of the
3050    loop.  The EXTRA arg accounts for other buffers we might have inserted,
3051    such as line substitutions.  */
3052
3053 void
3054 end_repeat (int extra)
3055 {
3056   cond_exit_macro (macro_nest);
3057   while (extra-- >= 0)
3058     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3059 }
3060
3061 static void
3062 assign_symbol (char *name, int mode)
3063 {
3064   symbolS *symbolP;
3065
3066   if (name[0] == '.' && name[1] == '\0')
3067     {
3068       /* Turn '. = mumble' into a .org mumble.  */
3069       segT segment;
3070       expressionS exp;
3071
3072       segment = get_known_segmented_expression (&exp);
3073
3074       if (!need_pass_2)
3075         do_org (segment, &exp, 0);
3076
3077       return;
3078     }
3079
3080   if ((symbolP = symbol_find (name)) == NULL
3081       && (symbolP = md_undefined_symbol (name)) == NULL)
3082     {
3083       symbolP = symbol_find_or_make (name);
3084 #ifndef NO_LISTING
3085       /* When doing symbol listings, play games with dummy fragments living
3086          outside the normal fragment chain to record the file and line info
3087          for this symbol.  */
3088       if (listing & LISTING_SYMBOLS)
3089         {
3090           extern struct list_info_struct *listing_tail;
3091           fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3092           dummy_frag->line = listing_tail;
3093           dummy_frag->fr_symbol = symbolP;
3094           symbol_set_frag (symbolP, dummy_frag);
3095         }
3096 #endif
3097 #ifdef OBJ_COFF
3098       /* "set" symbols are local unless otherwise specified.  */
3099       SF_SET_LOCAL (symbolP);
3100 #endif
3101     }
3102
3103   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3104     {
3105       /* Permit register names to be redefined.  */
3106       if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3107           && S_GET_SEGMENT (symbolP) != reg_section)
3108         {
3109           as_bad (_("symbol `%s' is already defined"), name);
3110           symbolP = symbol_clone (symbolP, 0);
3111         }
3112       /* If the symbol is volatile, copy the symbol and replace the
3113          original with the copy, so that previous uses of the symbol will
3114          retain the value of the symbol at the point of use.  */
3115       else if (S_IS_VOLATILE (symbolP))
3116         symbolP = symbol_clone (symbolP, 1);
3117     }
3118
3119   if (mode == 0)
3120     S_SET_VOLATILE (symbolP);
3121   else if (mode < 0)
3122     S_SET_FORWARD_REF (symbolP);
3123
3124   pseudo_set (symbolP);
3125 }
3126
3127 /* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
3128    then this is .equiv, and it is an error if the symbol is already
3129    defined.  If EQUIV is -1, the symbol additionally is a forward
3130    reference.  */
3131
3132 void
3133 s_set (int equiv)
3134 {
3135   char *name;
3136   char delim;
3137   char *end_name;
3138
3139   /* Especial apologies for the random logic:
3140      this just grew, and could be parsed much more simply!
3141      Dean in haste.  */
3142   name = input_line_pointer;
3143   delim = get_symbol_end ();
3144   end_name = input_line_pointer;
3145   *end_name = delim;
3146
3147   if (name == end_name)
3148     {
3149       as_bad (_("expected symbol name"));
3150       ignore_rest_of_line ();
3151       return;
3152     }
3153
3154   SKIP_WHITESPACE ();
3155
3156   if (*input_line_pointer != ',')
3157     {
3158       *end_name = 0;
3159       as_bad (_("expected comma after \"%s\""), name);
3160       *end_name = delim;
3161       ignore_rest_of_line ();
3162       return;
3163     }
3164
3165   input_line_pointer++;
3166   *end_name = 0;
3167
3168   assign_symbol (name, equiv);
3169   *end_name = delim;
3170
3171   demand_empty_rest_of_line ();
3172 }
3173
3174 void
3175 s_space (int mult)
3176 {
3177   expressionS exp;
3178   expressionS val;
3179   char *p = 0;
3180   char *stop = NULL;
3181   char stopc = 0;
3182   int bytes;
3183
3184 #ifdef md_flush_pending_output
3185   md_flush_pending_output ();
3186 #endif
3187
3188 #ifdef md_cons_align
3189   md_cons_align (1);
3190 #endif
3191
3192   if (flag_mri)
3193     stop = mri_comment_field (&stopc);
3194
3195   /* In m68k MRI mode, we need to align to a word boundary, unless
3196      this is ds.b.  */
3197   if (flag_m68k_mri && mult > 1)
3198     {
3199       if (now_seg == absolute_section)
3200         {
3201           abs_section_offset += abs_section_offset & 1;
3202           if (line_label != NULL)
3203             S_SET_VALUE (line_label, abs_section_offset);
3204         }
3205       else if (mri_common_symbol != NULL)
3206         {
3207           valueT mri_val;
3208
3209           mri_val = S_GET_VALUE (mri_common_symbol);
3210           if ((mri_val & 1) != 0)
3211             {
3212               S_SET_VALUE (mri_common_symbol, mri_val + 1);
3213               if (line_label != NULL)
3214                 {
3215                   expressionS *symexp;
3216
3217                   symexp = symbol_get_value_expression (line_label);
3218                   know (symexp->X_op == O_symbol);
3219                   know (symexp->X_add_symbol == mri_common_symbol);
3220                   symexp->X_add_number += 1;
3221                 }
3222             }
3223         }
3224       else
3225         {
3226           do_align (1, (char *) NULL, 0, 0);
3227           if (line_label != NULL)
3228             {
3229               symbol_set_frag (line_label, frag_now);
3230               S_SET_VALUE (line_label, frag_now_fix ());
3231             }
3232         }
3233     }
3234
3235   bytes = mult;
3236
3237   expression (&exp);
3238
3239   SKIP_WHITESPACE ();
3240   if (*input_line_pointer == ',')
3241     {
3242       ++input_line_pointer;
3243       expression (&val);
3244     }
3245   else
3246     {
3247       val.X_op = O_constant;
3248       val.X_add_number = 0;
3249     }
3250
3251   if (val.X_op != O_constant
3252       || val.X_add_number < - 0x80
3253       || val.X_add_number > 0xff
3254       || (mult != 0 && mult != 1 && val.X_add_number != 0))
3255     {
3256       resolve_expression (&exp);
3257       if (exp.X_op != O_constant)
3258         as_bad (_("unsupported variable size or fill value"));
3259       else
3260         {
3261           offsetT i;
3262
3263           if (mult == 0)
3264             mult = 1;
3265           bytes = mult * exp.X_add_number;
3266           for (i = 0; i < exp.X_add_number; i++)
3267             emit_expr (&val, mult);
3268         }
3269     }
3270   else
3271     {
3272       if (now_seg == absolute_section || mri_common_symbol != NULL)
3273         resolve_expression (&exp);
3274
3275       if (exp.X_op == O_constant)
3276         {
3277           offsetT repeat;
3278
3279           repeat = exp.X_add_number;
3280           if (mult)
3281             repeat *= mult;
3282           bytes = repeat;
3283           if (repeat <= 0)
3284             {
3285               if (!flag_mri)
3286                 as_warn (_(".space repeat count is zero, ignored"));
3287               else if (repeat < 0)
3288                 as_warn (_(".space repeat count is negative, ignored"));
3289               goto getout;
3290             }
3291
3292           /* If we are in the absolute section, just bump the offset.  */
3293           if (now_seg == absolute_section)
3294             {
3295               abs_section_offset += repeat;
3296               goto getout;
3297             }
3298
3299           /* If we are secretly in an MRI common section, then
3300              creating space just increases the size of the common
3301              symbol.  */
3302           if (mri_common_symbol != NULL)
3303             {
3304               S_SET_VALUE (mri_common_symbol,
3305                            S_GET_VALUE (mri_common_symbol) + repeat);
3306               goto getout;
3307             }
3308
3309           if (!need_pass_2)
3310             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3311                           (offsetT) repeat, (char *) 0);
3312         }
3313       else
3314         {
3315           if (now_seg == absolute_section)
3316             {
3317               as_bad (_("space allocation too complex in absolute section"));
3318               subseg_set (text_section, 0);
3319             }
3320
3321           if (mri_common_symbol != NULL)
3322             {
3323               as_bad (_("space allocation too complex in common section"));
3324               mri_common_symbol = NULL;
3325             }
3326
3327           if (!need_pass_2)
3328             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3329                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3330         }
3331
3332       if (p)
3333         *p = val.X_add_number;
3334     }
3335
3336  getout:
3337
3338   /* In MRI mode, after an odd number of bytes, we must align to an
3339      even word boundary, unless the next instruction is a dc.b, ds.b
3340      or dcb.b.  */
3341   if (flag_mri && (bytes & 1) != 0)
3342     mri_pending_align = 1;
3343
3344   demand_empty_rest_of_line ();
3345
3346   if (flag_mri)
3347     mri_comment_end (stop, stopc);
3348 }
3349
3350 /* This is like s_space, but the value is a floating point number with
3351    the given precision.  This is for the MRI dcb.s pseudo-op and
3352    friends.  */
3353
3354 void
3355 s_float_space (int float_type)
3356 {
3357   offsetT count;
3358   int flen;
3359   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3360   char *stop = NULL;
3361   char stopc = 0;
3362
3363 #ifdef md_cons_align
3364   md_cons_align (1);
3365 #endif
3366
3367   if (flag_mri)
3368     stop = mri_comment_field (&stopc);
3369
3370   count = get_absolute_expression ();
3371
3372   SKIP_WHITESPACE ();
3373   if (*input_line_pointer != ',')
3374     {
3375       as_bad (_("missing value"));
3376       ignore_rest_of_line ();
3377       if (flag_mri)
3378         mri_comment_end (stop, stopc);
3379       return;
3380     }
3381
3382   ++input_line_pointer;
3383
3384   SKIP_WHITESPACE ();
3385
3386   /* Skip any 0{letter} that may be present.  Don't even check if the
3387    * letter is legal.  */
3388   if (input_line_pointer[0] == '0'
3389       && ISALPHA (input_line_pointer[1]))
3390     input_line_pointer += 2;
3391
3392   /* Accept :xxxx, where the x's are hex digits, for a floating point
3393      with the exact digits specified.  */
3394   if (input_line_pointer[0] == ':')
3395     {
3396       flen = hex_float (float_type, temp);
3397       if (flen < 0)
3398         {
3399           ignore_rest_of_line ();
3400           if (flag_mri)
3401             mri_comment_end (stop, stopc);
3402           return;
3403         }
3404     }
3405   else
3406     {
3407       char *err;
3408
3409       err = md_atof (float_type, temp, &flen);
3410       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3411       know (err != NULL || flen > 0);
3412       if (err)
3413         {
3414           as_bad (_("bad floating literal: %s"), err);
3415           ignore_rest_of_line ();
3416           if (flag_mri)
3417             mri_comment_end (stop, stopc);
3418           return;
3419         }
3420     }
3421
3422   while (--count >= 0)
3423     {
3424       char *p;
3425
3426       p = frag_more (flen);
3427       memcpy (p, temp, (unsigned int) flen);
3428     }
3429
3430   demand_empty_rest_of_line ();
3431
3432   if (flag_mri)
3433     mri_comment_end (stop, stopc);
3434 }
3435
3436 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3437
3438 void
3439 s_struct (int ignore ATTRIBUTE_UNUSED)
3440 {
3441   char *stop = NULL;
3442   char stopc = 0;
3443
3444   if (flag_mri)
3445     stop = mri_comment_field (&stopc);
3446   abs_section_offset = get_absolute_expression ();
3447 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3448   /* The ELF backend needs to know that we are changing sections, so
3449      that .previous works correctly. */
3450   if (IS_ELF)
3451     obj_elf_section_change_hook ();
3452 #endif
3453   subseg_set (absolute_section, 0);
3454   demand_empty_rest_of_line ();
3455   if (flag_mri)
3456     mri_comment_end (stop, stopc);
3457 }
3458
3459 void
3460 s_text (int ignore ATTRIBUTE_UNUSED)
3461 {
3462   int temp;
3463
3464   temp = get_absolute_expression ();
3465   subseg_set (text_section, (subsegT) temp);
3466   demand_empty_rest_of_line ();
3467 #ifdef OBJ_VMS
3468   const_flag &= ~IN_DEFAULT_SECTION;
3469 #endif
3470 }
3471
3472 /* .weakref x, y sets x as an alias to y that, as long as y is not
3473    referenced directly, will cause y to become a weak symbol.  */
3474 void
3475 s_weakref (int ignore ATTRIBUTE_UNUSED)
3476 {
3477   char *name;
3478   char delim;
3479   char *end_name;
3480   symbolS *symbolP;
3481   symbolS *symbolP2;
3482   expressionS exp;
3483
3484   name = input_line_pointer;
3485   delim = get_symbol_end ();
3486   end_name = input_line_pointer;
3487
3488   if (name == end_name)
3489     {
3490       as_bad (_("expected symbol name"));
3491       *end_name = delim;
3492       ignore_rest_of_line ();
3493       return;
3494     }
3495
3496   symbolP = symbol_find_or_make (name);
3497
3498   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3499     {
3500       if (!S_IS_VOLATILE (symbolP))
3501         {
3502           as_bad (_("symbol `%s' is already defined"), name);
3503           *end_name = delim;
3504           ignore_rest_of_line ();
3505           return;
3506         }
3507       symbolP = symbol_clone (symbolP, 1);
3508       S_CLEAR_VOLATILE (symbolP);
3509     }
3510
3511   *end_name = delim;
3512
3513   SKIP_WHITESPACE ();
3514
3515   if (*input_line_pointer != ',')
3516     {
3517       *end_name = 0;
3518       as_bad (_("expected comma after \"%s\""), name);
3519       *end_name = delim;
3520       ignore_rest_of_line ();
3521       return;
3522     }
3523
3524   input_line_pointer++;
3525
3526   SKIP_WHITESPACE ();
3527
3528   name = input_line_pointer;
3529   delim = get_symbol_end ();
3530   end_name = input_line_pointer;
3531
3532   if (name == end_name)
3533     {
3534       as_bad (_("expected symbol name"));
3535       ignore_rest_of_line ();
3536       return;
3537     }
3538
3539   if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3540       && (symbolP2 = md_undefined_symbol (name)) == NULL)
3541     {
3542       symbolP2 = symbol_find_or_make (name);
3543       S_SET_WEAKREFD (symbolP2);
3544     }
3545   else
3546     {
3547       symbolS *symp = symbolP2;
3548
3549       while (S_IS_WEAKREFR (symp) && symp != symbolP)
3550         {
3551           expressionS *expP = symbol_get_value_expression (symp);
3552
3553           gas_assert (expP->X_op == O_symbol
3554                   && expP->X_add_number == 0);
3555           symp = expP->X_add_symbol;
3556         }
3557       if (symp == symbolP)
3558         {
3559           char *loop;
3560
3561           loop = concat (S_GET_NAME (symbolP),
3562                          " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3563
3564           symp = symbolP2;
3565           while (symp != symbolP)
3566             {
3567               char *old_loop = loop;
3568               symp = symbol_get_value_expression (symp)->X_add_symbol;
3569               loop = concat (loop, " => ", S_GET_NAME (symp),
3570                              (const char *) NULL);
3571               free (old_loop);
3572             }
3573
3574           as_bad (_("%s: would close weakref loop: %s"),
3575                   S_GET_NAME (symbolP), loop);
3576
3577           free (loop);
3578
3579           *end_name = delim;
3580           ignore_rest_of_line ();
3581           return;
3582         }
3583
3584       /* Short-circuiting instead of just checking here might speed
3585          things up a tiny little bit, but loop error messages would
3586          miss intermediate links.  */
3587       /* symbolP2 = symp; */
3588     }
3589
3590   *end_name = delim;
3591
3592   memset (&exp, 0, sizeof (exp));
3593   exp.X_op = O_symbol;
3594   exp.X_add_symbol = symbolP2;
3595
3596   S_SET_SEGMENT (symbolP, undefined_section);
3597   symbol_set_value_expression (symbolP, &exp);
3598   symbol_set_frag (symbolP, &zero_address_frag);
3599   S_SET_WEAKREFR (symbolP);
3600
3601   demand_empty_rest_of_line ();
3602 }
3603 \f
3604
3605 /* Verify that we are at the end of a line.  If not, issue an error and
3606    skip to EOL.  */
3607
3608 void
3609 demand_empty_rest_of_line (void)
3610 {
3611   SKIP_WHITESPACE ();
3612   if (is_end_of_line[(unsigned char) *input_line_pointer])
3613     input_line_pointer++;
3614   else
3615     {
3616       if (ISPRINT (*input_line_pointer))
3617         as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3618                  *input_line_pointer);
3619       else
3620         as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3621                  *input_line_pointer);
3622       ignore_rest_of_line ();
3623     }
3624
3625   /* Return pointing just after end-of-line.  */
3626   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3627 }
3628
3629 /* Silently advance to the end of line.  Use this after already having
3630    issued an error about something bad.  */
3631
3632 void
3633 ignore_rest_of_line (void)
3634 {
3635   while (input_line_pointer < buffer_limit
3636          && !is_end_of_line[(unsigned char) *input_line_pointer])
3637     input_line_pointer++;
3638
3639   input_line_pointer++;
3640
3641   /* Return pointing just after end-of-line.  */
3642   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3643 }
3644
3645 /* Sets frag for given symbol to zero_address_frag, except when the
3646    symbol frag is already set to a dummy listing frag.  */
3647
3648 static void
3649 set_zero_frag (symbolS *symbolP)
3650 {
3651   if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3652     symbol_set_frag (symbolP, &zero_address_frag);
3653 }
3654
3655 /* In:  Pointer to a symbol.
3656         Input_line_pointer->expression.
3657
3658    Out: Input_line_pointer->just after any whitespace after expression.
3659         Tried to set symbol to value of expression.
3660         Will change symbols type, value, and frag;  */
3661
3662 void
3663 pseudo_set (symbolS *symbolP)
3664 {
3665   expressionS exp;
3666   segT seg;
3667
3668   know (symbolP);               /* NULL pointer is logic error.  */
3669
3670   if (!S_IS_FORWARD_REF (symbolP))
3671     (void) expression (&exp);
3672   else
3673     (void) deferred_expression (&exp);
3674
3675   if (exp.X_op == O_illegal)
3676     as_bad (_("illegal expression"));
3677   else if (exp.X_op == O_absent)
3678     as_bad (_("missing expression"));
3679   else if (exp.X_op == O_big)
3680     {
3681       if (exp.X_add_number > 0)
3682         as_bad (_("bignum invalid"));
3683       else
3684         as_bad (_("floating point number invalid"));
3685     }
3686   else if (exp.X_op == O_subtract
3687            && !S_IS_FORWARD_REF (symbolP)
3688            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3689            && (symbol_get_frag (exp.X_add_symbol)
3690                == symbol_get_frag (exp.X_op_symbol)))
3691     {
3692       exp.X_op = O_constant;
3693       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3694                           - S_GET_VALUE (exp.X_op_symbol));
3695     }
3696
3697   if (symbol_section_p (symbolP))
3698     {
3699       as_bad ("attempt to set value of section symbol");
3700       return;
3701     }
3702
3703   switch (exp.X_op)
3704     {
3705     case O_illegal:
3706     case O_absent:
3707     case O_big:
3708       exp.X_add_number = 0;
3709       /* Fall through.  */
3710     case O_constant:
3711       S_SET_SEGMENT (symbolP, absolute_section);
3712       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3713       set_zero_frag (symbolP);
3714       break;
3715
3716     case O_register:
3717 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3718       if (S_IS_EXTERNAL (symbolP))
3719         {
3720           as_bad ("can't equate global symbol `%s' with register name",
3721                   S_GET_NAME (symbolP));
3722           return;
3723         }
3724 #endif
3725       S_SET_SEGMENT (symbolP, reg_section);
3726       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3727       set_zero_frag (symbolP);
3728       symbol_get_value_expression (symbolP)->X_op = O_register;
3729       break;
3730
3731     case O_symbol:
3732       seg = S_GET_SEGMENT (exp.X_add_symbol);
3733       /* For x=undef+const, create an expression symbol.
3734          For x=x+const, just update x except when x is an undefined symbol
3735          For x=defined+const, evaluate x.  */
3736       if (symbolP == exp.X_add_symbol
3737           && (seg != undefined_section
3738               || !symbol_constant_p (symbolP)))
3739         {
3740           *symbol_X_add_number (symbolP) += exp.X_add_number;
3741           break;
3742         }
3743       else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3744         {
3745           symbolS *s = exp.X_add_symbol;
3746
3747           if (S_IS_COMMON (s))
3748             as_bad (_("`%s' can't be equated to common symbol '%s'"),
3749                     S_GET_NAME (symbolP), S_GET_NAME (s));
3750
3751           S_SET_SEGMENT (symbolP, seg);
3752           S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3753           symbol_set_frag (symbolP, symbol_get_frag (s));
3754           copy_symbol_attributes (symbolP, s);
3755           break;
3756         }
3757       S_SET_SEGMENT (symbolP, undefined_section);
3758       symbol_set_value_expression (symbolP, &exp);
3759       copy_symbol_attributes (symbolP, exp.X_add_symbol);
3760       set_zero_frag (symbolP);
3761       break;
3762
3763     default:
3764       /* The value is some complex expression.  */
3765       S_SET_SEGMENT (symbolP, expr_section);
3766       symbol_set_value_expression (symbolP, &exp);
3767       set_zero_frag (symbolP);
3768       break;
3769     }
3770 }
3771 \f
3772 /*                      cons()
3773
3774    CONStruct more frag of .bytes, or .words etc.
3775    Should need_pass_2 be 1 then emit no frag(s).
3776    This understands EXPRESSIONS.
3777
3778    Bug (?)
3779
3780    This has a split personality. We use expression() to read the
3781    value. We can detect if the value won't fit in a byte or word.
3782    But we can't detect if expression() discarded significant digits
3783    in the case of a long. Not worth the crocks required to fix it.  */
3784
3785 /* Select a parser for cons expressions.  */
3786
3787 /* Some targets need to parse the expression in various fancy ways.
3788    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3789    (for example, the HPPA does this).  Otherwise, you can define
3790    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3791    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3792    are defined, which is the normal case, then only simple expressions
3793    are permitted.  */
3794
3795 #ifdef TC_M68K
3796 static void
3797 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3798 #endif
3799
3800 #ifndef TC_PARSE_CONS_EXPRESSION
3801 #ifdef BITFIELD_CONS_EXPRESSIONS
3802 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3803 static void
3804 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3805 #endif
3806 #ifdef REPEAT_CONS_EXPRESSIONS
3807 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3808 static void
3809 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3810 #endif
3811
3812 /* If we haven't gotten one yet, just call expression.  */
3813 #ifndef TC_PARSE_CONS_EXPRESSION
3814 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3815 #endif
3816 #endif
3817
3818 void
3819 do_parse_cons_expression (expressionS *exp,
3820                           int nbytes ATTRIBUTE_UNUSED)
3821 {
3822   TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3823 }
3824
3825
3826 /* Worker to do .byte etc statements.
3827    Clobbers input_line_pointer and checks end-of-line.  */
3828
3829 static void
3830 cons_worker (int nbytes,        /* 1=.byte, 2=.word, 4=.long.  */
3831              int rva)
3832 {
3833   int c;
3834   expressionS exp;
3835   char *stop = NULL;
3836   char stopc = 0;
3837
3838 #ifdef md_flush_pending_output
3839   md_flush_pending_output ();
3840 #endif
3841
3842   if (flag_mri)
3843     stop = mri_comment_field (&stopc);
3844
3845   if (is_it_end_of_statement ())
3846     {
3847       demand_empty_rest_of_line ();
3848       if (flag_mri)
3849         mri_comment_end (stop, stopc);
3850       return;
3851     }
3852
3853 #ifdef TC_ADDRESS_BYTES
3854   if (nbytes == 0)
3855     nbytes = TC_ADDRESS_BYTES ();
3856 #endif
3857
3858 #ifdef md_cons_align
3859   md_cons_align (nbytes);
3860 #endif
3861
3862   c = 0;
3863   do
3864     {
3865 #ifdef TC_M68K
3866       if (flag_m68k_mri)
3867         parse_mri_cons (&exp, (unsigned int) nbytes);
3868       else
3869 #endif
3870         {
3871           if (*input_line_pointer == '"')
3872             {
3873               as_bad (_("unexpected `\"' in expression"));
3874               ignore_rest_of_line ();
3875               return;
3876             }
3877           TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3878         }
3879
3880       if (rva)
3881         {
3882           if (exp.X_op == O_symbol)
3883             exp.X_op = O_symbol_rva;
3884           else
3885             as_fatal (_("rva without symbol"));
3886         }
3887       emit_expr (&exp, (unsigned int) nbytes);
3888       ++c;
3889     }
3890   while (*input_line_pointer++ == ',');
3891
3892   /* In MRI mode, after an odd number of bytes, we must align to an
3893      even word boundary, unless the next instruction is a dc.b, ds.b
3894      or dcb.b.  */
3895   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3896     mri_pending_align = 1;
3897
3898   input_line_pointer--;         /* Put terminator back into stream.  */
3899
3900   demand_empty_rest_of_line ();
3901
3902   if (flag_mri)
3903     mri_comment_end (stop, stopc);
3904 }
3905
3906 void
3907 cons (int size)
3908 {
3909   cons_worker (size, 0);
3910 }
3911
3912 void
3913 s_rva (int size)
3914 {
3915   cons_worker (size, 1);
3916 }
3917
3918 /* .reloc offset, reloc_name, symbol+addend.  */
3919
3920 void
3921 s_reloc (int ignore ATTRIBUTE_UNUSED)
3922 {
3923   char *stop = NULL;
3924   char stopc = 0;
3925   expressionS exp;
3926   char *r_name;
3927   int c;
3928   struct reloc_list *reloc;
3929
3930   reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
3931
3932   if (flag_mri)
3933     stop = mri_comment_field (&stopc);
3934
3935   expression (&exp);
3936   switch (exp.X_op)
3937     {
3938     case O_illegal:
3939     case O_absent:
3940     case O_big:
3941     case O_register:
3942       as_bad (_("missing or bad offset expression"));
3943       goto err_out;
3944     case O_constant:
3945       exp.X_add_symbol = section_symbol (now_seg);
3946       exp.X_op = O_symbol;
3947       /* Fall thru */
3948     case O_symbol:
3949       if (exp.X_add_number == 0)
3950         {
3951           reloc->u.a.offset_sym = exp.X_add_symbol;
3952           break;
3953         }
3954       /* Fall thru */
3955     default:
3956       reloc->u.a.offset_sym = make_expr_symbol (&exp);
3957       break;
3958     }
3959
3960   SKIP_WHITESPACE ();
3961   if (*input_line_pointer != ',')
3962     {
3963       as_bad (_("missing reloc type"));
3964       goto err_out;
3965     }
3966
3967   ++input_line_pointer;
3968   SKIP_WHITESPACE ();
3969   r_name = input_line_pointer;
3970   c = get_symbol_end ();
3971   reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3972   *input_line_pointer = c;
3973   if (reloc->u.a.howto == NULL)
3974     {
3975       as_bad (_("unrecognized reloc type"));
3976       goto err_out;
3977     }
3978
3979   exp.X_op = O_absent;
3980   SKIP_WHITESPACE ();
3981   if (*input_line_pointer == ',')
3982     {
3983       ++input_line_pointer;
3984       expression (&exp);
3985     }
3986   switch (exp.X_op)
3987     {
3988     case O_illegal:
3989     case O_big:
3990     case O_register:
3991       as_bad (_("bad reloc expression"));
3992     err_out:
3993       ignore_rest_of_line ();
3994       free (reloc);
3995       if (flag_mri)
3996         mri_comment_end (stop, stopc);
3997       return;
3998     case O_absent:
3999       reloc->u.a.sym = NULL;
4000       reloc->u.a.addend = 0;
4001       break;
4002     case O_constant:
4003       reloc->u.a.sym = NULL;
4004       reloc->u.a.addend = exp.X_add_number;
4005       break;
4006     case O_symbol:
4007       reloc->u.a.sym = exp.X_add_symbol;
4008       reloc->u.a.addend = exp.X_add_number;
4009       break;
4010     default:
4011       reloc->u.a.sym = make_expr_symbol (&exp);
4012       reloc->u.a.addend = 0;
4013       break;
4014     }
4015
4016   as_where (&reloc->file, &reloc->line);
4017   reloc->next = reloc_list;
4018   reloc_list = reloc;
4019
4020   demand_empty_rest_of_line ();
4021   if (flag_mri)
4022     mri_comment_end (stop, stopc);
4023 }
4024
4025 /* Put the contents of expression EXP into the object file using
4026    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
4027
4028 void
4029 emit_expr (expressionS *exp, unsigned int nbytes)
4030 {
4031   operatorT op;
4032   char *p;
4033   valueT extra_digit = 0;
4034
4035   /* Don't do anything if we are going to make another pass.  */
4036   if (need_pass_2)
4037     return;
4038
4039   /* Grow the current frag now so that dot_value does not get invalidated
4040      if the frag were to fill up in the frag_more() call below.  */
4041   frag_grow (nbytes);
4042   dot_value = frag_now_fix ();
4043
4044 #ifndef NO_LISTING
4045 #ifdef OBJ_ELF
4046   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4047      appear as a four byte positive constant in the .line section,
4048      followed by a 2 byte 0xffff.  Look for that case here.  */
4049   {
4050     static int dwarf_line = -1;
4051
4052     if (strcmp (segment_name (now_seg), ".line") != 0)
4053       dwarf_line = -1;
4054     else if (dwarf_line >= 0
4055              && nbytes == 2
4056              && exp->X_op == O_constant
4057              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4058       listing_source_line ((unsigned int) dwarf_line);
4059     else if (nbytes == 4
4060              && exp->X_op == O_constant
4061              && exp->X_add_number >= 0)
4062       dwarf_line = exp->X_add_number;
4063     else
4064       dwarf_line = -1;
4065   }
4066
4067   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4068      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4069      AT_sibling (0x12) followed by a four byte address of the sibling
4070      followed by a 2 byte AT_name (0x38) followed by the name of the
4071      file.  We look for that case here.  */
4072   {
4073     static int dwarf_file = 0;
4074
4075     if (strcmp (segment_name (now_seg), ".debug") != 0)
4076       dwarf_file = 0;
4077     else if (dwarf_file == 0
4078              && nbytes == 2
4079              && exp->X_op == O_constant
4080              && exp->X_add_number == 0x11)
4081       dwarf_file = 1;
4082     else if (dwarf_file == 1
4083              && nbytes == 2
4084              && exp->X_op == O_constant
4085              && exp->X_add_number == 0x12)
4086       dwarf_file = 2;
4087     else if (dwarf_file == 2
4088              && nbytes == 4)
4089       dwarf_file = 3;
4090     else if (dwarf_file == 3
4091              && nbytes == 2
4092              && exp->X_op == O_constant
4093              && exp->X_add_number == 0x38)
4094       dwarf_file = 4;
4095     else
4096       dwarf_file = 0;
4097
4098     /* The variable dwarf_file_string tells stringer that the string
4099        may be the name of the source file.  */
4100     if (dwarf_file == 4)
4101       dwarf_file_string = 1;
4102     else
4103       dwarf_file_string = 0;
4104   }
4105 #endif
4106 #endif
4107
4108   if (check_eh_frame (exp, &nbytes))
4109     return;
4110
4111   op = exp->X_op;
4112
4113   /* Allow `.word 0' in the absolute section.  */
4114   if (now_seg == absolute_section)
4115     {
4116       if (op != O_constant || exp->X_add_number != 0)
4117         as_bad (_("attempt to store value in absolute section"));
4118       abs_section_offset += nbytes;
4119       return;
4120     }
4121
4122   /* Handle a negative bignum.  */
4123   if (op == O_uminus
4124       && exp->X_add_number == 0
4125       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4126       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4127     {
4128       int i;
4129       unsigned long carry;
4130
4131       exp = symbol_get_value_expression (exp->X_add_symbol);
4132
4133       /* Negate the bignum: one's complement each digit and add 1.  */
4134       carry = 1;
4135       for (i = 0; i < exp->X_add_number; i++)
4136         {
4137           unsigned long next;
4138
4139           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4140                    & LITTLENUM_MASK)
4141                   + carry);
4142           generic_bignum[i] = next & LITTLENUM_MASK;
4143           carry = next >> LITTLENUM_NUMBER_OF_BITS;
4144         }
4145
4146       /* We can ignore any carry out, because it will be handled by
4147          extra_digit if it is needed.  */
4148
4149       extra_digit = (valueT) -1;
4150       op = O_big;
4151     }
4152
4153   if (op == O_absent || op == O_illegal)
4154     {
4155       as_warn (_("zero assumed for missing expression"));
4156       exp->X_add_number = 0;
4157       op = O_constant;
4158     }
4159   else if (op == O_big && exp->X_add_number <= 0)
4160     {
4161       as_bad (_("floating point number invalid"));
4162       exp->X_add_number = 0;
4163       op = O_constant;
4164     }
4165   else if (op == O_register)
4166     {
4167       as_warn (_("register value used as expression"));
4168       op = O_constant;
4169     }
4170
4171   p = frag_more ((int) nbytes);
4172
4173 #ifndef WORKING_DOT_WORD
4174   /* If we have the difference of two symbols in a word, save it on
4175      the broken_words list.  See the code in write.c.  */
4176   if (op == O_subtract && nbytes == 2)
4177     {
4178       struct broken_word *x;
4179
4180       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4181       x->next_broken_word = broken_words;
4182       broken_words = x;
4183       x->seg = now_seg;
4184       x->subseg = now_subseg;
4185       x->frag = frag_now;
4186       x->word_goes_here = p;
4187       x->dispfrag = 0;
4188       x->add = exp->X_add_symbol;
4189       x->sub = exp->X_op_symbol;
4190       x->addnum = exp->X_add_number;
4191       x->added = 0;
4192       x->use_jump = 0;
4193       new_broken_words++;
4194       return;
4195     }
4196 #endif
4197
4198   /* If we have an integer, but the number of bytes is too large to
4199      pass to md_number_to_chars, handle it as a bignum.  */
4200   if (op == O_constant && nbytes > sizeof (valueT))
4201     {
4202       extra_digit = exp->X_unsigned ? 0 : -1;
4203       convert_to_bignum (exp);
4204       op = O_big;
4205     }
4206
4207   if (op == O_constant)
4208     {
4209       valueT get;
4210       valueT use;
4211       valueT mask;
4212       valueT hibit;
4213       valueT unmask;
4214
4215       /* JF << of >= number of bits in the object is undefined.  In
4216          particular SPARC (Sun 4) has problems.  */
4217       if (nbytes >= sizeof (valueT))
4218         {
4219           mask = 0;
4220           if (nbytes > sizeof (valueT))
4221             hibit = 0;
4222           else
4223             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4224         }
4225       else
4226         {
4227           /* Don't store these bits.  */
4228           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4229           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4230         }
4231
4232       unmask = ~mask;           /* Do store these bits.  */
4233
4234 #ifdef NEVER
4235       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4236       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
4237 #endif
4238
4239       get = exp->X_add_number;
4240       use = get & unmask;
4241       if ((get & mask) != 0
4242           && ((get & mask) != mask
4243               || (get & hibit) == 0))
4244         {               /* Leading bits contain both 0s & 1s.  */
4245 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4246 #ifndef __MSVCRT__
4247           as_warn (_("value 0x%llx truncated to 0x%llx"),
4248                    (unsigned long long) get, (unsigned long long) use);
4249 #else
4250           as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4251                    (unsigned long long) get, (unsigned long long) use);
4252 #endif
4253 #else
4254           as_warn (_("value 0x%lx truncated to 0x%lx"),
4255                    (unsigned long) get, (unsigned long) use);
4256 #endif
4257         }
4258       /* Put bytes in right order.  */
4259       md_number_to_chars (p, use, (int) nbytes);
4260     }
4261   else if (op == O_big)
4262     {
4263       unsigned int size;
4264       LITTLENUM_TYPE *nums;
4265
4266       size = exp->X_add_number * CHARS_PER_LITTLENUM;
4267       if (nbytes < size)
4268         {
4269           int i = nbytes / CHARS_PER_LITTLENUM;
4270           if (i != 0)
4271             {
4272               LITTLENUM_TYPE sign = 0;
4273               if ((generic_bignum[--i]
4274                    & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
4275                 sign = ~(LITTLENUM_TYPE) 0;
4276               while (++i < exp->X_add_number)
4277                 if (generic_bignum[i] != sign)
4278                   break;
4279             }
4280           if (i < exp->X_add_number)
4281             as_warn (_("bignum truncated to %d bytes"), nbytes);
4282           size = nbytes;
4283         }
4284
4285       if (nbytes == 1)
4286         {
4287           md_number_to_chars (p, (valueT) generic_bignum[0], 1);
4288           return;
4289         }
4290       know (nbytes % CHARS_PER_LITTLENUM == 0);
4291
4292       if (target_big_endian)
4293         {
4294           while (nbytes > size)
4295             {
4296               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4297               nbytes -= CHARS_PER_LITTLENUM;
4298               p += CHARS_PER_LITTLENUM;
4299             }
4300
4301           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4302           while (size >= CHARS_PER_LITTLENUM)
4303             {
4304               --nums;
4305               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4306               size -= CHARS_PER_LITTLENUM;
4307               p += CHARS_PER_LITTLENUM;
4308             }
4309         }
4310       else
4311         {
4312           nums = generic_bignum;
4313           while (size >= CHARS_PER_LITTLENUM)
4314             {
4315               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4316               ++nums;
4317               size -= CHARS_PER_LITTLENUM;
4318               p += CHARS_PER_LITTLENUM;
4319               nbytes -= CHARS_PER_LITTLENUM;
4320             }
4321
4322           while (nbytes >= CHARS_PER_LITTLENUM)
4323             {
4324               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4325               nbytes -= CHARS_PER_LITTLENUM;
4326               p += CHARS_PER_LITTLENUM;
4327             }
4328         }
4329     }
4330   else
4331     emit_expr_fix (exp, nbytes, frag_now, p);
4332 }
4333
4334 void
4335 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4336 {
4337   memset (p, 0, nbytes);
4338
4339   /* Generate a fixS to record the symbol value.  */
4340
4341 #ifdef TC_CONS_FIX_NEW
4342   TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4343 #else
4344   {
4345     bfd_reloc_code_real_type r;
4346
4347     switch (nbytes)
4348       {
4349       case 1:
4350         r = BFD_RELOC_8;
4351         break;
4352       case 2:
4353         r = BFD_RELOC_16;
4354         break;
4355       case 3:
4356         r = BFD_RELOC_24;
4357         break;
4358       case 4:
4359         r = BFD_RELOC_32;
4360         break;
4361       case 8:
4362         r = BFD_RELOC_64;
4363         break;
4364       default:
4365         as_bad (_("unsupported BFD relocation size %u"), nbytes);
4366         r = BFD_RELOC_32;
4367         break;
4368       }
4369     fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4370                  0, r);
4371   }
4372 #endif
4373 }
4374 \f
4375 #ifdef BITFIELD_CONS_EXPRESSIONS
4376
4377 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4378    w:x,y:z, where w and y are bitwidths and x and y are values.  They
4379    then pack them all together. We do a little better in that we allow
4380    them in words, longs, etc. and we'll pack them in target byte order
4381    for you.
4382
4383    The rules are: pack least significant bit first, if a field doesn't
4384    entirely fit, put it in the next unit.  Overflowing the bitfield is
4385    explicitly *not* even a warning.  The bitwidth should be considered
4386    a "mask".
4387
4388    To use this function the tc-XXX.h file should define
4389    BITFIELD_CONS_EXPRESSIONS.  */
4390
4391 static void
4392 parse_bitfield_cons (exp, nbytes)
4393      expressionS *exp;
4394      unsigned int nbytes;
4395 {
4396   unsigned int bits_available = BITS_PER_CHAR * nbytes;
4397   char *hold = input_line_pointer;
4398
4399   (void) expression (exp);
4400
4401   if (*input_line_pointer == ':')
4402     {
4403       /* Bitfields.  */
4404       long value = 0;
4405
4406       for (;;)
4407         {
4408           unsigned long width;
4409
4410           if (*input_line_pointer != ':')
4411             {
4412               input_line_pointer = hold;
4413               break;
4414             }                   /* Next piece is not a bitfield.  */
4415
4416           /* In the general case, we can't allow
4417              full expressions with symbol
4418              differences and such.  The relocation
4419              entries for symbols not defined in this
4420              assembly would require arbitrary field
4421              widths, positions, and masks which most
4422              of our current object formats don't
4423              support.
4424
4425              In the specific case where a symbol
4426              *is* defined in this assembly, we
4427              *could* build fixups and track it, but
4428              this could lead to confusion for the
4429              backends.  I'm lazy. I'll take any
4430              SEG_ABSOLUTE. I think that means that
4431              you can use a previous .set or
4432              .equ type symbol.  xoxorich.  */
4433
4434           if (exp->X_op == O_absent)
4435             {
4436               as_warn (_("using a bit field width of zero"));
4437               exp->X_add_number = 0;
4438               exp->X_op = O_constant;
4439             }                   /* Implied zero width bitfield.  */
4440
4441           if (exp->X_op != O_constant)
4442             {
4443               *input_line_pointer = '\0';
4444               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4445               *input_line_pointer = ':';
4446               demand_empty_rest_of_line ();
4447               return;
4448             }                   /* Too complex.  */
4449
4450           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4451             {
4452               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4453                        width, nbytes, (BITS_PER_CHAR * nbytes));
4454               width = BITS_PER_CHAR * nbytes;
4455             }                   /* Too big.  */
4456
4457           if (width > bits_available)
4458             {
4459               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
4460               input_line_pointer = hold;
4461               exp->X_add_number = value;
4462               break;
4463             }                   /* Won't fit.  */
4464
4465           /* Skip ':'.  */
4466           hold = ++input_line_pointer;
4467
4468           (void) expression (exp);
4469           if (exp->X_op != O_constant)
4470             {
4471               char cache = *input_line_pointer;
4472
4473               *input_line_pointer = '\0';
4474               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4475               *input_line_pointer = cache;
4476               demand_empty_rest_of_line ();
4477               return;
4478             }                   /* Too complex.  */
4479
4480           value |= ((~(-1 << width) & exp->X_add_number)
4481                     << ((BITS_PER_CHAR * nbytes) - bits_available));
4482
4483           if ((bits_available -= width) == 0
4484               || is_it_end_of_statement ()
4485               || *input_line_pointer != ',')
4486             {
4487               break;
4488             }                   /* All the bitfields we're gonna get.  */
4489
4490           hold = ++input_line_pointer;
4491           (void) expression (exp);
4492         }
4493
4494       exp->X_add_number = value;
4495       exp->X_op = O_constant;
4496       exp->X_unsigned = 1;
4497     }
4498 }
4499
4500 #endif /* BITFIELD_CONS_EXPRESSIONS */
4501 \f
4502 /* Handle an MRI style string expression.  */
4503
4504 #ifdef TC_M68K
4505 static void
4506 parse_mri_cons (exp, nbytes)
4507      expressionS *exp;
4508      unsigned int nbytes;
4509 {
4510   if (*input_line_pointer != '\''
4511       && (input_line_pointer[1] != '\''
4512           || (*input_line_pointer != 'A'
4513               && *input_line_pointer != 'E')))
4514     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4515   else
4516     {
4517       unsigned int scan;
4518       unsigned int result = 0;
4519
4520       /* An MRI style string.  Cut into as many bytes as will fit into
4521          a nbyte chunk, left justify if necessary, and separate with
4522          commas so we can try again later.  */
4523       if (*input_line_pointer == 'A')
4524         ++input_line_pointer;
4525       else if (*input_line_pointer == 'E')
4526         {
4527           as_bad (_("EBCDIC constants are not supported"));
4528           ++input_line_pointer;
4529         }
4530
4531       input_line_pointer++;
4532       for (scan = 0; scan < nbytes; scan++)
4533         {
4534           if (*input_line_pointer == '\'')
4535             {
4536               if (input_line_pointer[1] == '\'')
4537                 {
4538                   input_line_pointer++;
4539                 }
4540               else
4541                 break;
4542             }
4543           result = (result << 8) | (*input_line_pointer++);
4544         }
4545
4546       /* Left justify.  */
4547       while (scan < nbytes)
4548         {
4549           result <<= 8;
4550           scan++;
4551         }
4552
4553       /* Create correct expression.  */
4554       exp->X_op = O_constant;
4555       exp->X_add_number = result;
4556
4557       /* Fake it so that we can read the next char too.  */
4558       if (input_line_pointer[0] != '\'' ||
4559           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4560         {
4561           input_line_pointer -= 2;
4562           input_line_pointer[0] = ',';
4563           input_line_pointer[1] = '\'';
4564         }
4565       else
4566         input_line_pointer++;
4567     }
4568 }
4569 #endif /* TC_M68K */
4570 \f
4571 #ifdef REPEAT_CONS_EXPRESSIONS
4572
4573 /* Parse a repeat expression for cons.  This is used by the MIPS
4574    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
4575    object file COUNT times.
4576
4577    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
4578
4579 static void
4580 parse_repeat_cons (exp, nbytes)
4581      expressionS *exp;
4582      unsigned int nbytes;
4583 {
4584   expressionS count;
4585   int i;
4586
4587   expression (exp);
4588
4589   if (*input_line_pointer != ':')
4590     {
4591       /* No repeat count.  */
4592       return;
4593     }
4594
4595   ++input_line_pointer;
4596   expression (&count);
4597   if (count.X_op != O_constant
4598       || count.X_add_number <= 0)
4599     {
4600       as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4601       return;
4602     }
4603
4604   /* The cons function is going to output this expression once.  So we
4605      output it count - 1 times.  */
4606   for (i = count.X_add_number - 1; i > 0; i--)
4607     emit_expr (exp, nbytes);
4608 }
4609
4610 #endif /* REPEAT_CONS_EXPRESSIONS */
4611 \f
4612 /* Parse a floating point number represented as a hex constant.  This
4613    permits users to specify the exact bits they want in the floating
4614    point number.  */
4615
4616 static int
4617 hex_float (int float_type, char *bytes)
4618 {
4619   int length;
4620   int i;
4621
4622   switch (float_type)
4623     {
4624     case 'f':
4625     case 'F':
4626     case 's':
4627     case 'S':
4628       length = 4;
4629       break;
4630
4631     case 'd':
4632     case 'D':
4633     case 'r':
4634     case 'R':
4635       length = 8;
4636       break;
4637
4638     case 'x':
4639     case 'X':
4640       length = 12;
4641       break;
4642
4643     case 'p':
4644     case 'P':
4645       length = 12;
4646       break;
4647
4648     default:
4649       as_bad (_("unknown floating type type '%c'"), float_type);
4650       return -1;
4651     }
4652
4653   /* It would be nice if we could go through expression to parse the
4654      hex constant, but if we get a bignum it's a pain to sort it into
4655      the buffer correctly.  */
4656   i = 0;
4657   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4658     {
4659       int d;
4660
4661       /* The MRI assembler accepts arbitrary underscores strewn about
4662          through the hex constant, so we ignore them as well.  */
4663       if (*input_line_pointer == '_')
4664         {
4665           ++input_line_pointer;
4666           continue;
4667         }
4668
4669       if (i >= length)
4670         {
4671           as_warn (_("floating point constant too large"));
4672           return -1;
4673         }
4674       d = hex_value (*input_line_pointer) << 4;
4675       ++input_line_pointer;
4676       while (*input_line_pointer == '_')
4677         ++input_line_pointer;
4678       if (hex_p (*input_line_pointer))
4679         {
4680           d += hex_value (*input_line_pointer);
4681           ++input_line_pointer;
4682         }
4683       if (target_big_endian)
4684         bytes[i] = d;
4685       else
4686         bytes[length - i - 1] = d;
4687       ++i;
4688     }
4689
4690   if (i < length)
4691     {
4692       if (target_big_endian)
4693         memset (bytes + i, 0, length - i);
4694       else
4695         memset (bytes, 0, length - i);
4696     }
4697
4698   return length;
4699 }
4700
4701 /*                      float_cons()
4702
4703    CONStruct some more frag chars of .floats .ffloats etc.
4704    Makes 0 or more new frags.
4705    If need_pass_2 == 1, no frags are emitted.
4706    This understands only floating literals, not expressions. Sorry.
4707
4708    A floating constant is defined by atof_generic(), except it is preceded
4709    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4710    reading, I decided to be incompatible. This always tries to give you
4711    rounded bits to the precision of the pseudo-op. Former AS did premature
4712    truncation, restored noisy bits instead of trailing 0s AND gave you
4713    a choice of 2 flavours of noise according to which of 2 floating-point
4714    scanners you directed AS to use.
4715
4716    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
4717
4718 void
4719 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
4720             int float_type      /* 'f':.ffloat ... 'F':.float ...  */)
4721 {
4722   char *p;
4723   int length;                   /* Number of chars in an object.  */
4724   char *err;            /* Error from scanning floating literal.  */
4725   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4726
4727   if (is_it_end_of_statement ())
4728     {
4729       demand_empty_rest_of_line ();
4730       return;
4731     }
4732
4733 #ifdef md_flush_pending_output
4734   md_flush_pending_output ();
4735 #endif
4736
4737 #ifdef md_cons_align
4738   md_cons_align (1);
4739 #endif
4740
4741   do
4742     {
4743       /* input_line_pointer->1st char of a flonum (we hope!).  */
4744       SKIP_WHITESPACE ();
4745
4746       /* Skip any 0{letter} that may be present. Don't even check if the
4747          letter is legal. Someone may invent a "z" format and this routine
4748          has no use for such information. Lusers beware: you get
4749          diagnostics if your input is ill-conditioned.  */
4750       if (input_line_pointer[0] == '0'
4751           && ISALPHA (input_line_pointer[1]))
4752         input_line_pointer += 2;
4753
4754       /* Accept :xxxx, where the x's are hex digits, for a floating
4755          point with the exact digits specified.  */
4756       if (input_line_pointer[0] == ':')
4757         {
4758           ++input_line_pointer;
4759           length = hex_float (float_type, temp);
4760           if (length < 0)
4761             {
4762               ignore_rest_of_line ();
4763               return;
4764             }
4765         }
4766       else
4767         {
4768           err = md_atof (float_type, temp, &length);
4769           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4770           know (err != NULL || length > 0);
4771           if (err)
4772             {
4773               as_bad (_("bad floating literal: %s"), err);
4774               ignore_rest_of_line ();
4775               return;
4776             }
4777         }
4778
4779       if (!need_pass_2)
4780         {
4781           int count;
4782
4783           count = 1;
4784
4785 #ifdef REPEAT_CONS_EXPRESSIONS
4786           if (*input_line_pointer == ':')
4787             {
4788               expressionS count_exp;
4789
4790               ++input_line_pointer;
4791               expression (&count_exp);
4792
4793               if (count_exp.X_op != O_constant
4794                   || count_exp.X_add_number <= 0)
4795                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4796               else
4797                 count = count_exp.X_add_number;
4798             }
4799 #endif
4800
4801           while (--count >= 0)
4802             {
4803               p = frag_more (length);
4804               memcpy (p, temp, (unsigned int) length);
4805             }
4806         }
4807       SKIP_WHITESPACE ();
4808     }
4809   while (*input_line_pointer++ == ',');
4810
4811   /* Put terminator back into stream.  */
4812   --input_line_pointer;
4813   demand_empty_rest_of_line ();
4814 }
4815 \f
4816 /* Return the size of a LEB128 value.  */
4817
4818 static inline int
4819 sizeof_sleb128 (offsetT value)
4820 {
4821   int size = 0;
4822   unsigned byte;
4823
4824   do
4825     {
4826       byte = (value & 0x7f);
4827       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4828          Fortunately, we can structure things so that the extra work reduces
4829          to a noop on systems that do things "properly".  */
4830       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4831       size += 1;
4832     }
4833   while (!(((value == 0) && ((byte & 0x40) == 0))
4834            || ((value == -1) && ((byte & 0x40) != 0))));
4835
4836   return size;
4837 }
4838
4839 static inline int
4840 sizeof_uleb128 (valueT value)
4841 {
4842   int size = 0;
4843
4844   do
4845     {
4846       value >>= 7;
4847       size += 1;
4848     }
4849   while (value != 0);
4850
4851   return size;
4852 }
4853
4854 int
4855 sizeof_leb128 (valueT value, int sign)
4856 {
4857   if (sign)
4858     return sizeof_sleb128 ((offsetT) value);
4859   else
4860     return sizeof_uleb128 (value);
4861 }
4862
4863 /* Output a LEB128 value.  */
4864
4865 static inline int
4866 output_sleb128 (char *p, offsetT value)
4867 {
4868   char *orig = p;
4869   int more;
4870
4871   do
4872     {
4873       unsigned byte = (value & 0x7f);
4874
4875       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4876          Fortunately, we can structure things so that the extra work reduces
4877          to a noop on systems that do things "properly".  */
4878       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4879
4880       more = !((((value == 0) && ((byte & 0x40) == 0))
4881                 || ((value == -1) && ((byte & 0x40) != 0))));
4882       if (more)
4883         byte |= 0x80;
4884
4885       *p++ = byte;
4886     }
4887   while (more);
4888
4889   return p - orig;
4890 }
4891
4892 static inline int
4893 output_uleb128 (char *p, valueT value)
4894 {
4895   char *orig = p;
4896
4897   do
4898     {
4899       unsigned byte = (value & 0x7f);
4900       value >>= 7;
4901       if (value != 0)
4902         /* More bytes to follow.  */
4903         byte |= 0x80;
4904
4905       *p++ = byte;
4906     }
4907   while (value != 0);
4908
4909   return p - orig;
4910 }
4911
4912 int
4913 output_leb128 (char *p, valueT value, int sign)
4914 {
4915   if (sign)
4916     return output_sleb128 (p, (offsetT) value);
4917   else
4918     return output_uleb128 (p, value);
4919 }
4920
4921 /* Do the same for bignums.  We combine sizeof with output here in that
4922    we don't output for NULL values of P.  It isn't really as critical as
4923    for "normal" values that this be streamlined.  */
4924
4925 static inline int
4926 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4927 {
4928   char *orig = p;
4929   valueT val = 0;
4930   int loaded = 0;
4931   unsigned byte;
4932
4933   /* Strip leading sign extensions off the bignum.  */
4934   while (size > 1
4935          && bignum[size - 1] == LITTLENUM_MASK
4936          && bignum[size - 2] > LITTLENUM_MASK / 2)
4937     size--;
4938
4939   do
4940     {
4941       /* OR in the next part of the littlenum.  */
4942       val |= (*bignum << loaded);
4943       loaded += LITTLENUM_NUMBER_OF_BITS;
4944       size--;
4945       bignum++;
4946
4947       /* Add bytes until there are less than 7 bits left in VAL
4948          or until every non-sign bit has been written.  */
4949       do
4950         {
4951           byte = val & 0x7f;
4952           loaded -= 7;
4953           val >>= 7;
4954           if (size > 0
4955               || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4956             byte |= 0x80;
4957
4958           if (orig)
4959             *p = byte;
4960           p++;
4961         }
4962       while ((byte & 0x80) != 0 && loaded >= 7);
4963     }
4964   while (size > 0);
4965
4966   /* Mop up any left-over bits (of which there will be less than 7).  */
4967   if ((byte & 0x80) != 0)
4968     {
4969       /* Sign-extend VAL.  */
4970       if (val & (1 << (loaded - 1)))
4971         val |= ~0 << loaded;
4972       if (orig)
4973         *p = val & 0x7f;
4974       p++;
4975     }
4976
4977   return p - orig;
4978 }
4979
4980 static inline int
4981 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4982 {
4983   char *orig = p;
4984   valueT val = 0;
4985   int loaded = 0;
4986   unsigned byte;
4987
4988   /* Strip leading zeros off the bignum.  */
4989   /* XXX: Is this needed?  */
4990   while (size > 0 && bignum[size - 1] == 0)
4991     size--;
4992
4993   do
4994     {
4995       if (loaded < 7 && size > 0)
4996         {
4997           val |= (*bignum << loaded);
4998           loaded += 8 * CHARS_PER_LITTLENUM;
4999           size--;
5000           bignum++;
5001         }
5002
5003       byte = val & 0x7f;
5004       loaded -= 7;
5005       val >>= 7;
5006
5007       if (size > 0 || val)
5008         byte |= 0x80;
5009
5010       if (orig)
5011         *p = byte;
5012       p++;
5013     }
5014   while (byte & 0x80);
5015
5016   return p - orig;
5017 }
5018
5019 static int
5020 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
5021 {
5022   if (sign)
5023     return output_big_sleb128 (p, bignum, size);
5024   else
5025     return output_big_uleb128 (p, bignum, size);
5026 }
5027
5028 /* Generate the appropriate fragments for a given expression to emit a
5029    leb128 value.  */
5030
5031 static void
5032 emit_leb128_expr (expressionS *exp, int sign)
5033 {
5034   operatorT op = exp->X_op;
5035   unsigned int nbytes;
5036
5037   if (op == O_absent || op == O_illegal)
5038     {
5039       as_warn (_("zero assumed for missing expression"));
5040       exp->X_add_number = 0;
5041       op = O_constant;
5042     }
5043   else if (op == O_big && exp->X_add_number <= 0)
5044     {
5045       as_bad (_("floating point number invalid"));
5046       exp->X_add_number = 0;
5047       op = O_constant;
5048     }
5049   else if (op == O_register)
5050     {
5051       as_warn (_("register value used as expression"));
5052       op = O_constant;
5053     }
5054   else if (op == O_constant
5055            && sign
5056            && (exp->X_add_number < 0) != !exp->X_unsigned)
5057     {
5058       /* We're outputting a signed leb128 and the sign of X_add_number
5059          doesn't reflect the sign of the original value.  Convert EXP
5060          to a correctly-extended bignum instead.  */
5061       convert_to_bignum (exp);
5062       op = O_big;
5063     }
5064
5065   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
5066      a signal that this is leb128 data.  It shouldn't optimize this away.  */
5067   nbytes = (unsigned int) -1;
5068   if (check_eh_frame (exp, &nbytes))
5069     abort ();
5070
5071   /* Let the backend know that subsequent data may be byte aligned.  */
5072 #ifdef md_cons_align
5073   md_cons_align (1);
5074 #endif
5075
5076   if (op == O_constant)
5077     {
5078       /* If we've got a constant, emit the thing directly right now.  */
5079
5080       valueT value = exp->X_add_number;
5081       int size;
5082       char *p;
5083
5084       size = sizeof_leb128 (value, sign);
5085       p = frag_more (size);
5086       output_leb128 (p, value, sign);
5087     }
5088   else if (op == O_big)
5089     {
5090       /* O_big is a different sort of constant.  */
5091
5092       int size;
5093       char *p;
5094
5095       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5096       p = frag_more (size);
5097       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5098     }
5099   else
5100     {
5101       /* Otherwise, we have to create a variable sized fragment and
5102          resolve things later.  */
5103
5104       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5105                 make_expr_symbol (exp), 0, (char *) NULL);
5106     }
5107 }
5108
5109 /* Parse the .sleb128 and .uleb128 pseudos.  */
5110
5111 void
5112 s_leb128 (int sign)
5113 {
5114   expressionS exp;
5115
5116 #ifdef md_flush_pending_output
5117   md_flush_pending_output ();
5118 #endif
5119
5120   do
5121     {
5122       expression (&exp);
5123       emit_leb128_expr (&exp, sign);
5124     }
5125   while (*input_line_pointer++ == ',');
5126
5127   input_line_pointer--;
5128   demand_empty_rest_of_line ();
5129 }
5130 \f
5131 static void
5132 stringer_append_char (int c, int bitsize)
5133 {
5134   if (!target_big_endian)
5135     FRAG_APPEND_1_CHAR (c);
5136
5137   switch (bitsize)
5138     {
5139     case 64:
5140       FRAG_APPEND_1_CHAR (0);
5141       FRAG_APPEND_1_CHAR (0);
5142       FRAG_APPEND_1_CHAR (0);
5143       FRAG_APPEND_1_CHAR (0);
5144       /* Fall through.  */
5145     case 32:
5146       FRAG_APPEND_1_CHAR (0);
5147       FRAG_APPEND_1_CHAR (0);
5148       /* Fall through.  */
5149     case 16:
5150       FRAG_APPEND_1_CHAR (0);
5151       /* Fall through.  */
5152     case 8:
5153       break;
5154     default:
5155       /* Called with invalid bitsize argument.  */
5156       abort ();
5157       break;
5158     }
5159   if (target_big_endian)
5160     FRAG_APPEND_1_CHAR (c);
5161 }
5162
5163 /* Worker to do .ascii etc statements.
5164    Reads 0 or more ',' separated, double-quoted strings.
5165    Caller should have checked need_pass_2 is FALSE because we don't
5166    check it.
5167    Checks for end-of-line.
5168    BITS_APPENDZERO says how many bits are in a target char.
5169    The bottom bit is set if a NUL char should be appended to the strings.  */
5170
5171 void
5172 stringer (int bits_appendzero)
5173 {
5174   const int bitsize = bits_appendzero & ~7;
5175   const int append_zero = bits_appendzero & 1;
5176   unsigned int c;
5177 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5178   char *start;
5179 #endif
5180
5181 #ifdef md_flush_pending_output
5182   md_flush_pending_output ();
5183 #endif
5184
5185 #ifdef md_cons_align
5186   md_cons_align (1);
5187 #endif
5188
5189   /* The following awkward logic is to parse ZERO or more strings,
5190      comma separated. Recall a string expression includes spaces
5191      before the opening '\"' and spaces after the closing '\"'.
5192      We fake a leading ',' if there is (supposed to be)
5193      a 1st, expression. We keep demanding expressions for each ','.  */
5194   if (is_it_end_of_statement ())
5195     {
5196       c = 0;                    /* Skip loop.  */
5197       ++input_line_pointer;     /* Compensate for end of loop.  */
5198     }
5199   else
5200     {
5201       c = ',';                  /* Do loop.  */
5202     }
5203   /* If we have been switched into the abs_section then we
5204      will not have an obstack onto which we can hang strings.  */
5205   if (now_seg == absolute_section)
5206     {
5207       as_bad (_("strings must be placed into a section"));
5208       c = 0;
5209       ignore_rest_of_line ();
5210     }
5211
5212   while (c == ',' || c == '<' || c == '"')
5213     {
5214       SKIP_WHITESPACE ();
5215       switch (*input_line_pointer)
5216         {
5217         case '\"':
5218           ++input_line_pointer; /*->1st char of string.  */
5219 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5220           start = input_line_pointer;
5221 #endif
5222
5223           while (is_a_char (c = next_char_of_string ()))
5224             stringer_append_char (c, bitsize);
5225
5226           if (append_zero)
5227             stringer_append_char (0, bitsize);
5228
5229           know (input_line_pointer[-1] == '\"');
5230
5231 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5232           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5233              will emit .string with a filename in the .debug section
5234              after a sequence of constants.  See the comment in
5235              emit_expr for the sequence.  emit_expr will set
5236              dwarf_file_string to non-zero if this string might be a
5237              source file name.  */
5238           if (strcmp (segment_name (now_seg), ".debug") != 0)
5239             dwarf_file_string = 0;
5240           else if (dwarf_file_string)
5241             {
5242               c = input_line_pointer[-1];
5243               input_line_pointer[-1] = '\0';
5244               listing_source_file (start);
5245               input_line_pointer[-1] = c;
5246             }
5247 #endif
5248
5249           break;
5250         case '<':
5251           input_line_pointer++;
5252           c = get_single_number ();
5253           stringer_append_char (c, bitsize);
5254           if (*input_line_pointer != '>')
5255             as_bad (_("expected <nn>"));
5256
5257           input_line_pointer++;
5258           break;
5259         case ',':
5260           input_line_pointer++;
5261           break;
5262         }
5263       SKIP_WHITESPACE ();
5264       c = *input_line_pointer;
5265     }
5266
5267   demand_empty_rest_of_line ();
5268 }
5269 \f
5270 /* FIXME-SOMEDAY: I had trouble here on characters with the
5271     high bits set.  We'll probably also have trouble with
5272     multibyte chars, wide chars, etc.  Also be careful about
5273     returning values bigger than 1 byte.  xoxorich.  */
5274
5275 unsigned int
5276 next_char_of_string (void)
5277 {
5278   unsigned int c;
5279
5280   c = *input_line_pointer++ & CHAR_MASK;
5281   switch (c)
5282     {
5283     case '\"':
5284       c = NOT_A_CHAR;
5285       break;
5286
5287     case '\n':
5288       as_warn (_("unterminated string; newline inserted"));
5289       bump_line_counters ();
5290       break;
5291
5292 #ifndef NO_STRING_ESCAPES
5293     case '\\':
5294       switch (c = *input_line_pointer++)
5295         {
5296         case 'b':
5297           c = '\b';
5298           break;
5299
5300         case 'f':
5301           c = '\f';
5302           break;
5303
5304         case 'n':
5305           c = '\n';
5306           break;
5307
5308         case 'r':
5309           c = '\r';
5310           break;
5311
5312         case 't':
5313           c = '\t';
5314           break;
5315
5316         case 'v':
5317           c = '\013';
5318           break;
5319
5320         case '\\':
5321         case '"':
5322           break;                /* As itself.  */
5323
5324         case '0':
5325         case '1':
5326         case '2':
5327         case '3':
5328         case '4':
5329         case '5':
5330         case '6':
5331         case '7':
5332         case '8':
5333         case '9':
5334           {
5335             long number;
5336             int i;
5337
5338             for (i = 0, number = 0;
5339                  ISDIGIT (c) && i < 3;
5340                  c = *input_line_pointer++, i++)
5341               {
5342                 number = number * 8 + c - '0';
5343               }
5344
5345             c = number & 0xff;
5346           }
5347           --input_line_pointer;
5348           break;
5349
5350         case 'x':
5351         case 'X':
5352           {
5353             long number;
5354
5355             number = 0;
5356             c = *input_line_pointer++;
5357             while (ISXDIGIT (c))
5358               {
5359                 if (ISDIGIT (c))
5360                   number = number * 16 + c - '0';
5361                 else if (ISUPPER (c))
5362                   number = number * 16 + c - 'A' + 10;
5363                 else
5364                   number = number * 16 + c - 'a' + 10;
5365                 c = *input_line_pointer++;
5366               }
5367             c = number & 0xff;
5368             --input_line_pointer;
5369           }
5370           break;
5371
5372         case '\n':
5373           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
5374           as_warn (_("unterminated string; newline inserted"));
5375           c = '\n';
5376           bump_line_counters ();
5377           break;
5378
5379         default:
5380
5381 #ifdef ONLY_STANDARD_ESCAPES
5382           as_bad (_("bad escaped character in string"));
5383           c = '?';
5384 #endif /* ONLY_STANDARD_ESCAPES */
5385
5386           break;
5387         }
5388       break;
5389 #endif /* ! defined (NO_STRING_ESCAPES) */
5390
5391     default:
5392       break;
5393     }
5394   return (c);
5395 }
5396 \f
5397 static segT
5398 get_segmented_expression (expressionS *expP)
5399 {
5400   segT retval;
5401
5402   retval = expression (expP);
5403   if (expP->X_op == O_illegal
5404       || expP->X_op == O_absent
5405       || expP->X_op == O_big)
5406     {
5407       as_bad (_("expected address expression"));
5408       expP->X_op = O_constant;
5409       expP->X_add_number = 0;
5410       retval = absolute_section;
5411     }
5412   return retval;
5413 }
5414
5415 static segT
5416 get_known_segmented_expression (expressionS *expP)
5417 {
5418   segT retval = get_segmented_expression (expP);
5419
5420   if (retval == undefined_section)
5421     {
5422       /* There is no easy way to extract the undefined symbol from the
5423          expression.  */
5424       if (expP->X_add_symbol != NULL
5425           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5426         as_warn (_("symbol \"%s\" undefined; zero assumed"),
5427                  S_GET_NAME (expP->X_add_symbol));
5428       else
5429         as_warn (_("some symbol undefined; zero assumed"));
5430       retval = absolute_section;
5431       expP->X_op = O_constant;
5432       expP->X_add_number = 0;
5433     }
5434   return retval;
5435 }
5436
5437 char                            /* Return terminator.  */
5438 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
5439 {
5440   /* FIXME: val_pointer should probably be offsetT *.  */
5441   *val_pointer = (long) get_absolute_expression ();
5442   return (*input_line_pointer++);
5443 }
5444 \f
5445 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5446    Give a warning if that happens.  */
5447
5448 char *
5449 demand_copy_C_string (int *len_pointer)
5450 {
5451   char *s;
5452
5453   if ((s = demand_copy_string (len_pointer)) != 0)
5454     {
5455       int len;
5456
5457       for (len = *len_pointer; len > 0; len--)
5458         {
5459           if (*s == 0)
5460             {
5461               s = 0;
5462               len = 1;
5463               *len_pointer = 0;
5464               as_bad (_("this string may not contain \'\\0\'"));
5465             }
5466         }
5467     }
5468
5469   return s;
5470 }
5471 \f
5472 /* Demand string, but return a safe (=private) copy of the string.
5473    Return NULL if we can't read a string here.  */
5474
5475 char *
5476 demand_copy_string (int *lenP)
5477 {
5478   unsigned int c;
5479   int len;
5480   char *retval;
5481
5482   len = 0;
5483   SKIP_WHITESPACE ();
5484   if (*input_line_pointer == '\"')
5485     {
5486       input_line_pointer++;     /* Skip opening quote.  */
5487
5488       while (is_a_char (c = next_char_of_string ()))
5489         {
5490           obstack_1grow (&notes, c);
5491           len++;
5492         }
5493       /* JF this next line is so demand_copy_C_string will return a
5494          null terminated string.  */
5495       obstack_1grow (&notes, '\0');
5496       retval = (char *) obstack_finish (&notes);
5497     }
5498   else
5499     {
5500       as_bad (_("missing string"));
5501       retval = NULL;
5502       ignore_rest_of_line ();
5503     }
5504   *lenP = len;
5505   return (retval);
5506 }
5507 \f
5508 /* In:  Input_line_pointer->next character.
5509
5510    Do:  Skip input_line_pointer over all whitespace.
5511
5512    Out: 1 if input_line_pointer->end-of-line.  */
5513
5514 int
5515 is_it_end_of_statement (void)
5516 {
5517   SKIP_WHITESPACE ();
5518   return (is_end_of_line[(unsigned char) *input_line_pointer]);
5519 }
5520
5521 void
5522 equals (char *sym_name, int reassign)
5523 {
5524   char *stop = NULL;
5525   char stopc = 0;
5526
5527   input_line_pointer++;
5528   if (*input_line_pointer == '=')
5529     input_line_pointer++;
5530   if (reassign < 0 && *input_line_pointer == '=')
5531     input_line_pointer++;
5532
5533   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5534     input_line_pointer++;
5535
5536   if (flag_mri)
5537     stop = mri_comment_field (&stopc);
5538
5539   assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5540
5541   if (flag_mri)
5542     {
5543       demand_empty_rest_of_line ();
5544       mri_comment_end (stop, stopc);
5545     }
5546 }
5547
5548 /* .incbin -- include a file verbatim at the current location.  */
5549
5550 void
5551 s_incbin (int x ATTRIBUTE_UNUSED)
5552 {
5553   FILE * binfile;
5554   char * path;
5555   char * filename;
5556   char * binfrag;
5557   long   skip = 0;
5558   long   count = 0;
5559   long   bytes;
5560   int    len;
5561
5562 #ifdef md_flush_pending_output
5563   md_flush_pending_output ();
5564 #endif
5565
5566 #ifdef md_cons_align
5567   md_cons_align (1);
5568 #endif
5569
5570   SKIP_WHITESPACE ();
5571   filename = demand_copy_string (& len);
5572   if (filename == NULL)
5573     return;
5574
5575   SKIP_WHITESPACE ();
5576
5577   /* Look for optional skip and count.  */
5578   if (* input_line_pointer == ',')
5579     {
5580       ++ input_line_pointer;
5581       skip = get_absolute_expression ();
5582
5583       SKIP_WHITESPACE ();
5584
5585       if (* input_line_pointer == ',')
5586         {
5587           ++ input_line_pointer;
5588
5589           count = get_absolute_expression ();
5590           if (count == 0)
5591             as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5592
5593           SKIP_WHITESPACE ();
5594         }
5595     }
5596
5597   demand_empty_rest_of_line ();
5598
5599   /* Try opening absolute path first, then try include dirs.  */
5600   binfile = fopen (filename, FOPEN_RB);
5601   if (binfile == NULL)
5602     {
5603       int i;
5604
5605       path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5606
5607       for (i = 0; i < include_dir_count; i++)
5608         {
5609           sprintf (path, "%s/%s", include_dirs[i], filename);
5610
5611           binfile = fopen (path, FOPEN_RB);
5612           if (binfile != NULL)
5613             break;
5614         }
5615
5616       if (binfile == NULL)
5617         as_bad (_("file not found: %s"), filename);
5618     }
5619   else
5620     path = xstrdup (filename);
5621
5622   if (binfile)
5623     {
5624       long   file_len;
5625
5626       register_dependency (path);
5627
5628       /* Compute the length of the file.  */
5629       if (fseek (binfile, 0, SEEK_END) != 0)
5630         {
5631           as_bad (_("seek to end of .incbin file failed `%s'"), path);
5632           goto done;
5633         }
5634       file_len = ftell (binfile);
5635
5636       /* If a count was not specified use the remainder of the file.  */
5637       if (count == 0)
5638         count = file_len - skip;
5639
5640       if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5641         {
5642           as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5643                   skip, count, file_len);
5644           goto done;
5645         }
5646
5647       if (fseek (binfile, skip, SEEK_SET) != 0)
5648         {
5649           as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5650           goto done;
5651         }
5652
5653       /* Allocate frag space and store file contents in it.  */
5654       binfrag = frag_more (count);
5655
5656       bytes = fread (binfrag, 1, count, binfile);
5657       if (bytes < count)
5658         as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5659                  path, bytes, count);
5660     }
5661 done:
5662   if (binfile != NULL)
5663     fclose (binfile);
5664   if (path)
5665     free (path);
5666 }
5667
5668 /* .include -- include a file at this point.  */
5669
5670 void
5671 s_include (int arg ATTRIBUTE_UNUSED)
5672 {
5673   char *filename;
5674   int i;
5675   FILE *try_file;
5676   char *path;
5677
5678   if (!flag_m68k_mri)
5679     {
5680       filename = demand_copy_string (&i);
5681       if (filename == NULL)
5682         {
5683           /* demand_copy_string has already printed an error and
5684              called ignore_rest_of_line.  */
5685           return;
5686         }
5687     }
5688   else
5689     {
5690       SKIP_WHITESPACE ();
5691       i = 0;
5692       while (!is_end_of_line[(unsigned char) *input_line_pointer]
5693              && *input_line_pointer != ' '
5694              && *input_line_pointer != '\t')
5695         {
5696           obstack_1grow (&notes, *input_line_pointer);
5697           ++input_line_pointer;
5698           ++i;
5699         }
5700
5701       obstack_1grow (&notes, '\0');
5702       filename = (char *) obstack_finish (&notes);
5703       while (!is_end_of_line[(unsigned char) *input_line_pointer])
5704         ++input_line_pointer;
5705     }
5706
5707   demand_empty_rest_of_line ();
5708   path = (char *) xmalloc ((unsigned long) i
5709                            + include_dir_maxlen + 5 /* slop */ );
5710
5711   for (i = 0; i < include_dir_count; i++)
5712     {
5713       strcpy (path, include_dirs[i]);
5714       strcat (path, "/");
5715       strcat (path, filename);
5716       if (0 != (try_file = fopen (path, FOPEN_RT)))
5717         {
5718           fclose (try_file);
5719           goto gotit;
5720         }
5721     }
5722
5723   free (path);
5724   path = filename;
5725 gotit:
5726   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
5727   register_dependency (path);
5728   input_scrub_insert_file (path);
5729 }
5730
5731 void
5732 add_include_dir (char *path)
5733 {
5734   int i;
5735
5736   if (include_dir_count == 0)
5737     {
5738       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5739       include_dirs[0] = ".";    /* Current dir.  */
5740       include_dir_count = 2;
5741     }
5742   else
5743     {
5744       include_dir_count++;
5745       include_dirs =
5746         (char **) realloc (include_dirs,
5747                            include_dir_count * sizeof (*include_dirs));
5748     }
5749
5750   include_dirs[include_dir_count - 1] = path;   /* New one.  */
5751
5752   i = strlen (path);
5753   if (i > include_dir_maxlen)
5754     include_dir_maxlen = i;
5755 }
5756 \f
5757 /* Output debugging information to denote the source file.  */
5758
5759 static void
5760 generate_file_debug (void)
5761 {
5762   if (debug_type == DEBUG_STABS)
5763     stabs_generate_asm_file ();
5764 }
5765
5766 /* Output line number debugging information for the current source line.  */
5767
5768 void
5769 generate_lineno_debug (void)
5770 {
5771   switch (debug_type)
5772     {
5773     case DEBUG_UNSPECIFIED:
5774     case DEBUG_NONE:
5775     case DEBUG_DWARF:
5776       break;
5777     case DEBUG_STABS:
5778       stabs_generate_asm_lineno ();
5779       break;
5780     case DEBUG_ECOFF:
5781       ecoff_generate_asm_lineno ();
5782       break;
5783     case DEBUG_DWARF2:
5784       /* ??? We could here indicate to dwarf2dbg.c that something
5785          has changed.  However, since there is additional backend
5786          support that is required (calling dwarf2_emit_insn), we
5787          let dwarf2dbg.c call as_where on its own.  */
5788       break;
5789     }
5790 }
5791
5792 /* Output debugging information to mark a function entry point or end point.
5793    END_P is zero for .func, and non-zero for .endfunc.  */
5794
5795 void
5796 s_func (int end_p)
5797 {
5798   do_s_func (end_p, NULL);
5799 }
5800
5801 /* Subroutine of s_func so targets can choose a different default prefix.
5802    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
5803
5804 static void
5805 do_s_func (int end_p, const char *default_prefix)
5806 {
5807   /* Record the current function so that we can issue an error message for
5808      misplaced .func,.endfunc, and also so that .endfunc needs no
5809      arguments.  */
5810   static char *current_name;
5811   static char *current_label;
5812
5813   if (end_p)
5814     {
5815       if (current_name == NULL)
5816         {
5817           as_bad (_("missing .func"));
5818           ignore_rest_of_line ();
5819           return;
5820         }
5821
5822       if (debug_type == DEBUG_STABS)
5823         stabs_generate_asm_endfunc (current_name, current_label);
5824
5825       current_name = current_label = NULL;
5826     }
5827   else /* ! end_p */
5828     {
5829       char *name, *label;
5830       char delim1, delim2;
5831
5832       if (current_name != NULL)
5833         {
5834           as_bad (_(".endfunc missing for previous .func"));
5835           ignore_rest_of_line ();
5836           return;
5837         }
5838
5839       name = input_line_pointer;
5840       delim1 = get_symbol_end ();
5841       name = xstrdup (name);
5842       *input_line_pointer = delim1;
5843       SKIP_WHITESPACE ();
5844       if (*input_line_pointer != ',')
5845         {
5846           if (default_prefix)
5847             {
5848               if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5849                 as_fatal ("%s", xstrerror (errno));
5850             }
5851           else
5852             {
5853               char leading_char = bfd_get_symbol_leading_char (stdoutput);
5854               /* Missing entry point, use function's name with the leading
5855                  char prepended.  */
5856               if (leading_char)
5857                 {
5858                   if (asprintf (&label, "%c%s", leading_char, name) == -1)
5859                     as_fatal ("%s", xstrerror (errno));
5860                 }
5861               else
5862                 label = name;
5863             }
5864         }
5865       else
5866         {
5867           ++input_line_pointer;
5868           SKIP_WHITESPACE ();
5869           label = input_line_pointer;
5870           delim2 = get_symbol_end ();
5871           label = xstrdup (label);
5872           *input_line_pointer = delim2;
5873         }
5874
5875       if (debug_type == DEBUG_STABS)
5876         stabs_generate_asm_func (name, label);
5877
5878       current_name = name;
5879       current_label = label;
5880     }
5881
5882   demand_empty_rest_of_line ();
5883 }
5884 \f
5885 void
5886 s_ignore (int arg ATTRIBUTE_UNUSED)
5887 {
5888   ignore_rest_of_line ();
5889 }
5890
5891 void
5892 read_print_statistics (FILE *file)
5893 {
5894   hash_print_statistics (file, "pseudo-op table", po_hash);
5895 }
5896
5897 /* Inserts the given line into the input stream.
5898
5899    This call avoids macro/conditionals nesting checking, since the contents of
5900    the line are assumed to replace the contents of a line already scanned.
5901
5902    An appropriate use of this function would be substitution of input lines when
5903    called by md_start_line_hook().  The given line is assumed to already be
5904    properly scrubbed.  */
5905
5906 void
5907 input_scrub_insert_line (const char *line)
5908 {
5909   sb newline;
5910   sb_new (&newline);
5911   sb_add_string (&newline, line);
5912   input_scrub_include_sb (&newline, input_line_pointer, 0);
5913   sb_kill (&newline);
5914   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5915 }
5916
5917 /* Insert a file into the input stream; the path must resolve to an actual
5918    file; no include path searching or dependency registering is performed.  */
5919
5920 void
5921 input_scrub_insert_file (char *path)
5922 {
5923   input_scrub_include_file (path, input_line_pointer);
5924   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5925 }
5926
5927 /* Find the end of a line, considering quotation and escaping of quotes.  */
5928
5929 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5930 # define TC_SINGLE_QUOTE_STRINGS 1
5931 #endif
5932
5933 static char *
5934 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5935                    int in_macro)
5936 {
5937   char inquote = '\0';
5938   int inescape = 0;
5939
5940   while (!is_end_of_line[(unsigned char) *s]
5941          || (inquote && !ISCNTRL (*s))
5942          || (inquote == '\'' && flag_mri)
5943 #ifdef TC_EOL_IN_INSN
5944          || (insn && TC_EOL_IN_INSN (s))
5945 #endif
5946          /* PR 6926:  When we are parsing the body of a macro the sequence
5947             \@ is special - it refers to the invocation count.  If the @
5948             character happens to be registered as a line-separator character
5949             by the target, then the is_end_of_line[] test above will have
5950             returned true, but we need to ignore the line separating
5951             semantics in this particular case.  */
5952          || (in_macro && inescape && *s == '@')
5953         )
5954     {
5955       if (mri_string && *s == '\'')
5956         inquote ^= *s;
5957       else if (inescape)
5958         inescape = 0;
5959       else if (*s == '\\')
5960         inescape = 1;
5961       else if (!inquote
5962                ? *s == '"'
5963 #ifdef TC_SINGLE_QUOTE_STRINGS
5964                  || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5965 #endif
5966                : *s == inquote)
5967         inquote ^= *s;
5968       ++s;
5969     }
5970   if (inquote)
5971     as_warn (_("missing closing `%c'"), inquote);
5972   if (inescape)
5973     as_warn (_("stray `\\'"));
5974   return s;
5975 }
5976
5977 char *
5978 find_end_of_line (char *s, int mri_string)
5979 {
5980   return _find_end_of_line (s, mri_string, 0, 0);
5981 }