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