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