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