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 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3155   int ext;
3156 #endif /* OBJ_AOUT or OBJ_BOUT */
3157
3158   know (symbolP);               /* NULL pointer is logic error.  */
3159 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3160   ext = S_IS_EXTERNAL (symbolP);
3161 #endif /* OBJ_AOUT or OBJ_BOUT */
3162
3163   (void) expression (&exp);
3164
3165   if (exp.X_op == O_illegal)
3166     as_bad (_("illegal expression; zero assumed"));
3167   else if (exp.X_op == O_absent)
3168     as_bad (_("missing expression; zero assumed"));
3169   else if (exp.X_op == O_big)
3170     {
3171       if (exp.X_add_number > 0)
3172         as_bad (_("bignum invalid; zero assumed"));
3173       else
3174         as_bad (_("floating point number invalid; zero assumed"));
3175     }
3176   else if (exp.X_op == O_subtract
3177            && (S_GET_SEGMENT (exp.X_add_symbol)
3178                == S_GET_SEGMENT (exp.X_op_symbol))
3179            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3180            && (symbol_get_frag (exp.X_add_symbol)
3181                == symbol_get_frag (exp.X_op_symbol)))
3182     {
3183       exp.X_op = O_constant;
3184       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3185                           - S_GET_VALUE (exp.X_op_symbol));
3186     }
3187
3188   switch (exp.X_op)
3189     {
3190     case O_illegal:
3191     case O_absent:
3192     case O_big:
3193       exp.X_add_number = 0;
3194       /* Fall through.  */
3195     case O_constant:
3196       S_SET_SEGMENT (symbolP, absolute_section);
3197 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3198       if (ext)
3199         S_SET_EXTERNAL (symbolP);
3200       else
3201         S_CLEAR_EXTERNAL (symbolP);
3202 #endif /* OBJ_AOUT or OBJ_BOUT */
3203       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3204       if (exp.X_op != O_constant)
3205         symbol_set_frag (symbolP, &zero_address_frag);
3206       break;
3207
3208     case O_register:
3209       S_SET_SEGMENT (symbolP, reg_section);
3210       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3211       symbol_set_frag (symbolP, &zero_address_frag);
3212       break;
3213
3214     case O_symbol:
3215       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3216           || exp.X_add_number != 0)
3217         symbol_set_value_expression (symbolP, &exp);
3218       else if (symbol_section_p (symbolP))
3219         as_bad ("invalid attempt to set value of section symbol");
3220       else
3221         {
3222           symbolS *s = exp.X_add_symbol;
3223
3224           S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3225 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3226           if (ext)
3227             S_SET_EXTERNAL (symbolP);
3228           else
3229             S_CLEAR_EXTERNAL (symbolP);
3230 #endif /* OBJ_AOUT or OBJ_BOUT */
3231           S_SET_VALUE (symbolP,
3232                        exp.X_add_number + S_GET_VALUE (s));
3233           symbol_set_frag (symbolP, symbol_get_frag (s));
3234           copy_symbol_attributes (symbolP, s);
3235         }
3236       break;
3237
3238     default:
3239       /* The value is some complex expression.
3240          FIXME: Should we set the segment to anything?  */
3241       symbol_set_value_expression (symbolP, &exp);
3242       break;
3243     }
3244 }
3245 \f
3246 /*                      cons()
3247
3248    CONStruct more frag of .bytes, or .words etc.
3249    Should need_pass_2 be 1 then emit no frag(s).
3250    This understands EXPRESSIONS.
3251
3252    Bug (?)
3253
3254    This has a split personality. We use expression() to read the
3255    value. We can detect if the value won't fit in a byte or word.
3256    But we can't detect if expression() discarded significant digits
3257    in the case of a long. Not worth the crocks required to fix it.  */
3258
3259 /* Select a parser for cons expressions.  */
3260
3261 /* Some targets need to parse the expression in various fancy ways.
3262    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3263    (for example, the HPPA does this).  Otherwise, you can define
3264    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3265    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3266    are defined, which is the normal case, then only simple expressions
3267    are permitted.  */
3268
3269 #ifdef TC_M68K
3270 static void
3271 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3272 #endif
3273
3274 #ifndef TC_PARSE_CONS_EXPRESSION
3275 #ifdef BITFIELD_CONS_EXPRESSIONS
3276 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3277 static void
3278 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3279 #endif
3280 #ifdef REPEAT_CONS_EXPRESSIONS
3281 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3282 static void
3283 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3284 #endif
3285
3286 /* If we haven't gotten one yet, just call expression.  */
3287 #ifndef TC_PARSE_CONS_EXPRESSION
3288 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3289 #endif
3290 #endif
3291
3292 /* Worker to do .byte etc statements.
3293    Clobbers input_line_pointer and checks end-of-line.  */
3294
3295 static void
3296 cons_worker (nbytes, rva)
3297      register int nbytes;       /* 1=.byte, 2=.word, 4=.long.  */
3298      int rva;
3299 {
3300   int c;
3301   expressionS exp;
3302   char *stop = NULL;
3303   char stopc;
3304
3305 #ifdef md_flush_pending_output
3306   md_flush_pending_output ();
3307 #endif
3308
3309   if (flag_mri)
3310     stop = mri_comment_field (&stopc);
3311
3312   if (is_it_end_of_statement ())
3313     {
3314       demand_empty_rest_of_line ();
3315       if (flag_mri)
3316         mri_comment_end (stop, stopc);
3317       return;
3318     }
3319
3320 #ifdef md_cons_align
3321   md_cons_align (nbytes);
3322 #endif
3323
3324   c = 0;
3325   do
3326     {
3327 #ifdef TC_M68K
3328       if (flag_m68k_mri)
3329         parse_mri_cons (&exp, (unsigned int) nbytes);
3330       else
3331 #endif
3332         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3333
3334       if (rva)
3335         {
3336           if (exp.X_op == O_symbol)
3337             exp.X_op = O_symbol_rva;
3338           else
3339             as_fatal (_("rva without symbol"));
3340         }
3341       emit_expr (&exp, (unsigned int) nbytes);
3342       ++c;
3343     }
3344   while (*input_line_pointer++ == ',');
3345
3346   /* In MRI mode, after an odd number of bytes, we must align to an
3347      even word boundary, unless the next instruction is a dc.b, ds.b
3348      or dcb.b.  */
3349   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3350     mri_pending_align = 1;
3351
3352   input_line_pointer--;         /* Put terminator back into stream.  */
3353
3354   demand_empty_rest_of_line ();
3355
3356   if (flag_mri)
3357     mri_comment_end (stop, stopc);
3358 }
3359
3360 void
3361 cons (size)
3362      int size;
3363 {
3364   cons_worker (size, 0);
3365 }
3366
3367 void
3368 s_rva (size)
3369      int size;
3370 {
3371   cons_worker (size, 1);
3372 }
3373
3374 /* Put the contents of expression EXP into the object file using
3375    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
3376
3377 void
3378 emit_expr (exp, nbytes)
3379      expressionS *exp;
3380      unsigned int nbytes;
3381 {
3382   operatorT op;
3383   register char *p;
3384   valueT extra_digit = 0;
3385
3386   /* Don't do anything if we are going to make another pass.  */
3387   if (need_pass_2)
3388     return;
3389
3390 #ifndef NO_LISTING
3391 #ifdef OBJ_ELF
3392   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3393      appear as a four byte positive constant in the .line section,
3394      followed by a 2 byte 0xffff.  Look for that case here.  */
3395   {
3396     static int dwarf_line = -1;
3397
3398     if (strcmp (segment_name (now_seg), ".line") != 0)
3399       dwarf_line = -1;
3400     else if (dwarf_line >= 0
3401              && nbytes == 2
3402              && exp->X_op == O_constant
3403              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3404       listing_source_line ((unsigned int) dwarf_line);
3405     else if (nbytes == 4
3406              && exp->X_op == O_constant
3407              && exp->X_add_number >= 0)
3408       dwarf_line = exp->X_add_number;
3409     else
3410       dwarf_line = -1;
3411   }
3412
3413   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3414      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3415      AT_sibling (0x12) followed by a four byte address of the sibling
3416      followed by a 2 byte AT_name (0x38) followed by the name of the
3417      file.  We look for that case here.  */
3418   {
3419     static int dwarf_file = 0;
3420
3421     if (strcmp (segment_name (now_seg), ".debug") != 0)
3422       dwarf_file = 0;
3423     else if (dwarf_file == 0
3424              && nbytes == 2
3425              && exp->X_op == O_constant
3426              && exp->X_add_number == 0x11)
3427       dwarf_file = 1;
3428     else if (dwarf_file == 1
3429              && nbytes == 2
3430              && exp->X_op == O_constant
3431              && exp->X_add_number == 0x12)
3432       dwarf_file = 2;
3433     else if (dwarf_file == 2
3434              && nbytes == 4)
3435       dwarf_file = 3;
3436     else if (dwarf_file == 3
3437              && nbytes == 2
3438              && exp->X_op == O_constant
3439              && exp->X_add_number == 0x38)
3440       dwarf_file = 4;
3441     else
3442       dwarf_file = 0;
3443
3444     /* The variable dwarf_file_string tells stringer that the string
3445        may be the name of the source file.  */
3446     if (dwarf_file == 4)
3447       dwarf_file_string = 1;
3448     else
3449       dwarf_file_string = 0;
3450   }
3451 #endif
3452 #endif
3453
3454   if (check_eh_frame (exp, &nbytes))
3455     return;
3456
3457   op = exp->X_op;
3458
3459   /* Allow `.word 0' in the absolute section.  */
3460   if (now_seg == absolute_section)
3461     {
3462       if (op != O_constant || exp->X_add_number != 0)
3463         as_bad (_("attempt to store value in absolute section"));
3464       abs_section_offset += nbytes;
3465       return;
3466     }
3467
3468   /* Handle a negative bignum.  */
3469   if (op == O_uminus
3470       && exp->X_add_number == 0
3471       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3472       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3473     {
3474       int i;
3475       unsigned long carry;
3476
3477       exp = symbol_get_value_expression (exp->X_add_symbol);
3478
3479       /* Negate the bignum: one's complement each digit and add 1.  */
3480       carry = 1;
3481       for (i = 0; i < exp->X_add_number; i++)
3482         {
3483           unsigned long next;
3484
3485           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3486                    & LITTLENUM_MASK)
3487                   + carry);
3488           generic_bignum[i] = next & LITTLENUM_MASK;
3489           carry = next >> LITTLENUM_NUMBER_OF_BITS;
3490         }
3491
3492       /* We can ignore any carry out, because it will be handled by
3493          extra_digit if it is needed.  */
3494
3495       extra_digit = (valueT) -1;
3496       op = O_big;
3497     }
3498
3499   if (op == O_absent || op == O_illegal)
3500     {
3501       as_warn (_("zero assumed for missing expression"));
3502       exp->X_add_number = 0;
3503       op = O_constant;
3504     }
3505   else if (op == O_big && exp->X_add_number <= 0)
3506     {
3507       as_bad (_("floating point number invalid; zero assumed"));
3508       exp->X_add_number = 0;
3509       op = O_constant;
3510     }
3511   else if (op == O_register)
3512     {
3513       as_warn (_("register value used as expression"));
3514       op = O_constant;
3515     }
3516
3517   p = frag_more ((int) nbytes);
3518
3519 #ifndef WORKING_DOT_WORD
3520   /* If we have the difference of two symbols in a word, save it on
3521      the broken_words list.  See the code in write.c.  */
3522   if (op == O_subtract && nbytes == 2)
3523     {
3524       struct broken_word *x;
3525
3526       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3527       x->next_broken_word = broken_words;
3528       broken_words = x;
3529       x->seg = now_seg;
3530       x->subseg = now_subseg;
3531       x->frag = frag_now;
3532       x->word_goes_here = p;
3533       x->dispfrag = 0;
3534       x->add = exp->X_add_symbol;
3535       x->sub = exp->X_op_symbol;
3536       x->addnum = exp->X_add_number;
3537       x->added = 0;
3538       new_broken_words++;
3539       return;
3540     }
3541 #endif
3542
3543   /* If we have an integer, but the number of bytes is too large to
3544      pass to md_number_to_chars, handle it as a bignum.  */
3545   if (op == O_constant && nbytes > sizeof (valueT))
3546     {
3547       valueT val;
3548       int gencnt;
3549
3550       if (!exp->X_unsigned && exp->X_add_number < 0)
3551         extra_digit = (valueT) -1;
3552       val = (valueT) exp->X_add_number;
3553       gencnt = 0;
3554       do
3555         {
3556           generic_bignum[gencnt] = val & LITTLENUM_MASK;
3557           val >>= LITTLENUM_NUMBER_OF_BITS;
3558           ++gencnt;
3559         }
3560       while (val != 0);
3561       op = exp->X_op = O_big;
3562       exp->X_add_number = gencnt;
3563     }
3564
3565   if (op == O_constant)
3566     {
3567       register valueT get;
3568       register valueT use;
3569       register valueT mask;
3570       valueT hibit;
3571       register valueT unmask;
3572
3573       /* JF << of >= number of bits in the object is undefined.  In
3574          particular SPARC (Sun 4) has problems.  */
3575       if (nbytes >= sizeof (valueT))
3576         {
3577           mask = 0;
3578           if (nbytes > sizeof (valueT))
3579             hibit = 0;
3580           else
3581             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3582         }
3583       else
3584         {
3585           /* Don't store these bits.  */
3586           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3587           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3588         }
3589
3590       unmask = ~mask;           /* Do store these bits.  */
3591
3592 #ifdef NEVER
3593       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3594       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
3595 #endif
3596
3597       get = exp->X_add_number;
3598       use = get & unmask;
3599       if ((get & mask) != 0
3600           && ((get & mask) != mask
3601               || (get & hibit) == 0))
3602         {               /* Leading bits contain both 0s & 1s.  */
3603           as_warn (_("Value 0x%lx truncated to 0x%lx."),
3604                    (unsigned long) get, (unsigned long) use);
3605         }
3606       /* Put bytes in right order.  */
3607       md_number_to_chars (p, use, (int) nbytes);
3608     }
3609   else if (op == O_big)
3610     {
3611       unsigned int size;
3612       LITTLENUM_TYPE *nums;
3613
3614       know (nbytes % CHARS_PER_LITTLENUM == 0);
3615
3616       size = exp->X_add_number * CHARS_PER_LITTLENUM;
3617       if (nbytes < size)
3618         {
3619           as_warn (_("Bignum truncated to %d bytes"), nbytes);
3620           size = nbytes;
3621         }
3622
3623       if (target_big_endian)
3624         {
3625           while (nbytes > size)
3626             {
3627               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3628               nbytes -= CHARS_PER_LITTLENUM;
3629               p += CHARS_PER_LITTLENUM;
3630             }
3631
3632           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3633           while (size > 0)
3634             {
3635               --nums;
3636               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3637               size -= CHARS_PER_LITTLENUM;
3638               p += CHARS_PER_LITTLENUM;
3639             }
3640         }
3641       else
3642         {
3643           nums = generic_bignum;
3644           while (size > 0)
3645             {
3646               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3647               ++nums;
3648               size -= CHARS_PER_LITTLENUM;
3649               p += CHARS_PER_LITTLENUM;
3650               nbytes -= CHARS_PER_LITTLENUM;
3651             }
3652
3653           while (nbytes > 0)
3654             {
3655               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3656               nbytes -= CHARS_PER_LITTLENUM;
3657               p += CHARS_PER_LITTLENUM;
3658             }
3659         }
3660     }
3661   else
3662     {
3663       memset (p, 0, nbytes);
3664
3665       /* Now we need to generate a fixS to record the symbol value.
3666          This is easy for BFD.  For other targets it can be more
3667          complex.  For very complex cases (currently, the HPPA and
3668          NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3669          want.  For simpler cases, you can define TC_CONS_RELOC to be
3670          the name of the reloc code that should be stored in the fixS.
3671          If neither is defined, the code uses NO_RELOC if it is
3672          defined, and otherwise uses 0.  */
3673
3674 #ifdef BFD_ASSEMBLER
3675 #ifdef TC_CONS_FIX_NEW
3676       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3677 #else
3678       {
3679         bfd_reloc_code_real_type r;
3680
3681         switch (nbytes)
3682           {
3683           case 1:
3684             r = BFD_RELOC_8;
3685             break;
3686           case 2:
3687             r = BFD_RELOC_16;
3688             break;
3689           case 4:
3690             r = BFD_RELOC_32;
3691             break;
3692           case 8:
3693             r = BFD_RELOC_64;
3694             break;
3695           default:
3696             as_bad (_("unsupported BFD relocation size %u"), nbytes);
3697             r = BFD_RELOC_32;
3698             break;
3699           }
3700         fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3701                      0, r);
3702       }
3703 #endif
3704 #else
3705 #ifdef TC_CONS_FIX_NEW
3706       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3707 #else
3708       /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
3709          it is defined, otherwise use NO_RELOC if it is defined,
3710          otherwise use 0.  */
3711 #ifndef TC_CONS_RELOC
3712 #ifdef NO_RELOC
3713 #define TC_CONS_RELOC NO_RELOC
3714 #else
3715 #define TC_CONS_RELOC 0
3716 #endif
3717 #endif
3718       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3719                    TC_CONS_RELOC);
3720 #endif /* TC_CONS_FIX_NEW */
3721 #endif /* BFD_ASSEMBLER */
3722     }
3723 }
3724 \f
3725 #ifdef BITFIELD_CONS_EXPRESSIONS
3726
3727 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3728    w:x,y:z, where w and y are bitwidths and x and y are values.  They
3729    then pack them all together. We do a little better in that we allow
3730    them in words, longs, etc. and we'll pack them in target byte order
3731    for you.
3732
3733    The rules are: pack least significat bit first, if a field doesn't
3734    entirely fit, put it in the next unit.  Overflowing the bitfield is
3735    explicitly *not* even a warning.  The bitwidth should be considered
3736    a "mask".
3737
3738    To use this function the tc-XXX.h file should define
3739    BITFIELD_CONS_EXPRESSIONS.  */
3740
3741 static void
3742 parse_bitfield_cons (exp, nbytes)
3743      expressionS *exp;
3744      unsigned int nbytes;
3745 {
3746   unsigned int bits_available = BITS_PER_CHAR * nbytes;
3747   char *hold = input_line_pointer;
3748
3749   (void) expression (exp);
3750
3751   if (*input_line_pointer == ':')
3752     {
3753       /* Bitfields.  */
3754       long value = 0;
3755
3756       for (;;)
3757         {
3758           unsigned long width;
3759
3760           if (*input_line_pointer != ':')
3761             {
3762               input_line_pointer = hold;
3763               break;
3764             }                   /* Next piece is not a bitfield.  */
3765
3766           /* In the general case, we can't allow
3767              full expressions with symbol
3768              differences and such.  The relocation
3769              entries for symbols not defined in this
3770              assembly would require arbitrary field
3771              widths, positions, and masks which most
3772              of our current object formats don't
3773              support.
3774
3775              In the specific case where a symbol
3776              *is* defined in this assembly, we
3777              *could* build fixups and track it, but
3778              this could lead to confusion for the
3779              backends.  I'm lazy. I'll take any
3780              SEG_ABSOLUTE. I think that means that
3781              you can use a previous .set or
3782              .equ type symbol.  xoxorich.  */
3783
3784           if (exp->X_op == O_absent)
3785             {
3786               as_warn (_("using a bit field width of zero"));
3787               exp->X_add_number = 0;
3788               exp->X_op = O_constant;
3789             }                   /* Implied zero width bitfield.  */
3790
3791           if (exp->X_op != O_constant)
3792             {
3793               *input_line_pointer = '\0';
3794               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3795               *input_line_pointer = ':';
3796               demand_empty_rest_of_line ();
3797               return;
3798             }                   /* Too complex.  */
3799
3800           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3801             {
3802               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3803                        width, nbytes, (BITS_PER_CHAR * nbytes));
3804               width = BITS_PER_CHAR * nbytes;
3805             }                   /* Too big.  */
3806
3807           if (width > bits_available)
3808             {
3809               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
3810               input_line_pointer = hold;
3811               exp->X_add_number = value;
3812               break;
3813             }                   /* Won't fit.  */
3814
3815           /* Skip ':'.  */
3816           hold = ++input_line_pointer;
3817
3818           (void) expression (exp);
3819           if (exp->X_op != O_constant)
3820             {
3821               char cache = *input_line_pointer;
3822
3823               *input_line_pointer = '\0';
3824               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3825               *input_line_pointer = cache;
3826               demand_empty_rest_of_line ();
3827               return;
3828             }                   /* Too complex.  */
3829
3830           value |= ((~(-1 << width) & exp->X_add_number)
3831                     << ((BITS_PER_CHAR * nbytes) - bits_available));
3832
3833           if ((bits_available -= width) == 0
3834               || is_it_end_of_statement ()
3835               || *input_line_pointer != ',')
3836             {
3837               break;
3838             }                   /* All the bitfields we're gonna get.  */
3839
3840           hold = ++input_line_pointer;
3841           (void) expression (exp);
3842         }
3843
3844       exp->X_add_number = value;
3845       exp->X_op = O_constant;
3846       exp->X_unsigned = 1;
3847     }
3848 }
3849
3850 #endif /* BITFIELD_CONS_EXPRESSIONS */
3851 \f
3852 /* Handle an MRI style string expression.  */
3853
3854 #ifdef TC_M68K
3855 static void
3856 parse_mri_cons (exp, nbytes)
3857      expressionS *exp;
3858      unsigned int nbytes;
3859 {
3860   if (*input_line_pointer != '\''
3861       && (input_line_pointer[1] != '\''
3862           || (*input_line_pointer != 'A'
3863               && *input_line_pointer != 'E')))
3864     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3865   else
3866     {
3867       unsigned int scan;
3868       unsigned int result = 0;
3869
3870       /* An MRI style string.  Cut into as many bytes as will fit into
3871          a nbyte chunk, left justify if necessary, and separate with
3872          commas so we can try again later.  */
3873       if (*input_line_pointer == 'A')
3874         ++input_line_pointer;
3875       else if (*input_line_pointer == 'E')
3876         {
3877           as_bad (_("EBCDIC constants are not supported"));
3878           ++input_line_pointer;
3879         }
3880
3881       input_line_pointer++;
3882       for (scan = 0; scan < nbytes; scan++)
3883         {
3884           if (*input_line_pointer == '\'')
3885             {
3886               if (input_line_pointer[1] == '\'')
3887                 {
3888                   input_line_pointer++;
3889                 }
3890               else
3891                 break;
3892             }
3893           result = (result << 8) | (*input_line_pointer++);
3894         }
3895
3896       /* Left justify.  */
3897       while (scan < nbytes)
3898         {
3899           result <<= 8;
3900           scan++;
3901         }
3902
3903       /* Create correct expression.  */
3904       exp->X_op = O_constant;
3905       exp->X_add_number = result;
3906
3907       /* Fake it so that we can read the next char too.  */
3908       if (input_line_pointer[0] != '\'' ||
3909           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3910         {
3911           input_line_pointer -= 2;
3912           input_line_pointer[0] = ',';
3913           input_line_pointer[1] = '\'';
3914         }
3915       else
3916         input_line_pointer++;
3917     }
3918 }
3919 #endif /* TC_M68K */
3920 \f
3921 #ifdef REPEAT_CONS_EXPRESSIONS
3922
3923 /* Parse a repeat expression for cons.  This is used by the MIPS
3924    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
3925    object file COUNT times.
3926
3927    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
3928
3929 static void
3930 parse_repeat_cons (exp, nbytes)
3931      expressionS *exp;
3932      unsigned int nbytes;
3933 {
3934   expressionS count;
3935   register int i;
3936
3937   expression (exp);
3938
3939   if (*input_line_pointer != ':')
3940     {
3941       /* No repeat count.  */
3942       return;
3943     }
3944
3945   ++input_line_pointer;
3946   expression (&count);
3947   if (count.X_op != O_constant
3948       || count.X_add_number <= 0)
3949     {
3950       as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
3951       return;
3952     }
3953
3954   /* The cons function is going to output this expression once.  So we
3955      output it count - 1 times.  */
3956   for (i = count.X_add_number - 1; i > 0; i--)
3957     emit_expr (exp, nbytes);
3958 }
3959
3960 #endif /* REPEAT_CONS_EXPRESSIONS */
3961 \f
3962 /* Parse a floating point number represented as a hex constant.  This
3963    permits users to specify the exact bits they want in the floating
3964    point number.  */
3965
3966 static int
3967 hex_float (float_type, bytes)
3968      int float_type;
3969      char *bytes;
3970 {
3971   int length;
3972   int i;
3973
3974   switch (float_type)
3975     {
3976     case 'f':
3977     case 'F':
3978     case 's':
3979     case 'S':
3980       length = 4;
3981       break;
3982
3983     case 'd':
3984     case 'D':
3985     case 'r':
3986     case 'R':
3987       length = 8;
3988       break;
3989
3990     case 'x':
3991     case 'X':
3992       length = 12;
3993       break;
3994
3995     case 'p':
3996     case 'P':
3997       length = 12;
3998       break;
3999
4000     default:
4001       as_bad (_("Unknown floating type type '%c'"), float_type);
4002       return -1;
4003     }
4004
4005   /* It would be nice if we could go through expression to parse the
4006      hex constant, but if we get a bignum it's a pain to sort it into
4007      the buffer correctly.  */
4008   i = 0;
4009   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4010     {
4011       int d;
4012
4013       /* The MRI assembler accepts arbitrary underscores strewn about
4014          through the hex constant, so we ignore them as well.  */
4015       if (*input_line_pointer == '_')
4016         {
4017           ++input_line_pointer;
4018           continue;
4019         }
4020
4021       if (i >= length)
4022         {
4023           as_warn (_("Floating point constant too large"));
4024           return -1;
4025         }
4026       d = hex_value (*input_line_pointer) << 4;
4027       ++input_line_pointer;
4028       while (*input_line_pointer == '_')
4029         ++input_line_pointer;
4030       if (hex_p (*input_line_pointer))
4031         {
4032           d += hex_value (*input_line_pointer);
4033           ++input_line_pointer;
4034         }
4035       if (target_big_endian)
4036         bytes[i] = d;
4037       else
4038         bytes[length - i - 1] = d;
4039       ++i;
4040     }
4041
4042   if (i < length)
4043     {
4044       if (target_big_endian)
4045         memset (bytes + i, 0, length - i);
4046       else
4047         memset (bytes, 0, length - i);
4048     }
4049
4050   return length;
4051 }
4052
4053 /*                      float_cons()
4054
4055    CONStruct some more frag chars of .floats .ffloats etc.
4056    Makes 0 or more new frags.
4057    If need_pass_2 == 1, no frags are emitted.
4058    This understands only floating literals, not expressions. Sorry.
4059
4060    A floating constant is defined by atof_generic(), except it is preceded
4061    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4062    reading, I decided to be incompatible. This always tries to give you
4063    rounded bits to the precision of the pseudo-op. Former AS did premature
4064    truncatation, restored noisy bits instead of trailing 0s AND gave you
4065    a choice of 2 flavours of noise according to which of 2 floating-point
4066    scanners you directed AS to use.
4067
4068    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
4069
4070 void
4071 float_cons (float_type)
4072      /* Clobbers input_line-pointer, checks end-of-line.  */
4073      register int float_type;   /* 'f':.ffloat ... 'F':.float ...  */
4074 {
4075   register char *p;
4076   int length;                   /* Number of chars in an object.  */
4077   register char *err;           /* Error from scanning floating literal.  */
4078   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4079
4080   if (is_it_end_of_statement ())
4081     {
4082       demand_empty_rest_of_line ();
4083       return;
4084     }
4085
4086 #ifdef md_flush_pending_output
4087   md_flush_pending_output ();
4088 #endif
4089
4090   do
4091     {
4092       /* input_line_pointer->1st char of a flonum (we hope!).  */
4093       SKIP_WHITESPACE ();
4094
4095       /* Skip any 0{letter} that may be present. Don't even check if the
4096          letter is legal. Someone may invent a "z" format and this routine
4097          has no use for such information. Lusers beware: you get
4098          diagnostics if your input is ill-conditioned.  */
4099       if (input_line_pointer[0] == '0'
4100           && isalpha ((unsigned char) input_line_pointer[1]))
4101         input_line_pointer += 2;
4102
4103       /* Accept :xxxx, where the x's are hex digits, for a floating
4104          point with the exact digits specified.  */
4105       if (input_line_pointer[0] == ':')
4106         {
4107           ++input_line_pointer;
4108           length = hex_float (float_type, temp);
4109           if (length < 0)
4110             {
4111               ignore_rest_of_line ();
4112               return;
4113             }
4114         }
4115       else
4116         {
4117           err = md_atof (float_type, temp, &length);
4118           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4119           know (length > 0);
4120           if (err)
4121             {
4122               as_bad (_("Bad floating literal: %s"), err);
4123               ignore_rest_of_line ();
4124               return;
4125             }
4126         }
4127
4128       if (!need_pass_2)
4129         {
4130           int count;
4131
4132           count = 1;
4133
4134 #ifdef REPEAT_CONS_EXPRESSIONS
4135           if (*input_line_pointer == ':')
4136             {
4137               expressionS count_exp;
4138
4139               ++input_line_pointer;
4140               expression (&count_exp);
4141
4142               if (count_exp.X_op != O_constant
4143                   || count_exp.X_add_number <= 0)
4144                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4145               else
4146                 count = count_exp.X_add_number;
4147             }
4148 #endif
4149
4150           while (--count >= 0)
4151             {
4152               p = frag_more (length);
4153               memcpy (p, temp, (unsigned int) length);
4154             }
4155         }
4156       SKIP_WHITESPACE ();
4157     }
4158   while (*input_line_pointer++ == ',');
4159
4160   /* Put terminator back into stream.  */
4161   --input_line_pointer;
4162   demand_empty_rest_of_line ();
4163 }
4164 \f
4165 /* Return the size of a LEB128 value.  */
4166
4167 static inline int
4168 sizeof_sleb128 (value)
4169      offsetT value;
4170 {
4171   register int size = 0;
4172   register unsigned byte;
4173
4174   do
4175     {
4176       byte = (value & 0x7f);
4177       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4178          Fortunately, we can structure things so that the extra work reduces
4179          to a noop on systems that do things "properly".  */
4180       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4181       size += 1;
4182     }
4183   while (!(((value == 0) && ((byte & 0x40) == 0))
4184            || ((value == -1) && ((byte & 0x40) != 0))));
4185
4186   return size;
4187 }
4188
4189 static inline int
4190 sizeof_uleb128 (value)
4191      valueT value;
4192 {
4193   register int size = 0;
4194   register unsigned byte;
4195
4196   do
4197     {
4198       byte = (value & 0x7f);
4199       value >>= 7;
4200       size += 1;
4201     }
4202   while (value != 0);
4203
4204   return size;
4205 }
4206
4207 int
4208 sizeof_leb128 (value, sign)
4209      valueT value;
4210      int sign;
4211 {
4212   if (sign)
4213     return sizeof_sleb128 ((offsetT) value);
4214   else
4215     return sizeof_uleb128 (value);
4216 }
4217
4218 /* Output a LEB128 value.  */
4219
4220 static inline int
4221 output_sleb128 (p, value)
4222      char *p;
4223      offsetT value;
4224 {
4225   register char *orig = p;
4226   register int more;
4227
4228   do
4229     {
4230       unsigned byte = (value & 0x7f);
4231
4232       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4233          Fortunately, we can structure things so that the extra work reduces
4234          to a noop on systems that do things "properly".  */
4235       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4236
4237       more = !((((value == 0) && ((byte & 0x40) == 0))
4238                 || ((value == -1) && ((byte & 0x40) != 0))));
4239       if (more)
4240         byte |= 0x80;
4241
4242       *p++ = byte;
4243     }
4244   while (more);
4245
4246   return p - orig;
4247 }
4248
4249 static inline int
4250 output_uleb128 (p, value)
4251      char *p;
4252      valueT value;
4253 {
4254   char *orig = p;
4255
4256   do
4257     {
4258       unsigned byte = (value & 0x7f);
4259       value >>= 7;
4260       if (value != 0)
4261         /* More bytes to follow.  */
4262         byte |= 0x80;
4263
4264       *p++ = byte;
4265     }
4266   while (value != 0);
4267
4268   return p - orig;
4269 }
4270
4271 int
4272 output_leb128 (p, value, sign)
4273      char *p;
4274      valueT value;
4275      int sign;
4276 {
4277   if (sign)
4278     return output_sleb128 (p, (offsetT) value);
4279   else
4280     return output_uleb128 (p, value);
4281 }
4282
4283 /* Do the same for bignums.  We combine sizeof with output here in that
4284    we don't output for NULL values of P.  It isn't really as critical as
4285    for "normal" values that this be streamlined.  */
4286
4287 static inline int
4288 output_big_sleb128 (p, bignum, size)
4289      char *p;
4290      LITTLENUM_TYPE *bignum;
4291      int size;
4292 {
4293   char *orig = p;
4294   valueT val = 0;
4295   int loaded = 0;
4296   unsigned byte;
4297
4298   /* Strip leading sign extensions off the bignum.  */
4299   while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
4300     size--;
4301
4302   do
4303     {
4304       if (loaded < 7 && size > 0)
4305         {
4306           val |= (*bignum << loaded);
4307           loaded += 8 * CHARS_PER_LITTLENUM;
4308           size--;
4309           bignum++;
4310         }
4311
4312       byte = val & 0x7f;
4313       loaded -= 7;
4314       val >>= 7;
4315
4316       if (size == 0)
4317         {
4318           if ((val == 0 && (byte & 0x40) == 0)
4319               || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
4320                   && (byte & 0x40) != 0))
4321             byte |= 0x80;
4322         }
4323
4324       if (orig)
4325         *p = byte;
4326       p++;
4327     }
4328   while (byte & 0x80);
4329
4330   return p - orig;
4331 }
4332
4333 static inline int
4334 output_big_uleb128 (p, bignum, size)
4335      char *p;
4336      LITTLENUM_TYPE *bignum;
4337      int size;
4338 {
4339   char *orig = p;
4340   valueT val = 0;
4341   int loaded = 0;
4342   unsigned byte;
4343
4344   /* Strip leading zeros off the bignum.  */
4345   /* XXX: Is this needed?  */
4346   while (size > 0 && bignum[size - 1] == 0)
4347     size--;
4348
4349   do
4350     {
4351       if (loaded < 7 && size > 0)
4352         {
4353           val |= (*bignum << loaded);
4354           loaded += 8 * CHARS_PER_LITTLENUM;
4355           size--;
4356           bignum++;
4357         }
4358
4359       byte = val & 0x7f;
4360       loaded -= 7;
4361       val >>= 7;
4362
4363       if (size > 0 || val)
4364         byte |= 0x80;
4365
4366       if (orig)
4367         *p = byte;
4368       p++;
4369     }
4370   while (byte & 0x80);
4371
4372   return p - orig;
4373 }
4374
4375 static int
4376 output_big_leb128 (p, bignum, size, sign)
4377      char *p;
4378      LITTLENUM_TYPE *bignum;
4379      int size, sign;
4380 {
4381   if (sign)
4382     return output_big_sleb128 (p, bignum, size);
4383   else
4384     return output_big_uleb128 (p, bignum, size);
4385 }
4386
4387 /* Generate the appropriate fragments for a given expression to emit a
4388    leb128 value.  */
4389
4390 void
4391 emit_leb128_expr (exp, sign)
4392      expressionS *exp;
4393      int sign;
4394 {
4395   operatorT op = exp->X_op;
4396
4397   if (op == O_absent || op == O_illegal)
4398     {
4399       as_warn (_("zero assumed for missing expression"));
4400       exp->X_add_number = 0;
4401       op = O_constant;
4402     }
4403   else if (op == O_big && exp->X_add_number <= 0)
4404     {
4405       as_bad (_("floating point number invalid; zero assumed"));
4406       exp->X_add_number = 0;
4407       op = O_constant;
4408     }
4409   else if (op == O_register)
4410     {
4411       as_warn (_("register value used as expression"));
4412       op = O_constant;
4413     }
4414
4415   if (op == O_constant)
4416     {
4417       /* If we've got a constant, emit the thing directly right now.  */
4418
4419       valueT value = exp->X_add_number;
4420       int size;
4421       char *p;
4422
4423       size = sizeof_leb128 (value, sign);
4424       p = frag_more (size);
4425       output_leb128 (p, value, sign);
4426     }
4427   else if (op == O_big)
4428     {
4429       /* O_big is a different sort of constant.  */
4430
4431       int size;
4432       char *p;
4433
4434       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4435       p = frag_more (size);
4436       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4437     }
4438   else
4439     {
4440       /* Otherwise, we have to create a variable sized fragment and
4441          resolve things later.  */
4442
4443       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4444                 make_expr_symbol (exp), 0, (char *) NULL);
4445     }
4446 }
4447
4448 /* Parse the .sleb128 and .uleb128 pseudos.  */
4449
4450 void
4451 s_leb128 (sign)
4452      int sign;
4453 {
4454   expressionS exp;
4455
4456   do
4457     {
4458       expression (&exp);
4459       emit_leb128_expr (&exp, sign);
4460     }
4461   while (*input_line_pointer++ == ',');
4462
4463   input_line_pointer--;
4464   demand_empty_rest_of_line ();
4465 }
4466 \f
4467 /* We read 0 or more ',' separated, double-quoted strings.
4468    Caller should have checked need_pass_2 is FALSE because we don't
4469    check it.  */
4470
4471 void
4472 stringer (append_zero)          /* Worker to do .ascii etc statements.  */
4473      /* Checks end-of-line.  */
4474      register int append_zero;  /* 0: don't append '\0', else 1.  */
4475 {
4476   register unsigned int c;
4477   char *start;
4478
4479 #ifdef md_flush_pending_output
4480   md_flush_pending_output ();
4481 #endif
4482
4483   /* The following awkward logic is to parse ZERO or more strings,
4484      comma separated. Recall a string expression includes spaces
4485      before the opening '\"' and spaces after the closing '\"'.
4486      We fake a leading ',' if there is (supposed to be)
4487      a 1st, expression. We keep demanding expressions for each ','.  */
4488   if (is_it_end_of_statement ())
4489     {
4490       c = 0;                    /* Skip loop.  */
4491       ++input_line_pointer;     /* Compensate for end of loop.  */
4492     }
4493   else
4494     {
4495       c = ',';                  /* Do loop.  */
4496     }
4497   while (c == ',' || c == '<' || c == '"')
4498     {
4499       SKIP_WHITESPACE ();
4500       switch (*input_line_pointer)
4501         {
4502         case '\"':
4503           ++input_line_pointer; /*->1st char of string.  */
4504           start = input_line_pointer;
4505           while (is_a_char (c = next_char_of_string ()))
4506             {
4507               FRAG_APPEND_1_CHAR (c);
4508             }
4509           if (append_zero)
4510             {
4511               FRAG_APPEND_1_CHAR (0);
4512             }
4513           know (input_line_pointer[-1] == '\"');
4514
4515 #ifndef NO_LISTING
4516 #ifdef OBJ_ELF
4517           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4518              will emit .string with a filename in the .debug section
4519              after a sequence of constants.  See the comment in
4520              emit_expr for the sequence.  emit_expr will set
4521              dwarf_file_string to non-zero if this string might be a
4522              source file name.  */
4523           if (strcmp (segment_name (now_seg), ".debug") != 0)
4524             dwarf_file_string = 0;
4525           else if (dwarf_file_string)
4526             {
4527               c = input_line_pointer[-1];
4528               input_line_pointer[-1] = '\0';
4529               listing_source_file (start);
4530               input_line_pointer[-1] = c;
4531             }
4532 #endif
4533 #endif
4534
4535           break;
4536         case '<':
4537           input_line_pointer++;
4538           c = get_single_number ();
4539           FRAG_APPEND_1_CHAR (c);
4540           if (*input_line_pointer != '>')
4541             {
4542               as_bad (_("Expected <nn>"));
4543             }
4544           input_line_pointer++;
4545           break;
4546         case ',':
4547           input_line_pointer++;
4548           break;
4549         }
4550       SKIP_WHITESPACE ();
4551       c = *input_line_pointer;
4552     }
4553
4554   demand_empty_rest_of_line ();
4555 }                               /* stringer() */
4556 \f
4557 /* FIXME-SOMEDAY: I had trouble here on characters with the
4558     high bits set.  We'll probably also have trouble with
4559     multibyte chars, wide chars, etc.  Also be careful about
4560     returning values bigger than 1 byte.  xoxorich.  */
4561
4562 unsigned int
4563 next_char_of_string ()
4564 {
4565   register unsigned int c;
4566
4567   c = *input_line_pointer++ & CHAR_MASK;
4568   switch (c)
4569     {
4570     case '\"':
4571       c = NOT_A_CHAR;
4572       break;
4573
4574     case '\n':
4575       as_warn (_("Unterminated string: Newline inserted."));
4576       bump_line_counters ();
4577       break;
4578
4579 #ifndef NO_STRING_ESCAPES
4580     case '\\':
4581       switch (c = *input_line_pointer++)
4582         {
4583         case 'b':
4584           c = '\b';
4585           break;
4586
4587         case 'f':
4588           c = '\f';
4589           break;
4590
4591         case 'n':
4592           c = '\n';
4593           break;
4594
4595         case 'r':
4596           c = '\r';
4597           break;
4598
4599         case 't':
4600           c = '\t';
4601           break;
4602
4603         case 'v':
4604           c = '\013';
4605           break;
4606
4607         case '\\':
4608         case '"':
4609           break;                /* As itself.  */
4610
4611         case '0':
4612         case '1':
4613         case '2':
4614         case '3':
4615         case '4':
4616         case '5':
4617         case '6':
4618         case '7':
4619         case '8':
4620         case '9':
4621           {
4622             long number;
4623             int i;
4624
4625             for (i = 0, number = 0;
4626                  isdigit (c) && i < 3;
4627                  c = *input_line_pointer++, i++)
4628               {
4629                 number = number * 8 + c - '0';
4630               }
4631
4632             c = number & 0xff;
4633           }
4634           --input_line_pointer;
4635           break;
4636
4637         case 'x':
4638         case 'X':
4639           {
4640             long number;
4641
4642             number = 0;
4643             c = *input_line_pointer++;
4644             while (isxdigit (c))
4645               {
4646                 if (isdigit (c))
4647                   number = number * 16 + c - '0';
4648                 else if (isupper (c))
4649                   number = number * 16 + c - 'A' + 10;
4650                 else
4651                   number = number * 16 + c - 'a' + 10;
4652                 c = *input_line_pointer++;
4653               }
4654             c = number & 0xff;
4655             --input_line_pointer;
4656           }
4657           break;
4658
4659         case '\n':
4660           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
4661           as_warn (_("Unterminated string: Newline inserted."));
4662           c = '\n';
4663           bump_line_counters ();
4664           break;
4665
4666         default:
4667
4668 #ifdef ONLY_STANDARD_ESCAPES
4669           as_bad (_("Bad escaped character in string, '?' assumed"));
4670           c = '?';
4671 #endif /* ONLY_STANDARD_ESCAPES */
4672
4673           break;
4674         }
4675       break;
4676 #endif /* ! defined (NO_STRING_ESCAPES) */
4677
4678     default:
4679       break;
4680     }
4681   return (c);
4682 }
4683 \f
4684 static segT
4685 get_segmented_expression (expP)
4686      register expressionS *expP;
4687 {
4688   register segT retval;
4689
4690   retval = expression (expP);
4691   if (expP->X_op == O_illegal
4692       || expP->X_op == O_absent
4693       || expP->X_op == O_big)
4694     {
4695       as_bad (_("expected address expression; zero assumed"));
4696       expP->X_op = O_constant;
4697       expP->X_add_number = 0;
4698       retval = absolute_section;
4699     }
4700   return retval;
4701 }
4702
4703 static segT
4704 get_known_segmented_expression (expP)
4705      register expressionS *expP;
4706 {
4707   register segT retval;
4708
4709   if ((retval = get_segmented_expression (expP)) == undefined_section)
4710     {
4711       /* There is no easy way to extract the undefined symbol from the
4712          expression.  */
4713       if (expP->X_add_symbol != NULL
4714           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4715         as_warn (_("symbol \"%s\" undefined; zero assumed"),
4716                  S_GET_NAME (expP->X_add_symbol));
4717       else
4718         as_warn (_("some symbol undefined; zero assumed"));
4719       retval = absolute_section;
4720       expP->X_op = O_constant;
4721       expP->X_add_number = 0;
4722     }
4723   know (retval == absolute_section || SEG_NORMAL (retval));
4724   return (retval);
4725 }
4726
4727 offsetT
4728 get_absolute_expression ()
4729 {
4730   expressionS exp;
4731
4732   expression (&exp);
4733   if (exp.X_op != O_constant)
4734     {
4735       if (exp.X_op != O_absent)
4736         as_bad (_("bad or irreducible absolute expression; zero assumed"));
4737       exp.X_add_number = 0;
4738     }
4739   return exp.X_add_number;
4740 }
4741
4742 char                            /* Return terminator.  */
4743 get_absolute_expression_and_terminator (val_pointer)
4744      long *val_pointer;         /* Return value of expression.  */
4745 {
4746   /* FIXME: val_pointer should probably be offsetT *.  */
4747   *val_pointer = (long) get_absolute_expression ();
4748   return (*input_line_pointer++);
4749 }
4750 \f
4751 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4752    Give a warning if that happens.  */
4753
4754 char *
4755 demand_copy_C_string (len_pointer)
4756      int *len_pointer;
4757 {
4758   register char *s;
4759
4760   if ((s = demand_copy_string (len_pointer)) != 0)
4761     {
4762       register int len;
4763
4764       for (len = *len_pointer; len > 0; len--)
4765         {
4766           if (*s == 0)
4767             {
4768               s = 0;
4769               len = 1;
4770               *len_pointer = 0;
4771               as_bad (_("This string may not contain \'\\0\'"));
4772             }
4773         }
4774     }
4775
4776   return s;
4777 }
4778 \f
4779 /* Demand string, but return a safe (=private) copy of the string.
4780    Return NULL if we can't read a string here.  */
4781
4782 char *
4783 demand_copy_string (lenP)
4784      int *lenP;
4785 {
4786   register unsigned int c;
4787   register int len;
4788   char *retval;
4789
4790   len = 0;
4791   SKIP_WHITESPACE ();
4792   if (*input_line_pointer == '\"')
4793     {
4794       input_line_pointer++;     /* Skip opening quote.  */
4795
4796       while (is_a_char (c = next_char_of_string ()))
4797         {
4798           obstack_1grow (&notes, c);
4799           len++;
4800         }
4801       /* JF this next line is so demand_copy_C_string will return a
4802          null terminated string.  */
4803       obstack_1grow (&notes, '\0');
4804       retval = obstack_finish (&notes);
4805     }
4806   else
4807     {
4808       as_warn (_("Missing string"));
4809       retval = NULL;
4810       ignore_rest_of_line ();
4811     }
4812   *lenP = len;
4813   return (retval);
4814 }
4815 \f
4816 /* In:  Input_line_pointer->next character.
4817
4818    Do:  Skip input_line_pointer over all whitespace.
4819
4820    Out: 1 if input_line_pointer->end-of-line.  */
4821
4822 int
4823 is_it_end_of_statement ()
4824 {
4825   SKIP_WHITESPACE ();
4826   return (is_end_of_line[(unsigned char) *input_line_pointer]);
4827 }
4828
4829 void
4830 equals (sym_name, reassign)
4831      char *sym_name;
4832      int reassign;
4833 {
4834   register symbolS *symbolP;    /* Symbol we are working with.  */
4835   char *stop = NULL;
4836   char stopc;
4837
4838   input_line_pointer++;
4839   if (*input_line_pointer == '=')
4840     input_line_pointer++;
4841
4842   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4843     input_line_pointer++;
4844
4845   if (flag_mri)
4846     stop = mri_comment_field (&stopc);
4847
4848   if (sym_name[0] == '.' && sym_name[1] == '\0')
4849     {
4850       /* Turn '. = mumble' into a .org mumble.  */
4851       register segT segment;
4852       expressionS exp;
4853
4854       segment = get_known_segmented_expression (&exp);
4855       if (!need_pass_2)
4856         do_org (segment, &exp, 0);
4857     }
4858   else
4859     {
4860       symbolP = symbol_find_or_make (sym_name);
4861       /* Permit register names to be redefined.  */
4862       if (!reassign
4863           && S_IS_DEFINED (symbolP)
4864           && S_GET_SEGMENT (symbolP) != reg_section)
4865         as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
4866
4867 #ifdef OBJ_COFF
4868       /* "set" symbols are local unless otherwise specified.  */
4869       SF_SET_LOCAL (symbolP);
4870 #endif /* OBJ_COFF */
4871
4872       pseudo_set (symbolP);
4873     }
4874
4875   if (flag_mri)
4876     {
4877       /* Check garbage after the expression.  */
4878       ignore_rest_of_line ();
4879       mri_comment_end (stop, stopc);
4880     }
4881 }
4882
4883 /* .include -- include a file at this point.  */
4884
4885 void
4886 s_include (arg)
4887      int arg ATTRIBUTE_UNUSED;
4888 {
4889   char *filename;
4890   int i;
4891   FILE *try;
4892   char *path;
4893
4894   if (!flag_m68k_mri)
4895     {
4896       filename = demand_copy_string (&i);
4897       if (filename == NULL)
4898         {
4899           /* demand_copy_string has already printed an error and
4900              called ignore_rest_of_line.  */
4901           return;
4902         }
4903     }
4904   else
4905     {
4906       SKIP_WHITESPACE ();
4907       i = 0;
4908       while (!is_end_of_line[(unsigned char) *input_line_pointer]
4909              && *input_line_pointer != ' '
4910              && *input_line_pointer != '\t')
4911         {
4912           obstack_1grow (&notes, *input_line_pointer);
4913           ++input_line_pointer;
4914           ++i;
4915         }
4916
4917       obstack_1grow (&notes, '\0');
4918       filename = obstack_finish (&notes);
4919       while (!is_end_of_line[(unsigned char) *input_line_pointer])
4920         ++input_line_pointer;
4921     }
4922
4923   demand_empty_rest_of_line ();
4924   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4925
4926   for (i = 0; i < include_dir_count; i++)
4927     {
4928       strcpy (path, include_dirs[i]);
4929       strcat (path, "/");
4930       strcat (path, filename);
4931       if (0 != (try = fopen (path, "r")))
4932         {
4933           fclose (try);
4934           goto gotit;
4935         }
4936     }
4937
4938   free (path);
4939   path = filename;
4940 gotit:
4941   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
4942   register_dependency (path);
4943   input_scrub_insert_file (path);
4944 }
4945
4946 void
4947 add_include_dir (path)
4948      char *path;
4949 {
4950   int i;
4951
4952   if (include_dir_count == 0)
4953     {
4954       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4955       include_dirs[0] = ".";    /* Current dir.  */
4956       include_dir_count = 2;
4957     }
4958   else
4959     {
4960       include_dir_count++;
4961       include_dirs =
4962         (char **) realloc (include_dirs,
4963                            include_dir_count * sizeof (*include_dirs));
4964     }
4965
4966   include_dirs[include_dir_count - 1] = path;   /* New one.  */
4967
4968   i = strlen (path);
4969   if (i > include_dir_maxlen)
4970     include_dir_maxlen = i;
4971 }
4972 \f
4973 /* Output debugging information to denote the source file.  */
4974
4975 static void
4976 generate_file_debug ()
4977 {
4978   if (debug_type == DEBUG_STABS)
4979     stabs_generate_asm_file ();
4980 }
4981
4982 /* Output line number debugging information for the current source line.  */
4983
4984 void
4985 generate_lineno_debug ()
4986 {
4987   switch (debug_type)
4988     {
4989     case DEBUG_UNSPECIFIED:
4990     case DEBUG_NONE:
4991     case DEBUG_DWARF:
4992       break;
4993     case DEBUG_STABS:
4994       stabs_generate_asm_lineno ();
4995       break;
4996     case DEBUG_ECOFF:
4997       ecoff_generate_asm_lineno ();
4998       break;
4999     case DEBUG_DWARF2:
5000       /* ??? We could here indicate to dwarf2dbg.c that something
5001          has changed.  However, since there is additional backend
5002          support that is required (calling dwarf2_emit_insn), we
5003          let dwarf2dbg.c call as_where on its own.  */
5004       break;
5005     }
5006 }
5007
5008 /* Output debugging information to mark a function entry point or end point.
5009    END_P is zero for .func, and non-zero for .endfunc.  */
5010
5011 void
5012 s_func (end_p)
5013      int end_p;
5014 {
5015   do_s_func (end_p, NULL);
5016 }
5017
5018 /* Subroutine of s_func so targets can choose a different default prefix.
5019    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
5020
5021 void
5022 do_s_func (end_p, default_prefix)
5023      int end_p;
5024      const char *default_prefix;
5025 {
5026   /* Record the current function so that we can issue an error message for
5027      misplaced .func,.endfunc, and also so that .endfunc needs no
5028      arguments.  */
5029   static char *current_name;
5030   static char *current_label;
5031
5032   if (end_p)
5033     {
5034       if (current_name == NULL)
5035         {
5036           as_bad (_("missing .func"));
5037           ignore_rest_of_line ();
5038           return;
5039         }
5040
5041       if (debug_type == DEBUG_STABS)
5042         stabs_generate_asm_endfunc (current_name, current_label);
5043
5044       current_name = current_label = NULL;
5045     }
5046   else /* ! end_p */
5047     {
5048       char *name, *label;
5049       char delim1, delim2;
5050
5051       if (current_name != NULL)
5052         {
5053           as_bad (_(".endfunc missing for previous .func"));
5054           ignore_rest_of_line ();
5055           return;
5056         }
5057
5058       name = input_line_pointer;
5059       delim1 = get_symbol_end ();
5060       name = xstrdup (name);
5061       *input_line_pointer = delim1;
5062       SKIP_WHITESPACE ();
5063       if (*input_line_pointer != ',')
5064         {
5065           if (default_prefix)
5066             asprintf (&label, "%s%s", default_prefix, name);
5067           else
5068             {
5069               char leading_char = 0;
5070 #ifdef BFD_ASSEMBLER
5071               leading_char = bfd_get_symbol_leading_char (stdoutput);
5072 #endif
5073               /* Missing entry point, use function's name with the leading
5074                  char prepended.  */
5075               if (leading_char)
5076                 asprintf (&label, "%c%s", leading_char, name);
5077               else
5078                 label = name;
5079             }
5080         }
5081       else
5082         {
5083           ++input_line_pointer;
5084           SKIP_WHITESPACE ();
5085           label = input_line_pointer;
5086           delim2 = get_symbol_end ();
5087           label = xstrdup (label);
5088           *input_line_pointer = delim2;
5089         }
5090
5091       if (debug_type == DEBUG_STABS)
5092         stabs_generate_asm_func (name, label);
5093
5094       current_name = name;
5095       current_label = label;
5096     }
5097
5098   demand_empty_rest_of_line ();
5099 }
5100 \f
5101 void
5102 s_ignore (arg)
5103      int arg ATTRIBUTE_UNUSED;
5104 {
5105   while (!is_end_of_line[(unsigned char) *input_line_pointer])
5106     {
5107       ++input_line_pointer;
5108     }
5109   ++input_line_pointer;
5110 }
5111
5112 void
5113 read_print_statistics (file)
5114      FILE *file;
5115 {
5116   hash_print_statistics (file, "pseudo-op table", po_hash);
5117 }
5118
5119 /* Inserts the given line into the input stream.
5120
5121    This call avoids macro/conditionals nesting checking, since the contents of
5122    the line are assumed to replace the contents of a line already scanned.
5123
5124    An appropriate use of this function would be substition of input lines when
5125    called by md_start_line_hook().  The given line is assumed to already be
5126    properly scrubbed.  */
5127
5128 void
5129 input_scrub_insert_line (line)
5130      const char *line;
5131 {
5132   sb newline;
5133   sb_new (&newline);
5134   sb_add_string (&newline, line);
5135   input_scrub_include_sb (&newline, input_line_pointer, 0);
5136   sb_kill (&newline);
5137   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5138 }
5139
5140 /* Insert a file into the input stream; the path must resolve to an actual
5141    file; no include path searching or dependency registering is performed.  */
5142
5143 void
5144 input_scrub_insert_file (path)
5145      char *path;
5146 {
5147   input_scrub_include_file (path, input_line_pointer);
5148   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5149 }