gas/read.c

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