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