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