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