gas/read.c

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