gas/read.c

   1 /* read.c - read a source file -
   2    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
  24    But then, GNU isn't spozed to run on your machine anyway.
  25    (RMS is so shortsighted sometimes.)  */
  26 #define MASK_CHAR ((int)(unsigned char) -1)
  27
  28 /* This is the largest known floating point format (for now). It will
  29    grow when we do 4361 style flonums.  */
  30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  31
  32 /* Routines that read assembler source text to build spaghetti in memory.
  33    Another group of these functions is in the expr.c module.  */
  34
  35 #include "as.h"
  36 #include "safe-ctype.h"
  37 #include "subsegs.h"
  38 #include "sb.h"
  39 #include "macro.h"
  40 #include "obstack.h"
  41 #include "ecoff.h"
  42 #include "dw2gencfi.h"
  43
  44 #ifndef TC_START_LABEL
  45 #define TC_START_LABEL(x,y,z) (x == ':')
  46 #endif
  47
  48 /* Set by the object-format or the target.  */
  49 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
  50 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)                \
  51   do                                                            \
  52     {                                                           \
  53       if ((SIZE) >= 8)                                          \
  54         (P2VAR) = 3;                                            \
  55       else if ((SIZE) >= 4)                                     \
  56         (P2VAR) = 2;                                            \
  57       else if ((SIZE) >= 2)                                     \
  58         (P2VAR) = 1;                                            \
  59       else                                                      \
  60         (P2VAR) = 0;                                            \
  61     }                                                           \
  62   while (0)
  63 #endif
  64
  65 char *input_line_pointer;       /*->next char of source file to parse.  */
  66
  67 #if BITS_PER_CHAR != 8
  68 /*  The following table is indexed by[(char)] and will break if
  69     a char does not have exactly 256 states (hopefully 0:255!)!  */
  70 die horribly;
  71 #endif
  72
  73 #ifndef LEX_AT
  74 #define LEX_AT 0
  75 #endif
  76
  77 #ifndef LEX_BR
  78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
  79 #define LEX_BR 0
  80 #endif
  81
  82 #ifndef LEX_PCT
  83 /* The Delta 68k assembler permits % inside label names.  */
  84 #define LEX_PCT 0
  85 #endif
  86
  87 #ifndef LEX_QM
  88 /* The PowerPC Windows NT assemblers permits ? inside label names.  */
  89 #define LEX_QM 0
  90 #endif
  91
  92 #ifndef LEX_HASH
  93 /* The IA-64 assembler uses # as a suffix designating a symbol.  We include
  94    it in the symbol and strip it out in tc_canonicalize_symbol_name.  */
  95 #define LEX_HASH 0
  96 #endif
  97
  98 #ifndef LEX_DOLLAR
  99 #define LEX_DOLLAR 3
 100 #endif
 101
 102 #ifndef LEX_TILDE
 103 /* The Delta 68k assembler permits ~ at start of label names.  */
 104 #define LEX_TILDE 0
 105 #endif
 106
 107 /* Used by is_... macros. our ctype[].  */
 108 char lex_type[256] = {
 109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
 110   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
 111   0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
 112   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  /* 0123456789:;<=>? */
 113   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  /* @ABCDEFGHIJKLMNO */
 114   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
 115   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
 116   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~.  */
 117   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 118   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 119   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 120   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 121   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 122   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 123   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 124   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
 125 };
 126
 127 /* In: a character.
 128    Out: 1 if this character ends a line.
 129         2 if this character is a line separator.  */
 130 char is_end_of_line[256] = {
 131 #ifdef CR_EOL
 132   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,       /* @abcdefghijklmno */
 133 #else
 134   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,       /* @abcdefghijklmno */
 135 #endif
 136   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 137   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* _!"#$%&'()*+,-./ */
 138   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
 139   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 140   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 141   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 142   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 143   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 144   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 145   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 146   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 147   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 148   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 149   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
 150   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0        /* */
 151 };
 152
 153 #ifndef TC_CASE_SENSITIVE
 154 char original_case_string[128];
 155 #endif
 156
 157 /* Functions private to this file.  */
 158
 159 static char *buffer;    /* 1st char of each buffer of lines is here.  */
 160 static char *buffer_limit;      /*->1 + last char in buffer.  */
 161
 162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
 163    in the tc-<CPU>.h file.  See the "Porting GAS" section of the
 164    internals manual.  */
 165 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 166
 167 /* Variables for handling include file directory table.  */
 168
 169 /* Table of pointers to directories to search for .include's.  */
 170 char **include_dirs;
 171
 172 /* How many are in the table.  */
 173 int include_dir_count;
 174
 175 /* Length of longest in table.  */
 176 int include_dir_maxlen = 1;
 177
 178 #ifndef WORKING_DOT_WORD
 179 struct broken_word *broken_words;
 180 int new_broken_words;
 181 #endif
 182
 183 /* The current offset into the absolute section.  We don't try to
 184    build frags in the absolute section, since no data can be stored
 185    there.  We just keep track of the current offset.  */
 186 addressT abs_section_offset;
 187
 188 /* If this line had an MRI style label, it is stored in this variable.
 189    This is used by some of the MRI pseudo-ops.  */
 190 symbolS *line_label;
 191
 192 /* This global variable is used to support MRI common sections.  We
 193    translate such sections into a common symbol.  This variable is
 194    non-NULL when we are in an MRI common section.  */
 195 symbolS *mri_common_symbol;
 196
 197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
 198    need to align to an even byte boundary unless the next pseudo-op is
 199    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
 200    may be needed.  */
 201 static int mri_pending_align;
 202
 203 #ifndef NO_LISTING
 204 #ifdef OBJ_ELF
 205 /* This variable is set to be non-zero if the next string we see might
 206    be the name of the source file in DWARF debugging information.  See
 207    the comment in emit_expr for the format we look for.  */
 208 static int dwarf_file_string;
 209 #endif
 210 #endif
 211
 212 static void do_s_func (int end_p, const char *default_prefix);
 213 static void do_align (int, char *, int, int);
 214 static void s_align (int, int);
 215 static void s_altmacro (int);
 216 static void s_bad_end (int);
 217 #ifdef OBJ_ELF
 218 static void s_gnu_attribute (int);
 219 #endif
 220 static void s_reloc (int);
 221 static int hex_float (int, char *);
 222 static segT get_known_segmented_expression (expressionS * expP);
 223 static void pobegin (void);
 224 static int get_non_macro_line_sb (sb *);
 225 static void generate_file_debug (void);
 226 static char *_find_end_of_line (char *, int, int, int);
 227 \f
 228 void
 229 read_begin (void)
 230 {
 231   const char *p;
 232
 233   pobegin ();
 234   obj_read_begin_hook ();
 235
 236   /* Something close -- but not too close -- to a multiple of 1024.
 237      The debugging malloc I'm using has 24 bytes of overhead.  */
 238   obstack_begin (&notes, chunksize);
 239   obstack_begin (&cond_obstack, chunksize);
 240
 241   /* Use machine dependent syntax.  */
 242   for (p = line_separator_chars; *p; p++)
 243     is_end_of_line[(unsigned char) *p] = 2;
 244   /* Use more.  FIXME-SOMEDAY.  */
 245
 246   if (flag_mri)
 247     lex_type['?'] = 3;
 248 }
 249 \f
 250 #ifndef TC_ADDRESS_BYTES
 251 #define TC_ADDRESS_BYTES address_bytes
 252
 253 static inline int
 254 address_bytes (void)
 255 {
 256   /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
 257      contain an address.  */
 258   int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
 259   n |= n >> 1;
 260   n |= n >> 2;
 261   n += 1;
 262   return n;
 263 }
 264 #endif
 265
 266 /* Set up pseudo-op tables.  */
 267
 268 static struct hash_control *po_hash;
 269
 270 static const pseudo_typeS potable[] = {
 271   {"abort", s_abort, 0},
 272   {"align", s_align_ptwo, 0},
 273   {"altmacro", s_altmacro, 1},
 274   {"ascii", stringer, 8+0},
 275   {"asciz", stringer, 8+1},
 276   {"balign", s_align_bytes, 0},
 277   {"balignw", s_align_bytes, -2},
 278   {"balignl", s_align_bytes, -4},
 279 /* block  */
 280   {"byte", cons, 1},
 281   {"comm", s_comm, 0},
 282   {"common", s_mri_common, 0},
 283   {"common.s", s_mri_common, 1},
 284   {"data", s_data, 0},
 285   {"dc", cons, 2},
 286 #ifdef TC_ADDRESS_BYTES
 287   {"dc.a", cons, 0},
 288 #endif
 289   {"dc.b", cons, 1},
 290   {"dc.d", float_cons, 'd'},
 291   {"dc.l", cons, 4},
 292   {"dc.s", float_cons, 'f'},
 293   {"dc.w", cons, 2},
 294   {"dc.x", float_cons, 'x'},
 295   {"dcb", s_space, 2},
 296   {"dcb.b", s_space, 1},
 297   {"dcb.d", s_float_space, 'd'},
 298   {"dcb.l", s_space, 4},
 299   {"dcb.s", s_float_space, 'f'},
 300   {"dcb.w", s_space, 2},
 301   {"dcb.x", s_float_space, 'x'},
 302   {"ds", s_space, 2},
 303   {"ds.b", s_space, 1},
 304   {"ds.d", s_space, 8},
 305   {"ds.l", s_space, 4},
 306   {"ds.p", s_space, 12},
 307   {"ds.s", s_space, 4},
 308   {"ds.w", s_space, 2},
 309   {"ds.x", s_space, 12},
 310   {"debug", s_ignore, 0},
 311 #ifdef S_SET_DESC
 312   {"desc", s_desc, 0},
 313 #endif
 314 /* dim  */
 315   {"double", float_cons, 'd'},
 316 /* dsect  */
 317   {"eject", listing_eject, 0},  /* Formfeed listing.  */
 318   {"else", s_else, 0},
 319   {"elsec", s_else, 0},
 320   {"elseif", s_elseif, (int) O_ne},
 321   {"end", s_end, 0},
 322   {"endc", s_endif, 0},
 323   {"endfunc", s_func, 1},
 324   {"endif", s_endif, 0},
 325   {"endm", s_bad_end, 0},
 326   {"endr", s_bad_end, 1},
 327 /* endef  */
 328   {"equ", s_set, 0},
 329   {"equiv", s_set, 1},
 330   {"eqv", s_set, -1},
 331   {"err", s_err, 0},
 332   {"error", s_errwarn, 1},
 333   {"exitm", s_mexit, 0},
 334 /* extend  */
 335   {"extern", s_ignore, 0},      /* We treat all undef as ext.  */
 336   {"appfile", s_app_file, 1},
 337   {"appline", s_app_line, 1},
 338   {"fail", s_fail, 0},
 339   {"file", s_app_file, 0},
 340   {"fill", s_fill, 0},
 341   {"float", float_cons, 'f'},
 342   {"format", s_ignore, 0},
 343   {"func", s_func, 0},
 344   {"global", s_globl, 0},
 345   {"globl", s_globl, 0},
 346 #ifdef OBJ_ELF
 347   {"gnu_attribute", s_gnu_attribute, 0},
 348 #endif
 349   {"hword", cons, 2},
 350   {"if", s_if, (int) O_ne},
 351   {"ifb", s_ifb, 1},
 352   {"ifc", s_ifc, 0},
 353   {"ifdef", s_ifdef, 0},
 354   {"ifeq", s_if, (int) O_eq},
 355   {"ifeqs", s_ifeqs, 0},
 356   {"ifge", s_if, (int) O_ge},
 357   {"ifgt", s_if, (int) O_gt},
 358   {"ifle", s_if, (int) O_le},
 359   {"iflt", s_if, (int) O_lt},
 360   {"ifnb", s_ifb, 0},
 361   {"ifnc", s_ifc, 1},
 362   {"ifndef", s_ifdef, 1},
 363   {"ifne", s_if, (int) O_ne},
 364   {"ifnes", s_ifeqs, 1},
 365   {"ifnotdef", s_ifdef, 1},
 366   {"incbin", s_incbin, 0},
 367   {"include", s_include, 0},
 368   {"int", cons, 4},
 369   {"irp", s_irp, 0},
 370   {"irep", s_irp, 0},
 371   {"irpc", s_irp, 1},
 372   {"irepc", s_irp, 1},
 373   {"lcomm", s_lcomm, 0},
 374   {"lflags", s_ignore, 0},      /* Listing flags.  */
 375   {"linefile", s_app_line, 0},
 376   {"linkonce", s_linkonce, 0},
 377   {"list", listing_list, 1},    /* Turn listing on.  */
 378   {"llen", listing_psize, 1},
 379   {"long", cons, 4},
 380   {"lsym", s_lsym, 0},
 381   {"macro", s_macro, 0},
 382   {"mexit", s_mexit, 0},
 383   {"mri", s_mri, 0},
 384   {".mri", s_mri, 0},   /* Special case so .mri works in MRI mode.  */
 385   {"name", s_ignore, 0},
 386   {"noaltmacro", s_altmacro, 0},
 387   {"noformat", s_ignore, 0},
 388   {"nolist", listing_list, 0},  /* Turn listing off.  */
 389   {"nopage", listing_nopage, 0},
 390   {"octa", cons, 16},
 391   {"offset", s_struct, 0},
 392   {"org", s_org, 0},
 393   {"p2align", s_align_ptwo, 0},
 394   {"p2alignw", s_align_ptwo, -2},
 395   {"p2alignl", s_align_ptwo, -4},
 396   {"page", listing_eject, 0},
 397   {"plen", listing_psize, 0},
 398   {"print", s_print, 0},
 399   {"psize", listing_psize, 0},  /* Set paper size.  */
 400   {"purgem", s_purgem, 0},
 401   {"quad", cons, 8},
 402   {"reloc", s_reloc, 0},
 403   {"rep", s_rept, 0},
 404   {"rept", s_rept, 0},
 405   {"rva", s_rva, 4},
 406   {"sbttl", listing_title, 1},  /* Subtitle of listing.  */
 407 /* scl  */
 408 /* sect  */
 409   {"set", s_set, 0},
 410   {"short", cons, 2},
 411   {"single", float_cons, 'f'},
 412 /* size  */
 413   {"space", s_space, 0},
 414   {"skip", s_space, 0},
 415   {"sleb128", s_leb128, 1},
 416   {"spc", s_ignore, 0},
 417   {"stabd", s_stab, 'd'},
 418   {"stabn", s_stab, 'n'},
 419   {"stabs", s_stab, 's'},
 420   {"string", stringer, 8+1},
 421   {"string8", stringer, 8+1},
 422   {"string16", stringer, 16+1},
 423   {"string32", stringer, 32+1},
 424   {"string64", stringer, 64+1},
 425   {"struct", s_struct, 0},
 426 /* tag  */
 427   {"text", s_text, 0},
 428
 429   /* This is for gcc to use.  It's only just been added (2/94), so gcc
 430      won't be able to use it for a while -- probably a year or more.
 431      But once this has been released, check with gcc maintainers
 432      before deleting it or even changing the spelling.  */
 433   {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
 434   /* If we're folding case -- done for some targets, not necessarily
 435      all -- the above string in an input file will be converted to
 436      this one.  Match it either way...  */
 437   {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
 438
 439   {"title", listing_title, 0},  /* Listing title.  */
 440   {"ttl", listing_title, 0},
 441 /* type  */
 442   {"uleb128", s_leb128, 0},
 443 /* use  */
 444 /* val  */
 445   {"xcom", s_comm, 0},
 446   {"xdef", s_globl, 0},
 447   {"xref", s_ignore, 0},
 448   {"xstabs", s_xstab, 's'},
 449   {"warning", s_errwarn, 0},
 450   {"weakref", s_weakref, 0},
 451   {"word", cons, 2},
 452   {"zero", s_space, 0},
 453   {NULL, NULL, 0}                       /* End sentinel.  */
 454 };
 455
 456 static offsetT
 457 get_absolute_expr (expressionS *exp)
 458 {
 459   expression_and_evaluate (exp);
 460   if (exp->X_op != O_constant)
 461     {
 462       if (exp->X_op != O_absent)
 463         as_bad (_("bad or irreducible absolute expression"));
 464       exp->X_add_number = 0;
 465     }
 466   return exp->X_add_number;
 467 }
 468
 469 offsetT
 470 get_absolute_expression (void)
 471 {
 472   expressionS exp;
 473
 474   return get_absolute_expr (&exp);
 475 }
 476
 477 static int pop_override_ok = 0;
 478 static const char *pop_table_name;
 479
 480 void
 481 pop_insert (const pseudo_typeS *table)
 482 {
 483   const char *errtxt;
 484   const pseudo_typeS *pop;
 485   for (pop = table; pop->poc_name; pop++)
 486     {
 487       errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
 488       if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
 489         as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
 490                   errtxt);
 491     }
 492 }
 493
 494 #ifndef md_pop_insert
 495 #define md_pop_insert()         pop_insert(md_pseudo_table)
 496 #endif
 497
 498 #ifndef obj_pop_insert
 499 #define obj_pop_insert()        pop_insert(obj_pseudo_table)
 500 #endif
 501
 502 #ifndef cfi_pop_insert
 503 #define cfi_pop_insert()        pop_insert(cfi_pseudo_table)
 504 #endif
 505
 506 static void
 507 pobegin (void)
 508 {
 509   po_hash = hash_new ();
 510
 511   /* Do the target-specific pseudo ops.  */
 512   pop_table_name = "md";
 513   md_pop_insert ();
 514
 515   /* Now object specific.  Skip any that were in the target table.  */
 516   pop_table_name = "obj";
 517   pop_override_ok = 1;
 518   obj_pop_insert ();
 519
 520   /* Now portable ones.  Skip any that we've seen already.  */
 521   pop_table_name = "standard";
 522   pop_insert (potable);
 523
 524 #ifdef TARGET_USE_CFIPOP
 525   pop_table_name = "cfi";
 526   pop_override_ok = 1;
 527   cfi_pop_insert ();
 528 #endif
 529 }
 530 \f
 531 #define HANDLE_CONDITIONAL_ASSEMBLY()                                   \
 532   if (ignore_input ())                                                  \
 533     {                                                                   \
 534       char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
 535       input_line_pointer = (input_line_pointer <= buffer_limit          \
 536                             && eol >= buffer_limit)                     \
 537                            ? buffer_limit                               \
 538                            : eol + 1;                                   \
 539       continue;                                                         \
 540     }
 541
 542 /* This function is used when scrubbing the characters between #APP
 543    and #NO_APP.  */
 544
 545 static char *scrub_string;
 546 static char *scrub_string_end;
 547
 548 static int
 549 scrub_from_string (char *buf, int buflen)
 550 {
 551   int copy;
 552
 553   copy = scrub_string_end - scrub_string;
 554   if (copy > buflen)
 555     copy = buflen;
 556   memcpy (buf, scrub_string, copy);
 557   scrub_string += copy;
 558   return copy;
 559 }
 560
 561 /* Helper function of read_a_source_file, which tries to expand a macro.  */
 562 static int
 563 try_macro (char term, const char *line)
 564 {
 565   sb out;
 566   const char *err;
 567   macro_entry *macro;
 568
 569   if (check_macro (line, &out, &err, &macro))
 570     {
 571       if (err != NULL)
 572         as_bad ("%s", err);
 573       *input_line_pointer++ = term;
 574       input_scrub_include_sb (&out,
 575                               input_line_pointer, 1);
 576       sb_kill (&out);
 577       buffer_limit =
 578         input_scrub_next_buffer (&input_line_pointer);
 579 #ifdef md_macro_info
 580       md_macro_info (macro);
 581 #endif
 582       return 1;
 583     }
 584   return 0;
 585 }
 586
 587 /* We read the file, putting things into a web that represents what we
 588    have been reading.  */
 589 void
 590 read_a_source_file (char *name)
 591 {
 592   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   register 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   register 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   register 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   register char *name;
2432   register char c;
2433   register char *p;
2434   expressionS exp;
2435   register 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, old_flag;
2611
2612   on = get_absolute_expression ();
2613   old_flag = flag_mri;
2614   if (on != 0)
2615     {
2616       flag_mri = 1;
2617 #ifdef TC_M68K
2618       flag_m68k_mri = 1;
2619 #endif
2620       macro_mri_mode (1);
2621     }
2622   else
2623     {
2624       flag_mri = 0;
2625 #ifdef TC_M68K
2626       flag_m68k_mri = 0;
2627 #endif
2628       macro_mri_mode (0);
2629     }
2630
2631   /* Operator precedence changes in m68k MRI mode, so we need to
2632      update the operator rankings.  */
2633   expr_set_precedence ();
2634
2635 #ifdef MRI_MODE_CHANGE
2636   if (on != old_flag)
2637     MRI_MODE_CHANGE (on);
2638 #endif
2639
2640   demand_empty_rest_of_line ();
2641 }
2642
2643 /* Handle changing the location counter.  */
2644
2645 static void
2646 do_org (segT segment, expressionS *exp, int fill)
2647 {
2648   if (segment != now_seg && segment != absolute_section)
2649     as_bad (_("invalid segment \"%s\""), segment_name (segment));
2650
2651   if (now_seg == absolute_section)
2652     {
2653       if (fill != 0)
2654         as_warn (_("ignoring fill value in absolute section"));
2655       if (exp->X_op != O_constant)
2656         {
2657           as_bad (_("only constant offsets supported in absolute section"));
2658           exp->X_add_number = 0;
2659         }
2660       abs_section_offset = exp->X_add_number;
2661     }
2662   else
2663     {
2664       char *p;
2665       symbolS *sym = exp->X_add_symbol;
2666       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2667
2668       if (exp->X_op != O_constant && exp->X_op != O_symbol)
2669         {
2670           /* Handle complex expressions.  */
2671           sym = make_expr_symbol (exp);
2672           off = 0;
2673         }
2674
2675       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2676       *p = fill;
2677     }
2678 }
2679
2680 void
2681 s_org (int ignore ATTRIBUTE_UNUSED)
2682 {
2683   register segT segment;
2684   expressionS exp;
2685   register long temp_fill;
2686
2687 #ifdef md_flush_pending_output
2688   md_flush_pending_output ();
2689 #endif
2690
2691   /* The m68k MRI assembler has a different meaning for .org.  It
2692      means to create an absolute section at a given address.  We can't
2693      support that--use a linker script instead.  */
2694   if (flag_m68k_mri)
2695     {
2696       as_bad (_("MRI style ORG pseudo-op not supported"));
2697       ignore_rest_of_line ();
2698       return;
2699     }
2700
2701   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2702      thing as a sub-segment-relative origin.  Any absolute origin is
2703      given a warning, then assumed to be segment-relative.  Any
2704      segmented origin expression ("foo+42") had better be in the right
2705      segment or the .org is ignored.
2706
2707      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2708      we never know sub-segment sizes when we are reading code.  BSD
2709      will crash trying to emit negative numbers of filler bytes in
2710      certain .orgs. We don't crash, but see as-write for that code.
2711
2712      Don't make frag if need_pass_2==1.  */
2713   segment = get_known_segmented_expression (&exp);
2714   if (*input_line_pointer == ',')
2715     {
2716       input_line_pointer++;
2717       temp_fill = get_absolute_expression ();
2718     }
2719   else
2720     temp_fill = 0;
2721
2722   if (!need_pass_2)
2723     do_org (segment, &exp, temp_fill);
2724
2725   demand_empty_rest_of_line ();
2726 }
2727
2728 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2729    called by the obj-format routine which handles section changing
2730    when in MRI mode.  It will create a new section, and return it.  It
2731    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2732    'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */
2733
2734 void
2735 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2736 {
2737 #ifdef TC_M68K
2738
2739   char *name;
2740   char c;
2741   segT seg;
2742
2743   SKIP_WHITESPACE ();
2744
2745   name = input_line_pointer;
2746   if (!ISDIGIT (*name))
2747     c = get_symbol_end ();
2748   else
2749     {
2750       do
2751         {
2752           ++input_line_pointer;
2753         }
2754       while (ISDIGIT (*input_line_pointer));
2755
2756       c = *input_line_pointer;
2757       *input_line_pointer = '\0';
2758     }
2759
2760   name = xstrdup (name);
2761
2762   *input_line_pointer = c;
2763
2764   seg = subseg_new (name, 0);
2765
2766   if (*input_line_pointer == ',')
2767     {
2768       int align;
2769
2770       ++input_line_pointer;
2771       align = get_absolute_expression ();
2772       record_alignment (seg, align);
2773     }
2774
2775   *type = 'C';
2776   if (*input_line_pointer == ',')
2777     {
2778       c = *++input_line_pointer;
2779       c = TOUPPER (c);
2780       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2781         *type = c;
2782       else
2783         as_bad (_("unrecognized section type"));
2784       ++input_line_pointer;
2785
2786       {
2787         flagword flags;
2788
2789         flags = SEC_NO_FLAGS;
2790         if (*type == 'C')
2791           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2792         else if (*type == 'D' || *type == 'M')
2793           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2794         else if (*type == 'R')
2795           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2796         if (flags != SEC_NO_FLAGS)
2797           {
2798             if (!bfd_set_section_flags (stdoutput, seg, flags))
2799               as_warn (_("error setting flags for \"%s\": %s"),
2800                        bfd_section_name (stdoutput, seg),
2801                        bfd_errmsg (bfd_get_error ()));
2802           }
2803       }
2804     }
2805
2806   /* Ignore the HP type.  */
2807   if (*input_line_pointer == ',')
2808     input_line_pointer += 2;
2809
2810   demand_empty_rest_of_line ();
2811
2812 #else /* ! TC_M68K */
2813 #ifdef TC_I960
2814
2815   char *name;
2816   char c;
2817   segT seg;
2818
2819   SKIP_WHITESPACE ();
2820
2821   name = input_line_pointer;
2822   c = get_symbol_end ();
2823
2824   name = xstrdup (name);
2825
2826   *input_line_pointer = c;
2827
2828   seg = subseg_new (name, 0);
2829
2830   if (*input_line_pointer != ',')
2831     *type = 'C';
2832   else
2833     {
2834       char *sectype;
2835
2836       ++input_line_pointer;
2837       SKIP_WHITESPACE ();
2838       sectype = input_line_pointer;
2839       c = get_symbol_end ();
2840       if (*sectype == '\0')
2841         *type = 'C';
2842       else if (strcasecmp (sectype, "text") == 0)
2843         *type = 'C';
2844       else if (strcasecmp (sectype, "data") == 0)
2845         *type = 'D';
2846       else if (strcasecmp (sectype, "romdata") == 0)
2847         *type = 'R';
2848       else
2849         as_warn (_("unrecognized section type `%s'"), sectype);
2850       *input_line_pointer = c;
2851     }
2852
2853   if (*input_line_pointer == ',')
2854     {
2855       char *seccmd;
2856
2857       ++input_line_pointer;
2858       SKIP_WHITESPACE ();
2859       seccmd = input_line_pointer;
2860       c = get_symbol_end ();
2861       if (strcasecmp (seccmd, "absolute") == 0)
2862         {
2863           as_bad (_("absolute sections are not supported"));
2864           *input_line_pointer = c;
2865           ignore_rest_of_line ();
2866           return;
2867         }
2868       else if (strcasecmp (seccmd, "align") == 0)
2869         {
2870           int align;
2871
2872           *input_line_pointer = c;
2873           align = get_absolute_expression ();
2874           record_alignment (seg, align);
2875         }
2876       else
2877         {
2878           as_warn (_("unrecognized section command `%s'"), seccmd);
2879           *input_line_pointer = c;
2880         }
2881     }
2882
2883   demand_empty_rest_of_line ();
2884
2885 #else /* ! TC_I960 */
2886   /* The MRI assembler seems to use different forms of .sect for
2887      different targets.  */
2888   as_bad ("MRI mode not supported for this target");
2889   ignore_rest_of_line ();
2890 #endif /* ! TC_I960 */
2891 #endif /* ! TC_M68K */
2892 }
2893
2894 /* Handle the .print pseudo-op.  */
2895
2896 void
2897 s_print (int ignore ATTRIBUTE_UNUSED)
2898 {
2899   char *s;
2900   int len;
2901
2902   s = demand_copy_C_string (&len);
2903   if (s != NULL)
2904     printf ("%s\n", s);
2905   demand_empty_rest_of_line ();
2906 }
2907
2908 /* Handle the .purgem pseudo-op.  */
2909
2910 void
2911 s_purgem (int ignore ATTRIBUTE_UNUSED)
2912 {
2913   if (is_it_end_of_statement ())
2914     {
2915       demand_empty_rest_of_line ();
2916       return;
2917     }
2918
2919   do
2920     {
2921       char *name;
2922       char c;
2923
2924       SKIP_WHITESPACE ();
2925       name = input_line_pointer;
2926       c = get_symbol_end ();
2927       delete_macro (name);
2928       *input_line_pointer = c;
2929       SKIP_WHITESPACE ();
2930     }
2931   while (*input_line_pointer++ == ',');
2932
2933   --input_line_pointer;
2934   demand_empty_rest_of_line ();
2935 }
2936
2937 /* Handle the .endm/.endr pseudo-ops.  */
2938
2939 static void
2940 s_bad_end (int endr)
2941 {
2942   as_warn (_(".end%c encountered without preceeding %s"),
2943            endr ? 'r' : 'm',
2944            endr ? ".rept, .irp, or .irpc" : ".macro");
2945   demand_empty_rest_of_line ();
2946 }
2947
2948 /* Handle the .rept pseudo-op.  */
2949
2950 void
2951 s_rept (int ignore ATTRIBUTE_UNUSED)
2952 {
2953   int count;
2954
2955   count = get_absolute_expression ();
2956
2957   do_repeat (count, "REPT", "ENDR");
2958 }
2959
2960 /* This function provides a generic repeat block implementation.   It allows
2961    different directives to be used as the start/end keys.  */
2962
2963 void
2964 do_repeat (int count, const char *start, const char *end)
2965 {
2966   sb one;
2967   sb many;
2968
2969   sb_new (&one);
2970   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2971     {
2972       as_bad (_("%s without %s"), start, end);
2973       return;
2974     }
2975
2976   sb_new (&many);
2977   while (count-- > 0)
2978     sb_add_sb (&many, &one);
2979
2980   sb_kill (&one);
2981
2982   input_scrub_include_sb (&many, input_line_pointer, 1);
2983   sb_kill (&many);
2984   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2985 }
2986
2987 /* Like do_repeat except that any text matching EXPANDER in the
2988    block is replaced by the itteration count.  */
2989
2990 void
2991 do_repeat_with_expander (int count,
2992                          const char * start,
2993                          const char * end,
2994                          const char * expander)
2995 {
2996   sb one;
2997   sb many;
2998
2999   sb_new (&one);
3000   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3001     {
3002       as_bad (_("%s without %s"), start, end);
3003       return;
3004     }
3005
3006   sb_new (&many);
3007
3008   if (expander != NULL && strstr (one.ptr, expander) != NULL)
3009     {
3010       while (count -- > 0)
3011         {
3012           int len;
3013           char * sub;
3014           sb processed;
3015
3016           sb_new (& processed);
3017           sb_add_sb (& processed, & one);
3018           sub = strstr (processed.ptr, expander);
3019           len = sprintf (sub, "%d", count);
3020           gas_assert (len < 8);
3021           strcpy (sub + len, sub + 8);
3022           processed.len -= (8 - len);
3023           sb_add_sb (& many, & processed);
3024           sb_kill (& processed);
3025         }
3026     }
3027   else
3028     while (count-- > 0)
3029       sb_add_sb (&many, &one);
3030
3031   sb_kill (&one);
3032
3033   input_scrub_include_sb (&many, input_line_pointer, 1);
3034   sb_kill (&many);
3035   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3036 }
3037
3038 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3039    input buffers to skip.  Assumes that conditionals preceding the loop end
3040    are properly nested.
3041
3042    This function makes it easier to implement a premature "break" out of the
3043    loop.  The EXTRA arg accounts for other buffers we might have inserted,
3044    such as line substitutions.  */
3045
3046 void
3047 end_repeat (int extra)
3048 {
3049   cond_exit_macro (macro_nest);
3050   while (extra-- >= 0)
3051     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3052 }
3053
3054 static void
3055 assign_symbol (char *name, int mode)
3056 {
3057   symbolS *symbolP;
3058
3059   if (name[0] == '.' && name[1] == '\0')
3060     {
3061       /* Turn '. = mumble' into a .org mumble.  */
3062       segT segment;
3063       expressionS exp;
3064
3065       segment = get_known_segmented_expression (&exp);
3066
3067       if (!need_pass_2)
3068         do_org (segment, &exp, 0);
3069
3070       return;
3071     }
3072
3073   if ((symbolP = symbol_find (name)) == NULL
3074       && (symbolP = md_undefined_symbol (name)) == NULL)
3075     {
3076       symbolP = symbol_find_or_make (name);
3077 #ifndef NO_LISTING
3078       /* When doing symbol listings, play games with dummy fragments living
3079          outside the normal fragment chain to record the file and line info
3080          for this symbol.  */
3081       if (listing & LISTING_SYMBOLS)
3082         {
3083           extern struct list_info_struct *listing_tail;
3084           fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3085           dummy_frag->line = listing_tail;
3086           dummy_frag->fr_symbol = symbolP;
3087           symbol_set_frag (symbolP, dummy_frag);
3088         }
3089 #endif
3090 #ifdef OBJ_COFF
3091       /* "set" symbols are local unless otherwise specified.  */
3092       SF_SET_LOCAL (symbolP);
3093 #endif
3094     }
3095
3096   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3097     {
3098       /* Permit register names to be redefined.  */
3099       if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3100           && S_GET_SEGMENT (symbolP) != reg_section)
3101         {
3102           as_bad (_("symbol `%s' is already defined"), name);
3103           symbolP = symbol_clone (symbolP, 0);
3104         }
3105       /* If the symbol is volatile, copy the symbol and replace the
3106          original with the copy, so that previous uses of the symbol will
3107          retain the value of the symbol at the point of use.  */
3108       else if (S_IS_VOLATILE (symbolP))
3109         symbolP = symbol_clone (symbolP, 1);
3110     }
3111
3112   if (mode == 0)
3113     S_SET_VOLATILE (symbolP);
3114   else if (mode < 0)
3115     S_SET_FORWARD_REF (symbolP);
3116
3117   pseudo_set (symbolP);
3118 }
3119
3120 /* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
3121    then this is .equiv, and it is an error if the symbol is already
3122    defined.  If EQUIV is -1, the symbol additionally is a forward
3123    reference.  */
3124
3125 void
3126 s_set (int equiv)
3127 {
3128   char *name;
3129   char delim;
3130   char *end_name;
3131
3132   /* Especial apologies for the random logic:
3133      this just grew, and could be parsed much more simply!
3134      Dean in haste.  */
3135   name = input_line_pointer;
3136   delim = get_symbol_end ();
3137   end_name = input_line_pointer;
3138   *end_name = delim;
3139
3140   if (name == end_name)
3141     {
3142       as_bad (_("expected symbol name"));
3143       ignore_rest_of_line ();
3144       return;
3145     }
3146
3147   SKIP_WHITESPACE ();
3148
3149   if (*input_line_pointer != ',')
3150     {
3151       *end_name = 0;
3152       as_bad (_("expected comma after \"%s\""), name);
3153       *end_name = delim;
3154       ignore_rest_of_line ();
3155       return;
3156     }
3157
3158   input_line_pointer++;
3159   *end_name = 0;
3160
3161   assign_symbol (name, equiv);
3162   *end_name = delim;
3163
3164   demand_empty_rest_of_line ();
3165 }
3166
3167 void
3168 s_space (int mult)
3169 {
3170   expressionS exp;
3171   expressionS val;
3172   char *p = 0;
3173   char *stop = NULL;
3174   char stopc = 0;
3175   int bytes;
3176
3177 #ifdef md_flush_pending_output
3178   md_flush_pending_output ();
3179 #endif
3180
3181 #ifdef md_cons_align
3182   md_cons_align (1);
3183 #endif
3184
3185   if (flag_mri)
3186     stop = mri_comment_field (&stopc);
3187
3188   /* In m68k MRI mode, we need to align to a word boundary, unless
3189      this is ds.b.  */
3190   if (flag_m68k_mri && mult > 1)
3191     {
3192       if (now_seg == absolute_section)
3193         {
3194           abs_section_offset += abs_section_offset & 1;
3195           if (line_label != NULL)
3196             S_SET_VALUE (line_label, abs_section_offset);
3197         }
3198       else if (mri_common_symbol != NULL)
3199         {
3200           valueT mri_val;
3201
3202           mri_val = S_GET_VALUE (mri_common_symbol);
3203           if ((mri_val & 1) != 0)
3204             {
3205               S_SET_VALUE (mri_common_symbol, mri_val + 1);
3206               if (line_label != NULL)
3207                 {
3208                   expressionS *symexp;
3209
3210                   symexp = symbol_get_value_expression (line_label);
3211                   know (symexp->X_op == O_symbol);
3212                   know (symexp->X_add_symbol == mri_common_symbol);
3213                   symexp->X_add_number += 1;
3214                 }
3215             }
3216         }
3217       else
3218         {
3219           do_align (1, (char *) NULL, 0, 0);
3220           if (line_label != NULL)
3221             {
3222               symbol_set_frag (line_label, frag_now);
3223               S_SET_VALUE (line_label, frag_now_fix ());
3224             }
3225         }
3226     }
3227
3228   bytes = mult;
3229
3230   expression (&exp);
3231
3232   SKIP_WHITESPACE ();
3233   if (*input_line_pointer == ',')
3234     {
3235       ++input_line_pointer;
3236       expression (&val);
3237     }
3238   else
3239     {
3240       val.X_op = O_constant;
3241       val.X_add_number = 0;
3242     }
3243
3244   if (val.X_op != O_constant
3245       || val.X_add_number < - 0x80
3246       || val.X_add_number > 0xff
3247       || (mult != 0 && mult != 1 && val.X_add_number != 0))
3248     {
3249       resolve_expression (&exp);
3250       if (exp.X_op != O_constant)
3251         as_bad (_("unsupported variable size or fill value"));
3252       else
3253         {
3254           offsetT i;
3255
3256           if (mult == 0)
3257             mult = 1;
3258           bytes = mult * exp.X_add_number;
3259           for (i = 0; i < exp.X_add_number; i++)
3260             emit_expr (&val, mult);
3261         }
3262     }
3263   else
3264     {
3265       if (now_seg == absolute_section || mri_common_symbol != NULL)
3266         resolve_expression (&exp);
3267
3268       if (exp.X_op == O_constant)
3269         {
3270           offsetT repeat;
3271
3272           repeat = exp.X_add_number;
3273           if (mult)
3274             repeat *= mult;
3275           bytes = repeat;
3276           if (repeat <= 0)
3277             {
3278               if (!flag_mri)
3279                 as_warn (_(".space repeat count is zero, ignored"));
3280               else if (repeat < 0)
3281                 as_warn (_(".space repeat count is negative, ignored"));
3282               goto getout;
3283             }
3284
3285           /* If we are in the absolute section, just bump the offset.  */
3286           if (now_seg == absolute_section)
3287             {
3288               abs_section_offset += repeat;
3289               goto getout;
3290             }
3291
3292           /* If we are secretly in an MRI common section, then
3293              creating space just increases the size of the common
3294              symbol.  */
3295           if (mri_common_symbol != NULL)
3296             {
3297               S_SET_VALUE (mri_common_symbol,
3298                            S_GET_VALUE (mri_common_symbol) + repeat);
3299               goto getout;
3300             }
3301
3302           if (!need_pass_2)
3303             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3304                           (offsetT) repeat, (char *) 0);
3305         }
3306       else
3307         {
3308           if (now_seg == absolute_section)
3309             {
3310               as_bad (_("space allocation too complex in absolute section"));
3311               subseg_set (text_section, 0);
3312             }
3313
3314           if (mri_common_symbol != NULL)
3315             {
3316               as_bad (_("space allocation too complex in common section"));
3317               mri_common_symbol = NULL;
3318             }
3319
3320           if (!need_pass_2)
3321             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3322                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3323         }
3324
3325       if (p)
3326         *p = val.X_add_number;
3327     }
3328
3329  getout:
3330
3331   /* In MRI mode, after an odd number of bytes, we must align to an
3332      even word boundary, unless the next instruction is a dc.b, ds.b
3333      or dcb.b.  */
3334   if (flag_mri && (bytes & 1) != 0)
3335     mri_pending_align = 1;
3336
3337   demand_empty_rest_of_line ();
3338
3339   if (flag_mri)
3340     mri_comment_end (stop, stopc);
3341 }
3342
3343 /* This is like s_space, but the value is a floating point number with
3344    the given precision.  This is for the MRI dcb.s pseudo-op and
3345    friends.  */
3346
3347 void
3348 s_float_space (int float_type)
3349 {
3350   offsetT count;
3351   int flen;
3352   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3353   char *stop = NULL;
3354   char stopc = 0;
3355
3356 #ifdef md_cons_align
3357   md_cons_align (1);
3358 #endif
3359
3360   if (flag_mri)
3361     stop = mri_comment_field (&stopc);
3362
3363   count = get_absolute_expression ();
3364
3365   SKIP_WHITESPACE ();
3366   if (*input_line_pointer != ',')
3367     {
3368       as_bad (_("missing value"));
3369       ignore_rest_of_line ();
3370       if (flag_mri)
3371         mri_comment_end (stop, stopc);
3372       return;
3373     }
3374
3375   ++input_line_pointer;
3376
3377   SKIP_WHITESPACE ();
3378
3379   /* Skip any 0{letter} that may be present.  Don't even check if the
3380    * letter is legal.  */
3381   if (input_line_pointer[0] == '0'
3382       && ISALPHA (input_line_pointer[1]))
3383     input_line_pointer += 2;
3384
3385   /* Accept :xxxx, where the x's are hex digits, for a floating point
3386      with the exact digits specified.  */
3387   if (input_line_pointer[0] == ':')
3388     {
3389       flen = hex_float (float_type, temp);
3390       if (flen < 0)
3391         {
3392           ignore_rest_of_line ();
3393           if (flag_mri)
3394             mri_comment_end (stop, stopc);
3395           return;
3396         }
3397     }
3398   else
3399     {
3400       char *err;
3401
3402       err = md_atof (float_type, temp, &flen);
3403       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3404       know (err != NULL || flen > 0);
3405       if (err)
3406         {
3407           as_bad (_("bad floating literal: %s"), err);
3408           ignore_rest_of_line ();
3409           if (flag_mri)
3410             mri_comment_end (stop, stopc);
3411           return;
3412         }
3413     }
3414
3415   while (--count >= 0)
3416     {
3417       char *p;
3418
3419       p = frag_more (flen);
3420       memcpy (p, temp, (unsigned int) flen);
3421     }
3422
3423   demand_empty_rest_of_line ();
3424
3425   if (flag_mri)
3426     mri_comment_end (stop, stopc);
3427 }
3428
3429 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3430
3431 void
3432 s_struct (int ignore ATTRIBUTE_UNUSED)
3433 {
3434   char *stop = NULL;
3435   char stopc = 0;
3436
3437   if (flag_mri)
3438     stop = mri_comment_field (&stopc);
3439   abs_section_offset = get_absolute_expression ();
3440 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3441   /* The ELF backend needs to know that we are changing sections, so
3442      that .previous works correctly. */
3443   if (IS_ELF)
3444     obj_elf_section_change_hook ();
3445 #endif
3446   subseg_set (absolute_section, 0);
3447   demand_empty_rest_of_line ();
3448   if (flag_mri)
3449     mri_comment_end (stop, stopc);
3450 }
3451
3452 void
3453 s_text (int ignore ATTRIBUTE_UNUSED)
3454 {
3455   register int temp;
3456
3457   temp = get_absolute_expression ();
3458   subseg_set (text_section, (subsegT) temp);
3459   demand_empty_rest_of_line ();
3460 #ifdef OBJ_VMS
3461   const_flag &= ~IN_DEFAULT_SECTION;
3462 #endif
3463 }
3464
3465 /* .weakref x, y sets x as an alias to y that, as long as y is not
3466    referenced directly, will cause y to become a weak symbol.  */
3467 void
3468 s_weakref (int ignore ATTRIBUTE_UNUSED)
3469 {
3470   char *name;
3471   char delim;
3472   char *end_name;
3473   symbolS *symbolP;
3474   symbolS *symbolP2;
3475   expressionS exp;
3476
3477   name = input_line_pointer;
3478   delim = get_symbol_end ();
3479   end_name = input_line_pointer;
3480
3481   if (name == end_name)
3482     {
3483       as_bad (_("expected symbol name"));
3484       *end_name = delim;
3485       ignore_rest_of_line ();
3486       return;
3487     }
3488
3489   symbolP = symbol_find_or_make (name);
3490
3491   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3492     {
3493       if (!S_IS_VOLATILE (symbolP))
3494         {
3495           as_bad (_("symbol `%s' is already defined"), name);
3496           *end_name = delim;
3497           ignore_rest_of_line ();
3498           return;
3499         }
3500       symbolP = symbol_clone (symbolP, 1);
3501       S_CLEAR_VOLATILE (symbolP);
3502     }
3503
3504   *end_name = delim;
3505
3506   SKIP_WHITESPACE ();
3507
3508   if (*input_line_pointer != ',')
3509     {
3510       *end_name = 0;
3511       as_bad (_("expected comma after \"%s\""), name);
3512       *end_name = delim;
3513       ignore_rest_of_line ();
3514       return;
3515     }
3516
3517   input_line_pointer++;
3518
3519   SKIP_WHITESPACE ();
3520
3521   name = input_line_pointer;
3522   delim = get_symbol_end ();
3523   end_name = input_line_pointer;
3524
3525   if (name == end_name)
3526     {
3527       as_bad (_("expected symbol name"));
3528       ignore_rest_of_line ();
3529       return;
3530     }
3531
3532   if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3533       && (symbolP2 = md_undefined_symbol (name)) == NULL)
3534     {
3535       symbolP2 = symbol_find_or_make (name);
3536       S_SET_WEAKREFD (symbolP2);
3537     }
3538   else
3539     {
3540       symbolS *symp = symbolP2;
3541
3542       while (S_IS_WEAKREFR (symp) && symp != symbolP)
3543         {
3544           expressionS *expP = symbol_get_value_expression (symp);
3545
3546           gas_assert (expP->X_op == O_symbol
3547                   && expP->X_add_number == 0);
3548           symp = expP->X_add_symbol;
3549         }
3550       if (symp == symbolP)
3551         {
3552           char *loop;
3553
3554           loop = concat (S_GET_NAME (symbolP),
3555                          " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3556
3557           symp = symbolP2;
3558           while (symp != symbolP)
3559             {
3560               char *old_loop = loop;
3561               symp = symbol_get_value_expression (symp)->X_add_symbol;
3562               loop = concat (loop, " => ", S_GET_NAME (symp),
3563                              (const char *) NULL);
3564               free (old_loop);
3565             }
3566
3567           as_bad (_("%s: would close weakref loop: %s"),
3568                   S_GET_NAME (symbolP), loop);
3569
3570           free (loop);
3571
3572           *end_name = delim;
3573           ignore_rest_of_line ();
3574           return;
3575         }
3576
3577       /* Short-circuiting instead of just checking here might speed
3578          things up a tiny little bit, but loop error messages would
3579          miss intermediate links.  */
3580       /* symbolP2 = symp; */
3581     }
3582
3583   *end_name = delim;
3584
3585   memset (&exp, 0, sizeof (exp));
3586   exp.X_op = O_symbol;
3587   exp.X_add_symbol = symbolP2;
3588
3589   S_SET_SEGMENT (symbolP, undefined_section);
3590   symbol_set_value_expression (symbolP, &exp);
3591   symbol_set_frag (symbolP, &zero_address_frag);
3592   S_SET_WEAKREFR (symbolP);
3593
3594   demand_empty_rest_of_line ();
3595 }
3596 \f
3597
3598 /* Verify that we are at the end of a line.  If not, issue an error and
3599    skip to EOL.  */
3600
3601 void
3602 demand_empty_rest_of_line (void)
3603 {
3604   SKIP_WHITESPACE ();
3605   if (is_end_of_line[(unsigned char) *input_line_pointer])
3606     input_line_pointer++;
3607   else
3608     {
3609       if (ISPRINT (*input_line_pointer))
3610         as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3611                  *input_line_pointer);
3612       else
3613         as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3614                  *input_line_pointer);
3615       ignore_rest_of_line ();
3616     }
3617
3618   /* Return pointing just after end-of-line.  */
3619   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3620 }
3621
3622 /* Silently advance to the end of line.  Use this after already having
3623    issued an error about something bad.  */
3624
3625 void
3626 ignore_rest_of_line (void)
3627 {
3628   while (input_line_pointer < buffer_limit
3629          && !is_end_of_line[(unsigned char) *input_line_pointer])
3630     input_line_pointer++;
3631
3632   input_line_pointer++;
3633
3634   /* Return pointing just after end-of-line.  */
3635   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3636 }
3637
3638 /* Sets frag for given symbol to zero_address_frag, except when the
3639    symbol frag is already set to a dummy listing frag.  */
3640
3641 static void
3642 set_zero_frag (symbolS *symbolP)
3643 {
3644   if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3645     symbol_set_frag (symbolP, &zero_address_frag);
3646 }
3647
3648 /* In:  Pointer to a symbol.
3649         Input_line_pointer->expression.
3650
3651    Out: Input_line_pointer->just after any whitespace after expression.
3652         Tried to set symbol to value of expression.
3653         Will change symbols type, value, and frag;  */
3654
3655 void
3656 pseudo_set (symbolS *symbolP)
3657 {
3658   expressionS exp;
3659   segT seg;
3660
3661   know (symbolP);               /* NULL pointer is logic error.  */
3662
3663   if (!S_IS_FORWARD_REF (symbolP))
3664     (void) expression (&exp);
3665   else
3666     (void) deferred_expression (&exp);
3667
3668   if (exp.X_op == O_illegal)
3669     as_bad (_("illegal expression"));
3670   else if (exp.X_op == O_absent)
3671     as_bad (_("missing expression"));
3672   else if (exp.X_op == O_big)
3673     {
3674       if (exp.X_add_number > 0)
3675         as_bad (_("bignum invalid"));
3676       else
3677         as_bad (_("floating point number invalid"));
3678     }
3679   else if (exp.X_op == O_subtract
3680            && !S_IS_FORWARD_REF (symbolP)
3681            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3682            && (symbol_get_frag (exp.X_add_symbol)
3683                == symbol_get_frag (exp.X_op_symbol)))
3684     {
3685       exp.X_op = O_constant;
3686       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3687                           - S_GET_VALUE (exp.X_op_symbol));
3688     }
3689
3690   if (symbol_section_p (symbolP))
3691     {
3692       as_bad ("attempt to set value of section symbol");
3693       return;
3694     }
3695
3696   switch (exp.X_op)
3697     {
3698     case O_illegal:
3699     case O_absent:
3700     case O_big:
3701       exp.X_add_number = 0;
3702       /* Fall through.  */
3703     case O_constant:
3704       S_SET_SEGMENT (symbolP, absolute_section);
3705       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3706       set_zero_frag (symbolP);
3707       break;
3708
3709     case O_register:
3710 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3711       if (S_IS_EXTERNAL (symbolP))
3712         {
3713           as_bad ("can't equate global symbol `%s' with register name",
3714                   S_GET_NAME (symbolP));
3715           return;
3716         }
3717 #endif
3718       S_SET_SEGMENT (symbolP, reg_section);
3719       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3720       set_zero_frag (symbolP);
3721       symbol_get_value_expression (symbolP)->X_op = O_register;
3722       break;
3723
3724     case O_symbol:
3725       seg = S_GET_SEGMENT (exp.X_add_symbol);
3726       /* For x=undef+const, create an expression symbol.
3727          For x=x+const, just update x except when x is an undefined symbol
3728          For x=defined+const, evaluate x.  */
3729       if (symbolP == exp.X_add_symbol
3730           && (seg != undefined_section
3731               || !symbol_constant_p (symbolP)))
3732         {
3733           *symbol_X_add_number (symbolP) += exp.X_add_number;
3734           break;
3735         }
3736       else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3737         {
3738           symbolS *s = exp.X_add_symbol;
3739
3740           if (S_IS_COMMON (s))
3741             as_bad (_("`%s' can't be equated to common symbol '%s'"),
3742                     S_GET_NAME (symbolP), S_GET_NAME (s));
3743
3744           S_SET_SEGMENT (symbolP, seg);
3745           S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3746           symbol_set_frag (symbolP, symbol_get_frag (s));
3747           copy_symbol_attributes (symbolP, s);
3748           break;
3749         }
3750       S_SET_SEGMENT (symbolP, undefined_section);
3751       symbol_set_value_expression (symbolP, &exp);
3752       copy_symbol_attributes (symbolP, exp.X_add_symbol);
3753       set_zero_frag (symbolP);
3754       break;
3755
3756     default:
3757       /* The value is some complex expression.  */
3758       S_SET_SEGMENT (symbolP, expr_section);
3759       symbol_set_value_expression (symbolP, &exp);
3760       set_zero_frag (symbolP);
3761       break;
3762     }
3763 }
3764 \f
3765 /*                      cons()
3766
3767    CONStruct more frag of .bytes, or .words etc.
3768    Should need_pass_2 be 1 then emit no frag(s).
3769    This understands EXPRESSIONS.
3770
3771    Bug (?)
3772
3773    This has a split personality. We use expression() to read the
3774    value. We can detect if the value won't fit in a byte or word.
3775    But we can't detect if expression() discarded significant digits
3776    in the case of a long. Not worth the crocks required to fix it.  */
3777
3778 /* Select a parser for cons expressions.  */
3779
3780 /* Some targets need to parse the expression in various fancy ways.
3781    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3782    (for example, the HPPA does this).  Otherwise, you can define
3783    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3784    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3785    are defined, which is the normal case, then only simple expressions
3786    are permitted.  */
3787
3788 #ifdef TC_M68K
3789 static void
3790 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3791 #endif
3792
3793 #ifndef TC_PARSE_CONS_EXPRESSION
3794 #ifdef BITFIELD_CONS_EXPRESSIONS
3795 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3796 static void
3797 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3798 #endif
3799 #ifdef REPEAT_CONS_EXPRESSIONS
3800 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3801 static void
3802 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3803 #endif
3804
3805 /* If we haven't gotten one yet, just call expression.  */
3806 #ifndef TC_PARSE_CONS_EXPRESSION
3807 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3808 #endif
3809 #endif
3810
3811 void
3812 do_parse_cons_expression (expressionS *exp,
3813                           int nbytes ATTRIBUTE_UNUSED)
3814 {
3815   TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3816 }
3817
3818
3819 /* Worker to do .byte etc statements.
3820    Clobbers input_line_pointer and checks end-of-line.  */
3821
3822 static void
3823 cons_worker (register int nbytes,       /* 1=.byte, 2=.word, 4=.long.  */
3824              int rva)
3825 {
3826   int c;
3827   expressionS exp;
3828   char *stop = NULL;
3829   char stopc = 0;
3830
3831 #ifdef md_flush_pending_output
3832   md_flush_pending_output ();
3833 #endif
3834
3835   if (flag_mri)
3836     stop = mri_comment_field (&stopc);
3837
3838   if (is_it_end_of_statement ())
3839     {
3840       demand_empty_rest_of_line ();
3841       if (flag_mri)
3842         mri_comment_end (stop, stopc);
3843       return;
3844     }
3845
3846 #ifdef TC_ADDRESS_BYTES
3847   if (nbytes == 0)
3848     nbytes = TC_ADDRESS_BYTES ();
3849 #endif
3850
3851 #ifdef md_cons_align
3852   md_cons_align (nbytes);
3853 #endif
3854
3855   c = 0;
3856   do
3857     {
3858 #ifdef TC_M68K
3859       if (flag_m68k_mri)
3860         parse_mri_cons (&exp, (unsigned int) nbytes);
3861       else
3862 #endif
3863         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3864
3865       if (rva)
3866         {
3867           if (exp.X_op == O_symbol)
3868             exp.X_op = O_symbol_rva;
3869           else
3870             as_fatal (_("rva without symbol"));
3871         }
3872       emit_expr (&exp, (unsigned int) nbytes);
3873       ++c;
3874     }
3875   while (*input_line_pointer++ == ',');
3876
3877   /* In MRI mode, after an odd number of bytes, we must align to an
3878      even word boundary, unless the next instruction is a dc.b, ds.b
3879      or dcb.b.  */
3880   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3881     mri_pending_align = 1;
3882
3883   input_line_pointer--;         /* Put terminator back into stream.  */
3884
3885   demand_empty_rest_of_line ();
3886
3887   if (flag_mri)
3888     mri_comment_end (stop, stopc);
3889 }
3890
3891 void
3892 cons (int size)
3893 {
3894   cons_worker (size, 0);
3895 }
3896
3897 void
3898 s_rva (int size)
3899 {
3900   cons_worker (size, 1);
3901 }
3902
3903 /* .reloc offset, reloc_name, symbol+addend.  */
3904
3905 void
3906 s_reloc (int ignore ATTRIBUTE_UNUSED)
3907 {
3908   char *stop = NULL;
3909   char stopc = 0;
3910   expressionS exp;
3911   char *r_name;
3912   int c;
3913   struct reloc_list *reloc;
3914
3915   reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
3916
3917   if (flag_mri)
3918     stop = mri_comment_field (&stopc);
3919
3920   expression (&exp);
3921   switch (exp.X_op)
3922     {
3923     case O_illegal:
3924     case O_absent:
3925     case O_big:
3926     case O_register:
3927       as_bad (_("missing or bad offset expression"));
3928       goto err_out;
3929     case O_constant:
3930       exp.X_add_symbol = section_symbol (now_seg);
3931       exp.X_op = O_symbol;
3932       /* Fall thru */
3933     case O_symbol:
3934       if (exp.X_add_number == 0)
3935         {
3936           reloc->u.a.offset_sym = exp.X_add_symbol;
3937           break;
3938         }
3939       /* Fall thru */
3940     default:
3941       reloc->u.a.offset_sym = make_expr_symbol (&exp);
3942       break;
3943     }
3944
3945   SKIP_WHITESPACE ();
3946   if (*input_line_pointer != ',')
3947     {
3948       as_bad (_("missing reloc type"));
3949       goto err_out;
3950     }
3951
3952   ++input_line_pointer;
3953   SKIP_WHITESPACE ();
3954   r_name = input_line_pointer;
3955   c = get_symbol_end ();
3956   reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3957   *input_line_pointer = c;
3958   if (reloc->u.a.howto == NULL)
3959     {
3960       as_bad (_("unrecognized reloc type"));
3961       goto err_out;
3962     }
3963
3964   exp.X_op = O_absent;
3965   SKIP_WHITESPACE ();
3966   if (*input_line_pointer == ',')
3967     {
3968       ++input_line_pointer;
3969       expression (&exp);
3970     }
3971   switch (exp.X_op)
3972     {
3973     case O_illegal:
3974     case O_big:
3975     case O_register:
3976       as_bad (_("bad reloc expression"));
3977     err_out:
3978       ignore_rest_of_line ();
3979       free (reloc);
3980       if (flag_mri)
3981         mri_comment_end (stop, stopc);
3982       return;
3983     case O_absent:
3984       reloc->u.a.sym = NULL;
3985       reloc->u.a.addend = 0;
3986       break;
3987     case O_constant:
3988       reloc->u.a.sym = NULL;
3989       reloc->u.a.addend = exp.X_add_number;
3990       break;
3991     case O_symbol:
3992       reloc->u.a.sym = exp.X_add_symbol;
3993       reloc->u.a.addend = exp.X_add_number;
3994       break;
3995     default:
3996       reloc->u.a.sym = make_expr_symbol (&exp);
3997       reloc->u.a.addend = 0;
3998       break;
3999     }
4000
4001   as_where (&reloc->file, &reloc->line);
4002   reloc->next = reloc_list;
4003   reloc_list = reloc;
4004
4005   demand_empty_rest_of_line ();
4006   if (flag_mri)
4007     mri_comment_end (stop, stopc);
4008 }
4009
4010 /* Put the contents of expression EXP into the object file using
4011    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
4012
4013 void
4014 emit_expr (expressionS *exp, unsigned int nbytes)
4015 {
4016   operatorT op;
4017   register char *p;
4018   valueT extra_digit = 0;
4019
4020   /* Don't do anything if we are going to make another pass.  */
4021   if (need_pass_2)
4022     return;
4023
4024   /* Grow the current frag now so that dot_value does not get invalidated
4025      if the frag were to fill up in the frag_more() call below.  */
4026   frag_grow (nbytes);
4027   dot_value = frag_now_fix ();
4028
4029 #ifndef NO_LISTING
4030 #ifdef OBJ_ELF
4031   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4032      appear as a four byte positive constant in the .line section,
4033      followed by a 2 byte 0xffff.  Look for that case here.  */
4034   {
4035     static int dwarf_line = -1;
4036
4037     if (strcmp (segment_name (now_seg), ".line") != 0)
4038       dwarf_line = -1;
4039     else if (dwarf_line >= 0
4040              && nbytes == 2
4041              && exp->X_op == O_constant
4042              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4043       listing_source_line ((unsigned int) dwarf_line);
4044     else if (nbytes == 4
4045              && exp->X_op == O_constant
4046              && exp->X_add_number >= 0)
4047       dwarf_line = exp->X_add_number;
4048     else
4049       dwarf_line = -1;
4050   }
4051
4052   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4053      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4054      AT_sibling (0x12) followed by a four byte address of the sibling
4055      followed by a 2 byte AT_name (0x38) followed by the name of the
4056      file.  We look for that case here.  */
4057   {
4058     static int dwarf_file = 0;
4059
4060     if (strcmp (segment_name (now_seg), ".debug") != 0)
4061       dwarf_file = 0;
4062     else if (dwarf_file == 0
4063              && nbytes == 2
4064              && exp->X_op == O_constant
4065              && exp->X_add_number == 0x11)
4066       dwarf_file = 1;
4067     else if (dwarf_file == 1
4068              && nbytes == 2
4069              && exp->X_op == O_constant
4070              && exp->X_add_number == 0x12)
4071       dwarf_file = 2;
4072     else if (dwarf_file == 2
4073              && nbytes == 4)
4074       dwarf_file = 3;
4075     else if (dwarf_file == 3
4076              && nbytes == 2
4077              && exp->X_op == O_constant
4078              && exp->X_add_number == 0x38)
4079       dwarf_file = 4;
4080     else
4081       dwarf_file = 0;
4082
4083     /* The variable dwarf_file_string tells stringer that the string
4084        may be the name of the source file.  */
4085     if (dwarf_file == 4)
4086       dwarf_file_string = 1;
4087     else
4088       dwarf_file_string = 0;
4089   }
4090 #endif
4091 #endif
4092
4093   if (check_eh_frame (exp, &nbytes))
4094     return;
4095
4096   op = exp->X_op;
4097
4098   /* Allow `.word 0' in the absolute section.  */
4099   if (now_seg == absolute_section)
4100     {
4101       if (op != O_constant || exp->X_add_number != 0)
4102         as_bad (_("attempt to store value in absolute section"));
4103       abs_section_offset += nbytes;
4104       return;
4105     }
4106
4107   /* Handle a negative bignum.  */
4108   if (op == O_uminus
4109       && exp->X_add_number == 0
4110       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4111       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4112     {
4113       int i;
4114       unsigned long carry;
4115
4116       exp = symbol_get_value_expression (exp->X_add_symbol);
4117
4118       /* Negate the bignum: one's complement each digit and add 1.  */
4119       carry = 1;
4120       for (i = 0; i < exp->X_add_number; i++)
4121         {
4122           unsigned long next;
4123
4124           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4125                    & LITTLENUM_MASK)
4126                   + carry);
4127           generic_bignum[i] = next & LITTLENUM_MASK;
4128           carry = next >> LITTLENUM_NUMBER_OF_BITS;
4129         }
4130
4131       /* We can ignore any carry out, because it will be handled by
4132          extra_digit if it is needed.  */
4133
4134       extra_digit = (valueT) -1;
4135       op = O_big;
4136     }
4137
4138   if (op == O_absent || op == O_illegal)
4139     {
4140       as_warn (_("zero assumed for missing expression"));
4141       exp->X_add_number = 0;
4142       op = O_constant;
4143     }
4144   else if (op == O_big && exp->X_add_number <= 0)
4145     {
4146       as_bad (_("floating point number invalid"));
4147       exp->X_add_number = 0;
4148       op = O_constant;
4149     }
4150   else if (op == O_register)
4151     {
4152       as_warn (_("register value used as expression"));
4153       op = O_constant;
4154     }
4155
4156   p = frag_more ((int) nbytes);
4157
4158 #ifndef WORKING_DOT_WORD
4159   /* If we have the difference of two symbols in a word, save it on
4160      the broken_words list.  See the code in write.c.  */
4161   if (op == O_subtract && nbytes == 2)
4162     {
4163       struct broken_word *x;
4164
4165       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4166       x->next_broken_word = broken_words;
4167       broken_words = x;
4168       x->seg = now_seg;
4169       x->subseg = now_subseg;
4170       x->frag = frag_now;
4171       x->word_goes_here = p;
4172       x->dispfrag = 0;
4173       x->add = exp->X_add_symbol;
4174       x->sub = exp->X_op_symbol;
4175       x->addnum = exp->X_add_number;
4176       x->added = 0;
4177       x->use_jump = 0;
4178       new_broken_words++;
4179       return;
4180     }
4181 #endif
4182
4183   /* If we have an integer, but the number of bytes is too large to
4184      pass to md_number_to_chars, handle it as a bignum.  */
4185   if (op == O_constant && nbytes > sizeof (valueT))
4186     {
4187       extra_digit = exp->X_unsigned ? 0 : -1;
4188       convert_to_bignum (exp);
4189       op = O_big;
4190     }
4191
4192   if (op == O_constant)
4193     {
4194       register valueT get;
4195       register valueT use;
4196       register valueT mask;
4197       valueT hibit;
4198       register valueT unmask;
4199
4200       /* JF << of >= number of bits in the object is undefined.  In
4201          particular SPARC (Sun 4) has problems.  */
4202       if (nbytes >= sizeof (valueT))
4203         {
4204           mask = 0;
4205           if (nbytes > sizeof (valueT))
4206             hibit = 0;
4207           else
4208             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4209         }
4210       else
4211         {
4212           /* Don't store these bits.  */
4213           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4214           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4215         }
4216
4217       unmask = ~mask;           /* Do store these bits.  */
4218
4219 #ifdef NEVER
4220       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4221       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
4222 #endif
4223
4224       get = exp->X_add_number;
4225       use = get & unmask;
4226       if ((get & mask) != 0
4227           && ((get & mask) != mask
4228               || (get & hibit) == 0))
4229         {               /* Leading bits contain both 0s & 1s.  */
4230 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4231 #ifndef __MSVCRT__
4232           as_warn (_("value 0x%llx truncated to 0x%llx"),
4233                    (unsigned long long) get, (unsigned long long) use);
4234 #else
4235           as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4236                    (unsigned long long) get, (unsigned long long) use);
4237 #endif
4238 #else
4239           as_warn (_("value 0x%lx truncated to 0x%lx"),
4240                    (unsigned long) get, (unsigned long) use);
4241 #endif
4242         }
4243       /* Put bytes in right order.  */
4244       md_number_to_chars (p, use, (int) nbytes);
4245     }
4246   else if (op == O_big)
4247     {
4248       unsigned int size;
4249       LITTLENUM_TYPE *nums;
4250
4251       know (nbytes % CHARS_PER_LITTLENUM == 0);
4252
4253       size = exp->X_add_number * CHARS_PER_LITTLENUM;
4254       if (nbytes < size)
4255         {
4256           as_warn (_("bignum truncated to %d bytes"), nbytes);
4257           size = nbytes;
4258         }
4259
4260       if (target_big_endian)
4261         {
4262           while (nbytes > size)
4263             {
4264               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4265               nbytes -= CHARS_PER_LITTLENUM;
4266               p += CHARS_PER_LITTLENUM;
4267             }
4268
4269           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4270           while (size >= CHARS_PER_LITTLENUM)
4271             {
4272               --nums;
4273               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4274               size -= CHARS_PER_LITTLENUM;
4275               p += CHARS_PER_LITTLENUM;
4276             }
4277         }
4278       else
4279         {
4280           nums = generic_bignum;
4281           while (size >= CHARS_PER_LITTLENUM)
4282             {
4283               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4284               ++nums;
4285               size -= CHARS_PER_LITTLENUM;
4286               p += CHARS_PER_LITTLENUM;
4287               nbytes -= CHARS_PER_LITTLENUM;
4288             }
4289
4290           while (nbytes >= CHARS_PER_LITTLENUM)
4291             {
4292               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4293               nbytes -= CHARS_PER_LITTLENUM;
4294               p += CHARS_PER_LITTLENUM;
4295             }
4296         }
4297     }
4298   else
4299     emit_expr_fix (exp, nbytes, frag_now, p);
4300 }
4301
4302 void
4303 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4304 {
4305   memset (p, 0, nbytes);
4306
4307   /* Generate a fixS to record the symbol value.  */
4308
4309 #ifdef TC_CONS_FIX_NEW
4310   TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4311 #else
4312   {
4313     bfd_reloc_code_real_type r;
4314
4315     switch (nbytes)
4316       {
4317       case 1:
4318         r = BFD_RELOC_8;
4319         break;
4320       case 2:
4321         r = BFD_RELOC_16;
4322         break;
4323       case 3:
4324         r = BFD_RELOC_24;
4325         break;
4326       case 4:
4327         r = BFD_RELOC_32;
4328         break;
4329       case 8:
4330         r = BFD_RELOC_64;
4331         break;
4332       default:
4333         as_bad (_("unsupported BFD relocation size %u"), nbytes);
4334         r = BFD_RELOC_32;
4335         break;
4336       }
4337     fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4338                  0, r);
4339   }
4340 #endif
4341 }
4342 \f
4343 #ifdef BITFIELD_CONS_EXPRESSIONS
4344
4345 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4346    w:x,y:z, where w and y are bitwidths and x and y are values.  They
4347    then pack them all together. We do a little better in that we allow
4348    them in words, longs, etc. and we'll pack them in target byte order
4349    for you.
4350
4351    The rules are: pack least significant bit first, if a field doesn't
4352    entirely fit, put it in the next unit.  Overflowing the bitfield is
4353    explicitly *not* even a warning.  The bitwidth should be considered
4354    a "mask".
4355
4356    To use this function the tc-XXX.h file should define
4357    BITFIELD_CONS_EXPRESSIONS.  */
4358
4359 static void
4360 parse_bitfield_cons (exp, nbytes)
4361      expressionS *exp;
4362      unsigned int nbytes;
4363 {
4364   unsigned int bits_available = BITS_PER_CHAR * nbytes;
4365   char *hold = input_line_pointer;
4366
4367   (void) expression (exp);
4368
4369   if (*input_line_pointer == ':')
4370     {
4371       /* Bitfields.  */
4372       long value = 0;
4373
4374       for (;;)
4375         {
4376           unsigned long width;
4377
4378           if (*input_line_pointer != ':')
4379             {
4380               input_line_pointer = hold;
4381               break;
4382             }                   /* Next piece is not a bitfield.  */
4383
4384           /* In the general case, we can't allow
4385              full expressions with symbol
4386              differences and such.  The relocation
4387              entries for symbols not defined in this
4388              assembly would require arbitrary field
4389              widths, positions, and masks which most
4390              of our current object formats don't
4391              support.
4392
4393              In the specific case where a symbol
4394              *is* defined in this assembly, we
4395              *could* build fixups and track it, but
4396              this could lead to confusion for the
4397              backends.  I'm lazy. I'll take any
4398              SEG_ABSOLUTE. I think that means that
4399              you can use a previous .set or
4400              .equ type symbol.  xoxorich.  */
4401
4402           if (exp->X_op == O_absent)
4403             {
4404               as_warn (_("using a bit field width of zero"));
4405               exp->X_add_number = 0;
4406               exp->X_op = O_constant;
4407             }                   /* Implied zero width bitfield.  */
4408
4409           if (exp->X_op != O_constant)
4410             {
4411               *input_line_pointer = '\0';
4412               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4413               *input_line_pointer = ':';
4414               demand_empty_rest_of_line ();
4415               return;
4416             }                   /* Too complex.  */
4417
4418           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4419             {
4420               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4421                        width, nbytes, (BITS_PER_CHAR * nbytes));
4422               width = BITS_PER_CHAR * nbytes;
4423             }                   /* Too big.  */
4424
4425           if (width > bits_available)
4426             {
4427               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
4428               input_line_pointer = hold;
4429               exp->X_add_number = value;
4430               break;
4431             }                   /* Won't fit.  */
4432
4433           /* Skip ':'.  */
4434           hold = ++input_line_pointer;
4435
4436           (void) expression (exp);
4437           if (exp->X_op != O_constant)
4438             {
4439               char cache = *input_line_pointer;
4440
4441               *input_line_pointer = '\0';
4442               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4443               *input_line_pointer = cache;
4444               demand_empty_rest_of_line ();
4445               return;
4446             }                   /* Too complex.  */
4447
4448           value |= ((~(-1 << width) & exp->X_add_number)
4449                     << ((BITS_PER_CHAR * nbytes) - bits_available));
4450
4451           if ((bits_available -= width) == 0
4452               || is_it_end_of_statement ()
4453               || *input_line_pointer != ',')
4454             {
4455               break;
4456             }                   /* All the bitfields we're gonna get.  */
4457
4458           hold = ++input_line_pointer;
4459           (void) expression (exp);
4460         }
4461
4462       exp->X_add_number = value;
4463       exp->X_op = O_constant;
4464       exp->X_unsigned = 1;
4465     }
4466 }
4467
4468 #endif /* BITFIELD_CONS_EXPRESSIONS */
4469 \f
4470 /* Handle an MRI style string expression.  */
4471
4472 #ifdef TC_M68K
4473 static void
4474 parse_mri_cons (exp, nbytes)
4475      expressionS *exp;
4476      unsigned int nbytes;
4477 {
4478   if (*input_line_pointer != '\''
4479       && (input_line_pointer[1] != '\''
4480           || (*input_line_pointer != 'A'
4481               && *input_line_pointer != 'E')))
4482     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4483   else
4484     {
4485       unsigned int scan;
4486       unsigned int result = 0;
4487
4488       /* An MRI style string.  Cut into as many bytes as will fit into
4489          a nbyte chunk, left justify if necessary, and separate with
4490          commas so we can try again later.  */
4491       if (*input_line_pointer == 'A')
4492         ++input_line_pointer;
4493       else if (*input_line_pointer == 'E')
4494         {
4495           as_bad (_("EBCDIC constants are not supported"));
4496           ++input_line_pointer;
4497         }
4498
4499       input_line_pointer++;
4500       for (scan = 0; scan < nbytes; scan++)
4501         {
4502           if (*input_line_pointer == '\'')
4503             {
4504               if (input_line_pointer[1] == '\'')
4505                 {
4506                   input_line_pointer++;
4507                 }
4508               else
4509                 break;
4510             }
4511           result = (result << 8) | (*input_line_pointer++);
4512         }
4513
4514       /* Left justify.  */
4515       while (scan < nbytes)
4516         {
4517           result <<= 8;
4518           scan++;
4519         }
4520
4521       /* Create correct expression.  */
4522       exp->X_op = O_constant;
4523       exp->X_add_number = result;
4524
4525       /* Fake it so that we can read the next char too.  */
4526       if (input_line_pointer[0] != '\'' ||
4527           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4528         {
4529           input_line_pointer -= 2;
4530           input_line_pointer[0] = ',';
4531           input_line_pointer[1] = '\'';
4532         }
4533       else
4534         input_line_pointer++;
4535     }
4536 }
4537 #endif /* TC_M68K */
4538 \f
4539 #ifdef REPEAT_CONS_EXPRESSIONS
4540
4541 /* Parse a repeat expression for cons.  This is used by the MIPS
4542    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
4543    object file COUNT times.
4544
4545    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
4546
4547 static void
4548 parse_repeat_cons (exp, nbytes)
4549      expressionS *exp;
4550      unsigned int nbytes;
4551 {
4552   expressionS count;
4553   register int i;
4554
4555   expression (exp);
4556
4557   if (*input_line_pointer != ':')
4558     {
4559       /* No repeat count.  */
4560       return;
4561     }
4562
4563   ++input_line_pointer;
4564   expression (&count);
4565   if (count.X_op != O_constant
4566       || count.X_add_number <= 0)
4567     {
4568       as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4569       return;
4570     }
4571
4572   /* The cons function is going to output this expression once.  So we
4573      output it count - 1 times.  */
4574   for (i = count.X_add_number - 1; i > 0; i--)
4575     emit_expr (exp, nbytes);
4576 }
4577
4578 #endif /* REPEAT_CONS_EXPRESSIONS */
4579 \f
4580 /* Parse a floating point number represented as a hex constant.  This
4581    permits users to specify the exact bits they want in the floating
4582    point number.  */
4583
4584 static int
4585 hex_float (int float_type, char *bytes)
4586 {
4587   int length;
4588   int i;
4589
4590   switch (float_type)
4591     {
4592     case 'f':
4593     case 'F':
4594     case 's':
4595     case 'S':
4596       length = 4;
4597       break;
4598
4599     case 'd':
4600     case 'D':
4601     case 'r':
4602     case 'R':
4603       length = 8;
4604       break;
4605
4606     case 'x':
4607     case 'X':
4608       length = 12;
4609       break;
4610
4611     case 'p':
4612     case 'P':
4613       length = 12;
4614       break;
4615
4616     default:
4617       as_bad (_("unknown floating type type '%c'"), float_type);
4618       return -1;
4619     }
4620
4621   /* It would be nice if we could go through expression to parse the
4622      hex constant, but if we get a bignum it's a pain to sort it into
4623      the buffer correctly.  */
4624   i = 0;
4625   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4626     {
4627       int d;
4628
4629       /* The MRI assembler accepts arbitrary underscores strewn about
4630          through the hex constant, so we ignore them as well.  */
4631       if (*input_line_pointer == '_')
4632         {
4633           ++input_line_pointer;
4634           continue;
4635         }
4636
4637       if (i >= length)
4638         {
4639           as_warn (_("floating point constant too large"));
4640           return -1;
4641         }
4642       d = hex_value (*input_line_pointer) << 4;
4643       ++input_line_pointer;
4644       while (*input_line_pointer == '_')
4645         ++input_line_pointer;
4646       if (hex_p (*input_line_pointer))
4647         {
4648           d += hex_value (*input_line_pointer);
4649           ++input_line_pointer;
4650         }
4651       if (target_big_endian)
4652         bytes[i] = d;
4653       else
4654         bytes[length - i - 1] = d;
4655       ++i;
4656     }
4657
4658   if (i < length)
4659     {
4660       if (target_big_endian)
4661         memset (bytes + i, 0, length - i);
4662       else
4663         memset (bytes, 0, length - i);
4664     }
4665
4666   return length;
4667 }
4668
4669 /*                      float_cons()
4670
4671    CONStruct some more frag chars of .floats .ffloats etc.
4672    Makes 0 or more new frags.
4673    If need_pass_2 == 1, no frags are emitted.
4674    This understands only floating literals, not expressions. Sorry.
4675
4676    A floating constant is defined by atof_generic(), except it is preceded
4677    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4678    reading, I decided to be incompatible. This always tries to give you
4679    rounded bits to the precision of the pseudo-op. Former AS did premature
4680    truncation, restored noisy bits instead of trailing 0s AND gave you
4681    a choice of 2 flavours of noise according to which of 2 floating-point
4682    scanners you directed AS to use.
4683
4684    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
4685
4686 void
4687 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
4688             register int float_type     /* 'f':.ffloat ... 'F':.float ...  */)
4689 {
4690   register char *p;
4691   int length;                   /* Number of chars in an object.  */
4692   register char *err;           /* Error from scanning floating literal.  */
4693   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4694
4695   if (is_it_end_of_statement ())
4696     {
4697       demand_empty_rest_of_line ();
4698       return;
4699     }
4700
4701 #ifdef md_flush_pending_output
4702   md_flush_pending_output ();
4703 #endif
4704
4705 #ifdef md_cons_align
4706   md_cons_align (1);
4707 #endif
4708
4709   do
4710     {
4711       /* input_line_pointer->1st char of a flonum (we hope!).  */
4712       SKIP_WHITESPACE ();
4713
4714       /* Skip any 0{letter} that may be present. Don't even check if the
4715          letter is legal. Someone may invent a "z" format and this routine
4716          has no use for such information. Lusers beware: you get
4717          diagnostics if your input is ill-conditioned.  */
4718       if (input_line_pointer[0] == '0'
4719           && ISALPHA (input_line_pointer[1]))
4720         input_line_pointer += 2;
4721
4722       /* Accept :xxxx, where the x's are hex digits, for a floating
4723          point with the exact digits specified.  */
4724       if (input_line_pointer[0] == ':')
4725         {
4726           ++input_line_pointer;
4727           length = hex_float (float_type, temp);
4728           if (length < 0)
4729             {
4730               ignore_rest_of_line ();
4731               return;
4732             }
4733         }
4734       else
4735         {
4736           err = md_atof (float_type, temp, &length);
4737           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4738           know (err != NULL || length > 0);
4739           if (err)
4740             {
4741               as_bad (_("bad floating literal: %s"), err);
4742               ignore_rest_of_line ();
4743               return;
4744             }
4745         }
4746
4747       if (!need_pass_2)
4748         {
4749           int count;
4750
4751           count = 1;
4752
4753 #ifdef REPEAT_CONS_EXPRESSIONS
4754           if (*input_line_pointer == ':')
4755             {
4756               expressionS count_exp;
4757
4758               ++input_line_pointer;
4759               expression (&count_exp);
4760
4761               if (count_exp.X_op != O_constant
4762                   || count_exp.X_add_number <= 0)
4763                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4764               else
4765                 count = count_exp.X_add_number;
4766             }
4767 #endif
4768
4769           while (--count >= 0)
4770             {
4771               p = frag_more (length);
4772               memcpy (p, temp, (unsigned int) length);
4773             }
4774         }
4775       SKIP_WHITESPACE ();
4776     }
4777   while (*input_line_pointer++ == ',');
4778
4779   /* Put terminator back into stream.  */
4780   --input_line_pointer;
4781   demand_empty_rest_of_line ();
4782 }
4783 \f
4784 /* Return the size of a LEB128 value.  */
4785
4786 static inline int
4787 sizeof_sleb128 (offsetT value)
4788 {
4789   register int size = 0;
4790   register unsigned byte;
4791
4792   do
4793     {
4794       byte = (value & 0x7f);
4795       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4796          Fortunately, we can structure things so that the extra work reduces
4797          to a noop on systems that do things "properly".  */
4798       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4799       size += 1;
4800     }
4801   while (!(((value == 0) && ((byte & 0x40) == 0))
4802            || ((value == -1) && ((byte & 0x40) != 0))));
4803
4804   return size;
4805 }
4806
4807 static inline int
4808 sizeof_uleb128 (valueT value)
4809 {
4810   register int size = 0;
4811   register unsigned byte;
4812
4813   do
4814     {
4815       byte = (value & 0x7f);
4816       value >>= 7;
4817       size += 1;
4818     }
4819   while (value != 0);
4820
4821   return size;
4822 }
4823
4824 int
4825 sizeof_leb128 (valueT value, int sign)
4826 {
4827   if (sign)
4828     return sizeof_sleb128 ((offsetT) value);
4829   else
4830     return sizeof_uleb128 (value);
4831 }
4832
4833 /* Output a LEB128 value.  */
4834
4835 static inline int
4836 output_sleb128 (char *p, offsetT value)
4837 {
4838   register char *orig = p;
4839   register int more;
4840
4841   do
4842     {
4843       unsigned byte = (value & 0x7f);
4844
4845       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4846          Fortunately, we can structure things so that the extra work reduces
4847          to a noop on systems that do things "properly".  */
4848       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4849
4850       more = !((((value == 0) && ((byte & 0x40) == 0))
4851                 || ((value == -1) && ((byte & 0x40) != 0))));
4852       if (more)
4853         byte |= 0x80;
4854
4855       *p++ = byte;
4856     }
4857   while (more);
4858
4859   return p - orig;
4860 }
4861
4862 static inline int
4863 output_uleb128 (char *p, valueT value)
4864 {
4865   char *orig = p;
4866
4867   do
4868     {
4869       unsigned byte = (value & 0x7f);
4870       value >>= 7;
4871       if (value != 0)
4872         /* More bytes to follow.  */
4873         byte |= 0x80;
4874
4875       *p++ = byte;
4876     }
4877   while (value != 0);
4878
4879   return p - orig;
4880 }
4881
4882 int
4883 output_leb128 (char *p, valueT value, int sign)
4884 {
4885   if (sign)
4886     return output_sleb128 (p, (offsetT) value);
4887   else
4888     return output_uleb128 (p, value);
4889 }
4890
4891 /* Do the same for bignums.  We combine sizeof with output here in that
4892    we don't output for NULL values of P.  It isn't really as critical as
4893    for "normal" values that this be streamlined.  */
4894
4895 static inline int
4896 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4897 {
4898   char *orig = p;
4899   valueT val = 0;
4900   int loaded = 0;
4901   unsigned byte;
4902
4903   /* Strip leading sign extensions off the bignum.  */
4904   while (size > 1
4905          && bignum[size - 1] == LITTLENUM_MASK
4906          && bignum[size - 2] > LITTLENUM_MASK / 2)
4907     size--;
4908
4909   do
4910     {
4911       /* OR in the next part of the littlenum.  */
4912       val |= (*bignum << loaded);
4913       loaded += LITTLENUM_NUMBER_OF_BITS;
4914       size--;
4915       bignum++;
4916
4917       /* Add bytes until there are less than 7 bits left in VAL
4918          or until every non-sign bit has been written.  */
4919       do
4920         {
4921           byte = val & 0x7f;
4922           loaded -= 7;
4923           val >>= 7;
4924           if (size > 0
4925               || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4926             byte |= 0x80;
4927
4928           if (orig)
4929             *p = byte;
4930           p++;
4931         }
4932       while ((byte & 0x80) != 0 && loaded >= 7);
4933     }
4934   while (size > 0);
4935
4936   /* Mop up any left-over bits (of which there will be less than 7).  */
4937   if ((byte & 0x80) != 0)
4938     {
4939       /* Sign-extend VAL.  */
4940       if (val & (1 << (loaded - 1)))
4941         val |= ~0 << loaded;
4942       if (orig)
4943         *p = val & 0x7f;
4944       p++;
4945     }
4946
4947   return p - orig;
4948 }
4949
4950 static inline int
4951 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4952 {
4953   char *orig = p;
4954   valueT val = 0;
4955   int loaded = 0;
4956   unsigned byte;
4957
4958   /* Strip leading zeros off the bignum.  */
4959   /* XXX: Is this needed?  */
4960   while (size > 0 && bignum[size - 1] == 0)
4961     size--;
4962
4963   do
4964     {
4965       if (loaded < 7 && size > 0)
4966         {
4967           val |= (*bignum << loaded);
4968           loaded += 8 * CHARS_PER_LITTLENUM;
4969           size--;
4970           bignum++;
4971         }
4972
4973       byte = val & 0x7f;
4974       loaded -= 7;
4975       val >>= 7;
4976
4977       if (size > 0 || val)
4978         byte |= 0x80;
4979
4980       if (orig)
4981         *p = byte;
4982       p++;
4983     }
4984   while (byte & 0x80);
4985
4986   return p - orig;
4987 }
4988
4989 static int
4990 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4991 {
4992   if (sign)
4993     return output_big_sleb128 (p, bignum, size);
4994   else
4995     return output_big_uleb128 (p, bignum, size);
4996 }
4997
4998 /* Generate the appropriate fragments for a given expression to emit a
4999    leb128 value.  */
5000
5001 static void
5002 emit_leb128_expr (expressionS *exp, int sign)
5003 {
5004   operatorT op = exp->X_op;
5005   unsigned int nbytes;
5006
5007   if (op == O_absent || op == O_illegal)
5008     {
5009       as_warn (_("zero assumed for missing expression"));
5010       exp->X_add_number = 0;
5011       op = O_constant;
5012     }
5013   else if (op == O_big && exp->X_add_number <= 0)
5014     {
5015       as_bad (_("floating point number invalid"));
5016       exp->X_add_number = 0;
5017       op = O_constant;
5018     }
5019   else if (op == O_register)
5020     {
5021       as_warn (_("register value used as expression"));
5022       op = O_constant;
5023     }
5024   else if (op == O_constant
5025            && sign
5026            && (exp->X_add_number < 0) != !exp->X_unsigned)
5027     {
5028       /* We're outputting a signed leb128 and the sign of X_add_number
5029          doesn't reflect the sign of the original value.  Convert EXP
5030          to a correctly-extended bignum instead.  */
5031       convert_to_bignum (exp);
5032       op = O_big;
5033     }
5034
5035   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
5036      a signal that this is leb128 data.  It shouldn't optimize this away.  */
5037   nbytes = (unsigned int) -1;
5038   if (check_eh_frame (exp, &nbytes))
5039     abort ();
5040
5041   /* Let the backend know that subsequent data may be byte aligned.  */
5042 #ifdef md_cons_align
5043   md_cons_align (1);
5044 #endif
5045
5046   if (op == O_constant)
5047     {
5048       /* If we've got a constant, emit the thing directly right now.  */
5049
5050       valueT value = exp->X_add_number;
5051       int size;
5052       char *p;
5053
5054       size = sizeof_leb128 (value, sign);
5055       p = frag_more (size);
5056       output_leb128 (p, value, sign);
5057     }
5058   else if (op == O_big)
5059     {
5060       /* O_big is a different sort of constant.  */
5061
5062       int size;
5063       char *p;
5064
5065       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5066       p = frag_more (size);
5067       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5068     }
5069   else
5070     {
5071       /* Otherwise, we have to create a variable sized fragment and
5072          resolve things later.  */
5073
5074       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5075                 make_expr_symbol (exp), 0, (char *) NULL);
5076     }
5077 }
5078
5079 /* Parse the .sleb128 and .uleb128 pseudos.  */
5080
5081 void
5082 s_leb128 (int sign)
5083 {
5084   expressionS exp;
5085
5086 #ifdef md_flush_pending_output
5087   md_flush_pending_output ();
5088 #endif
5089
5090   do
5091     {
5092       expression (&exp);
5093       emit_leb128_expr (&exp, sign);
5094     }
5095   while (*input_line_pointer++ == ',');
5096
5097   input_line_pointer--;
5098   demand_empty_rest_of_line ();
5099 }
5100 \f
5101 static void
5102 stringer_append_char (int c, int bitsize)
5103 {
5104   if (!target_big_endian)
5105     FRAG_APPEND_1_CHAR (c);
5106
5107   switch (bitsize)
5108     {
5109     case 64:
5110       FRAG_APPEND_1_CHAR (0);
5111       FRAG_APPEND_1_CHAR (0);
5112       FRAG_APPEND_1_CHAR (0);
5113       FRAG_APPEND_1_CHAR (0);
5114       /* Fall through.  */
5115     case 32:
5116       FRAG_APPEND_1_CHAR (0);
5117       FRAG_APPEND_1_CHAR (0);
5118       /* Fall through.  */
5119     case 16:
5120       FRAG_APPEND_1_CHAR (0);
5121       /* Fall through.  */
5122     case 8:
5123       break;
5124     default:
5125       /* Called with invalid bitsize argument.  */
5126       abort ();
5127       break;
5128     }
5129   if (target_big_endian)
5130     FRAG_APPEND_1_CHAR (c);
5131 }
5132
5133 /* Worker to do .ascii etc statements.
5134    Reads 0 or more ',' separated, double-quoted strings.
5135    Caller should have checked need_pass_2 is FALSE because we don't
5136    check it.
5137    Checks for end-of-line.
5138    BITS_APPENDZERO says how many bits are in a target char.
5139    The bottom bit is set if a NUL char should be appended to the strings.  */
5140
5141 void
5142 stringer (int bits_appendzero)
5143 {
5144   const int bitsize = bits_appendzero & ~7;
5145   const int append_zero = bits_appendzero & 1;
5146   unsigned int c;
5147   char *start;
5148
5149 #ifdef md_flush_pending_output
5150   md_flush_pending_output ();
5151 #endif
5152
5153 #ifdef md_cons_align
5154   md_cons_align (1);
5155 #endif
5156
5157   /* The following awkward logic is to parse ZERO or more strings,
5158      comma separated. Recall a string expression includes spaces
5159      before the opening '\"' and spaces after the closing '\"'.
5160      We fake a leading ',' if there is (supposed to be)
5161      a 1st, expression. We keep demanding expressions for each ','.  */
5162   if (is_it_end_of_statement ())
5163     {
5164       c = 0;                    /* Skip loop.  */
5165       ++input_line_pointer;     /* Compensate for end of loop.  */
5166     }
5167   else
5168     {
5169       c = ',';                  /* Do loop.  */
5170     }
5171   /* If we have been switched into the abs_section then we
5172      will not have an obstack onto which we can hang strings.  */
5173   if (now_seg == absolute_section)
5174     {
5175       as_bad (_("strings must be placed into a section"));
5176       c = 0;
5177       ignore_rest_of_line ();
5178     }
5179
5180   while (c == ',' || c == '<' || c == '"')
5181     {
5182       SKIP_WHITESPACE ();
5183       switch (*input_line_pointer)
5184         {
5185         case '\"':
5186           ++input_line_pointer; /*->1st char of string.  */
5187           start = input_line_pointer;
5188
5189           while (is_a_char (c = next_char_of_string ()))
5190             stringer_append_char (c, bitsize);
5191
5192           if (append_zero)
5193             stringer_append_char (0, bitsize);
5194
5195           know (input_line_pointer[-1] == '\"');
5196
5197 #ifndef NO_LISTING
5198 #ifdef OBJ_ELF
5199           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5200              will emit .string with a filename in the .debug section
5201              after a sequence of constants.  See the comment in
5202              emit_expr for the sequence.  emit_expr will set
5203              dwarf_file_string to non-zero if this string might be a
5204              source file name.  */
5205           if (strcmp (segment_name (now_seg), ".debug") != 0)
5206             dwarf_file_string = 0;
5207           else if (dwarf_file_string)
5208             {
5209               c = input_line_pointer[-1];
5210               input_line_pointer[-1] = '\0';
5211               listing_source_file (start);
5212               input_line_pointer[-1] = c;
5213             }
5214 #endif
5215 #endif
5216
5217           break;
5218         case '<':
5219           input_line_pointer++;
5220           c = get_single_number ();
5221           stringer_append_char (c, bitsize);
5222           if (*input_line_pointer != '>')
5223             as_bad (_("expected <nn>"));
5224
5225           input_line_pointer++;
5226           break;
5227         case ',':
5228           input_line_pointer++;
5229           break;
5230         }
5231       SKIP_WHITESPACE ();
5232       c = *input_line_pointer;
5233     }
5234
5235   demand_empty_rest_of_line ();
5236 }
5237 \f
5238 /* FIXME-SOMEDAY: I had trouble here on characters with the
5239     high bits set.  We'll probably also have trouble with
5240     multibyte chars, wide chars, etc.  Also be careful about
5241     returning values bigger than 1 byte.  xoxorich.  */
5242
5243 unsigned int
5244 next_char_of_string (void)
5245 {
5246   register unsigned int c;
5247
5248   c = *input_line_pointer++ & CHAR_MASK;
5249   switch (c)
5250     {
5251     case '\"':
5252       c = NOT_A_CHAR;
5253       break;
5254
5255     case '\n':
5256       as_warn (_("unterminated string; newline inserted"));
5257       bump_line_counters ();
5258       break;
5259
5260 #ifndef NO_STRING_ESCAPES
5261     case '\\':
5262       switch (c = *input_line_pointer++)
5263         {
5264         case 'b':
5265           c = '\b';
5266           break;
5267
5268         case 'f':
5269           c = '\f';
5270           break;
5271
5272         case 'n':
5273           c = '\n';
5274           break;
5275
5276         case 'r':
5277           c = '\r';
5278           break;
5279
5280         case 't':
5281           c = '\t';
5282           break;
5283
5284         case 'v':
5285           c = '\013';
5286           break;
5287
5288         case '\\':
5289         case '"':
5290           break;                /* As itself.  */
5291
5292         case '0':
5293         case '1':
5294         case '2':
5295         case '3':
5296         case '4':
5297         case '5':
5298         case '6':
5299         case '7':
5300         case '8':
5301         case '9':
5302           {
5303             long number;
5304             int i;
5305
5306             for (i = 0, number = 0;
5307                  ISDIGIT (c) && i < 3;
5308                  c = *input_line_pointer++, i++)
5309               {
5310                 number = number * 8 + c - '0';
5311               }
5312
5313             c = number & 0xff;
5314           }
5315           --input_line_pointer;
5316           break;
5317
5318         case 'x':
5319         case 'X':
5320           {
5321             long number;
5322
5323             number = 0;
5324             c = *input_line_pointer++;
5325             while (ISXDIGIT (c))
5326               {
5327                 if (ISDIGIT (c))
5328                   number = number * 16 + c - '0';
5329                 else if (ISUPPER (c))
5330                   number = number * 16 + c - 'A' + 10;
5331                 else
5332                   number = number * 16 + c - 'a' + 10;
5333                 c = *input_line_pointer++;
5334               }
5335             c = number & 0xff;
5336             --input_line_pointer;
5337           }
5338           break;
5339
5340         case '\n':
5341           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
5342           as_warn (_("unterminated string; newline inserted"));
5343           c = '\n';
5344           bump_line_counters ();
5345           break;
5346
5347         default:
5348
5349 #ifdef ONLY_STANDARD_ESCAPES
5350           as_bad (_("bad escaped character in string"));
5351           c = '?';
5352 #endif /* ONLY_STANDARD_ESCAPES */
5353
5354           break;
5355         }
5356       break;
5357 #endif /* ! defined (NO_STRING_ESCAPES) */
5358
5359     default:
5360       break;
5361     }
5362   return (c);
5363 }
5364 \f
5365 static segT
5366 get_segmented_expression (register expressionS *expP)
5367 {
5368   register segT retval;
5369
5370   retval = expression (expP);
5371   if (expP->X_op == O_illegal
5372       || expP->X_op == O_absent
5373       || expP->X_op == O_big)
5374     {
5375       as_bad (_("expected address expression"));
5376       expP->X_op = O_constant;
5377       expP->X_add_number = 0;
5378       retval = absolute_section;
5379     }
5380   return retval;
5381 }
5382
5383 static segT
5384 get_known_segmented_expression (register expressionS *expP)
5385 {
5386   register segT retval;
5387
5388   if ((retval = get_segmented_expression (expP)) == undefined_section)
5389     {
5390       /* There is no easy way to extract the undefined symbol from the
5391          expression.  */
5392       if (expP->X_add_symbol != NULL
5393           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5394         as_warn (_("symbol \"%s\" undefined; zero assumed"),
5395                  S_GET_NAME (expP->X_add_symbol));
5396       else
5397         as_warn (_("some symbol undefined; zero assumed"));
5398       retval = absolute_section;
5399       expP->X_op = O_constant;
5400       expP->X_add_number = 0;
5401     }
5402   know (retval == absolute_section || SEG_NORMAL (retval));
5403   return (retval);
5404 }
5405
5406 char                            /* Return terminator.  */
5407 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
5408 {
5409   /* FIXME: val_pointer should probably be offsetT *.  */
5410   *val_pointer = (long) get_absolute_expression ();
5411   return (*input_line_pointer++);
5412 }
5413 \f
5414 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5415    Give a warning if that happens.  */
5416
5417 char *
5418 demand_copy_C_string (int *len_pointer)
5419 {
5420   register char *s;
5421
5422   if ((s = demand_copy_string (len_pointer)) != 0)
5423     {
5424       register int len;
5425
5426       for (len = *len_pointer; len > 0; len--)
5427         {
5428           if (*s == 0)
5429             {
5430               s = 0;
5431               len = 1;
5432               *len_pointer = 0;
5433               as_bad (_("this string may not contain \'\\0\'"));
5434             }
5435         }
5436     }
5437
5438   return s;
5439 }
5440 \f
5441 /* Demand string, but return a safe (=private) copy of the string.
5442    Return NULL if we can't read a string here.  */
5443
5444 char *
5445 demand_copy_string (int *lenP)
5446 {
5447   register unsigned int c;
5448   register int len;
5449   char *retval;
5450
5451   len = 0;
5452   SKIP_WHITESPACE ();
5453   if (*input_line_pointer == '\"')
5454     {
5455       input_line_pointer++;     /* Skip opening quote.  */
5456
5457       while (is_a_char (c = next_char_of_string ()))
5458         {
5459           obstack_1grow (&notes, c);
5460           len++;
5461         }
5462       /* JF this next line is so demand_copy_C_string will return a
5463          null terminated string.  */
5464       obstack_1grow (&notes, '\0');
5465       retval = (char *) obstack_finish (&notes);
5466     }
5467   else
5468     {
5469       as_bad (_("missing string"));
5470       retval = NULL;
5471       ignore_rest_of_line ();
5472     }
5473   *lenP = len;
5474   return (retval);
5475 }
5476 \f
5477 /* In:  Input_line_pointer->next character.
5478
5479    Do:  Skip input_line_pointer over all whitespace.
5480
5481    Out: 1 if input_line_pointer->end-of-line.  */
5482
5483 int
5484 is_it_end_of_statement (void)
5485 {
5486   SKIP_WHITESPACE ();
5487   return (is_end_of_line[(unsigned char) *input_line_pointer]);
5488 }
5489
5490 void
5491 equals (char *sym_name, int reassign)
5492 {
5493   char *stop = NULL;
5494   char stopc = 0;
5495
5496   input_line_pointer++;
5497   if (*input_line_pointer == '=')
5498     input_line_pointer++;
5499   if (reassign < 0 && *input_line_pointer == '=')
5500     input_line_pointer++;
5501
5502   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5503     input_line_pointer++;
5504
5505   if (flag_mri)
5506     stop = mri_comment_field (&stopc);
5507
5508   assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5509
5510   if (flag_mri)
5511     {
5512       demand_empty_rest_of_line ();
5513       mri_comment_end (stop, stopc);
5514     }
5515 }
5516
5517 /* .incbin -- include a file verbatim at the current location.  */
5518
5519 void
5520 s_incbin (int x ATTRIBUTE_UNUSED)
5521 {
5522   FILE * binfile;
5523   char * path;
5524   char * filename;
5525   char * binfrag;
5526   long   skip = 0;
5527   long   count = 0;
5528   long   bytes;
5529   int    len;
5530
5531 #ifdef md_flush_pending_output
5532   md_flush_pending_output ();
5533 #endif
5534
5535 #ifdef md_cons_align
5536   md_cons_align (1);
5537 #endif
5538
5539   SKIP_WHITESPACE ();
5540   filename = demand_copy_string (& len);
5541   if (filename == NULL)
5542     return;
5543
5544   SKIP_WHITESPACE ();
5545
5546   /* Look for optional skip and count.  */
5547   if (* input_line_pointer == ',')
5548     {
5549       ++ input_line_pointer;
5550       skip = get_absolute_expression ();
5551
5552       SKIP_WHITESPACE ();
5553
5554       if (* input_line_pointer == ',')
5555         {
5556           ++ input_line_pointer;
5557
5558           count = get_absolute_expression ();
5559           if (count == 0)
5560             as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5561
5562           SKIP_WHITESPACE ();
5563         }
5564     }
5565
5566   demand_empty_rest_of_line ();
5567
5568   /* Try opening absolute path first, then try include dirs.  */
5569   binfile = fopen (filename, FOPEN_RB);
5570   if (binfile == NULL)
5571     {
5572       int i;
5573
5574       path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5575
5576       for (i = 0; i < include_dir_count; i++)
5577         {
5578           sprintf (path, "%s/%s", include_dirs[i], filename);
5579
5580           binfile = fopen (path, FOPEN_RB);
5581           if (binfile != NULL)
5582             break;
5583         }
5584
5585       if (binfile == NULL)
5586         as_bad (_("file not found: %s"), filename);
5587     }
5588   else
5589     path = xstrdup (filename);
5590
5591   if (binfile)
5592     {
5593       long   file_len;
5594
5595       register_dependency (path);
5596
5597       /* Compute the length of the file.  */
5598       if (fseek (binfile, 0, SEEK_END) != 0)
5599         {
5600           as_bad (_("seek to end of .incbin file failed `%s'"), path);
5601           goto done;
5602         }
5603       file_len = ftell (binfile);
5604
5605       /* If a count was not specified use the remainder of the file.  */
5606       if (count == 0)
5607         count = file_len - skip;
5608
5609       if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5610         {
5611           as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5612                   skip, count, file_len);
5613           goto done;
5614         }
5615
5616       if (fseek (binfile, skip, SEEK_SET) != 0)
5617         {
5618           as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5619           goto done;
5620         }
5621
5622       /* Allocate frag space and store file contents in it.  */
5623       binfrag = frag_more (count);
5624
5625       bytes = fread (binfrag, 1, count, binfile);
5626       if (bytes < count)
5627         as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5628                  path, bytes, count);
5629     }
5630 done:
5631   if (binfile != NULL)
5632     fclose (binfile);
5633   if (path)
5634     free (path);
5635 }
5636
5637 /* .include -- include a file at this point.  */
5638
5639 void
5640 s_include (int arg ATTRIBUTE_UNUSED)
5641 {
5642   char *filename;
5643   int i;
5644   FILE *try_file;
5645   char *path;
5646
5647   if (!flag_m68k_mri)
5648     {
5649       filename = demand_copy_string (&i);
5650       if (filename == NULL)
5651         {
5652           /* demand_copy_string has already printed an error and
5653              called ignore_rest_of_line.  */
5654           return;
5655         }
5656     }
5657   else
5658     {
5659       SKIP_WHITESPACE ();
5660       i = 0;
5661       while (!is_end_of_line[(unsigned char) *input_line_pointer]
5662              && *input_line_pointer != ' '
5663              && *input_line_pointer != '\t')
5664         {
5665           obstack_1grow (&notes, *input_line_pointer);
5666           ++input_line_pointer;
5667           ++i;
5668         }
5669
5670       obstack_1grow (&notes, '\0');
5671       filename = (char *) obstack_finish (&notes);
5672       while (!is_end_of_line[(unsigned char) *input_line_pointer])
5673         ++input_line_pointer;
5674     }
5675
5676   demand_empty_rest_of_line ();
5677   path = (char *) xmalloc ((unsigned long) i
5678                            + include_dir_maxlen + 5 /* slop */ );
5679
5680   for (i = 0; i < include_dir_count; i++)
5681     {
5682       strcpy (path, include_dirs[i]);
5683       strcat (path, "/");
5684       strcat (path, filename);
5685       if (0 != (try_file = fopen (path, FOPEN_RT)))
5686         {
5687           fclose (try_file);
5688           goto gotit;
5689         }
5690     }
5691
5692   free (path);
5693   path = filename;
5694 gotit:
5695   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
5696   register_dependency (path);
5697   input_scrub_insert_file (path);
5698 }
5699
5700 void
5701 add_include_dir (char *path)
5702 {
5703   int i;
5704
5705   if (include_dir_count == 0)
5706     {
5707       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5708       include_dirs[0] = ".";    /* Current dir.  */
5709       include_dir_count = 2;
5710     }
5711   else
5712     {
5713       include_dir_count++;
5714       include_dirs =
5715         (char **) realloc (include_dirs,
5716                            include_dir_count * sizeof (*include_dirs));
5717     }
5718
5719   include_dirs[include_dir_count - 1] = path;   /* New one.  */
5720
5721   i = strlen (path);
5722   if (i > include_dir_maxlen)
5723     include_dir_maxlen = i;
5724 }
5725 \f
5726 /* Output debugging information to denote the source file.  */
5727
5728 static void
5729 generate_file_debug (void)
5730 {
5731   if (debug_type == DEBUG_STABS)
5732     stabs_generate_asm_file ();
5733 }
5734
5735 /* Output line number debugging information for the current source line.  */
5736
5737 void
5738 generate_lineno_debug (void)
5739 {
5740   switch (debug_type)
5741     {
5742     case DEBUG_UNSPECIFIED:
5743     case DEBUG_NONE:
5744     case DEBUG_DWARF:
5745       break;
5746     case DEBUG_STABS:
5747       stabs_generate_asm_lineno ();
5748       break;
5749     case DEBUG_ECOFF:
5750       ecoff_generate_asm_lineno ();
5751       break;
5752     case DEBUG_DWARF2:
5753       /* ??? We could here indicate to dwarf2dbg.c that something
5754          has changed.  However, since there is additional backend
5755          support that is required (calling dwarf2_emit_insn), we
5756          let dwarf2dbg.c call as_where on its own.  */
5757       break;
5758     }
5759 }
5760
5761 /* Output debugging information to mark a function entry point or end point.
5762    END_P is zero for .func, and non-zero for .endfunc.  */
5763
5764 void
5765 s_func (int end_p)
5766 {
5767   do_s_func (end_p, NULL);
5768 }
5769
5770 /* Subroutine of s_func so targets can choose a different default prefix.
5771    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
5772
5773 static void
5774 do_s_func (int end_p, const char *default_prefix)
5775 {
5776   /* Record the current function so that we can issue an error message for
5777      misplaced .func,.endfunc, and also so that .endfunc needs no
5778      arguments.  */
5779   static char *current_name;
5780   static char *current_label;
5781
5782   if (end_p)
5783     {
5784       if (current_name == NULL)
5785         {
5786           as_bad (_("missing .func"));
5787           ignore_rest_of_line ();
5788           return;
5789         }
5790
5791       if (debug_type == DEBUG_STABS)
5792         stabs_generate_asm_endfunc (current_name, current_label);
5793
5794       current_name = current_label = NULL;
5795     }
5796   else /* ! end_p */
5797     {
5798       char *name, *label;
5799       char delim1, delim2;
5800
5801       if (current_name != NULL)
5802         {
5803           as_bad (_(".endfunc missing for previous .func"));
5804           ignore_rest_of_line ();
5805           return;
5806         }
5807
5808       name = input_line_pointer;
5809       delim1 = get_symbol_end ();
5810       name = xstrdup (name);
5811       *input_line_pointer = delim1;
5812       SKIP_WHITESPACE ();
5813       if (*input_line_pointer != ',')
5814         {
5815           if (default_prefix)
5816             {
5817               if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5818                 as_fatal ("%s", xstrerror (errno));
5819             }
5820           else
5821             {
5822               char leading_char = bfd_get_symbol_leading_char (stdoutput);
5823               /* Missing entry point, use function's name with the leading
5824                  char prepended.  */
5825               if (leading_char)
5826                 {
5827                   if (asprintf (&label, "%c%s", leading_char, name) == -1)
5828                     as_fatal ("%s", xstrerror (errno));
5829                 }
5830               else
5831                 label = name;
5832             }
5833         }
5834       else
5835         {
5836           ++input_line_pointer;
5837           SKIP_WHITESPACE ();
5838           label = input_line_pointer;
5839           delim2 = get_symbol_end ();
5840           label = xstrdup (label);
5841           *input_line_pointer = delim2;
5842         }
5843
5844       if (debug_type == DEBUG_STABS)
5845         stabs_generate_asm_func (name, label);
5846
5847       current_name = name;
5848       current_label = label;
5849     }
5850
5851   demand_empty_rest_of_line ();
5852 }
5853 \f
5854 void
5855 s_ignore (int arg ATTRIBUTE_UNUSED)
5856 {
5857   ignore_rest_of_line ();
5858 }
5859
5860 void
5861 read_print_statistics (FILE *file)
5862 {
5863   hash_print_statistics (file, "pseudo-op table", po_hash);
5864 }
5865
5866 /* Inserts the given line into the input stream.
5867
5868    This call avoids macro/conditionals nesting checking, since the contents of
5869    the line are assumed to replace the contents of a line already scanned.
5870
5871    An appropriate use of this function would be substitution of input lines when
5872    called by md_start_line_hook().  The given line is assumed to already be
5873    properly scrubbed.  */
5874
5875 void
5876 input_scrub_insert_line (const char *line)
5877 {
5878   sb newline;
5879   sb_new (&newline);
5880   sb_add_string (&newline, line);
5881   input_scrub_include_sb (&newline, input_line_pointer, 0);
5882   sb_kill (&newline);
5883   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5884 }
5885
5886 /* Insert a file into the input stream; the path must resolve to an actual
5887    file; no include path searching or dependency registering is performed.  */
5888
5889 void
5890 input_scrub_insert_file (char *path)
5891 {
5892   input_scrub_include_file (path, input_line_pointer);
5893   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5894 }
5895
5896 /* Find the end of a line, considering quotation and escaping of quotes.  */
5897
5898 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5899 # define TC_SINGLE_QUOTE_STRINGS 1
5900 #endif
5901
5902 static char *
5903 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5904                    int in_macro)
5905 {
5906   char inquote = '\0';
5907   int inescape = 0;
5908
5909   while (!is_end_of_line[(unsigned char) *s]
5910          || (inquote && !ISCNTRL (*s))
5911          || (inquote == '\'' && flag_mri)
5912 #ifdef TC_EOL_IN_INSN
5913          || (insn && TC_EOL_IN_INSN (s))
5914 #endif
5915          /* PR 6926:  When we are parsing the body of a macro the sequence
5916             \@ is special - it refers to the invocation count.  If the @
5917             character happens to be registered as a line-separator character
5918             by the target, then the is_end_of_line[] test above will have
5919             returned true, but we need to ignore the line separating
5920             semantics in this particular case.  */
5921          || (in_macro && inescape && *s == '@')
5922         )
5923     {
5924       if (mri_string && *s == '\'')
5925         inquote ^= *s;
5926       else if (inescape)
5927         inescape = 0;
5928       else if (*s == '\\')
5929         inescape = 1;
5930       else if (!inquote
5931                ? *s == '"'
5932 #ifdef TC_SINGLE_QUOTE_STRINGS
5933                  || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5934 #endif
5935                : *s == inquote)
5936         inquote ^= *s;
5937       ++s;
5938     }
5939   if (inquote)
5940     as_warn (_("missing closing `%c'"), inquote);
5941   if (inescape)
5942     as_warn (_("stray `\\'"));
5943   return s;
5944 }
5945
5946 char *
5947 find_end_of_line (char *s, int mri_string)
5948 {
5949   return _find_end_of_line (s, mri_string, 0, 0);
5950 }