gas/read.c

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