gas/read.c

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