gas/read.c

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