gas/read.c

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