gas/read.c

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