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