gas/read.c

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