gas/read.c

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