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