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