gas/read.c

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