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       symbolS *sym = exp->X_add_symbol;
2383       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2384
2385       if (exp->X_op != O_constant && exp->X_op != O_symbol)
2386         {
2387           /* Handle complex expressions.  */
2388           sym = make_expr_symbol (exp);
2389           off = 0;
2390         }
2391
2392       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2393       *p = fill;
2394     }
2395 }
2396
2397 void
2398 s_org (ignore)
2399      int ignore ATTRIBUTE_UNUSED;
2400 {
2401   register segT segment;
2402   expressionS exp;
2403   register long temp_fill;
2404
2405 #ifdef md_flush_pending_output
2406   md_flush_pending_output ();
2407 #endif
2408
2409   /* The m68k MRI assembler has a different meaning for .org.  It
2410      means to create an absolute section at a given address.  We can't
2411      support that--use a linker script instead.  */
2412   if (flag_m68k_mri)
2413     {
2414       as_bad (_("MRI style ORG pseudo-op not supported"));
2415       ignore_rest_of_line ();
2416       return;
2417     }
2418
2419   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2420      thing as a sub-segment-relative origin.  Any absolute origin is
2421      given a warning, then assumed to be segment-relative.  Any
2422      segmented origin expression ("foo+42") had better be in the right
2423      segment or the .org is ignored.
2424
2425      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2426      we never know sub-segment sizes when we are reading code.  BSD
2427      will crash trying to emit negative numbers of filler bytes in
2428      certain .orgs. We don't crash, but see as-write for that code.
2429
2430      Don't make frag if need_pass_2==1.  */
2431   segment = get_known_segmented_expression (&exp);
2432   if (*input_line_pointer == ',')
2433     {
2434       input_line_pointer++;
2435       temp_fill = get_absolute_expression ();
2436     }
2437   else
2438     temp_fill = 0;
2439
2440   if (!need_pass_2)
2441     do_org (segment, &exp, temp_fill);
2442
2443   demand_empty_rest_of_line ();
2444 }
2445
2446 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2447    called by the obj-format routine which handles section changing
2448    when in MRI mode.  It will create a new section, and return it.  It
2449    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2450    'M' (mixed), or 'R' (romable).  If BFD_ASSEMBLER is defined, the
2451    flags will be set in the section.  */
2452
2453 void
2454 s_mri_sect (type)
2455      char *type ATTRIBUTE_UNUSED;
2456 {
2457 #ifdef TC_M68K
2458
2459   char *name;
2460   char c;
2461   segT seg;
2462
2463   SKIP_WHITESPACE ();
2464
2465   name = input_line_pointer;
2466   if (!isdigit ((unsigned char) *name))
2467     c = get_symbol_end ();
2468   else
2469     {
2470       do
2471         {
2472           ++input_line_pointer;
2473         }
2474       while (isdigit ((unsigned char) *input_line_pointer));
2475
2476       c = *input_line_pointer;
2477       *input_line_pointer = '\0';
2478     }
2479
2480   name = xstrdup (name);
2481
2482   *input_line_pointer = c;
2483
2484   seg = subseg_new (name, 0);
2485
2486   if (*input_line_pointer == ',')
2487     {
2488       int align;
2489
2490       ++input_line_pointer;
2491       align = get_absolute_expression ();
2492       record_alignment (seg, align);
2493     }
2494
2495   *type = 'C';
2496   if (*input_line_pointer == ',')
2497     {
2498       c = *++input_line_pointer;
2499       c = toupper ((unsigned char) c);
2500       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2501         *type = c;
2502       else
2503         as_bad (_("unrecognized section type"));
2504       ++input_line_pointer;
2505
2506 #ifdef BFD_ASSEMBLER
2507       {
2508         flagword flags;
2509
2510         flags = SEC_NO_FLAGS;
2511         if (*type == 'C')
2512           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2513         else if (*type == 'D' || *type == 'M')
2514           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2515         else if (*type == 'R')
2516           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2517         if (flags != SEC_NO_FLAGS)
2518           {
2519             if (!bfd_set_section_flags (stdoutput, seg, flags))
2520               as_warn (_("error setting flags for \"%s\": %s"),
2521                        bfd_section_name (stdoutput, seg),
2522                        bfd_errmsg (bfd_get_error ()));
2523           }
2524       }
2525 #endif
2526     }
2527
2528   /* Ignore the HP type.  */
2529   if (*input_line_pointer == ',')
2530     input_line_pointer += 2;
2531
2532   demand_empty_rest_of_line ();
2533
2534 #else /* ! TC_M68K */
2535 #ifdef TC_I960
2536
2537   char *name;
2538   char c;
2539   segT seg;
2540
2541   SKIP_WHITESPACE ();
2542
2543   name = input_line_pointer;
2544   c = get_symbol_end ();
2545
2546   name = xstrdup (name);
2547
2548   *input_line_pointer = c;
2549
2550   seg = subseg_new (name, 0);
2551
2552   if (*input_line_pointer != ',')
2553     *type = 'C';
2554   else
2555     {
2556       char *sectype;
2557
2558       ++input_line_pointer;
2559       SKIP_WHITESPACE ();
2560       sectype = input_line_pointer;
2561       c = get_symbol_end ();
2562       if (*sectype == '\0')
2563         *type = 'C';
2564       else if (strcasecmp (sectype, "text") == 0)
2565         *type = 'C';
2566       else if (strcasecmp (sectype, "data") == 0)
2567         *type = 'D';
2568       else if (strcasecmp (sectype, "romdata") == 0)
2569         *type = 'R';
2570       else
2571         as_warn (_("unrecognized section type `%s'"), sectype);
2572       *input_line_pointer = c;
2573     }
2574
2575   if (*input_line_pointer == ',')
2576     {
2577       char *seccmd;
2578
2579       ++input_line_pointer;
2580       SKIP_WHITESPACE ();
2581       seccmd = input_line_pointer;
2582       c = get_symbol_end ();
2583       if (strcasecmp (seccmd, "absolute") == 0)
2584         {
2585           as_bad (_("absolute sections are not supported"));
2586           *input_line_pointer = c;
2587           ignore_rest_of_line ();
2588           return;
2589         }
2590       else if (strcasecmp (seccmd, "align") == 0)
2591         {
2592           int align;
2593
2594           *input_line_pointer = c;
2595           align = get_absolute_expression ();
2596           record_alignment (seg, align);
2597         }
2598       else
2599         {
2600           as_warn (_("unrecognized section command `%s'"), seccmd);
2601           *input_line_pointer = c;
2602         }
2603     }
2604
2605   demand_empty_rest_of_line ();
2606
2607 #else /* ! TC_I960 */
2608   /* The MRI assembler seems to use different forms of .sect for
2609      different targets.  */
2610   as_bad ("MRI mode not supported for this target");
2611   ignore_rest_of_line ();
2612 #endif /* ! TC_I960 */
2613 #endif /* ! TC_M68K */
2614 }
2615
2616 /* Handle the .print pseudo-op.  */
2617
2618 void
2619 s_print (ignore)
2620      int ignore ATTRIBUTE_UNUSED;
2621 {
2622   char *s;
2623   int len;
2624
2625   s = demand_copy_C_string (&len);
2626   printf ("%s\n", s);
2627   demand_empty_rest_of_line ();
2628 }
2629
2630 /* Handle the .purgem pseudo-op.  */
2631
2632 void
2633 s_purgem (ignore)
2634      int ignore ATTRIBUTE_UNUSED;
2635 {
2636   if (is_it_end_of_statement ())
2637     {
2638       demand_empty_rest_of_line ();
2639       return;
2640     }
2641
2642   do
2643     {
2644       char *name;
2645       char c;
2646
2647       SKIP_WHITESPACE ();
2648       name = input_line_pointer;
2649       c = get_symbol_end ();
2650       delete_macro (name);
2651       *input_line_pointer = c;
2652       SKIP_WHITESPACE ();
2653     }
2654   while (*input_line_pointer++ == ',');
2655
2656   --input_line_pointer;
2657   demand_empty_rest_of_line ();
2658 }
2659
2660 /* Handle the .rept pseudo-op.  */
2661
2662 void
2663 s_rept (ignore)
2664      int ignore ATTRIBUTE_UNUSED;
2665 {
2666   int count;
2667
2668   count = get_absolute_expression ();
2669
2670   do_repeat (count, "REPT", "ENDR");
2671 }
2672
2673 /* This function provides a generic repeat block implementation.   It allows
2674    different directives to be used as the start/end keys.  */
2675
2676 void
2677 do_repeat (count, start, end)
2678      int count;
2679      const char *start;
2680      const char *end;
2681 {
2682   sb one;
2683   sb many;
2684
2685   sb_new (&one);
2686   if (!buffer_and_nest (start, end, &one, get_line_sb))
2687     {
2688       as_bad (_("%s without %s"), start, end);
2689       return;
2690     }
2691
2692   sb_new (&many);
2693   while (count-- > 0)
2694     sb_add_sb (&many, &one);
2695
2696   sb_kill (&one);
2697
2698   input_scrub_include_sb (&many, input_line_pointer, 1);
2699   sb_kill (&many);
2700   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2701 }
2702
2703 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2704    input buffers to skip.  Assumes that conditionals preceding the loop end
2705    are properly nested.
2706
2707    This function makes it easier to implement a premature "break" out of the
2708    loop.  The EXTRA arg accounts for other buffers we might have inserted,
2709    such as line substitutions.  */
2710
2711 void
2712 end_repeat (extra)
2713      int extra;
2714 {
2715   cond_exit_macro (macro_nest);
2716   while (extra-- >= 0)
2717     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2718 }
2719
2720 /* Handle the .equ, .equiv and .set directives.  If EQUIV is 1, then
2721    this is .equiv, and it is an error if the symbol is already
2722    defined.  */
2723
2724 void
2725 s_set (equiv)
2726      int equiv;
2727 {
2728   register char *name;
2729   register char delim;
2730   register char *end_name;
2731   register symbolS *symbolP;
2732
2733   /* Especial apologies for the random logic:
2734      this just grew, and could be parsed much more simply!
2735      Dean in haste.  */
2736   name = input_line_pointer;
2737   delim = get_symbol_end ();
2738   end_name = input_line_pointer;
2739   *end_name = delim;
2740   SKIP_WHITESPACE ();
2741
2742   if (*input_line_pointer != ',')
2743     {
2744       *end_name = 0;
2745       as_bad (_("Expected comma after name \"%s\""), name);
2746       *end_name = delim;
2747       ignore_rest_of_line ();
2748       return;
2749     }
2750
2751   input_line_pointer++;
2752   *end_name = 0;
2753
2754   if (name[0] == '.' && name[1] == '\0')
2755     {
2756       /* Turn '. = mumble' into a .org mumble.  */
2757       register segT segment;
2758       expressionS exp;
2759
2760       segment = get_known_segmented_expression (&exp);
2761
2762       if (!need_pass_2)
2763         do_org (segment, &exp, 0);
2764
2765       *end_name = delim;
2766       return;
2767     }
2768
2769   if ((symbolP = symbol_find (name)) == NULL
2770       && (symbolP = md_undefined_symbol (name)) == NULL)
2771     {
2772 #ifndef NO_LISTING
2773       /* When doing symbol listings, play games with dummy fragments living
2774          outside the normal fragment chain to record the file and line info
2775          for this symbol.  */
2776       if (listing & LISTING_SYMBOLS)
2777         {
2778           extern struct list_info_struct *listing_tail;
2779           fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
2780           memset (dummy_frag, 0, sizeof (fragS));
2781           dummy_frag->fr_type = rs_fill;
2782           dummy_frag->line = listing_tail;
2783           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2784           dummy_frag->fr_symbol = symbolP;
2785         }
2786       else
2787 #endif
2788         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2789
2790 #ifdef OBJ_COFF
2791       /* "set" symbols are local unless otherwise specified.  */
2792       SF_SET_LOCAL (symbolP);
2793 #endif /* OBJ_COFF */
2794     }
2795
2796   symbol_table_insert (symbolP);
2797
2798   *end_name = delim;
2799
2800   if (equiv
2801       && S_IS_DEFINED (symbolP)
2802       && S_GET_SEGMENT (symbolP) != reg_section)
2803     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2804
2805   pseudo_set (symbolP);
2806   demand_empty_rest_of_line ();
2807 }
2808
2809 void
2810 s_space (mult)
2811      int mult;
2812 {
2813   expressionS exp;
2814   expressionS val;
2815   char *p = 0;
2816   char *stop = NULL;
2817   char stopc;
2818   int bytes;
2819
2820 #ifdef md_flush_pending_output
2821   md_flush_pending_output ();
2822 #endif
2823
2824   if (flag_mri)
2825     stop = mri_comment_field (&stopc);
2826
2827   /* In m68k MRI mode, we need to align to a word boundary, unless
2828      this is ds.b.  */
2829   if (flag_m68k_mri && mult > 1)
2830     {
2831       if (now_seg == absolute_section)
2832         {
2833           abs_section_offset += abs_section_offset & 1;
2834           if (line_label != NULL)
2835             S_SET_VALUE (line_label, abs_section_offset);
2836         }
2837       else if (mri_common_symbol != NULL)
2838         {
2839           valueT val;
2840
2841           val = S_GET_VALUE (mri_common_symbol);
2842           if ((val & 1) != 0)
2843             {
2844               S_SET_VALUE (mri_common_symbol, val + 1);
2845               if (line_label != NULL)
2846                 {
2847                   expressionS *symexp;
2848
2849                   symexp = symbol_get_value_expression (line_label);
2850                   know (symexp->X_op == O_symbol);
2851                   know (symexp->X_add_symbol == mri_common_symbol);
2852                   symexp->X_add_number += 1;
2853                 }
2854             }
2855         }
2856       else
2857         {
2858           do_align (1, (char *) NULL, 0, 0);
2859           if (line_label != NULL)
2860             {
2861               symbol_set_frag (line_label, frag_now);
2862               S_SET_VALUE (line_label, frag_now_fix ());
2863             }
2864         }
2865     }
2866
2867   bytes = mult;
2868
2869   expression (&exp);
2870
2871   SKIP_WHITESPACE ();
2872   if (*input_line_pointer == ',')
2873     {
2874       ++input_line_pointer;
2875       expression (&val);
2876     }
2877   else
2878     {
2879       val.X_op = O_constant;
2880       val.X_add_number = 0;
2881     }
2882
2883   if (val.X_op != O_constant
2884       || val.X_add_number < - 0x80
2885       || val.X_add_number > 0xff
2886       || (mult != 0 && mult != 1 && val.X_add_number != 0))
2887     {
2888       if (exp.X_op != O_constant)
2889         as_bad (_("Unsupported variable size or fill value"));
2890       else
2891         {
2892           offsetT i;
2893
2894           if (mult == 0)
2895             mult = 1;
2896           bytes = mult * exp.X_add_number;
2897           for (i = 0; i < exp.X_add_number; i++)
2898             emit_expr (&val, mult);
2899         }
2900     }
2901   else
2902     {
2903       if (exp.X_op == O_constant)
2904         {
2905           long repeat;
2906
2907           repeat = exp.X_add_number;
2908           if (mult)
2909             repeat *= mult;
2910           bytes = repeat;
2911           if (repeat <= 0)
2912             {
2913               if (!flag_mri)
2914                 as_warn (_(".space repeat count is zero, ignored"));
2915               else if (repeat < 0)
2916                 as_warn (_(".space repeat count is negative, ignored"));
2917               goto getout;
2918             }
2919
2920           /* If we are in the absolute section, just bump the offset.  */
2921           if (now_seg == absolute_section)
2922             {
2923               abs_section_offset += repeat;
2924               goto getout;
2925             }
2926
2927           /* If we are secretly in an MRI common section, then
2928              creating space just increases the size of the common
2929              symbol.  */
2930           if (mri_common_symbol != NULL)
2931             {
2932               S_SET_VALUE (mri_common_symbol,
2933                            S_GET_VALUE (mri_common_symbol) + repeat);
2934               goto getout;
2935             }
2936
2937           if (!need_pass_2)
2938             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2939                           (offsetT) repeat, (char *) 0);
2940         }
2941       else
2942         {
2943           if (now_seg == absolute_section)
2944             {
2945               as_bad (_("space allocation too complex in absolute section"));
2946               subseg_set (text_section, 0);
2947             }
2948
2949           if (mri_common_symbol != NULL)
2950             {
2951               as_bad (_("space allocation too complex in common section"));
2952               mri_common_symbol = NULL;
2953             }
2954
2955           if (!need_pass_2)
2956             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2957                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
2958         }
2959
2960       if (p)
2961         *p = val.X_add_number;
2962     }
2963
2964  getout:
2965
2966   /* In MRI mode, after an odd number of bytes, we must align to an
2967      even word boundary, unless the next instruction is a dc.b, ds.b
2968      or dcb.b.  */
2969   if (flag_mri && (bytes & 1) != 0)
2970     mri_pending_align = 1;
2971
2972   demand_empty_rest_of_line ();
2973
2974   if (flag_mri)
2975     mri_comment_end (stop, stopc);
2976 }
2977
2978 /* This is like s_space, but the value is a floating point number with
2979    the given precision.  This is for the MRI dcb.s pseudo-op and
2980    friends.  */
2981
2982 void
2983 s_float_space (float_type)
2984      int float_type;
2985 {
2986   offsetT count;
2987   int flen;
2988   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
2989   char *stop = NULL;
2990   char stopc;
2991
2992   if (flag_mri)
2993     stop = mri_comment_field (&stopc);
2994
2995   count = get_absolute_expression ();
2996
2997   SKIP_WHITESPACE ();
2998   if (*input_line_pointer != ',')
2999     {
3000       as_bad (_("missing value"));
3001       ignore_rest_of_line ();
3002       if (flag_mri)
3003         mri_comment_end (stop, stopc);
3004       return;
3005     }
3006
3007   ++input_line_pointer;
3008
3009   SKIP_WHITESPACE ();
3010
3011   /* Skip any 0{letter} that may be present.  Don't even check if the
3012    * letter is legal.  */
3013   if (input_line_pointer[0] == '0'
3014       && isalpha ((unsigned char) input_line_pointer[1]))
3015     input_line_pointer += 2;
3016
3017   /* Accept :xxxx, where the x's are hex digits, for a floating point
3018      with the exact digits specified.  */
3019   if (input_line_pointer[0] == ':')
3020     {
3021       flen = hex_float (float_type, temp);
3022       if (flen < 0)
3023         {
3024           ignore_rest_of_line ();
3025           if (flag_mri)
3026             mri_comment_end (stop, stopc);
3027           return;
3028         }
3029     }
3030   else
3031     {
3032       char *err;
3033
3034       err = md_atof (float_type, temp, &flen);
3035       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3036       know (flen > 0);
3037       if (err)
3038         {
3039           as_bad (_("Bad floating literal: %s"), err);
3040           ignore_rest_of_line ();
3041           if (flag_mri)
3042             mri_comment_end (stop, stopc);
3043           return;
3044         }
3045     }
3046
3047   while (--count >= 0)
3048     {
3049       char *p;
3050
3051       p = frag_more (flen);
3052       memcpy (p, temp, (unsigned int) flen);
3053     }
3054
3055   demand_empty_rest_of_line ();
3056
3057   if (flag_mri)
3058     mri_comment_end (stop, stopc);
3059 }
3060
3061 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3062
3063 void
3064 s_struct (ignore)
3065      int ignore ATTRIBUTE_UNUSED;
3066 {
3067   char *stop = NULL;
3068   char stopc;
3069
3070   if (flag_mri)
3071     stop = mri_comment_field (&stopc);
3072   abs_section_offset = get_absolute_expression ();
3073   subseg_set (absolute_section, 0);
3074   demand_empty_rest_of_line ();
3075   if (flag_mri)
3076     mri_comment_end (stop, stopc);
3077 }
3078
3079 void
3080 s_text (ignore)
3081      int ignore ATTRIBUTE_UNUSED;
3082 {
3083   register int temp;
3084
3085   temp = get_absolute_expression ();
3086   subseg_set (text_section, (subsegT) temp);
3087   demand_empty_rest_of_line ();
3088 #ifdef OBJ_VMS
3089   const_flag &= ~IN_DEFAULT_SECTION;
3090 #endif
3091 }
3092 \f
3093 void
3094 demand_empty_rest_of_line ()
3095 {
3096   SKIP_WHITESPACE ();
3097   if (is_end_of_line[(unsigned char) *input_line_pointer])
3098     input_line_pointer++;
3099   else
3100     ignore_rest_of_line ();
3101
3102   /* Return having already swallowed end-of-line.  */
3103 }
3104
3105 void
3106 ignore_rest_of_line ()
3107 {
3108   /* For suspect lines: gives warning.  */
3109   if (!is_end_of_line[(unsigned char) *input_line_pointer])
3110     {
3111       if (isprint ((unsigned char) *input_line_pointer))
3112         as_bad (_("Rest of line ignored. First ignored character is `%c'."),
3113                 *input_line_pointer);
3114       else
3115         as_bad (_("Rest of line ignored. First ignored character valued 0x%x."),
3116                 *input_line_pointer);
3117
3118       while (input_line_pointer < buffer_limit
3119              && !is_end_of_line[(unsigned char) *input_line_pointer])
3120         input_line_pointer++;
3121     }
3122
3123   input_line_pointer++;
3124
3125   /* Return pointing just after end-of-line.  */
3126   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3127 }
3128
3129 void
3130 discard_rest_of_line ()
3131 {
3132   while (input_line_pointer < buffer_limit
3133          && !is_end_of_line[(unsigned char) *input_line_pointer])
3134     input_line_pointer++;
3135
3136   input_line_pointer++;
3137
3138   /* Return pointing just after end-of-line.  */
3139   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3140 }
3141
3142 /* In:  Pointer to a symbol.
3143         Input_line_pointer->expression.
3144
3145    Out: Input_line_pointer->just after any whitespace after expression.
3146         Tried to set symbol to value of expression.
3147         Will change symbols type, value, and frag;  */
3148
3149 void
3150 pseudo_set (symbolP)
3151      symbolS *symbolP;
3152 {
3153   expressionS exp;
3154   segT seg;
3155 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3156   int ext;
3157 #endif /* OBJ_AOUT or OBJ_BOUT */
3158
3159   know (symbolP);               /* NULL pointer is logic error.  */
3160 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3161   ext = S_IS_EXTERNAL (symbolP);
3162 #endif /* OBJ_AOUT or OBJ_BOUT */
3163
3164   seg = expression (&exp);
3165
3166   if (exp.X_op == O_illegal)
3167     as_bad (_("illegal expression; zero assumed"));
3168   else if (exp.X_op == O_absent)
3169     as_bad (_("missing expression; zero assumed"));
3170   else if (exp.X_op == O_big)
3171     {
3172       if (exp.X_add_number > 0)
3173         as_bad (_("bignum invalid; zero assumed"));
3174       else
3175         as_bad (_("floating point number invalid; zero assumed"));
3176     }
3177   else if (exp.X_op == O_subtract
3178            && (S_GET_SEGMENT (exp.X_add_symbol)
3179                == S_GET_SEGMENT (exp.X_op_symbol))
3180            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3181            && (symbol_get_frag (exp.X_add_symbol)
3182                == symbol_get_frag (exp.X_op_symbol)))
3183     {
3184       exp.X_op = O_constant;
3185       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3186                           - S_GET_VALUE (exp.X_op_symbol));
3187     }
3188
3189   switch (exp.X_op)
3190     {
3191     case O_illegal:
3192     case O_absent:
3193     case O_big:
3194       exp.X_add_number = 0;
3195       /* Fall through.  */
3196     case O_constant:
3197       S_SET_SEGMENT (symbolP, absolute_section);
3198 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3199       if (ext)
3200         S_SET_EXTERNAL (symbolP);
3201       else
3202         S_CLEAR_EXTERNAL (symbolP);
3203 #endif /* OBJ_AOUT or OBJ_BOUT */
3204       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3205       if (exp.X_op != O_constant)
3206         symbol_set_frag (symbolP, &zero_address_frag);
3207       break;
3208
3209     case O_register:
3210       S_SET_SEGMENT (symbolP, reg_section);
3211       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3212       symbol_set_frag (symbolP, &zero_address_frag);
3213       break;
3214
3215     case O_symbol:
3216       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3217           || exp.X_add_number != 0)
3218         symbol_set_value_expression (symbolP, &exp);
3219       else if (symbol_section_p (symbolP))
3220         as_bad ("invalid attempt to set value of section symbol");
3221       else
3222         {
3223           symbolS *s = exp.X_add_symbol;
3224
3225           S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3226 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3227           if (ext)
3228             S_SET_EXTERNAL (symbolP);
3229           else
3230             S_CLEAR_EXTERNAL (symbolP);
3231 #endif /* OBJ_AOUT or OBJ_BOUT */
3232           S_SET_VALUE (symbolP,
3233                        exp.X_add_number + S_GET_VALUE (s));
3234           symbol_set_frag (symbolP, symbol_get_frag (s));
3235           copy_symbol_attributes (symbolP, s);
3236         }
3237       break;
3238
3239     default:
3240       /* The value is some complex expression.  */
3241       symbol_set_value_expression (symbolP, &exp);
3242       S_SET_SEGMENT (symbolP, seg);
3243       break;
3244     }
3245 }
3246 \f
3247 /*                      cons()
3248
3249    CONStruct more frag of .bytes, or .words etc.
3250    Should need_pass_2 be 1 then emit no frag(s).
3251    This understands EXPRESSIONS.
3252
3253    Bug (?)
3254
3255    This has a split personality. We use expression() to read the
3256    value. We can detect if the value won't fit in a byte or word.
3257    But we can't detect if expression() discarded significant digits
3258    in the case of a long. Not worth the crocks required to fix it.  */
3259
3260 /* Select a parser for cons expressions.  */
3261
3262 /* Some targets need to parse the expression in various fancy ways.
3263    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3264    (for example, the HPPA does this).  Otherwise, you can define
3265    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3266    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3267    are defined, which is the normal case, then only simple expressions
3268    are permitted.  */
3269
3270 #ifdef TC_M68K
3271 static void
3272 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3273 #endif
3274
3275 #ifndef TC_PARSE_CONS_EXPRESSION
3276 #ifdef BITFIELD_CONS_EXPRESSIONS
3277 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3278 static void
3279 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3280 #endif
3281 #ifdef REPEAT_CONS_EXPRESSIONS
3282 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3283 static void
3284 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3285 #endif
3286
3287 /* If we haven't gotten one yet, just call expression.  */
3288 #ifndef TC_PARSE_CONS_EXPRESSION
3289 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3290 #endif
3291 #endif
3292
3293 /* Worker to do .byte etc statements.
3294    Clobbers input_line_pointer and checks end-of-line.  */
3295
3296 static void
3297 cons_worker (nbytes, rva)
3298      register int nbytes;       /* 1=.byte, 2=.word, 4=.long.  */
3299      int rva;
3300 {
3301   int c;
3302   expressionS exp;
3303   char *stop = NULL;
3304   char stopc;
3305
3306 #ifdef md_flush_pending_output
3307   md_flush_pending_output ();
3308 #endif
3309
3310   if (flag_mri)
3311     stop = mri_comment_field (&stopc);
3312
3313   if (is_it_end_of_statement ())
3314     {
3315       demand_empty_rest_of_line ();
3316       if (flag_mri)
3317         mri_comment_end (stop, stopc);
3318       return;
3319     }
3320
3321 #ifdef md_cons_align
3322   md_cons_align (nbytes);
3323 #endif
3324
3325   c = 0;
3326   do
3327     {
3328 #ifdef TC_M68K
3329       if (flag_m68k_mri)
3330         parse_mri_cons (&exp, (unsigned int) nbytes);
3331       else
3332 #endif
3333         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3334
3335       if (rva)
3336         {
3337           if (exp.X_op == O_symbol)
3338             exp.X_op = O_symbol_rva;
3339           else
3340             as_fatal (_("rva without symbol"));
3341         }
3342       emit_expr (&exp, (unsigned int) nbytes);
3343       ++c;
3344     }
3345   while (*input_line_pointer++ == ',');
3346
3347   /* In MRI mode, after an odd number of bytes, we must align to an
3348      even word boundary, unless the next instruction is a dc.b, ds.b
3349      or dcb.b.  */
3350   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3351     mri_pending_align = 1;
3352
3353   input_line_pointer--;         /* Put terminator back into stream.  */
3354
3355   demand_empty_rest_of_line ();
3356
3357   if (flag_mri)
3358     mri_comment_end (stop, stopc);
3359 }
3360
3361 void
3362 cons (size)
3363      int size;
3364 {
3365   cons_worker (size, 0);
3366 }
3367
3368 void
3369 s_rva (size)
3370      int size;
3371 {
3372   cons_worker (size, 1);
3373 }
3374
3375 /* Put the contents of expression EXP into the object file using
3376    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
3377
3378 void
3379 emit_expr (exp, nbytes)
3380      expressionS *exp;
3381      unsigned int nbytes;
3382 {
3383   operatorT op;
3384   register char *p;
3385   valueT extra_digit = 0;
3386
3387   /* Don't do anything if we are going to make another pass.  */
3388   if (need_pass_2)
3389     return;
3390
3391 #ifndef NO_LISTING
3392 #ifdef OBJ_ELF
3393   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3394      appear as a four byte positive constant in the .line section,
3395      followed by a 2 byte 0xffff.  Look for that case here.  */
3396   {
3397     static int dwarf_line = -1;
3398
3399     if (strcmp (segment_name (now_seg), ".line") != 0)
3400       dwarf_line = -1;
3401     else if (dwarf_line >= 0
3402              && nbytes == 2
3403              && exp->X_op == O_constant
3404              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3405       listing_source_line ((unsigned int) dwarf_line);
3406     else if (nbytes == 4
3407              && exp->X_op == O_constant
3408              && exp->X_add_number >= 0)
3409       dwarf_line = exp->X_add_number;
3410     else
3411       dwarf_line = -1;
3412   }
3413
3414   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3415      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3416      AT_sibling (0x12) followed by a four byte address of the sibling
3417      followed by a 2 byte AT_name (0x38) followed by the name of the
3418      file.  We look for that case here.  */
3419   {
3420     static int dwarf_file = 0;
3421
3422     if (strcmp (segment_name (now_seg), ".debug") != 0)
3423       dwarf_file = 0;
3424     else if (dwarf_file == 0
3425              && nbytes == 2
3426              && exp->X_op == O_constant
3427              && exp->X_add_number == 0x11)
3428       dwarf_file = 1;
3429     else if (dwarf_file == 1
3430              && nbytes == 2
3431              && exp->X_op == O_constant
3432              && exp->X_add_number == 0x12)
3433       dwarf_file = 2;
3434     else if (dwarf_file == 2
3435              && nbytes == 4)
3436       dwarf_file = 3;
3437     else if (dwarf_file == 3
3438              && nbytes == 2
3439              && exp->X_op == O_constant
3440              && exp->X_add_number == 0x38)
3441       dwarf_file = 4;
3442     else
3443       dwarf_file = 0;
3444
3445     /* The variable dwarf_file_string tells stringer that the string
3446        may be the name of the source file.  */
3447     if (dwarf_file == 4)
3448       dwarf_file_string = 1;
3449     else
3450       dwarf_file_string = 0;
3451   }
3452 #endif
3453 #endif
3454
3455   if (check_eh_frame (exp, &nbytes))
3456     return;
3457
3458   op = exp->X_op;
3459
3460   /* Allow `.word 0' in the absolute section.  */
3461   if (now_seg == absolute_section)
3462     {
3463       if (op != O_constant || exp->X_add_number != 0)
3464         as_bad (_("attempt to store value in absolute section"));
3465       abs_section_offset += nbytes;
3466       return;
3467     }
3468
3469   /* Handle a negative bignum.  */
3470   if (op == O_uminus
3471       && exp->X_add_number == 0
3472       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3473       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3474     {
3475       int i;
3476       unsigned long carry;
3477
3478       exp = symbol_get_value_expression (exp->X_add_symbol);
3479
3480       /* Negate the bignum: one's complement each digit and add 1.  */
3481       carry = 1;
3482       for (i = 0; i < exp->X_add_number; i++)
3483         {
3484           unsigned long next;
3485
3486           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3487                    & LITTLENUM_MASK)
3488                   + carry);
3489           generic_bignum[i] = next & LITTLENUM_MASK;
3490           carry = next >> LITTLENUM_NUMBER_OF_BITS;
3491         }
3492
3493       /* We can ignore any carry out, because it will be handled by
3494          extra_digit if it is needed.  */
3495
3496       extra_digit = (valueT) -1;
3497       op = O_big;
3498     }
3499
3500   if (op == O_absent || op == O_illegal)
3501     {
3502       as_warn (_("zero assumed for missing expression"));
3503       exp->X_add_number = 0;
3504       op = O_constant;
3505     }
3506   else if (op == O_big && exp->X_add_number <= 0)
3507     {
3508       as_bad (_("floating point number invalid; zero assumed"));
3509       exp->X_add_number = 0;
3510       op = O_constant;
3511     }
3512   else if (op == O_register)
3513     {
3514       as_warn (_("register value used as expression"));
3515       op = O_constant;
3516     }
3517
3518   p = frag_more ((int) nbytes);
3519
3520 #ifndef WORKING_DOT_WORD
3521   /* If we have the difference of two symbols in a word, save it on
3522      the broken_words list.  See the code in write.c.  */
3523   if (op == O_subtract && nbytes == 2)
3524     {
3525       struct broken_word *x;
3526
3527       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3528       x->next_broken_word = broken_words;
3529       broken_words = x;
3530       x->seg = now_seg;
3531       x->subseg = now_subseg;
3532       x->frag = frag_now;
3533       x->word_goes_here = p;
3534       x->dispfrag = 0;
3535       x->add = exp->X_add_symbol;
3536       x->sub = exp->X_op_symbol;
3537       x->addnum = exp->X_add_number;
3538       x->added = 0;
3539       new_broken_words++;
3540       return;
3541     }
3542 #endif
3543
3544   /* If we have an integer, but the number of bytes is too large to
3545      pass to md_number_to_chars, handle it as a bignum.  */
3546   if (op == O_constant && nbytes > sizeof (valueT))
3547     {
3548       valueT val;
3549       int gencnt;
3550
3551       if (!exp->X_unsigned && exp->X_add_number < 0)
3552         extra_digit = (valueT) -1;
3553       val = (valueT) exp->X_add_number;
3554       gencnt = 0;
3555       do
3556         {
3557           generic_bignum[gencnt] = val & LITTLENUM_MASK;
3558           val >>= LITTLENUM_NUMBER_OF_BITS;
3559           ++gencnt;
3560         }
3561       while (val != 0);
3562       op = exp->X_op = O_big;
3563       exp->X_add_number = gencnt;
3564     }
3565
3566   if (op == O_constant)
3567     {
3568       register valueT get;
3569       register valueT use;
3570       register valueT mask;
3571       valueT hibit;
3572       register valueT unmask;
3573
3574       /* JF << of >= number of bits in the object is undefined.  In
3575          particular SPARC (Sun 4) has problems.  */
3576       if (nbytes >= sizeof (valueT))
3577         {
3578           mask = 0;
3579           if (nbytes > sizeof (valueT))
3580             hibit = 0;
3581           else
3582             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3583         }
3584       else
3585         {
3586           /* Don't store these bits.  */
3587           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3588           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3589         }
3590
3591       unmask = ~mask;           /* Do store these bits.  */
3592
3593 #ifdef NEVER
3594       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3595       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
3596 #endif
3597
3598       get = exp->X_add_number;
3599       use = get & unmask;
3600       if ((get & mask) != 0
3601           && ((get & mask) != mask
3602               || (get & hibit) == 0))
3603         {               /* Leading bits contain both 0s & 1s.  */
3604           as_warn (_("Value 0x%lx truncated to 0x%lx."),
3605                    (unsigned long) get, (unsigned long) use);
3606         }
3607       /* Put bytes in right order.  */
3608       md_number_to_chars (p, use, (int) nbytes);
3609     }
3610   else if (op == O_big)
3611     {
3612       unsigned int size;
3613       LITTLENUM_TYPE *nums;
3614
3615       know (nbytes % CHARS_PER_LITTLENUM == 0);
3616
3617       size = exp->X_add_number * CHARS_PER_LITTLENUM;
3618       if (nbytes < size)
3619         {
3620           as_warn (_("Bignum truncated to %d bytes"), nbytes);
3621           size = nbytes;
3622         }
3623
3624       if (target_big_endian)
3625         {
3626           while (nbytes > size)
3627             {
3628               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3629               nbytes -= CHARS_PER_LITTLENUM;
3630               p += CHARS_PER_LITTLENUM;
3631             }
3632
3633           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3634           while (size > 0)
3635             {
3636               --nums;
3637               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3638               size -= CHARS_PER_LITTLENUM;
3639               p += CHARS_PER_LITTLENUM;
3640             }
3641         }
3642       else
3643         {
3644           nums = generic_bignum;
3645           while (size > 0)
3646             {
3647               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3648               ++nums;
3649               size -= CHARS_PER_LITTLENUM;
3650               p += CHARS_PER_LITTLENUM;
3651               nbytes -= CHARS_PER_LITTLENUM;
3652             }
3653
3654           while (nbytes > 0)
3655             {
3656               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3657               nbytes -= CHARS_PER_LITTLENUM;
3658               p += CHARS_PER_LITTLENUM;
3659             }
3660         }
3661     }
3662   else
3663     {
3664       memset (p, 0, nbytes);
3665
3666       /* Now we need to generate a fixS to record the symbol value.
3667          This is easy for BFD.  For other targets it can be more
3668          complex.  For very complex cases (currently, the HPPA and
3669          NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3670          want.  For simpler cases, you can define TC_CONS_RELOC to be
3671          the name of the reloc code that should be stored in the fixS.
3672          If neither is defined, the code uses NO_RELOC if it is
3673          defined, and otherwise uses 0.  */
3674
3675 #ifdef BFD_ASSEMBLER
3676 #ifdef TC_CONS_FIX_NEW
3677       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3678 #else
3679       {
3680         bfd_reloc_code_real_type r;
3681
3682         switch (nbytes)
3683           {
3684           case 1:
3685             r = BFD_RELOC_8;
3686             break;
3687           case 2:
3688             r = BFD_RELOC_16;
3689             break;
3690           case 4:
3691             r = BFD_RELOC_32;
3692             break;
3693           case 8:
3694             r = BFD_RELOC_64;
3695             break;
3696           default:
3697             as_bad (_("unsupported BFD relocation size %u"), nbytes);
3698             r = BFD_RELOC_32;
3699             break;
3700           }
3701         fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3702                      0, r);
3703       }
3704 #endif
3705 #else
3706 #ifdef TC_CONS_FIX_NEW
3707       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3708 #else
3709       /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
3710          it is defined, otherwise use NO_RELOC if it is defined,
3711          otherwise use 0.  */
3712 #ifndef TC_CONS_RELOC
3713 #ifdef NO_RELOC
3714 #define TC_CONS_RELOC NO_RELOC
3715 #else
3716 #define TC_CONS_RELOC 0
3717 #endif
3718 #endif
3719       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3720                    TC_CONS_RELOC);
3721 #endif /* TC_CONS_FIX_NEW */
3722 #endif /* BFD_ASSEMBLER */
3723     }
3724 }
3725 \f
3726 #ifdef BITFIELD_CONS_EXPRESSIONS
3727
3728 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3729    w:x,y:z, where w and y are bitwidths and x and y are values.  They
3730    then pack them all together. We do a little better in that we allow
3731    them in words, longs, etc. and we'll pack them in target byte order
3732    for you.
3733
3734    The rules are: pack least significat bit first, if a field doesn't
3735    entirely fit, put it in the next unit.  Overflowing the bitfield is
3736    explicitly *not* even a warning.  The bitwidth should be considered
3737    a "mask".
3738
3739    To use this function the tc-XXX.h file should define
3740    BITFIELD_CONS_EXPRESSIONS.  */
3741
3742 static void
3743 parse_bitfield_cons (exp, nbytes)
3744      expressionS *exp;
3745      unsigned int nbytes;
3746 {
3747   unsigned int bits_available = BITS_PER_CHAR * nbytes;
3748   char *hold = input_line_pointer;
3749
3750   (void) expression (exp);
3751
3752   if (*input_line_pointer == ':')
3753     {
3754       /* Bitfields.  */
3755       long value = 0;
3756
3757       for (;;)
3758         {
3759           unsigned long width;
3760
3761           if (*input_line_pointer != ':')
3762             {
3763               input_line_pointer = hold;
3764               break;
3765             }                   /* Next piece is not a bitfield.  */
3766
3767           /* In the general case, we can't allow
3768              full expressions with symbol
3769              differences and such.  The relocation
3770              entries for symbols not defined in this
3771              assembly would require arbitrary field
3772              widths, positions, and masks which most
3773              of our current object formats don't
3774              support.
3775
3776              In the specific case where a symbol
3777              *is* defined in this assembly, we
3778              *could* build fixups and track it, but
3779              this could lead to confusion for the
3780              backends.  I'm lazy. I'll take any
3781              SEG_ABSOLUTE. I think that means that
3782              you can use a previous .set or
3783              .equ type symbol.  xoxorich.  */
3784
3785           if (exp->X_op == O_absent)
3786             {
3787               as_warn (_("using a bit field width of zero"));
3788               exp->X_add_number = 0;
3789               exp->X_op = O_constant;
3790             }                   /* Implied zero width bitfield.  */
3791
3792           if (exp->X_op != O_constant)
3793             {
3794               *input_line_pointer = '\0';
3795               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3796               *input_line_pointer = ':';
3797               demand_empty_rest_of_line ();
3798               return;
3799             }                   /* Too complex.  */
3800
3801           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3802             {
3803               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3804                        width, nbytes, (BITS_PER_CHAR * nbytes));
3805               width = BITS_PER_CHAR * nbytes;
3806             }                   /* Too big.  */
3807
3808           if (width > bits_available)
3809             {
3810               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
3811               input_line_pointer = hold;
3812               exp->X_add_number = value;
3813               break;
3814             }                   /* Won't fit.  */
3815
3816           /* Skip ':'.  */
3817           hold = ++input_line_pointer;
3818
3819           (void) expression (exp);
3820           if (exp->X_op != O_constant)
3821             {
3822               char cache = *input_line_pointer;
3823
3824               *input_line_pointer = '\0';
3825               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3826               *input_line_pointer = cache;
3827               demand_empty_rest_of_line ();
3828               return;
3829             }                   /* Too complex.  */
3830
3831           value |= ((~(-1 << width) & exp->X_add_number)
3832                     << ((BITS_PER_CHAR * nbytes) - bits_available));
3833
3834           if ((bits_available -= width) == 0
3835               || is_it_end_of_statement ()
3836               || *input_line_pointer != ',')
3837             {
3838               break;
3839             }                   /* All the bitfields we're gonna get.  */
3840
3841           hold = ++input_line_pointer;
3842           (void) expression (exp);
3843         }
3844
3845       exp->X_add_number = value;
3846       exp->X_op = O_constant;
3847       exp->X_unsigned = 1;
3848     }
3849 }
3850
3851 #endif /* BITFIELD_CONS_EXPRESSIONS */
3852 \f
3853 /* Handle an MRI style string expression.  */
3854
3855 #ifdef TC_M68K
3856 static void
3857 parse_mri_cons (exp, nbytes)
3858      expressionS *exp;
3859      unsigned int nbytes;
3860 {
3861   if (*input_line_pointer != '\''
3862       && (input_line_pointer[1] != '\''
3863           || (*input_line_pointer != 'A'
3864               && *input_line_pointer != 'E')))
3865     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3866   else
3867     {
3868       unsigned int scan;
3869       unsigned int result = 0;
3870
3871       /* An MRI style string.  Cut into as many bytes as will fit into
3872          a nbyte chunk, left justify if necessary, and separate with
3873          commas so we can try again later.  */
3874       if (*input_line_pointer == 'A')
3875         ++input_line_pointer;
3876       else if (*input_line_pointer == 'E')
3877         {
3878           as_bad (_("EBCDIC constants are not supported"));
3879           ++input_line_pointer;
3880         }
3881
3882       input_line_pointer++;
3883       for (scan = 0; scan < nbytes; scan++)
3884         {
3885           if (*input_line_pointer == '\'')
3886             {
3887               if (input_line_pointer[1] == '\'')
3888                 {
3889                   input_line_pointer++;
3890                 }
3891               else
3892                 break;
3893             }
3894           result = (result << 8) | (*input_line_pointer++);
3895         }
3896
3897       /* Left justify.  */
3898       while (scan < nbytes)
3899         {
3900           result <<= 8;
3901           scan++;
3902         }
3903
3904       /* Create correct expression.  */
3905       exp->X_op = O_constant;
3906       exp->X_add_number = result;
3907
3908       /* Fake it so that we can read the next char too.  */
3909       if (input_line_pointer[0] != '\'' ||
3910           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3911         {
3912           input_line_pointer -= 2;
3913           input_line_pointer[0] = ',';
3914           input_line_pointer[1] = '\'';
3915         }
3916       else
3917         input_line_pointer++;
3918     }
3919 }
3920 #endif /* TC_M68K */
3921 \f
3922 #ifdef REPEAT_CONS_EXPRESSIONS
3923
3924 /* Parse a repeat expression for cons.  This is used by the MIPS
3925    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
3926    object file COUNT times.
3927
3928    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
3929
3930 static void
3931 parse_repeat_cons (exp, nbytes)
3932      expressionS *exp;
3933      unsigned int nbytes;
3934 {
3935   expressionS count;
3936   register int i;
3937
3938   expression (exp);
3939
3940   if (*input_line_pointer != ':')
3941     {
3942       /* No repeat count.  */
3943       return;
3944     }
3945
3946   ++input_line_pointer;
3947   expression (&count);
3948   if (count.X_op != O_constant
3949       || count.X_add_number <= 0)
3950     {
3951       as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
3952       return;
3953     }
3954
3955   /* The cons function is going to output this expression once.  So we
3956      output it count - 1 times.  */
3957   for (i = count.X_add_number - 1; i > 0; i--)
3958     emit_expr (exp, nbytes);
3959 }
3960
3961 #endif /* REPEAT_CONS_EXPRESSIONS */
3962 \f
3963 /* Parse a floating point number represented as a hex constant.  This
3964    permits users to specify the exact bits they want in the floating
3965    point number.  */
3966
3967 static int
3968 hex_float (float_type, bytes)
3969      int float_type;
3970      char *bytes;
3971 {
3972   int length;
3973   int i;
3974
3975   switch (float_type)
3976     {
3977     case 'f':
3978     case 'F':
3979     case 's':
3980     case 'S':
3981       length = 4;
3982       break;
3983
3984     case 'd':
3985     case 'D':
3986     case 'r':
3987     case 'R':
3988       length = 8;
3989       break;
3990
3991     case 'x':
3992     case 'X':
3993       length = 12;
3994       break;
3995
3996     case 'p':
3997     case 'P':
3998       length = 12;
3999       break;
4000
4001     default:
4002       as_bad (_("Unknown floating type type '%c'"), float_type);
4003       return -1;
4004     }
4005
4006   /* It would be nice if we could go through expression to parse the
4007      hex constant, but if we get a bignum it's a pain to sort it into
4008      the buffer correctly.  */
4009   i = 0;
4010   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4011     {
4012       int d;
4013
4014       /* The MRI assembler accepts arbitrary underscores strewn about
4015          through the hex constant, so we ignore them as well.  */
4016       if (*input_line_pointer == '_')
4017         {
4018           ++input_line_pointer;
4019           continue;
4020         }
4021
4022       if (i >= length)
4023         {
4024           as_warn (_("Floating point constant too large"));
4025           return -1;
4026         }
4027       d = hex_value (*input_line_pointer) << 4;
4028       ++input_line_pointer;
4029       while (*input_line_pointer == '_')
4030         ++input_line_pointer;
4031       if (hex_p (*input_line_pointer))
4032         {
4033           d += hex_value (*input_line_pointer);
4034           ++input_line_pointer;
4035         }
4036       if (target_big_endian)
4037         bytes[i] = d;
4038       else
4039         bytes[length - i - 1] = d;
4040       ++i;
4041     }
4042
4043   if (i < length)
4044     {
4045       if (target_big_endian)
4046         memset (bytes + i, 0, length - i);
4047       else
4048         memset (bytes, 0, length - i);
4049     }
4050
4051   return length;
4052 }
4053
4054 /*                      float_cons()
4055
4056    CONStruct some more frag chars of .floats .ffloats etc.
4057    Makes 0 or more new frags.
4058    If need_pass_2 == 1, no frags are emitted.
4059    This understands only floating literals, not expressions. Sorry.
4060
4061    A floating constant is defined by atof_generic(), except it is preceded
4062    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4063    reading, I decided to be incompatible. This always tries to give you
4064    rounded bits to the precision of the pseudo-op. Former AS did premature
4065    truncatation, restored noisy bits instead of trailing 0s AND gave you
4066    a choice of 2 flavours of noise according to which of 2 floating-point
4067    scanners you directed AS to use.
4068
4069    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
4070
4071 void
4072 float_cons (float_type)
4073      /* Clobbers input_line-pointer, checks end-of-line.  */
4074      register int float_type;   /* 'f':.ffloat ... 'F':.float ...  */
4075 {
4076   register char *p;
4077   int length;                   /* Number of chars in an object.  */
4078   register char *err;           /* Error from scanning floating literal.  */
4079   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4080
4081   if (is_it_end_of_statement ())
4082     {
4083       demand_empty_rest_of_line ();
4084       return;
4085     }
4086
4087 #ifdef md_flush_pending_output
4088   md_flush_pending_output ();
4089 #endif
4090
4091   do
4092     {
4093       /* input_line_pointer->1st char of a flonum (we hope!).  */
4094       SKIP_WHITESPACE ();
4095
4096       /* Skip any 0{letter} that may be present. Don't even check if the
4097          letter is legal. Someone may invent a "z" format and this routine
4098          has no use for such information. Lusers beware: you get
4099          diagnostics if your input is ill-conditioned.  */
4100       if (input_line_pointer[0] == '0'
4101           && isalpha ((unsigned char) input_line_pointer[1]))
4102         input_line_pointer += 2;
4103
4104       /* Accept :xxxx, where the x's are hex digits, for a floating
4105          point with the exact digits specified.  */
4106       if (input_line_pointer[0] == ':')
4107         {
4108           ++input_line_pointer;
4109           length = hex_float (float_type, temp);
4110           if (length < 0)
4111             {
4112               ignore_rest_of_line ();
4113               return;
4114             }
4115         }
4116       else
4117         {
4118           err = md_atof (float_type, temp, &length);
4119           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4120           know (length > 0);
4121           if (err)
4122             {
4123               as_bad (_("Bad floating literal: %s"), err);
4124               ignore_rest_of_line ();
4125               return;
4126             }
4127         }
4128
4129       if (!need_pass_2)
4130         {
4131           int count;
4132
4133           count = 1;
4134
4135 #ifdef REPEAT_CONS_EXPRESSIONS
4136           if (*input_line_pointer == ':')
4137             {
4138               expressionS count_exp;
4139
4140               ++input_line_pointer;
4141               expression (&count_exp);
4142
4143               if (count_exp.X_op != O_constant
4144                   || count_exp.X_add_number <= 0)
4145                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4146               else
4147                 count = count_exp.X_add_number;
4148             }
4149 #endif
4150
4151           while (--count >= 0)
4152             {
4153               p = frag_more (length);
4154               memcpy (p, temp, (unsigned int) length);
4155             }
4156         }
4157       SKIP_WHITESPACE ();
4158     }
4159   while (*input_line_pointer++ == ',');
4160
4161   /* Put terminator back into stream.  */
4162   --input_line_pointer;
4163   demand_empty_rest_of_line ();
4164 }
4165 \f
4166 /* Return the size of a LEB128 value.  */
4167
4168 static inline int
4169 sizeof_sleb128 (value)
4170      offsetT value;
4171 {
4172   register int size = 0;
4173   register unsigned byte;
4174
4175   do
4176     {
4177       byte = (value & 0x7f);
4178       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4179          Fortunately, we can structure things so that the extra work reduces
4180          to a noop on systems that do things "properly".  */
4181       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4182       size += 1;
4183     }
4184   while (!(((value == 0) && ((byte & 0x40) == 0))
4185            || ((value == -1) && ((byte & 0x40) != 0))));
4186
4187   return size;
4188 }
4189
4190 static inline int
4191 sizeof_uleb128 (value)
4192      valueT value;
4193 {
4194   register int size = 0;
4195   register unsigned byte;
4196
4197   do
4198     {
4199       byte = (value & 0x7f);
4200       value >>= 7;
4201       size += 1;
4202     }
4203   while (value != 0);
4204
4205   return size;
4206 }
4207
4208 int
4209 sizeof_leb128 (value, sign)
4210      valueT value;
4211      int sign;
4212 {
4213   if (sign)
4214     return sizeof_sleb128 ((offsetT) value);
4215   else
4216     return sizeof_uleb128 (value);
4217 }
4218
4219 /* Output a LEB128 value.  */
4220
4221 static inline int
4222 output_sleb128 (p, value)
4223      char *p;
4224      offsetT value;
4225 {
4226   register char *orig = p;
4227   register int more;
4228
4229   do
4230     {
4231       unsigned byte = (value & 0x7f);
4232
4233       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4234          Fortunately, we can structure things so that the extra work reduces
4235          to a noop on systems that do things "properly".  */
4236       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4237
4238       more = !((((value == 0) && ((byte & 0x40) == 0))
4239                 || ((value == -1) && ((byte & 0x40) != 0))));
4240       if (more)
4241         byte |= 0x80;
4242
4243       *p++ = byte;
4244     }
4245   while (more);
4246
4247   return p - orig;
4248 }
4249
4250 static inline int
4251 output_uleb128 (p, value)
4252      char *p;
4253      valueT value;
4254 {
4255   char *orig = p;
4256
4257   do
4258     {
4259       unsigned byte = (value & 0x7f);
4260       value >>= 7;
4261       if (value != 0)
4262         /* More bytes to follow.  */
4263         byte |= 0x80;
4264
4265       *p++ = byte;
4266     }
4267   while (value != 0);
4268
4269   return p - orig;
4270 }
4271
4272 int
4273 output_leb128 (p, value, sign)
4274      char *p;
4275      valueT value;
4276      int sign;
4277 {
4278   if (sign)
4279     return output_sleb128 (p, (offsetT) value);
4280   else
4281     return output_uleb128 (p, value);
4282 }
4283
4284 /* Do the same for bignums.  We combine sizeof with output here in that
4285    we don't output for NULL values of P.  It isn't really as critical as
4286    for "normal" values that this be streamlined.  */
4287
4288 static inline int
4289 output_big_sleb128 (p, bignum, size)
4290      char *p;
4291      LITTLENUM_TYPE *bignum;
4292      int size;
4293 {
4294   char *orig = p;
4295   valueT val = 0;
4296   int loaded = 0;
4297   unsigned byte;
4298
4299   /* Strip leading sign extensions off the bignum.  */
4300   while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
4301     size--;
4302
4303   do
4304     {
4305       if (loaded < 7 && size > 0)
4306         {
4307           val |= (*bignum << loaded);
4308           loaded += 8 * CHARS_PER_LITTLENUM;
4309           size--;
4310           bignum++;
4311         }
4312
4313       byte = val & 0x7f;
4314       loaded -= 7;
4315       val >>= 7;
4316
4317       if (size == 0)
4318         {
4319           if ((val == 0 && (byte & 0x40) == 0)
4320               || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
4321                   && (byte & 0x40) != 0))
4322             byte |= 0x80;
4323         }
4324
4325       if (orig)
4326         *p = byte;
4327       p++;
4328     }
4329   while (byte & 0x80);
4330
4331   return p - orig;
4332 }
4333
4334 static inline int
4335 output_big_uleb128 (p, bignum, size)
4336      char *p;
4337      LITTLENUM_TYPE *bignum;
4338      int size;
4339 {
4340   char *orig = p;
4341   valueT val = 0;
4342   int loaded = 0;
4343   unsigned byte;
4344
4345   /* Strip leading zeros off the bignum.  */
4346   /* XXX: Is this needed?  */
4347   while (size > 0 && bignum[size - 1] == 0)
4348     size--;
4349
4350   do
4351     {
4352       if (loaded < 7 && size > 0)
4353         {
4354           val |= (*bignum << loaded);
4355           loaded += 8 * CHARS_PER_LITTLENUM;
4356           size--;
4357           bignum++;
4358         }
4359
4360       byte = val & 0x7f;
4361       loaded -= 7;
4362       val >>= 7;
4363
4364       if (size > 0 || val)
4365         byte |= 0x80;
4366
4367       if (orig)
4368         *p = byte;
4369       p++;
4370     }
4371   while (byte & 0x80);
4372
4373   return p - orig;
4374 }
4375
4376 static int
4377 output_big_leb128 (p, bignum, size, sign)
4378      char *p;
4379      LITTLENUM_TYPE *bignum;
4380      int size, sign;
4381 {
4382   if (sign)
4383     return output_big_sleb128 (p, bignum, size);
4384   else
4385     return output_big_uleb128 (p, bignum, size);
4386 }
4387
4388 /* Generate the appropriate fragments for a given expression to emit a
4389    leb128 value.  */
4390
4391 void
4392 emit_leb128_expr (exp, sign)
4393      expressionS *exp;
4394      int sign;
4395 {
4396   operatorT op = exp->X_op;
4397   int nbytes;
4398
4399   if (op == O_absent || op == O_illegal)
4400     {
4401       as_warn (_("zero assumed for missing expression"));
4402       exp->X_add_number = 0;
4403       op = O_constant;
4404     }
4405   else if (op == O_big && exp->X_add_number <= 0)
4406     {
4407       as_bad (_("floating point number invalid; zero assumed"));
4408       exp->X_add_number = 0;
4409       op = O_constant;
4410     }
4411   else if (op == O_register)
4412     {
4413       as_warn (_("register value used as expression"));
4414       op = O_constant;
4415     }
4416
4417   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
4418      a signal that this is leb128 data.  It shouldn't optimize this away.  */
4419   nbytes = -1;
4420   if (check_eh_frame (exp, &nbytes))
4421     abort ();
4422
4423   if (op == O_constant)
4424     {
4425       /* If we've got a constant, emit the thing directly right now.  */
4426
4427       valueT value = exp->X_add_number;
4428       int size;
4429       char *p;
4430
4431       size = sizeof_leb128 (value, sign);
4432       p = frag_more (size);
4433       output_leb128 (p, value, sign);
4434     }
4435   else if (op == O_big)
4436     {
4437       /* O_big is a different sort of constant.  */
4438
4439       int size;
4440       char *p;
4441
4442       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4443       p = frag_more (size);
4444       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4445     }
4446   else
4447     {
4448       /* Otherwise, we have to create a variable sized fragment and
4449          resolve things later.  */
4450
4451       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4452                 make_expr_symbol (exp), 0, (char *) NULL);
4453     }
4454 }
4455
4456 /* Parse the .sleb128 and .uleb128 pseudos.  */
4457
4458 void
4459 s_leb128 (sign)
4460      int sign;
4461 {
4462   expressionS exp;
4463
4464   do
4465     {
4466       expression (&exp);
4467       emit_leb128_expr (&exp, sign);
4468     }
4469   while (*input_line_pointer++ == ',');
4470
4471   input_line_pointer--;
4472   demand_empty_rest_of_line ();
4473 }
4474 \f
4475 /* We read 0 or more ',' separated, double-quoted strings.
4476    Caller should have checked need_pass_2 is FALSE because we don't
4477    check it.  */
4478
4479 void
4480 stringer (append_zero)          /* Worker to do .ascii etc statements.  */
4481      /* Checks end-of-line.  */
4482      register int append_zero;  /* 0: don't append '\0', else 1.  */
4483 {
4484   register unsigned int c;
4485   char *start;
4486
4487 #ifdef md_flush_pending_output
4488   md_flush_pending_output ();
4489 #endif
4490
4491   /* The following awkward logic is to parse ZERO or more strings,
4492      comma separated. Recall a string expression includes spaces
4493      before the opening '\"' and spaces after the closing '\"'.
4494      We fake a leading ',' if there is (supposed to be)
4495      a 1st, expression. We keep demanding expressions for each ','.  */
4496   if (is_it_end_of_statement ())
4497     {
4498       c = 0;                    /* Skip loop.  */
4499       ++input_line_pointer;     /* Compensate for end of loop.  */
4500     }
4501   else
4502     {
4503       c = ',';                  /* Do loop.  */
4504     }
4505   while (c == ',' || c == '<' || c == '"')
4506     {
4507       SKIP_WHITESPACE ();
4508       switch (*input_line_pointer)
4509         {
4510         case '\"':
4511           ++input_line_pointer; /*->1st char of string.  */
4512           start = input_line_pointer;
4513           while (is_a_char (c = next_char_of_string ()))
4514             {
4515               FRAG_APPEND_1_CHAR (c);
4516             }
4517           if (append_zero)
4518             {
4519               FRAG_APPEND_1_CHAR (0);
4520             }
4521           know (input_line_pointer[-1] == '\"');
4522
4523 #ifndef NO_LISTING
4524 #ifdef OBJ_ELF
4525           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4526              will emit .string with a filename in the .debug section
4527              after a sequence of constants.  See the comment in
4528              emit_expr for the sequence.  emit_expr will set
4529              dwarf_file_string to non-zero if this string might be a
4530              source file name.  */
4531           if (strcmp (segment_name (now_seg), ".debug") != 0)
4532             dwarf_file_string = 0;
4533           else if (dwarf_file_string)
4534             {
4535               c = input_line_pointer[-1];
4536               input_line_pointer[-1] = '\0';
4537               listing_source_file (start);
4538               input_line_pointer[-1] = c;
4539             }
4540 #endif
4541 #endif
4542
4543           break;
4544         case '<':
4545           input_line_pointer++;
4546           c = get_single_number ();
4547           FRAG_APPEND_1_CHAR (c);
4548           if (*input_line_pointer != '>')
4549             {
4550               as_bad (_("Expected <nn>"));
4551             }
4552           input_line_pointer++;
4553           break;
4554         case ',':
4555           input_line_pointer++;
4556           break;
4557         }
4558       SKIP_WHITESPACE ();
4559       c = *input_line_pointer;
4560     }
4561
4562   demand_empty_rest_of_line ();
4563 }                               /* stringer() */
4564 \f
4565 /* FIXME-SOMEDAY: I had trouble here on characters with the
4566     high bits set.  We'll probably also have trouble with
4567     multibyte chars, wide chars, etc.  Also be careful about
4568     returning values bigger than 1 byte.  xoxorich.  */
4569
4570 unsigned int
4571 next_char_of_string ()
4572 {
4573   register unsigned int c;
4574
4575   c = *input_line_pointer++ & CHAR_MASK;
4576   switch (c)
4577     {
4578     case '\"':
4579       c = NOT_A_CHAR;
4580       break;
4581
4582     case '\n':
4583       as_warn (_("Unterminated string: Newline inserted."));
4584       bump_line_counters ();
4585       break;
4586
4587 #ifndef NO_STRING_ESCAPES
4588     case '\\':
4589       switch (c = *input_line_pointer++)
4590         {
4591         case 'b':
4592           c = '\b';
4593           break;
4594
4595         case 'f':
4596           c = '\f';
4597           break;
4598
4599         case 'n':
4600           c = '\n';
4601           break;
4602
4603         case 'r':
4604           c = '\r';
4605           break;
4606
4607         case 't':
4608           c = '\t';
4609           break;
4610
4611         case 'v':
4612           c = '\013';
4613           break;
4614
4615         case '\\':
4616         case '"':
4617           break;                /* As itself.  */
4618
4619         case '0':
4620         case '1':
4621         case '2':
4622         case '3':
4623         case '4':
4624         case '5':
4625         case '6':
4626         case '7':
4627         case '8':
4628         case '9':
4629           {
4630             long number;
4631             int i;
4632
4633             for (i = 0, number = 0;
4634                  isdigit (c) && i < 3;
4635                  c = *input_line_pointer++, i++)
4636               {
4637                 number = number * 8 + c - '0';
4638               }
4639
4640             c = number & 0xff;
4641           }
4642           --input_line_pointer;
4643           break;
4644
4645         case 'x':
4646         case 'X':
4647           {
4648             long number;
4649
4650             number = 0;
4651             c = *input_line_pointer++;
4652             while (isxdigit (c))
4653               {
4654                 if (isdigit (c))
4655                   number = number * 16 + c - '0';
4656                 else if (isupper (c))
4657                   number = number * 16 + c - 'A' + 10;
4658                 else
4659                   number = number * 16 + c - 'a' + 10;
4660                 c = *input_line_pointer++;
4661               }
4662             c = number & 0xff;
4663             --input_line_pointer;
4664           }
4665           break;
4666
4667         case '\n':
4668           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
4669           as_warn (_("Unterminated string: Newline inserted."));
4670           c = '\n';
4671           bump_line_counters ();
4672           break;
4673
4674         default:
4675
4676 #ifdef ONLY_STANDARD_ESCAPES
4677           as_bad (_("Bad escaped character in string, '?' assumed"));
4678           c = '?';
4679 #endif /* ONLY_STANDARD_ESCAPES */
4680
4681           break;
4682         }
4683       break;
4684 #endif /* ! defined (NO_STRING_ESCAPES) */
4685
4686     default:
4687       break;
4688     }
4689   return (c);
4690 }
4691 \f
4692 static segT
4693 get_segmented_expression (expP)
4694      register expressionS *expP;
4695 {
4696   register segT retval;
4697
4698   retval = expression (expP);
4699   if (expP->X_op == O_illegal
4700       || expP->X_op == O_absent
4701       || expP->X_op == O_big)
4702     {
4703       as_bad (_("expected address expression; zero assumed"));
4704       expP->X_op = O_constant;
4705       expP->X_add_number = 0;
4706       retval = absolute_section;
4707     }
4708   return retval;
4709 }
4710
4711 static segT
4712 get_known_segmented_expression (expP)
4713      register expressionS *expP;
4714 {
4715   register segT retval;
4716
4717   if ((retval = get_segmented_expression (expP)) == undefined_section)
4718     {
4719       /* There is no easy way to extract the undefined symbol from the
4720          expression.  */
4721       if (expP->X_add_symbol != NULL
4722           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4723         as_warn (_("symbol \"%s\" undefined; zero assumed"),
4724                  S_GET_NAME (expP->X_add_symbol));
4725       else
4726         as_warn (_("some symbol undefined; zero assumed"));
4727       retval = absolute_section;
4728       expP->X_op = O_constant;
4729       expP->X_add_number = 0;
4730     }
4731   know (retval == absolute_section || SEG_NORMAL (retval));
4732   return (retval);
4733 }
4734
4735 offsetT
4736 get_absolute_expression ()
4737 {
4738   expressionS exp;
4739
4740   expression (&exp);
4741   if (exp.X_op != O_constant)
4742     {
4743       if (exp.X_op != O_absent)
4744         as_bad (_("bad or irreducible absolute expression; zero assumed"));
4745       exp.X_add_number = 0;
4746     }
4747   return exp.X_add_number;
4748 }
4749
4750 char                            /* Return terminator.  */
4751 get_absolute_expression_and_terminator (val_pointer)
4752      long *val_pointer;         /* Return value of expression.  */
4753 {
4754   /* FIXME: val_pointer should probably be offsetT *.  */
4755   *val_pointer = (long) get_absolute_expression ();
4756   return (*input_line_pointer++);
4757 }
4758 \f
4759 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4760    Give a warning if that happens.  */
4761
4762 char *
4763 demand_copy_C_string (len_pointer)
4764      int *len_pointer;
4765 {
4766   register char *s;
4767
4768   if ((s = demand_copy_string (len_pointer)) != 0)
4769     {
4770       register int len;
4771
4772       for (len = *len_pointer; len > 0; len--)
4773         {
4774           if (*s == 0)
4775             {
4776               s = 0;
4777               len = 1;
4778               *len_pointer = 0;
4779               as_bad (_("This string may not contain \'\\0\'"));
4780             }
4781         }
4782     }
4783
4784   return s;
4785 }
4786 \f
4787 /* Demand string, but return a safe (=private) copy of the string.
4788    Return NULL if we can't read a string here.  */
4789
4790 char *
4791 demand_copy_string (lenP)
4792      int *lenP;
4793 {
4794   register unsigned int c;
4795   register int len;
4796   char *retval;
4797
4798   len = 0;
4799   SKIP_WHITESPACE ();
4800   if (*input_line_pointer == '\"')
4801     {
4802       input_line_pointer++;     /* Skip opening quote.  */
4803
4804       while (is_a_char (c = next_char_of_string ()))
4805         {
4806           obstack_1grow (&notes, c);
4807           len++;
4808         }
4809       /* JF this next line is so demand_copy_C_string will return a
4810          null terminated string.  */
4811       obstack_1grow (&notes, '\0');
4812       retval = obstack_finish (&notes);
4813     }
4814   else
4815     {
4816       as_warn (_("Missing string"));
4817       retval = NULL;
4818       ignore_rest_of_line ();
4819     }
4820   *lenP = len;
4821   return (retval);
4822 }
4823 \f
4824 /* In:  Input_line_pointer->next character.
4825
4826    Do:  Skip input_line_pointer over all whitespace.
4827
4828    Out: 1 if input_line_pointer->end-of-line.  */
4829
4830 int
4831 is_it_end_of_statement ()
4832 {
4833   SKIP_WHITESPACE ();
4834   return (is_end_of_line[(unsigned char) *input_line_pointer]);
4835 }
4836
4837 void
4838 equals (sym_name, reassign)
4839      char *sym_name;
4840      int reassign;
4841 {
4842   register symbolS *symbolP;    /* Symbol we are working with.  */
4843   char *stop = NULL;
4844   char stopc;
4845
4846   input_line_pointer++;
4847   if (*input_line_pointer == '=')
4848     input_line_pointer++;
4849
4850   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4851     input_line_pointer++;
4852
4853   if (flag_mri)
4854     stop = mri_comment_field (&stopc);
4855
4856   if (sym_name[0] == '.' && sym_name[1] == '\0')
4857     {
4858       /* Turn '. = mumble' into a .org mumble.  */
4859       register segT segment;
4860       expressionS exp;
4861
4862       segment = get_known_segmented_expression (&exp);
4863       if (!need_pass_2)
4864         do_org (segment, &exp, 0);
4865     }
4866   else
4867     {
4868 #ifdef OBJ_COFF
4869       int local;
4870
4871       symbolP = symbol_find (sym_name);
4872       local = symbolP == NULL;
4873       if (local)
4874 #endif /* OBJ_COFF */
4875       symbolP = symbol_find_or_make (sym_name);
4876       /* Permit register names to be redefined.  */
4877       if (!reassign
4878           && S_IS_DEFINED (symbolP)
4879           && S_GET_SEGMENT (symbolP) != reg_section)
4880         as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
4881
4882 #ifdef OBJ_COFF
4883       /* "set" symbols are local unless otherwise specified.  */
4884       if (local)
4885         SF_SET_LOCAL (symbolP);
4886 #endif /* OBJ_COFF */
4887
4888       pseudo_set (symbolP);
4889     }
4890
4891   if (flag_mri)
4892     {
4893       /* Check garbage after the expression.  */
4894       ignore_rest_of_line ();
4895       mri_comment_end (stop, stopc);
4896     }
4897 }
4898
4899 /* .include -- include a file at this point.  */
4900
4901 void
4902 s_include (arg)
4903      int arg ATTRIBUTE_UNUSED;
4904 {
4905   char *filename;
4906   int i;
4907   FILE *try;
4908   char *path;
4909
4910   if (!flag_m68k_mri)
4911     {
4912       filename = demand_copy_string (&i);
4913       if (filename == NULL)
4914         {
4915           /* demand_copy_string has already printed an error and
4916              called ignore_rest_of_line.  */
4917           return;
4918         }
4919     }
4920   else
4921     {
4922       SKIP_WHITESPACE ();
4923       i = 0;
4924       while (!is_end_of_line[(unsigned char) *input_line_pointer]
4925              && *input_line_pointer != ' '
4926              && *input_line_pointer != '\t')
4927         {
4928           obstack_1grow (&notes, *input_line_pointer);
4929           ++input_line_pointer;
4930           ++i;
4931         }
4932
4933       obstack_1grow (&notes, '\0');
4934       filename = obstack_finish (&notes);
4935       while (!is_end_of_line[(unsigned char) *input_line_pointer])
4936         ++input_line_pointer;
4937     }
4938
4939   demand_empty_rest_of_line ();
4940   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4941
4942   for (i = 0; i < include_dir_count; i++)
4943     {
4944       strcpy (path, include_dirs[i]);
4945       strcat (path, "/");
4946       strcat (path, filename);
4947       if (0 != (try = fopen (path, "r")))
4948         {
4949           fclose (try);
4950           goto gotit;
4951         }
4952     }
4953
4954   free (path);
4955   path = filename;
4956 gotit:
4957   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
4958   register_dependency (path);
4959   input_scrub_insert_file (path);
4960 }
4961
4962 void
4963 add_include_dir (path)
4964      char *path;
4965 {
4966   int i;
4967
4968   if (include_dir_count == 0)
4969     {
4970       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4971       include_dirs[0] = ".";    /* Current dir.  */
4972       include_dir_count = 2;
4973     }
4974   else
4975     {
4976       include_dir_count++;
4977       include_dirs =
4978         (char **) realloc (include_dirs,
4979                            include_dir_count * sizeof (*include_dirs));
4980     }
4981
4982   include_dirs[include_dir_count - 1] = path;   /* New one.  */
4983
4984   i = strlen (path);
4985   if (i > include_dir_maxlen)
4986     include_dir_maxlen = i;
4987 }
4988 \f
4989 /* Output debugging information to denote the source file.  */
4990
4991 static void
4992 generate_file_debug ()
4993 {
4994   if (debug_type == DEBUG_STABS)
4995     stabs_generate_asm_file ();
4996 }
4997
4998 /* Output line number debugging information for the current source line.  */
4999
5000 void
5001 generate_lineno_debug ()
5002 {
5003   switch (debug_type)
5004     {
5005     case DEBUG_UNSPECIFIED:
5006     case DEBUG_NONE:
5007     case DEBUG_DWARF:
5008       break;
5009     case DEBUG_STABS:
5010       stabs_generate_asm_lineno ();
5011       break;
5012     case DEBUG_ECOFF:
5013       ecoff_generate_asm_lineno ();
5014       break;
5015     case DEBUG_DWARF2:
5016       /* ??? We could here indicate to dwarf2dbg.c that something
5017          has changed.  However, since there is additional backend
5018          support that is required (calling dwarf2_emit_insn), we
5019          let dwarf2dbg.c call as_where on its own.  */
5020       break;
5021     }
5022 }
5023
5024 /* Output debugging information to mark a function entry point or end point.
5025    END_P is zero for .func, and non-zero for .endfunc.  */
5026
5027 void
5028 s_func (end_p)
5029      int end_p;
5030 {
5031   do_s_func (end_p, NULL);
5032 }
5033
5034 /* Subroutine of s_func so targets can choose a different default prefix.
5035    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
5036
5037 void
5038 do_s_func (end_p, default_prefix)
5039      int end_p;
5040      const char *default_prefix;
5041 {
5042   /* Record the current function so that we can issue an error message for
5043      misplaced .func,.endfunc, and also so that .endfunc needs no
5044      arguments.  */
5045   static char *current_name;
5046   static char *current_label;
5047
5048   if (end_p)
5049     {
5050       if (current_name == NULL)
5051         {
5052           as_bad (_("missing .func"));
5053           ignore_rest_of_line ();
5054           return;
5055         }
5056
5057       if (debug_type == DEBUG_STABS)
5058         stabs_generate_asm_endfunc (current_name, current_label);
5059
5060       current_name = current_label = NULL;
5061     }
5062   else /* ! end_p */
5063     {
5064       char *name, *label;
5065       char delim1, delim2;
5066
5067       if (current_name != NULL)
5068         {
5069           as_bad (_(".endfunc missing for previous .func"));
5070           ignore_rest_of_line ();
5071           return;
5072         }
5073
5074       name = input_line_pointer;
5075       delim1 = get_symbol_end ();
5076       name = xstrdup (name);
5077       *input_line_pointer = delim1;
5078       SKIP_WHITESPACE ();
5079       if (*input_line_pointer != ',')
5080         {
5081           if (default_prefix)
5082             asprintf (&label, "%s%s", default_prefix, name);
5083           else
5084             {
5085               char leading_char = 0;
5086 #ifdef BFD_ASSEMBLER
5087               leading_char = bfd_get_symbol_leading_char (stdoutput);
5088 #endif
5089               /* Missing entry point, use function's name with the leading
5090                  char prepended.  */
5091               if (leading_char)
5092                 asprintf (&label, "%c%s", leading_char, name);
5093               else
5094                 label = name;
5095             }
5096         }
5097       else
5098         {
5099           ++input_line_pointer;
5100           SKIP_WHITESPACE ();
5101           label = input_line_pointer;
5102           delim2 = get_symbol_end ();
5103           label = xstrdup (label);
5104           *input_line_pointer = delim2;
5105         }
5106
5107       if (debug_type == DEBUG_STABS)
5108         stabs_generate_asm_func (name, label);
5109
5110       current_name = name;
5111       current_label = label;
5112     }
5113
5114   demand_empty_rest_of_line ();
5115 }
5116 \f
5117 void
5118 s_ignore (arg)
5119      int arg ATTRIBUTE_UNUSED;
5120 {
5121   while (!is_end_of_line[(unsigned char) *input_line_pointer])
5122     {
5123       ++input_line_pointer;
5124     }
5125   ++input_line_pointer;
5126 }
5127
5128 void
5129 read_print_statistics (file)
5130      FILE *file;
5131 {
5132   hash_print_statistics (file, "pseudo-op table", po_hash);
5133 }
5134
5135 /* Inserts the given line into the input stream.
5136
5137    This call avoids macro/conditionals nesting checking, since the contents of
5138    the line are assumed to replace the contents of a line already scanned.
5139
5140    An appropriate use of this function would be substition of input lines when
5141    called by md_start_line_hook().  The given line is assumed to already be
5142    properly scrubbed.  */
5143
5144 void
5145 input_scrub_insert_line (line)
5146      const char *line;
5147 {
5148   sb newline;
5149   sb_new (&newline);
5150   sb_add_string (&newline, line);
5151   input_scrub_include_sb (&newline, input_line_pointer, 0);
5152   sb_kill (&newline);
5153   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5154 }
5155
5156 /* Insert a file into the input stream; the path must resolve to an actual
5157    file; no include path searching or dependency registering is performed.  */
5158
5159 void
5160 input_scrub_insert_file (path)
5161      char *path;
5162 {
5163   input_scrub_include_file (path, input_line_pointer);
5164   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5165 }