gas/read.c

   1 /* read.c - read a source file -
   2    Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
   3    2000 Free Software Foundation, Inc.
   4
   5 This file is part of GAS, the GNU Assembler.
   6
   7 GAS is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GAS is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GAS; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA. */
  21
  22 #if 0
  23 #define MASK_CHAR (0xFF)        /* If your chars aren't 8 bits, you will
  24                                    change this a bit.  But then, GNU isn't
  25                                    spozed to run on your machine anyway.
  26                                    (RMS is so shortsighted sometimes.)
  27                                    */
  28 #else
  29 #define MASK_CHAR ((int)(unsigned char)-1)
  30 #endif
  31
  32
  33 /* This is the largest known floating point format (for now). It will
  34    grow when we do 4361 style flonums. */
  35
  36 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  37
  38 /* Routines that read assembler source text to build spagetti in memory.
  39    Another group of these functions is in the expr.c module.  */
  40
  41 /* for isdigit() */
  42 #include <ctype.h>
  43
  44 #include "as.h"
  45 #include "subsegs.h"
  46 #include "sb.h"
  47 #include "macro.h"
  48 #include "obstack.h"
  49 #include "listing.h"
  50 #include "ecoff.h"
  51
  52 #ifndef TC_START_LABEL
  53 #define TC_START_LABEL(x,y) (x==':')
  54 #endif
  55
  56 /* The NOP_OPCODE is for the alignment fill value.
  57  * fill it a nop instruction so that the disassembler does not choke
  58  * on it
  59  */
  60 #ifndef NOP_OPCODE
  61 #define NOP_OPCODE 0x00
  62 #endif
  63
  64 char *input_line_pointer;       /*->next char of source file to parse. */
  65
  66 #if BITS_PER_CHAR != 8
  67 /*  The following table is indexed by[(char)] and will break if
  68     a char does not have exactly 256 states (hopefully 0:255!)!  */
  69 die horribly;
  70 #endif
  71
  72 #ifndef LEX_AT
  73 /* The m88k unfortunately uses @ as a label beginner.  */
  74 #define LEX_AT 0
  75 #endif
  76
  77 #ifndef LEX_BR
  78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
  79 #define LEX_BR 0
  80 #endif
  81
  82 #ifndef LEX_PCT
  83 /* The Delta 68k assembler permits % inside label names.  */
  84 #define LEX_PCT 0
  85 #endif
  86
  87 #ifndef LEX_QM
  88 /* The PowerPC Windows NT assemblers permits ? inside label names.  */
  89 #define LEX_QM 0
  90 #endif
  91
  92 #ifndef LEX_HASH
  93 #define LEX_HASH 0
  94 #endif
  95
  96 #ifndef LEX_DOLLAR
  97 /* The a29k assembler does not permits labels to start with $.  */
  98 #define LEX_DOLLAR 3
  99 #endif
 100
 101 #ifndef LEX_TILDE
 102 /* The Delta 68k assembler permits ~ at start of label names.  */
 103 #define LEX_TILDE 0
 104 #endif
 105
 106 /* used by is_... macros. our ctype[] */
 107 char lex_type[256] =
 108 {
 109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
 110   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
 111   0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
 112   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  /* 0123456789:;<=>? */
 113   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  /* @ABCDEFGHIJKLMNO */
 114   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
 115   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
 116   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */
 117   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 118   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 119   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 120   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 121   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 122   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 123   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 124   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
 125 };
 126
 127
 128 /*
 129  * In: a character.
 130  * Out: 1 if this character ends a line.
 131  */
 132 #define Z_ (0)
 133 char is_end_of_line[256] =
 134 {
 135 #ifdef CR_EOL
 136   99, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, 99, Z_, Z_, 99, Z_, Z_,       /* @abcdefghijklmno */
 137 #else
 138   99, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, 99, Z_, Z_, Z_, Z_, Z_,       /* @abcdefghijklmno */
 139 #endif
 140   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 141 #ifdef TC_HPPA
 142   Z_,99, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,        /* _!"#$%&'()*+,-./ */
 143   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* 0123456789:;<=>? */
 144 #else
 145   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 146   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, 99, Z_, Z_, Z_, Z_,       /* 0123456789:;<=>? */
 147 #endif
 148   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 149   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 150   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 151   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 152   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 153   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 154   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 155   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 156   Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_, Z_,       /* */
 157 };
 158 #undef Z_
 159
 160 /* Functions private to this file. */
 161
 162 static char *buffer;    /* 1st char of each buffer of lines is here. */
 163 static char *buffer_limit;      /*->1 + last char in buffer. */
 164
 165 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1 in the
 166    tc-<CPU>.h file.  See the "Porting GAS" section of the internals manual. */
 167 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 168
 169 static char *old_buffer;        /* JF a hack */
 170 static char *old_input;
 171 static char *old_limit;
 172
 173 /* Variables for handling include file directory table. */
 174
 175 char **include_dirs;    /* Table of pointers to directories to
 176                            search for .include's */
 177 int include_dir_count;  /* How many are in the table */
 178 int include_dir_maxlen = 1;/* Length of longest in table */
 179
 180 #ifndef WORKING_DOT_WORD
 181 struct broken_word *broken_words;
 182 int new_broken_words;
 183 #endif
 184
 185 /* The current offset into the absolute section.  We don't try to
 186    build frags in the absolute section, since no data can be stored
 187    there.  We just keep track of the current offset.  */
 188 addressT abs_section_offset;
 189
 190 /* If this line had an MRI style label, it is stored in this variable.
 191    This is used by some of the MRI pseudo-ops.  */
 192 symbolS *line_label;
 193
 194 /* This global variable is used to support MRI common sections.  We
 195    translate such sections into a common symbol.  This variable is
 196    non-NULL when we are in an MRI common section.  */
 197 symbolS *mri_common_symbol;
 198
 199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
 200    need to align to an even byte boundary unless the next pseudo-op is
 201    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
 202    may be needed.  */
 203 static int mri_pending_align;
 204
 205 #ifndef NO_LISTING
 206 #ifdef OBJ_ELF
 207 /* This variable is set to be non-zero if the next string we see might
 208    be the name of the source file in DWARF debugging information.  See
 209    the comment in emit_expr for the format we look for.  */
 210 static int dwarf_file_string;
 211 #endif
 212 #endif
 213
 214 static void cons_worker PARAMS ((int, int));
 215 static int scrub_from_string PARAMS ((char *, int));
 216 static void do_align PARAMS ((int, char *, int, int));
 217 static void s_align PARAMS ((int, int));
 218 static void s_lcomm_internal PARAMS ((int, int));
 219 static int hex_float PARAMS ((int, char *));
 220 static inline int sizeof_sleb128 PARAMS ((offsetT));
 221 static inline int sizeof_uleb128 PARAMS ((valueT));
 222 static inline int output_sleb128 PARAMS ((char *, offsetT));
 223 static inline int output_uleb128 PARAMS ((char *, valueT));
 224 static inline int output_big_sleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
 225 static inline int output_big_uleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
 226 static int output_big_leb128 PARAMS ((char *, LITTLENUM_TYPE *, int, int));
 227 static void do_org PARAMS ((segT, expressionS *, int));
 228 char *demand_copy_string PARAMS ((int *lenP));
 229 static segT get_segmented_expression PARAMS ((expressionS *expP));
 230 static segT get_known_segmented_expression PARAMS ((expressionS * expP));
 231 static void pobegin PARAMS ((void));
 232 static int get_line_sb PARAMS ((sb *));
 233 static void generate_file_debug PARAMS ((void));
 234 \f
 235
 236 void
 237 read_begin ()
 238 {
 239   const char *p;
 240
 241   pobegin ();
 242   obj_read_begin_hook ();
 243
 244   /* Something close -- but not too close -- to a multiple of 1024.
 245      The debugging malloc I'm using has 24 bytes of overhead.  */
 246   obstack_begin (&notes, chunksize);
 247   obstack_begin (&cond_obstack, chunksize);
 248
 249   /* Use machine dependent syntax */
 250   for (p = line_separator_chars; *p; p++)
 251     is_end_of_line[(unsigned char) *p] = 1;
 252   /* Use more.  FIXME-SOMEDAY. */
 253
 254   if (flag_mri)
 255     lex_type['?'] = 3;
 256 }
 257 \f
 258 /* set up pseudo-op tables */
 259
 260 static struct hash_control *po_hash;
 261
 262 static const pseudo_typeS potable[] =
 263 {
 264   {"abort", s_abort, 0},
 265   {"align", s_align_ptwo, 0},
 266   {"ascii", stringer, 0},
 267   {"asciz", stringer, 1},
 268   {"balign", s_align_bytes, 0},
 269   {"balignw", s_align_bytes, -2},
 270   {"balignl", s_align_bytes, -4},
 271 /* block */
 272   {"byte", cons, 1},
 273   {"comm", s_comm, 0},
 274   {"common", s_mri_common, 0},
 275   {"common.s", s_mri_common, 1},
 276   {"data", s_data, 0},
 277   {"dc", cons, 2},
 278   {"dc.b", cons, 1},
 279   {"dc.d", float_cons, 'd'},
 280   {"dc.l", cons, 4},
 281   {"dc.s", float_cons, 'f'},
 282   {"dc.w", cons, 2},
 283   {"dc.x", float_cons, 'x'},
 284   {"dcb", s_space, 2},
 285   {"dcb.b", s_space, 1},
 286   {"dcb.d", s_float_space, 'd'},
 287   {"dcb.l", s_space, 4},
 288   {"dcb.s", s_float_space, 'f'},
 289   {"dcb.w", s_space, 2},
 290   {"dcb.x", s_float_space, 'x'},
 291   {"ds", s_space, 2},
 292   {"ds.b", s_space, 1},
 293   {"ds.d", s_space, 8},
 294   {"ds.l", s_space, 4},
 295   {"ds.p", s_space, 12},
 296   {"ds.s", s_space, 4},
 297   {"ds.w", s_space, 2},
 298   {"ds.x", s_space, 12},
 299   {"debug", s_ignore, 0},
 300 #ifdef S_SET_DESC
 301   {"desc", s_desc, 0},
 302 #endif
 303 /* dim */
 304   {"double", float_cons, 'd'},
 305 /* dsect */
 306   {"eject", listing_eject, 0},  /* Formfeed listing */
 307   {"else", s_else, 0},
 308   {"elsec", s_else, 0},
 309   {"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 ("%s", 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 - OCTETS_PER_BYTE_POWER);
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_MAYBE_AOUT) \
2061      || defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))
2062 #ifdef BFD_ASSEMBLER
2063       (OUTPUT_FLAVOR != bfd_target_aout_flavour
2064        || (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&
2065 #else
2066       (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&
2067 #endif
2068 #endif
2069       (S_GET_SEGMENT (symbolP) == bss_seg
2070        || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
2071     {
2072       char *pfrag;
2073
2074       subseg_set (bss_seg, 1);
2075
2076       if (align)
2077         frag_align (align, 0, 0);
2078                                         /* detach from old frag */
2079       if (S_GET_SEGMENT (symbolP) == bss_seg)
2080         symbol_get_frag (symbolP)->fr_symbol = NULL;
2081
2082       symbol_set_frag (symbolP, frag_now);
2083       pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
2084                         (offsetT) temp, (char *) 0);
2085       *pfrag = 0;
2086
2087       S_SET_SEGMENT (symbolP, bss_seg);
2088
2089 #ifdef OBJ_COFF
2090       /* The symbol may already have been created with a preceding
2091          ".globl" directive -- be careful not to step on storage class
2092          in that case.  Otherwise, set it to static. */
2093       if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2094         {
2095           S_SET_STORAGE_CLASS (symbolP, C_STAT);
2096         }
2097 #endif /* OBJ_COFF */
2098
2099 #ifdef S_SET_SIZE
2100       S_SET_SIZE (symbolP, temp);
2101 #endif
2102     }
2103   else
2104     as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2105             S_GET_NAME (symbolP));
2106
2107   subseg_set (current_seg, current_subseg);
2108
2109   demand_empty_rest_of_line ();
2110 }                               /* s_lcomm_internal() */
2111
2112 void
2113 s_lcomm (needs_align)
2114      int needs_align;
2115 {
2116   s_lcomm_internal (needs_align, 0);
2117 }
2118
2119 void s_lcomm_bytes (needs_align)
2120      int needs_align;
2121 {
2122   s_lcomm_internal (needs_align, 1);
2123 }
2124
2125 void
2126 s_lsym (ignore)
2127      int ignore ATTRIBUTE_UNUSED;
2128 {
2129   register char *name;
2130   register char c;
2131   register char *p;
2132   expressionS exp;
2133   register symbolS *symbolP;
2134
2135   /* we permit ANY defined expression: BSD4.2 demands constants */
2136   name = input_line_pointer;
2137   c = get_symbol_end ();
2138   p = input_line_pointer;
2139   *p = c;
2140   SKIP_WHITESPACE ();
2141   if (*input_line_pointer != ',')
2142     {
2143       *p = 0;
2144       as_bad (_("Expected comma after name \"%s\""), name);
2145       *p = c;
2146       ignore_rest_of_line ();
2147       return;
2148     }
2149   input_line_pointer++;
2150   expression (&exp);
2151   if (exp.X_op != O_constant
2152       && exp.X_op != O_register)
2153     {
2154       as_bad (_("bad expression"));
2155       ignore_rest_of_line ();
2156       return;
2157     }
2158   *p = 0;
2159   symbolP = symbol_find_or_make (name);
2160
2161   /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2162      symbolP->sy_desc == 0) out of this test because coff doesn't have
2163      those fields, and I can't see when they'd ever be tripped.  I
2164      don't think I understand why they were here so I may have
2165      introduced a bug. As recently as 1.37 didn't have this test
2166      anyway.  xoxorich. */
2167
2168   if (S_GET_SEGMENT (symbolP) == undefined_section
2169       && S_GET_VALUE (symbolP) == 0)
2170     {
2171       /* The name might be an undefined .global symbol; be sure to
2172          keep the "external" bit. */
2173       S_SET_SEGMENT (symbolP,
2174                      (exp.X_op == O_constant
2175                       ? absolute_section
2176                       : reg_section));
2177       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2178     }
2179   else
2180     {
2181       as_bad (_("Symbol %s already defined"), name);
2182     }
2183   *p = c;
2184   demand_empty_rest_of_line ();
2185 }                               /* s_lsym() */
2186
2187 /* Read a line into an sb.  */
2188
2189 static int
2190 get_line_sb (line)
2191      sb *line;
2192 {
2193   char quote1, quote2, inquote;
2194
2195   if (input_line_pointer[-1] == '\n')
2196     bump_line_counters ();
2197
2198   if (input_line_pointer >= buffer_limit)
2199     {
2200       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2201       if (buffer_limit == 0)
2202         return 0;
2203     }
2204
2205   /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2206      code needs to be changed.  */
2207   if (! flag_m68k_mri)
2208     quote1 = '"';
2209   else
2210     quote1 = '\0';
2211
2212   quote2 = '\0';
2213   if (flag_m68k_mri)
2214     quote2 = '\'';
2215 #ifdef LEX_IS_STRINGQUOTE
2216   quote2 = '\'';
2217 #endif
2218
2219   inquote = '\0';
2220   while (! is_end_of_line[(unsigned char) *input_line_pointer]
2221          || (inquote != '\0' && *input_line_pointer != '\n'))
2222     {
2223       if (inquote == *input_line_pointer)
2224         inquote = '\0';
2225       else if (inquote == '\0')
2226         {
2227           if (*input_line_pointer == quote1)
2228             inquote = quote1;
2229           else if (*input_line_pointer == quote2)
2230             inquote = quote2;
2231         }
2232       sb_add_char (line, *input_line_pointer++);
2233     }
2234   while (input_line_pointer < buffer_limit
2235          && is_end_of_line[(unsigned char) *input_line_pointer])
2236     {
2237       if (input_line_pointer[-1] == '\n')
2238         bump_line_counters ();
2239       ++input_line_pointer;
2240     }
2241   return 1;
2242 }
2243
2244 /* Define a macro.  This is an interface to macro.c, which is shared
2245    between gas and gasp.  */
2246
2247 void
2248 s_macro (ignore)
2249      int ignore ATTRIBUTE_UNUSED;
2250 {
2251   char *file;
2252   unsigned int line;
2253   sb s;
2254   sb label;
2255   const char *err;
2256   const char *name;
2257
2258   as_where (&file, &line);
2259
2260   sb_new (&s);
2261   while (! is_end_of_line[(unsigned char) *input_line_pointer])
2262     sb_add_char (&s, *input_line_pointer++);
2263
2264   sb_new (&label);
2265   if (line_label != NULL)
2266     sb_add_string (&label, S_GET_NAME (line_label));
2267
2268   err = define_macro (0, &s, &label, get_line_sb, &name);
2269   if (err != NULL)
2270     as_bad_where (file, line, "%s", err);
2271   else
2272     {
2273       if (line_label != NULL)
2274         {
2275           S_SET_SEGMENT (line_label, undefined_section);
2276           S_SET_VALUE (line_label, 0);
2277           symbol_set_frag (line_label, &zero_address_frag);
2278         }
2279
2280       if (((flag_m68k_mri
2281 #ifdef NO_PSEUDO_DOT
2282             || 1
2283 #endif
2284             )
2285            && hash_find (po_hash, name) != NULL)
2286           || (! flag_m68k_mri
2287               && *name == '.'
2288               && hash_find (po_hash, name + 1) != NULL))
2289         as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2290                  name);
2291     }
2292
2293   sb_kill (&s);
2294 }
2295
2296 /* Handle the .mexit pseudo-op, which immediately exits a macro
2297    expansion.  */
2298
2299 void
2300 s_mexit (ignore)
2301      int ignore ATTRIBUTE_UNUSED;
2302 {
2303   cond_exit_macro (macro_nest);
2304   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2305 }
2306
2307 /* Switch in and out of MRI mode.  */
2308
2309 void
2310 s_mri (ignore)
2311      int ignore ATTRIBUTE_UNUSED;
2312 {
2313   int on, old_flag;
2314
2315   on = get_absolute_expression ();
2316   old_flag = flag_mri;
2317   if (on != 0)
2318     {
2319       flag_mri = 1;
2320 #ifdef TC_M68K
2321       flag_m68k_mri = 1;
2322 #endif
2323       macro_mri_mode (1);
2324     }
2325   else
2326     {
2327       flag_mri = 0;
2328       flag_m68k_mri = 0;
2329       macro_mri_mode (0);
2330     }
2331
2332   /* Operator precedence changes in m68k MRI mode, so we need to
2333      update the operator rankings.  */
2334   expr_set_precedence ();
2335
2336 #ifdef MRI_MODE_CHANGE
2337   if (on != old_flag)
2338     MRI_MODE_CHANGE (on);
2339 #endif
2340
2341   demand_empty_rest_of_line ();
2342 }
2343
2344 /* Handle changing the location counter.  */
2345
2346 static void
2347 do_org (segment, exp, fill)
2348      segT segment;
2349      expressionS *exp;
2350      int fill;
2351 {
2352   if (segment != now_seg && segment != absolute_section)
2353     as_bad (_("invalid segment \"%s\"; segment \"%s\" assumed"),
2354             segment_name (segment), segment_name (now_seg));
2355
2356   if (now_seg == absolute_section)
2357     {
2358       if (fill != 0)
2359         as_warn (_("ignoring fill value in absolute section"));
2360       if (exp->X_op != O_constant)
2361         {
2362           as_bad (_("only constant offsets supported in absolute section"));
2363           exp->X_add_number = 0;
2364         }
2365       abs_section_offset = exp->X_add_number;
2366     }
2367   else
2368     {
2369       char *p;
2370
2371       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, exp->X_add_symbol,
2372                     exp->X_add_number * OCTETS_PER_BYTE, (char *) NULL);
2373       *p = fill;
2374     }
2375 }
2376
2377 void
2378 s_org (ignore)
2379      int ignore ATTRIBUTE_UNUSED;
2380 {
2381   register segT segment;
2382   expressionS exp;
2383   register long temp_fill;
2384
2385 #ifdef md_flush_pending_output
2386   md_flush_pending_output ();
2387 #endif
2388
2389   /* The m68k MRI assembler has a different meaning for .org.  It
2390      means to create an absolute section at a given address.  We can't
2391      support that--use a linker script instead.  */
2392   if (flag_m68k_mri)
2393     {
2394       as_bad (_("MRI style ORG pseudo-op not supported"));
2395       ignore_rest_of_line ();
2396       return;
2397     }
2398
2399   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2400      thing as a sub-segment-relative origin.  Any absolute origin is
2401      given a warning, then assumed to be segment-relative.  Any
2402      segmented origin expression ("foo+42") had better be in the right
2403      segment or the .org is ignored.
2404
2405      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2406      we never know sub-segment sizes when we are reading code.  BSD
2407      will crash trying to emit negative numbers of filler bytes in
2408      certain .orgs. We don't crash, but see as-write for that code.
2409
2410      Don't make frag if need_pass_2==1.  */
2411   segment = get_known_segmented_expression (&exp);
2412   if (*input_line_pointer == ',')
2413     {
2414       input_line_pointer++;
2415       temp_fill = get_absolute_expression ();
2416     }
2417   else
2418     temp_fill = 0;
2419
2420   if (!need_pass_2)
2421     do_org (segment, &exp, temp_fill);
2422
2423   demand_empty_rest_of_line ();
2424 }                               /* s_org() */
2425
2426 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2427    called by the obj-format routine which handles section changing
2428    when in MRI mode.  It will create a new section, and return it.  It
2429    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2430    'M' (mixed), or 'R' (romable).  If BFD_ASSEMBLER is defined, the
2431    flags will be set in the section.  */
2432
2433 void
2434 s_mri_sect (type)
2435      char *type ATTRIBUTE_UNUSED;
2436 {
2437 #ifdef TC_M68K
2438
2439   char *name;
2440   char c;
2441   segT seg;
2442
2443   SKIP_WHITESPACE ();
2444
2445   name = input_line_pointer;
2446   if (! isdigit ((unsigned char) *name))
2447     c = get_symbol_end ();
2448   else
2449     {
2450       do
2451         {
2452           ++input_line_pointer;
2453         }
2454       while (isdigit ((unsigned char) *input_line_pointer));
2455       c = *input_line_pointer;
2456       *input_line_pointer = '\0';
2457     }
2458
2459   name = xstrdup (name);
2460
2461   *input_line_pointer = c;
2462
2463   seg = subseg_new (name, 0);
2464
2465   if (*input_line_pointer == ',')
2466     {
2467       int align;
2468
2469       ++input_line_pointer;
2470       align = get_absolute_expression ();
2471       record_alignment (seg, align);
2472     }
2473
2474   *type = 'C';
2475   if (*input_line_pointer == ',')
2476     {
2477       c = *++input_line_pointer;
2478       c = toupper ((unsigned char) c);
2479       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2480         *type = c;
2481       else
2482         as_bad (_("unrecognized section type"));
2483       ++input_line_pointer;
2484
2485 #ifdef BFD_ASSEMBLER
2486       {
2487         flagword flags;
2488
2489         flags = SEC_NO_FLAGS;
2490         if (*type == 'C')
2491           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2492         else if (*type == 'D' || *type == 'M')
2493           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2494         else if (*type == 'R')
2495           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2496         if (flags != SEC_NO_FLAGS)
2497           {
2498             if (! bfd_set_section_flags (stdoutput, seg, flags))
2499               as_warn (_("error setting flags for \"%s\": %s"),
2500                        bfd_section_name (stdoutput, seg),
2501                        bfd_errmsg (bfd_get_error ()));
2502           }
2503       }
2504 #endif
2505     }
2506
2507   /* Ignore the HP type.  */
2508   if (*input_line_pointer == ',')
2509     input_line_pointer += 2;
2510
2511   demand_empty_rest_of_line ();
2512
2513 #else /* ! TC_M68K */
2514 #ifdef TC_I960
2515
2516   char *name;
2517   char c;
2518   segT seg;
2519
2520   SKIP_WHITESPACE ();
2521
2522   name = input_line_pointer;
2523   c = get_symbol_end ();
2524
2525   name = xstrdup (name);
2526
2527   *input_line_pointer = c;
2528
2529   seg = subseg_new (name, 0);
2530
2531   if (*input_line_pointer != ',')
2532     *type = 'C';
2533   else
2534     {
2535       char *sectype;
2536
2537       ++input_line_pointer;
2538       SKIP_WHITESPACE ();
2539       sectype = input_line_pointer;
2540       c = get_symbol_end ();
2541       if (*sectype == '\0')
2542         *type = 'C';
2543       else if (strcasecmp (sectype, "text") == 0)
2544         *type = 'C';
2545       else if (strcasecmp (sectype, "data") == 0)
2546         *type = 'D';
2547       else if (strcasecmp (sectype, "romdata") == 0)
2548         *type = 'R';
2549       else
2550         as_warn (_("unrecognized section type `%s'"), sectype);
2551       *input_line_pointer = c;
2552     }
2553
2554   if (*input_line_pointer == ',')
2555     {
2556       char *seccmd;
2557
2558       ++input_line_pointer;
2559       SKIP_WHITESPACE ();
2560       seccmd = input_line_pointer;
2561       c = get_symbol_end ();
2562       if (strcasecmp (seccmd, "absolute") == 0)
2563         {
2564           as_bad (_("absolute sections are not supported"));
2565           *input_line_pointer = c;
2566           ignore_rest_of_line ();
2567           return;
2568         }
2569       else if (strcasecmp (seccmd, "align") == 0)
2570         {
2571           int align;
2572
2573           *input_line_pointer = c;
2574           align = get_absolute_expression ();
2575           record_alignment (seg, align);
2576         }
2577       else
2578         {
2579           as_warn (_("unrecognized section command `%s'"), seccmd);
2580           *input_line_pointer = c;
2581         }
2582     }
2583
2584   demand_empty_rest_of_line ();
2585
2586 #else /* ! TC_I960 */
2587   /* The MRI assembler seems to use different forms of .sect for
2588      different targets.  */
2589   as_bad ("MRI mode not supported for this target");
2590   ignore_rest_of_line ();
2591 #endif /* ! TC_I960 */
2592 #endif /* ! TC_M68K */
2593 }
2594
2595 /* Handle the .print pseudo-op.  */
2596
2597 void
2598 s_print (ignore)
2599      int ignore ATTRIBUTE_UNUSED;
2600 {
2601   char *s;
2602   int len;
2603
2604   s = demand_copy_C_string (&len);
2605   printf ("%s\n", s);
2606   demand_empty_rest_of_line ();
2607 }
2608
2609 /* Handle the .purgem pseudo-op.  */
2610
2611 void
2612 s_purgem (ignore)
2613      int ignore ATTRIBUTE_UNUSED;
2614 {
2615   if (is_it_end_of_statement ())
2616     {
2617       demand_empty_rest_of_line ();
2618       return;
2619     }
2620
2621   do
2622     {
2623       char *name;
2624       char c;
2625
2626       SKIP_WHITESPACE ();
2627       name = input_line_pointer;
2628       c = get_symbol_end ();
2629       delete_macro (name);
2630       *input_line_pointer = c;
2631       SKIP_WHITESPACE ();
2632     }
2633   while (*input_line_pointer++ == ',');
2634
2635   --input_line_pointer;
2636   demand_empty_rest_of_line ();
2637 }
2638
2639 /* Handle the .rept pseudo-op.  */
2640
2641 void
2642 s_rept (ignore)
2643      int ignore ATTRIBUTE_UNUSED;
2644 {
2645   int count;
2646   sb one;
2647   sb many;
2648
2649   count = get_absolute_expression ();
2650
2651   sb_new (&one);
2652   if (! buffer_and_nest ("REPT", "ENDR", &one, get_line_sb))
2653     {
2654       as_bad (_("rept without endr"));
2655       return;
2656     }
2657
2658   sb_new (&many);
2659   while (count-- > 0)
2660     sb_add_sb (&many, &one);
2661
2662   sb_kill (&one);
2663
2664   input_scrub_include_sb (&many, input_line_pointer);
2665   sb_kill (&many);
2666   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2667 }
2668
2669 /* Handle the .equ, .equiv and .set directives.  If EQUIV is 1, then
2670    this is .equiv, and it is an error if the symbol is already
2671    defined.  */
2672
2673 void
2674 s_set (equiv)
2675      int equiv;
2676 {
2677   register char *name;
2678   register char delim;
2679   register char *end_name;
2680   register symbolS *symbolP;
2681
2682   /*
2683    * Especial apologies for the random logic:
2684    * this just grew, and could be parsed much more simply!
2685    * Dean in haste.
2686    */
2687   name = input_line_pointer;
2688   delim = get_symbol_end ();
2689   end_name = input_line_pointer;
2690   *end_name = delim;
2691   SKIP_WHITESPACE ();
2692
2693   if (*input_line_pointer != ',')
2694     {
2695       *end_name = 0;
2696       as_bad (_("Expected comma after name \"%s\""), name);
2697       *end_name = delim;
2698       ignore_rest_of_line ();
2699       return;
2700     }
2701
2702   input_line_pointer++;
2703   *end_name = 0;
2704
2705   if (name[0] == '.' && name[1] == '\0')
2706     {
2707       /* Turn '. = mumble' into a .org mumble */
2708       register segT segment;
2709       expressionS exp;
2710
2711       segment = get_known_segmented_expression (&exp);
2712
2713       if (!need_pass_2)
2714         do_org (segment, &exp, 0);
2715
2716       *end_name = delim;
2717       return;
2718     }
2719
2720   if ((symbolP = symbol_find (name)) == NULL
2721       && (symbolP = md_undefined_symbol (name)) == NULL)
2722     {
2723 #ifndef NO_LISTING
2724       /* When doing symbol listings, play games with dummy fragments living
2725          outside the normal fragment chain to record the file and line info
2726          for this symbol.  */
2727       if (listing & LISTING_SYMBOLS)
2728         {
2729           extern struct list_info_struct *listing_tail;
2730           fragS *dummy_frag = (fragS *) xmalloc (sizeof(fragS));
2731           memset (dummy_frag, 0, sizeof(fragS));
2732           dummy_frag->fr_type = rs_fill;
2733           dummy_frag->line = listing_tail;
2734           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2735           dummy_frag->fr_symbol = symbolP;
2736         }
2737       else
2738 #endif
2739         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2740
2741 #ifdef OBJ_COFF
2742       /* "set" symbols are local unless otherwise specified. */
2743       SF_SET_LOCAL (symbolP);
2744 #endif /* OBJ_COFF */
2745
2746     }                           /* make a new symbol */
2747
2748   symbol_table_insert (symbolP);
2749
2750   *end_name = delim;
2751
2752   if (equiv
2753       && S_IS_DEFINED (symbolP)
2754       && S_GET_SEGMENT (symbolP) != reg_section)
2755     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2756
2757   pseudo_set (symbolP);
2758   demand_empty_rest_of_line ();
2759 }                               /* s_set() */
2760
2761 void
2762 s_space (mult)
2763      int mult;
2764 {
2765   expressionS exp;
2766   expressionS val;
2767   char *p = 0;
2768   char *stop = NULL;
2769   char stopc;
2770   int bytes;
2771
2772 #ifdef md_flush_pending_output
2773   md_flush_pending_output ();
2774 #endif
2775
2776   if (flag_mri)
2777     stop = mri_comment_field (&stopc);
2778
2779   /* In m68k MRI mode, we need to align to a word boundary, unless
2780      this is ds.b.  */
2781   if (flag_m68k_mri && mult > 1)
2782     {
2783       if (now_seg == absolute_section)
2784         {
2785           abs_section_offset += abs_section_offset & 1;
2786           if (line_label != NULL)
2787             S_SET_VALUE (line_label, abs_section_offset);
2788         }
2789       else if (mri_common_symbol != NULL)
2790         {
2791           valueT val;
2792
2793           val = S_GET_VALUE (mri_common_symbol);
2794           if ((val & 1) != 0)
2795             {
2796               S_SET_VALUE (mri_common_symbol, val + 1);
2797               if (line_label != NULL)
2798                 {
2799                   expressionS *symexp;
2800
2801                   symexp = symbol_get_value_expression (line_label);
2802                   know (symexp->X_op == O_symbol);
2803                   know (symexp->X_add_symbol == mri_common_symbol);
2804                   symexp->X_add_number += 1;
2805                 }
2806             }
2807         }
2808       else
2809         {
2810           do_align (1, (char *) NULL, 0, 0);
2811           if (line_label != NULL)
2812             {
2813               symbol_set_frag (line_label, frag_now);
2814               S_SET_VALUE (line_label, frag_now_fix ());
2815             }
2816         }
2817     }
2818
2819   bytes = mult;
2820
2821   expression (&exp);
2822
2823   SKIP_WHITESPACE ();
2824   if (*input_line_pointer == ',')
2825     {
2826       ++input_line_pointer;
2827       expression (&val);
2828     }
2829   else
2830     {
2831       val.X_op = O_constant;
2832       val.X_add_number = 0;
2833     }
2834
2835   if (val.X_op != O_constant
2836       || val.X_add_number < - 0x80
2837       || val.X_add_number > 0xff
2838       || (mult != 0 && mult != 1 && val.X_add_number != 0))
2839     {
2840       if (exp.X_op != O_constant)
2841         as_bad (_("Unsupported variable size or fill value"));
2842       else
2843         {
2844           offsetT i;
2845
2846           if (mult == 0)
2847             mult = 1;
2848           bytes = mult * exp.X_add_number;
2849           for (i = 0; i < exp.X_add_number; i++)
2850             emit_expr (&val, mult);
2851         }
2852     }
2853   else
2854     {
2855       if (exp.X_op == O_constant)
2856         {
2857           long repeat;
2858
2859           repeat = exp.X_add_number;
2860           if (mult)
2861             repeat *= mult;
2862           bytes = repeat;
2863           if (repeat <= 0)
2864             {
2865               if (! flag_mri)
2866                 as_warn (_(".space repeat count is zero, ignored"));
2867               else if (repeat < 0)
2868                 as_warn (_(".space repeat count is negative, ignored"));
2869               goto getout;
2870             }
2871
2872           /* If we are in the absolute section, just bump the offset.  */
2873           if (now_seg == absolute_section)
2874             {
2875               abs_section_offset += repeat;
2876               goto getout;
2877             }
2878
2879           /* If we are secretly in an MRI common section, then
2880              creating space just increases the size of the common
2881              symbol.  */
2882           if (mri_common_symbol != NULL)
2883             {
2884               S_SET_VALUE (mri_common_symbol,
2885                            S_GET_VALUE (mri_common_symbol) + repeat);
2886               goto getout;
2887             }
2888
2889           if (!need_pass_2)
2890             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2891                           (offsetT) repeat, (char *) 0);
2892         }
2893       else
2894         {
2895           if (now_seg == absolute_section)
2896             {
2897               as_bad (_("space allocation too complex in absolute section"));
2898               subseg_set (text_section, 0);
2899             }
2900           if (mri_common_symbol != NULL)
2901             {
2902               as_bad (_("space allocation too complex in common section"));
2903               mri_common_symbol = NULL;
2904             }
2905           if (!need_pass_2)
2906             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2907                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
2908         }
2909
2910       if (p)
2911         *p = val.X_add_number;
2912     }
2913
2914  getout:
2915
2916   /* In MRI mode, after an odd number of bytes, we must align to an
2917      even word boundary, unless the next instruction is a dc.b, ds.b
2918      or dcb.b.  */
2919   if (flag_mri && (bytes & 1) != 0)
2920     mri_pending_align = 1;
2921
2922   demand_empty_rest_of_line ();
2923
2924   if (flag_mri)
2925     mri_comment_end (stop, stopc);
2926 }
2927
2928 /* This is like s_space, but the value is a floating point number with
2929    the given precision.  This is for the MRI dcb.s pseudo-op and
2930    friends.  */
2931
2932 void
2933 s_float_space (float_type)
2934      int float_type;
2935 {
2936   offsetT count;
2937   int flen;
2938   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
2939   char *stop = NULL;
2940   char stopc;
2941
2942   if (flag_mri)
2943     stop = mri_comment_field (&stopc);
2944
2945   count = get_absolute_expression ();
2946
2947   SKIP_WHITESPACE ();
2948   if (*input_line_pointer != ',')
2949     {
2950       as_bad (_("missing value"));
2951       ignore_rest_of_line ();
2952       if (flag_mri)
2953         mri_comment_end (stop, stopc);
2954       return;
2955     }
2956
2957   ++input_line_pointer;
2958
2959   SKIP_WHITESPACE ();
2960
2961   /* Skip any 0{letter} that may be present.  Don't even check if the
2962    * letter is legal.  */
2963   if (input_line_pointer[0] == '0'
2964       && isalpha ((unsigned char) input_line_pointer[1]))
2965     input_line_pointer += 2;
2966
2967   /* Accept :xxxx, where the x's are hex digits, for a floating point
2968      with the exact digits specified.  */
2969   if (input_line_pointer[0] == ':')
2970     {
2971       flen = hex_float (float_type, temp);
2972       if (flen < 0)
2973         {
2974           ignore_rest_of_line ();
2975           if (flag_mri)
2976             mri_comment_end (stop, stopc);
2977           return;
2978         }
2979     }
2980   else
2981     {
2982       char *err;
2983
2984       err = md_atof (float_type, temp, &flen);
2985       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
2986       know (flen > 0);
2987       if (err)
2988         {
2989           as_bad (_("Bad floating literal: %s"), err);
2990           ignore_rest_of_line ();
2991           if (flag_mri)
2992             mri_comment_end (stop, stopc);
2993           return;
2994         }
2995     }
2996
2997   while (--count >= 0)
2998     {
2999       char *p;
3000
3001       p = frag_more (flen);
3002       memcpy (p, temp, (unsigned int) flen);
3003     }
3004
3005   demand_empty_rest_of_line ();
3006
3007   if (flag_mri)
3008     mri_comment_end (stop, stopc);
3009 }
3010
3011 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3012
3013 void
3014 s_struct (ignore)
3015      int ignore ATTRIBUTE_UNUSED;
3016 {
3017   char *stop = NULL;
3018   char stopc;
3019
3020   if (flag_mri)
3021     stop = mri_comment_field (&stopc);
3022   abs_section_offset = get_absolute_expression ();
3023   subseg_set (absolute_section, 0);
3024   demand_empty_rest_of_line ();
3025   if (flag_mri)
3026     mri_comment_end (stop, stopc);
3027 }
3028
3029 void
3030 s_text (ignore)
3031      int ignore ATTRIBUTE_UNUSED;
3032 {
3033   register int temp;
3034
3035   temp = get_absolute_expression ();
3036   subseg_set (text_section, (subsegT) temp);
3037   demand_empty_rest_of_line ();
3038 #ifdef OBJ_VMS
3039   const_flag &= ~IN_DEFAULT_SECTION;
3040 #endif
3041 }                               /* s_text() */
3042 \f
3043
3044 void
3045 demand_empty_rest_of_line ()
3046 {
3047   SKIP_WHITESPACE ();
3048   if (is_end_of_line[(unsigned char) *input_line_pointer])
3049     {
3050       input_line_pointer++;
3051     }
3052   else
3053     {
3054       ignore_rest_of_line ();
3055     }
3056   /* Return having already swallowed end-of-line. */
3057 }                               /* Return pointing just after end-of-line. */
3058
3059 void
3060 ignore_rest_of_line ()          /* For suspect lines: gives warning. */
3061 {
3062   if (!is_end_of_line[(unsigned char) *input_line_pointer])
3063     {
3064       if (isprint ((unsigned char) *input_line_pointer))
3065         as_bad (_("Rest of line ignored. First ignored character is `%c'."),
3066                 *input_line_pointer);
3067       else
3068         as_bad (_("Rest of line ignored. First ignored character valued 0x%x."),
3069                 *input_line_pointer);
3070       while (input_line_pointer < buffer_limit
3071              && !is_end_of_line[(unsigned char) *input_line_pointer])
3072         {
3073           input_line_pointer++;
3074         }
3075     }
3076   input_line_pointer++;         /* Return pointing just after end-of-line. */
3077   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3078 }
3079
3080 void
3081 discard_rest_of_line ()
3082 {
3083   while (input_line_pointer < buffer_limit
3084          && !is_end_of_line[(unsigned char) *input_line_pointer])
3085     {
3086       input_line_pointer++;
3087     }
3088   input_line_pointer++;         /* Return pointing just after end-of-line. */
3089   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3090 }
3091
3092 /*
3093  *                      pseudo_set()
3094  *
3095  * In:  Pointer to a symbol.
3096  *      Input_line_pointer->expression.
3097  *
3098  * Out: Input_line_pointer->just after any whitespace after expression.
3099  *      Tried to set symbol to value of expression.
3100  *      Will change symbols type, value, and frag;
3101  */
3102 void
3103 pseudo_set (symbolP)
3104      symbolS *symbolP;
3105 {
3106   expressionS exp;
3107 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3108   int ext;
3109 #endif /* OBJ_AOUT or OBJ_BOUT */
3110
3111   know (symbolP);               /* NULL pointer is logic error. */
3112 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3113   ext = S_IS_EXTERNAL (symbolP);
3114 #endif /* OBJ_AOUT or OBJ_BOUT */
3115
3116   (void) expression (&exp);
3117
3118   if (exp.X_op == O_illegal)
3119     as_bad (_("illegal expression; zero assumed"));
3120   else if (exp.X_op == O_absent)
3121     as_bad (_("missing expression; zero assumed"));
3122   else if (exp.X_op == O_big)
3123     {
3124       if (exp.X_add_number > 0)
3125         as_bad (_("bignum invalid; zero assumed"));
3126       else
3127         as_bad (_("floating point number invalid; zero assumed"));
3128     }
3129   else if (exp.X_op == O_subtract
3130            && (S_GET_SEGMENT (exp.X_add_symbol)
3131                == S_GET_SEGMENT (exp.X_op_symbol))
3132            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3133            && (symbol_get_frag (exp.X_add_symbol)
3134                == symbol_get_frag (exp.X_op_symbol)))
3135     {
3136       exp.X_op = O_constant;
3137       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3138                           - S_GET_VALUE (exp.X_op_symbol));
3139     }
3140
3141   switch (exp.X_op)
3142     {
3143     case O_illegal:
3144     case O_absent:
3145     case O_big:
3146       exp.X_add_number = 0;
3147       /* Fall through.  */
3148     case O_constant:
3149       S_SET_SEGMENT (symbolP, absolute_section);
3150 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3151       if (ext)
3152         S_SET_EXTERNAL (symbolP);
3153       else
3154         S_CLEAR_EXTERNAL (symbolP);
3155 #endif /* OBJ_AOUT or OBJ_BOUT */
3156       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3157       if (exp.X_op != O_constant)
3158         symbol_set_frag (symbolP, &zero_address_frag);
3159       break;
3160
3161     case O_register:
3162       S_SET_SEGMENT (symbolP, reg_section);
3163       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3164       symbol_set_frag (symbolP, &zero_address_frag);
3165       break;
3166
3167     case O_symbol:
3168       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3169           || exp.X_add_number != 0)
3170         symbol_set_value_expression (symbolP, &exp);
3171       else if (symbol_section_p (symbolP))
3172         as_bad ("invalid attempt to set value of section symbol");
3173       else
3174         {
3175           symbolS *s = exp.X_add_symbol;
3176
3177           S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3178 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3179           if (ext)
3180             S_SET_EXTERNAL (symbolP);
3181           else
3182             S_CLEAR_EXTERNAL (symbolP);
3183 #endif /* OBJ_AOUT or OBJ_BOUT */
3184           S_SET_VALUE (symbolP,
3185                        exp.X_add_number + S_GET_VALUE (s));
3186           symbol_set_frag (symbolP, symbol_get_frag (s));
3187           copy_symbol_attributes (symbolP, s);
3188         }
3189       break;
3190
3191     default:
3192       /* The value is some complex expression.
3193          FIXME: Should we set the segment to anything?  */
3194       symbol_set_value_expression (symbolP, &exp);
3195       break;
3196     }
3197 }
3198 \f
3199 /*
3200  *                      cons()
3201  *
3202  * CONStruct more frag of .bytes, or .words etc.
3203  * Should need_pass_2 be 1 then emit no frag(s).
3204  * This understands EXPRESSIONS.
3205  *
3206  * Bug (?)
3207  *
3208  * This has a split personality. We use expression() to read the
3209  * value. We can detect if the value won't fit in a byte or word.
3210  * But we can't detect if expression() discarded significant digits
3211  * in the case of a long. Not worth the crocks required to fix it.
3212  */
3213
3214 /* Select a parser for cons expressions.  */
3215
3216 /* Some targets need to parse the expression in various fancy ways.
3217    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3218    (for example, the HPPA does this).  Otherwise, you can define
3219    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3220    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3221    are defined, which is the normal case, then only simple expressions
3222    are permitted.  */
3223
3224 static void
3225 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3226
3227 #ifndef TC_PARSE_CONS_EXPRESSION
3228 #ifdef BITFIELD_CONS_EXPRESSIONS
3229 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3230 static void
3231 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3232 #endif
3233 #ifdef REPEAT_CONS_EXPRESSIONS
3234 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3235 static void
3236 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3237 #endif
3238
3239 /* If we haven't gotten one yet, just call expression.  */
3240 #ifndef TC_PARSE_CONS_EXPRESSION
3241 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3242 #endif
3243 #endif
3244
3245 /* worker to do .byte etc statements */
3246 /* clobbers input_line_pointer, checks */
3247 /* end-of-line. */
3248 static void
3249 cons_worker (nbytes, rva)
3250      register int nbytes;       /* 1=.byte, 2=.word, 4=.long */
3251      int rva;
3252 {
3253   int c;
3254   expressionS exp;
3255   char *stop = NULL;
3256   char stopc;
3257
3258 #ifdef md_flush_pending_output
3259   md_flush_pending_output ();
3260 #endif
3261
3262   if (flag_mri)
3263     stop = mri_comment_field (&stopc);
3264
3265   if (is_it_end_of_statement ())
3266     {
3267       demand_empty_rest_of_line ();
3268       if (flag_mri)
3269         mri_comment_end (stop, stopc);
3270       return;
3271     }
3272
3273 #ifdef md_cons_align
3274   md_cons_align (nbytes);
3275 #endif
3276
3277   c = 0;
3278   do
3279     {
3280       if (flag_m68k_mri)
3281         parse_mri_cons (&exp, (unsigned int) nbytes);
3282       else
3283         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3284
3285       if (rva)
3286         {
3287           if (exp.X_op == O_symbol)
3288             exp.X_op = O_symbol_rva;
3289           else
3290             as_fatal (_("rva without symbol"));
3291         }
3292       emit_expr (&exp, (unsigned int) nbytes);
3293       ++c;
3294     }
3295   while (*input_line_pointer++ == ',');
3296
3297   /* In MRI mode, after an odd number of bytes, we must align to an
3298      even word boundary, unless the next instruction is a dc.b, ds.b
3299      or dcb.b.  */
3300   if (flag_mri && nbytes == 1 && (c & 1) != 0)
3301     mri_pending_align = 1;
3302
3303   input_line_pointer--;         /* Put terminator back into stream. */
3304
3305   demand_empty_rest_of_line ();
3306
3307   if (flag_mri)
3308     mri_comment_end (stop, stopc);
3309 }
3310
3311
3312 void
3313 cons (size)
3314      int size;
3315 {
3316   cons_worker (size, 0);
3317 }
3318
3319 void
3320 s_rva (size)
3321      int size;
3322 {
3323   cons_worker (size, 1);
3324 }
3325
3326 /* Put the contents of expression EXP into the object file using
3327    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
3328
3329 void
3330 emit_expr (exp, nbytes)
3331      expressionS *exp;
3332      unsigned int nbytes;
3333 {
3334   operatorT op;
3335   register char *p;
3336   valueT extra_digit = 0;
3337
3338   /* Don't do anything if we are going to make another pass.  */
3339   if (need_pass_2)
3340     return;
3341
3342 #ifndef NO_LISTING
3343 #ifdef OBJ_ELF
3344   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3345      appear as a four byte positive constant in the .line section,
3346      followed by a 2 byte 0xffff.  Look for that case here.  */
3347   {
3348     static int dwarf_line = -1;
3349
3350     if (strcmp (segment_name (now_seg), ".line") != 0)
3351       dwarf_line = -1;
3352     else if (dwarf_line >= 0
3353              && nbytes == 2
3354              && exp->X_op == O_constant
3355              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3356       listing_source_line ((unsigned int) dwarf_line);
3357     else if (nbytes == 4
3358              && exp->X_op == O_constant
3359              && exp->X_add_number >= 0)
3360       dwarf_line = exp->X_add_number;
3361     else
3362       dwarf_line = -1;
3363   }
3364
3365   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3366      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3367      AT_sibling (0x12) followed by a four byte address of the sibling
3368      followed by a 2 byte AT_name (0x38) followed by the name of the
3369      file.  We look for that case here.  */
3370   {
3371     static int dwarf_file = 0;
3372
3373     if (strcmp (segment_name (now_seg), ".debug") != 0)
3374       dwarf_file = 0;
3375     else if (dwarf_file == 0
3376              && nbytes == 2
3377              && exp->X_op == O_constant
3378              && exp->X_add_number == 0x11)
3379       dwarf_file = 1;
3380     else if (dwarf_file == 1
3381              && nbytes == 2
3382              && exp->X_op == O_constant
3383              && exp->X_add_number == 0x12)
3384       dwarf_file = 2;
3385     else if (dwarf_file == 2
3386              && nbytes == 4)
3387       dwarf_file = 3;
3388     else if (dwarf_file == 3
3389              && nbytes == 2
3390              && exp->X_op == O_constant
3391              && exp->X_add_number == 0x38)
3392       dwarf_file = 4;
3393     else
3394       dwarf_file = 0;
3395
3396     /* The variable dwarf_file_string tells stringer that the string
3397        may be the name of the source file.  */
3398     if (dwarf_file == 4)
3399       dwarf_file_string = 1;
3400     else
3401       dwarf_file_string = 0;
3402   }
3403 #endif
3404 #endif
3405
3406   if (check_eh_frame (exp, &nbytes))
3407     return;
3408
3409   op = exp->X_op;
3410
3411   /* Allow `.word 0' in the absolute section.  */
3412   if (now_seg == absolute_section)
3413     {
3414       if (op != O_constant || exp->X_add_number != 0)
3415         as_bad (_("attempt to store value in absolute section"));
3416       abs_section_offset += nbytes;
3417       return;
3418     }
3419
3420   /* Handle a negative bignum.  */
3421   if (op == O_uminus
3422       && exp->X_add_number == 0
3423       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3424       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3425     {
3426       int i;
3427       unsigned long carry;
3428
3429       exp = symbol_get_value_expression (exp->X_add_symbol);
3430
3431       /* Negate the bignum: one's complement each digit and add 1.  */
3432       carry = 1;
3433       for (i = 0; i < exp->X_add_number; i++)
3434         {
3435           unsigned long next;
3436
3437           next = (((~ (generic_bignum[i] & LITTLENUM_MASK))
3438                    & LITTLENUM_MASK)
3439                   + carry);
3440           generic_bignum[i] = next & LITTLENUM_MASK;
3441           carry = next >> LITTLENUM_NUMBER_OF_BITS;
3442         }
3443
3444       /* We can ignore any carry out, because it will be handled by
3445          extra_digit if it is needed.  */
3446
3447       extra_digit = (valueT) -1;
3448       op = O_big;
3449     }
3450
3451   if (op == O_absent || op == O_illegal)
3452     {
3453       as_warn (_("zero assumed for missing expression"));
3454       exp->X_add_number = 0;
3455       op = O_constant;
3456     }
3457   else if (op == O_big && exp->X_add_number <= 0)
3458     {
3459       as_bad (_("floating point number invalid; zero assumed"));
3460       exp->X_add_number = 0;
3461       op = O_constant;
3462     }
3463   else if (op == O_register)
3464     {
3465       as_warn (_("register value used as expression"));
3466       op = O_constant;
3467     }
3468
3469   p = frag_more ((int) nbytes);
3470
3471 #ifndef WORKING_DOT_WORD
3472   /* If we have the difference of two symbols in a word, save it on
3473      the broken_words list.  See the code in write.c.  */
3474   if (op == O_subtract && nbytes == 2)
3475     {
3476       struct broken_word *x;
3477
3478       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3479       x->next_broken_word = broken_words;
3480       broken_words = x;
3481       x->seg = now_seg;
3482       x->subseg = now_subseg;
3483       x->frag = frag_now;
3484       x->word_goes_here = p;
3485       x->dispfrag = 0;
3486       x->add = exp->X_add_symbol;
3487       x->sub = exp->X_op_symbol;
3488       x->addnum = exp->X_add_number;
3489       x->added = 0;
3490       new_broken_words++;
3491       return;
3492     }
3493 #endif
3494
3495   /* If we have an integer, but the number of bytes is too large to
3496      pass to md_number_to_chars, handle it as a bignum.  */
3497   if (op == O_constant && nbytes > sizeof (valueT))
3498     {
3499       valueT val;
3500       int gencnt;
3501
3502       if (! exp->X_unsigned && exp->X_add_number < 0)
3503         extra_digit = (valueT) -1;
3504       val = (valueT) exp->X_add_number;
3505       gencnt = 0;
3506       do
3507         {
3508           generic_bignum[gencnt] = val & LITTLENUM_MASK;
3509           val >>= LITTLENUM_NUMBER_OF_BITS;
3510           ++gencnt;
3511         }
3512       while (val != 0);
3513       op = exp->X_op = O_big;
3514       exp->X_add_number = gencnt;
3515     }
3516
3517   if (op == O_constant)
3518     {
3519       register valueT get;
3520       register valueT use;
3521       register valueT mask;
3522       valueT hibit;
3523       register valueT unmask;
3524
3525       /* JF << of >= number of bits in the object is undefined.  In
3526          particular SPARC (Sun 4) has problems */
3527       if (nbytes >= sizeof (valueT))
3528         {
3529           mask = 0;
3530           if (nbytes > sizeof (valueT))
3531             hibit = 0;
3532           else
3533             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3534         }
3535       else
3536         {
3537           /* Don't store these bits. */
3538           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3539           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3540         }
3541
3542       unmask = ~mask;           /* Do store these bits. */
3543
3544 #ifdef NEVER
3545       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3546       mask = ~(unmask >> 1);    /* Includes sign bit now. */
3547 #endif
3548
3549       get = exp->X_add_number;
3550       use = get & unmask;
3551       if ((get & mask) != 0
3552           && ((get & mask) != mask
3553               || (get & hibit) == 0))
3554         {               /* Leading bits contain both 0s & 1s. */
3555           as_warn (_("Value 0x%lx truncated to 0x%lx."),
3556                    (unsigned long) get, (unsigned long) use);
3557         }
3558       /* put bytes in right order. */
3559       md_number_to_chars (p, use, (int) nbytes);
3560     }
3561   else if (op == O_big)
3562     {
3563       unsigned int size;
3564       LITTLENUM_TYPE *nums;
3565
3566       know (nbytes % CHARS_PER_LITTLENUM == 0);
3567
3568       size = exp->X_add_number * CHARS_PER_LITTLENUM;
3569       if (nbytes < size)
3570         {
3571           as_warn (_("Bignum truncated to %d bytes"), nbytes);
3572           size = nbytes;
3573         }
3574
3575       if (target_big_endian)
3576         {
3577           while (nbytes > size)
3578             {
3579               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3580               nbytes -= CHARS_PER_LITTLENUM;
3581               p += CHARS_PER_LITTLENUM;
3582             }
3583
3584           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3585           while (size > 0)
3586             {
3587               --nums;
3588               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3589               size -= CHARS_PER_LITTLENUM;
3590               p += CHARS_PER_LITTLENUM;
3591             }
3592         }
3593       else
3594         {
3595           nums = generic_bignum;
3596           while (size > 0)
3597             {
3598               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3599               ++nums;
3600               size -= CHARS_PER_LITTLENUM;
3601               p += CHARS_PER_LITTLENUM;
3602               nbytes -= CHARS_PER_LITTLENUM;
3603             }
3604
3605           while (nbytes > 0)
3606             {
3607               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3608               nbytes -= CHARS_PER_LITTLENUM;
3609               p += CHARS_PER_LITTLENUM;
3610             }
3611         }
3612     }
3613   else
3614     {
3615       memset (p, 0, nbytes);
3616
3617       /* Now we need to generate a fixS to record the symbol value.
3618          This is easy for BFD.  For other targets it can be more
3619          complex.  For very complex cases (currently, the HPPA and
3620          NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3621          want.  For simpler cases, you can define TC_CONS_RELOC to be
3622          the name of the reloc code that should be stored in the fixS.
3623          If neither is defined, the code uses NO_RELOC if it is
3624          defined, and otherwise uses 0.  */
3625
3626 #ifdef BFD_ASSEMBLER
3627 #ifdef TC_CONS_FIX_NEW
3628       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3629 #else
3630       {
3631         bfd_reloc_code_real_type r;
3632
3633         switch (nbytes)
3634           {
3635           case 1:
3636             r = BFD_RELOC_8;
3637             break;
3638           case 2:
3639             r = BFD_RELOC_16;
3640             break;
3641           case 4:
3642             r = BFD_RELOC_32;
3643             break;
3644           case 8:
3645             r = BFD_RELOC_64;
3646             break;
3647           default:
3648             as_bad (_("unsupported BFD relocation size %u"), nbytes);
3649             r = BFD_RELOC_32;
3650             break;
3651           }
3652         fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3653                      0, r);
3654       }
3655 #endif
3656 #else
3657 #ifdef TC_CONS_FIX_NEW
3658       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3659 #else
3660       /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
3661          it is defined, otherwise use NO_RELOC if it is defined,
3662          otherwise use 0.  */
3663 #ifndef TC_CONS_RELOC
3664 #ifdef NO_RELOC
3665 #define TC_CONS_RELOC NO_RELOC
3666 #else
3667 #define TC_CONS_RELOC 0
3668 #endif
3669 #endif
3670       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3671                    TC_CONS_RELOC);
3672 #endif /* TC_CONS_FIX_NEW */
3673 #endif /* BFD_ASSEMBLER */
3674     }
3675 }
3676 \f
3677 #ifdef BITFIELD_CONS_EXPRESSIONS
3678
3679 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3680    w:x,y:z, where w and y are bitwidths and x and y are values.  They
3681    then pack them all together. We do a little better in that we allow
3682    them in words, longs, etc. and we'll pack them in target byte order
3683    for you.
3684
3685    The rules are: pack least significat bit first, if a field doesn't
3686    entirely fit, put it in the next unit.  Overflowing the bitfield is
3687    explicitly *not* even a warning.  The bitwidth should be considered
3688    a "mask".
3689
3690    To use this function the tc-XXX.h file should define
3691    BITFIELD_CONS_EXPRESSIONS.  */
3692
3693 static void
3694 parse_bitfield_cons (exp, nbytes)
3695      expressionS *exp;
3696      unsigned int nbytes;
3697 {
3698   unsigned int bits_available = BITS_PER_CHAR * nbytes;
3699   char *hold = input_line_pointer;
3700
3701   (void) expression (exp);
3702
3703   if (*input_line_pointer == ':')
3704     {                   /* bitfields */
3705       long value = 0;
3706
3707       for (;;)
3708         {
3709           unsigned long width;
3710
3711           if (*input_line_pointer != ':')
3712             {
3713               input_line_pointer = hold;
3714               break;
3715             }                   /* next piece is not a bitfield */
3716
3717           /* In the general case, we can't allow
3718              full expressions with symbol
3719              differences and such.  The relocation
3720              entries for symbols not defined in this
3721              assembly would require arbitrary field
3722              widths, positions, and masks which most
3723              of our current object formats don't
3724              support.
3725
3726              In the specific case where a symbol
3727              *is* defined in this assembly, we
3728              *could* build fixups and track it, but
3729              this could lead to confusion for the
3730              backends.  I'm lazy. I'll take any
3731              SEG_ABSOLUTE. I think that means that
3732              you can use a previous .set or
3733              .equ type symbol.  xoxorich. */
3734
3735           if (exp->X_op == O_absent)
3736             {
3737               as_warn (_("using a bit field width of zero"));
3738               exp->X_add_number = 0;
3739               exp->X_op = O_constant;
3740             }                   /* implied zero width bitfield */
3741
3742           if (exp->X_op != O_constant)
3743             {
3744               *input_line_pointer = '\0';
3745               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3746               *input_line_pointer = ':';
3747               demand_empty_rest_of_line ();
3748               return;
3749             }                   /* too complex */
3750
3751           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3752             {
3753               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3754                        width, nbytes, (BITS_PER_CHAR * nbytes));
3755               width = BITS_PER_CHAR * nbytes;
3756             }                   /* too big */
3757
3758           if (width > bits_available)
3759             {
3760               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
3761               input_line_pointer = hold;
3762               exp->X_add_number = value;
3763               break;
3764             }                   /* won't fit */
3765
3766           hold = ++input_line_pointer; /* skip ':' */
3767
3768           (void) expression (exp);
3769           if (exp->X_op != O_constant)
3770             {
3771               char cache = *input_line_pointer;
3772
3773               *input_line_pointer = '\0';
3774               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3775               *input_line_pointer = cache;
3776               demand_empty_rest_of_line ();
3777               return;
3778             }                   /* too complex */
3779
3780           value |= ((~(-1 << width) & exp->X_add_number)
3781                     << ((BITS_PER_CHAR * nbytes) - bits_available));
3782
3783           if ((bits_available -= width) == 0
3784               || is_it_end_of_statement ()
3785               || *input_line_pointer != ',')
3786             {
3787               break;
3788             }                   /* all the bitfields we're gonna get */
3789
3790           hold = ++input_line_pointer;
3791           (void) expression (exp);
3792         }                       /* forever loop */
3793
3794       exp->X_add_number = value;
3795       exp->X_op = O_constant;
3796       exp->X_unsigned = 1;
3797     }                           /* if looks like a bitfield */
3798 }                               /* parse_bitfield_cons() */
3799
3800 #endif /* BITFIELD_CONS_EXPRESSIONS */
3801 \f
3802 /* Handle an MRI style string expression.  */
3803
3804 static void
3805 parse_mri_cons (exp, nbytes)
3806      expressionS *exp;
3807      unsigned int nbytes;
3808 {
3809   if (*input_line_pointer != '\''
3810       && (input_line_pointer[1] != '\''
3811           || (*input_line_pointer != 'A'
3812               && *input_line_pointer != 'E')))
3813     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3814   else
3815     {
3816       unsigned int scan;
3817       unsigned int result = 0;
3818
3819       /* An MRI style string.  Cut into as many bytes as will fit into
3820          a nbyte chunk, left justify if necessary, and separate with
3821          commas so we can try again later.  */
3822       if (*input_line_pointer == 'A')
3823         ++input_line_pointer;
3824       else if (*input_line_pointer == 'E')
3825         {
3826           as_bad (_("EBCDIC constants are not supported"));
3827           ++input_line_pointer;
3828         }
3829
3830       input_line_pointer++;
3831       for (scan = 0; scan < nbytes; scan++)
3832         {
3833           if (*input_line_pointer == '\'')
3834             {
3835               if (input_line_pointer[1] == '\'')
3836                 {
3837                   input_line_pointer++;
3838                 }
3839               else
3840                 break;
3841             }
3842           result = (result << 8) | (*input_line_pointer++);
3843         }
3844
3845       /* Left justify */
3846       while (scan < nbytes)
3847         {
3848           result <<= 8;
3849           scan++;
3850         }
3851       /* Create correct expression */
3852       exp->X_op = O_constant;
3853       exp->X_add_number = result;
3854       /* Fake it so that we can read the next char too */
3855       if (input_line_pointer[0] != '\'' ||
3856           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3857         {
3858           input_line_pointer -= 2;
3859           input_line_pointer[0] = ',';
3860           input_line_pointer[1] = '\'';
3861         }
3862       else
3863         input_line_pointer++;
3864     }
3865 }
3866 \f
3867 #ifdef REPEAT_CONS_EXPRESSIONS
3868
3869 /* Parse a repeat expression for cons.  This is used by the MIPS
3870    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
3871    object file COUNT times.
3872
3873    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
3874
3875 static void
3876 parse_repeat_cons (exp, nbytes)
3877      expressionS *exp;
3878      unsigned int nbytes;
3879 {
3880   expressionS count;
3881   register int i;
3882
3883   expression (exp);
3884
3885   if (*input_line_pointer != ':')
3886     {
3887       /* No repeat count.  */
3888       return;
3889     }
3890
3891   ++input_line_pointer;
3892   expression (&count);
3893   if (count.X_op != O_constant
3894       || count.X_add_number <= 0)
3895     {
3896       as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
3897       return;
3898     }
3899
3900   /* The cons function is going to output this expression once.  So we
3901      output it count - 1 times.  */
3902   for (i = count.X_add_number - 1; i > 0; i--)
3903     emit_expr (exp, nbytes);
3904 }
3905
3906 #endif /* REPEAT_CONS_EXPRESSIONS */
3907 \f
3908 /* Parse a floating point number represented as a hex constant.  This
3909    permits users to specify the exact bits they want in the floating
3910    point number.  */
3911
3912 static int
3913 hex_float (float_type, bytes)
3914      int float_type;
3915      char *bytes;
3916 {
3917   int length;
3918   int i;
3919
3920   switch (float_type)
3921     {
3922     case 'f':
3923     case 'F':
3924     case 's':
3925     case 'S':
3926       length = 4;
3927       break;
3928
3929     case 'd':
3930     case 'D':
3931     case 'r':
3932     case 'R':
3933       length = 8;
3934       break;
3935
3936     case 'x':
3937     case 'X':
3938       length = 12;
3939       break;
3940
3941     case 'p':
3942     case 'P':
3943       length = 12;
3944       break;
3945
3946     default:
3947       as_bad (_("Unknown floating type type '%c'"), float_type);
3948       return -1;
3949     }
3950
3951   /* It would be nice if we could go through expression to parse the
3952      hex constant, but if we get a bignum it's a pain to sort it into
3953      the buffer correctly.  */
3954   i = 0;
3955   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
3956     {
3957       int d;
3958
3959       /* The MRI assembler accepts arbitrary underscores strewn about
3960          through the hex constant, so we ignore them as well. */
3961       if (*input_line_pointer == '_')
3962         {
3963           ++input_line_pointer;
3964           continue;
3965         }
3966
3967       if (i >= length)
3968         {
3969           as_warn (_("Floating point constant too large"));
3970           return -1;
3971         }
3972       d = hex_value (*input_line_pointer) << 4;
3973       ++input_line_pointer;
3974       while (*input_line_pointer == '_')
3975         ++input_line_pointer;
3976       if (hex_p (*input_line_pointer))
3977         {
3978           d += hex_value (*input_line_pointer);
3979           ++input_line_pointer;
3980         }
3981       if (target_big_endian)
3982         bytes[i] = d;
3983       else
3984         bytes[length - i - 1] = d;
3985       ++i;
3986     }
3987
3988   if (i < length)
3989     {
3990       if (target_big_endian)
3991         memset (bytes + i, 0, length - i);
3992       else
3993         memset (bytes, 0, length - i);
3994     }
3995
3996   return length;
3997 }
3998
3999 /*
4000  *                      float_cons()
4001  *
4002  * CONStruct some more frag chars of .floats .ffloats etc.
4003  * Makes 0 or more new frags.
4004  * If need_pass_2 == 1, no frags are emitted.
4005  * This understands only floating literals, not expressions. Sorry.
4006  *
4007  * A floating constant is defined by atof_generic(), except it is preceded
4008  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4009  * reading, I decided to be incompatible. This always tries to give you
4010  * rounded bits to the precision of the pseudo-op. Former AS did premature
4011  * truncatation, restored noisy bits instead of trailing 0s AND gave you
4012  * a choice of 2 flavours of noise according to which of 2 floating-point
4013  * scanners you directed AS to use.
4014  *
4015  * In:  input_line_pointer->whitespace before, or '0' of flonum.
4016  *
4017  */
4018
4019 void
4020 float_cons (float_type)
4021      /* Clobbers input_line-pointer, checks end-of-line. */
4022      register int float_type;   /* 'f':.ffloat ... 'F':.float ... */
4023 {
4024   register char *p;
4025   int length;                   /* Number of chars in an object. */
4026   register char *err;           /* Error from scanning floating literal. */
4027   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4028
4029   if (is_it_end_of_statement ())
4030     {
4031       demand_empty_rest_of_line ();
4032       return;
4033     }
4034
4035 #ifdef md_flush_pending_output
4036   md_flush_pending_output ();
4037 #endif
4038
4039   do
4040     {
4041       /* input_line_pointer->1st char of a flonum (we hope!). */
4042       SKIP_WHITESPACE ();
4043
4044       /* Skip any 0{letter} that may be present. Don't even check if the
4045        * letter is legal. Someone may invent a "z" format and this routine
4046        * has no use for such information. Lusers beware: you get
4047        * diagnostics if your input is ill-conditioned.
4048        */
4049       if (input_line_pointer[0] == '0'
4050           && isalpha ((unsigned char) input_line_pointer[1]))
4051         input_line_pointer += 2;
4052
4053       /* Accept :xxxx, where the x's are hex digits, for a floating
4054          point with the exact digits specified.  */
4055       if (input_line_pointer[0] == ':')
4056         {
4057           ++input_line_pointer;
4058           length = hex_float (float_type, temp);
4059           if (length < 0)
4060             {
4061               ignore_rest_of_line ();
4062               return;
4063             }
4064         }
4065       else
4066         {
4067           err = md_atof (float_type, temp, &length);
4068           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4069           know (length > 0);
4070           if (err)
4071             {
4072               as_bad (_("Bad floating literal: %s"), err);
4073               ignore_rest_of_line ();
4074               return;
4075             }
4076         }
4077
4078       if (!need_pass_2)
4079         {
4080           int count;
4081
4082           count = 1;
4083
4084 #ifdef REPEAT_CONS_EXPRESSIONS
4085           if (*input_line_pointer == ':')
4086             {
4087               expressionS count_exp;
4088
4089               ++input_line_pointer;
4090               expression (&count_exp);
4091               if (count_exp.X_op != O_constant
4092                   || count_exp.X_add_number <= 0)
4093                 {
4094                   as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4095                 }
4096               else
4097                 count = count_exp.X_add_number;
4098             }
4099 #endif
4100
4101           while (--count >= 0)
4102             {
4103               p = frag_more (length);
4104               memcpy (p, temp, (unsigned int) length);
4105             }
4106         }
4107       SKIP_WHITESPACE ();
4108     }
4109   while (*input_line_pointer++ == ',');
4110
4111   --input_line_pointer;         /* Put terminator back into stream.  */
4112   demand_empty_rest_of_line ();
4113 }                               /* float_cons() */
4114 \f
4115 /* Return the size of a LEB128 value */
4116
4117 static inline int
4118 sizeof_sleb128 (value)
4119      offsetT value;
4120 {
4121   register int size = 0;
4122   register unsigned byte;
4123
4124   do
4125     {
4126       byte = (value & 0x7f);
4127       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4128          Fortunately, we can structure things so that the extra work reduces
4129          to a noop on systems that do things "properly".  */
4130       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4131       size += 1;
4132     }
4133   while (!(((value == 0) && ((byte & 0x40) == 0))
4134            || ((value == -1) && ((byte & 0x40) != 0))));
4135
4136   return size;
4137 }
4138
4139 static inline int
4140 sizeof_uleb128 (value)
4141      valueT value;
4142 {
4143   register int size = 0;
4144   register unsigned byte;
4145
4146   do
4147     {
4148       byte = (value & 0x7f);
4149       value >>= 7;
4150       size += 1;
4151     }
4152   while (value != 0);
4153
4154   return size;
4155 }
4156
4157 int
4158 sizeof_leb128 (value, sign)
4159      valueT value;
4160      int sign;
4161 {
4162   if (sign)
4163     return sizeof_sleb128 ((offsetT) value);
4164   else
4165     return sizeof_uleb128 (value);
4166 }
4167
4168 /* Output a LEB128 value.  */
4169
4170 static inline int
4171 output_sleb128 (p, value)
4172      char *p;
4173      offsetT value;
4174 {
4175   register char *orig = p;
4176   register int more;
4177
4178   do
4179     {
4180       unsigned byte = (value & 0x7f);
4181
4182       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4183          Fortunately, we can structure things so that the extra work reduces
4184          to a noop on systems that do things "properly".  */
4185       value = (value >> 7) | ~(-(offsetT)1 >> 7);
4186
4187       more = !((((value == 0) && ((byte & 0x40) == 0))
4188                 || ((value == -1) && ((byte & 0x40) != 0))));
4189       if (more)
4190         byte |= 0x80;
4191
4192       *p++ = byte;
4193     }
4194   while (more);
4195
4196   return p - orig;
4197 }
4198
4199 static inline int
4200 output_uleb128 (p, value)
4201      char *p;
4202      valueT value;
4203 {
4204   char *orig = p;
4205
4206   do
4207     {
4208       unsigned byte = (value & 0x7f);
4209       value >>= 7;
4210       if (value != 0)
4211         /* More bytes to follow.  */
4212         byte |= 0x80;
4213
4214       *p++ = byte;
4215     }
4216   while (value != 0);
4217
4218   return p - orig;
4219 }
4220
4221 int
4222 output_leb128 (p, value, sign)
4223      char *p;
4224      valueT value;
4225      int sign;
4226 {
4227   if (sign)
4228     return output_sleb128 (p, (offsetT) value);
4229   else
4230     return output_uleb128 (p, value);
4231 }
4232
4233 /* Do the same for bignums.  We combine sizeof with output here in that
4234    we don't output for NULL values of P.  It isn't really as critical as
4235    for "normal" values that this be streamlined.  */
4236
4237 static inline int
4238 output_big_sleb128 (p, bignum, size)
4239      char *p;
4240      LITTLENUM_TYPE *bignum;
4241      int size;
4242 {
4243   char *orig = p;
4244   valueT val = 0;
4245   int loaded = 0;
4246   unsigned byte;
4247
4248   /* Strip leading sign extensions off the bignum.  */
4249   while (size > 0 && bignum[size-1] == (LITTLENUM_TYPE)-1)
4250     size--;
4251
4252   do
4253     {
4254       if (loaded < 7 && size > 0)
4255         {
4256           val |= (*bignum << loaded);
4257           loaded += 8 * CHARS_PER_LITTLENUM;
4258           size--;
4259           bignum++;
4260         }
4261
4262       byte = val & 0x7f;
4263       loaded -= 7;
4264       val >>= 7;
4265
4266       if (size == 0)
4267         {
4268           if ((val == 0 && (byte & 0x40) == 0)
4269               || (~(val | ~(((valueT)1 << loaded) - 1)) == 0
4270                   && (byte & 0x40) != 0))
4271             byte |= 0x80;
4272         }
4273
4274       if (orig)
4275         *p = byte;
4276       p++;
4277     }
4278   while (byte & 0x80);
4279
4280   return p - orig;
4281 }
4282
4283 static inline int
4284 output_big_uleb128 (p, bignum, size)
4285      char *p;
4286      LITTLENUM_TYPE *bignum;
4287      int size;
4288 {
4289   char *orig = p;
4290   valueT val = 0;
4291   int loaded = 0;
4292   unsigned byte;
4293
4294   /* Strip leading zeros off the bignum.  */
4295   /* XXX: Is this needed?  */
4296   while (size > 0 && bignum[size-1] == 0)
4297     size--;
4298
4299   do
4300     {
4301       if (loaded < 7 && size > 0)
4302         {
4303           val |= (*bignum << loaded);
4304           loaded += 8 * CHARS_PER_LITTLENUM;
4305           size--;
4306           bignum++;
4307         }
4308
4309       byte = val & 0x7f;
4310       loaded -= 7;
4311       val >>= 7;
4312
4313       if (size > 0 || val)
4314         byte |= 0x80;
4315
4316       if (orig)
4317         *p = byte;
4318       p++;
4319     }
4320   while (byte & 0x80);
4321
4322   return p - orig;
4323 }
4324
4325 static int
4326 output_big_leb128 (p, bignum, size, sign)
4327      char *p;
4328      LITTLENUM_TYPE *bignum;
4329      int size, sign;
4330 {
4331   if (sign)
4332     return output_big_sleb128 (p, bignum, size);
4333   else
4334     return output_big_uleb128 (p, bignum, size);
4335 }
4336
4337 /* Generate the appropriate fragments for a given expression to emit a
4338    leb128 value.  */
4339
4340 void
4341 emit_leb128_expr(exp, sign)
4342      expressionS *exp;
4343      int sign;
4344 {
4345   operatorT op = exp->X_op;
4346
4347   if (op == O_absent || op == O_illegal)
4348     {
4349       as_warn (_("zero assumed for missing expression"));
4350       exp->X_add_number = 0;
4351       op = O_constant;
4352     }
4353   else if (op == O_big && exp->X_add_number <= 0)
4354     {
4355       as_bad (_("floating point number invalid; zero assumed"));
4356       exp->X_add_number = 0;
4357       op = O_constant;
4358     }
4359   else if (op == O_register)
4360     {
4361       as_warn (_("register value used as expression"));
4362       op = O_constant;
4363     }
4364
4365   if (op == O_constant)
4366     {
4367       /* If we've got a constant, emit the thing directly right now.  */
4368
4369       valueT value = exp->X_add_number;
4370       int size;
4371       char *p;
4372
4373       size = sizeof_leb128 (value, sign);
4374       p = frag_more (size);
4375       output_leb128 (p, value, sign);
4376     }
4377   else if (op == O_big)
4378     {
4379       /* O_big is a different sort of constant.  */
4380
4381       int size;
4382       char *p;
4383
4384       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4385       p = frag_more (size);
4386       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4387     }
4388   else
4389     {
4390       /* Otherwise, we have to create a variable sized fragment and
4391          resolve things later.  */
4392
4393       frag_var (rs_leb128, sizeof_uleb128 (~(valueT)0), 0, sign,
4394                 make_expr_symbol (exp), 0, (char *) NULL);
4395     }
4396 }
4397
4398 /* Parse the .sleb128 and .uleb128 pseudos.  */
4399
4400 void
4401 s_leb128 (sign)
4402      int sign;
4403 {
4404   expressionS exp;
4405
4406   do {
4407     expression (&exp);
4408     emit_leb128_expr (&exp, sign);
4409   } while (*input_line_pointer++ == ',');
4410
4411   input_line_pointer--;
4412   demand_empty_rest_of_line ();
4413 }
4414 \f
4415 /*
4416  *                      stringer()
4417  *
4418  * We read 0 or more ',' separated, double-quoted strings.
4419  *
4420  * Caller should have checked need_pass_2 is FALSE because we don't check it.
4421  */
4422
4423
4424 void
4425 stringer (append_zero)          /* Worker to do .ascii etc statements. */
4426      /* Checks end-of-line. */
4427      register int append_zero;  /* 0: don't append '\0', else 1 */
4428 {
4429   register unsigned int c;
4430   char *start;
4431
4432 #ifdef md_flush_pending_output
4433   md_flush_pending_output ();
4434 #endif
4435
4436   /*
4437    * The following awkward logic is to parse ZERO or more strings,
4438    * comma separated. Recall a string expression includes spaces
4439    * before the opening '\"' and spaces after the closing '\"'.
4440    * We fake a leading ',' if there is (supposed to be)
4441    * a 1st, expression. We keep demanding expressions for each
4442    * ','.
4443    */
4444   if (is_it_end_of_statement ())
4445     {
4446       c = 0;                    /* Skip loop. */
4447       ++input_line_pointer;     /* Compensate for end of loop. */
4448     }
4449   else
4450     {
4451       c = ',';                  /* Do loop. */
4452     }
4453   while (c == ',' || c == '<' || c == '"')
4454     {
4455       SKIP_WHITESPACE ();
4456       switch (*input_line_pointer)
4457         {
4458         case '\"':
4459           ++input_line_pointer; /*->1st char of string. */
4460           start = input_line_pointer;
4461           while (is_a_char (c = next_char_of_string ()))
4462             {
4463               FRAG_APPEND_1_CHAR (c);
4464             }
4465           if (append_zero)
4466             {
4467               FRAG_APPEND_1_CHAR (0);
4468             }
4469           know (input_line_pointer[-1] == '\"');
4470
4471 #ifndef NO_LISTING
4472 #ifdef OBJ_ELF
4473           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4474              will emit .string with a filename in the .debug section
4475              after a sequence of constants.  See the comment in
4476              emit_expr for the sequence.  emit_expr will set
4477              dwarf_file_string to non-zero if this string might be a
4478              source file name.  */
4479           if (strcmp (segment_name (now_seg), ".debug") != 0)
4480             dwarf_file_string = 0;
4481           else if (dwarf_file_string)
4482             {
4483               c = input_line_pointer[-1];
4484               input_line_pointer[-1] = '\0';
4485               listing_source_file (start);
4486               input_line_pointer[-1] = c;
4487             }
4488 #endif
4489 #endif
4490
4491           break;
4492         case '<':
4493           input_line_pointer++;
4494           c = get_single_number ();
4495           FRAG_APPEND_1_CHAR (c);
4496           if (*input_line_pointer != '>')
4497             {
4498               as_bad (_("Expected <nn>"));
4499             }
4500           input_line_pointer++;
4501           break;
4502         case ',':
4503           input_line_pointer++;
4504           break;
4505         }
4506       SKIP_WHITESPACE ();
4507       c = *input_line_pointer;
4508     }
4509
4510   demand_empty_rest_of_line ();
4511 }                               /* stringer() */
4512 \f
4513 /* FIXME-SOMEDAY: I had trouble here on characters with the
4514     high bits set.  We'll probably also have trouble with
4515     multibyte chars, wide chars, etc.  Also be careful about
4516     returning values bigger than 1 byte.  xoxorich. */
4517
4518 unsigned int
4519 next_char_of_string ()
4520 {
4521   register unsigned int c;
4522
4523   c = *input_line_pointer++ & CHAR_MASK;
4524   switch (c)
4525     {
4526     case '\"':
4527       c = NOT_A_CHAR;
4528       break;
4529
4530     case '\n':
4531       as_warn (_("Unterminated string: Newline inserted."));
4532       bump_line_counters ();
4533       break;
4534
4535 #ifndef NO_STRING_ESCAPES
4536     case '\\':
4537       switch (c = *input_line_pointer++)
4538         {
4539         case 'b':
4540           c = '\b';
4541           break;
4542
4543         case 'f':
4544           c = '\f';
4545           break;
4546
4547         case 'n':
4548           c = '\n';
4549           break;
4550
4551         case 'r':
4552           c = '\r';
4553           break;
4554
4555         case 't':
4556           c = '\t';
4557           break;
4558
4559         case 'v':
4560           c = '\013';
4561           break;
4562
4563         case '\\':
4564         case '"':
4565           break;                /* As itself. */
4566
4567         case '0':
4568         case '1':
4569         case '2':
4570         case '3':
4571         case '4':
4572         case '5':
4573         case '6':
4574         case '7':
4575         case '8':
4576         case '9':
4577           {
4578             long number;
4579             int i;
4580
4581             for (i = 0, number = 0; isdigit (c) && i < 3; c = *input_line_pointer++, i++)
4582               {
4583                 number = number * 8 + c - '0';
4584               }
4585             c = number & 0xff;
4586           }
4587           --input_line_pointer;
4588           break;
4589
4590         case 'x':
4591         case 'X':
4592           {
4593             long number;
4594
4595             number = 0;
4596             c = *input_line_pointer++;
4597             while (isxdigit (c))
4598               {
4599                 if (isdigit (c))
4600                   number = number * 16 + c - '0';
4601                 else if (isupper (c))
4602                   number = number * 16 + c - 'A' + 10;
4603                 else
4604                   number = number * 16 + c - 'a' + 10;
4605                 c = *input_line_pointer++;
4606               }
4607             c = number & 0xff;
4608             --input_line_pointer;
4609           }
4610           break;
4611
4612         case '\n':
4613           /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4614           as_warn (_("Unterminated string: Newline inserted."));
4615           c = '\n';
4616           bump_line_counters ();
4617           break;
4618
4619         default:
4620
4621 #ifdef ONLY_STANDARD_ESCAPES
4622           as_bad (_("Bad escaped character in string, '?' assumed"));
4623           c = '?';
4624 #endif /* ONLY_STANDARD_ESCAPES */
4625
4626           break;
4627         }                       /* switch on escaped char */
4628       break;
4629 #endif /* ! defined (NO_STRING_ESCAPES) */
4630
4631     default:
4632       break;
4633     }                           /* switch on char */
4634   return (c);
4635 }                               /* next_char_of_string() */
4636 \f
4637 static segT
4638 get_segmented_expression (expP)
4639      register expressionS *expP;
4640 {
4641   register segT retval;
4642
4643   retval = expression (expP);
4644   if (expP->X_op == O_illegal
4645       || expP->X_op == O_absent
4646       || expP->X_op == O_big)
4647     {
4648       as_bad (_("expected address expression; zero assumed"));
4649       expP->X_op = O_constant;
4650       expP->X_add_number = 0;
4651       retval = absolute_section;
4652     }
4653   return retval;
4654 }
4655
4656 static segT
4657 get_known_segmented_expression (expP)
4658      register expressionS *expP;
4659 {
4660   register segT retval;
4661
4662   if ((retval = get_segmented_expression (expP)) == undefined_section)
4663     {
4664       /* There is no easy way to extract the undefined symbol from the
4665          expression.  */
4666       if (expP->X_add_symbol != NULL
4667           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4668         as_warn (_("symbol \"%s\" undefined; zero assumed"),
4669                  S_GET_NAME (expP->X_add_symbol));
4670       else
4671         as_warn (_("some symbol undefined; zero assumed"));
4672       retval = absolute_section;
4673       expP->X_op = O_constant;
4674       expP->X_add_number = 0;
4675     }
4676   know (retval == absolute_section || SEG_NORMAL (retval));
4677   return (retval);
4678 }                               /* get_known_segmented_expression() */
4679
4680 offsetT
4681 get_absolute_expression ()
4682 {
4683   expressionS exp;
4684
4685   expression (&exp);
4686   if (exp.X_op != O_constant)
4687     {
4688       if (exp.X_op != O_absent)
4689         as_bad (_("bad or irreducible absolute expression; zero assumed"));
4690       exp.X_add_number = 0;
4691     }
4692   return exp.X_add_number;
4693 }
4694
4695 char                            /* return terminator */
4696 get_absolute_expression_and_terminator (val_pointer)
4697      long *val_pointer;         /* return value of expression */
4698 {
4699   /* FIXME: val_pointer should probably be offsetT *.  */
4700   *val_pointer = (long) get_absolute_expression ();
4701   return (*input_line_pointer++);
4702 }
4703 \f
4704 /*
4705  *                      demand_copy_C_string()
4706  *
4707  * Like demand_copy_string, but return NULL if the string contains any '\0's.
4708  * Give a warning if that happens.
4709  */
4710 char *
4711 demand_copy_C_string (len_pointer)
4712      int *len_pointer;
4713 {
4714   register char *s;
4715
4716   if ((s = demand_copy_string (len_pointer)) != 0)
4717     {
4718       register int len;
4719
4720       for (len = *len_pointer; len > 0; len--)
4721         {
4722           if (*s == 0)
4723             {
4724               s = 0;
4725               len = 1;
4726               *len_pointer = 0;
4727               as_bad (_("This string may not contain \'\\0\'"));
4728             }
4729         }
4730     }
4731   return s;
4732 }
4733 \f
4734 /*
4735  *                      demand_copy_string()
4736  *
4737  * Demand string, but return a safe (=private) copy of the string.
4738  * Return NULL if we can't read a string here.
4739  */
4740 char *
4741 demand_copy_string (lenP)
4742      int *lenP;
4743 {
4744   register unsigned int c;
4745   register int len;
4746   char *retval;
4747
4748   len = 0;
4749   SKIP_WHITESPACE ();
4750   if (*input_line_pointer == '\"')
4751     {
4752       input_line_pointer++;     /* Skip opening quote. */
4753
4754       while (is_a_char (c = next_char_of_string ()))
4755         {
4756           obstack_1grow (&notes, c);
4757           len++;
4758         }
4759       /* JF this next line is so demand_copy_C_string will return a
4760          null terminated string. */
4761       obstack_1grow (&notes, '\0');
4762       retval = obstack_finish (&notes);
4763     }
4764   else
4765     {
4766       as_warn (_("Missing string"));
4767       retval = NULL;
4768       ignore_rest_of_line ();
4769     }
4770   *lenP = len;
4771   return (retval);
4772 }                               /* demand_copy_string() */
4773 \f
4774 /*
4775  *              is_it_end_of_statement()
4776  *
4777  * In:  Input_line_pointer->next character.
4778  *
4779  * Do:  Skip input_line_pointer over all whitespace.
4780  *
4781  * Out: 1 if input_line_pointer->end-of-line.
4782 */
4783 int
4784 is_it_end_of_statement ()
4785 {
4786   SKIP_WHITESPACE ();
4787   return (is_end_of_line[(unsigned char) *input_line_pointer]);
4788 }                               /* is_it_end_of_statement() */
4789
4790 void
4791 equals (sym_name, reassign)
4792      char *sym_name;
4793      int reassign;
4794 {
4795   register symbolS *symbolP;    /* symbol we are working with */
4796   char *stop = NULL;
4797   char stopc;
4798
4799   input_line_pointer++;
4800   if (*input_line_pointer == '=')
4801     input_line_pointer++;
4802
4803   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4804     input_line_pointer++;
4805
4806   if (flag_mri)
4807     stop = mri_comment_field (&stopc);
4808
4809   if (sym_name[0] == '.' && sym_name[1] == '\0')
4810     {
4811       /* Turn '. = mumble' into a .org mumble */
4812       register segT segment;
4813       expressionS exp;
4814
4815       segment = get_known_segmented_expression (&exp);
4816       if (!need_pass_2)
4817         do_org (segment, &exp, 0);
4818     }
4819   else
4820     {
4821       symbolP = symbol_find_or_make (sym_name);
4822       /* Permit register names to be redefined.  */
4823       if (! reassign
4824           && S_IS_DEFINED (symbolP)
4825           && S_GET_SEGMENT (symbolP) != reg_section)
4826         as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
4827       pseudo_set (symbolP);
4828     }
4829
4830   if (flag_mri)
4831      {
4832        ignore_rest_of_line (); /* check garbage after the expression */
4833        mri_comment_end (stop, stopc);
4834      }
4835 }                               /* equals() */
4836
4837 /* .include -- include a file at this point. */
4838
4839 /* ARGSUSED */
4840 void
4841 s_include (arg)
4842      int arg ATTRIBUTE_UNUSED;
4843 {
4844   char *newbuf;
4845   char *filename;
4846   int i;
4847   FILE *try;
4848   char *path;
4849
4850   if (! flag_m68k_mri)
4851     {
4852       filename = demand_copy_string (&i);
4853       if (filename == NULL)
4854         {
4855           /* demand_copy_string has already printed an error and
4856              called ignore_rest_of_line.  */
4857           return;
4858         }
4859     }
4860   else
4861     {
4862       SKIP_WHITESPACE ();
4863       i = 0;
4864       while (! is_end_of_line[(unsigned char) *input_line_pointer]
4865              && *input_line_pointer != ' '
4866              && *input_line_pointer != '\t')
4867         {
4868           obstack_1grow (&notes, *input_line_pointer);
4869           ++input_line_pointer;
4870           ++i;
4871         }
4872       obstack_1grow (&notes, '\0');
4873       filename = obstack_finish (&notes);
4874       while (! is_end_of_line[(unsigned char) *input_line_pointer])
4875         ++input_line_pointer;
4876     }
4877   demand_empty_rest_of_line ();
4878   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4879   for (i = 0; i < include_dir_count; i++)
4880     {
4881       strcpy (path, include_dirs[i]);
4882       strcat (path, "/");
4883       strcat (path, filename);
4884       if (0 != (try = fopen (path, "r")))
4885         {
4886           fclose (try);
4887           goto gotit;
4888         }
4889     }
4890   free (path);
4891   path = filename;
4892 gotit:
4893   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY. */
4894   register_dependency (path);
4895   newbuf = input_scrub_include_file (path, input_line_pointer);
4896   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
4897 }                               /* s_include() */
4898
4899 void
4900 add_include_dir (path)
4901      char *path;
4902 {
4903   int i;
4904
4905   if (include_dir_count == 0)
4906     {
4907       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4908       include_dirs[0] = ".";    /* Current dir */
4909       include_dir_count = 2;
4910     }
4911   else
4912     {
4913       include_dir_count++;
4914       include_dirs = (char **) realloc (include_dirs,
4915                                 include_dir_count * sizeof (*include_dirs));
4916     }
4917
4918   include_dirs[include_dir_count - 1] = path;   /* New one */
4919
4920   i = strlen (path);
4921   if (i > include_dir_maxlen)
4922     include_dir_maxlen = i;
4923 }                               /* add_include_dir() */
4924 \f
4925 /* Output debugging information to denote the source file.  */
4926
4927 static void
4928 generate_file_debug ()
4929 {
4930   if (debug_type == DEBUG_STABS)
4931     stabs_generate_asm_file ();
4932 }
4933
4934 /* Output line number debugging information for the current source line.  */
4935
4936 void
4937 generate_lineno_debug ()
4938 {
4939 #ifdef ECOFF_DEBUGGING
4940   /* ECOFF assemblers automatically generate debugging information.
4941      FIXME: This should probably be handled elsewhere.  */
4942   if (debug_type == DEBUG_UNSPECIFIED)
4943     {
4944       if (ECOFF_DEBUGGING && ecoff_no_current_file ())
4945         debug_type = DEBUG_ECOFF;
4946       else
4947         debug_type = DEBUG_NONE;
4948     }
4949 #endif
4950
4951   switch (debug_type)
4952     {
4953     case DEBUG_UNSPECIFIED:
4954     case DEBUG_NONE:
4955       break;
4956     case DEBUG_STABS:
4957       stabs_generate_asm_lineno ();
4958       break;
4959     case DEBUG_ECOFF:
4960       ecoff_generate_asm_lineno ();
4961       break;
4962     case DEBUG_DWARF:
4963     case DEBUG_DWARF2:
4964       /* FIXME.  */
4965       break;
4966     }
4967 }
4968
4969 /* Output debugging information to mark a function entry point or end point.
4970    END_P is zero for .func, and non-zero for .endfunc.  */
4971
4972 void
4973 s_func (end_p)
4974      int end_p;
4975 {
4976   do_s_func (end_p, NULL);
4977 }
4978
4979 /* Subroutine of s_func so targets can choose a different default prefix.
4980    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
4981
4982 void
4983 do_s_func (end_p, default_prefix)
4984      int end_p;
4985      const char *default_prefix;
4986 {
4987   /* Record the current function so that we can issue an error message for
4988      misplaced .func,.endfunc, and also so that .endfunc needs no
4989      arguments.  */
4990   static char *current_name;
4991   static char *current_label;
4992
4993   if (end_p)
4994     {
4995       if (current_name == NULL)
4996         {
4997           as_bad (_("missing .func"));
4998           ignore_rest_of_line ();
4999           return;
5000         }
5001
5002       if (debug_type == DEBUG_STABS)
5003         stabs_generate_asm_endfunc (current_name, current_label);
5004
5005       current_name = current_label = NULL;
5006     }
5007   else /* ! end_p */
5008     {
5009       char *name,*label;
5010       char delim1,delim2;
5011
5012       if (current_name != NULL)
5013         {
5014           as_bad (_(".endfunc missing for previous .func"));
5015           ignore_rest_of_line ();
5016           return;
5017         }
5018
5019       name = input_line_pointer;
5020       delim1 = get_symbol_end ();
5021       name = xstrdup (name);
5022       *input_line_pointer = delim1;
5023       SKIP_WHITESPACE ();
5024       if (*input_line_pointer != ',')
5025         {
5026           if (default_prefix)
5027             asprintf (&label, "%s%s", default_prefix, name);
5028           else
5029             {
5030               char leading_char = 0;
5031 #ifdef BFD_ASSEMBLER
5032               leading_char = bfd_get_symbol_leading_char (stdoutput);
5033 #endif
5034               /* Missing entry point, use function's name with the leading
5035                  char prepended.  */
5036               if (leading_char)
5037                 asprintf (&label, "%c%s", leading_char, name);
5038               else
5039                 label = name;
5040             }
5041         }
5042       else
5043         {
5044           ++input_line_pointer;
5045           SKIP_WHITESPACE ();
5046           label = input_line_pointer;
5047           delim2 = get_symbol_end ();
5048           label = xstrdup (label);
5049           *input_line_pointer = delim2;
5050         }
5051
5052       if (debug_type == DEBUG_STABS)
5053         stabs_generate_asm_func (name, label);
5054
5055       current_name = name;
5056       current_label = label;
5057     }
5058
5059   demand_empty_rest_of_line ();
5060 }
5061 \f
5062 void
5063 s_ignore (arg)
5064      int arg ATTRIBUTE_UNUSED;
5065 {
5066   while (!is_end_of_line[(unsigned char) *input_line_pointer])
5067     {
5068       ++input_line_pointer;
5069     }
5070   ++input_line_pointer;
5071 }
5072
5073
5074 void
5075 read_print_statistics (file)
5076      FILE *file;
5077 {
5078   hash_print_statistics (file, "pseudo-op table", po_hash);
5079 }
5080
5081 /* end of read.c */