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