gas/read.c

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