gas/read.c

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