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 #ifdef md_cons_align
1924   md_cons_align (1);
1925 #endif
1926
1927   get_known_segmented_expression (&rep_exp);
1928   if (*input_line_pointer == ',')
1929     {
1930       input_line_pointer++;
1931       size = get_absolute_expression ();
1932       if (*input_line_pointer == ',')
1933         {
1934           input_line_pointer++;
1935           fill = get_absolute_expression ();
1936         }
1937     }
1938
1939   /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
1940 #define BSD_FILL_SIZE_CROCK_8 (8)
1941   if (size > BSD_FILL_SIZE_CROCK_8)
1942     {
1943       as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1944       size = BSD_FILL_SIZE_CROCK_8;
1945     }
1946   if (size < 0)
1947     {
1948       as_warn (_("size negative; .fill ignored"));
1949       size = 0;
1950     }
1951   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1952     {
1953       if (rep_exp.X_add_number < 0)
1954         as_warn (_("repeat < 0; .fill ignored"));
1955       size = 0;
1956     }
1957
1958   if (size && !need_pass_2)
1959     {
1960       if (rep_exp.X_op == O_constant)
1961         {
1962           p = frag_var (rs_fill, (int) size, (int) size,
1963                         (relax_substateT) 0, (symbolS *) 0,
1964                         (offsetT) rep_exp.X_add_number,
1965                         (char *) 0);
1966         }
1967       else
1968         {
1969           /* We don't have a constant repeat count, so we can't use
1970              rs_fill.  We can get the same results out of rs_space,
1971              but its argument is in bytes, so we must multiply the
1972              repeat count by size.  */
1973
1974           symbolS *rep_sym;
1975           rep_sym = make_expr_symbol (&rep_exp);
1976           if (size != 1)
1977             {
1978               expressionS size_exp;
1979               size_exp.X_op = O_constant;
1980               size_exp.X_add_number = size;
1981
1982               rep_exp.X_op = O_multiply;
1983               rep_exp.X_add_symbol = rep_sym;
1984               rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1985               rep_exp.X_add_number = 0;
1986               rep_sym = make_expr_symbol (&rep_exp);
1987             }
1988
1989           p = frag_var (rs_space, (int) size, (int) size,
1990                         (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1991         }
1992
1993       memset (p, 0, (unsigned int) size);
1994
1995       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1996          flavoured AS.  The following bizarre behaviour is to be
1997          compatible with above.  I guess they tried to take up to 8
1998          bytes from a 4-byte expression and they forgot to sign
1999          extend.  */
2000 #define BSD_FILL_SIZE_CROCK_4 (4)
2001       md_number_to_chars (p, (valueT) fill,
2002                           (size > BSD_FILL_SIZE_CROCK_4
2003                            ? BSD_FILL_SIZE_CROCK_4
2004                            : (int) size));
2005       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2006          but emits no error message because it seems a legal thing to do.
2007          It is a degenerate case of .fill but could be emitted by a
2008          compiler.  */
2009     }
2010   demand_empty_rest_of_line ();
2011 }
2012
2013 void
2014 s_globl (int ignore ATTRIBUTE_UNUSED)
2015 {
2016   char *name;
2017   int c;
2018   symbolS *symbolP;
2019   char *stop = NULL;
2020   char stopc = 0;
2021
2022   if (flag_mri)
2023     stop = mri_comment_field (&stopc);
2024
2025   do
2026     {
2027       name = input_line_pointer;
2028       c = get_symbol_end ();
2029       symbolP = symbol_find_or_make (name);
2030       S_SET_EXTERNAL (symbolP);
2031
2032       *input_line_pointer = c;
2033       SKIP_WHITESPACE ();
2034       c = *input_line_pointer;
2035       if (c == ',')
2036         {
2037           input_line_pointer++;
2038           SKIP_WHITESPACE ();
2039           if (is_end_of_line[(unsigned char) *input_line_pointer])
2040             c = '\n';
2041         }
2042     }
2043   while (c == ',');
2044
2045   demand_empty_rest_of_line ();
2046
2047   if (flag_mri)
2048     mri_comment_end (stop, stopc);
2049 }
2050
2051 #ifdef OBJ_ELF
2052 #define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
2053
2054 static inline int
2055 skip_past_char (char ** str, char c)
2056 {
2057   if (**str == c)
2058     {
2059       (*str)++;
2060       return 0;
2061     }
2062   else
2063     return -1;
2064 }
2065 #define skip_past_comma(str) skip_past_char (str, ',')
2066
2067 /* Parse an attribute directive for VENDOR.
2068    Returns the attribute number read, or zero on error.  */
2069 int
2070 s_vendor_attribute (int vendor)
2071 {
2072   expressionS exp;
2073   int type;
2074   int tag;
2075   unsigned int i = 0;
2076   char *s = NULL;
2077
2078   /* Read the first number or name.  */
2079   skip_whitespace (input_line_pointer);
2080   s = input_line_pointer;
2081   if (ISDIGIT (*input_line_pointer))
2082     {
2083       expression (& exp);
2084       if (exp.X_op != O_constant)
2085         goto bad;
2086       tag = exp.X_add_number;
2087     }
2088   else
2089     {
2090       char *name;
2091
2092       /* A name may contain '_', but no other punctuation.  */
2093       for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2094            ++input_line_pointer)
2095         i++;
2096       if (i == 0)
2097         goto bad;
2098
2099       name = alloca (i + 1);
2100       memcpy (name, s, i);
2101       name[i] = '\0';
2102
2103 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2104 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2105 #endif
2106
2107       tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2108       if (tag == -1)
2109         {
2110           as_bad (_("Attribute name not recognised: %s"), name);
2111           ignore_rest_of_line ();
2112           return 0;
2113         }
2114     }
2115
2116   type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2117
2118   if (skip_past_comma (&input_line_pointer) == -1)
2119     goto bad;
2120   if (type & 1)
2121     {
2122       expression (& exp);
2123       if (exp.X_op != O_constant)
2124         {
2125           as_bad (_("expected numeric constant"));
2126           ignore_rest_of_line ();
2127           return 0;
2128         }
2129       i = exp.X_add_number;
2130     }
2131   if ((type & 3) == 3
2132       && skip_past_comma (&input_line_pointer) == -1)
2133     {
2134       as_bad (_("expected comma"));
2135       ignore_rest_of_line ();
2136       return 0;
2137     }
2138   if (type & 2)
2139     {
2140       int len;
2141
2142       skip_whitespace (input_line_pointer);
2143       if (*input_line_pointer != '"')
2144         goto bad_string;
2145       s = demand_copy_C_string (&len);
2146     }
2147
2148   switch (type & 3)
2149     {
2150     case 3:
2151       bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2152       break;
2153     case 2:
2154       bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2155       break;
2156     case 1:
2157       bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2158       break;
2159     default:
2160       abort ();
2161     }
2162
2163   demand_empty_rest_of_line ();
2164   return tag;
2165 bad_string:
2166   as_bad (_("bad string constant"));
2167   ignore_rest_of_line ();
2168   return 0;
2169 bad:
2170   as_bad (_("expected <tag> , <value>"));
2171   ignore_rest_of_line ();
2172   return 0;
2173 }
2174
2175 /* Parse a .gnu_attribute directive.  */
2176
2177 static void
2178 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2179 {
2180   s_vendor_attribute (OBJ_ATTR_GNU);
2181 }
2182 #endif /* OBJ_ELF */
2183
2184 /* Handle the MRI IRP and IRPC pseudo-ops.  */
2185
2186 void
2187 s_irp (int irpc)
2188 {
2189   char *file, *eol;
2190   unsigned int line;
2191   sb s;
2192   const char *err;
2193   sb out;
2194
2195   as_where (&file, &line);
2196
2197   sb_new (&s);
2198   eol = find_end_of_line (input_line_pointer, 0);
2199   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2200   input_line_pointer = eol;
2201
2202   sb_new (&out);
2203
2204   err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2205   if (err != NULL)
2206     as_bad_where (file, line, "%s", err);
2207
2208   sb_kill (&s);
2209
2210   input_scrub_include_sb (&out, input_line_pointer, 1);
2211   sb_kill (&out);
2212   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2213 }
2214
2215 /* Handle the .linkonce pseudo-op.  This tells the assembler to mark
2216    the section to only be linked once.  However, this is not supported
2217    by most object file formats.  This takes an optional argument,
2218    which is what to do about duplicates.  */
2219
2220 void
2221 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2222 {
2223   enum linkonce_type type;
2224
2225   SKIP_WHITESPACE ();
2226
2227   type = LINKONCE_DISCARD;
2228
2229   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2230     {
2231       char *s;
2232       char c;
2233
2234       s = input_line_pointer;
2235       c = get_symbol_end ();
2236       if (strcasecmp (s, "discard") == 0)
2237         type = LINKONCE_DISCARD;
2238       else if (strcasecmp (s, "one_only") == 0)
2239         type = LINKONCE_ONE_ONLY;
2240       else if (strcasecmp (s, "same_size") == 0)
2241         type = LINKONCE_SAME_SIZE;
2242       else if (strcasecmp (s, "same_contents") == 0)
2243         type = LINKONCE_SAME_CONTENTS;
2244       else
2245         as_warn (_("unrecognized .linkonce type `%s'"), s);
2246
2247       *input_line_pointer = c;
2248     }
2249
2250 #ifdef obj_handle_link_once
2251   obj_handle_link_once (type);
2252 #else /* ! defined (obj_handle_link_once) */
2253   {
2254     flagword flags;
2255
2256     if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2257       as_warn (_(".linkonce is not supported for this object file format"));
2258
2259     flags = bfd_get_section_flags (stdoutput, now_seg);
2260     flags |= SEC_LINK_ONCE;
2261     switch (type)
2262       {
2263       default:
2264         abort ();
2265       case LINKONCE_DISCARD:
2266         flags |= SEC_LINK_DUPLICATES_DISCARD;
2267         break;
2268       case LINKONCE_ONE_ONLY:
2269         flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2270         break;
2271       case LINKONCE_SAME_SIZE:
2272         flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2273         break;
2274       case LINKONCE_SAME_CONTENTS:
2275         flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2276         break;
2277       }
2278     if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2279       as_bad (_("bfd_set_section_flags: %s"),
2280               bfd_errmsg (bfd_get_error ()));
2281   }
2282 #endif /* ! defined (obj_handle_link_once) */
2283
2284   demand_empty_rest_of_line ();
2285 }
2286
2287 void
2288 bss_alloc (symbolS *symbolP, addressT size, int align)
2289 {
2290   char *pfrag;
2291   segT current_seg = now_seg;
2292   subsegT current_subseg = now_subseg;
2293   segT bss_seg = bss_section;
2294
2295 #if defined (TC_MIPS) || defined (TC_ALPHA)
2296   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2297       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2298     {
2299       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
2300       if (size <= bfd_get_gp_size (stdoutput))
2301         {
2302           bss_seg = subseg_new (".sbss", 1);
2303           seg_info (bss_seg)->bss = 1;
2304           if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2305             as_warn (_("error setting flags for \".sbss\": %s"),
2306                      bfd_errmsg (bfd_get_error ()));
2307         }
2308     }
2309 #endif
2310   subseg_set (bss_seg, 1);
2311
2312   if (align)
2313     {
2314       record_alignment (bss_seg, align);
2315       frag_align (align, 0, 0);
2316     }
2317
2318   /* Detach from old frag.  */
2319   if (S_GET_SEGMENT (symbolP) == bss_seg)
2320     symbol_get_frag (symbolP)->fr_symbol = NULL;
2321
2322   symbol_set_frag (symbolP, frag_now);
2323   pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2324   *pfrag = 0;
2325
2326 #ifdef S_SET_SIZE
2327   S_SET_SIZE (symbolP, size);
2328 #endif
2329   S_SET_SEGMENT (symbolP, bss_seg);
2330
2331 #ifdef OBJ_COFF
2332   /* The symbol may already have been created with a preceding
2333      ".globl" directive -- be careful not to step on storage class
2334      in that case.  Otherwise, set it to static.  */
2335   if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2336     S_SET_STORAGE_CLASS (symbolP, C_STAT);
2337 #endif /* OBJ_COFF */
2338
2339   subseg_set (current_seg, current_subseg);
2340 }
2341
2342 offsetT
2343 parse_align (int align_bytes)
2344 {
2345   expressionS exp;
2346   addressT align;
2347
2348   SKIP_WHITESPACE ();
2349   if (*input_line_pointer != ',')
2350     {
2351     no_align:
2352       as_bad (_("expected alignment after size"));
2353       ignore_rest_of_line ();
2354       return -1;
2355     }
2356
2357   input_line_pointer++;
2358   SKIP_WHITESPACE ();
2359
2360   align = get_absolute_expr (&exp);
2361   if (exp.X_op == O_absent)
2362     goto no_align;
2363
2364   if (!exp.X_unsigned)
2365     {
2366       as_warn (_("alignment negative; 0 assumed"));
2367       align = 0;
2368     }
2369
2370   if (align_bytes && align != 0)
2371     {
2372       /* convert to a power of 2 alignment */
2373       unsigned int alignp2 = 0;
2374       while ((align & 1) == 0)
2375         align >>= 1, ++alignp2;
2376       if (align != 1)
2377         {
2378           as_bad (_("alignment not a power of 2"));
2379           ignore_rest_of_line ();
2380           return -1;
2381         }
2382       align = alignp2;
2383     }
2384   return align;
2385 }
2386
2387 /* Called from s_comm_internal after symbol name and size have been
2388    parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2389    1 if this was a ".bss" directive which has a 3rd argument
2390    (alignment as a power of 2), or 2 if this was a ".bss" directive
2391    with alignment in bytes.  */
2392
2393 symbolS *
2394 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2395 {
2396   addressT align = 0;
2397
2398   if (needs_align)
2399     {
2400       align = parse_align (needs_align - 1);
2401       if (align == (addressT) -1)
2402         return NULL;
2403     }
2404   else
2405     /* Assume some objects may require alignment on some systems.  */
2406     TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2407
2408   bss_alloc (symbolP, size, align);
2409   return symbolP;
2410 }
2411
2412 void
2413 s_lcomm (int needs_align)
2414 {
2415   s_comm_internal (needs_align, s_lcomm_internal);
2416 }
2417
2418 void
2419 s_lcomm_bytes (int needs_align)
2420 {
2421   s_comm_internal (needs_align * 2, s_lcomm_internal);
2422 }
2423
2424 void
2425 s_lsym (int ignore ATTRIBUTE_UNUSED)
2426 {
2427   register char *name;
2428   register char c;
2429   register char *p;
2430   expressionS exp;
2431   register symbolS *symbolP;
2432
2433   /* We permit ANY defined expression: BSD4.2 demands constants.  */
2434   name = input_line_pointer;
2435   c = get_symbol_end ();
2436   p = input_line_pointer;
2437   *p = c;
2438
2439   if (name == p)
2440     {
2441       as_bad (_("expected symbol name"));
2442       ignore_rest_of_line ();
2443       return;
2444     }
2445
2446   SKIP_WHITESPACE ();
2447
2448   if (*input_line_pointer != ',')
2449     {
2450       *p = 0;
2451       as_bad (_("expected comma after \"%s\""), name);
2452       *p = c;
2453       ignore_rest_of_line ();
2454       return;
2455     }
2456
2457   input_line_pointer++;
2458   expression_and_evaluate (&exp);
2459
2460   if (exp.X_op != O_constant
2461       && exp.X_op != O_register)
2462     {
2463       as_bad (_("bad expression"));
2464       ignore_rest_of_line ();
2465       return;
2466     }
2467
2468   *p = 0;
2469   symbolP = symbol_find_or_make (name);
2470
2471   if (S_GET_SEGMENT (symbolP) == undefined_section)
2472     {
2473       /* The name might be an undefined .global symbol; be sure to
2474          keep the "external" bit.  */
2475       S_SET_SEGMENT (symbolP,
2476                      (exp.X_op == O_constant
2477                       ? absolute_section
2478                       : reg_section));
2479       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2480     }
2481   else
2482     {
2483       as_bad (_("symbol `%s' is already defined"), name);
2484     }
2485
2486   *p = c;
2487   demand_empty_rest_of_line ();
2488 }
2489
2490 /* Read a line into an sb.  Returns the character that ended the line
2491    or zero if there are no more lines.  */
2492
2493 static int
2494 get_line_sb (sb *line, int in_macro)
2495 {
2496   char *eol;
2497
2498   if (input_line_pointer[-1] == '\n')
2499     bump_line_counters ();
2500
2501   if (input_line_pointer >= buffer_limit)
2502     {
2503       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2504       if (buffer_limit == 0)
2505         return 0;
2506     }
2507
2508   eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2509   sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2510   input_line_pointer = eol;
2511
2512   /* Don't skip multiple end-of-line characters, because that breaks support
2513      for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2514      characters but isn't.  Instead just skip one end of line character and
2515      return the character skipped so that the caller can re-insert it if
2516      necessary.   */
2517   return *input_line_pointer++;
2518 }
2519
2520 static int
2521 get_non_macro_line_sb (sb *line)
2522 {
2523   return get_line_sb (line, 0);
2524 }
2525
2526 static int
2527 get_macro_line_sb (sb *line)
2528 {
2529   return get_line_sb (line, 1);
2530 }
2531
2532 /* Define a macro.  This is an interface to macro.c.  */
2533
2534 void
2535 s_macro (int ignore ATTRIBUTE_UNUSED)
2536 {
2537   char *file, *eol;
2538   unsigned int line;
2539   sb s;
2540   const char *err;
2541   const char *name;
2542
2543   as_where (&file, &line);
2544
2545   sb_new (&s);
2546   eol = find_end_of_line (input_line_pointer, 0);
2547   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2548   input_line_pointer = eol;
2549
2550   if (line_label != NULL)
2551     {
2552       sb label;
2553
2554       sb_new (&label);
2555       sb_add_string (&label, S_GET_NAME (line_label));
2556       err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2557       sb_kill (&label);
2558     }
2559   else
2560     err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2561   if (err != NULL)
2562     as_bad_where (file, line, err, name);
2563   else
2564     {
2565       if (line_label != NULL)
2566         {
2567           S_SET_SEGMENT (line_label, absolute_section);
2568           S_SET_VALUE (line_label, 0);
2569           symbol_set_frag (line_label, &zero_address_frag);
2570         }
2571
2572       if (((NO_PSEUDO_DOT || flag_m68k_mri)
2573            && hash_find (po_hash, name) != NULL)
2574           || (!flag_m68k_mri
2575               && *name == '.'
2576               && hash_find (po_hash, name + 1) != NULL))
2577         as_warn_where (file,
2578                  line,
2579                  _("attempt to redefine pseudo-op `%s' ignored"),
2580                  name);
2581     }
2582
2583   sb_kill (&s);
2584 }
2585
2586 /* Handle the .mexit pseudo-op, which immediately exits a macro
2587    expansion.  */
2588
2589 void
2590 s_mexit (int ignore ATTRIBUTE_UNUSED)
2591 {
2592   if (macro_nest)
2593     {
2594       cond_exit_macro (macro_nest);
2595       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2596     }
2597   else
2598     as_warn (_("ignoring macro exit outside a macro definition."));
2599 }
2600
2601 /* Switch in and out of MRI mode.  */
2602
2603 void
2604 s_mri (int ignore ATTRIBUTE_UNUSED)
2605 {
2606   int on, old_flag;
2607
2608   on = get_absolute_expression ();
2609   old_flag = flag_mri;
2610   if (on != 0)
2611     {
2612       flag_mri = 1;
2613 #ifdef TC_M68K
2614       flag_m68k_mri = 1;
2615 #endif
2616       macro_mri_mode (1);
2617     }
2618   else
2619     {
2620       flag_mri = 0;
2621 #ifdef TC_M68K
2622       flag_m68k_mri = 0;
2623 #endif
2624       macro_mri_mode (0);
2625     }
2626
2627   /* Operator precedence changes in m68k MRI mode, so we need to
2628      update the operator rankings.  */
2629   expr_set_precedence ();
2630
2631 #ifdef MRI_MODE_CHANGE
2632   if (on != old_flag)
2633     MRI_MODE_CHANGE (on);
2634 #endif
2635
2636   demand_empty_rest_of_line ();
2637 }
2638
2639 /* Handle changing the location counter.  */
2640
2641 static void
2642 do_org (segT segment, expressionS *exp, int fill)
2643 {
2644   if (segment != now_seg && segment != absolute_section)
2645     as_bad (_("invalid segment \"%s\""), segment_name (segment));
2646
2647   if (now_seg == absolute_section)
2648     {
2649       if (fill != 0)
2650         as_warn (_("ignoring fill value in absolute section"));
2651       if (exp->X_op != O_constant)
2652         {
2653           as_bad (_("only constant offsets supported in absolute section"));
2654           exp->X_add_number = 0;
2655         }
2656       abs_section_offset = exp->X_add_number;
2657     }
2658   else
2659     {
2660       char *p;
2661       symbolS *sym = exp->X_add_symbol;
2662       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2663
2664       if (exp->X_op != O_constant && exp->X_op != O_symbol)
2665         {
2666           /* Handle complex expressions.  */
2667           sym = make_expr_symbol (exp);
2668           off = 0;
2669         }
2670
2671       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2672       *p = fill;
2673     }
2674 }
2675
2676 void
2677 s_org (int ignore ATTRIBUTE_UNUSED)
2678 {
2679   register segT segment;
2680   expressionS exp;
2681   register long temp_fill;
2682
2683 #ifdef md_flush_pending_output
2684   md_flush_pending_output ();
2685 #endif
2686
2687   /* The m68k MRI assembler has a different meaning for .org.  It
2688      means to create an absolute section at a given address.  We can't
2689      support that--use a linker script instead.  */
2690   if (flag_m68k_mri)
2691     {
2692       as_bad (_("MRI style ORG pseudo-op not supported"));
2693       ignore_rest_of_line ();
2694       return;
2695     }
2696
2697   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2698      thing as a sub-segment-relative origin.  Any absolute origin is
2699      given a warning, then assumed to be segment-relative.  Any
2700      segmented origin expression ("foo+42") had better be in the right
2701      segment or the .org is ignored.
2702
2703      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2704      we never know sub-segment sizes when we are reading code.  BSD
2705      will crash trying to emit negative numbers of filler bytes in
2706      certain .orgs. We don't crash, but see as-write for that code.
2707
2708      Don't make frag if need_pass_2==1.  */
2709   segment = get_known_segmented_expression (&exp);
2710   if (*input_line_pointer == ',')
2711     {
2712       input_line_pointer++;
2713       temp_fill = get_absolute_expression ();
2714     }
2715   else
2716     temp_fill = 0;
2717
2718   if (!need_pass_2)
2719     do_org (segment, &exp, temp_fill);
2720
2721   demand_empty_rest_of_line ();
2722 }
2723
2724 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2725    called by the obj-format routine which handles section changing
2726    when in MRI mode.  It will create a new section, and return it.  It
2727    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2728    'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */
2729
2730 void
2731 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2732 {
2733 #ifdef TC_M68K
2734
2735   char *name;
2736   char c;
2737   segT seg;
2738
2739   SKIP_WHITESPACE ();
2740
2741   name = input_line_pointer;
2742   if (!ISDIGIT (*name))
2743     c = get_symbol_end ();
2744   else
2745     {
2746       do
2747         {
2748           ++input_line_pointer;
2749         }
2750       while (ISDIGIT (*input_line_pointer));
2751
2752       c = *input_line_pointer;
2753       *input_line_pointer = '\0';
2754     }
2755
2756   name = xstrdup (name);
2757
2758   *input_line_pointer = c;
2759
2760   seg = subseg_new (name, 0);
2761
2762   if (*input_line_pointer == ',')
2763     {
2764       int align;
2765
2766       ++input_line_pointer;
2767       align = get_absolute_expression ();
2768       record_alignment (seg, align);
2769     }
2770
2771   *type = 'C';
2772   if (*input_line_pointer == ',')
2773     {
2774       c = *++input_line_pointer;
2775       c = TOUPPER (c);
2776       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2777         *type = c;
2778       else
2779         as_bad (_("unrecognized section type"));
2780       ++input_line_pointer;
2781
2782       {
2783         flagword flags;
2784
2785         flags = SEC_NO_FLAGS;
2786         if (*type == 'C')
2787           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2788         else if (*type == 'D' || *type == 'M')
2789           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2790         else if (*type == 'R')
2791           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2792         if (flags != SEC_NO_FLAGS)
2793           {
2794             if (!bfd_set_section_flags (stdoutput, seg, flags))
2795               as_warn (_("error setting flags for \"%s\": %s"),
2796                        bfd_section_name (stdoutput, seg),
2797                        bfd_errmsg (bfd_get_error ()));
2798           }
2799       }
2800     }
2801
2802   /* Ignore the HP type.  */
2803   if (*input_line_pointer == ',')
2804     input_line_pointer += 2;
2805
2806   demand_empty_rest_of_line ();
2807
2808 #else /* ! TC_M68K */
2809 #ifdef TC_I960
2810
2811   char *name;
2812   char c;
2813   segT seg;
2814
2815   SKIP_WHITESPACE ();
2816
2817   name = input_line_pointer;
2818   c = get_symbol_end ();
2819
2820   name = xstrdup (name);
2821
2822   *input_line_pointer = c;
2823
2824   seg = subseg_new (name, 0);
2825
2826   if (*input_line_pointer != ',')
2827     *type = 'C';
2828   else
2829     {
2830       char *sectype;
2831
2832       ++input_line_pointer;
2833       SKIP_WHITESPACE ();
2834       sectype = input_line_pointer;
2835       c = get_symbol_end ();
2836       if (*sectype == '\0')
2837         *type = 'C';
2838       else if (strcasecmp (sectype, "text") == 0)
2839         *type = 'C';
2840       else if (strcasecmp (sectype, "data") == 0)
2841         *type = 'D';
2842       else if (strcasecmp (sectype, "romdata") == 0)
2843         *type = 'R';
2844       else
2845         as_warn (_("unrecognized section type `%s'"), sectype);
2846       *input_line_pointer = c;
2847     }
2848
2849   if (*input_line_pointer == ',')
2850     {
2851       char *seccmd;
2852
2853       ++input_line_pointer;
2854       SKIP_WHITESPACE ();
2855       seccmd = input_line_pointer;
2856       c = get_symbol_end ();
2857       if (strcasecmp (seccmd, "absolute") == 0)
2858         {
2859           as_bad (_("absolute sections are not supported"));
2860           *input_line_pointer = c;
2861           ignore_rest_of_line ();
2862           return;
2863         }
2864       else if (strcasecmp (seccmd, "align") == 0)
2865         {
2866           int align;
2867
2868           *input_line_pointer = c;
2869           align = get_absolute_expression ();
2870           record_alignment (seg, align);
2871         }
2872       else
2873         {
2874           as_warn (_("unrecognized section command `%s'"), seccmd);
2875           *input_line_pointer = c;
2876         }
2877     }
2878
2879   demand_empty_rest_of_line ();
2880
2881 #else /* ! TC_I960 */
2882   /* The MRI assembler seems to use different forms of .sect for
2883      different targets.  */
2884   as_bad ("MRI mode not supported for this target");
2885   ignore_rest_of_line ();
2886 #endif /* ! TC_I960 */
2887 #endif /* ! TC_M68K */
2888 }
2889
2890 /* Handle the .print pseudo-op.  */
2891
2892 void
2893 s_print (int ignore ATTRIBUTE_UNUSED)
2894 {
2895   char *s;
2896   int len;
2897
2898   s = demand_copy_C_string (&len);
2899   if (s != NULL)
2900     printf ("%s\n", s);
2901   demand_empty_rest_of_line ();
2902 }
2903
2904 /* Handle the .purgem pseudo-op.  */
2905
2906 void
2907 s_purgem (int ignore ATTRIBUTE_UNUSED)
2908 {
2909   if (is_it_end_of_statement ())
2910     {
2911       demand_empty_rest_of_line ();
2912       return;
2913     }
2914
2915   do
2916     {
2917       char *name;
2918       char c;
2919
2920       SKIP_WHITESPACE ();
2921       name = input_line_pointer;
2922       c = get_symbol_end ();
2923       delete_macro (name);
2924       *input_line_pointer = c;
2925       SKIP_WHITESPACE ();
2926     }
2927   while (*input_line_pointer++ == ',');
2928
2929   --input_line_pointer;
2930   demand_empty_rest_of_line ();
2931 }
2932
2933 /* Handle the .endm/.endr pseudo-ops.  */
2934
2935 static void
2936 s_bad_end (int endr)
2937 {
2938   as_warn (_(".end%c encountered without preceeding %s"),
2939            endr ? 'r' : 'm',
2940            endr ? ".rept, .irp, or .irpc" : ".macro");
2941   demand_empty_rest_of_line ();
2942 }
2943
2944 /* Handle the .rept pseudo-op.  */
2945
2946 void
2947 s_rept (int ignore ATTRIBUTE_UNUSED)
2948 {
2949   int count;
2950
2951   count = get_absolute_expression ();
2952
2953   do_repeat (count, "REPT", "ENDR");
2954 }
2955
2956 /* This function provides a generic repeat block implementation.   It allows
2957    different directives to be used as the start/end keys.  */
2958
2959 void
2960 do_repeat (int count, const char *start, const char *end)
2961 {
2962   sb one;
2963   sb many;
2964
2965   sb_new (&one);
2966   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2967     {
2968       as_bad (_("%s without %s"), start, end);
2969       return;
2970     }
2971
2972   sb_new (&many);
2973   while (count-- > 0)
2974     sb_add_sb (&many, &one);
2975
2976   sb_kill (&one);
2977
2978   input_scrub_include_sb (&many, input_line_pointer, 1);
2979   sb_kill (&many);
2980   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2981 }
2982
2983 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2984    input buffers to skip.  Assumes that conditionals preceding the loop end
2985    are properly nested.
2986
2987    This function makes it easier to implement a premature "break" out of the
2988    loop.  The EXTRA arg accounts for other buffers we might have inserted,
2989    such as line substitutions.  */
2990
2991 void
2992 end_repeat (int extra)
2993 {
2994   cond_exit_macro (macro_nest);
2995   while (extra-- >= 0)
2996     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2997 }
2998
2999 static void
3000 assign_symbol (char *name, int mode)
3001 {
3002   symbolS *symbolP;
3003
3004   if (name[0] == '.' && name[1] == '\0')
3005     {
3006       /* Turn '. = mumble' into a .org mumble.  */
3007       segT segment;
3008       expressionS exp;
3009
3010       segment = get_known_segmented_expression (&exp);
3011
3012       if (!need_pass_2)
3013         do_org (segment, &exp, 0);
3014
3015       return;
3016     }
3017
3018   if ((symbolP = symbol_find (name)) == NULL
3019       && (symbolP = md_undefined_symbol (name)) == NULL)
3020     {
3021       symbolP = symbol_find_or_make (name);
3022 #ifndef NO_LISTING
3023       /* When doing symbol listings, play games with dummy fragments living
3024          outside the normal fragment chain to record the file and line info
3025          for this symbol.  */
3026       if (listing & LISTING_SYMBOLS)
3027         {
3028           extern struct list_info_struct *listing_tail;
3029           fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3030           dummy_frag->line = listing_tail;
3031           dummy_frag->fr_symbol = symbolP;
3032           symbol_set_frag (symbolP, dummy_frag);
3033         }
3034 #endif
3035 #ifdef OBJ_COFF
3036       /* "set" symbols are local unless otherwise specified.  */
3037       SF_SET_LOCAL (symbolP);
3038 #endif
3039     }
3040
3041   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3042     {
3043       /* Permit register names to be redefined.  */
3044       if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3045           && S_GET_SEGMENT (symbolP) != reg_section)
3046         {
3047           as_bad (_("symbol `%s' is already defined"), name);
3048           symbolP = symbol_clone (symbolP, 0);
3049         }
3050       /* If the symbol is volatile, copy the symbol and replace the
3051          original with the copy, so that previous uses of the symbol will
3052          retain the value of the symbol at the point of use.  */
3053       else if (S_IS_VOLATILE (symbolP))
3054         symbolP = symbol_clone (symbolP, 1);
3055     }
3056
3057   if (mode == 0)
3058     S_SET_VOLATILE (symbolP);
3059   else if (mode < 0)
3060     S_SET_FORWARD_REF (symbolP);
3061
3062   pseudo_set (symbolP);
3063 }
3064
3065 /* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
3066    then this is .equiv, and it is an error if the symbol is already
3067    defined.  If EQUIV is -1, the symbol additionally is a forward
3068    reference.  */
3069
3070 void
3071 s_set (int equiv)
3072 {
3073   char *name;
3074   char delim;
3075   char *end_name;
3076
3077   /* Especial apologies for the random logic:
3078      this just grew, and could be parsed much more simply!
3079      Dean in haste.  */
3080   name = input_line_pointer;
3081   delim = get_symbol_end ();
3082   end_name = input_line_pointer;
3083   *end_name = delim;
3084
3085   if (name == end_name)
3086     {
3087       as_bad (_("expected symbol name"));
3088       ignore_rest_of_line ();
3089       return;
3090     }
3091
3092   SKIP_WHITESPACE ();
3093
3094   if (*input_line_pointer != ',')
3095     {
3096       *end_name = 0;
3097       as_bad (_("expected comma after \"%s\""), name);
3098       *end_name = delim;
3099       ignore_rest_of_line ();
3100       return;
3101     }
3102
3103   input_line_pointer++;
3104   *end_name = 0;
3105
3106   assign_symbol (name, equiv);
3107   *end_name = delim;
3108
3109   demand_empty_rest_of_line ();
3110 }
3111
3112 void
3113 s_space (int mult)
3114 {
3115   expressionS exp;
3116   expressionS val;
3117   char *p = 0;
3118   char *stop = NULL;
3119   char stopc = 0;
3120   int bytes;
3121
3122 #ifdef md_flush_pending_output
3123   md_flush_pending_output ();
3124 #endif
3125
3126 #ifdef md_cons_align
3127   md_cons_align (1);
3128 #endif
3129
3130   if (flag_mri)
3131     stop = mri_comment_field (&stopc);
3132
3133   /* In m68k MRI mode, we need to align to a word boundary, unless
3134      this is ds.b.  */
3135   if (flag_m68k_mri && mult > 1)
3136     {
3137       if (now_seg == absolute_section)
3138         {
3139           abs_section_offset += abs_section_offset & 1;
3140           if (line_label != NULL)
3141             S_SET_VALUE (line_label, abs_section_offset);
3142         }
3143       else if (mri_common_symbol != NULL)
3144         {
3145           valueT val;
3146
3147           val = S_GET_VALUE (mri_common_symbol);
3148           if ((val & 1) != 0)
3149             {
3150               S_SET_VALUE (mri_common_symbol, val + 1);
3151               if (line_label != NULL)
3152                 {
3153                   expressionS *symexp;
3154
3155                   symexp = symbol_get_value_expression (line_label);
3156                   know (symexp->X_op == O_symbol);
3157                   know (symexp->X_add_symbol == mri_common_symbol);
3158                   symexp->X_add_number += 1;
3159                 }
3160             }
3161         }
3162       else
3163         {
3164           do_align (1, (char *) NULL, 0, 0);
3165           if (line_label != NULL)
3166             {
3167               symbol_set_frag (line_label, frag_now);
3168               S_SET_VALUE (line_label, frag_now_fix ());
3169             }
3170         }
3171     }
3172
3173   bytes = mult;
3174
3175   expression (&exp);
3176
3177   SKIP_WHITESPACE ();
3178   if (*input_line_pointer == ',')
3179     {
3180       ++input_line_pointer;
3181       expression (&val);
3182     }
3183   else
3184     {
3185       val.X_op = O_constant;
3186       val.X_add_number = 0;
3187     }
3188
3189   if (val.X_op != O_constant
3190       || val.X_add_number < - 0x80
3191       || val.X_add_number > 0xff
3192       || (mult != 0 && mult != 1 && val.X_add_number != 0))
3193     {
3194       resolve_expression (&exp);
3195       if (exp.X_op != O_constant)
3196         as_bad (_("unsupported variable size or fill value"));
3197       else
3198         {
3199           offsetT i;
3200
3201           if (mult == 0)
3202             mult = 1;
3203           bytes = mult * exp.X_add_number;
3204           for (i = 0; i < exp.X_add_number; i++)
3205             emit_expr (&val, mult);
3206         }
3207     }
3208   else
3209     {
3210       if (now_seg == absolute_section || mri_common_symbol != NULL)
3211         resolve_expression (&exp);
3212
3213       if (exp.X_op == O_constant)
3214         {
3215           offsetT repeat;
3216
3217           repeat = exp.X_add_number;
3218           if (mult)
3219             repeat *= mult;
3220           bytes = repeat;
3221           if (repeat <= 0)
3222             {
3223               if (!flag_mri)
3224                 as_warn (_(".space repeat count is zero, ignored"));
3225               else if (repeat < 0)
3226                 as_warn (_(".space repeat count is negative, ignored"));
3227               goto getout;
3228             }
3229
3230           /* If we are in the absolute section, just bump the offset.  */
3231           if (now_seg == absolute_section)
3232             {
3233               abs_section_offset += repeat;
3234               goto getout;
3235             }
3236
3237           /* If we are secretly in an MRI common section, then
3238              creating space just increases the size of the common
3239              symbol.  */
3240           if (mri_common_symbol != NULL)
3241             {
3242               S_SET_VALUE (mri_common_symbol,
3243                            S_GET_VALUE (mri_common_symbol) + repeat);
3244               goto getout;
3245             }
3246
3247           if (!need_pass_2)
3248             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3249                           (offsetT) repeat, (char *) 0);
3250         }
3251       else
3252         {
3253           if (now_seg == absolute_section)
3254             {
3255               as_bad (_("space allocation too complex in absolute section"));
3256               subseg_set (text_section, 0);
3257             }
3258
3259           if (mri_common_symbol != NULL)
3260             {
3261               as_bad (_("space allocation too complex in common section"));
3262               mri_common_symbol = NULL;
3263             }
3264
3265           if (!need_pass_2)
3266             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3267                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3268         }
3269
3270       if (p)
3271         *p = val.X_add_number;
3272     }
3273
3274  getout:
3275
3276   /* In MRI mode, after an odd number of bytes, we must align to an
3277      even word boundary, unless the next instruction is a dc.b, ds.b
3278      or dcb.b.  */
3279   if (flag_mri && (bytes & 1) != 0)
3280     mri_pending_align = 1;
3281
3282   demand_empty_rest_of_line ();
3283
3284   if (flag_mri)
3285     mri_comment_end (stop, stopc);
3286 }
3287
3288 /* This is like s_space, but the value is a floating point number with
3289    the given precision.  This is for the MRI dcb.s pseudo-op and
3290    friends.  */
3291
3292 void
3293 s_float_space (int float_type)
3294 {
3295   offsetT count;
3296   int flen;
3297   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3298   char *stop = NULL;
3299   char stopc = 0;
3300
3301 #ifdef md_cons_align
3302   md_cons_align (1);
3303 #endif
3304
3305   if (flag_mri)
3306     stop = mri_comment_field (&stopc);
3307
3308   count = get_absolute_expression ();
3309
3310   SKIP_WHITESPACE ();
3311   if (*input_line_pointer != ',')
3312     {
3313       as_bad (_("missing value"));
3314       ignore_rest_of_line ();
3315       if (flag_mri)
3316         mri_comment_end (stop, stopc);
3317       return;
3318     }
3319
3320   ++input_line_pointer;
3321
3322   SKIP_WHITESPACE ();
3323
3324   /* Skip any 0{letter} that may be present.  Don't even check if the
3325    * letter is legal.  */
3326   if (input_line_pointer[0] == '0'
3327       && ISALPHA (input_line_pointer[1]))
3328     input_line_pointer += 2;
3329
3330   /* Accept :xxxx, where the x's are hex digits, for a floating point
3331      with the exact digits specified.  */
3332   if (input_line_pointer[0] == ':')
3333     {
3334       flen = hex_float (float_type, temp);
3335       if (flen < 0)
3336         {
3337           ignore_rest_of_line ();
3338           if (flag_mri)
3339             mri_comment_end (stop, stopc);
3340           return;
3341         }
3342     }
3343   else
3344     {
3345       char *err;
3346
3347       err = md_atof (float_type, temp, &flen);
3348       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3349       know (err != NULL || flen > 0);
3350       if (err)
3351         {
3352           as_bad (_("bad floating literal: %s"), err);
3353           ignore_rest_of_line ();
3354           if (flag_mri)
3355             mri_comment_end (stop, stopc);
3356           return;
3357         }
3358     }
3359
3360   while (--count >= 0)
3361     {
3362       char *p;
3363
3364       p = frag_more (flen);
3365       memcpy (p, temp, (unsigned int) flen);
3366     }
3367
3368   demand_empty_rest_of_line ();
3369
3370   if (flag_mri)
3371     mri_comment_end (stop, stopc);
3372 }
3373
3374 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3375
3376 void
3377 s_struct (int ignore ATTRIBUTE_UNUSED)
3378 {
3379   char *stop = NULL;
3380   char stopc = 0;
3381
3382   if (flag_mri)
3383     stop = mri_comment_field (&stopc);
3384   abs_section_offset = get_absolute_expression ();
3385 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3386   /* The ELF backend needs to know that we are changing sections, so
3387      that .previous works correctly. */
3388   if (IS_ELF)
3389     obj_elf_section_change_hook ();
3390 #endif
3391   subseg_set (absolute_section, 0);
3392   demand_empty_rest_of_line ();
3393   if (flag_mri)
3394     mri_comment_end (stop, stopc);
3395 }
3396
3397 void
3398 s_text (int ignore ATTRIBUTE_UNUSED)
3399 {
3400   register int temp;
3401
3402   temp = get_absolute_expression ();
3403   subseg_set (text_section, (subsegT) temp);
3404   demand_empty_rest_of_line ();
3405 #ifdef OBJ_VMS
3406   const_flag &= ~IN_DEFAULT_SECTION;
3407 #endif
3408 }
3409
3410 /* .weakref x, y sets x as an alias to y that, as long as y is not
3411    referenced directly, will cause y to become a weak symbol.  */
3412 void
3413 s_weakref (int ignore ATTRIBUTE_UNUSED)
3414 {
3415   char *name;
3416   char delim;
3417   char *end_name;
3418   symbolS *symbolP;
3419   symbolS *symbolP2;
3420   expressionS exp;
3421
3422   name = input_line_pointer;
3423   delim = get_symbol_end ();
3424   end_name = input_line_pointer;
3425
3426   if (name == end_name)
3427     {
3428       as_bad (_("expected symbol name"));
3429       *end_name = delim;
3430       ignore_rest_of_line ();
3431       return;
3432     }
3433
3434   symbolP = symbol_find_or_make (name);
3435
3436   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3437     {
3438       if (!S_IS_VOLATILE (symbolP))
3439         {
3440           as_bad (_("symbol `%s' is already defined"), name);
3441           *end_name = delim;
3442           ignore_rest_of_line ();
3443           return;
3444         }
3445       symbolP = symbol_clone (symbolP, 1);
3446       S_CLEAR_VOLATILE (symbolP);
3447     }
3448
3449   *end_name = delim;
3450
3451   SKIP_WHITESPACE ();
3452
3453   if (*input_line_pointer != ',')
3454     {
3455       *end_name = 0;
3456       as_bad (_("expected comma after \"%s\""), name);
3457       *end_name = delim;
3458       ignore_rest_of_line ();
3459       return;
3460     }
3461
3462   input_line_pointer++;
3463
3464   SKIP_WHITESPACE ();
3465
3466   name = input_line_pointer;
3467   delim = get_symbol_end ();
3468   end_name = input_line_pointer;
3469
3470   if (name == end_name)
3471     {
3472       as_bad (_("expected symbol name"));
3473       ignore_rest_of_line ();
3474       return;
3475     }
3476
3477   if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3478       && (symbolP2 = md_undefined_symbol (name)) == NULL)
3479     {
3480       symbolP2 = symbol_find_or_make (name);
3481       S_SET_WEAKREFD (symbolP2);
3482     }
3483   else
3484     {
3485       symbolS *symp = symbolP2;
3486
3487       while (S_IS_WEAKREFR (symp) && symp != symbolP)
3488         {
3489           expressionS *expP = symbol_get_value_expression (symp);
3490
3491           assert (expP->X_op == O_symbol
3492                   && expP->X_add_number == 0);
3493           symp = expP->X_add_symbol;
3494         }
3495       if (symp == symbolP)
3496         {
3497           char *loop;
3498
3499           loop = concat (S_GET_NAME (symbolP),
3500                          " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3501
3502           symp = symbolP2;
3503           while (symp != symbolP)
3504             {
3505               char *old_loop = loop;
3506               symp = symbol_get_value_expression (symp)->X_add_symbol;
3507               loop = concat (loop, " => ", S_GET_NAME (symp),
3508                              (const char *) NULL);
3509               free (old_loop);
3510             }
3511
3512           as_bad (_("%s: would close weakref loop: %s"),
3513                   S_GET_NAME (symbolP), loop);
3514
3515           free (loop);
3516
3517           *end_name = delim;
3518           ignore_rest_of_line ();
3519           return;
3520         }
3521
3522       /* Short-circuiting instead of just checking here might speed
3523          things up a tiny little bit, but loop error messages would
3524          miss intermediate links.  */
3525       /* symbolP2 = symp; */
3526     }
3527
3528   *end_name = delim;
3529
3530   memset (&exp, 0, sizeof (exp));
3531   exp.X_op = O_symbol;
3532   exp.X_add_symbol = symbolP2;
3533
3534   S_SET_SEGMENT (symbolP, undefined_section);
3535   symbol_set_value_expression (symbolP, &exp);
3536   symbol_set_frag (symbolP, &zero_address_frag);
3537   S_SET_WEAKREFR (symbolP);
3538
3539   demand_empty_rest_of_line ();
3540 }
3541 \f
3542
3543 /* Verify that we are at the end of a line.  If not, issue an error and
3544    skip to EOL.  */
3545
3546 void
3547 demand_empty_rest_of_line (void)
3548 {
3549   SKIP_WHITESPACE ();
3550   if (is_end_of_line[(unsigned char) *input_line_pointer])
3551     input_line_pointer++;
3552   else
3553     {
3554       if (ISPRINT (*input_line_pointer))
3555         as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3556                  *input_line_pointer);
3557       else
3558         as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3559                  *input_line_pointer);
3560       ignore_rest_of_line ();
3561     }
3562
3563   /* Return pointing just after end-of-line.  */
3564   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3565 }
3566
3567 /* Silently advance to the end of line.  Use this after already having
3568    issued an error about something bad.  */
3569
3570 void
3571 ignore_rest_of_line (void)
3572 {
3573   while (input_line_pointer < buffer_limit
3574          && !is_end_of_line[(unsigned char) *input_line_pointer])
3575     input_line_pointer++;
3576
3577   input_line_pointer++;
3578
3579   /* Return pointing just after end-of-line.  */
3580   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3581 }
3582
3583 /* Sets frag for given symbol to zero_address_frag, except when the
3584    symbol frag is already set to a dummy listing frag.  */
3585
3586 static void
3587 set_zero_frag (symbolS *symbolP)
3588 {
3589   if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3590     symbol_set_frag (symbolP, &zero_address_frag);
3591 }
3592
3593 /* In:  Pointer to a symbol.
3594         Input_line_pointer->expression.
3595
3596    Out: Input_line_pointer->just after any whitespace after expression.
3597         Tried to set symbol to value of expression.
3598         Will change symbols type, value, and frag;  */
3599
3600 void
3601 pseudo_set (symbolS *symbolP)
3602 {
3603   expressionS exp;
3604   segT seg;
3605
3606   know (symbolP);               /* NULL pointer is logic error.  */
3607
3608   if (!S_IS_FORWARD_REF (symbolP))
3609     (void) expression (&exp);
3610   else
3611     (void) deferred_expression (&exp);
3612
3613   if (exp.X_op == O_illegal)
3614     as_bad (_("illegal expression"));
3615   else if (exp.X_op == O_absent)
3616     as_bad (_("missing expression"));
3617   else if (exp.X_op == O_big)
3618     {
3619       if (exp.X_add_number > 0)
3620         as_bad (_("bignum invalid"));
3621       else
3622         as_bad (_("floating point number invalid"));
3623     }
3624   else if (exp.X_op == O_subtract
3625            && !S_IS_FORWARD_REF (symbolP)
3626            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3627            && (symbol_get_frag (exp.X_add_symbol)
3628                == symbol_get_frag (exp.X_op_symbol)))
3629     {
3630       exp.X_op = O_constant;
3631       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3632                           - S_GET_VALUE (exp.X_op_symbol));
3633     }
3634
3635   if (symbol_section_p (symbolP))
3636     {
3637       as_bad ("attempt to set value of section symbol");
3638       return;
3639     }
3640
3641   switch (exp.X_op)
3642     {
3643     case O_illegal:
3644     case O_absent:
3645     case O_big:
3646       exp.X_add_number = 0;
3647       /* Fall through.  */
3648     case O_constant:
3649       S_SET_SEGMENT (symbolP, absolute_section);
3650       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3651       set_zero_frag (symbolP);
3652       break;
3653
3654     case O_register:
3655 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3656       if (S_IS_EXTERNAL (symbolP))
3657         {
3658           as_bad ("can't equate global symbol `%s' with register name",
3659                   S_GET_NAME (symbolP));
3660           return;
3661         }
3662 #endif
3663       S_SET_SEGMENT (symbolP, reg_section);
3664       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3665       set_zero_frag (symbolP);
3666       symbol_get_value_expression (symbolP)->X_op = O_register;
3667       break;
3668
3669     case O_symbol:
3670       seg = S_GET_SEGMENT (exp.X_add_symbol);
3671       /* For x=undef+const, create an expression symbol.
3672          For x=x+const, just update x except when x is an undefined symbol
3673          For x=defined+const, evaluate x.  */
3674       if (symbolP == exp.X_add_symbol
3675           && (seg != undefined_section
3676               || !symbol_constant_p (symbolP)))
3677         {
3678           *symbol_X_add_number (symbolP) += exp.X_add_number;
3679           break;
3680         }
3681       else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3682         {
3683           symbolS *s = exp.X_add_symbol;
3684
3685           if (S_IS_COMMON (s))
3686             as_bad (_("`%s' can't be equated to common symbol '%s'"),
3687                     S_GET_NAME (symbolP), S_GET_NAME (s));
3688
3689           S_SET_SEGMENT (symbolP, seg);
3690           S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3691           symbol_set_frag (symbolP, symbol_get_frag (s));
3692           copy_symbol_attributes (symbolP, s);
3693           break;
3694         }
3695       S_SET_SEGMENT (symbolP, undefined_section);
3696       symbol_set_value_expression (symbolP, &exp);
3697       set_zero_frag (symbolP);
3698       break;
3699
3700     default:
3701       /* The value is some complex expression.  */
3702       S_SET_SEGMENT (symbolP, expr_section);
3703       symbol_set_value_expression (symbolP, &exp);
3704       set_zero_frag (symbolP);
3705       break;
3706     }
3707 }
3708 \f
3709 /*                      cons()
3710
3711    CONStruct more frag of .bytes, or .words etc.
3712    Should need_pass_2 be 1 then emit no frag(s).
3713    This understands EXPRESSIONS.
3714
3715    Bug (?)
3716
3717    This has a split personality. We use expression() to read the
3718    value. We can detect if the value won't fit in a byte or word.
3719    But we can't detect if expression() discarded significant digits
3720    in the case of a long. Not worth the crocks required to fix it.  */
3721
3722 /* Select a parser for cons expressions.  */
3723
3724 /* Some targets need to parse the expression in various fancy ways.
3725    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3726    (for example, the HPPA does this).  Otherwise, you can define
3727    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3728    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3729    are defined, which is the normal case, then only simple expressions
3730    are permitted.  */
3731
3732 #ifdef TC_M68K
3733 static void
3734 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3735 #endif
3736
3737 #ifndef TC_PARSE_CONS_EXPRESSION
3738 #ifdef BITFIELD_CONS_EXPRESSIONS
3739 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3740 static void
3741 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3742 #endif
3743 #ifdef REPEAT_CONS_EXPRESSIONS
3744 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3745 static void
3746 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3747 #endif
3748
3749 /* If we haven't gotten one yet, just call expression.  */
3750 #ifndef TC_PARSE_CONS_EXPRESSION
3751 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3752 #endif
3753 #endif
3754
3755 void
3756 do_parse_cons_expression (expressionS *exp,
3757                           int nbytes ATTRIBUTE_UNUSED)
3758 {
3759   TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3760 }
3761
3762
3763 /* Worker to do .byte etc statements.
3764    Clobbers input_line_pointer and checks end-of-line.  */
3765
3766 static void
3767 cons_worker (register int nbytes,       /* 1=.byte, 2=.word, 4=.long.  */
3768              int rva)
3769 {
3770   int c;
3771   expressionS exp;
3772   char *stop = NULL;
3773   char stopc = 0;
3774
3775 #ifdef md_flush_pending_output
3776   md_flush_pending_output ();
3777 #endif
3778
3779   if (flag_mri)
3780     stop = mri_comment_field (&stopc);
3781
3782   if (is_it_end_of_statement ())
3783     {
3784       demand_empty_rest_of_line ();
3785       if (flag_mri)
3786         mri_comment_end (stop, stopc);
3787       return;
3788     }
3789
3790 #ifdef TC_ADDRESS_BYTES
3791   if (nbytes == 0)
3792     nbytes = TC_ADDRESS_BYTES ();
3793 #endif
3794
3795 #ifdef md_cons_align
3796   md_cons_align (nbytes);
3797 #endif
3798
3799   c = 0;
3800   do
3801     {
3802 #ifdef TC_M68K
3803       if (flag_m68k_mri)
3804         parse_mri_cons (&exp, (unsigned int) nbytes);
3805       else
3806 #endif
3807         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3808
3809       if (rva)
3810         {
3811           if (exp.X_op == O_symbol)
3812             exp.X_op = O_symbol_rva;
3813           else
3814             as_fatal (_("rva without symbol"));
3815         }
3816       emit_expr (&exp, (unsigned int) nbytes);
3817       ++c;
3818     }
3819   while (*input_line_pointer++ == ',');
3820
3821   /* In MRI mode, after an odd number of bytes, we must align to an
3822      even word boundary, unless the next instruction is a dc.b, ds.b
3823      or dcb.b.  */
3824   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3825     mri_pending_align = 1;
3826
3827   input_line_pointer--;         /* Put terminator back into stream.  */
3828
3829   demand_empty_rest_of_line ();
3830
3831   if (flag_mri)
3832     mri_comment_end (stop, stopc);
3833 }
3834
3835 void
3836 cons (int size)
3837 {
3838   cons_worker (size, 0);
3839 }
3840
3841 void
3842 s_rva (int size)
3843 {
3844   cons_worker (size, 1);
3845 }
3846
3847 /* .reloc offset, reloc_name, symbol+addend.  */
3848
3849 void
3850 s_reloc (int ignore ATTRIBUTE_UNUSED)
3851 {
3852   char *stop = NULL;
3853   char stopc = 0;
3854   expressionS exp;
3855   char *r_name;
3856   int c;
3857   struct reloc_list *reloc;
3858
3859   reloc = xmalloc (sizeof (*reloc));
3860
3861   if (flag_mri)
3862     stop = mri_comment_field (&stopc);
3863
3864   expression (&exp);
3865   switch (exp.X_op)
3866     {
3867     case O_illegal:
3868     case O_absent:
3869     case O_big:
3870     case O_register:
3871       as_bad (_("missing or bad offset expression"));
3872       goto err_out;
3873     case O_constant:
3874       exp.X_add_symbol = section_symbol (now_seg);
3875       exp.X_op = O_symbol;
3876       /* Fall thru */
3877     case O_symbol:
3878       if (exp.X_add_number == 0)
3879         {
3880           reloc->u.a.offset_sym = exp.X_add_symbol;
3881           break;
3882         }
3883       /* Fall thru */
3884     default:
3885       reloc->u.a.offset_sym = make_expr_symbol (&exp);
3886       break;
3887     }
3888
3889   SKIP_WHITESPACE ();
3890   if (*input_line_pointer != ',')
3891     {
3892       as_bad (_("missing reloc type"));
3893       goto err_out;
3894     }
3895
3896   ++input_line_pointer;
3897   SKIP_WHITESPACE ();
3898   r_name = input_line_pointer;
3899   c = get_symbol_end ();
3900   reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3901   *input_line_pointer = c;
3902   if (reloc->u.a.howto == NULL)
3903     {
3904       as_bad (_("unrecognized reloc type"));
3905       goto err_out;
3906     }
3907
3908   exp.X_op = O_absent;
3909   SKIP_WHITESPACE ();
3910   if (*input_line_pointer == ',')
3911     {
3912       ++input_line_pointer;
3913       expression_and_evaluate (&exp);
3914     }
3915   switch (exp.X_op)
3916     {
3917     case O_illegal:
3918     case O_big:
3919     case O_register:
3920       as_bad (_("bad reloc expression"));
3921     err_out:
3922       ignore_rest_of_line ();
3923       free (reloc);
3924       if (flag_mri)
3925         mri_comment_end (stop, stopc);
3926       return;
3927     case O_absent:
3928       reloc->u.a.sym = NULL;
3929       reloc->u.a.addend = 0;
3930       break;
3931     case O_constant:
3932       reloc->u.a.sym = NULL;
3933       reloc->u.a.addend = exp.X_add_number;
3934       break;
3935     case O_symbol:
3936       reloc->u.a.sym = exp.X_add_symbol;
3937       reloc->u.a.addend = exp.X_add_number;
3938       break;
3939     default:
3940       reloc->u.a.sym = make_expr_symbol (&exp);
3941       reloc->u.a.addend = 0;
3942       break;
3943     }
3944
3945   as_where (&reloc->file, &reloc->line);
3946   reloc->next = reloc_list;
3947   reloc_list = reloc;
3948
3949   demand_empty_rest_of_line ();
3950   if (flag_mri)
3951     mri_comment_end (stop, stopc);
3952 }
3953
3954 /* Put the contents of expression EXP into the object file using
3955    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
3956
3957 void
3958 emit_expr (expressionS *exp, unsigned int nbytes)
3959 {
3960   operatorT op;
3961   register char *p;
3962   valueT extra_digit = 0;
3963
3964   /* Don't do anything if we are going to make another pass.  */
3965   if (need_pass_2)
3966     return;
3967
3968   /* Grow the current frag now so that dot_value does not get invalidated
3969      if the frag were to fill up in the frag_more() call below.  */
3970   frag_grow (nbytes);
3971   dot_value = frag_now_fix ();
3972
3973 #ifndef NO_LISTING
3974 #ifdef OBJ_ELF
3975   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3976      appear as a four byte positive constant in the .line section,
3977      followed by a 2 byte 0xffff.  Look for that case here.  */
3978   {
3979     static int dwarf_line = -1;
3980
3981     if (strcmp (segment_name (now_seg), ".line") != 0)
3982       dwarf_line = -1;
3983     else if (dwarf_line >= 0
3984              && nbytes == 2
3985              && exp->X_op == O_constant
3986              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3987       listing_source_line ((unsigned int) dwarf_line);
3988     else if (nbytes == 4
3989              && exp->X_op == O_constant
3990              && exp->X_add_number >= 0)
3991       dwarf_line = exp->X_add_number;
3992     else
3993       dwarf_line = -1;
3994   }
3995
3996   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3997      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3998      AT_sibling (0x12) followed by a four byte address of the sibling
3999      followed by a 2 byte AT_name (0x38) followed by the name of the
4000      file.  We look for that case here.  */
4001   {
4002     static int dwarf_file = 0;
4003
4004     if (strcmp (segment_name (now_seg), ".debug") != 0)
4005       dwarf_file = 0;
4006     else if (dwarf_file == 0
4007              && nbytes == 2
4008              && exp->X_op == O_constant
4009              && exp->X_add_number == 0x11)
4010       dwarf_file = 1;
4011     else if (dwarf_file == 1
4012              && nbytes == 2
4013              && exp->X_op == O_constant
4014              && exp->X_add_number == 0x12)
4015       dwarf_file = 2;
4016     else if (dwarf_file == 2
4017              && nbytes == 4)
4018       dwarf_file = 3;
4019     else if (dwarf_file == 3
4020              && nbytes == 2
4021              && exp->X_op == O_constant
4022              && exp->X_add_number == 0x38)
4023       dwarf_file = 4;
4024     else
4025       dwarf_file = 0;
4026
4027     /* The variable dwarf_file_string tells stringer that the string
4028        may be the name of the source file.  */
4029     if (dwarf_file == 4)
4030       dwarf_file_string = 1;
4031     else
4032       dwarf_file_string = 0;
4033   }
4034 #endif
4035 #endif
4036
4037   if (check_eh_frame (exp, &nbytes))
4038     return;
4039
4040   op = exp->X_op;
4041
4042   /* Allow `.word 0' in the absolute section.  */
4043   if (now_seg == absolute_section)
4044     {
4045       if (op != O_constant || exp->X_add_number != 0)
4046         as_bad (_("attempt to store value in absolute section"));
4047       abs_section_offset += nbytes;
4048       return;
4049     }
4050
4051   /* Handle a negative bignum.  */
4052   if (op == O_uminus
4053       && exp->X_add_number == 0
4054       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4055       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4056     {
4057       int i;
4058       unsigned long carry;
4059
4060       exp = symbol_get_value_expression (exp->X_add_symbol);
4061
4062       /* Negate the bignum: one's complement each digit and add 1.  */
4063       carry = 1;
4064       for (i = 0; i < exp->X_add_number; i++)
4065         {
4066           unsigned long next;
4067
4068           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4069                    & LITTLENUM_MASK)
4070                   + carry);
4071           generic_bignum[i] = next & LITTLENUM_MASK;
4072           carry = next >> LITTLENUM_NUMBER_OF_BITS;
4073         }
4074
4075       /* We can ignore any carry out, because it will be handled by
4076          extra_digit if it is needed.  */
4077
4078       extra_digit = (valueT) -1;
4079       op = O_big;
4080     }
4081
4082   if (op == O_absent || op == O_illegal)
4083     {
4084       as_warn (_("zero assumed for missing expression"));
4085       exp->X_add_number = 0;
4086       op = O_constant;
4087     }
4088   else if (op == O_big && exp->X_add_number <= 0)
4089     {
4090       as_bad (_("floating point number invalid"));
4091       exp->X_add_number = 0;
4092       op = O_constant;
4093     }
4094   else if (op == O_register)
4095     {
4096       as_warn (_("register value used as expression"));
4097       op = O_constant;
4098     }
4099
4100   p = frag_more ((int) nbytes);
4101
4102 #ifndef WORKING_DOT_WORD
4103   /* If we have the difference of two symbols in a word, save it on
4104      the broken_words list.  See the code in write.c.  */
4105   if (op == O_subtract && nbytes == 2)
4106     {
4107       struct broken_word *x;
4108
4109       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4110       x->next_broken_word = broken_words;
4111       broken_words = x;
4112       x->seg = now_seg;
4113       x->subseg = now_subseg;
4114       x->frag = frag_now;
4115       x->word_goes_here = p;
4116       x->dispfrag = 0;
4117       x->add = exp->X_add_symbol;
4118       x->sub = exp->X_op_symbol;
4119       x->addnum = exp->X_add_number;
4120       x->added = 0;
4121       x->use_jump = 0;
4122       new_broken_words++;
4123       return;
4124     }
4125 #endif
4126
4127   /* If we have an integer, but the number of bytes is too large to
4128      pass to md_number_to_chars, handle it as a bignum.  */
4129   if (op == O_constant && nbytes > sizeof (valueT))
4130     {
4131       extra_digit = exp->X_unsigned ? 0 : -1;
4132       convert_to_bignum (exp);
4133       op = O_big;
4134     }
4135
4136   if (op == O_constant)
4137     {
4138       register valueT get;
4139       register valueT use;
4140       register valueT mask;
4141       valueT hibit;
4142       register valueT unmask;
4143
4144       /* JF << of >= number of bits in the object is undefined.  In
4145          particular SPARC (Sun 4) has problems.  */
4146       if (nbytes >= sizeof (valueT))
4147         {
4148           mask = 0;
4149           if (nbytes > sizeof (valueT))
4150             hibit = 0;
4151           else
4152             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4153         }
4154       else
4155         {
4156           /* Don't store these bits.  */
4157           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4158           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4159         }
4160
4161       unmask = ~mask;           /* Do store these bits.  */
4162
4163 #ifdef NEVER
4164       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4165       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
4166 #endif
4167
4168       get = exp->X_add_number;
4169       use = get & unmask;
4170       if ((get & mask) != 0
4171           && ((get & mask) != mask
4172               || (get & hibit) == 0))
4173         {               /* Leading bits contain both 0s & 1s.  */
4174 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4175 #ifndef __MSVCRT__
4176           as_warn (_("value 0x%llx truncated to 0x%llx"),
4177                    (unsigned long long) get, (unsigned long long) use);
4178 #else
4179           as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4180                    (unsigned long long) get, (unsigned long long) use);
4181 #endif
4182 #else
4183           as_warn (_("value 0x%lx truncated to 0x%lx"),
4184                    (unsigned long) get, (unsigned long) use);
4185 #endif
4186         }
4187       /* Put bytes in right order.  */
4188       md_number_to_chars (p, use, (int) nbytes);
4189     }
4190   else if (op == O_big)
4191     {
4192       unsigned int size;
4193       LITTLENUM_TYPE *nums;
4194
4195       know (nbytes % CHARS_PER_LITTLENUM == 0);
4196
4197       size = exp->X_add_number * CHARS_PER_LITTLENUM;
4198       if (nbytes < size)
4199         {
4200           as_warn (_("bignum truncated to %d bytes"), nbytes);
4201           size = nbytes;
4202         }
4203
4204       if (target_big_endian)
4205         {
4206           while (nbytes > size)
4207             {
4208               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4209               nbytes -= CHARS_PER_LITTLENUM;
4210               p += CHARS_PER_LITTLENUM;
4211             }
4212
4213           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4214           while (size >= CHARS_PER_LITTLENUM)
4215             {
4216               --nums;
4217               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4218               size -= CHARS_PER_LITTLENUM;
4219               p += CHARS_PER_LITTLENUM;
4220             }
4221         }
4222       else
4223         {
4224           nums = generic_bignum;
4225           while (size >= CHARS_PER_LITTLENUM)
4226             {
4227               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4228               ++nums;
4229               size -= CHARS_PER_LITTLENUM;
4230               p += CHARS_PER_LITTLENUM;
4231               nbytes -= CHARS_PER_LITTLENUM;
4232             }
4233
4234           while (nbytes >= CHARS_PER_LITTLENUM)
4235             {
4236               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4237               nbytes -= CHARS_PER_LITTLENUM;
4238               p += CHARS_PER_LITTLENUM;
4239             }
4240         }
4241     }
4242   else
4243     emit_expr_fix (exp, nbytes, frag_now, p);
4244 }
4245
4246 void
4247 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4248 {
4249   memset (p, 0, nbytes);
4250
4251   /* Generate a fixS to record the symbol value.  */
4252
4253 #ifdef TC_CONS_FIX_NEW
4254   TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4255 #else
4256   {
4257     bfd_reloc_code_real_type r;
4258
4259     switch (nbytes)
4260       {
4261       case 1:
4262         r = BFD_RELOC_8;
4263         break;
4264       case 2:
4265         r = BFD_RELOC_16;
4266         break;
4267       case 4:
4268         r = BFD_RELOC_32;
4269         break;
4270       case 8:
4271         r = BFD_RELOC_64;
4272         break;
4273       default:
4274         as_bad (_("unsupported BFD relocation size %u"), nbytes);
4275         r = BFD_RELOC_32;
4276         break;
4277       }
4278     fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4279                  0, r);
4280   }
4281 #endif
4282 }
4283 \f
4284 #ifdef BITFIELD_CONS_EXPRESSIONS
4285
4286 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4287    w:x,y:z, where w and y are bitwidths and x and y are values.  They
4288    then pack them all together. We do a little better in that we allow
4289    them in words, longs, etc. and we'll pack them in target byte order
4290    for you.
4291
4292    The rules are: pack least significant bit first, if a field doesn't
4293    entirely fit, put it in the next unit.  Overflowing the bitfield is
4294    explicitly *not* even a warning.  The bitwidth should be considered
4295    a "mask".
4296
4297    To use this function the tc-XXX.h file should define
4298    BITFIELD_CONS_EXPRESSIONS.  */
4299
4300 static void
4301 parse_bitfield_cons (exp, nbytes)
4302      expressionS *exp;
4303      unsigned int nbytes;
4304 {
4305   unsigned int bits_available = BITS_PER_CHAR * nbytes;
4306   char *hold = input_line_pointer;
4307
4308   (void) expression (exp);
4309
4310   if (*input_line_pointer == ':')
4311     {
4312       /* Bitfields.  */
4313       long value = 0;
4314
4315       for (;;)
4316         {
4317           unsigned long width;
4318
4319           if (*input_line_pointer != ':')
4320             {
4321               input_line_pointer = hold;
4322               break;
4323             }                   /* Next piece is not a bitfield.  */
4324
4325           /* In the general case, we can't allow
4326              full expressions with symbol
4327              differences and such.  The relocation
4328              entries for symbols not defined in this
4329              assembly would require arbitrary field
4330              widths, positions, and masks which most
4331              of our current object formats don't
4332              support.
4333
4334              In the specific case where a symbol
4335              *is* defined in this assembly, we
4336              *could* build fixups and track it, but
4337              this could lead to confusion for the
4338              backends.  I'm lazy. I'll take any
4339              SEG_ABSOLUTE. I think that means that
4340              you can use a previous .set or
4341              .equ type symbol.  xoxorich.  */
4342
4343           if (exp->X_op == O_absent)
4344             {
4345               as_warn (_("using a bit field width of zero"));
4346               exp->X_add_number = 0;
4347               exp->X_op = O_constant;
4348             }                   /* Implied zero width bitfield.  */
4349
4350           if (exp->X_op != O_constant)
4351             {
4352               *input_line_pointer = '\0';
4353               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4354               *input_line_pointer = ':';
4355               demand_empty_rest_of_line ();
4356               return;
4357             }                   /* Too complex.  */
4358
4359           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4360             {
4361               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4362                        width, nbytes, (BITS_PER_CHAR * nbytes));
4363               width = BITS_PER_CHAR * nbytes;
4364             }                   /* Too big.  */
4365
4366           if (width > bits_available)
4367             {
4368               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
4369               input_line_pointer = hold;
4370               exp->X_add_number = value;
4371               break;
4372             }                   /* Won't fit.  */
4373
4374           /* Skip ':'.  */
4375           hold = ++input_line_pointer;
4376
4377           (void) expression (exp);
4378           if (exp->X_op != O_constant)
4379             {
4380               char cache = *input_line_pointer;
4381
4382               *input_line_pointer = '\0';
4383               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4384               *input_line_pointer = cache;
4385               demand_empty_rest_of_line ();
4386               return;
4387             }                   /* Too complex.  */
4388
4389           value |= ((~(-1 << width) & exp->X_add_number)
4390                     << ((BITS_PER_CHAR * nbytes) - bits_available));
4391
4392           if ((bits_available -= width) == 0
4393               || is_it_end_of_statement ()
4394               || *input_line_pointer != ',')
4395             {
4396               break;
4397             }                   /* All the bitfields we're gonna get.  */
4398
4399           hold = ++input_line_pointer;
4400           (void) expression (exp);
4401         }
4402
4403       exp->X_add_number = value;
4404       exp->X_op = O_constant;
4405       exp->X_unsigned = 1;
4406     }
4407 }
4408
4409 #endif /* BITFIELD_CONS_EXPRESSIONS */
4410 \f
4411 /* Handle an MRI style string expression.  */
4412
4413 #ifdef TC_M68K
4414 static void
4415 parse_mri_cons (exp, nbytes)
4416      expressionS *exp;
4417      unsigned int nbytes;
4418 {
4419   if (*input_line_pointer != '\''
4420       && (input_line_pointer[1] != '\''
4421           || (*input_line_pointer != 'A'
4422               && *input_line_pointer != 'E')))
4423     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4424   else
4425     {
4426       unsigned int scan;
4427       unsigned int result = 0;
4428
4429       /* An MRI style string.  Cut into as many bytes as will fit into
4430          a nbyte chunk, left justify if necessary, and separate with
4431          commas so we can try again later.  */
4432       if (*input_line_pointer == 'A')
4433         ++input_line_pointer;
4434       else if (*input_line_pointer == 'E')
4435         {
4436           as_bad (_("EBCDIC constants are not supported"));
4437           ++input_line_pointer;
4438         }
4439
4440       input_line_pointer++;
4441       for (scan = 0; scan < nbytes; scan++)
4442         {
4443           if (*input_line_pointer == '\'')
4444             {
4445               if (input_line_pointer[1] == '\'')
4446                 {
4447                   input_line_pointer++;
4448                 }
4449               else
4450                 break;
4451             }
4452           result = (result << 8) | (*input_line_pointer++);
4453         }
4454
4455       /* Left justify.  */
4456       while (scan < nbytes)
4457         {
4458           result <<= 8;
4459           scan++;
4460         }
4461
4462       /* Create correct expression.  */
4463       exp->X_op = O_constant;
4464       exp->X_add_number = result;
4465
4466       /* Fake it so that we can read the next char too.  */
4467       if (input_line_pointer[0] != '\'' ||
4468           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4469         {
4470           input_line_pointer -= 2;
4471           input_line_pointer[0] = ',';
4472           input_line_pointer[1] = '\'';
4473         }
4474       else
4475         input_line_pointer++;
4476     }
4477 }
4478 #endif /* TC_M68K */
4479 \f
4480 #ifdef REPEAT_CONS_EXPRESSIONS
4481
4482 /* Parse a repeat expression for cons.  This is used by the MIPS
4483    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
4484    object file COUNT times.
4485
4486    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
4487
4488 static void
4489 parse_repeat_cons (exp, nbytes)
4490      expressionS *exp;
4491      unsigned int nbytes;
4492 {
4493   expressionS count;
4494   register int i;
4495
4496   expression (exp);
4497
4498   if (*input_line_pointer != ':')
4499     {
4500       /* No repeat count.  */
4501       return;
4502     }
4503
4504   ++input_line_pointer;
4505   expression (&count);
4506   if (count.X_op != O_constant
4507       || count.X_add_number <= 0)
4508     {
4509       as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4510       return;
4511     }
4512
4513   /* The cons function is going to output this expression once.  So we
4514      output it count - 1 times.  */
4515   for (i = count.X_add_number - 1; i > 0; i--)
4516     emit_expr (exp, nbytes);
4517 }
4518
4519 #endif /* REPEAT_CONS_EXPRESSIONS */
4520 \f
4521 /* Parse a floating point number represented as a hex constant.  This
4522    permits users to specify the exact bits they want in the floating
4523    point number.  */
4524
4525 static int
4526 hex_float (int float_type, char *bytes)
4527 {
4528   int length;
4529   int i;
4530
4531   switch (float_type)
4532     {
4533     case 'f':
4534     case 'F':
4535     case 's':
4536     case 'S':
4537       length = 4;
4538       break;
4539
4540     case 'd':
4541     case 'D':
4542     case 'r':
4543     case 'R':
4544       length = 8;
4545       break;
4546
4547     case 'x':
4548     case 'X':
4549       length = 12;
4550       break;
4551
4552     case 'p':
4553     case 'P':
4554       length = 12;
4555       break;
4556
4557     default:
4558       as_bad (_("unknown floating type type '%c'"), float_type);
4559       return -1;
4560     }
4561
4562   /* It would be nice if we could go through expression to parse the
4563      hex constant, but if we get a bignum it's a pain to sort it into
4564      the buffer correctly.  */
4565   i = 0;
4566   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4567     {
4568       int d;
4569
4570       /* The MRI assembler accepts arbitrary underscores strewn about
4571          through the hex constant, so we ignore them as well.  */
4572       if (*input_line_pointer == '_')
4573         {
4574           ++input_line_pointer;
4575           continue;
4576         }
4577
4578       if (i >= length)
4579         {
4580           as_warn (_("floating point constant too large"));
4581           return -1;
4582         }
4583       d = hex_value (*input_line_pointer) << 4;
4584       ++input_line_pointer;
4585       while (*input_line_pointer == '_')
4586         ++input_line_pointer;
4587       if (hex_p (*input_line_pointer))
4588         {
4589           d += hex_value (*input_line_pointer);
4590           ++input_line_pointer;
4591         }
4592       if (target_big_endian)
4593         bytes[i] = d;
4594       else
4595         bytes[length - i - 1] = d;
4596       ++i;
4597     }
4598
4599   if (i < length)
4600     {
4601       if (target_big_endian)
4602         memset (bytes + i, 0, length - i);
4603       else
4604         memset (bytes, 0, length - i);
4605     }
4606
4607   return length;
4608 }
4609
4610 /*                      float_cons()
4611
4612    CONStruct some more frag chars of .floats .ffloats etc.
4613    Makes 0 or more new frags.
4614    If need_pass_2 == 1, no frags are emitted.
4615    This understands only floating literals, not expressions. Sorry.
4616
4617    A floating constant is defined by atof_generic(), except it is preceded
4618    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4619    reading, I decided to be incompatible. This always tries to give you
4620    rounded bits to the precision of the pseudo-op. Former AS did premature
4621    truncation, restored noisy bits instead of trailing 0s AND gave you
4622    a choice of 2 flavours of noise according to which of 2 floating-point
4623    scanners you directed AS to use.
4624
4625    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
4626
4627 void
4628 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
4629             register int float_type     /* 'f':.ffloat ... 'F':.float ...  */)
4630 {
4631   register char *p;
4632   int length;                   /* Number of chars in an object.  */
4633   register char *err;           /* Error from scanning floating literal.  */
4634   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4635
4636   if (is_it_end_of_statement ())
4637     {
4638       demand_empty_rest_of_line ();
4639       return;
4640     }
4641
4642 #ifdef md_flush_pending_output
4643   md_flush_pending_output ();
4644 #endif
4645
4646 #ifdef md_cons_align
4647   md_cons_align (1);
4648 #endif
4649
4650   do
4651     {
4652       /* input_line_pointer->1st char of a flonum (we hope!).  */
4653       SKIP_WHITESPACE ();
4654
4655       /* Skip any 0{letter} that may be present. Don't even check if the
4656          letter is legal. Someone may invent a "z" format and this routine
4657          has no use for such information. Lusers beware: you get
4658          diagnostics if your input is ill-conditioned.  */
4659       if (input_line_pointer[0] == '0'
4660           && ISALPHA (input_line_pointer[1]))
4661         input_line_pointer += 2;
4662
4663       /* Accept :xxxx, where the x's are hex digits, for a floating
4664          point with the exact digits specified.  */
4665       if (input_line_pointer[0] == ':')
4666         {
4667           ++input_line_pointer;
4668           length = hex_float (float_type, temp);
4669           if (length < 0)
4670             {
4671               ignore_rest_of_line ();
4672               return;
4673             }
4674         }
4675       else
4676         {
4677           err = md_atof (float_type, temp, &length);
4678           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4679           know (err != NULL || length > 0);
4680           if (err)
4681             {
4682               as_bad (_("bad floating literal: %s"), err);
4683               ignore_rest_of_line ();
4684               return;
4685             }
4686         }
4687
4688       if (!need_pass_2)
4689         {
4690           int count;
4691
4692           count = 1;
4693
4694 #ifdef REPEAT_CONS_EXPRESSIONS
4695           if (*input_line_pointer == ':')
4696             {
4697               expressionS count_exp;
4698
4699               ++input_line_pointer;
4700               expression (&count_exp);
4701
4702               if (count_exp.X_op != O_constant
4703                   || count_exp.X_add_number <= 0)
4704                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4705               else
4706                 count = count_exp.X_add_number;
4707             }
4708 #endif
4709
4710           while (--count >= 0)
4711             {
4712               p = frag_more (length);
4713               memcpy (p, temp, (unsigned int) length);
4714             }
4715         }
4716       SKIP_WHITESPACE ();
4717     }
4718   while (*input_line_pointer++ == ',');
4719
4720   /* Put terminator back into stream.  */
4721   --input_line_pointer;
4722   demand_empty_rest_of_line ();
4723 }
4724 \f
4725 /* Return the size of a LEB128 value.  */
4726
4727 static inline int
4728 sizeof_sleb128 (offsetT value)
4729 {
4730   register int size = 0;
4731   register unsigned byte;
4732
4733   do
4734     {
4735       byte = (value & 0x7f);
4736       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4737          Fortunately, we can structure things so that the extra work reduces
4738          to a noop on systems that do things "properly".  */
4739       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4740       size += 1;
4741     }
4742   while (!(((value == 0) && ((byte & 0x40) == 0))
4743            || ((value == -1) && ((byte & 0x40) != 0))));
4744
4745   return size;
4746 }
4747
4748 static inline int
4749 sizeof_uleb128 (valueT value)
4750 {
4751   register int size = 0;
4752   register unsigned byte;
4753
4754   do
4755     {
4756       byte = (value & 0x7f);
4757       value >>= 7;
4758       size += 1;
4759     }
4760   while (value != 0);
4761
4762   return size;
4763 }
4764
4765 int
4766 sizeof_leb128 (valueT value, int sign)
4767 {
4768   if (sign)
4769     return sizeof_sleb128 ((offsetT) value);
4770   else
4771     return sizeof_uleb128 (value);
4772 }
4773
4774 /* Output a LEB128 value.  */
4775
4776 static inline int
4777 output_sleb128 (char *p, offsetT value)
4778 {
4779   register char *orig = p;
4780   register int more;
4781
4782   do
4783     {
4784       unsigned byte = (value & 0x7f);
4785
4786       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4787          Fortunately, we can structure things so that the extra work reduces
4788          to a noop on systems that do things "properly".  */
4789       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4790
4791       more = !((((value == 0) && ((byte & 0x40) == 0))
4792                 || ((value == -1) && ((byte & 0x40) != 0))));
4793       if (more)
4794         byte |= 0x80;
4795
4796       *p++ = byte;
4797     }
4798   while (more);
4799
4800   return p - orig;
4801 }
4802
4803 static inline int
4804 output_uleb128 (char *p, valueT value)
4805 {
4806   char *orig = p;
4807
4808   do
4809     {
4810       unsigned byte = (value & 0x7f);
4811       value >>= 7;
4812       if (value != 0)
4813         /* More bytes to follow.  */
4814         byte |= 0x80;
4815
4816       *p++ = byte;
4817     }
4818   while (value != 0);
4819
4820   return p - orig;
4821 }
4822
4823 int
4824 output_leb128 (char *p, valueT value, int sign)
4825 {
4826   if (sign)
4827     return output_sleb128 (p, (offsetT) value);
4828   else
4829     return output_uleb128 (p, value);
4830 }
4831
4832 /* Do the same for bignums.  We combine sizeof with output here in that
4833    we don't output for NULL values of P.  It isn't really as critical as
4834    for "normal" values that this be streamlined.  */
4835
4836 static inline int
4837 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4838 {
4839   char *orig = p;
4840   valueT val = 0;
4841   int loaded = 0;
4842   unsigned byte;
4843
4844   /* Strip leading sign extensions off the bignum.  */
4845   while (size > 1
4846          && bignum[size - 1] == LITTLENUM_MASK
4847          && bignum[size - 2] > LITTLENUM_MASK / 2)
4848     size--;
4849
4850   do
4851     {
4852       /* OR in the next part of the littlenum.  */
4853       val |= (*bignum << loaded);
4854       loaded += LITTLENUM_NUMBER_OF_BITS;
4855       size--;
4856       bignum++;
4857
4858       /* Add bytes until there are less than 7 bits left in VAL
4859          or until every non-sign bit has been written.  */
4860       do
4861         {
4862           byte = val & 0x7f;
4863           loaded -= 7;
4864           val >>= 7;
4865           if (size > 0
4866               || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4867             byte |= 0x80;
4868
4869           if (orig)
4870             *p = byte;
4871           p++;
4872         }
4873       while ((byte & 0x80) != 0 && loaded >= 7);
4874     }
4875   while (size > 0);
4876
4877   /* Mop up any left-over bits (of which there will be less than 7).  */
4878   if ((byte & 0x80) != 0)
4879     {
4880       /* Sign-extend VAL.  */
4881       if (val & (1 << (loaded - 1)))
4882         val |= ~0 << loaded;
4883       if (orig)
4884         *p = val & 0x7f;
4885       p++;
4886     }
4887
4888   return p - orig;
4889 }
4890
4891 static inline int
4892 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4893 {
4894   char *orig = p;
4895   valueT val = 0;
4896   int loaded = 0;
4897   unsigned byte;
4898
4899   /* Strip leading zeros off the bignum.  */
4900   /* XXX: Is this needed?  */
4901   while (size > 0 && bignum[size - 1] == 0)
4902     size--;
4903
4904   do
4905     {
4906       if (loaded < 7 && size > 0)
4907         {
4908           val |= (*bignum << loaded);
4909           loaded += 8 * CHARS_PER_LITTLENUM;
4910           size--;
4911           bignum++;
4912         }
4913
4914       byte = val & 0x7f;
4915       loaded -= 7;
4916       val >>= 7;
4917
4918       if (size > 0 || val)
4919         byte |= 0x80;
4920
4921       if (orig)
4922         *p = byte;
4923       p++;
4924     }
4925   while (byte & 0x80);
4926
4927   return p - orig;
4928 }
4929
4930 static int
4931 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4932 {
4933   if (sign)
4934     return output_big_sleb128 (p, bignum, size);
4935   else
4936     return output_big_uleb128 (p, bignum, size);
4937 }
4938
4939 /* Generate the appropriate fragments for a given expression to emit a
4940    leb128 value.  */
4941
4942 static void
4943 emit_leb128_expr (expressionS *exp, int sign)
4944 {
4945   operatorT op = exp->X_op;
4946   unsigned int nbytes;
4947
4948   if (op == O_absent || op == O_illegal)
4949     {
4950       as_warn (_("zero assumed for missing expression"));
4951       exp->X_add_number = 0;
4952       op = O_constant;
4953     }
4954   else if (op == O_big && exp->X_add_number <= 0)
4955     {
4956       as_bad (_("floating point number invalid"));
4957       exp->X_add_number = 0;
4958       op = O_constant;
4959     }
4960   else if (op == O_register)
4961     {
4962       as_warn (_("register value used as expression"));
4963       op = O_constant;
4964     }
4965   else if (op == O_constant
4966            && sign
4967            && (exp->X_add_number < 0) != !exp->X_unsigned)
4968     {
4969       /* We're outputting a signed leb128 and the sign of X_add_number
4970          doesn't reflect the sign of the original value.  Convert EXP
4971          to a correctly-extended bignum instead.  */
4972       convert_to_bignum (exp);
4973       op = O_big;
4974     }
4975
4976   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
4977      a signal that this is leb128 data.  It shouldn't optimize this away.  */
4978   nbytes = (unsigned int) -1;
4979   if (check_eh_frame (exp, &nbytes))
4980     abort ();
4981
4982   /* Let the backend know that subsequent data may be byte aligned.  */
4983 #ifdef md_cons_align
4984   md_cons_align (1);
4985 #endif
4986
4987   if (op == O_constant)
4988     {
4989       /* If we've got a constant, emit the thing directly right now.  */
4990
4991       valueT value = exp->X_add_number;
4992       int size;
4993       char *p;
4994
4995       size = sizeof_leb128 (value, sign);
4996       p = frag_more (size);
4997       output_leb128 (p, value, sign);
4998     }
4999   else if (op == O_big)
5000     {
5001       /* O_big is a different sort of constant.  */
5002
5003       int size;
5004       char *p;
5005
5006       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5007       p = frag_more (size);
5008       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5009     }
5010   else
5011     {
5012       /* Otherwise, we have to create a variable sized fragment and
5013          resolve things later.  */
5014
5015       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5016                 make_expr_symbol (exp), 0, (char *) NULL);
5017     }
5018 }
5019
5020 /* Parse the .sleb128 and .uleb128 pseudos.  */
5021
5022 void
5023 s_leb128 (int sign)
5024 {
5025   expressionS exp;
5026
5027 #ifdef md_flush_pending_output
5028   md_flush_pending_output ();
5029 #endif
5030
5031   do
5032     {
5033       expression (&exp);
5034       emit_leb128_expr (&exp, sign);
5035     }
5036   while (*input_line_pointer++ == ',');
5037
5038   input_line_pointer--;
5039   demand_empty_rest_of_line ();
5040 }
5041 \f
5042 static void
5043 stringer_append_char (int c, int bitsize)
5044 {
5045   if (!target_big_endian)
5046     FRAG_APPEND_1_CHAR (c);
5047
5048   switch (bitsize)
5049     {
5050     case 64:
5051       FRAG_APPEND_1_CHAR (0);
5052       FRAG_APPEND_1_CHAR (0);
5053       FRAG_APPEND_1_CHAR (0);
5054       FRAG_APPEND_1_CHAR (0);
5055       /* Fall through.  */
5056     case 32:
5057       FRAG_APPEND_1_CHAR (0);
5058       FRAG_APPEND_1_CHAR (0);
5059       /* Fall through.  */
5060     case 16:
5061       FRAG_APPEND_1_CHAR (0);
5062       /* Fall through.  */
5063     case 8:
5064       break;
5065     default:
5066       /* Called with invalid bitsize argument.  */
5067       abort ();
5068       break;
5069     }
5070   if (target_big_endian)
5071     FRAG_APPEND_1_CHAR (c);
5072 }
5073
5074 /* Worker to do .ascii etc statements.
5075    Reads 0 or more ',' separated, double-quoted strings.
5076    Caller should have checked need_pass_2 is FALSE because we don't
5077    check it.
5078    Checks for end-of-line.
5079    BITS_APPENDZERO says how many bits are in a target char.
5080    The bottom bit is set if a NUL char should be appended to the strings.  */
5081
5082 void
5083 stringer (int bits_appendzero)
5084 {
5085   const int bitsize = bits_appendzero & ~7;
5086   const int append_zero = bits_appendzero & 1;
5087   unsigned int c;
5088   char *start;
5089
5090 #ifdef md_flush_pending_output
5091   md_flush_pending_output ();
5092 #endif
5093
5094 #ifdef md_cons_align
5095   md_cons_align (1);
5096 #endif
5097
5098   /* The following awkward logic is to parse ZERO or more strings,
5099      comma separated. Recall a string expression includes spaces
5100      before the opening '\"' and spaces after the closing '\"'.
5101      We fake a leading ',' if there is (supposed to be)
5102      a 1st, expression. We keep demanding expressions for each ','.  */
5103   if (is_it_end_of_statement ())
5104     {
5105       c = 0;                    /* Skip loop.  */
5106       ++input_line_pointer;     /* Compensate for end of loop.  */
5107     }
5108   else
5109     {
5110       c = ',';                  /* Do loop.  */
5111     }
5112   /* If we have been switched into the abs_section then we
5113      will not have an obstack onto which we can hang strings.  */
5114   if (now_seg == absolute_section)
5115     {
5116       as_bad (_("strings must be placed into a section"));
5117       c = 0;
5118       ignore_rest_of_line ();
5119     }
5120
5121   while (c == ',' || c == '<' || c == '"')
5122     {
5123       SKIP_WHITESPACE ();
5124       switch (*input_line_pointer)
5125         {
5126         case '\"':
5127           ++input_line_pointer; /*->1st char of string.  */
5128           start = input_line_pointer;
5129
5130           while (is_a_char (c = next_char_of_string ()))
5131             stringer_append_char (c, bitsize);
5132
5133           if (append_zero)
5134             stringer_append_char (0, bitsize);
5135
5136           know (input_line_pointer[-1] == '\"');
5137
5138 #ifndef NO_LISTING
5139 #ifdef OBJ_ELF
5140           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5141              will emit .string with a filename in the .debug section
5142              after a sequence of constants.  See the comment in
5143              emit_expr for the sequence.  emit_expr will set
5144              dwarf_file_string to non-zero if this string might be a
5145              source file name.  */
5146           if (strcmp (segment_name (now_seg), ".debug") != 0)
5147             dwarf_file_string = 0;
5148           else if (dwarf_file_string)
5149             {
5150               c = input_line_pointer[-1];
5151               input_line_pointer[-1] = '\0';
5152               listing_source_file (start);
5153               input_line_pointer[-1] = c;
5154             }
5155 #endif
5156 #endif
5157
5158           break;
5159         case '<':
5160           input_line_pointer++;
5161           c = get_single_number ();
5162           stringer_append_char (c, bitsize);
5163           if (*input_line_pointer != '>')
5164             as_bad (_("expected <nn>"));
5165
5166           input_line_pointer++;
5167           break;
5168         case ',':
5169           input_line_pointer++;
5170           break;
5171         }
5172       SKIP_WHITESPACE ();
5173       c = *input_line_pointer;
5174     }
5175
5176   demand_empty_rest_of_line ();
5177 }
5178 \f
5179 /* FIXME-SOMEDAY: I had trouble here on characters with the
5180     high bits set.  We'll probably also have trouble with
5181     multibyte chars, wide chars, etc.  Also be careful about
5182     returning values bigger than 1 byte.  xoxorich.  */
5183
5184 unsigned int
5185 next_char_of_string (void)
5186 {
5187   register unsigned int c;
5188
5189   c = *input_line_pointer++ & CHAR_MASK;
5190   switch (c)
5191     {
5192     case '\"':
5193       c = NOT_A_CHAR;
5194       break;
5195
5196     case '\n':
5197       as_warn (_("unterminated string; newline inserted"));
5198       bump_line_counters ();
5199       break;
5200
5201 #ifndef NO_STRING_ESCAPES
5202     case '\\':
5203       switch (c = *input_line_pointer++)
5204         {
5205         case 'b':
5206           c = '\b';
5207           break;
5208
5209         case 'f':
5210           c = '\f';
5211           break;
5212
5213         case 'n':
5214           c = '\n';
5215           break;
5216
5217         case 'r':
5218           c = '\r';
5219           break;
5220
5221         case 't':
5222           c = '\t';
5223           break;
5224
5225         case 'v':
5226           c = '\013';
5227           break;
5228
5229         case '\\':
5230         case '"':
5231           break;                /* As itself.  */
5232
5233         case '0':
5234         case '1':
5235         case '2':
5236         case '3':
5237         case '4':
5238         case '5':
5239         case '6':
5240         case '7':
5241         case '8':
5242         case '9':
5243           {
5244             long number;
5245             int i;
5246
5247             for (i = 0, number = 0;
5248                  ISDIGIT (c) && i < 3;
5249                  c = *input_line_pointer++, i++)
5250               {
5251                 number = number * 8 + c - '0';
5252               }
5253
5254             c = number & 0xff;
5255           }
5256           --input_line_pointer;
5257           break;
5258
5259         case 'x':
5260         case 'X':
5261           {
5262             long number;
5263
5264             number = 0;
5265             c = *input_line_pointer++;
5266             while (ISXDIGIT (c))
5267               {
5268                 if (ISDIGIT (c))
5269                   number = number * 16 + c - '0';
5270                 else if (ISUPPER (c))
5271                   number = number * 16 + c - 'A' + 10;
5272                 else
5273                   number = number * 16 + c - 'a' + 10;
5274                 c = *input_line_pointer++;
5275               }
5276             c = number & 0xff;
5277             --input_line_pointer;
5278           }
5279           break;
5280
5281         case '\n':
5282           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
5283           as_warn (_("unterminated string; newline inserted"));
5284           c = '\n';
5285           bump_line_counters ();
5286           break;
5287
5288         default:
5289
5290 #ifdef ONLY_STANDARD_ESCAPES
5291           as_bad (_("bad escaped character in string"));
5292           c = '?';
5293 #endif /* ONLY_STANDARD_ESCAPES */
5294
5295           break;
5296         }
5297       break;
5298 #endif /* ! defined (NO_STRING_ESCAPES) */
5299
5300     default:
5301       break;
5302     }
5303   return (c);
5304 }
5305 \f
5306 static segT
5307 get_segmented_expression (register expressionS *expP)
5308 {
5309   register segT retval;
5310
5311   retval = expression (expP);
5312   if (expP->X_op == O_illegal
5313       || expP->X_op == O_absent
5314       || expP->X_op == O_big)
5315     {
5316       as_bad (_("expected address expression"));
5317       expP->X_op = O_constant;
5318       expP->X_add_number = 0;
5319       retval = absolute_section;
5320     }
5321   return retval;
5322 }
5323
5324 static segT
5325 get_known_segmented_expression (register expressionS *expP)
5326 {
5327   register segT retval;
5328
5329   if ((retval = get_segmented_expression (expP)) == undefined_section)
5330     {
5331       /* There is no easy way to extract the undefined symbol from the
5332          expression.  */
5333       if (expP->X_add_symbol != NULL
5334           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5335         as_warn (_("symbol \"%s\" undefined; zero assumed"),
5336                  S_GET_NAME (expP->X_add_symbol));
5337       else
5338         as_warn (_("some symbol undefined; zero assumed"));
5339       retval = absolute_section;
5340       expP->X_op = O_constant;
5341       expP->X_add_number = 0;
5342     }
5343   know (retval == absolute_section || SEG_NORMAL (retval));
5344   return (retval);
5345 }
5346
5347 char                            /* Return terminator.  */
5348 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
5349 {
5350   /* FIXME: val_pointer should probably be offsetT *.  */
5351   *val_pointer = (long) get_absolute_expression ();
5352   return (*input_line_pointer++);
5353 }
5354 \f
5355 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5356    Give a warning if that happens.  */
5357
5358 char *
5359 demand_copy_C_string (int *len_pointer)
5360 {
5361   register char *s;
5362
5363   if ((s = demand_copy_string (len_pointer)) != 0)
5364     {
5365       register int len;
5366
5367       for (len = *len_pointer; len > 0; len--)
5368         {
5369           if (*s == 0)
5370             {
5371               s = 0;
5372               len = 1;
5373               *len_pointer = 0;
5374               as_bad (_("this string may not contain \'\\0\'"));
5375             }
5376         }
5377     }
5378
5379   return s;
5380 }
5381 \f
5382 /* Demand string, but return a safe (=private) copy of the string.
5383    Return NULL if we can't read a string here.  */
5384
5385 char *
5386 demand_copy_string (int *lenP)
5387 {
5388   register unsigned int c;
5389   register int len;
5390   char *retval;
5391
5392   len = 0;
5393   SKIP_WHITESPACE ();
5394   if (*input_line_pointer == '\"')
5395     {
5396       input_line_pointer++;     /* Skip opening quote.  */
5397
5398       while (is_a_char (c = next_char_of_string ()))
5399         {
5400           obstack_1grow (&notes, c);
5401           len++;
5402         }
5403       /* JF this next line is so demand_copy_C_string will return a
5404          null terminated string.  */
5405       obstack_1grow (&notes, '\0');
5406       retval = obstack_finish (&notes);
5407     }
5408   else
5409     {
5410       as_bad (_("missing string"));
5411       retval = NULL;
5412       ignore_rest_of_line ();
5413     }
5414   *lenP = len;
5415   return (retval);
5416 }
5417 \f
5418 /* In:  Input_line_pointer->next character.
5419
5420    Do:  Skip input_line_pointer over all whitespace.
5421
5422    Out: 1 if input_line_pointer->end-of-line.  */
5423
5424 int
5425 is_it_end_of_statement (void)
5426 {
5427   SKIP_WHITESPACE ();
5428   return (is_end_of_line[(unsigned char) *input_line_pointer]);
5429 }
5430
5431 void
5432 equals (char *sym_name, int reassign)
5433 {
5434   char *stop = NULL;
5435   char stopc = 0;
5436
5437   input_line_pointer++;
5438   if (*input_line_pointer == '=')
5439     input_line_pointer++;
5440   if (reassign < 0 && *input_line_pointer == '=')
5441     input_line_pointer++;
5442
5443   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5444     input_line_pointer++;
5445
5446   if (flag_mri)
5447     stop = mri_comment_field (&stopc);
5448
5449   assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5450
5451   if (flag_mri)
5452     {
5453       demand_empty_rest_of_line ();
5454       mri_comment_end (stop, stopc);
5455     }
5456 }
5457
5458 /* .incbin -- include a file verbatim at the current location.  */
5459
5460 void
5461 s_incbin (int x ATTRIBUTE_UNUSED)
5462 {
5463   FILE * binfile;
5464   char * path;
5465   char * filename;
5466   char * binfrag;
5467   long   skip = 0;
5468   long   count = 0;
5469   long   bytes;
5470   int    len;
5471
5472 #ifdef md_flush_pending_output
5473   md_flush_pending_output ();
5474 #endif
5475
5476 #ifdef md_cons_align
5477   md_cons_align (1);
5478 #endif
5479
5480   SKIP_WHITESPACE ();
5481   filename = demand_copy_string (& len);
5482   if (filename == NULL)
5483     return;
5484
5485   SKIP_WHITESPACE ();
5486
5487   /* Look for optional skip and count.  */
5488   if (* input_line_pointer == ',')
5489     {
5490       ++ input_line_pointer;
5491       skip = get_absolute_expression ();
5492
5493       SKIP_WHITESPACE ();
5494
5495       if (* input_line_pointer == ',')
5496         {
5497           ++ input_line_pointer;
5498
5499           count = get_absolute_expression ();
5500           if (count == 0)
5501             as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5502
5503           SKIP_WHITESPACE ();
5504         }
5505     }
5506
5507   demand_empty_rest_of_line ();
5508
5509   /* Try opening absolute path first, then try include dirs.  */
5510   binfile = fopen (filename, FOPEN_RB);
5511   if (binfile == NULL)
5512     {
5513       int i;
5514
5515       path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5516
5517       for (i = 0; i < include_dir_count; i++)
5518         {
5519           sprintf (path, "%s/%s", include_dirs[i], filename);
5520
5521           binfile = fopen (path, FOPEN_RB);
5522           if (binfile != NULL)
5523             break;
5524         }
5525
5526       if (binfile == NULL)
5527         as_bad (_("file not found: %s"), filename);
5528     }
5529   else
5530     path = xstrdup (filename);
5531
5532   if (binfile)
5533     {
5534       long   file_len;
5535
5536       register_dependency (path);
5537
5538       /* Compute the length of the file.  */
5539       if (fseek (binfile, 0, SEEK_END) != 0)
5540         {
5541           as_bad (_("seek to end of .incbin file failed `%s'"), path);
5542           goto done;
5543         }
5544       file_len = ftell (binfile);
5545
5546       /* If a count was not specified use the remainder of the file.  */
5547       if (count == 0)
5548         count = file_len - skip;
5549
5550       if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5551         {
5552           as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5553                   skip, count, file_len);
5554           goto done;
5555         }
5556
5557       if (fseek (binfile, skip, SEEK_SET) != 0)
5558         {
5559           as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5560           goto done;
5561         }
5562
5563       /* Allocate frag space and store file contents in it.  */
5564       binfrag = frag_more (count);
5565
5566       bytes = fread (binfrag, 1, count, binfile);
5567       if (bytes < count)
5568         as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5569                  path, bytes, count);
5570     }
5571 done:
5572   if (binfile != NULL)
5573     fclose (binfile);
5574   if (path)
5575     free (path);
5576 }
5577
5578 /* .include -- include a file at this point.  */
5579
5580 void
5581 s_include (int arg ATTRIBUTE_UNUSED)
5582 {
5583   char *filename;
5584   int i;
5585   FILE *try;
5586   char *path;
5587
5588   if (!flag_m68k_mri)
5589     {
5590       filename = demand_copy_string (&i);
5591       if (filename == NULL)
5592         {
5593           /* demand_copy_string has already printed an error and
5594              called ignore_rest_of_line.  */
5595           return;
5596         }
5597     }
5598   else
5599     {
5600       SKIP_WHITESPACE ();
5601       i = 0;
5602       while (!is_end_of_line[(unsigned char) *input_line_pointer]
5603              && *input_line_pointer != ' '
5604              && *input_line_pointer != '\t')
5605         {
5606           obstack_1grow (&notes, *input_line_pointer);
5607           ++input_line_pointer;
5608           ++i;
5609         }
5610
5611       obstack_1grow (&notes, '\0');
5612       filename = obstack_finish (&notes);
5613       while (!is_end_of_line[(unsigned char) *input_line_pointer])
5614         ++input_line_pointer;
5615     }
5616
5617   demand_empty_rest_of_line ();
5618   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
5619
5620   for (i = 0; i < include_dir_count; i++)
5621     {
5622       strcpy (path, include_dirs[i]);
5623       strcat (path, "/");
5624       strcat (path, filename);
5625       if (0 != (try = fopen (path, FOPEN_RT)))
5626         {
5627           fclose (try);
5628           goto gotit;
5629         }
5630     }
5631
5632   free (path);
5633   path = filename;
5634 gotit:
5635   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
5636   register_dependency (path);
5637   input_scrub_insert_file (path);
5638 }
5639
5640 void
5641 add_include_dir (char *path)
5642 {
5643   int i;
5644
5645   if (include_dir_count == 0)
5646     {
5647       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5648       include_dirs[0] = ".";    /* Current dir.  */
5649       include_dir_count = 2;
5650     }
5651   else
5652     {
5653       include_dir_count++;
5654       include_dirs =
5655         (char **) realloc (include_dirs,
5656                            include_dir_count * sizeof (*include_dirs));
5657     }
5658
5659   include_dirs[include_dir_count - 1] = path;   /* New one.  */
5660
5661   i = strlen (path);
5662   if (i > include_dir_maxlen)
5663     include_dir_maxlen = i;
5664 }
5665 \f
5666 /* Output debugging information to denote the source file.  */
5667
5668 static void
5669 generate_file_debug (void)
5670 {
5671   if (debug_type == DEBUG_STABS)
5672     stabs_generate_asm_file ();
5673 }
5674
5675 /* Output line number debugging information for the current source line.  */
5676
5677 void
5678 generate_lineno_debug (void)
5679 {
5680   switch (debug_type)
5681     {
5682     case DEBUG_UNSPECIFIED:
5683     case DEBUG_NONE:
5684     case DEBUG_DWARF:
5685       break;
5686     case DEBUG_STABS:
5687       stabs_generate_asm_lineno ();
5688       break;
5689     case DEBUG_ECOFF:
5690       ecoff_generate_asm_lineno ();
5691       break;
5692     case DEBUG_DWARF2:
5693       /* ??? We could here indicate to dwarf2dbg.c that something
5694          has changed.  However, since there is additional backend
5695          support that is required (calling dwarf2_emit_insn), we
5696          let dwarf2dbg.c call as_where on its own.  */
5697       break;
5698     }
5699 }
5700
5701 /* Output debugging information to mark a function entry point or end point.
5702    END_P is zero for .func, and non-zero for .endfunc.  */
5703
5704 void
5705 s_func (int end_p)
5706 {
5707   do_s_func (end_p, NULL);
5708 }
5709
5710 /* Subroutine of s_func so targets can choose a different default prefix.
5711    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
5712
5713 static void
5714 do_s_func (int end_p, const char *default_prefix)
5715 {
5716   /* Record the current function so that we can issue an error message for
5717      misplaced .func,.endfunc, and also so that .endfunc needs no
5718      arguments.  */
5719   static char *current_name;
5720   static char *current_label;
5721
5722   if (end_p)
5723     {
5724       if (current_name == NULL)
5725         {
5726           as_bad (_("missing .func"));
5727           ignore_rest_of_line ();
5728           return;
5729         }
5730
5731       if (debug_type == DEBUG_STABS)
5732         stabs_generate_asm_endfunc (current_name, current_label);
5733
5734       current_name = current_label = NULL;
5735     }
5736   else /* ! end_p */
5737     {
5738       char *name, *label;
5739       char delim1, delim2;
5740
5741       if (current_name != NULL)
5742         {
5743           as_bad (_(".endfunc missing for previous .func"));
5744           ignore_rest_of_line ();
5745           return;
5746         }
5747
5748       name = input_line_pointer;
5749       delim1 = get_symbol_end ();
5750       name = xstrdup (name);
5751       *input_line_pointer = delim1;
5752       SKIP_WHITESPACE ();
5753       if (*input_line_pointer != ',')
5754         {
5755           if (default_prefix)
5756             {
5757               if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5758                 as_fatal ("%s", xstrerror (errno));
5759             }
5760           else
5761             {
5762               char leading_char = bfd_get_symbol_leading_char (stdoutput);
5763               /* Missing entry point, use function's name with the leading
5764                  char prepended.  */
5765               if (leading_char)
5766                 {
5767                   if (asprintf (&label, "%c%s", leading_char, name) == -1)
5768                     as_fatal ("%s", xstrerror (errno));
5769                 }
5770               else
5771                 label = name;
5772             }
5773         }
5774       else
5775         {
5776           ++input_line_pointer;
5777           SKIP_WHITESPACE ();
5778           label = input_line_pointer;
5779           delim2 = get_symbol_end ();
5780           label = xstrdup (label);
5781           *input_line_pointer = delim2;
5782         }
5783
5784       if (debug_type == DEBUG_STABS)
5785         stabs_generate_asm_func (name, label);
5786
5787       current_name = name;
5788       current_label = label;
5789     }
5790
5791   demand_empty_rest_of_line ();
5792 }
5793 \f
5794 void
5795 s_ignore (int arg ATTRIBUTE_UNUSED)
5796 {
5797   ignore_rest_of_line ();
5798 }
5799
5800 void
5801 read_print_statistics (FILE *file)
5802 {
5803   hash_print_statistics (file, "pseudo-op table", po_hash);
5804 }
5805
5806 /* Inserts the given line into the input stream.
5807
5808    This call avoids macro/conditionals nesting checking, since the contents of
5809    the line are assumed to replace the contents of a line already scanned.
5810
5811    An appropriate use of this function would be substitution of input lines when
5812    called by md_start_line_hook().  The given line is assumed to already be
5813    properly scrubbed.  */
5814
5815 void
5816 input_scrub_insert_line (const char *line)
5817 {
5818   sb newline;
5819   sb_new (&newline);
5820   sb_add_string (&newline, line);
5821   input_scrub_include_sb (&newline, input_line_pointer, 0);
5822   sb_kill (&newline);
5823   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5824 }
5825
5826 /* Insert a file into the input stream; the path must resolve to an actual
5827    file; no include path searching or dependency registering is performed.  */
5828
5829 void
5830 input_scrub_insert_file (char *path)
5831 {
5832   input_scrub_include_file (path, input_line_pointer);
5833   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5834 }
5835
5836 /* Find the end of a line, considering quotation and escaping of quotes.  */
5837
5838 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5839 # define TC_SINGLE_QUOTE_STRINGS 1
5840 #endif
5841
5842 static char *
5843 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5844                    int in_macro)
5845 {
5846   char inquote = '\0';
5847   int inescape = 0;
5848
5849   while (!is_end_of_line[(unsigned char) *s]
5850          || (inquote && !ISCNTRL (*s))
5851          || (inquote == '\'' && flag_mri)
5852 #ifdef TC_EOL_IN_INSN
5853          || (insn && TC_EOL_IN_INSN (s))
5854 #endif
5855          /* PR 6926:  When we are parsing the body of a macro the sequence
5856             \@ is special - it refers to the invocation count.  If the @
5857             character happens to be registered as a line-separator character
5858             by the target, then the is_end_of_line[] test above will have
5859             returned true, but we need to ignore the line separating
5860             semantics in this particular case.  */
5861          || (in_macro && inescape && *s == '@')
5862         )
5863     {
5864       if (mri_string && *s == '\'')
5865         inquote ^= *s;
5866       else if (inescape)
5867         inescape = 0;
5868       else if (*s == '\\')
5869         inescape = 1;
5870       else if (!inquote
5871                ? *s == '"'
5872 #ifdef TC_SINGLE_QUOTE_STRINGS
5873                  || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5874 #endif
5875                : *s == inquote)
5876         inquote ^= *s;
5877       ++s;
5878     }
5879   if (inquote)
5880     as_warn (_("missing closing `%c'"), inquote);
5881   if (inescape)
5882     as_warn (_("stray `\\'"));
5883   return s;
5884 }
5885
5886 char *
5887 find_end_of_line (char *s, int mri_string)
5888 {
5889   return _find_end_of_line (s, mri_string, 0, 0);
5890 }