gas/read.c

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