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