contrib/binutils-2.22/gas/read.c

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