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