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