1 /* read.c - read a source file -
2    Copyright (C) 1986-2016 Free Software Foundation, Inc.
3 
4    This file is part of GAS, the GNU Assembler.
5 
6    GAS is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3, or (at your option)
9    any later version.
10 
11    GAS is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15 
16    You should have received a copy of the GNU General Public License
17    along with GAS; see the file COPYING.  If not, write to the Free
18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19    02110-1301, USA.  */
20 
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22    But then, GNU isn't spozed to run on your machine anyway.
23    (RMS is so shortsighted sometimes.)  */
24 #define MASK_CHAR ((int)(unsigned char) -1)
25 
26 /* This is the largest known floating point format (for now). It will
27    grow when we do 4361 style flonums.  */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
29 
30 /* Routines that read assembler source text to build spaghetti in memory.
31    Another group of these functions is in the expr.c module.  */
32 
33 #include "as.h"
34 #include "safe-ctype.h"
35 #include "subsegs.h"
36 #include "sb.h"
37 #include "macro.h"
38 #include "obstack.h"
39 #include "ecoff.h"
40 #include "dw2gencfi.h"
41 #include "wchar.h"
42 
43 #ifndef TC_START_LABEL
44 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
45 #endif
46 
47 /* Set by the object-format or the target.  */
48 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
49 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)		\
50   do								\
51     {								\
52       if ((SIZE) >= 8)						\
53 	(P2VAR) = 3;						\
54       else if ((SIZE) >= 4)					\
55 	(P2VAR) = 2;						\
56       else if ((SIZE) >= 2)					\
57 	(P2VAR) = 1;						\
58       else							\
59 	(P2VAR) = 0;						\
60     }								\
61   while (0)
62 #endif
63 
64 char *input_line_pointer;	/*->next char of source file to parse.  */
65 
66 #if BITS_PER_CHAR != 8
67 /*  The following table is indexed by[(char)] and will break if
68     a char does not have exactly 256 states (hopefully 0:255!)!  */
69 die horribly;
70 #endif
71 
72 #ifndef LEX_AT
73 #define LEX_AT 0
74 #endif
75 
76 #ifndef LEX_BR
77 /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
78 #define LEX_BR 0
79 #endif
80 
81 #ifndef LEX_PCT
82 /* The Delta 68k assembler permits % inside label names.  */
83 #define LEX_PCT 0
84 #endif
85 
86 #ifndef LEX_QM
87 /* The PowerPC Windows NT assemblers permits ? inside label names.  */
88 #define LEX_QM 0
89 #endif
90 
91 #ifndef LEX_HASH
92 /* The IA-64 assembler uses # as a suffix designating a symbol.  We include
93    it in the symbol and strip it out in tc_canonicalize_symbol_name.  */
94 #define LEX_HASH 0
95 #endif
96 
97 #ifndef LEX_DOLLAR
98 #define LEX_DOLLAR 3
99 #endif
100 
101 #ifndef LEX_TILDE
102 /* The Delta 68k assembler permits ~ at start of label names.  */
103 #define LEX_TILDE 0
104 #endif
105 
106 /* Used by is_... macros. our ctype[].  */
107 char lex_type[256] = {
108   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* @ABCDEFGHIJKLMNO */
109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ[\]^_ */
110   0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
111   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,	/* 0123456789:;<=>? */
112   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	/* @ABCDEFGHIJKLMNO */
113   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
114   0, 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, LEX_TILDE, 0, /* pqrstuvwxyz{|}~.  */
116   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
117   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
124 };
125 
126 /* In: a character.
127    Out: 1 if this character ends a line.
128 	2 if this character is a line separator.  */
129 char is_end_of_line[256] = {
130 #ifdef CR_EOL
131   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,	/* @abcdefghijklmno */
132 #else
133   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,	/* @abcdefghijklmno */
134 #endif
135   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* */
136   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* _!"#$%&'()*+,-./ */
137   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0123456789:;<=>? */
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,	/* */
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 };
151 
152 #ifndef TC_CASE_SENSITIVE
153 char original_case_string[128];
154 #endif
155 
156 /* Functions private to this file.  */
157 
158 static char *buffer;	/* 1st char of each buffer of lines is here.  */
159 static char *buffer_limit;	/*->1 + last char in buffer.  */
160 
161 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
162    in the tc-<CPU>.h file.  See the "Porting GAS" section of the
163    internals manual.  */
164 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
165 
166 /* Variables for handling include file directory table.  */
167 
168 /* Table of pointers to directories to search for .include's.  */
169 const char **include_dirs;
170 
171 /* How many are in the table.  */
172 int include_dir_count;
173 
174 /* Length of longest in table.  */
175 int include_dir_maxlen = 1;
176 
177 #ifndef WORKING_DOT_WORD
178 struct broken_word *broken_words;
179 int new_broken_words;
180 #endif
181 
182 /* The current offset into the absolute section.  We don't try to
183    build frags in the absolute section, since no data can be stored
184    there.  We just keep track of the current offset.  */
185 addressT abs_section_offset;
186 
187 /* If this line had an MRI style label, it is stored in this variable.
188    This is used by some of the MRI pseudo-ops.  */
189 symbolS *line_label;
190 
191 /* This global variable is used to support MRI common sections.  We
192    translate such sections into a common symbol.  This variable is
193    non-NULL when we are in an MRI common section.  */
194 symbolS *mri_common_symbol;
195 
196 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
197    need to align to an even byte boundary unless the next pseudo-op is
198    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
199    may be needed.  */
200 static int mri_pending_align;
201 
202 #ifndef NO_LISTING
203 #ifdef OBJ_ELF
204 /* This variable is set to be non-zero if the next string we see might
205    be the name of the source file in DWARF debugging information.  See
206    the comment in emit_expr for the format we look for.  */
207 static int dwarf_file_string;
208 #endif
209 #endif
210 
211 /* If the target defines the md_frag_max_var hook then we know
212    enough to implement the .bundle_align_mode features.  */
213 #ifdef md_frag_max_var
214 # define HANDLE_BUNDLE
215 #endif
216 
217 #ifdef HANDLE_BUNDLE
218 /* .bundle_align_mode sets this.  Normally it's zero.  When nonzero,
219    it's the exponent of the bundle size, and aligned instruction bundle
220    mode is in effect.  */
221 static unsigned int bundle_align_p2;
222 
223 /* These are set by .bundle_lock and .bundle_unlock.  .bundle_lock sets
224    bundle_lock_frag to frag_now and then starts a new frag with
225    frag_align_code.  At the same time, bundle_lock_frain gets frchain_now,
226    so that .bundle_unlock can verify that we didn't change segments.
227    .bundle_unlock resets both to NULL.  If we detect a bundling violation,
228    then we reset bundle_lock_frchain to NULL as an indicator that we've
229    already diagnosed the error with as_bad and don't need a cascade of
230    redundant errors, but bundle_lock_frag remains set to indicate that
231    we are expecting to see .bundle_unlock.  */
232 static fragS *bundle_lock_frag;
233 static frchainS *bundle_lock_frchain;
234 
235 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
236    to allow nesting.  */
237 static unsigned int bundle_lock_depth;
238 #endif
239 
240 static void do_s_func (int end_p, const char *default_prefix);
241 static void s_align (int, int);
242 static void s_altmacro (int);
243 static void s_bad_end (int);
244 static void s_reloc (int);
245 static int hex_float (int, char *);
246 static segT get_known_segmented_expression (expressionS * expP);
247 static void pobegin (void);
248 static size_t get_non_macro_line_sb (sb *);
249 static void generate_file_debug (void);
250 static char *_find_end_of_line (char *, int, int, int);
251 
252 void
read_begin(void)253 read_begin (void)
254 {
255   const char *p;
256 
257   pobegin ();
258   obj_read_begin_hook ();
259 
260   /* Something close -- but not too close -- to a multiple of 1024.
261      The debugging malloc I'm using has 24 bytes of overhead.  */
262   obstack_begin (&notes, chunksize);
263   obstack_begin (&cond_obstack, chunksize);
264 
265 #ifndef tc_line_separator_chars
266 #define tc_line_separator_chars line_separator_chars
267 #endif
268   /* Use machine dependent syntax.  */
269   for (p = tc_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 
277 #ifndef TC_ADDRESS_BYTES
278 #define TC_ADDRESS_BYTES address_bytes
279 
280 static inline int
address_bytes(void)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
get_absolute_expr(expressionS * exp)486 get_absolute_expr (expressionS *exp)
487 {
488   expression_and_evaluate (exp);
489 
490   if (exp->X_op != O_constant)
491     {
492       if (exp->X_op != O_absent)
493 	as_bad (_("bad or irreducible absolute expression"));
494       exp->X_add_number = 0;
495     }
496   return exp->X_add_number;
497 }
498 
499 offsetT
get_absolute_expression(void)500 get_absolute_expression (void)
501 {
502   expressionS exp;
503 
504   return get_absolute_expr (&exp);
505 }
506 
507 static int pop_override_ok = 0;
508 static const char *pop_table_name;
509 
510 void
pop_insert(const pseudo_typeS * table)511 pop_insert (const pseudo_typeS *table)
512 {
513   const char *errtxt;
514   const pseudo_typeS *pop;
515   for (pop = table; pop->poc_name; pop++)
516     {
517       errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
518       if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
519 	as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
520 		  errtxt);
521     }
522 }
523 
524 #ifndef md_pop_insert
525 #define md_pop_insert()		pop_insert(md_pseudo_table)
526 #endif
527 
528 #ifndef obj_pop_insert
529 #define obj_pop_insert()	pop_insert(obj_pseudo_table)
530 #endif
531 
532 #ifndef cfi_pop_insert
533 #define cfi_pop_insert()	pop_insert(cfi_pseudo_table)
534 #endif
535 
536 static void
pobegin(void)537 pobegin (void)
538 {
539   po_hash = hash_new ();
540 
541   /* Do the target-specific pseudo ops.  */
542   pop_table_name = "md";
543   md_pop_insert ();
544 
545   /* Now object specific.  Skip any that were in the target table.  */
546   pop_table_name = "obj";
547   pop_override_ok = 1;
548   obj_pop_insert ();
549 
550   /* Now portable ones.  Skip any that we've seen already.  */
551   pop_table_name = "standard";
552   pop_insert (potable);
553 
554   /* Now CFI ones.  */
555   pop_table_name = "cfi";
556   pop_override_ok = 1;
557   cfi_pop_insert ();
558 }
559 
560 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read)				\
561   if (ignore_input ())							\
562     {									\
563       char *eol = find_end_of_line (input_line_pointer - (num_read),	\
564 				    flag_m68k_mri);			\
565       input_line_pointer = (input_line_pointer <= buffer_limit		\
566 			    && eol >= buffer_limit)			\
567 			   ? buffer_limit				\
568 			   : eol + 1;					\
569       continue;								\
570     }
571 
572 /* This function is used when scrubbing the characters between #APP
573    and #NO_APP.  */
574 
575 static char *scrub_string;
576 static char *scrub_string_end;
577 
578 static size_t
scrub_from_string(char * buf,size_t buflen)579 scrub_from_string (char *buf, size_t buflen)
580 {
581   size_t copy;
582 
583   copy = scrub_string_end - scrub_string;
584   if (copy > buflen)
585     copy = buflen;
586   memcpy (buf, scrub_string, copy);
587   scrub_string += copy;
588   return copy;
589 }
590 
591 /* Helper function of read_a_source_file, which tries to expand a macro.  */
592 static int
try_macro(char term,const char * line)593 try_macro (char term, const char *line)
594 {
595   sb out;
596   const char *err;
597   macro_entry *macro;
598 
599   if (check_macro (line, &out, &err, &macro))
600     {
601       if (err != NULL)
602 	as_bad ("%s", err);
603       *input_line_pointer++ = term;
604       input_scrub_include_sb (&out,
605 			      input_line_pointer, 1);
606       sb_kill (&out);
607       buffer_limit =
608 	input_scrub_next_buffer (&input_line_pointer);
609 #ifdef md_macro_info
610       md_macro_info (macro);
611 #endif
612       return 1;
613     }
614   return 0;
615 }
616 
617 #ifdef HANDLE_BUNDLE
618 /* Start a new instruction bundle.  Returns the rs_align_code frag that
619    will be used to align the new bundle.  */
620 static fragS *
start_bundle(void)621 start_bundle (void)
622 {
623   fragS *frag = frag_now;
624 
625   frag_align_code (0, 0);
626 
627   while (frag->fr_type != rs_align_code)
628     frag = frag->fr_next;
629 
630   gas_assert (frag != frag_now);
631 
632   return frag;
633 }
634 
635 /* Calculate the maximum size after relaxation of the region starting
636    at the given frag and extending through frag_now (which is unfinished).  */
637 static unsigned int
pending_bundle_size(fragS * frag)638 pending_bundle_size (fragS *frag)
639 {
640   unsigned int offset = frag->fr_fix;
641   unsigned int size = 0;
642 
643   gas_assert (frag != frag_now);
644   gas_assert (frag->fr_type == rs_align_code);
645 
646   while (frag != frag_now)
647     {
648       /* This should only happen in what will later become an error case.  */
649       if (frag == NULL)
650 	return 0;
651 
652       size += frag->fr_fix;
653       if (frag->fr_type == rs_machine_dependent)
654 	size += md_frag_max_var (frag);
655 
656       frag = frag->fr_next;
657     }
658 
659   gas_assert (frag == frag_now);
660   size += frag_now_fix ();
661   if (frag->fr_type == rs_machine_dependent)
662     size += md_frag_max_var (frag);
663 
664   gas_assert (size >= offset);
665 
666   return size - offset;
667 }
668 
669 /* Finish off the frag created to ensure bundle alignment.  */
670 static void
finish_bundle(fragS * frag,unsigned int size)671 finish_bundle (fragS *frag, unsigned int size)
672 {
673   gas_assert (bundle_align_p2 > 0);
674   gas_assert (frag->fr_type == rs_align_code);
675 
676   if (size > 1)
677     {
678       /* If there is more than a single byte, then we need to set up the
679 	 alignment frag.  Otherwise we leave it at its initial state from
680 	 calling frag_align_code (0, 0), so that it does nothing.  */
681       frag->fr_offset = bundle_align_p2;
682       frag->fr_subtype = size - 1;
683     }
684 
685   /* We do this every time rather than just in s_bundle_align_mode
686      so that we catch any affected section without needing hooks all
687      over for all paths that do section changes.  It's cheap enough.  */
688   if (bundle_align_p2 > OCTETS_PER_BYTE_POWER)
689     record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER);
690 }
691 
692 /* Assemble one instruction.  This takes care of the bundle features
693    around calling md_assemble.  */
694 static void
assemble_one(char * line)695 assemble_one (char *line)
696 {
697   fragS *insn_start_frag = NULL;
698 
699   if (bundle_lock_frchain != NULL && bundle_lock_frchain != frchain_now)
700     {
701       as_bad (_("cannot change section or subsection inside .bundle_lock"));
702       /* Clearing this serves as a marker that we have already complained.  */
703       bundle_lock_frchain = NULL;
704     }
705 
706   if (bundle_lock_frchain == NULL && bundle_align_p2 > 0)
707     insn_start_frag = start_bundle ();
708 
709   md_assemble (line);
710 
711   if (bundle_lock_frchain != NULL)
712     {
713       /* Make sure this hasn't pushed the locked sequence
714 	 past the bundle size.  */
715       unsigned int bundle_size = pending_bundle_size (bundle_lock_frag);
716       if (bundle_size > (1U << bundle_align_p2))
717 	as_bad (_("\
718 .bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"),
719 		bundle_size, 1U << bundle_align_p2);
720     }
721   else if (bundle_align_p2 > 0)
722     {
723       unsigned int insn_size = pending_bundle_size (insn_start_frag);
724 
725       if (insn_size > (1U << bundle_align_p2))
726 	as_bad (_("\
727 single instruction is %u bytes long but .bundle_align_mode limit is %u"),
728 		(unsigned int) insn_size, 1U << bundle_align_p2);
729 
730       finish_bundle (insn_start_frag, insn_size);
731     }
732 }
733 
734 #else  /* !HANDLE_BUNDLE */
735 
736 # define assemble_one(line) md_assemble(line)
737 
738 #endif  /* HANDLE_BUNDLE */
739 
740 static bfd_boolean
in_bss(void)741 in_bss (void)
742 {
743   flagword flags = bfd_get_section_flags (stdoutput, now_seg);
744 
745   return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS));
746 }
747 
748 /* Guts of .align directive:
749    N is the power of two to which to align.  A value of zero is accepted but
750     ignored: the default alignment of the section will be at least this.
751    FILL may be NULL, or it may point to the bytes of the fill pattern.
752    LEN is the length of whatever FILL points to, if anything.  If LEN is zero
753     but FILL is not NULL then LEN is treated as if it were one.
754    MAX is the maximum number of characters to skip when doing the alignment,
755     or 0 if there is no maximum.  */
756 
757 void
do_align(unsigned int n,char * fill,unsigned int len,unsigned int max)758 do_align (unsigned int n, char *fill, unsigned int len, unsigned int max)
759 {
760   if (now_seg == absolute_section || in_bss ())
761     {
762       if (fill != NULL)
763 	while (len-- > 0)
764 	  if (*fill++ != '\0')
765 	    {
766 	      if (now_seg == absolute_section)
767 		as_warn (_("ignoring fill value in absolute section"));
768 	      else
769 		as_warn (_("ignoring fill value in section `%s'"),
770 			 segment_name (now_seg));
771 	      break;
772 	    }
773       fill = NULL;
774       len = 0;
775     }
776 
777 #ifdef md_flush_pending_output
778   md_flush_pending_output ();
779 #endif
780 
781 #ifdef md_do_align
782   md_do_align (n, fill, len, max, just_record_alignment);
783 #endif
784 
785   /* Only make a frag if we HAVE to...  */
786   if ((n > OCTETS_PER_BYTE_POWER) && !need_pass_2)
787     {
788       if (fill == NULL)
789 	{
790 	  if (subseg_text_p (now_seg))
791 	    frag_align_code (n, max);
792 	  else
793 	    frag_align (n, 0, max);
794 	}
795       else if (len <= 1)
796 	frag_align (n, *fill, max);
797       else
798 	frag_align_pattern (n, fill, len, max);
799     }
800 
801 #ifdef md_do_align
802  just_record_alignment: ATTRIBUTE_UNUSED_LABEL
803 #endif
804 
805   if (n > OCTETS_PER_BYTE_POWER)
806     record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
807 }
808 
809 /* We read the file, putting things into a web that represents what we
810    have been reading.  */
811 void
read_a_source_file(const char * name)812 read_a_source_file (const char *name)
813 {
814   char nul_char;
815   char next_char;
816   char *s;		/* String of symbol, '\0' appended.  */
817   int temp;
818   pseudo_typeS *pop;
819 
820 #ifdef WARN_COMMENTS
821   found_comment = 0;
822 #endif
823 
824   buffer = input_scrub_new_file (name);
825 
826   listing_file (name);
827   listing_newline (NULL);
828   register_dependency (name);
829 
830   /* Generate debugging information before we've read anything in to denote
831      this file as the "main" source file and not a subordinate one
832      (e.g. N_SO vs N_SOL in stabs).  */
833   generate_file_debug ();
834 
835   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
836     {				/* We have another line to parse.  */
837 #ifndef NO_LISTING
838       /* In order to avoid listing macro expansion lines with labels
839 	 multiple times, keep track of which line was last issued.  */
840       static char *last_eol;
841 
842       last_eol = NULL;
843 #endif
844       while (input_line_pointer < buffer_limit)
845 	{
846 	  bfd_boolean was_new_line;
847 	  /* We have more of this buffer to parse.  */
848 
849 	  /* We now have input_line_pointer->1st char of next line.
850 	     If input_line_pointer [-1] == '\n' then we just
851 	     scanned another line: so bump line counters.  */
852 	  was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
853 	  if (was_new_line)
854 	    {
855 	      symbol_set_value_now (&dot_symbol);
856 #ifdef md_start_line_hook
857 	      md_start_line_hook ();
858 #endif
859 	      if (input_line_pointer[-1] == '\n')
860 		bump_line_counters ();
861 	    }
862 
863 #ifndef NO_LISTING
864 	  /* If listing is on, and we are expanding a macro, then give
865 	     the listing code the contents of the expanded line.  */
866 	  if (listing)
867 	    {
868 	      if ((listing & LISTING_MACEXP) && macro_nest > 0)
869 		{
870 		  /* Find the end of the current expanded macro line.  */
871 		  s = find_end_of_line (input_line_pointer, flag_m68k_mri);
872 
873 		  if (s != last_eol)
874 		    {
875 		      char *copy;
876 		      int len;
877 
878 		      last_eol = s;
879 		      /* Copy it for safe keeping.  Also give an indication of
880 			 how much macro nesting is involved at this point.  */
881 		      len = s - input_line_pointer;
882 		      copy = XNEWVEC (char, len + macro_nest + 2);
883 		      memset (copy, '>', macro_nest);
884 		      copy[macro_nest] = ' ';
885 		      memcpy (copy + macro_nest + 1, input_line_pointer, len);
886 		      copy[macro_nest + 1 + len] = '\0';
887 
888 		      /* Install the line with the listing facility.  */
889 		      listing_newline (copy);
890 		    }
891 		}
892 	      else
893 		listing_newline (NULL);
894 	    }
895 #endif
896 	  if (was_new_line)
897 	    {
898 	      line_label = NULL;
899 
900 	      if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
901 		{
902 		  next_char = * input_line_pointer;
903 		  /* Text at the start of a line must be a label, we
904 		     run down and stick a colon in.  */
905 		  if (is_name_beginner (next_char) || next_char == '"')
906 		    {
907 		      char *line_start;
908 		      int mri_line_macro;
909 
910 		      HANDLE_CONDITIONAL_ASSEMBLY (0);
911 
912 		      nul_char = get_symbol_name (& line_start);
913 		      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
914 
915 		      /* In MRI mode, the EQU and MACRO pseudoops must
916 			 be handled specially.  */
917 		      mri_line_macro = 0;
918 		      if (flag_m68k_mri)
919 			{
920 			  char *rest = input_line_pointer + 1;
921 
922 			  if (*rest == ':')
923 			    ++rest;
924 			  if (*rest == ' ' || *rest == '\t')
925 			    ++rest;
926 			  if ((strncasecmp (rest, "EQU", 3) == 0
927 			       || strncasecmp (rest, "SET", 3) == 0)
928 			      && (rest[3] == ' ' || rest[3] == '\t'))
929 			    {
930 			      input_line_pointer = rest + 3;
931 			      equals (line_start,
932 				      strncasecmp (rest, "SET", 3) == 0);
933 			      continue;
934 			    }
935 			  if (strncasecmp (rest, "MACRO", 5) == 0
936 			      && (rest[5] == ' '
937 				  || rest[5] == '\t'
938 				  || is_end_of_line[(unsigned char) rest[5]]))
939 			    mri_line_macro = 1;
940 			}
941 
942 		      /* In MRI mode, we need to handle the MACRO
943 			 pseudo-op specially: we don't want to put the
944 			 symbol in the symbol table.  */
945 		      if (!mri_line_macro
946 #ifdef TC_START_LABEL_WITHOUT_COLON
947 			  && TC_START_LABEL_WITHOUT_COLON (nul_char, next_char)
948 #endif
949 			  )
950 			line_label = colon (line_start);
951 		      else
952 			line_label = symbol_create (line_start,
953 						    absolute_section,
954 						    (valueT) 0,
955 						    &zero_address_frag);
956 
957 		      next_char = restore_line_pointer (nul_char);
958 		      if (next_char == ':')
959 			input_line_pointer++;
960 		    }
961 		}
962 	    }
963 
964 	  /* We are at the beginning of a line, or similar place.
965 	     We expect a well-formed assembler statement.
966 	     A "symbol-name:" is a statement.
967 
968 	     Depending on what compiler is used, the order of these tests
969 	     may vary to catch most common case 1st.
970 	     Each test is independent of all other tests at the (top)
971 	     level.  */
972 	  do
973 	    nul_char = next_char = *input_line_pointer++;
974 	  while (next_char == '\t' || next_char == ' ' || next_char == '\f');
975 
976 	  /* C is the 1st significant character.
977 	     Input_line_pointer points after that character.  */
978 	  if (is_name_beginner (next_char) || next_char == '"')
979 	    {
980 	      char *rest;
981 
982 	      /* Want user-defined label or pseudo/opcode.  */
983 	      HANDLE_CONDITIONAL_ASSEMBLY (1);
984 
985 	      --input_line_pointer;
986 	      nul_char = get_symbol_name (& s);	/* name's delimiter.  */
987 	      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
988 	      rest = input_line_pointer + (nul_char == '"' ? 2 : 1);
989 
990 	      /* NEXT_CHAR is character after symbol.
991 		 The end of symbol in the input line is now '\0'.
992 		 S points to the beginning of the symbol.
993 		   [In case of pseudo-op, s->'.'.]
994 		 Input_line_pointer->'\0' where NUL_CHAR was.  */
995 	      if (TC_START_LABEL (s, nul_char, next_char))
996 		{
997 		  if (flag_m68k_mri)
998 		    {
999 		      /* In MRI mode, \tsym: set 0 is permitted.  */
1000 		      if (*rest == ':')
1001 			++rest;
1002 
1003 		      if (*rest == ' ' || *rest == '\t')
1004 			++rest;
1005 
1006 		      if ((strncasecmp (rest, "EQU", 3) == 0
1007 			   || strncasecmp (rest, "SET", 3) == 0)
1008 			  && (rest[3] == ' ' || rest[3] == '\t'))
1009 			{
1010 			  input_line_pointer = rest + 3;
1011 			  equals (s, 1);
1012 			  continue;
1013 			}
1014 		    }
1015 
1016 		  line_label = colon (s);	/* User-defined label.  */
1017 		  restore_line_pointer (nul_char);
1018 		  ++ input_line_pointer;
1019 #ifdef tc_check_label
1020 		  tc_check_label (line_label);
1021 #endif
1022 		  /* Input_line_pointer->after ':'.  */
1023 		  SKIP_WHITESPACE ();
1024 		}
1025 	      else if ((next_char == '=' && *rest == '=')
1026 		       || ((next_char == ' ' || next_char == '\t')
1027 			   && rest[0] == '='
1028 			   && rest[1] == '='))
1029 		{
1030 		  equals (s, -1);
1031 		  demand_empty_rest_of_line ();
1032 		}
1033 	      else if ((next_char == '='
1034 		       || ((next_char == ' ' || next_char == '\t')
1035 			    && *rest == '='))
1036 #ifdef TC_EQUAL_IN_INSN
1037 			   && !TC_EQUAL_IN_INSN (next_char, s)
1038 #endif
1039 			   )
1040 		{
1041 		  equals (s, 1);
1042 		  demand_empty_rest_of_line ();
1043 		}
1044 	      else
1045 		{
1046 		  /* Expect pseudo-op or machine instruction.  */
1047 		  pop = NULL;
1048 
1049 #ifndef TC_CASE_SENSITIVE
1050 		  {
1051 		    char *s2 = s;
1052 
1053 		    strncpy (original_case_string, s2, sizeof (original_case_string));
1054 		    original_case_string[sizeof (original_case_string) - 1] = 0;
1055 
1056 		    while (*s2)
1057 		      {
1058 			*s2 = TOLOWER (*s2);
1059 			s2++;
1060 		      }
1061 		  }
1062 #endif
1063 		  if (NO_PSEUDO_DOT || flag_m68k_mri)
1064 		    {
1065 		      /* The MRI assembler uses pseudo-ops without
1066 			 a period.  */
1067 		      pop = (pseudo_typeS *) hash_find (po_hash, s);
1068 		      if (pop != NULL && pop->poc_handler == NULL)
1069 			pop = NULL;
1070 		    }
1071 
1072 		  if (pop != NULL
1073 		      || (!flag_m68k_mri && *s == '.'))
1074 		    {
1075 		      /* PSEUDO - OP.
1076 
1077 			 WARNING: next_char may be end-of-line.
1078 			 We lookup the pseudo-op table with s+1 because we
1079 			 already know that the pseudo-op begins with a '.'.  */
1080 
1081 		      if (pop == NULL)
1082 			pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
1083 		      if (pop && !pop->poc_handler)
1084 			pop = NULL;
1085 
1086 		      /* In MRI mode, we may need to insert an
1087 			 automatic alignment directive.  What a hack
1088 			 this is.  */
1089 		      if (mri_pending_align
1090 			  && (pop == NULL
1091 			      || !((pop->poc_handler == cons
1092 				    && pop->poc_val == 1)
1093 				   || (pop->poc_handler == s_space
1094 				       && pop->poc_val == 1)
1095 #ifdef tc_conditional_pseudoop
1096 				   || tc_conditional_pseudoop (pop)
1097 #endif
1098 				   || pop->poc_handler == s_if
1099 				   || pop->poc_handler == s_ifdef
1100 				   || pop->poc_handler == s_ifc
1101 				   || pop->poc_handler == s_ifeqs
1102 				   || pop->poc_handler == s_else
1103 				   || pop->poc_handler == s_endif
1104 				   || pop->poc_handler == s_globl
1105 				   || pop->poc_handler == s_ignore)))
1106 			{
1107 			  do_align (1, (char *) NULL, 0, 0);
1108 			  mri_pending_align = 0;
1109 
1110 			  if (line_label != NULL)
1111 			    {
1112 			      symbol_set_frag (line_label, frag_now);
1113 			      S_SET_VALUE (line_label, frag_now_fix ());
1114 			    }
1115 			}
1116 
1117 		      /* Print the error msg now, while we still can.  */
1118 		      if (pop == NULL)
1119 			{
1120 			  char *end = input_line_pointer;
1121 
1122 			  (void) restore_line_pointer (nul_char);
1123 			  s_ignore (0);
1124 			  nul_char = next_char = *--input_line_pointer;
1125 			  *input_line_pointer = '\0';
1126 			  if (! macro_defined || ! try_macro (next_char, s))
1127 			    {
1128 			      *end = '\0';
1129 			      as_bad (_("unknown pseudo-op: `%s'"), s);
1130 			      *input_line_pointer++ = nul_char;
1131 			    }
1132 			  continue;
1133 			}
1134 
1135 		      /* Put it back for error messages etc.  */
1136 		      next_char = restore_line_pointer (nul_char);
1137 		      /* The following skip of whitespace is compulsory.
1138 			 A well shaped space is sometimes all that separates
1139 			 keyword from operands.  */
1140 		      if (next_char == ' ' || next_char == '\t')
1141 			input_line_pointer++;
1142 
1143 		      /* Input_line is restored.
1144 			 Input_line_pointer->1st non-blank char
1145 			 after pseudo-operation.  */
1146 		      (*pop->poc_handler) (pop->poc_val);
1147 
1148 		      /* If that was .end, just get out now.  */
1149 		      if (pop->poc_handler == s_end)
1150 			goto quit;
1151 		    }
1152 		  else
1153 		    {
1154 		      /* WARNING: next_char may be end-of-line.  */
1155 		      /* Also: input_line_pointer->`\0` where nul_char was.  */
1156 		      (void) restore_line_pointer (nul_char);
1157 		      input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
1158 		      next_char = nul_char = *input_line_pointer;
1159 		      *input_line_pointer = '\0';
1160 
1161 		      generate_lineno_debug ();
1162 
1163 		      if (macro_defined && try_macro (next_char, s))
1164 			continue;
1165 
1166 		      if (mri_pending_align)
1167 			{
1168 			  do_align (1, (char *) NULL, 0, 0);
1169 			  mri_pending_align = 0;
1170 			  if (line_label != NULL)
1171 			    {
1172 			      symbol_set_frag (line_label, frag_now);
1173 			      S_SET_VALUE (line_label, frag_now_fix ());
1174 			    }
1175 			}
1176 
1177 		      assemble_one (s); /* Assemble 1 instruction.  */
1178 
1179 		      /* PR 19630: The backend may have set ilp to NULL
1180 			 if it encountered a catastrophic failure.  */
1181 		      if (input_line_pointer == NULL)
1182 			as_fatal (_("unable to continue with assembly."));
1183 
1184 		      *input_line_pointer++ = nul_char;
1185 
1186 		      /* We resume loop AFTER the end-of-line from
1187 			 this instruction.  */
1188 		    }
1189 		}
1190 	      continue;
1191 	    }
1192 
1193 	  /* Empty statement?  */
1194 	  if (is_end_of_line[(unsigned char) next_char])
1195 	    continue;
1196 
1197 	  if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (next_char))
1198 	    {
1199 	      /* local label  ("4:")  */
1200 	      char *backup = input_line_pointer;
1201 
1202 	      HANDLE_CONDITIONAL_ASSEMBLY (1);
1203 
1204 	      temp = next_char - '0';
1205 
1206 	      if (nul_char == '"')
1207 		++ input_line_pointer;
1208 
1209 	      /* Read the whole number.  */
1210 	      while (ISDIGIT (*input_line_pointer))
1211 		{
1212 		  temp = (temp * 10) + *input_line_pointer - '0';
1213 		  ++input_line_pointer;
1214 		}
1215 
1216 	      if (LOCAL_LABELS_DOLLAR
1217 		  && *input_line_pointer == '$'
1218 		  && *(input_line_pointer + 1) == ':')
1219 		{
1220 		  input_line_pointer += 2;
1221 
1222 		  if (dollar_label_defined (temp))
1223 		    {
1224 		      as_fatal (_("label \"%d$\" redefined"), temp);
1225 		    }
1226 
1227 		  define_dollar_label (temp);
1228 		  colon (dollar_label_name (temp, 0));
1229 		  continue;
1230 		}
1231 
1232 	      if (LOCAL_LABELS_FB
1233 		  && *input_line_pointer++ == ':')
1234 		{
1235 		  fb_label_instance_inc (temp);
1236 		  colon (fb_label_name (temp, 0));
1237 		  continue;
1238 		}
1239 
1240 	      input_line_pointer = backup;
1241 	    }
1242 
1243 	  if (next_char && strchr (line_comment_chars, next_char))
1244 	    {			/* Its a comment.  Better say APP or NO_APP.  */
1245 	      sb sbuf;
1246 	      char *ends;
1247 	      char *new_buf;
1248 	      char *new_tmp;
1249 	      unsigned int new_length;
1250 	      char *tmp_buf = 0;
1251 
1252 	      s = input_line_pointer;
1253 	      if (strncmp (s, "APP\n", 4))
1254 		{
1255 		  /* We ignore it.  */
1256 		  ignore_rest_of_line ();
1257 		  continue;
1258 		}
1259 	      bump_line_counters ();
1260 	      s += 4;
1261 
1262 	      ends = strstr (s, "#NO_APP\n");
1263 
1264 	      if (!ends)
1265 		{
1266 		  unsigned int tmp_len;
1267 		  unsigned int num;
1268 
1269 		  /* The end of the #APP wasn't in this buffer.  We
1270 		     keep reading in buffers until we find the #NO_APP
1271 		     that goes with this #APP  There is one.  The specs
1272 		     guarantee it...  */
1273 		  tmp_len = buffer_limit - s;
1274 		  tmp_buf = XNEWVEC (char, tmp_len + 1);
1275 		  memcpy (tmp_buf, s, tmp_len);
1276 		  do
1277 		    {
1278 		      new_tmp = input_scrub_next_buffer (&buffer);
1279 		      if (!new_tmp)
1280 			break;
1281 		      else
1282 			buffer_limit = new_tmp;
1283 		      input_line_pointer = buffer;
1284 		      ends = strstr (buffer, "#NO_APP\n");
1285 		      if (ends)
1286 			num = ends - buffer;
1287 		      else
1288 			num = buffer_limit - buffer;
1289 
1290 		      tmp_buf = XRESIZEVEC (char, tmp_buf, tmp_len + num);
1291 		      memcpy (tmp_buf + tmp_len, buffer, num);
1292 		      tmp_len += num;
1293 		    }
1294 		  while (!ends);
1295 
1296 		  input_line_pointer = ends ? ends + 8 : NULL;
1297 
1298 		  s = tmp_buf;
1299 		  ends = s + tmp_len;
1300 
1301 		}
1302 	      else
1303 		{
1304 		  input_line_pointer = ends + 8;
1305 		}
1306 
1307 	      scrub_string = s;
1308 	      scrub_string_end = ends;
1309 
1310 	      new_length = ends - s;
1311 	      new_buf = XNEWVEC (char, new_length);
1312 	      new_tmp = new_buf;
1313 	      for (;;)
1314 		{
1315 		  size_t space;
1316 		  size_t size;
1317 
1318 		  space = (new_buf + new_length) - new_tmp;
1319 		  size = do_scrub_chars (scrub_from_string, new_tmp, space);
1320 
1321 		  if (size < space)
1322 		    {
1323 		      new_tmp[size] = 0;
1324 		      break;
1325 		    }
1326 
1327 		  new_buf = XRESIZEVEC (char, new_buf, new_length + 100);
1328 		  new_tmp = new_buf + new_length;
1329 		  new_length += 100;
1330 		}
1331 
1332 	      if (tmp_buf)
1333 		free (tmp_buf);
1334 
1335 	      /* We've "scrubbed" input to the preferred format.  In the
1336 		 process we may have consumed the whole of the remaining
1337 		 file (and included files).  We handle this formatted
1338 		 input similar to that of macro expansion, letting
1339 		 actual macro expansion (possibly nested) and other
1340 		 input expansion work.  Beware that in messages, line
1341 		 numbers and possibly file names will be incorrect.  */
1342 	      new_length = strlen (new_buf);
1343 	      sb_build (&sbuf, new_length);
1344 	      sb_add_buffer (&sbuf, new_buf, new_length);
1345 	      input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1346 	      sb_kill (&sbuf);
1347 	      buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1348 	      free (new_buf);
1349 	      continue;
1350 	    }
1351 
1352 	  HANDLE_CONDITIONAL_ASSEMBLY (1);
1353 
1354 #ifdef tc_unrecognized_line
1355 	  if (tc_unrecognized_line (next_char))
1356 	    continue;
1357 #endif
1358 	  input_line_pointer--;
1359 	  /* Report unknown char as error.  */
1360 	  demand_empty_rest_of_line ();
1361 	}
1362     }
1363 
1364  quit:
1365   symbol_set_value_now (&dot_symbol);
1366 
1367 #ifdef HANDLE_BUNDLE
1368   if (bundle_lock_frag != NULL)
1369     {
1370       as_bad_where (bundle_lock_frag->fr_file, bundle_lock_frag->fr_line,
1371 		    _(".bundle_lock with no matching .bundle_unlock"));
1372       bundle_lock_frag = NULL;
1373       bundle_lock_frchain = NULL;
1374       bundle_lock_depth = 0;
1375     }
1376 #endif
1377 
1378 #ifdef md_cleanup
1379   md_cleanup ();
1380 #endif
1381   /* Close the input file.  */
1382   input_scrub_close ();
1383 #ifdef WARN_COMMENTS
1384   {
1385     if (warn_comment && found_comment)
1386       as_warn_where (found_comment_file, found_comment,
1387 		     "first comment found here");
1388   }
1389 #endif
1390 }
1391 
1392 /* Convert O_constant expression EXP into the equivalent O_big representation.
1393    Take the sign of the number from SIGN rather than X_add_number.  */
1394 
1395 static void
convert_to_bignum(expressionS * exp,int sign)1396 convert_to_bignum (expressionS *exp, int sign)
1397 {
1398   valueT value;
1399   unsigned int i;
1400 
1401   value = exp->X_add_number;
1402   for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1403     {
1404       generic_bignum[i] = value & LITTLENUM_MASK;
1405       value >>= LITTLENUM_NUMBER_OF_BITS;
1406     }
1407   /* Add a sequence of sign bits if the top bit of X_add_number is not
1408      the sign of the original value.  */
1409   if ((exp->X_add_number < 0) == !sign)
1410     generic_bignum[i++] = sign ? LITTLENUM_MASK : 0;
1411   exp->X_op = O_big;
1412   exp->X_add_number = i;
1413 }
1414 
1415 /* For most MRI pseudo-ops, the line actually ends at the first
1416    nonquoted space.  This function looks for that point, stuffs a null
1417    in, and sets *STOPCP to the character that used to be there, and
1418    returns the location.
1419 
1420    Until I hear otherwise, I am going to assume that this is only true
1421    for the m68k MRI assembler.  */
1422 
1423 char *
mri_comment_field(char * stopcp)1424 mri_comment_field (char *stopcp)
1425 {
1426   char *s;
1427 #ifdef TC_M68K
1428   int inquote = 0;
1429 
1430   know (flag_m68k_mri);
1431 
1432   for (s = input_line_pointer;
1433        ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1434 	|| inquote);
1435        s++)
1436     {
1437       if (*s == '\'')
1438 	inquote = !inquote;
1439     }
1440 #else
1441   for (s = input_line_pointer;
1442        !is_end_of_line[(unsigned char) *s];
1443        s++)
1444     ;
1445 #endif
1446   *stopcp = *s;
1447   *s = '\0';
1448 
1449   return s;
1450 }
1451 
1452 /* Skip to the end of an MRI comment field.  */
1453 
1454 void
mri_comment_end(char * stop,int stopc)1455 mri_comment_end (char *stop, int stopc)
1456 {
1457   know (flag_mri);
1458 
1459   input_line_pointer = stop;
1460   *stop = stopc;
1461   while (!is_end_of_line[(unsigned char) *input_line_pointer])
1462     ++input_line_pointer;
1463 }
1464 
1465 void
s_abort(int ignore ATTRIBUTE_UNUSED)1466 s_abort (int ignore ATTRIBUTE_UNUSED)
1467 {
1468   as_fatal (_(".abort detected.  Abandoning ship."));
1469 }
1470 
1471 /* Handle the .align pseudo-op.  A positive ARG is a default alignment
1472    (in bytes).  A negative ARG is the negative of the length of the
1473    fill pattern.  BYTES_P is non-zero if the alignment value should be
1474    interpreted as the byte boundary, rather than the power of 2.  */
1475 #ifndef TC_ALIGN_LIMIT
1476 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1477 #endif
1478 
1479 static void
s_align(signed int arg,int bytes_p)1480 s_align (signed int arg, int bytes_p)
1481 {
1482   unsigned int align_limit = TC_ALIGN_LIMIT;
1483   unsigned int align;
1484   char *stop = NULL;
1485   char stopc = 0;
1486   offsetT fill = 0;
1487   unsigned int max;
1488   int fill_p;
1489 
1490   if (flag_mri)
1491     stop = mri_comment_field (&stopc);
1492 
1493   if (is_end_of_line[(unsigned char) *input_line_pointer])
1494     {
1495       if (arg < 0)
1496 	align = 0;
1497       else
1498 	align = arg;	/* Default value from pseudo-op table.  */
1499     }
1500   else
1501     {
1502       align = get_absolute_expression ();
1503       SKIP_WHITESPACE ();
1504 
1505 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1506       if (arg > 0 && align == 0)
1507 	align = arg;
1508 #endif
1509     }
1510 
1511   if (bytes_p)
1512     {
1513       /* Convert to a power of 2.  */
1514       if (align != 0)
1515 	{
1516 	  unsigned int i;
1517 
1518 	  for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1519 	    ;
1520 	  if (align != 1)
1521 	    as_bad (_("alignment not a power of 2"));
1522 
1523 	  align = i;
1524 	}
1525     }
1526 
1527   if (align > align_limit)
1528     {
1529       align = align_limit;
1530       as_warn (_("alignment too large: %u assumed"), align);
1531     }
1532 
1533   if (*input_line_pointer != ',')
1534     {
1535       fill_p = 0;
1536       max = 0;
1537     }
1538   else
1539     {
1540       ++input_line_pointer;
1541       if (*input_line_pointer == ',')
1542 	fill_p = 0;
1543       else
1544 	{
1545 	  fill = get_absolute_expression ();
1546 	  SKIP_WHITESPACE ();
1547 	  fill_p = 1;
1548 	}
1549 
1550       if (*input_line_pointer != ',')
1551 	max = 0;
1552       else
1553 	{
1554 	  ++input_line_pointer;
1555 	  max = get_absolute_expression ();
1556 	}
1557     }
1558 
1559   if (!fill_p)
1560     {
1561       if (arg < 0)
1562 	as_warn (_("expected fill pattern missing"));
1563       do_align (align, (char *) NULL, 0, max);
1564     }
1565   else
1566     {
1567       unsigned int fill_len;
1568 
1569       if (arg >= 0)
1570 	fill_len = 1;
1571       else
1572 	fill_len = -arg;
1573 
1574       if (fill_len <= 1)
1575 	{
1576 	  char fill_char = 0;
1577 
1578 	  fill_char = fill;
1579 	  do_align (align, &fill_char, fill_len, max);
1580 	}
1581       else
1582 	{
1583 	  char ab[16];
1584 
1585 	  if ((size_t) fill_len > sizeof ab)
1586 	    {
1587 	      as_warn (_("fill pattern too long, truncating to %u"),
1588 		       (unsigned) sizeof ab);
1589 	      fill_len = sizeof ab;
1590 	    }
1591 
1592 	  md_number_to_chars (ab, fill, fill_len);
1593 	  do_align (align, ab, fill_len, max);
1594 	}
1595     }
1596 
1597   demand_empty_rest_of_line ();
1598 
1599   if (flag_mri)
1600     mri_comment_end (stop, stopc);
1601 }
1602 
1603 /* Handle the .align pseudo-op on machines where ".align 4" means
1604    align to a 4 byte boundary.  */
1605 
1606 void
s_align_bytes(int arg)1607 s_align_bytes (int arg)
1608 {
1609   s_align (arg, 1);
1610 }
1611 
1612 /* Handle the .align pseudo-op on machines where ".align 4" means align
1613    to a 2**4 boundary.  */
1614 
1615 void
s_align_ptwo(int arg)1616 s_align_ptwo (int arg)
1617 {
1618   s_align (arg, 0);
1619 }
1620 
1621 /* Switch in and out of alternate macro mode.  */
1622 
1623 static void
s_altmacro(int on)1624 s_altmacro (int on)
1625 {
1626   demand_empty_rest_of_line ();
1627   macro_set_alternate (on);
1628 }
1629 
1630 /* Read a symbol name from input_line_pointer.
1631 
1632    Stores the symbol name in a buffer and returns a pointer to this buffer.
1633    The buffer is xalloc'ed.  It is the caller's responsibility to free
1634    this buffer.
1635 
1636    The name is not left in the i_l_p buffer as it may need processing
1637    to handle escape characters.
1638 
1639    Advances i_l_p to the next non-whitespace character.
1640 
1641    If a symbol name could not be read, the routine issues an error
1642    messages, skips to the end of the line and returns NULL.  */
1643 
1644 char *
read_symbol_name(void)1645 read_symbol_name (void)
1646 {
1647   char * name;
1648   char * start;
1649   char c;
1650 
1651   c = *input_line_pointer++;
1652 
1653   if (c == '"')
1654     {
1655 #define SYM_NAME_CHUNK_LEN 128
1656       ptrdiff_t len = SYM_NAME_CHUNK_LEN;
1657       char * name_end;
1658       unsigned int C;
1659 
1660       start = name = XNEWVEC (char, len + 1);
1661 
1662       name_end = name + SYM_NAME_CHUNK_LEN;
1663 
1664       while (is_a_char (C = next_char_of_string ()))
1665 	{
1666 	  if (name >= name_end)
1667 	    {
1668 	      ptrdiff_t sofar;
1669 
1670 	      sofar = name - start;
1671 	      len += SYM_NAME_CHUNK_LEN;
1672 	      start = XRESIZEVEC (char, start, len + 1);
1673 	      name_end = start + len;
1674 	      name = start + sofar;
1675 	    }
1676 
1677 	  *name++ = (char) C;
1678 	}
1679       *name = 0;
1680 
1681       /* Since quoted symbol names can contain non-ASCII characters,
1682 	 check the string and warn if it cannot be recognised by the
1683 	 current character set.  */
1684       if (mbstowcs (NULL, name, len) == (size_t) -1)
1685 	as_warn (_("symbol name not recognised in the current locale"));
1686     }
1687   else if (is_name_beginner (c) || c == '\001')
1688     {
1689       ptrdiff_t len;
1690 
1691       name = input_line_pointer - 1;
1692 
1693       /* We accept \001 in a name in case this is
1694 	 being called with a constructed string.  */
1695       while (is_part_of_name (c = *input_line_pointer++)
1696 	     || c == '\001')
1697 	;
1698 
1699       len = (input_line_pointer - name) - 1;
1700       start = XNEWVEC (char, len + 1);
1701 
1702       memcpy (start, name, len);
1703       start[len] = 0;
1704 
1705       /* Skip a name ender char if one is present.  */
1706       if (! is_name_ender (c))
1707 	--input_line_pointer;
1708     }
1709   else
1710     name = start = NULL;
1711 
1712   if (name == start)
1713     {
1714       as_bad (_("expected symbol name"));
1715       ignore_rest_of_line ();
1716       return NULL;
1717     }
1718 
1719   SKIP_WHITESPACE ();
1720 
1721   return start;
1722 }
1723 
1724 
1725 symbolS *
s_comm_internal(int param,symbolS * (* comm_parse_extra)(int,symbolS *,addressT))1726 s_comm_internal (int param,
1727 		 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1728 {
1729   char *name;
1730   offsetT temp, size;
1731   symbolS *symbolP = NULL;
1732   char *stop = NULL;
1733   char stopc = 0;
1734   expressionS exp;
1735 
1736   if (flag_mri)
1737     stop = mri_comment_field (&stopc);
1738 
1739   if ((name = read_symbol_name ()) == NULL)
1740     goto out;
1741 
1742   /* Accept an optional comma after the name.  The comma used to be
1743      required, but Irix 5 cc does not generate it for .lcomm.  */
1744   if (*input_line_pointer == ',')
1745     input_line_pointer++;
1746 
1747   temp = get_absolute_expr (&exp);
1748   size = temp;
1749   size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1750   if (exp.X_op == O_absent)
1751     {
1752       as_bad (_("missing size expression"));
1753       ignore_rest_of_line ();
1754       goto out;
1755     }
1756   else if (temp != size || !exp.X_unsigned)
1757     {
1758       as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1759       ignore_rest_of_line ();
1760       goto out;
1761     }
1762 
1763   symbolP = symbol_find_or_make (name);
1764   if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
1765       && !S_IS_COMMON (symbolP))
1766     {
1767       if (!S_IS_VOLATILE (symbolP))
1768 	{
1769 	  symbolP = NULL;
1770 	  as_bad (_("symbol `%s' is already defined"), name);
1771 	  ignore_rest_of_line ();
1772 	  goto out;
1773 	}
1774       symbolP = symbol_clone (symbolP, 1);
1775       S_SET_SEGMENT (symbolP, undefined_section);
1776       S_SET_VALUE (symbolP, 0);
1777       symbol_set_frag (symbolP, &zero_address_frag);
1778       S_CLEAR_VOLATILE (symbolP);
1779     }
1780 
1781   size = S_GET_VALUE (symbolP);
1782   if (size == 0)
1783     size = temp;
1784   else if (size != temp)
1785     as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1786 	     name, (long) size, (long) temp);
1787 
1788   if (comm_parse_extra != NULL)
1789     symbolP = (*comm_parse_extra) (param, symbolP, size);
1790   else
1791     {
1792       S_SET_VALUE (symbolP, (valueT) size);
1793       S_SET_EXTERNAL (symbolP);
1794       S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
1795     }
1796 
1797   demand_empty_rest_of_line ();
1798  out:
1799   if (flag_mri)
1800     mri_comment_end (stop, stopc);
1801   if (name != NULL)
1802     free (name);
1803   return symbolP;
1804 }
1805 
1806 void
s_comm(int ignore)1807 s_comm (int ignore)
1808 {
1809   s_comm_internal (ignore, NULL);
1810 }
1811 
1812 /* The MRI COMMON pseudo-op.  We handle this by creating a common
1813    symbol with the appropriate name.  We make s_space do the right
1814    thing by increasing the size.  */
1815 
1816 void
s_mri_common(int small ATTRIBUTE_UNUSED)1817 s_mri_common (int small ATTRIBUTE_UNUSED)
1818 {
1819   char *name;
1820   char c;
1821   char *alc = NULL;
1822   symbolS *sym;
1823   offsetT align;
1824   char *stop = NULL;
1825   char stopc = 0;
1826 
1827   if (!flag_mri)
1828     {
1829       s_comm (0);
1830       return;
1831     }
1832 
1833   stop = mri_comment_field (&stopc);
1834 
1835   SKIP_WHITESPACE ();
1836 
1837   name = input_line_pointer;
1838   if (!ISDIGIT (*name))
1839     c = get_symbol_name (& name);
1840   else
1841     {
1842       do
1843 	{
1844 	  ++input_line_pointer;
1845 	}
1846       while (ISDIGIT (*input_line_pointer));
1847 
1848       c = *input_line_pointer;
1849       *input_line_pointer = '\0';
1850 
1851       if (line_label != NULL)
1852 	{
1853 	  alc = XNEWVEC (char, strlen (S_GET_NAME (line_label))
1854 			 + (input_line_pointer - name) + 1);
1855 	  sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1856 	  name = alc;
1857 	}
1858     }
1859 
1860   sym = symbol_find_or_make (name);
1861   c = restore_line_pointer (c);
1862   if (alc != NULL)
1863     free (alc);
1864 
1865   if (*input_line_pointer != ',')
1866     align = 0;
1867   else
1868     {
1869       ++input_line_pointer;
1870       align = get_absolute_expression ();
1871     }
1872 
1873   if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1874     {
1875       as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1876       ignore_rest_of_line ();
1877       mri_comment_end (stop, stopc);
1878       return;
1879     }
1880 
1881   S_SET_EXTERNAL (sym);
1882   S_SET_SEGMENT (sym, bfd_com_section_ptr);
1883   mri_common_symbol = sym;
1884 
1885 #ifdef S_SET_ALIGN
1886   if (align != 0)
1887     S_SET_ALIGN (sym, align);
1888 #else
1889   (void) align;
1890 #endif
1891 
1892   if (line_label != NULL)
1893     {
1894       expressionS exp;
1895       exp.X_op = O_symbol;
1896       exp.X_add_symbol = sym;
1897       exp.X_add_number = 0;
1898       symbol_set_value_expression (line_label, &exp);
1899       symbol_set_frag (line_label, &zero_address_frag);
1900       S_SET_SEGMENT (line_label, expr_section);
1901     }
1902 
1903   /* FIXME: We just ignore the small argument, which distinguishes
1904      COMMON and COMMON.S.  I don't know what we can do about it.  */
1905 
1906   /* Ignore the type and hptype.  */
1907   if (*input_line_pointer == ',')
1908     input_line_pointer += 2;
1909   if (*input_line_pointer == ',')
1910     input_line_pointer += 2;
1911 
1912   demand_empty_rest_of_line ();
1913 
1914   mri_comment_end (stop, stopc);
1915 }
1916 
1917 void
s_data(int ignore ATTRIBUTE_UNUSED)1918 s_data (int ignore ATTRIBUTE_UNUSED)
1919 {
1920   segT section;
1921   int temp;
1922 
1923   temp = get_absolute_expression ();
1924   if (flag_readonly_data_in_text)
1925     {
1926       section = text_section;
1927       temp += 1000;
1928     }
1929   else
1930     section = data_section;
1931 
1932   subseg_set (section, (subsegT) temp);
1933 
1934   demand_empty_rest_of_line ();
1935 }
1936 
1937 /* Handle the .appfile pseudo-op.  This is automatically generated by
1938    do_scrub_chars when a preprocessor # line comment is seen with a
1939    file name.  This default definition may be overridden by the object
1940    or CPU specific pseudo-ops.  This function is also the default
1941    definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1942    .file.  */
1943 
1944 void
s_app_file_string(char * file,int appfile ATTRIBUTE_UNUSED)1945 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1946 {
1947 #ifdef LISTING
1948   if (listing)
1949     listing_source_file (file);
1950 #endif
1951   register_dependency (file);
1952 #ifdef obj_app_file
1953   obj_app_file (file, appfile);
1954 #endif
1955 }
1956 
1957 void
s_app_file(int appfile)1958 s_app_file (int appfile)
1959 {
1960   char *s;
1961   int length;
1962 
1963   /* Some assemblers tolerate immediately following '"'.  */
1964   if ((s = demand_copy_string (&length)) != 0)
1965     {
1966       int may_omit
1967 	= (!new_logical_line_flags (s, -1, 1) && appfile);
1968 
1969       /* In MRI mode, the preprocessor may have inserted an extraneous
1970 	 backquote.  */
1971       if (flag_m68k_mri
1972 	  && *input_line_pointer == '\''
1973 	  && is_end_of_line[(unsigned char) input_line_pointer[1]])
1974 	++input_line_pointer;
1975 
1976       demand_empty_rest_of_line ();
1977       if (!may_omit)
1978 	s_app_file_string (s, appfile);
1979     }
1980 }
1981 
1982 static int
get_linefile_number(int * flag)1983 get_linefile_number (int *flag)
1984 {
1985   SKIP_WHITESPACE ();
1986 
1987   if (*input_line_pointer < '0' || *input_line_pointer > '9')
1988     return 0;
1989 
1990   *flag = get_absolute_expression ();
1991 
1992   return 1;
1993 }
1994 
1995 /* Handle the .appline pseudo-op.  This is automatically generated by
1996    do_scrub_chars when a preprocessor # line comment is seen.  This
1997    default definition may be overridden by the object or CPU specific
1998    pseudo-ops.  */
1999 
2000 void
s_app_line(int appline)2001 s_app_line (int appline)
2002 {
2003   char *file = NULL;
2004   int l;
2005 
2006   /* The given number is that of the next line.  */
2007   if (appline)
2008     l = get_absolute_expression ();
2009   else if (!get_linefile_number (&l))
2010     {
2011       ignore_rest_of_line ();
2012       return;
2013     }
2014 
2015   l--;
2016 
2017   if (l < -1)
2018     /* Some of the back ends can't deal with non-positive line numbers.
2019        Besides, it's silly.  GCC however will generate a line number of
2020        zero when it is pre-processing builtins for assembler-with-cpp files:
2021 
2022 	  # 0 "<built-in>"
2023 
2024        We do not want to barf on this, especially since such files are used
2025        in the GCC and GDB testsuites.  So we check for negative line numbers
2026        rather than non-positive line numbers.  */
2027     as_warn (_("line numbers must be positive; line number %d rejected"),
2028 	     l + 1);
2029   else
2030     {
2031       int flags = 0;
2032       int length = 0;
2033 
2034       if (!appline)
2035 	{
2036 	  SKIP_WHITESPACE ();
2037 
2038 	  if (*input_line_pointer == '"')
2039 	    file = demand_copy_string (&length);
2040 
2041 	  if (file)
2042 	    {
2043 	      int this_flag;
2044 
2045 	      while (get_linefile_number (&this_flag))
2046 		switch (this_flag)
2047 		  {
2048 		    /* From GCC's cpp documentation:
2049 		       1: start of a new file.
2050 		       2: returning to a file after having included
2051 			  another file.
2052 		       3: following text comes from a system header file.
2053 		       4: following text should be treated as extern "C".
2054 
2055 		       4 is nonsensical for the assembler; 3, we don't
2056 		       care about, so we ignore it just in case a
2057 		       system header file is included while
2058 		       preprocessing assembly.  So 1 and 2 are all we
2059 		       care about, and they are mutually incompatible.
2060 		       new_logical_line_flags() demands this.  */
2061 		  case 1:
2062 		  case 2:
2063 		    if (flags && flags != (1 << this_flag))
2064 		      as_warn (_("incompatible flag %i in line directive"),
2065 			       this_flag);
2066 		    else
2067 		      flags |= 1 << this_flag;
2068 		    break;
2069 
2070 		  case 3:
2071 		  case 4:
2072 		    /* We ignore these.  */
2073 		    break;
2074 
2075 		  default:
2076 		    as_warn (_("unsupported flag %i in line directive"),
2077 			     this_flag);
2078 		    break;
2079 		  }
2080 
2081 	      if (!is_end_of_line[(unsigned char)*input_line_pointer])
2082 		file = 0;
2083 	    }
2084 	}
2085 
2086       if (appline || file)
2087 	{
2088 	  new_logical_line_flags (file, l, flags);
2089 #ifdef LISTING
2090 	  if (listing)
2091 	    listing_source_line (l);
2092 #endif
2093 	}
2094     }
2095   if (appline || file)
2096     demand_empty_rest_of_line ();
2097   else
2098     ignore_rest_of_line ();
2099 }
2100 
2101 /* Handle the .end pseudo-op.  Actually, the real work is done in
2102    read_a_source_file.  */
2103 
2104 void
s_end(int ignore ATTRIBUTE_UNUSED)2105 s_end (int ignore ATTRIBUTE_UNUSED)
2106 {
2107   if (flag_mri)
2108     {
2109       /* The MRI assembler permits the start symbol to follow .end,
2110 	 but we don't support that.  */
2111       SKIP_WHITESPACE ();
2112       if (!is_end_of_line[(unsigned char) *input_line_pointer]
2113 	  && *input_line_pointer != '*'
2114 	  && *input_line_pointer != '!')
2115 	as_warn (_("start address not supported"));
2116     }
2117 }
2118 
2119 /* Handle the .err pseudo-op.  */
2120 
2121 void
s_err(int ignore ATTRIBUTE_UNUSED)2122 s_err (int ignore ATTRIBUTE_UNUSED)
2123 {
2124   as_bad (_(".err encountered"));
2125   demand_empty_rest_of_line ();
2126 }
2127 
2128 /* Handle the .error and .warning pseudo-ops.  */
2129 
2130 void
s_errwarn(int err)2131 s_errwarn (int err)
2132 {
2133   int len;
2134   /* The purpose for the conditional assignment is not to
2135      internationalize the directive itself, but that we need a
2136      self-contained message, one that can be passed like the
2137      demand_copy_C_string return value, and with no assumption on the
2138      location of the name of the directive within the message.  */
2139   const char *msg
2140     = (err ? _(".error directive invoked in source file")
2141        : _(".warning directive invoked in source file"));
2142 
2143   if (!is_it_end_of_statement ())
2144     {
2145       if (*input_line_pointer != '\"')
2146 	{
2147 	  as_bad (_("%s argument must be a string"),
2148 		  err ? ".error" : ".warning");
2149 	  ignore_rest_of_line ();
2150 	  return;
2151 	}
2152 
2153       msg = demand_copy_C_string (&len);
2154       if (msg == NULL)
2155 	return;
2156     }
2157 
2158   if (err)
2159     as_bad ("%s", msg);
2160   else
2161     as_warn ("%s", msg);
2162   demand_empty_rest_of_line ();
2163 }
2164 
2165 /* Handle the MRI fail pseudo-op.  */
2166 
2167 void
s_fail(int ignore ATTRIBUTE_UNUSED)2168 s_fail (int ignore ATTRIBUTE_UNUSED)
2169 {
2170   offsetT temp;
2171   char *stop = NULL;
2172   char stopc = 0;
2173 
2174   if (flag_mri)
2175     stop = mri_comment_field (&stopc);
2176 
2177   temp = get_absolute_expression ();
2178   if (temp >= 500)
2179     as_warn (_(".fail %ld encountered"), (long) temp);
2180   else
2181     as_bad (_(".fail %ld encountered"), (long) temp);
2182 
2183   demand_empty_rest_of_line ();
2184 
2185   if (flag_mri)
2186     mri_comment_end (stop, stopc);
2187 }
2188 
2189 void
s_fill(int ignore ATTRIBUTE_UNUSED)2190 s_fill (int ignore ATTRIBUTE_UNUSED)
2191 {
2192   expressionS rep_exp;
2193   long size = 1;
2194   long fill = 0;
2195   char *p;
2196 
2197 #ifdef md_flush_pending_output
2198   md_flush_pending_output ();
2199 #endif
2200 
2201 #ifdef md_cons_align
2202   md_cons_align (1);
2203 #endif
2204 
2205   get_known_segmented_expression (&rep_exp);
2206   if (*input_line_pointer == ',')
2207     {
2208       input_line_pointer++;
2209       size = get_absolute_expression ();
2210       if (*input_line_pointer == ',')
2211 	{
2212 	  input_line_pointer++;
2213 	  fill = get_absolute_expression ();
2214 	}
2215     }
2216 
2217   /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
2218 #define BSD_FILL_SIZE_CROCK_8 (8)
2219   if (size > BSD_FILL_SIZE_CROCK_8)
2220     {
2221       as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
2222       size = BSD_FILL_SIZE_CROCK_8;
2223     }
2224   if (size < 0)
2225     {
2226       as_warn (_("size negative; .fill ignored"));
2227       size = 0;
2228     }
2229   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
2230     {
2231       if (rep_exp.X_add_number < 0)
2232 	as_warn (_("repeat < 0; .fill ignored"));
2233       size = 0;
2234     }
2235 
2236   if (size && !need_pass_2)
2237     {
2238       if (now_seg == absolute_section)
2239 	{
2240 	  if (rep_exp.X_op != O_constant)
2241 	    as_bad (_("non-constant fill count for absolute section"));
2242 	  else if (fill && rep_exp.X_add_number != 0)
2243 	    as_bad (_("attempt to fill absolute section with non-zero value"));
2244 	  abs_section_offset += rep_exp.X_add_number * size;
2245 	}
2246       else if (fill
2247 	       && (rep_exp.X_op != O_constant || rep_exp.X_add_number != 0)
2248 	       && in_bss ())
2249 	as_bad (_("attempt to fill section `%s' with non-zero value"),
2250 		segment_name (now_seg));
2251 
2252       if (rep_exp.X_op == O_constant)
2253 	{
2254 	  p = frag_var (rs_fill, (int) size, (int) size,
2255 			(relax_substateT) 0, (symbolS *) 0,
2256 			(offsetT) rep_exp.X_add_number,
2257 			(char *) 0);
2258 	}
2259       else
2260 	{
2261 	  /* We don't have a constant repeat count, so we can't use
2262 	     rs_fill.  We can get the same results out of rs_space,
2263 	     but its argument is in bytes, so we must multiply the
2264 	     repeat count by size.  */
2265 
2266 	  symbolS *rep_sym;
2267 	  rep_sym = make_expr_symbol (&rep_exp);
2268 	  if (size != 1)
2269 	    {
2270 	      expressionS size_exp;
2271 	      size_exp.X_op = O_constant;
2272 	      size_exp.X_add_number = size;
2273 
2274 	      rep_exp.X_op = O_multiply;
2275 	      rep_exp.X_add_symbol = rep_sym;
2276 	      rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
2277 	      rep_exp.X_add_number = 0;
2278 	      rep_sym = make_expr_symbol (&rep_exp);
2279 	    }
2280 
2281 	  p = frag_var (rs_space, (int) size, (int) size,
2282 			(relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
2283 	}
2284 
2285       memset (p, 0, (unsigned int) size);
2286 
2287       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2288 	 flavoured AS.  The following bizarre behaviour is to be
2289 	 compatible with above.  I guess they tried to take up to 8
2290 	 bytes from a 4-byte expression and they forgot to sign
2291 	 extend.  */
2292 #define BSD_FILL_SIZE_CROCK_4 (4)
2293       md_number_to_chars (p, (valueT) fill,
2294 			  (size > BSD_FILL_SIZE_CROCK_4
2295 			   ? BSD_FILL_SIZE_CROCK_4
2296 			   : (int) size));
2297       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2298 	 but emits no error message because it seems a legal thing to do.
2299 	 It is a degenerate case of .fill but could be emitted by a
2300 	 compiler.  */
2301     }
2302   demand_empty_rest_of_line ();
2303 }
2304 
2305 void
s_globl(int ignore ATTRIBUTE_UNUSED)2306 s_globl (int ignore ATTRIBUTE_UNUSED)
2307 {
2308   char *name;
2309   int c;
2310   symbolS *symbolP;
2311   char *stop = NULL;
2312   char stopc = 0;
2313 
2314   if (flag_mri)
2315     stop = mri_comment_field (&stopc);
2316 
2317   do
2318     {
2319       if ((name = read_symbol_name ()) == NULL)
2320 	return;
2321 
2322       symbolP = symbol_find_or_make (name);
2323       S_SET_EXTERNAL (symbolP);
2324 
2325       SKIP_WHITESPACE ();
2326       c = *input_line_pointer;
2327       if (c == ',')
2328 	{
2329 	  input_line_pointer++;
2330 	  SKIP_WHITESPACE ();
2331 	  if (is_end_of_line[(unsigned char) *input_line_pointer])
2332 	    c = '\n';
2333 	}
2334 
2335       free (name);
2336     }
2337   while (c == ',');
2338 
2339   demand_empty_rest_of_line ();
2340 
2341   if (flag_mri)
2342     mri_comment_end (stop, stopc);
2343 }
2344 
2345 /* Handle the MRI IRP and IRPC pseudo-ops.  */
2346 
2347 void
s_irp(int irpc)2348 s_irp (int irpc)
2349 {
2350   char * eol;
2351   const char * file;
2352   unsigned int line;
2353   sb s;
2354   const char *err;
2355   sb out;
2356 
2357   file = as_where (&line);
2358 
2359   eol = find_end_of_line (input_line_pointer, 0);
2360   sb_build (&s, eol - input_line_pointer);
2361   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2362   input_line_pointer = eol;
2363 
2364   sb_new (&out);
2365 
2366   err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2367   if (err != NULL)
2368     as_bad_where (file, line, "%s", err);
2369 
2370   sb_kill (&s);
2371 
2372   input_scrub_include_sb (&out, input_line_pointer, 1);
2373   sb_kill (&out);
2374   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2375 }
2376 
2377 /* Handle the .linkonce pseudo-op.  This tells the assembler to mark
2378    the section to only be linked once.  However, this is not supported
2379    by most object file formats.  This takes an optional argument,
2380    which is what to do about duplicates.  */
2381 
2382 void
s_linkonce(int ignore ATTRIBUTE_UNUSED)2383 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2384 {
2385   enum linkonce_type type;
2386 
2387   SKIP_WHITESPACE ();
2388 
2389   type = LINKONCE_DISCARD;
2390 
2391   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2392     {
2393       char *s;
2394       char c;
2395 
2396       c = get_symbol_name (& s);
2397       if (strcasecmp (s, "discard") == 0)
2398 	type = LINKONCE_DISCARD;
2399       else if (strcasecmp (s, "one_only") == 0)
2400 	type = LINKONCE_ONE_ONLY;
2401       else if (strcasecmp (s, "same_size") == 0)
2402 	type = LINKONCE_SAME_SIZE;
2403       else if (strcasecmp (s, "same_contents") == 0)
2404 	type = LINKONCE_SAME_CONTENTS;
2405       else
2406 	as_warn (_("unrecognized .linkonce type `%s'"), s);
2407 
2408       (void) restore_line_pointer (c);
2409     }
2410 
2411 #ifdef obj_handle_link_once
2412   obj_handle_link_once (type);
2413 #else /* ! defined (obj_handle_link_once) */
2414   {
2415     flagword flags;
2416 
2417     if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2418       as_warn (_(".linkonce is not supported for this object file format"));
2419 
2420     flags = bfd_get_section_flags (stdoutput, now_seg);
2421     flags |= SEC_LINK_ONCE;
2422     switch (type)
2423       {
2424       default:
2425 	abort ();
2426       case LINKONCE_DISCARD:
2427 	flags |= SEC_LINK_DUPLICATES_DISCARD;
2428 	break;
2429       case LINKONCE_ONE_ONLY:
2430 	flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2431 	break;
2432       case LINKONCE_SAME_SIZE:
2433 	flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2434 	break;
2435       case LINKONCE_SAME_CONTENTS:
2436 	flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2437 	break;
2438       }
2439     if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2440       as_bad (_("bfd_set_section_flags: %s"),
2441 	      bfd_errmsg (bfd_get_error ()));
2442   }
2443 #endif /* ! defined (obj_handle_link_once) */
2444 
2445   demand_empty_rest_of_line ();
2446 }
2447 
2448 void
bss_alloc(symbolS * symbolP,addressT size,unsigned int align)2449 bss_alloc (symbolS *symbolP, addressT size, unsigned int align)
2450 {
2451   char *pfrag;
2452   segT current_seg = now_seg;
2453   subsegT current_subseg = now_subseg;
2454   segT bss_seg = bss_section;
2455 
2456 #if defined (TC_MIPS) || defined (TC_ALPHA)
2457   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2458       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2459     {
2460       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
2461       if (size <= bfd_get_gp_size (stdoutput))
2462 	{
2463 	  bss_seg = subseg_new (".sbss", 1);
2464 	  seg_info (bss_seg)->bss = 1;
2465 	  if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2466 	    as_warn (_("error setting flags for \".sbss\": %s"),
2467 		     bfd_errmsg (bfd_get_error ()));
2468 	}
2469     }
2470 #endif
2471   subseg_set (bss_seg, 1);
2472 
2473   if (align > OCTETS_PER_BYTE_POWER)
2474     {
2475       record_alignment (bss_seg, align);
2476       frag_align (align, 0, 0);
2477     }
2478 
2479   /* Detach from old frag.  */
2480   if (S_GET_SEGMENT (symbolP) == bss_seg)
2481     symbol_get_frag (symbolP)->fr_symbol = NULL;
2482 
2483   symbol_set_frag (symbolP, frag_now);
2484   pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2485   *pfrag = 0;
2486 
2487 #ifdef S_SET_SIZE
2488   S_SET_SIZE (symbolP, size);
2489 #endif
2490   S_SET_SEGMENT (symbolP, bss_seg);
2491 
2492 #ifdef OBJ_COFF
2493   /* The symbol may already have been created with a preceding
2494      ".globl" directive -- be careful not to step on storage class
2495      in that case.  Otherwise, set it to static.  */
2496   if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2497     S_SET_STORAGE_CLASS (symbolP, C_STAT);
2498 #endif /* OBJ_COFF */
2499 
2500   subseg_set (current_seg, current_subseg);
2501 }
2502 
2503 offsetT
parse_align(int align_bytes)2504 parse_align (int align_bytes)
2505 {
2506   expressionS exp;
2507   addressT align;
2508 
2509   SKIP_WHITESPACE ();
2510   if (*input_line_pointer != ',')
2511     {
2512     no_align:
2513       as_bad (_("expected alignment after size"));
2514       ignore_rest_of_line ();
2515       return -1;
2516     }
2517 
2518   input_line_pointer++;
2519   SKIP_WHITESPACE ();
2520 
2521   align = get_absolute_expr (&exp);
2522   if (exp.X_op == O_absent)
2523     goto no_align;
2524 
2525   if (!exp.X_unsigned)
2526     {
2527       as_warn (_("alignment negative; 0 assumed"));
2528       align = 0;
2529     }
2530 
2531   if (align_bytes && align != 0)
2532     {
2533       /* convert to a power of 2 alignment */
2534       unsigned int alignp2 = 0;
2535       while ((align & 1) == 0)
2536 	align >>= 1, ++alignp2;
2537       if (align != 1)
2538 	{
2539 	  as_bad (_("alignment not a power of 2"));
2540 	  ignore_rest_of_line ();
2541 	  return -1;
2542 	}
2543       align = alignp2;
2544     }
2545   return align;
2546 }
2547 
2548 /* Called from s_comm_internal after symbol name and size have been
2549    parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2550    1 if this was a ".bss" directive which has a 3rd argument
2551    (alignment as a power of 2), or 2 if this was a ".bss" directive
2552    with alignment in bytes.  */
2553 
2554 symbolS *
s_lcomm_internal(int needs_align,symbolS * symbolP,addressT size)2555 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2556 {
2557   addressT align = 0;
2558 
2559   if (needs_align)
2560     {
2561       align = parse_align (needs_align - 1);
2562       if (align == (addressT) -1)
2563 	return NULL;
2564     }
2565   else
2566     /* Assume some objects may require alignment on some systems.  */
2567     TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2568 
2569   bss_alloc (symbolP, size, align);
2570   return symbolP;
2571 }
2572 
2573 void
s_lcomm(int needs_align)2574 s_lcomm (int needs_align)
2575 {
2576   s_comm_internal (needs_align, s_lcomm_internal);
2577 }
2578 
2579 void
s_lcomm_bytes(int needs_align)2580 s_lcomm_bytes (int needs_align)
2581 {
2582   s_comm_internal (needs_align * 2, s_lcomm_internal);
2583 }
2584 
2585 void
s_lsym(int ignore ATTRIBUTE_UNUSED)2586 s_lsym (int ignore ATTRIBUTE_UNUSED)
2587 {
2588   char *name;
2589   expressionS exp;
2590   symbolS *symbolP;
2591 
2592   /* We permit ANY defined expression: BSD4.2 demands constants.  */
2593   if ((name = read_symbol_name ()) == NULL)
2594     return;
2595 
2596   if (*input_line_pointer != ',')
2597     {
2598       as_bad (_("expected comma after \"%s\""), name);
2599       goto err_out;
2600     }
2601 
2602   input_line_pointer++;
2603   expression_and_evaluate (&exp);
2604 
2605   if (exp.X_op != O_constant
2606       && exp.X_op != O_register)
2607     {
2608       as_bad (_("bad expression"));
2609       goto err_out;
2610     }
2611 
2612   symbolP = symbol_find_or_make (name);
2613 
2614   if (S_GET_SEGMENT (symbolP) == undefined_section)
2615     {
2616       /* The name might be an undefined .global symbol; be sure to
2617 	 keep the "external" bit.  */
2618       S_SET_SEGMENT (symbolP,
2619 		     (exp.X_op == O_constant
2620 		      ? absolute_section
2621 		      : reg_section));
2622       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2623     }
2624   else
2625     {
2626       as_bad (_("symbol `%s' is already defined"), name);
2627     }
2628 
2629   demand_empty_rest_of_line ();
2630   free (name);
2631   return;
2632 
2633  err_out:
2634   ignore_rest_of_line ();
2635   free (name);
2636   return;
2637 }
2638 
2639 /* Read a line into an sb.  Returns the character that ended the line
2640    or zero if there are no more lines.  */
2641 
2642 static int
get_line_sb(sb * line,int in_macro)2643 get_line_sb (sb *line, int in_macro)
2644 {
2645   char *eol;
2646 
2647   if (input_line_pointer[-1] == '\n')
2648     bump_line_counters ();
2649 
2650   if (input_line_pointer >= buffer_limit)
2651     {
2652       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2653       if (buffer_limit == 0)
2654 	return 0;
2655     }
2656 
2657   eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2658   sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2659   input_line_pointer = eol;
2660 
2661   /* Don't skip multiple end-of-line characters, because that breaks support
2662      for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2663      characters but isn't.  Instead just skip one end of line character and
2664      return the character skipped so that the caller can re-insert it if
2665      necessary.   */
2666   return *input_line_pointer++;
2667 }
2668 
2669 static size_t
get_non_macro_line_sb(sb * line)2670 get_non_macro_line_sb (sb *line)
2671 {
2672   return get_line_sb (line, 0);
2673 }
2674 
2675 static size_t
get_macro_line_sb(sb * line)2676 get_macro_line_sb (sb *line)
2677 {
2678   return get_line_sb (line, 1);
2679 }
2680 
2681 /* Define a macro.  This is an interface to macro.c.  */
2682 
2683 void
s_macro(int ignore ATTRIBUTE_UNUSED)2684 s_macro (int ignore ATTRIBUTE_UNUSED)
2685 {
2686   char *eol;
2687   const char * file;
2688   unsigned int line;
2689   sb s;
2690   const char *err;
2691   const char *name;
2692 
2693   file = as_where (&line);
2694 
2695   eol = find_end_of_line (input_line_pointer, 0);
2696   sb_build (&s, eol - input_line_pointer);
2697   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2698   input_line_pointer = eol;
2699 
2700   if (line_label != NULL)
2701     {
2702       sb label;
2703       size_t len;
2704 
2705       name = S_GET_NAME (line_label);
2706       len = strlen (name);
2707       sb_build (&label, len);
2708       sb_add_buffer (&label, name, len);
2709       err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2710       sb_kill (&label);
2711     }
2712   else
2713     err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2714   if (err != NULL)
2715     as_bad_where (file, line, err, name);
2716   else
2717     {
2718       if (line_label != NULL)
2719 	{
2720 	  S_SET_SEGMENT (line_label, absolute_section);
2721 	  S_SET_VALUE (line_label, 0);
2722 	  symbol_set_frag (line_label, &zero_address_frag);
2723 	}
2724 
2725       if (((NO_PSEUDO_DOT || flag_m68k_mri)
2726 	   && hash_find (po_hash, name) != NULL)
2727 	  || (!flag_m68k_mri
2728 	      && *name == '.'
2729 	      && hash_find (po_hash, name + 1) != NULL))
2730 	as_warn_where (file,
2731 		 line,
2732 		 _("attempt to redefine pseudo-op `%s' ignored"),
2733 		 name);
2734     }
2735 
2736   sb_kill (&s);
2737 }
2738 
2739 /* Handle the .mexit pseudo-op, which immediately exits a macro
2740    expansion.  */
2741 
2742 void
s_mexit(int ignore ATTRIBUTE_UNUSED)2743 s_mexit (int ignore ATTRIBUTE_UNUSED)
2744 {
2745   if (macro_nest)
2746     {
2747       cond_exit_macro (macro_nest);
2748       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2749     }
2750   else
2751     as_warn (_("ignoring macro exit outside a macro definition."));
2752 }
2753 
2754 /* Switch in and out of MRI mode.  */
2755 
2756 void
s_mri(int ignore ATTRIBUTE_UNUSED)2757 s_mri (int ignore ATTRIBUTE_UNUSED)
2758 {
2759   int on;
2760 #ifdef MRI_MODE_CHANGE
2761   int old_flag;
2762 #endif
2763 
2764   on = get_absolute_expression ();
2765 #ifdef MRI_MODE_CHANGE
2766   old_flag = flag_mri;
2767 #endif
2768   if (on != 0)
2769     {
2770       flag_mri = 1;
2771 #ifdef TC_M68K
2772       flag_m68k_mri = 1;
2773 #endif
2774       macro_mri_mode (1);
2775     }
2776   else
2777     {
2778       flag_mri = 0;
2779 #ifdef TC_M68K
2780       flag_m68k_mri = 0;
2781 #endif
2782       macro_mri_mode (0);
2783     }
2784 
2785   /* Operator precedence changes in m68k MRI mode, so we need to
2786      update the operator rankings.  */
2787   expr_set_precedence ();
2788 
2789 #ifdef MRI_MODE_CHANGE
2790   if (on != old_flag)
2791     MRI_MODE_CHANGE (on);
2792 #endif
2793 
2794   demand_empty_rest_of_line ();
2795 }
2796 
2797 /* Handle changing the location counter.  */
2798 
2799 static void
do_org(segT segment,expressionS * exp,int fill)2800 do_org (segT segment, expressionS *exp, int fill)
2801 {
2802   if (segment != now_seg
2803       && segment != absolute_section
2804       && segment != expr_section)
2805     as_bad (_("invalid segment \"%s\""), segment_name (segment));
2806 
2807   if (now_seg == absolute_section)
2808     {
2809       if (fill != 0)
2810 	as_warn (_("ignoring fill value in absolute section"));
2811       if (exp->X_op != O_constant)
2812 	{
2813 	  as_bad (_("only constant offsets supported in absolute section"));
2814 	  exp->X_add_number = 0;
2815 	}
2816       abs_section_offset = exp->X_add_number;
2817     }
2818   else
2819     {
2820       char *p;
2821       symbolS *sym = exp->X_add_symbol;
2822       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2823 
2824       if (fill && in_bss ())
2825 	as_warn (_("ignoring fill value in section `%s'"),
2826 		 segment_name (now_seg));
2827 
2828       if (exp->X_op != O_constant && exp->X_op != O_symbol)
2829 	{
2830 	  /* Handle complex expressions.  */
2831 	  sym = make_expr_symbol (exp);
2832 	  off = 0;
2833 	}
2834 
2835       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2836       *p = fill;
2837     }
2838 }
2839 
2840 void
s_org(int ignore ATTRIBUTE_UNUSED)2841 s_org (int ignore ATTRIBUTE_UNUSED)
2842 {
2843   segT segment;
2844   expressionS exp;
2845   long temp_fill;
2846 
2847 #ifdef md_flush_pending_output
2848   md_flush_pending_output ();
2849 #endif
2850 
2851   /* The m68k MRI assembler has a different meaning for .org.  It
2852      means to create an absolute section at a given address.  We can't
2853      support that--use a linker script instead.  */
2854   if (flag_m68k_mri)
2855     {
2856       as_bad (_("MRI style ORG pseudo-op not supported"));
2857       ignore_rest_of_line ();
2858       return;
2859     }
2860 
2861   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2862      thing as a sub-segment-relative origin.  Any absolute origin is
2863      given a warning, then assumed to be segment-relative.  Any
2864      segmented origin expression ("foo+42") had better be in the right
2865      segment or the .org is ignored.
2866 
2867      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2868      we never know sub-segment sizes when we are reading code.  BSD
2869      will crash trying to emit negative numbers of filler bytes in
2870      certain .orgs. We don't crash, but see as-write for that code.
2871 
2872      Don't make frag if need_pass_2==1.  */
2873   segment = get_known_segmented_expression (&exp);
2874   if (*input_line_pointer == ',')
2875     {
2876       input_line_pointer++;
2877       temp_fill = get_absolute_expression ();
2878     }
2879   else
2880     temp_fill = 0;
2881 
2882   if (!need_pass_2)
2883     do_org (segment, &exp, temp_fill);
2884 
2885   demand_empty_rest_of_line ();
2886 }
2887 
2888 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2889    called by the obj-format routine which handles section changing
2890    when in MRI mode.  It will create a new section, and return it.  It
2891    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2892    'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */
2893 
2894 void
s_mri_sect(char * type ATTRIBUTE_UNUSED)2895 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2896 {
2897 #ifdef TC_M68K
2898 
2899   char *name;
2900   char c;
2901   segT seg;
2902 
2903   SKIP_WHITESPACE ();
2904 
2905   name = input_line_pointer;
2906   if (!ISDIGIT (*name))
2907     c = get_symbol_name (& name);
2908   else
2909     {
2910       do
2911 	{
2912 	  ++input_line_pointer;
2913 	}
2914       while (ISDIGIT (*input_line_pointer));
2915 
2916       c = *input_line_pointer;
2917       *input_line_pointer = '\0';
2918     }
2919 
2920   name = xstrdup (name);
2921 
2922   c = restore_line_pointer (c);
2923 
2924   seg = subseg_new (name, 0);
2925 
2926   if (c == ',')
2927     {
2928       unsigned int align;
2929 
2930       ++input_line_pointer;
2931       align = get_absolute_expression ();
2932       record_alignment (seg, align);
2933     }
2934 
2935   *type = 'C';
2936   if (*input_line_pointer == ',')
2937     {
2938       c = *++input_line_pointer;
2939       c = TOUPPER (c);
2940       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2941 	*type = c;
2942       else
2943 	as_bad (_("unrecognized section type"));
2944       ++input_line_pointer;
2945 
2946       {
2947 	flagword flags;
2948 
2949 	flags = SEC_NO_FLAGS;
2950 	if (*type == 'C')
2951 	  flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2952 	else if (*type == 'D' || *type == 'M')
2953 	  flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2954 	else if (*type == 'R')
2955 	  flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2956 	if (flags != SEC_NO_FLAGS)
2957 	  {
2958 	    if (!bfd_set_section_flags (stdoutput, seg, flags))
2959 	      as_warn (_("error setting flags for \"%s\": %s"),
2960 		       bfd_section_name (stdoutput, seg),
2961 		       bfd_errmsg (bfd_get_error ()));
2962 	  }
2963       }
2964     }
2965 
2966   /* Ignore the HP type.  */
2967   if (*input_line_pointer == ',')
2968     input_line_pointer += 2;
2969 
2970   demand_empty_rest_of_line ();
2971 
2972 #else /* ! TC_M68K */
2973 #ifdef TC_I960
2974 
2975   char *name;
2976   char c;
2977   segT seg;
2978 
2979   SKIP_WHITESPACE ();
2980 
2981   c = get_symbol_name (& name);
2982 
2983   name = xstrdup (name);
2984 
2985   c = restore_line_pointer (c);
2986 
2987   seg = subseg_new (name, 0);
2988 
2989   if (c != ',')
2990     *type = 'C';
2991   else
2992     {
2993       char *sectype;
2994 
2995       ++input_line_pointer;
2996       SKIP_WHITESPACE ();
2997       c = get_symbol_name (& sectype);
2998       if (*sectype == '\0')
2999 	*type = 'C';
3000       else if (strcasecmp (sectype, "text") == 0)
3001 	*type = 'C';
3002       else if (strcasecmp (sectype, "data") == 0)
3003 	*type = 'D';
3004       else if (strcasecmp (sectype, "romdata") == 0)
3005 	*type = 'R';
3006       else
3007 	as_warn (_("unrecognized section type `%s'"), sectype);
3008       (void) restore_line_pointer (c);
3009     }
3010 
3011   if (*input_line_pointer == ',')
3012     {
3013       char *seccmd;
3014 
3015       ++input_line_pointer;
3016       SKIP_WHITESPACE ();
3017       c = get_symbol_name (& seccmd);
3018       if (strcasecmp (seccmd, "absolute") == 0)
3019 	{
3020 	  as_bad (_("absolute sections are not supported"));
3021 	  *input_line_pointer = c;
3022 	  ignore_rest_of_line ();
3023 	  return;
3024 	}
3025       else if (strcasecmp (seccmd, "align") == 0)
3026 	{
3027 	  unsigned int align;
3028 
3029 	  (void) restore_line_pointer (c);
3030 	  align = get_absolute_expression ();
3031 	  record_alignment (seg, align);
3032 	}
3033       else
3034 	{
3035 	  as_warn (_("unrecognized section command `%s'"), seccmd);
3036 	  (void) restore_line_pointer (c);
3037 	}
3038     }
3039 
3040   demand_empty_rest_of_line ();
3041 
3042 #else /* ! TC_I960 */
3043   /* The MRI assembler seems to use different forms of .sect for
3044      different targets.  */
3045   as_bad ("MRI mode not supported for this target");
3046   ignore_rest_of_line ();
3047 #endif /* ! TC_I960 */
3048 #endif /* ! TC_M68K */
3049 }
3050 
3051 /* Handle the .print pseudo-op.  */
3052 
3053 void
s_print(int ignore ATTRIBUTE_UNUSED)3054 s_print (int ignore ATTRIBUTE_UNUSED)
3055 {
3056   char *s;
3057   int len;
3058 
3059   s = demand_copy_C_string (&len);
3060   if (s != NULL)
3061     printf ("%s\n", s);
3062   demand_empty_rest_of_line ();
3063 }
3064 
3065 /* Handle the .purgem pseudo-op.  */
3066 
3067 void
s_purgem(int ignore ATTRIBUTE_UNUSED)3068 s_purgem (int ignore ATTRIBUTE_UNUSED)
3069 {
3070   if (is_it_end_of_statement ())
3071     {
3072       demand_empty_rest_of_line ();
3073       return;
3074     }
3075 
3076   do
3077     {
3078       char *name;
3079       char c;
3080 
3081       SKIP_WHITESPACE ();
3082       c = get_symbol_name (& name);
3083       delete_macro (name);
3084       *input_line_pointer = c;
3085       SKIP_WHITESPACE_AFTER_NAME ();
3086     }
3087   while (*input_line_pointer++ == ',');
3088 
3089   --input_line_pointer;
3090   demand_empty_rest_of_line ();
3091 }
3092 
3093 /* Handle the .endm/.endr pseudo-ops.  */
3094 
3095 static void
s_bad_end(int endr)3096 s_bad_end (int endr)
3097 {
3098   as_warn (_(".end%c encountered without preceding %s"),
3099 	   endr ? 'r' : 'm',
3100 	   endr ? ".rept, .irp, or .irpc" : ".macro");
3101   demand_empty_rest_of_line ();
3102 }
3103 
3104 /* Handle the .rept pseudo-op.  */
3105 
3106 void
s_rept(int ignore ATTRIBUTE_UNUSED)3107 s_rept (int ignore ATTRIBUTE_UNUSED)
3108 {
3109   int count;
3110 
3111   count = get_absolute_expression ();
3112 
3113   do_repeat (count, "REPT", "ENDR");
3114 }
3115 
3116 /* This function provides a generic repeat block implementation.   It allows
3117    different directives to be used as the start/end keys.  */
3118 
3119 void
do_repeat(int count,const char * start,const char * end)3120 do_repeat (int count, const char *start, const char *end)
3121 {
3122   sb one;
3123   sb many;
3124 
3125   sb_new (&one);
3126   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3127     {
3128       as_bad (_("%s without %s"), start, end);
3129       return;
3130     }
3131 
3132   sb_build (&many, count * one.len);
3133   while (count-- > 0)
3134     sb_add_sb (&many, &one);
3135 
3136   sb_kill (&one);
3137 
3138   input_scrub_include_sb (&many, input_line_pointer, 1);
3139   sb_kill (&many);
3140   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3141 }
3142 
3143 /* Like do_repeat except that any text matching EXPANDER in the
3144    block is replaced by the itteration count.  */
3145 
3146 void
do_repeat_with_expander(int count,const char * start,const char * end,const char * expander)3147 do_repeat_with_expander (int count,
3148 			 const char * start,
3149 			 const char * end,
3150 			 const char * expander)
3151 {
3152   sb one;
3153   sb many;
3154 
3155   sb_new (&one);
3156   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3157     {
3158       as_bad (_("%s without %s"), start, end);
3159       return;
3160     }
3161 
3162   sb_new (&many);
3163 
3164   if (expander != NULL && strstr (one.ptr, expander) != NULL)
3165     {
3166       while (count -- > 0)
3167 	{
3168 	  int len;
3169 	  char * sub;
3170 	  sb processed;
3171 
3172 	  sb_build (& processed, one.len);
3173 	  sb_add_sb (& processed, & one);
3174 	  sub = strstr (processed.ptr, expander);
3175 	  len = sprintf (sub, "%d", count);
3176 	  gas_assert (len < 8);
3177 	  strcpy (sub + len, sub + 8);
3178 	  processed.len -= (8 - len);
3179 	  sb_add_sb (& many, & processed);
3180 	  sb_kill (& processed);
3181 	}
3182     }
3183   else
3184     while (count-- > 0)
3185       sb_add_sb (&many, &one);
3186 
3187   sb_kill (&one);
3188 
3189   input_scrub_include_sb (&many, input_line_pointer, 1);
3190   sb_kill (&many);
3191   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3192 }
3193 
3194 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3195    input buffers to skip.  Assumes that conditionals preceding the loop end
3196    are properly nested.
3197 
3198    This function makes it easier to implement a premature "break" out of the
3199    loop.  The EXTRA arg accounts for other buffers we might have inserted,
3200    such as line substitutions.  */
3201 
3202 void
end_repeat(int extra)3203 end_repeat (int extra)
3204 {
3205   cond_exit_macro (macro_nest);
3206   while (extra-- >= 0)
3207     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3208 }
3209 
3210 static void
assign_symbol(char * name,int mode)3211 assign_symbol (char *name, int mode)
3212 {
3213   symbolS *symbolP;
3214 
3215   if (name[0] == '.' && name[1] == '\0')
3216     {
3217       /* Turn '. = mumble' into a .org mumble.  */
3218       segT segment;
3219       expressionS exp;
3220 
3221       segment = get_known_segmented_expression (&exp);
3222 
3223       if (!need_pass_2)
3224 	do_org (segment, &exp, 0);
3225 
3226       return;
3227     }
3228 
3229   if ((symbolP = symbol_find (name)) == NULL
3230       && (symbolP = md_undefined_symbol (name)) == NULL)
3231     {
3232       symbolP = symbol_find_or_make (name);
3233 #ifndef NO_LISTING
3234       /* When doing symbol listings, play games with dummy fragments living
3235 	 outside the normal fragment chain to record the file and line info
3236 	 for this symbol.  */
3237       if (listing & LISTING_SYMBOLS)
3238 	{
3239 	  extern struct list_info_struct *listing_tail;
3240 	  fragS *dummy_frag = XCNEW (fragS);
3241 	  dummy_frag->line = listing_tail;
3242 	  dummy_frag->fr_symbol = symbolP;
3243 	  symbol_set_frag (symbolP, dummy_frag);
3244 	}
3245 #endif
3246 #if defined (OBJ_COFF) && !defined (TE_PE)
3247       /* "set" symbols are local unless otherwise specified.  */
3248       SF_SET_LOCAL (symbolP);
3249 #endif
3250     }
3251 
3252   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3253     {
3254       if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3255 	  && !S_CAN_BE_REDEFINED (symbolP))
3256 	{
3257 	  as_bad (_("symbol `%s' is already defined"), name);
3258 	  ignore_rest_of_line ();
3259 	  input_line_pointer--;
3260 	  return;
3261 	}
3262       /* If the symbol is volatile, copy the symbol and replace the
3263 	 original with the copy, so that previous uses of the symbol will
3264 	 retain the value of the symbol at the point of use.  */
3265       else if (S_IS_VOLATILE (symbolP))
3266 	symbolP = symbol_clone (symbolP, 1);
3267     }
3268 
3269   if (mode == 0)
3270     S_SET_VOLATILE (symbolP);
3271   else if (mode < 0)
3272     S_SET_FORWARD_REF (symbolP);
3273 
3274   pseudo_set (symbolP);
3275 }
3276 
3277 /* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
3278    then this is .equiv, and it is an error if the symbol is already
3279    defined.  If EQUIV is -1, the symbol additionally is a forward
3280    reference.  */
3281 
3282 void
s_set(int equiv)3283 s_set (int equiv)
3284 {
3285   char *name;
3286 
3287   /* Especial apologies for the random logic:
3288      this just grew, and could be parsed much more simply!
3289      Dean in haste.  */
3290   if ((name = read_symbol_name ()) == NULL)
3291     return;
3292 
3293   if (*input_line_pointer != ',')
3294     {
3295       as_bad (_("expected comma after \"%s\""), name);
3296       ignore_rest_of_line ();
3297       free (name);
3298       return;
3299     }
3300 
3301   input_line_pointer++;
3302   assign_symbol (name, equiv);
3303   demand_empty_rest_of_line ();
3304   free (name);
3305 }
3306 
3307 void
s_space(int mult)3308 s_space (int mult)
3309 {
3310   expressionS exp;
3311   expressionS val;
3312   char *p = 0;
3313   char *stop = NULL;
3314   char stopc = 0;
3315   int bytes;
3316 
3317 #ifdef md_flush_pending_output
3318   md_flush_pending_output ();
3319 #endif
3320 
3321 #ifdef md_cons_align
3322   md_cons_align (1);
3323 #endif
3324 
3325   if (flag_mri)
3326     stop = mri_comment_field (&stopc);
3327 
3328   /* In m68k MRI mode, we need to align to a word boundary, unless
3329      this is ds.b.  */
3330   if (flag_m68k_mri && mult > 1)
3331     {
3332       if (now_seg == absolute_section)
3333 	{
3334 	  abs_section_offset += abs_section_offset & 1;
3335 	  if (line_label != NULL)
3336 	    S_SET_VALUE (line_label, abs_section_offset);
3337 	}
3338       else if (mri_common_symbol != NULL)
3339 	{
3340 	  valueT mri_val;
3341 
3342 	  mri_val = S_GET_VALUE (mri_common_symbol);
3343 	  if ((mri_val & 1) != 0)
3344 	    {
3345 	      S_SET_VALUE (mri_common_symbol, mri_val + 1);
3346 	      if (line_label != NULL)
3347 		{
3348 		  expressionS *symexp;
3349 
3350 		  symexp = symbol_get_value_expression (line_label);
3351 		  know (symexp->X_op == O_symbol);
3352 		  know (symexp->X_add_symbol == mri_common_symbol);
3353 		  symexp->X_add_number += 1;
3354 		}
3355 	    }
3356 	}
3357       else
3358 	{
3359 	  do_align (1, (char *) NULL, 0, 0);
3360 	  if (line_label != NULL)
3361 	    {
3362 	      symbol_set_frag (line_label, frag_now);
3363 	      S_SET_VALUE (line_label, frag_now_fix ());
3364 	    }
3365 	}
3366     }
3367 
3368   bytes = mult;
3369 
3370   expression (&exp);
3371 
3372   SKIP_WHITESPACE ();
3373   if (*input_line_pointer == ',')
3374     {
3375       ++input_line_pointer;
3376       expression (&val);
3377     }
3378   else
3379     {
3380       val.X_op = O_constant;
3381       val.X_add_number = 0;
3382     }
3383 
3384   if ((val.X_op != O_constant
3385        || val.X_add_number < - 0x80
3386        || val.X_add_number > 0xff
3387        || (mult != 0 && mult != 1 && val.X_add_number != 0))
3388       && (now_seg != absolute_section && !in_bss ()))
3389     {
3390       resolve_expression (&exp);
3391       if (exp.X_op != O_constant)
3392 	as_bad (_("unsupported variable size or fill value"));
3393       else
3394 	{
3395 	  offsetT i;
3396 
3397 	  if (mult == 0)
3398 	    mult = 1;
3399 	  bytes = mult * exp.X_add_number;
3400 	  for (i = 0; i < exp.X_add_number; i++)
3401 	    emit_expr (&val, mult);
3402 	}
3403     }
3404   else
3405     {
3406       if (now_seg == absolute_section || mri_common_symbol != NULL)
3407 	resolve_expression (&exp);
3408 
3409       if (exp.X_op == O_constant)
3410 	{
3411 	  offsetT repeat;
3412 
3413 	  repeat = exp.X_add_number;
3414 	  if (mult)
3415 	    repeat *= mult;
3416 	  bytes = repeat;
3417 	  if (repeat <= 0)
3418 	    {
3419 	      if (!flag_mri)
3420 		as_warn (_(".space repeat count is zero, ignored"));
3421 	      else if (repeat < 0)
3422 		as_warn (_(".space repeat count is negative, ignored"));
3423 	      goto getout;
3424 	    }
3425 
3426 	  /* If we are in the absolute section, just bump the offset.  */
3427 	  if (now_seg == absolute_section)
3428 	    {
3429 	      if (val.X_op != O_constant || val.X_add_number != 0)
3430 		as_warn (_("ignoring fill value in absolute section"));
3431 	      abs_section_offset += repeat;
3432 	      goto getout;
3433 	    }
3434 
3435 	  /* If we are secretly in an MRI common section, then
3436 	     creating space just increases the size of the common
3437 	     symbol.  */
3438 	  if (mri_common_symbol != NULL)
3439 	    {
3440 	      S_SET_VALUE (mri_common_symbol,
3441 			   S_GET_VALUE (mri_common_symbol) + repeat);
3442 	      goto getout;
3443 	    }
3444 
3445 	  if (!need_pass_2)
3446 	    p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3447 			  (offsetT) repeat, (char *) 0);
3448 	}
3449       else
3450 	{
3451 	  if (now_seg == absolute_section)
3452 	    {
3453 	      as_bad (_("space allocation too complex in absolute section"));
3454 	      subseg_set (text_section, 0);
3455 	    }
3456 
3457 	  if (mri_common_symbol != NULL)
3458 	    {
3459 	      as_bad (_("space allocation too complex in common section"));
3460 	      mri_common_symbol = NULL;
3461 	    }
3462 
3463 	  if (!need_pass_2)
3464 	    p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3465 			  make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3466 	}
3467 
3468       if ((val.X_op != O_constant || val.X_add_number != 0) && in_bss ())
3469 	as_warn (_("ignoring fill value in section `%s'"),
3470 		 segment_name (now_seg));
3471       else if (p)
3472 	*p = val.X_add_number;
3473     }
3474 
3475  getout:
3476 
3477   /* In MRI mode, after an odd number of bytes, we must align to an
3478      even word boundary, unless the next instruction is a dc.b, ds.b
3479      or dcb.b.  */
3480   if (flag_mri && (bytes & 1) != 0)
3481     mri_pending_align = 1;
3482 
3483   demand_empty_rest_of_line ();
3484 
3485   if (flag_mri)
3486     mri_comment_end (stop, stopc);
3487 }
3488 
3489 /* This is like s_space, but the value is a floating point number with
3490    the given precision.  This is for the MRI dcb.s pseudo-op and
3491    friends.  */
3492 
3493 void
s_float_space(int float_type)3494 s_float_space (int float_type)
3495 {
3496   offsetT count;
3497   int flen;
3498   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3499   char *stop = NULL;
3500   char stopc = 0;
3501 
3502 #ifdef md_cons_align
3503   md_cons_align (1);
3504 #endif
3505 
3506   if (flag_mri)
3507     stop = mri_comment_field (&stopc);
3508 
3509   count = get_absolute_expression ();
3510 
3511   SKIP_WHITESPACE ();
3512   if (*input_line_pointer != ',')
3513     {
3514       as_bad (_("missing value"));
3515       ignore_rest_of_line ();
3516       if (flag_mri)
3517 	mri_comment_end (stop, stopc);
3518       return;
3519     }
3520 
3521   ++input_line_pointer;
3522 
3523   SKIP_WHITESPACE ();
3524 
3525   /* Skip any 0{letter} that may be present.  Don't even check if the
3526    * letter is legal.  */
3527   if (input_line_pointer[0] == '0'
3528       && ISALPHA (input_line_pointer[1]))
3529     input_line_pointer += 2;
3530 
3531   /* Accept :xxxx, where the x's are hex digits, for a floating point
3532      with the exact digits specified.  */
3533   if (input_line_pointer[0] == ':')
3534     {
3535       flen = hex_float (float_type, temp);
3536       if (flen < 0)
3537 	{
3538 	  ignore_rest_of_line ();
3539 	  if (flag_mri)
3540 	    mri_comment_end (stop, stopc);
3541 	  return;
3542 	}
3543     }
3544   else
3545     {
3546       const char *err;
3547 
3548       err = md_atof (float_type, temp, &flen);
3549       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3550       know (err != NULL || flen > 0);
3551       if (err)
3552 	{
3553 	  as_bad (_("bad floating literal: %s"), err);
3554 	  ignore_rest_of_line ();
3555 	  if (flag_mri)
3556 	    mri_comment_end (stop, stopc);
3557 	  return;
3558 	}
3559     }
3560 
3561   while (--count >= 0)
3562     {
3563       char *p;
3564 
3565       p = frag_more (flen);
3566       memcpy (p, temp, (unsigned int) flen);
3567     }
3568 
3569   demand_empty_rest_of_line ();
3570 
3571   if (flag_mri)
3572     mri_comment_end (stop, stopc);
3573 }
3574 
3575 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
3576 
3577 void
s_struct(int ignore ATTRIBUTE_UNUSED)3578 s_struct (int ignore ATTRIBUTE_UNUSED)
3579 {
3580   char *stop = NULL;
3581   char stopc = 0;
3582 
3583   if (flag_mri)
3584     stop = mri_comment_field (&stopc);
3585   abs_section_offset = get_absolute_expression ();
3586 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3587   /* The ELF backend needs to know that we are changing sections, so
3588      that .previous works correctly. */
3589   if (IS_ELF)
3590     obj_elf_section_change_hook ();
3591 #endif
3592   subseg_set (absolute_section, 0);
3593   demand_empty_rest_of_line ();
3594   if (flag_mri)
3595     mri_comment_end (stop, stopc);
3596 }
3597 
3598 void
s_text(int ignore ATTRIBUTE_UNUSED)3599 s_text (int ignore ATTRIBUTE_UNUSED)
3600 {
3601   int temp;
3602 
3603   temp = get_absolute_expression ();
3604   subseg_set (text_section, (subsegT) temp);
3605   demand_empty_rest_of_line ();
3606 }
3607 
3608 /* .weakref x, y sets x as an alias to y that, as long as y is not
3609    referenced directly, will cause y to become a weak symbol.  */
3610 void
s_weakref(int ignore ATTRIBUTE_UNUSED)3611 s_weakref (int ignore ATTRIBUTE_UNUSED)
3612 {
3613   char *name;
3614   symbolS *symbolP;
3615   symbolS *symbolP2;
3616   expressionS exp;
3617 
3618   if ((name = read_symbol_name ()) == NULL)
3619     return;
3620 
3621   symbolP = symbol_find_or_make (name);
3622 
3623   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3624     {
3625       if (!S_IS_VOLATILE (symbolP))
3626 	{
3627 	  as_bad (_("symbol `%s' is already defined"), name);
3628 	  goto err_out;
3629 	}
3630       symbolP = symbol_clone (symbolP, 1);
3631       S_CLEAR_VOLATILE (symbolP);
3632     }
3633 
3634   SKIP_WHITESPACE ();
3635 
3636   if (*input_line_pointer != ',')
3637     {
3638       as_bad (_("expected comma after \"%s\""), name);
3639       goto err_out;
3640     }
3641 
3642   input_line_pointer++;
3643 
3644   SKIP_WHITESPACE ();
3645   free (name);
3646 
3647   if ((name = read_symbol_name ()) == NULL)
3648     return;
3649 
3650   if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3651       && (symbolP2 = md_undefined_symbol (name)) == NULL)
3652     {
3653       symbolP2 = symbol_find_or_make (name);
3654       S_SET_WEAKREFD (symbolP2);
3655     }
3656   else
3657     {
3658       symbolS *symp = symbolP2;
3659 
3660       while (S_IS_WEAKREFR (symp) && symp != symbolP)
3661 	{
3662 	  expressionS *expP = symbol_get_value_expression (symp);
3663 
3664 	  gas_assert (expP->X_op == O_symbol
3665 		  && expP->X_add_number == 0);
3666 	  symp = expP->X_add_symbol;
3667 	}
3668       if (symp == symbolP)
3669 	{
3670 	  char *loop;
3671 
3672 	  loop = concat (S_GET_NAME (symbolP),
3673 			 " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3674 
3675 	  symp = symbolP2;
3676 	  while (symp != symbolP)
3677 	    {
3678 	      char *old_loop = loop;
3679 
3680 	      symp = symbol_get_value_expression (symp)->X_add_symbol;
3681 	      loop = concat (loop, " => ", S_GET_NAME (symp),
3682 			     (const char *) NULL);
3683 	      free (old_loop);
3684 	    }
3685 
3686 	  as_bad (_("%s: would close weakref loop: %s"),
3687 		  S_GET_NAME (symbolP), loop);
3688 
3689 	  free (loop);
3690 	  free (name);
3691 	  ignore_rest_of_line ();
3692 	  return;
3693 	}
3694 
3695       /* Short-circuiting instead of just checking here might speed
3696 	 things up a tiny little bit, but loop error messages would
3697 	 miss intermediate links.  */
3698       /* symbolP2 = symp; */
3699     }
3700 
3701   memset (&exp, 0, sizeof (exp));
3702   exp.X_op = O_symbol;
3703   exp.X_add_symbol = symbolP2;
3704 
3705   S_SET_SEGMENT (symbolP, undefined_section);
3706   symbol_set_value_expression (symbolP, &exp);
3707   symbol_set_frag (symbolP, &zero_address_frag);
3708   S_SET_WEAKREFR (symbolP);
3709 
3710   demand_empty_rest_of_line ();
3711   free (name);
3712   return;
3713 
3714  err_out:
3715   ignore_rest_of_line ();
3716   free (name);
3717   return;
3718 }
3719 
3720 
3721 /* Verify that we are at the end of a line.  If not, issue an error and
3722    skip to EOL.  */
3723 
3724 void
demand_empty_rest_of_line(void)3725 demand_empty_rest_of_line (void)
3726 {
3727   SKIP_WHITESPACE ();
3728   if (is_end_of_line[(unsigned char) *input_line_pointer])
3729     input_line_pointer++;
3730   else
3731     {
3732       if (ISPRINT (*input_line_pointer))
3733 	as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3734 		 *input_line_pointer);
3735       else
3736 	as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3737 		 *input_line_pointer);
3738       ignore_rest_of_line ();
3739     }
3740 
3741   /* Return pointing just after end-of-line.  */
3742   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3743 }
3744 
3745 /* Silently advance to the end of line.  Use this after already having
3746    issued an error about something bad.  */
3747 
3748 void
ignore_rest_of_line(void)3749 ignore_rest_of_line (void)
3750 {
3751   while (input_line_pointer < buffer_limit
3752 	 && !is_end_of_line[(unsigned char) *input_line_pointer])
3753     input_line_pointer++;
3754 
3755   input_line_pointer++;
3756 
3757   /* Return pointing just after end-of-line.  */
3758   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3759 }
3760 
3761 /* Sets frag for given symbol to zero_address_frag, except when the
3762    symbol frag is already set to a dummy listing frag.  */
3763 
3764 static void
set_zero_frag(symbolS * symbolP)3765 set_zero_frag (symbolS *symbolP)
3766 {
3767   if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3768     symbol_set_frag (symbolP, &zero_address_frag);
3769 }
3770 
3771 /* In:	Pointer to a symbol.
3772 	Input_line_pointer->expression.
3773 
3774    Out:	Input_line_pointer->just after any whitespace after expression.
3775 	Tried to set symbol to value of expression.
3776 	Will change symbols type, value, and frag;  */
3777 
3778 void
pseudo_set(symbolS * symbolP)3779 pseudo_set (symbolS *symbolP)
3780 {
3781   expressionS exp;
3782   segT seg;
3783 
3784   know (symbolP);		/* NULL pointer is logic error.  */
3785 
3786   if (!S_IS_FORWARD_REF (symbolP))
3787     (void) expression (&exp);
3788   else
3789     (void) deferred_expression (&exp);
3790 
3791   if (exp.X_op == O_illegal)
3792     as_bad (_("illegal expression"));
3793   else if (exp.X_op == O_absent)
3794     as_bad (_("missing expression"));
3795   else if (exp.X_op == O_big)
3796     {
3797       if (exp.X_add_number > 0)
3798 	as_bad (_("bignum invalid"));
3799       else
3800 	as_bad (_("floating point number invalid"));
3801     }
3802   else if (exp.X_op == O_subtract
3803 	   && !S_IS_FORWARD_REF (symbolP)
3804 	   && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3805 	   && (symbol_get_frag (exp.X_add_symbol)
3806 	       == symbol_get_frag (exp.X_op_symbol)))
3807     {
3808       exp.X_op = O_constant;
3809       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3810 			  - S_GET_VALUE (exp.X_op_symbol));
3811     }
3812 
3813   if (symbol_section_p (symbolP))
3814     {
3815       as_bad ("attempt to set value of section symbol");
3816       return;
3817     }
3818 
3819   switch (exp.X_op)
3820     {
3821     case O_illegal:
3822     case O_absent:
3823     case O_big:
3824       exp.X_add_number = 0;
3825       /* Fall through.  */
3826     case O_constant:
3827       S_SET_SEGMENT (symbolP, absolute_section);
3828       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3829       set_zero_frag (symbolP);
3830       break;
3831 
3832     case O_register:
3833 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3834       if (S_IS_EXTERNAL (symbolP))
3835 	{
3836 	  as_bad ("can't equate global symbol `%s' with register name",
3837 		  S_GET_NAME (symbolP));
3838 	  return;
3839 	}
3840 #endif
3841       S_SET_SEGMENT (symbolP, reg_section);
3842       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3843       set_zero_frag (symbolP);
3844       symbol_get_value_expression (symbolP)->X_op = O_register;
3845       break;
3846 
3847     case O_symbol:
3848       seg = S_GET_SEGMENT (exp.X_add_symbol);
3849       /* For x=undef+const, create an expression symbol.
3850 	 For x=x+const, just update x except when x is an undefined symbol
3851 	 For x=defined+const, evaluate x.  */
3852       if (symbolP == exp.X_add_symbol
3853 	  && (seg != undefined_section
3854 	      || !symbol_constant_p (symbolP)))
3855 	{
3856 	  *symbol_X_add_number (symbolP) += exp.X_add_number;
3857 	  break;
3858 	}
3859       else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3860 	{
3861 	  symbolS *s = exp.X_add_symbol;
3862 
3863 	  if (S_IS_COMMON (s))
3864 	    as_bad (_("`%s' can't be equated to common symbol '%s'"),
3865 		    S_GET_NAME (symbolP), S_GET_NAME (s));
3866 
3867 	  S_SET_SEGMENT (symbolP, seg);
3868 	  S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3869 	  symbol_set_frag (symbolP, symbol_get_frag (s));
3870 	  copy_symbol_attributes (symbolP, s);
3871 	  break;
3872 	}
3873       S_SET_SEGMENT (symbolP, undefined_section);
3874       symbol_set_value_expression (symbolP, &exp);
3875       copy_symbol_attributes (symbolP, exp.X_add_symbol);
3876       set_zero_frag (symbolP);
3877       break;
3878 
3879     default:
3880       /* The value is some complex expression.  */
3881       S_SET_SEGMENT (symbolP, expr_section);
3882       symbol_set_value_expression (symbolP, &exp);
3883       set_zero_frag (symbolP);
3884       break;
3885     }
3886 }
3887 
3888 /*			cons()
3889 
3890    CONStruct more frag of .bytes, or .words etc.
3891    Should need_pass_2 be 1 then emit no frag(s).
3892    This understands EXPRESSIONS.
3893 
3894    Bug (?)
3895 
3896    This has a split personality. We use expression() to read the
3897    value. We can detect if the value won't fit in a byte or word.
3898    But we can't detect if expression() discarded significant digits
3899    in the case of a long. Not worth the crocks required to fix it.  */
3900 
3901 /* Select a parser for cons expressions.  */
3902 
3903 /* Some targets need to parse the expression in various fancy ways.
3904    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3905    (for example, the HPPA does this).  Otherwise, you can define
3906    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3907    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
3908    are defined, which is the normal case, then only simple expressions
3909    are permitted.  */
3910 
3911 #ifdef TC_M68K
3912 static void
3913 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3914 #endif
3915 
3916 #ifndef TC_PARSE_CONS_EXPRESSION
3917 #ifdef BITFIELD_CONS_EXPRESSIONS
3918 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3919   (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3920 static void
3921 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3922 #endif
3923 #ifdef REPEAT_CONS_EXPRESSIONS
3924 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3925   (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3926 static void
3927 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3928 #endif
3929 
3930 /* If we haven't gotten one yet, just call expression.  */
3931 #ifndef TC_PARSE_CONS_EXPRESSION
3932 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3933   (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3934 #endif
3935 #endif
3936 
3937 void
do_parse_cons_expression(expressionS * exp,int nbytes ATTRIBUTE_UNUSED)3938 do_parse_cons_expression (expressionS *exp,
3939 			  int nbytes ATTRIBUTE_UNUSED)
3940 {
3941   (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3942 }
3943 
3944 
3945 /* Worker to do .byte etc statements.
3946    Clobbers input_line_pointer and checks end-of-line.  */
3947 
3948 static void
cons_worker(int nbytes,int rva)3949 cons_worker (int nbytes,	/* 1=.byte, 2=.word, 4=.long.  */
3950 	     int rva)
3951 {
3952   int c;
3953   expressionS exp;
3954   char *stop = NULL;
3955   char stopc = 0;
3956 
3957 #ifdef md_flush_pending_output
3958   md_flush_pending_output ();
3959 #endif
3960 
3961   if (flag_mri)
3962     stop = mri_comment_field (&stopc);
3963 
3964   if (is_it_end_of_statement ())
3965     {
3966       demand_empty_rest_of_line ();
3967       if (flag_mri)
3968 	mri_comment_end (stop, stopc);
3969       return;
3970     }
3971 
3972 #ifdef TC_ADDRESS_BYTES
3973   if (nbytes == 0)
3974     nbytes = TC_ADDRESS_BYTES ();
3975 #endif
3976 
3977 #ifdef md_cons_align
3978   md_cons_align (nbytes);
3979 #endif
3980 
3981   c = 0;
3982   do
3983     {
3984       TC_PARSE_CONS_RETURN_TYPE ret = TC_PARSE_CONS_RETURN_NONE;
3985 #ifdef TC_CONS_FIX_CHECK
3986       fixS **cur_fix = &frchain_now->fix_tail;
3987 
3988       if (*cur_fix != NULL)
3989 	cur_fix = &(*cur_fix)->fx_next;
3990 #endif
3991 
3992 #ifdef TC_M68K
3993       if (flag_m68k_mri)
3994 	parse_mri_cons (&exp, (unsigned int) nbytes);
3995       else
3996 #endif
3997 	{
3998 #if 0
3999 	  if (*input_line_pointer == '"')
4000 	    {
4001 	      as_bad (_("unexpected `\"' in expression"));
4002 	      ignore_rest_of_line ();
4003 	      return;
4004 	    }
4005 #endif
4006 	  ret = TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
4007 	}
4008 
4009       if (rva)
4010 	{
4011 	  if (exp.X_op == O_symbol)
4012 	    exp.X_op = O_symbol_rva;
4013 	  else
4014 	    as_fatal (_("rva without symbol"));
4015 	}
4016       emit_expr_with_reloc (&exp, (unsigned int) nbytes, ret);
4017 #ifdef TC_CONS_FIX_CHECK
4018       TC_CONS_FIX_CHECK (&exp, nbytes, *cur_fix);
4019 #endif
4020       ++c;
4021     }
4022   while (*input_line_pointer++ == ',');
4023 
4024   /* In MRI mode, after an odd number of bytes, we must align to an
4025      even word boundary, unless the next instruction is a dc.b, ds.b
4026      or dcb.b.  */
4027   if (flag_mri && nbytes == 1 && (c & 1) != 0)
4028     mri_pending_align = 1;
4029 
4030   input_line_pointer--;		/* Put terminator back into stream.  */
4031 
4032   demand_empty_rest_of_line ();
4033 
4034   if (flag_mri)
4035     mri_comment_end (stop, stopc);
4036 }
4037 
4038 void
cons(int size)4039 cons (int size)
4040 {
4041   cons_worker (size, 0);
4042 }
4043 
4044 void
s_rva(int size)4045 s_rva (int size)
4046 {
4047   cons_worker (size, 1);
4048 }
4049 
4050 /* .reloc offset, reloc_name, symbol+addend.  */
4051 
4052 static void
s_reloc(int ignore ATTRIBUTE_UNUSED)4053 s_reloc (int ignore ATTRIBUTE_UNUSED)
4054 {
4055   char *stop = NULL;
4056   char stopc = 0;
4057   expressionS exp;
4058   char *r_name;
4059   int c;
4060   struct reloc_list *reloc;
4061   struct _bfd_rel { const char * name; bfd_reloc_code_real_type code; };
4062   static struct _bfd_rel bfd_relocs[] =
4063   {
4064     { "NONE", BFD_RELOC_NONE },
4065     { "8",  BFD_RELOC_8 },
4066     { "16", BFD_RELOC_16 },
4067     { "32", BFD_RELOC_32 },
4068     { "64", BFD_RELOC_64 }
4069   };
4070 
4071   reloc = XNEW (struct reloc_list);
4072 
4073   if (flag_mri)
4074     stop = mri_comment_field (&stopc);
4075 
4076   expression (&exp);
4077   switch (exp.X_op)
4078     {
4079     case O_illegal:
4080     case O_absent:
4081     case O_big:
4082     case O_register:
4083       as_bad (_("missing or bad offset expression"));
4084       goto err_out;
4085     case O_constant:
4086       exp.X_add_symbol = section_symbol (now_seg);
4087       exp.X_op = O_symbol;
4088       /* Fall thru */
4089     case O_symbol:
4090       if (exp.X_add_number == 0)
4091 	{
4092 	  reloc->u.a.offset_sym = exp.X_add_symbol;
4093 	  break;
4094 	}
4095       /* Fall thru */
4096     default:
4097       reloc->u.a.offset_sym = make_expr_symbol (&exp);
4098       break;
4099     }
4100 
4101   SKIP_WHITESPACE ();
4102   if (*input_line_pointer != ',')
4103     {
4104       as_bad (_("missing reloc type"));
4105       goto err_out;
4106     }
4107 
4108   ++input_line_pointer;
4109   SKIP_WHITESPACE ();
4110   c = get_symbol_name (& r_name);
4111   if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0)
4112     {
4113       unsigned int i;
4114 
4115       for (reloc->u.a.howto = NULL, i = 0; i < ARRAY_SIZE (bfd_relocs); i++)
4116 	if (strcasecmp (r_name + 10, bfd_relocs[i].name) == 0)
4117 	  {
4118 	    reloc->u.a.howto = bfd_reloc_type_lookup (stdoutput,
4119 						      bfd_relocs[i].code);
4120 	    break;
4121 	  }
4122     }
4123   else
4124     reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
4125   *input_line_pointer = c;
4126   if (reloc->u.a.howto == NULL)
4127     {
4128       as_bad (_("unrecognized reloc type"));
4129       goto err_out;
4130     }
4131 
4132   exp.X_op = O_absent;
4133   SKIP_WHITESPACE_AFTER_NAME ();
4134   if (*input_line_pointer == ',')
4135     {
4136       ++input_line_pointer;
4137       expression (&exp);
4138     }
4139   switch (exp.X_op)
4140     {
4141     case O_illegal:
4142     case O_big:
4143     case O_register:
4144       as_bad (_("bad reloc expression"));
4145     err_out:
4146       ignore_rest_of_line ();
4147       free (reloc);
4148       if (flag_mri)
4149 	mri_comment_end (stop, stopc);
4150       return;
4151     case O_absent:
4152       reloc->u.a.sym = NULL;
4153       reloc->u.a.addend = 0;
4154       break;
4155     case O_constant:
4156       reloc->u.a.sym = NULL;
4157       reloc->u.a.addend = exp.X_add_number;
4158       break;
4159     case O_symbol:
4160       reloc->u.a.sym = exp.X_add_symbol;
4161       reloc->u.a.addend = exp.X_add_number;
4162       break;
4163     default:
4164       reloc->u.a.sym = make_expr_symbol (&exp);
4165       reloc->u.a.addend = 0;
4166       break;
4167     }
4168 
4169   reloc->file = as_where (&reloc->line);
4170   reloc->next = reloc_list;
4171   reloc_list = reloc;
4172 
4173   demand_empty_rest_of_line ();
4174   if (flag_mri)
4175     mri_comment_end (stop, stopc);
4176 }
4177 
4178 /* Put the contents of expression EXP into the object file using
4179    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
4180 
4181 void
emit_expr(expressionS * exp,unsigned int nbytes)4182 emit_expr (expressionS *exp, unsigned int nbytes)
4183 {
4184   emit_expr_with_reloc (exp, nbytes, TC_PARSE_CONS_RETURN_NONE);
4185 }
4186 
4187 void
emit_expr_with_reloc(expressionS * exp,unsigned int nbytes,TC_PARSE_CONS_RETURN_TYPE reloc)4188 emit_expr_with_reloc (expressionS *exp,
4189 		      unsigned int nbytes,
4190 		      TC_PARSE_CONS_RETURN_TYPE reloc)
4191 {
4192   operatorT op;
4193   char *p;
4194   valueT extra_digit = 0;
4195 
4196   /* Don't do anything if we are going to make another pass.  */
4197   if (need_pass_2)
4198     return;
4199 
4200   frag_grow (nbytes);
4201   dot_value = frag_now_fix ();
4202   dot_frag = frag_now;
4203 
4204 #ifndef NO_LISTING
4205 #ifdef OBJ_ELF
4206   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4207      appear as a four byte positive constant in the .line section,
4208      followed by a 2 byte 0xffff.  Look for that case here.  */
4209   {
4210     static int dwarf_line = -1;
4211 
4212     if (strcmp (segment_name (now_seg), ".line") != 0)
4213       dwarf_line = -1;
4214     else if (dwarf_line >= 0
4215 	     && nbytes == 2
4216 	     && exp->X_op == O_constant
4217 	     && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4218       listing_source_line ((unsigned int) dwarf_line);
4219     else if (nbytes == 4
4220 	     && exp->X_op == O_constant
4221 	     && exp->X_add_number >= 0)
4222       dwarf_line = exp->X_add_number;
4223     else
4224       dwarf_line = -1;
4225   }
4226 
4227   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4228      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4229      AT_sibling (0x12) followed by a four byte address of the sibling
4230      followed by a 2 byte AT_name (0x38) followed by the name of the
4231      file.  We look for that case here.  */
4232   {
4233     static int dwarf_file = 0;
4234 
4235     if (strcmp (segment_name (now_seg), ".debug") != 0)
4236       dwarf_file = 0;
4237     else if (dwarf_file == 0
4238 	     && nbytes == 2
4239 	     && exp->X_op == O_constant
4240 	     && exp->X_add_number == 0x11)
4241       dwarf_file = 1;
4242     else if (dwarf_file == 1
4243 	     && nbytes == 2
4244 	     && exp->X_op == O_constant
4245 	     && exp->X_add_number == 0x12)
4246       dwarf_file = 2;
4247     else if (dwarf_file == 2
4248 	     && nbytes == 4)
4249       dwarf_file = 3;
4250     else if (dwarf_file == 3
4251 	     && nbytes == 2
4252 	     && exp->X_op == O_constant
4253 	     && exp->X_add_number == 0x38)
4254       dwarf_file = 4;
4255     else
4256       dwarf_file = 0;
4257 
4258     /* The variable dwarf_file_string tells stringer that the string
4259        may be the name of the source file.  */
4260     if (dwarf_file == 4)
4261       dwarf_file_string = 1;
4262     else
4263       dwarf_file_string = 0;
4264   }
4265 #endif
4266 #endif
4267 
4268   if (check_eh_frame (exp, &nbytes))
4269     return;
4270 
4271   op = exp->X_op;
4272 
4273   /* Handle a negative bignum.  */
4274   if (op == O_uminus
4275       && exp->X_add_number == 0
4276       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4277       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4278     {
4279       int i;
4280       unsigned long carry;
4281 
4282       exp = symbol_get_value_expression (exp->X_add_symbol);
4283 
4284       /* Negate the bignum: one's complement each digit and add 1.  */
4285       carry = 1;
4286       for (i = 0; i < exp->X_add_number; i++)
4287 	{
4288 	  unsigned long next;
4289 
4290 	  next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4291 		   & LITTLENUM_MASK)
4292 		  + carry);
4293 	  generic_bignum[i] = next & LITTLENUM_MASK;
4294 	  carry = next >> LITTLENUM_NUMBER_OF_BITS;
4295 	}
4296 
4297       /* We can ignore any carry out, because it will be handled by
4298 	 extra_digit if it is needed.  */
4299 
4300       extra_digit = (valueT) -1;
4301       op = O_big;
4302     }
4303 
4304   if (op == O_absent || op == O_illegal)
4305     {
4306       as_warn (_("zero assumed for missing expression"));
4307       exp->X_add_number = 0;
4308       op = O_constant;
4309     }
4310   else if (op == O_big && exp->X_add_number <= 0)
4311     {
4312       as_bad (_("floating point number invalid"));
4313       exp->X_add_number = 0;
4314       op = O_constant;
4315     }
4316   else if (op == O_register)
4317     {
4318       as_warn (_("register value used as expression"));
4319       op = O_constant;
4320     }
4321 
4322   /* Allow `.word 0' in the absolute section.  */
4323   if (now_seg == absolute_section)
4324     {
4325       if (op != O_constant || exp->X_add_number != 0)
4326 	as_bad (_("attempt to store value in absolute section"));
4327       abs_section_offset += nbytes;
4328       return;
4329     }
4330 
4331   /* Allow `.word 0' in BSS style sections.  */
4332   if ((op != O_constant || exp->X_add_number != 0) && in_bss ())
4333     as_bad (_("attempt to store non-zero value in section `%s'"),
4334 	    segment_name (now_seg));
4335 
4336   p = frag_more ((int) nbytes);
4337 
4338   if (reloc != TC_PARSE_CONS_RETURN_NONE)
4339     {
4340       emit_expr_fix (exp, nbytes, frag_now, p, reloc);
4341       return;
4342     }
4343 
4344 #ifndef WORKING_DOT_WORD
4345   /* If we have the difference of two symbols in a word, save it on
4346      the broken_words list.  See the code in write.c.  */
4347   if (op == O_subtract && nbytes == 2)
4348     {
4349       struct broken_word *x;
4350 
4351       x = XNEW (struct broken_word);
4352       x->next_broken_word = broken_words;
4353       broken_words = x;
4354       x->seg = now_seg;
4355       x->subseg = now_subseg;
4356       x->frag = frag_now;
4357       x->word_goes_here = p;
4358       x->dispfrag = 0;
4359       x->add = exp->X_add_symbol;
4360       x->sub = exp->X_op_symbol;
4361       x->addnum = exp->X_add_number;
4362       x->added = 0;
4363       x->use_jump = 0;
4364       new_broken_words++;
4365       return;
4366     }
4367 #endif
4368 
4369   /* If we have an integer, but the number of bytes is too large to
4370      pass to md_number_to_chars, handle it as a bignum.  */
4371   if (op == O_constant && nbytes > sizeof (valueT))
4372     {
4373       extra_digit = exp->X_unsigned ? 0 : -1;
4374       convert_to_bignum (exp, !exp->X_unsigned);
4375       op = O_big;
4376     }
4377 
4378   if (op == O_constant)
4379     {
4380       valueT get;
4381       valueT use;
4382       valueT mask;
4383       valueT hibit;
4384       valueT unmask;
4385 
4386       /* JF << of >= number of bits in the object is undefined.  In
4387 	 particular SPARC (Sun 4) has problems.  */
4388       if (nbytes >= sizeof (valueT))
4389 	{
4390 	  mask = 0;
4391 	  if (nbytes > sizeof (valueT))
4392 	    hibit = 0;
4393 	  else
4394 	    hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4395 	}
4396       else
4397 	{
4398 	  /* Don't store these bits.  */
4399 	  mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4400 	  hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4401 	}
4402 
4403       unmask = ~mask;		/* Do store these bits.  */
4404 
4405 #ifdef NEVER
4406       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4407       mask = ~(unmask >> 1);	/* Includes sign bit now.  */
4408 #endif
4409 
4410       get = exp->X_add_number;
4411       use = get & unmask;
4412       if ((get & mask) != 0
4413 	  && ((get & mask) != mask
4414 	      || (get & hibit) == 0))
4415 	{
4416 	  /* Leading bits contain both 0s & 1s.  */
4417 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4418 #ifndef __MSVCRT__
4419 	  as_warn (_("value 0x%llx truncated to 0x%llx"),
4420 		   (unsigned long long) get, (unsigned long long) use);
4421 #else
4422 	  as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4423 		   (unsigned long long) get, (unsigned long long) use);
4424 #endif
4425 #else
4426 	  as_warn (_("value 0x%lx truncated to 0x%lx"),
4427 		   (unsigned long) get, (unsigned long) use);
4428 #endif
4429 	}
4430       /* Put bytes in right order.  */
4431       md_number_to_chars (p, use, (int) nbytes);
4432     }
4433   else if (op == O_big)
4434     {
4435       unsigned int size;
4436       LITTLENUM_TYPE *nums;
4437 
4438       size = exp->X_add_number * CHARS_PER_LITTLENUM;
4439       if (nbytes < size)
4440 	{
4441 	  int i = nbytes / CHARS_PER_LITTLENUM;
4442 
4443 	  if (i != 0)
4444 	    {
4445 	      LITTLENUM_TYPE sign = 0;
4446 	      if ((generic_bignum[--i]
4447 		   & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
4448 		sign = ~(LITTLENUM_TYPE) 0;
4449 
4450 	      while (++i < exp->X_add_number)
4451 		if (generic_bignum[i] != sign)
4452 		  break;
4453 	    }
4454 	  else if (nbytes == 1)
4455 	    {
4456 	      /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4457 		 Check that bits 8.. of generic_bignum[0] match bit 7
4458 		 and that they match all of generic_bignum[1..exp->X_add_number].  */
4459 	      LITTLENUM_TYPE sign = (generic_bignum[0] & (1 << 7)) ? -1 : 0;
4460 	      LITTLENUM_TYPE himask = LITTLENUM_MASK & ~ 0xFF;
4461 
4462 	      if ((generic_bignum[0] & himask) == (sign & himask))
4463 		{
4464 		  while (++i < exp->X_add_number)
4465 		    if (generic_bignum[i] != sign)
4466 		      break;
4467 		}
4468 	    }
4469 
4470 	  if (i < exp->X_add_number)
4471 	    as_warn (_("bignum truncated to %d bytes"), nbytes);
4472 	  size = nbytes;
4473 	}
4474 
4475       if (nbytes == 1)
4476 	{
4477 	  md_number_to_chars (p, (valueT) generic_bignum[0], 1);
4478 	  return;
4479 	}
4480       know (nbytes % CHARS_PER_LITTLENUM == 0);
4481 
4482       if (target_big_endian)
4483 	{
4484 	  while (nbytes > size)
4485 	    {
4486 	      md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4487 	      nbytes -= CHARS_PER_LITTLENUM;
4488 	      p += CHARS_PER_LITTLENUM;
4489 	    }
4490 
4491 	  nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4492 	  while (size >= CHARS_PER_LITTLENUM)
4493 	    {
4494 	      --nums;
4495 	      md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4496 	      size -= CHARS_PER_LITTLENUM;
4497 	      p += CHARS_PER_LITTLENUM;
4498 	    }
4499 	}
4500       else
4501 	{
4502 	  nums = generic_bignum;
4503 	  while (size >= CHARS_PER_LITTLENUM)
4504 	    {
4505 	      md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4506 	      ++nums;
4507 	      size -= CHARS_PER_LITTLENUM;
4508 	      p += CHARS_PER_LITTLENUM;
4509 	      nbytes -= CHARS_PER_LITTLENUM;
4510 	    }
4511 
4512 	  while (nbytes >= CHARS_PER_LITTLENUM)
4513 	    {
4514 	      md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4515 	      nbytes -= CHARS_PER_LITTLENUM;
4516 	      p += CHARS_PER_LITTLENUM;
4517 	    }
4518 	}
4519     }
4520   else
4521     emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE);
4522 }
4523 
4524 void
emit_expr_fix(expressionS * exp,unsigned int nbytes,fragS * frag,char * p,TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED)4525 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p,
4526 	       TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED)
4527 {
4528   int offset = 0;
4529   unsigned int size = nbytes;
4530 
4531   memset (p, 0, size);
4532 
4533   /* Generate a fixS to record the symbol value.  */
4534 
4535 #ifdef TC_CONS_FIX_NEW
4536   TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r);
4537 #else
4538   if (r != TC_PARSE_CONS_RETURN_NONE)
4539     {
4540       reloc_howto_type *reloc_howto;
4541 
4542       reloc_howto = bfd_reloc_type_lookup (stdoutput, r);
4543       size = bfd_get_reloc_size (reloc_howto);
4544 
4545       if (size > nbytes)
4546 	{
4547 	  as_bad (_("%s relocations do not fit in %u bytes\n"),
4548 		  reloc_howto->name, nbytes);
4549 	  return;
4550 	}
4551       else if (target_big_endian)
4552 	offset = nbytes - size;
4553     }
4554   else
4555     switch (size)
4556       {
4557       case 1:
4558 	r = BFD_RELOC_8;
4559 	break;
4560       case 2:
4561 	r = BFD_RELOC_16;
4562 	break;
4563       case 3:
4564 	r = BFD_RELOC_24;
4565 	break;
4566       case 4:
4567 	r = BFD_RELOC_32;
4568 	break;
4569       case 8:
4570 	r = BFD_RELOC_64;
4571 	break;
4572       default:
4573 	as_bad (_("unsupported BFD relocation size %u"), size);
4574 	return;
4575       }
4576   fix_new_exp (frag, p - frag->fr_literal + offset, size,
4577 	       exp, 0, r);
4578 #endif
4579 }
4580 
4581 #ifdef BITFIELD_CONS_EXPRESSIONS
4582 
4583 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4584    w:x,y:z, where w and y are bitwidths and x and y are values.  They
4585    then pack them all together. We do a little better in that we allow
4586    them in words, longs, etc. and we'll pack them in target byte order
4587    for you.
4588 
4589    The rules are: pack least significant bit first, if a field doesn't
4590    entirely fit, put it in the next unit.  Overflowing the bitfield is
4591    explicitly *not* even a warning.  The bitwidth should be considered
4592    a "mask".
4593 
4594    To use this function the tc-XXX.h file should define
4595    BITFIELD_CONS_EXPRESSIONS.  */
4596 
4597 static void
parse_bitfield_cons(expressionS * exp,unsigned int nbytes)4598 parse_bitfield_cons (expressionS *exp, unsigned int nbytes)
4599 {
4600   unsigned int bits_available = BITS_PER_CHAR * nbytes;
4601   char *hold = input_line_pointer;
4602 
4603   (void) expression (exp);
4604 
4605   if (*input_line_pointer == ':')
4606     {
4607       /* Bitfields.  */
4608       long value = 0;
4609 
4610       for (;;)
4611 	{
4612 	  unsigned long width;
4613 
4614 	  if (*input_line_pointer != ':')
4615 	    {
4616 	      input_line_pointer = hold;
4617 	      break;
4618 	    }			/* Next piece is not a bitfield.  */
4619 
4620 	  /* In the general case, we can't allow
4621 	     full expressions with symbol
4622 	     differences and such.  The relocation
4623 	     entries for symbols not defined in this
4624 	     assembly would require arbitrary field
4625 	     widths, positions, and masks which most
4626 	     of our current object formats don't
4627 	     support.
4628 
4629 	     In the specific case where a symbol
4630 	     *is* defined in this assembly, we
4631 	     *could* build fixups and track it, but
4632 	     this could lead to confusion for the
4633 	     backends.  I'm lazy. I'll take any
4634 	     SEG_ABSOLUTE. I think that means that
4635 	     you can use a previous .set or
4636 	     .equ type symbol.  xoxorich.  */
4637 
4638 	  if (exp->X_op == O_absent)
4639 	    {
4640 	      as_warn (_("using a bit field width of zero"));
4641 	      exp->X_add_number = 0;
4642 	      exp->X_op = O_constant;
4643 	    }			/* Implied zero width bitfield.  */
4644 
4645 	  if (exp->X_op != O_constant)
4646 	    {
4647 	      *input_line_pointer = '\0';
4648 	      as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4649 	      *input_line_pointer = ':';
4650 	      demand_empty_rest_of_line ();
4651 	      return;
4652 	    }			/* Too complex.  */
4653 
4654 	  if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4655 	    {
4656 	      as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4657 		       width, nbytes, (BITS_PER_CHAR * nbytes));
4658 	      width = BITS_PER_CHAR * nbytes;
4659 	    }			/* Too big.  */
4660 
4661 	  if (width > bits_available)
4662 	    {
4663 	      /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
4664 	      input_line_pointer = hold;
4665 	      exp->X_add_number = value;
4666 	      break;
4667 	    }			/* Won't fit.  */
4668 
4669 	  /* Skip ':'.  */
4670 	  hold = ++input_line_pointer;
4671 
4672 	  (void) expression (exp);
4673 	  if (exp->X_op != O_constant)
4674 	    {
4675 	      char cache = *input_line_pointer;
4676 
4677 	      *input_line_pointer = '\0';
4678 	      as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4679 	      *input_line_pointer = cache;
4680 	      demand_empty_rest_of_line ();
4681 	      return;
4682 	    }			/* Too complex.  */
4683 
4684 	  value |= ((~(-(1 << width)) & exp->X_add_number)
4685 		    << ((BITS_PER_CHAR * nbytes) - bits_available));
4686 
4687 	  if ((bits_available -= width) == 0
4688 	      || is_it_end_of_statement ()
4689 	      || *input_line_pointer != ',')
4690 	    {
4691 	      break;
4692 	    }			/* All the bitfields we're gonna get.  */
4693 
4694 	  hold = ++input_line_pointer;
4695 	  (void) expression (exp);
4696 	}
4697 
4698       exp->X_add_number = value;
4699       exp->X_op = O_constant;
4700       exp->X_unsigned = 1;
4701       exp->X_extrabit = 0;
4702     }
4703 }
4704 
4705 #endif /* BITFIELD_CONS_EXPRESSIONS */
4706 
4707 /* Handle an MRI style string expression.  */
4708 
4709 #ifdef TC_M68K
4710 static void
parse_mri_cons(expressionS * exp,unsigned int nbytes)4711 parse_mri_cons (expressionS *exp, unsigned int nbytes)
4712 {
4713   if (*input_line_pointer != '\''
4714       && (input_line_pointer[1] != '\''
4715 	  || (*input_line_pointer != 'A'
4716 	      && *input_line_pointer != 'E')))
4717     (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4718   else
4719     {
4720       unsigned int scan;
4721       unsigned int result = 0;
4722 
4723       /* An MRI style string.  Cut into as many bytes as will fit into
4724 	 a nbyte chunk, left justify if necessary, and separate with
4725 	 commas so we can try again later.  */
4726       if (*input_line_pointer == 'A')
4727 	++input_line_pointer;
4728       else if (*input_line_pointer == 'E')
4729 	{
4730 	  as_bad (_("EBCDIC constants are not supported"));
4731 	  ++input_line_pointer;
4732 	}
4733 
4734       input_line_pointer++;
4735       for (scan = 0; scan < nbytes; scan++)
4736 	{
4737 	  if (*input_line_pointer == '\'')
4738 	    {
4739 	      if (input_line_pointer[1] == '\'')
4740 		{
4741 		  input_line_pointer++;
4742 		}
4743 	      else
4744 		break;
4745 	    }
4746 	  result = (result << 8) | (*input_line_pointer++);
4747 	}
4748 
4749       /* Left justify.  */
4750       while (scan < nbytes)
4751 	{
4752 	  result <<= 8;
4753 	  scan++;
4754 	}
4755 
4756       /* Create correct expression.  */
4757       exp->X_op = O_constant;
4758       exp->X_add_number = result;
4759 
4760       /* Fake it so that we can read the next char too.  */
4761       if (input_line_pointer[0] != '\'' ||
4762 	  (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4763 	{
4764 	  input_line_pointer -= 2;
4765 	  input_line_pointer[0] = ',';
4766 	  input_line_pointer[1] = '\'';
4767 	}
4768       else
4769 	input_line_pointer++;
4770     }
4771 }
4772 #endif /* TC_M68K */
4773 
4774 #ifdef REPEAT_CONS_EXPRESSIONS
4775 
4776 /* Parse a repeat expression for cons.  This is used by the MIPS
4777    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
4778    object file COUNT times.
4779 
4780    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
4781 
4782 static void
parse_repeat_cons(expressionS * exp,unsigned int nbytes)4783 parse_repeat_cons (expressionS *exp, unsigned int nbytes)
4784 {
4785   expressionS count;
4786   int i;
4787 
4788   expression (exp);
4789 
4790   if (*input_line_pointer != ':')
4791     {
4792       /* No repeat count.  */
4793       return;
4794     }
4795 
4796   ++input_line_pointer;
4797   expression (&count);
4798   if (count.X_op != O_constant
4799       || count.X_add_number <= 0)
4800     {
4801       as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4802       return;
4803     }
4804 
4805   /* The cons function is going to output this expression once.  So we
4806      output it count - 1 times.  */
4807   for (i = count.X_add_number - 1; i > 0; i--)
4808     emit_expr (exp, nbytes);
4809 }
4810 
4811 #endif /* REPEAT_CONS_EXPRESSIONS */
4812 
4813 /* Parse a floating point number represented as a hex constant.  This
4814    permits users to specify the exact bits they want in the floating
4815    point number.  */
4816 
4817 static int
hex_float(int float_type,char * bytes)4818 hex_float (int float_type, char *bytes)
4819 {
4820   int length;
4821   int i;
4822 
4823   switch (float_type)
4824     {
4825     case 'f':
4826     case 'F':
4827     case 's':
4828     case 'S':
4829       length = 4;
4830       break;
4831 
4832     case 'd':
4833     case 'D':
4834     case 'r':
4835     case 'R':
4836       length = 8;
4837       break;
4838 
4839     case 'x':
4840     case 'X':
4841       length = 12;
4842       break;
4843 
4844     case 'p':
4845     case 'P':
4846       length = 12;
4847       break;
4848 
4849     default:
4850       as_bad (_("unknown floating type type '%c'"), float_type);
4851       return -1;
4852     }
4853 
4854   /* It would be nice if we could go through expression to parse the
4855      hex constant, but if we get a bignum it's a pain to sort it into
4856      the buffer correctly.  */
4857   i = 0;
4858   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4859     {
4860       int d;
4861 
4862       /* The MRI assembler accepts arbitrary underscores strewn about
4863 	 through the hex constant, so we ignore them as well.  */
4864       if (*input_line_pointer == '_')
4865 	{
4866 	  ++input_line_pointer;
4867 	  continue;
4868 	}
4869 
4870       if (i >= length)
4871 	{
4872 	  as_warn (_("floating point constant too large"));
4873 	  return -1;
4874 	}
4875       d = hex_value (*input_line_pointer) << 4;
4876       ++input_line_pointer;
4877       while (*input_line_pointer == '_')
4878 	++input_line_pointer;
4879       if (hex_p (*input_line_pointer))
4880 	{
4881 	  d += hex_value (*input_line_pointer);
4882 	  ++input_line_pointer;
4883 	}
4884       if (target_big_endian)
4885 	bytes[i] = d;
4886       else
4887 	bytes[length - i - 1] = d;
4888       ++i;
4889     }
4890 
4891   if (i < length)
4892     {
4893       if (target_big_endian)
4894 	memset (bytes + i, 0, length - i);
4895       else
4896 	memset (bytes, 0, length - i);
4897     }
4898 
4899   return length;
4900 }
4901 
4902 /*			float_cons()
4903 
4904    CONStruct some more frag chars of .floats .ffloats etc.
4905    Makes 0 or more new frags.
4906    If need_pass_2 == 1, no frags are emitted.
4907    This understands only floating literals, not expressions. Sorry.
4908 
4909    A floating constant is defined by atof_generic(), except it is preceded
4910    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4911    reading, I decided to be incompatible. This always tries to give you
4912    rounded bits to the precision of the pseudo-op. Former AS did premature
4913    truncation, restored noisy bits instead of trailing 0s AND gave you
4914    a choice of 2 flavours of noise according to which of 2 floating-point
4915    scanners you directed AS to use.
4916 
4917    In:	input_line_pointer->whitespace before, or '0' of flonum.  */
4918 
4919 void
float_cons(int float_type)4920 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
4921 	    int float_type	/* 'f':.ffloat ... 'F':.float ...  */)
4922 {
4923   char *p;
4924   int length;			/* Number of chars in an object.  */
4925   const char *err;		/* Error from scanning floating literal.  */
4926   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4927 
4928   if (is_it_end_of_statement ())
4929     {
4930       demand_empty_rest_of_line ();
4931       return;
4932     }
4933 
4934   if (now_seg == absolute_section)
4935     {
4936       as_bad (_("attempt to store float in absolute section"));
4937       ignore_rest_of_line ();
4938       return;
4939     }
4940 
4941   if (in_bss ())
4942     {
4943       as_bad (_("attempt to store float in section `%s'"),
4944 	      segment_name (now_seg));
4945       ignore_rest_of_line ();
4946       return;
4947     }
4948 
4949 #ifdef md_flush_pending_output
4950   md_flush_pending_output ();
4951 #endif
4952 
4953 #ifdef md_cons_align
4954   md_cons_align (1);
4955 #endif
4956 
4957   do
4958     {
4959       /* input_line_pointer->1st char of a flonum (we hope!).  */
4960       SKIP_WHITESPACE ();
4961 
4962       /* Skip any 0{letter} that may be present. Don't even check if the
4963 	 letter is legal. Someone may invent a "z" format and this routine
4964 	 has no use for such information. Lusers beware: you get
4965 	 diagnostics if your input is ill-conditioned.  */
4966       if (input_line_pointer[0] == '0'
4967 	  && ISALPHA (input_line_pointer[1]))
4968 	input_line_pointer += 2;
4969 
4970       /* Accept :xxxx, where the x's are hex digits, for a floating
4971 	 point with the exact digits specified.  */
4972       if (input_line_pointer[0] == ':')
4973 	{
4974 	  ++input_line_pointer;
4975 	  length = hex_float (float_type, temp);
4976 	  if (length < 0)
4977 	    {
4978 	      ignore_rest_of_line ();
4979 	      return;
4980 	    }
4981 	}
4982       else
4983 	{
4984 	  err = md_atof (float_type, temp, &length);
4985 	  know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4986 	  know (err != NULL || length > 0);
4987 	  if (err)
4988 	    {
4989 	      as_bad (_("bad floating literal: %s"), err);
4990 	      ignore_rest_of_line ();
4991 	      return;
4992 	    }
4993 	}
4994 
4995       if (!need_pass_2)
4996 	{
4997 	  int count;
4998 
4999 	  count = 1;
5000 
5001 #ifdef REPEAT_CONS_EXPRESSIONS
5002 	  if (*input_line_pointer == ':')
5003 	    {
5004 	      expressionS count_exp;
5005 
5006 	      ++input_line_pointer;
5007 	      expression (&count_exp);
5008 
5009 	      if (count_exp.X_op != O_constant
5010 		  || count_exp.X_add_number <= 0)
5011 		as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5012 	      else
5013 		count = count_exp.X_add_number;
5014 	    }
5015 #endif
5016 
5017 	  while (--count >= 0)
5018 	    {
5019 	      p = frag_more (length);
5020 	      memcpy (p, temp, (unsigned int) length);
5021 	    }
5022 	}
5023       SKIP_WHITESPACE ();
5024     }
5025   while (*input_line_pointer++ == ',');
5026 
5027   /* Put terminator back into stream.  */
5028   --input_line_pointer;
5029   demand_empty_rest_of_line ();
5030 }
5031 
5032 /* LEB128 Encoding.
5033 
5034    Note - we are using the DWARF standard's definition of LEB128 encoding
5035    where each 7-bit value is a stored in a byte, *not* an octet.  This
5036    means that on targets where a byte contains multiple octets there is
5037    a *huge waste of space*.  (This also means that we do not have to
5038    have special versions of these functions for when OCTETS_PER_BYTE_POWER
5039    is non-zero).
5040 
5041    If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5042    we would then have to consider whether multiple, successive LEB128
5043    values should be packed into the bytes without padding (bad idea) or
5044    whether each LEB128 number is padded out to a whole number of bytes.
5045    Plus you have to decide on the endianness of packing octets into a
5046    byte.  */
5047 
5048 /* Return the size of a LEB128 value in bytes.  */
5049 
5050 static inline unsigned int
sizeof_sleb128(offsetT value)5051 sizeof_sleb128 (offsetT value)
5052 {
5053   int size = 0;
5054   unsigned byte;
5055 
5056   do
5057     {
5058       byte = (value & 0x7f);
5059       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5060 	 Fortunately, we can structure things so that the extra work reduces
5061 	 to a noop on systems that do things "properly".  */
5062       value = (value >> 7) | ~(-(offsetT)1 >> 7);
5063       size += 1;
5064     }
5065   while (!(((value == 0) && ((byte & 0x40) == 0))
5066 	   || ((value == -1) && ((byte & 0x40) != 0))));
5067 
5068   return size;
5069 }
5070 
5071 static inline unsigned int
sizeof_uleb128(valueT value)5072 sizeof_uleb128 (valueT value)
5073 {
5074   int size = 0;
5075 
5076   do
5077     {
5078       value >>= 7;
5079       size += 1;
5080     }
5081   while (value != 0);
5082 
5083   return size;
5084 }
5085 
5086 unsigned int
sizeof_leb128(valueT value,int sign)5087 sizeof_leb128 (valueT value, int sign)
5088 {
5089   if (sign)
5090     return sizeof_sleb128 ((offsetT) value);
5091   else
5092     return sizeof_uleb128 (value);
5093 }
5094 
5095 /* Output a LEB128 value.  Returns the number of bytes used.  */
5096 
5097 static inline unsigned int
output_sleb128(char * p,offsetT value)5098 output_sleb128 (char *p, offsetT value)
5099 {
5100   char *orig = p;
5101   int more;
5102 
5103   do
5104     {
5105       unsigned byte = (value & 0x7f);
5106 
5107       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5108 	 Fortunately, we can structure things so that the extra work reduces
5109 	 to a noop on systems that do things "properly".  */
5110       value = (value >> 7) | ~(-(offsetT)1 >> 7);
5111 
5112       more = !((((value == 0) && ((byte & 0x40) == 0))
5113 		|| ((value == -1) && ((byte & 0x40) != 0))));
5114       if (more)
5115 	byte |= 0x80;
5116 
5117       *p++ = byte;
5118     }
5119   while (more);
5120 
5121   return p - orig;
5122 }
5123 
5124 static inline unsigned int
output_uleb128(char * p,valueT value)5125 output_uleb128 (char *p, valueT value)
5126 {
5127   char *orig = p;
5128 
5129   do
5130     {
5131       unsigned byte = (value & 0x7f);
5132 
5133       value >>= 7;
5134       if (value != 0)
5135 	/* More bytes to follow.  */
5136 	byte |= 0x80;
5137 
5138       *p++ = byte;
5139     }
5140   while (value != 0);
5141 
5142   return p - orig;
5143 }
5144 
5145 unsigned int
output_leb128(char * p,valueT value,int sign)5146 output_leb128 (char *p, valueT value, int sign)
5147 {
5148   if (sign)
5149     return output_sleb128 (p, (offsetT) value);
5150   else
5151     return output_uleb128 (p, value);
5152 }
5153 
5154 /* Do the same for bignums.  We combine sizeof with output here in that
5155    we don't output for NULL values of P.  It isn't really as critical as
5156    for "normal" values that this be streamlined.  Returns the number of
5157    bytes used.  */
5158 
5159 static inline unsigned int
output_big_sleb128(char * p,LITTLENUM_TYPE * bignum,unsigned int size)5160 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size)
5161 {
5162   char *orig = p;
5163   valueT val = 0;
5164   int loaded = 0;
5165   unsigned byte;
5166 
5167   /* Strip leading sign extensions off the bignum.  */
5168   while (size > 1
5169 	 && bignum[size - 1] == LITTLENUM_MASK
5170 	 && bignum[size - 2] > LITTLENUM_MASK / 2)
5171     size--;
5172 
5173   do
5174     {
5175       /* OR in the next part of the littlenum.  */
5176       val |= (*bignum << loaded);
5177       loaded += LITTLENUM_NUMBER_OF_BITS;
5178       size--;
5179       bignum++;
5180 
5181       /* Add bytes until there are less than 7 bits left in VAL
5182 	 or until every non-sign bit has been written.  */
5183       do
5184 	{
5185 	  byte = val & 0x7f;
5186 	  loaded -= 7;
5187 	  val >>= 7;
5188 	  if (size > 0
5189 	      || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
5190 	    byte |= 0x80;
5191 
5192 	  if (orig)
5193 	    *p = byte;
5194 	  p++;
5195 	}
5196       while ((byte & 0x80) != 0 && loaded >= 7);
5197     }
5198   while (size > 0);
5199 
5200   /* Mop up any left-over bits (of which there will be less than 7).  */
5201   if ((byte & 0x80) != 0)
5202     {
5203       /* Sign-extend VAL.  */
5204       if (val & (1 << (loaded - 1)))
5205 	val |= ~0U << loaded;
5206       if (orig)
5207 	*p = val & 0x7f;
5208       p++;
5209     }
5210 
5211   return p - orig;
5212 }
5213 
5214 static inline unsigned int
output_big_uleb128(char * p,LITTLENUM_TYPE * bignum,unsigned int size)5215 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size)
5216 {
5217   char *orig = p;
5218   valueT val = 0;
5219   int loaded = 0;
5220   unsigned byte;
5221 
5222   /* Strip leading zeros off the bignum.  */
5223   /* XXX: Is this needed?  */
5224   while (size > 0 && bignum[size - 1] == 0)
5225     size--;
5226 
5227   do
5228     {
5229       if (loaded < 7 && size > 0)
5230 	{
5231 	  val |= (*bignum << loaded);
5232 	  loaded += 8 * CHARS_PER_LITTLENUM;
5233 	  size--;
5234 	  bignum++;
5235 	}
5236 
5237       byte = val & 0x7f;
5238       loaded -= 7;
5239       val >>= 7;
5240 
5241       if (size > 0 || val)
5242 	byte |= 0x80;
5243 
5244       if (orig)
5245 	*p = byte;
5246       p++;
5247     }
5248   while (byte & 0x80);
5249 
5250   return p - orig;
5251 }
5252 
5253 static unsigned int
output_big_leb128(char * p,LITTLENUM_TYPE * bignum,unsigned int size,int sign)5254 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size, int sign)
5255 {
5256   if (sign)
5257     return output_big_sleb128 (p, bignum, size);
5258   else
5259     return output_big_uleb128 (p, bignum, size);
5260 }
5261 
5262 /* Generate the appropriate fragments for a given expression to emit a
5263    leb128 value.  SIGN is 1 for sleb, 0 for uleb.  */
5264 
5265 static void
emit_leb128_expr(expressionS * exp,int sign)5266 emit_leb128_expr (expressionS *exp, int sign)
5267 {
5268   operatorT op = exp->X_op;
5269   unsigned int nbytes;
5270 
5271   if (op == O_absent || op == O_illegal)
5272     {
5273       as_warn (_("zero assumed for missing expression"));
5274       exp->X_add_number = 0;
5275       op = O_constant;
5276     }
5277   else if (op == O_big && exp->X_add_number <= 0)
5278     {
5279       as_bad (_("floating point number invalid"));
5280       exp->X_add_number = 0;
5281       op = O_constant;
5282     }
5283   else if (op == O_register)
5284     {
5285       as_warn (_("register value used as expression"));
5286       op = O_constant;
5287     }
5288   else if (op == O_constant
5289 	   && sign
5290 	   && (exp->X_add_number < 0) == !exp->X_extrabit)
5291     {
5292       /* We're outputting a signed leb128 and the sign of X_add_number
5293 	 doesn't reflect the sign of the original value.  Convert EXP
5294 	 to a correctly-extended bignum instead.  */
5295       convert_to_bignum (exp, exp->X_extrabit);
5296       op = O_big;
5297     }
5298 
5299   if (now_seg == absolute_section)
5300     {
5301       if (op != O_constant || exp->X_add_number != 0)
5302 	as_bad (_("attempt to store value in absolute section"));
5303       abs_section_offset++;
5304       return;
5305     }
5306 
5307   if ((op != O_constant || exp->X_add_number != 0) && in_bss ())
5308     as_bad (_("attempt to store non-zero value in section `%s'"),
5309 	    segment_name (now_seg));
5310 
5311   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
5312      a signal that this is leb128 data.  It shouldn't optimize this away.  */
5313   nbytes = (unsigned int) -1;
5314   if (check_eh_frame (exp, &nbytes))
5315     abort ();
5316 
5317   /* Let the backend know that subsequent data may be byte aligned.  */
5318 #ifdef md_cons_align
5319   md_cons_align (1);
5320 #endif
5321 
5322   if (op == O_constant)
5323     {
5324       /* If we've got a constant, emit the thing directly right now.  */
5325 
5326       valueT value = exp->X_add_number;
5327       unsigned int size;
5328       char *p;
5329 
5330       size = sizeof_leb128 (value, sign);
5331       p = frag_more (size);
5332       if (output_leb128 (p, value, sign) > size)
5333 	abort ();
5334     }
5335   else if (op == O_big)
5336     {
5337       /* O_big is a different sort of constant.  */
5338 
5339       unsigned int size;
5340       char *p;
5341 
5342       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5343       p = frag_more (size);
5344       if (output_big_leb128 (p, generic_bignum, exp->X_add_number, sign) > size)
5345 	abort ();
5346     }
5347   else
5348     {
5349       /* Otherwise, we have to create a variable sized fragment and
5350 	 resolve things later.  */
5351 
5352       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5353 		make_expr_symbol (exp), 0, (char *) NULL);
5354     }
5355 }
5356 
5357 /* Parse the .sleb128 and .uleb128 pseudos.  */
5358 
5359 void
s_leb128(int sign)5360 s_leb128 (int sign)
5361 {
5362   expressionS exp;
5363 
5364 #ifdef md_flush_pending_output
5365   md_flush_pending_output ();
5366 #endif
5367 
5368   do
5369     {
5370       expression (&exp);
5371       emit_leb128_expr (&exp, sign);
5372     }
5373   while (*input_line_pointer++ == ',');
5374 
5375   input_line_pointer--;
5376   demand_empty_rest_of_line ();
5377 }
5378 
5379 static void
stringer_append_char(int c,int bitsize)5380 stringer_append_char (int c, int bitsize)
5381 {
5382   if (c && in_bss ())
5383     as_bad (_("attempt to store non-empty string in section `%s'"),
5384 	    segment_name (now_seg));
5385 
5386   if (!target_big_endian)
5387     FRAG_APPEND_1_CHAR (c);
5388 
5389   switch (bitsize)
5390     {
5391     case 64:
5392       FRAG_APPEND_1_CHAR (0);
5393       FRAG_APPEND_1_CHAR (0);
5394       FRAG_APPEND_1_CHAR (0);
5395       FRAG_APPEND_1_CHAR (0);
5396       /* Fall through.  */
5397     case 32:
5398       FRAG_APPEND_1_CHAR (0);
5399       FRAG_APPEND_1_CHAR (0);
5400       /* Fall through.  */
5401     case 16:
5402       FRAG_APPEND_1_CHAR (0);
5403       /* Fall through.  */
5404     case 8:
5405       break;
5406     default:
5407       /* Called with invalid bitsize argument.  */
5408       abort ();
5409       break;
5410     }
5411   if (target_big_endian)
5412     FRAG_APPEND_1_CHAR (c);
5413 }
5414 
5415 /* Worker to do .ascii etc statements.
5416    Reads 0 or more ',' separated, double-quoted strings.
5417    Caller should have checked need_pass_2 is FALSE because we don't
5418    check it.
5419    Checks for end-of-line.
5420    BITS_APPENDZERO says how many bits are in a target char.
5421    The bottom bit is set if a NUL char should be appended to the strings.  */
5422 
5423 void
stringer(int bits_appendzero)5424 stringer (int bits_appendzero)
5425 {
5426   const int bitsize = bits_appendzero & ~7;
5427   const int append_zero = bits_appendzero & 1;
5428   unsigned int c;
5429 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5430   char *start;
5431 #endif
5432 
5433 #ifdef md_flush_pending_output
5434   md_flush_pending_output ();
5435 #endif
5436 
5437 #ifdef md_cons_align
5438   md_cons_align (1);
5439 #endif
5440 
5441   /* If we have been switched into the abs_section then we
5442      will not have an obstack onto which we can hang strings.  */
5443   if (now_seg == absolute_section)
5444     {
5445       as_bad (_("strings must be placed into a section"));
5446       ignore_rest_of_line ();
5447       return;
5448     }
5449 
5450   /* The following awkward logic is to parse ZERO or more strings,
5451      comma separated. Recall a string expression includes spaces
5452      before the opening '\"' and spaces after the closing '\"'.
5453      We fake a leading ',' if there is (supposed to be)
5454      a 1st, expression. We keep demanding expressions for each ','.  */
5455   if (is_it_end_of_statement ())
5456     {
5457       c = 0;			/* Skip loop.  */
5458       ++input_line_pointer;	/* Compensate for end of loop.  */
5459     }
5460   else
5461     {
5462       c = ',';			/* Do loop.  */
5463     }
5464 
5465   while (c == ',' || c == '<' || c == '"')
5466     {
5467       SKIP_WHITESPACE ();
5468       switch (*input_line_pointer)
5469 	{
5470 	case '\"':
5471 	  ++input_line_pointer;	/*->1st char of string.  */
5472 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5473 	  start = input_line_pointer;
5474 #endif
5475 
5476 	  while (is_a_char (c = next_char_of_string ()))
5477 	    stringer_append_char (c, bitsize);
5478 
5479 	  if (append_zero)
5480 	    stringer_append_char (0, bitsize);
5481 
5482 	  know (input_line_pointer[-1] == '\"');
5483 
5484 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5485 	  /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5486 	     will emit .string with a filename in the .debug section
5487 	     after a sequence of constants.  See the comment in
5488 	     emit_expr for the sequence.  emit_expr will set
5489 	     dwarf_file_string to non-zero if this string might be a
5490 	     source file name.  */
5491 	  if (strcmp (segment_name (now_seg), ".debug") != 0)
5492 	    dwarf_file_string = 0;
5493 	  else if (dwarf_file_string)
5494 	    {
5495 	      c = input_line_pointer[-1];
5496 	      input_line_pointer[-1] = '\0';
5497 	      listing_source_file (start);
5498 	      input_line_pointer[-1] = c;
5499 	    }
5500 #endif
5501 
5502 	  break;
5503 	case '<':
5504 	  input_line_pointer++;
5505 	  c = get_single_number ();
5506 	  stringer_append_char (c, bitsize);
5507 	  if (*input_line_pointer != '>')
5508 	    as_bad (_("expected <nn>"));
5509 
5510 	  input_line_pointer++;
5511 	  break;
5512 	case ',':
5513 	  input_line_pointer++;
5514 	  break;
5515 	}
5516       SKIP_WHITESPACE ();
5517       c = *input_line_pointer;
5518     }
5519 
5520   demand_empty_rest_of_line ();
5521 }
5522 
5523 /* FIXME-SOMEDAY: I had trouble here on characters with the
5524     high bits set.  We'll probably also have trouble with
5525     multibyte chars, wide chars, etc.  Also be careful about
5526     returning values bigger than 1 byte.  xoxorich.  */
5527 
5528 unsigned int
next_char_of_string(void)5529 next_char_of_string (void)
5530 {
5531   unsigned int c;
5532 
5533   c = *input_line_pointer++ & CHAR_MASK;
5534   switch (c)
5535     {
5536     case '\"':
5537       c = NOT_A_CHAR;
5538       break;
5539 
5540     case '\n':
5541       as_warn (_("unterminated string; newline inserted"));
5542       bump_line_counters ();
5543       break;
5544 
5545 #ifndef NO_STRING_ESCAPES
5546     case '\\':
5547       switch (c = *input_line_pointer++ & CHAR_MASK)
5548 	{
5549 	case 'b':
5550 	  c = '\b';
5551 	  break;
5552 
5553 	case 'f':
5554 	  c = '\f';
5555 	  break;
5556 
5557 	case 'n':
5558 	  c = '\n';
5559 	  break;
5560 
5561 	case 'r':
5562 	  c = '\r';
5563 	  break;
5564 
5565 	case 't':
5566 	  c = '\t';
5567 	  break;
5568 
5569 	case 'v':
5570 	  c = '\013';
5571 	  break;
5572 
5573 	case '\\':
5574 	case '"':
5575 	  break;		/* As itself.  */
5576 
5577 	case '0':
5578 	case '1':
5579 	case '2':
5580 	case '3':
5581 	case '4':
5582 	case '5':
5583 	case '6':
5584 	case '7':
5585 	case '8':
5586 	case '9':
5587 	  {
5588 	    long number;
5589 	    int i;
5590 
5591 	    for (i = 0, number = 0;
5592 		 ISDIGIT (c) && i < 3;
5593 		 c = *input_line_pointer++, i++)
5594 	      {
5595 		number = number * 8 + c - '0';
5596 	      }
5597 
5598 	    c = number & CHAR_MASK;
5599 	  }
5600 	  --input_line_pointer;
5601 	  break;
5602 
5603 	case 'x':
5604 	case 'X':
5605 	  {
5606 	    long number;
5607 
5608 	    number = 0;
5609 	    c = *input_line_pointer++;
5610 	    while (ISXDIGIT (c))
5611 	      {
5612 		if (ISDIGIT (c))
5613 		  number = number * 16 + c - '0';
5614 		else if (ISUPPER (c))
5615 		  number = number * 16 + c - 'A' + 10;
5616 		else
5617 		  number = number * 16 + c - 'a' + 10;
5618 		c = *input_line_pointer++;
5619 	      }
5620 	    c = number & CHAR_MASK;
5621 	    --input_line_pointer;
5622 	  }
5623 	  break;
5624 
5625 	case '\n':
5626 	  /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
5627 	  as_warn (_("unterminated string; newline inserted"));
5628 	  c = '\n';
5629 	  bump_line_counters ();
5630 	  break;
5631 
5632 	default:
5633 
5634 #ifdef ONLY_STANDARD_ESCAPES
5635 	  as_bad (_("bad escaped character in string"));
5636 	  c = '?';
5637 #endif /* ONLY_STANDARD_ESCAPES */
5638 
5639 	  break;
5640 	}
5641       break;
5642 #endif /* ! defined (NO_STRING_ESCAPES) */
5643 
5644     default:
5645       break;
5646     }
5647   return (c);
5648 }
5649 
5650 static segT
get_segmented_expression(expressionS * expP)5651 get_segmented_expression (expressionS *expP)
5652 {
5653   segT retval;
5654 
5655   retval = expression (expP);
5656   if (expP->X_op == O_illegal
5657       || expP->X_op == O_absent
5658       || expP->X_op == O_big)
5659     {
5660       as_bad (_("expected address expression"));
5661       expP->X_op = O_constant;
5662       expP->X_add_number = 0;
5663       retval = absolute_section;
5664     }
5665   return retval;
5666 }
5667 
5668 static segT
get_known_segmented_expression(expressionS * expP)5669 get_known_segmented_expression (expressionS *expP)
5670 {
5671   segT retval = get_segmented_expression (expP);
5672 
5673   if (retval == undefined_section)
5674     {
5675       /* There is no easy way to extract the undefined symbol from the
5676 	 expression.  */
5677       if (expP->X_add_symbol != NULL
5678 	  && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5679 	as_warn (_("symbol \"%s\" undefined; zero assumed"),
5680 		 S_GET_NAME (expP->X_add_symbol));
5681       else
5682 	as_warn (_("some symbol undefined; zero assumed"));
5683       retval = absolute_section;
5684       expP->X_op = O_constant;
5685       expP->X_add_number = 0;
5686     }
5687   return retval;
5688 }
5689 
5690 char				/* Return terminator.  */
get_absolute_expression_and_terminator(long * val_pointer)5691 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
5692 {
5693   /* FIXME: val_pointer should probably be offsetT *.  */
5694   *val_pointer = (long) get_absolute_expression ();
5695   return (*input_line_pointer++);
5696 }
5697 
5698 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5699    Give a warning if that happens.  */
5700 
5701 char *
demand_copy_C_string(int * len_pointer)5702 demand_copy_C_string (int *len_pointer)
5703 {
5704   char *s;
5705 
5706   if ((s = demand_copy_string (len_pointer)) != 0)
5707     {
5708       int len;
5709 
5710       for (len = *len_pointer; len > 0; len--)
5711 	{
5712 	  if (*s == 0)
5713 	    {
5714 	      s = 0;
5715 	      len = 1;
5716 	      *len_pointer = 0;
5717 	      as_bad (_("this string may not contain \'\\0\'"));
5718 	    }
5719 	}
5720     }
5721 
5722   return s;
5723 }
5724 
5725 /* Demand string, but return a safe (=private) copy of the string.
5726    Return NULL if we can't read a string here.  */
5727 
5728 char *
demand_copy_string(int * lenP)5729 demand_copy_string (int *lenP)
5730 {
5731   unsigned int c;
5732   int len;
5733   char *retval;
5734 
5735   len = 0;
5736   SKIP_WHITESPACE ();
5737   if (*input_line_pointer == '\"')
5738     {
5739       input_line_pointer++;	/* Skip opening quote.  */
5740 
5741       while (is_a_char (c = next_char_of_string ()))
5742 	{
5743 	  obstack_1grow (&notes, c);
5744 	  len++;
5745 	}
5746       /* JF this next line is so demand_copy_C_string will return a
5747 	 null terminated string.  */
5748       obstack_1grow (&notes, '\0');
5749       retval = (char *) obstack_finish (&notes);
5750     }
5751   else
5752     {
5753       as_bad (_("missing string"));
5754       retval = NULL;
5755       ignore_rest_of_line ();
5756     }
5757   *lenP = len;
5758   return (retval);
5759 }
5760 
5761 /* In:	Input_line_pointer->next character.
5762 
5763    Do:	Skip input_line_pointer over all whitespace.
5764 
5765    Out:	1 if input_line_pointer->end-of-line.  */
5766 
5767 int
is_it_end_of_statement(void)5768 is_it_end_of_statement (void)
5769 {
5770   SKIP_WHITESPACE ();
5771   return (is_end_of_line[(unsigned char) *input_line_pointer]);
5772 }
5773 
5774 void
equals(char * sym_name,int reassign)5775 equals (char *sym_name, int reassign)
5776 {
5777   char *stop = NULL;
5778   char stopc = 0;
5779 
5780   input_line_pointer++;
5781   if (*input_line_pointer == '=')
5782     input_line_pointer++;
5783   if (reassign < 0 && *input_line_pointer == '=')
5784     input_line_pointer++;
5785 
5786   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5787     input_line_pointer++;
5788 
5789   if (flag_mri)
5790     stop = mri_comment_field (&stopc);
5791 
5792   assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5793 
5794   if (flag_mri)
5795     {
5796       demand_empty_rest_of_line ();
5797       mri_comment_end (stop, stopc);
5798     }
5799 }
5800 
5801 /* .incbin -- include a file verbatim at the current location.  */
5802 
5803 void
s_incbin(int x ATTRIBUTE_UNUSED)5804 s_incbin (int x ATTRIBUTE_UNUSED)
5805 {
5806   FILE * binfile;
5807   char * path;
5808   char * filename;
5809   char * binfrag;
5810   long   skip = 0;
5811   long   count = 0;
5812   long   bytes;
5813   int    len;
5814 
5815   if (! allow_incbin_directive)
5816     {
5817       as_fatal (_("\'.incbin\' directive not allowed, use --allow-incbin flag"
5818                   " to enable."));
5819     }
5820 
5821 #ifdef md_flush_pending_output
5822   md_flush_pending_output ();
5823 #endif
5824 
5825 #ifdef md_cons_align
5826   md_cons_align (1);
5827 #endif
5828 
5829   SKIP_WHITESPACE ();
5830   filename = demand_copy_string (& len);
5831   if (filename == NULL)
5832     return;
5833 
5834   SKIP_WHITESPACE ();
5835 
5836   /* Look for optional skip and count.  */
5837   if (* input_line_pointer == ',')
5838     {
5839       ++ input_line_pointer;
5840       skip = get_absolute_expression ();
5841 
5842       SKIP_WHITESPACE ();
5843 
5844       if (* input_line_pointer == ',')
5845 	{
5846 	  ++ input_line_pointer;
5847 
5848 	  count = get_absolute_expression ();
5849 	  if (count == 0)
5850 	    as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5851 
5852 	  SKIP_WHITESPACE ();
5853 	}
5854     }
5855 
5856   demand_empty_rest_of_line ();
5857 
5858   /* Try opening absolute path first, then try include dirs.  */
5859   binfile = fopen (filename, FOPEN_RB);
5860   if (binfile == NULL)
5861     {
5862       int i;
5863 
5864       path = XNEWVEC (char, (unsigned long) len + include_dir_maxlen + 5);
5865 
5866       for (i = 0; i < include_dir_count; i++)
5867 	{
5868 	  sprintf (path, "%s/%s", include_dirs[i], filename);
5869 
5870 	  binfile = fopen (path, FOPEN_RB);
5871 	  if (binfile != NULL)
5872 	    break;
5873 	}
5874 
5875       if (binfile == NULL)
5876 	as_bad (_("file not found: %s"), filename);
5877     }
5878   else
5879     path = xstrdup (filename);
5880 
5881   if (binfile)
5882     {
5883       long   file_len;
5884 
5885       register_dependency (path);
5886 
5887       /* Compute the length of the file.  */
5888       if (fseek (binfile, 0, SEEK_END) != 0)
5889 	{
5890 	  as_bad (_("seek to end of .incbin file failed `%s'"), path);
5891 	  goto done;
5892 	}
5893       file_len = ftell (binfile);
5894 
5895       /* If a count was not specified use the remainder of the file.  */
5896       if (count == 0)
5897 	count = file_len - skip;
5898 
5899       if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5900 	{
5901 	  as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5902 		  skip, count, file_len);
5903 	  goto done;
5904 	}
5905 
5906       if (fseek (binfile, skip, SEEK_SET) != 0)
5907 	{
5908 	  as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5909 	  goto done;
5910 	}
5911 
5912       /* Allocate frag space and store file contents in it.  */
5913       binfrag = frag_more (count);
5914 
5915       bytes = fread (binfrag, 1, count, binfile);
5916       if (bytes < count)
5917 	as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5918 		 path, bytes, count);
5919     }
5920 done:
5921   if (binfile != NULL)
5922     fclose (binfile);
5923   if (path)
5924     free (path);
5925 }
5926 
5927 /* .include -- include a file at this point.  */
5928 
5929 void
s_include(int arg ATTRIBUTE_UNUSED)5930 s_include (int arg ATTRIBUTE_UNUSED)
5931 {
5932   char *filename;
5933   int i;
5934   FILE *try_file;
5935   char *path;
5936 
5937   if (!flag_m68k_mri)
5938     {
5939       filename = demand_copy_string (&i);
5940       if (filename == NULL)
5941 	{
5942 	  /* demand_copy_string has already printed an error and
5943 	     called ignore_rest_of_line.  */
5944 	  return;
5945 	}
5946     }
5947   else
5948     {
5949       SKIP_WHITESPACE ();
5950       i = 0;
5951       while (!is_end_of_line[(unsigned char) *input_line_pointer]
5952 	     && *input_line_pointer != ' '
5953 	     && *input_line_pointer != '\t')
5954 	{
5955 	  obstack_1grow (&notes, *input_line_pointer);
5956 	  ++input_line_pointer;
5957 	  ++i;
5958 	}
5959 
5960       obstack_1grow (&notes, '\0');
5961       filename = (char *) obstack_finish (&notes);
5962       while (!is_end_of_line[(unsigned char) *input_line_pointer])
5963 	++input_line_pointer;
5964     }
5965 
5966   demand_empty_rest_of_line ();
5967   path = XNEWVEC (char, (unsigned long) i
5968 		  + include_dir_maxlen + 5 /* slop */ );
5969 
5970   for (i = 0; i < include_dir_count; i++)
5971     {
5972       strcpy (path, include_dirs[i]);
5973       strcat (path, "/");
5974       strcat (path, filename);
5975       if (0 != (try_file = fopen (path, FOPEN_RT)))
5976 	{
5977 	  fclose (try_file);
5978 	  goto gotit;
5979 	}
5980     }
5981 
5982   free (path);
5983   path = filename;
5984 gotit:
5985   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
5986   register_dependency (path);
5987   input_scrub_insert_file (path);
5988 }
5989 
5990 void
add_include_dir(char * path)5991 add_include_dir (char *path)
5992 {
5993   int i;
5994 
5995   if (include_dir_count == 0)
5996     {
5997       include_dirs = XNEWVEC (const char *, 2);
5998       include_dirs[0] = ".";	/* Current dir.  */
5999       include_dir_count = 2;
6000     }
6001   else
6002     {
6003       include_dir_count++;
6004       include_dirs = XRESIZEVEC (const char *, include_dirs,
6005 				 include_dir_count);
6006     }
6007 
6008   include_dirs[include_dir_count - 1] = path;	/* New one.  */
6009 
6010   i = strlen (path);
6011   if (i > include_dir_maxlen)
6012     include_dir_maxlen = i;
6013 }
6014 
6015 /* Output debugging information to denote the source file.  */
6016 
6017 static void
generate_file_debug(void)6018 generate_file_debug (void)
6019 {
6020   if (debug_type == DEBUG_STABS)
6021     stabs_generate_asm_file ();
6022 }
6023 
6024 /* Output line number debugging information for the current source line.  */
6025 
6026 void
generate_lineno_debug(void)6027 generate_lineno_debug (void)
6028 {
6029   switch (debug_type)
6030     {
6031     case DEBUG_UNSPECIFIED:
6032     case DEBUG_NONE:
6033     case DEBUG_DWARF:
6034       break;
6035     case DEBUG_STABS:
6036       stabs_generate_asm_lineno ();
6037       break;
6038     case DEBUG_ECOFF:
6039       ecoff_generate_asm_lineno ();
6040       break;
6041     case DEBUG_DWARF2:
6042       /* ??? We could here indicate to dwarf2dbg.c that something
6043 	 has changed.  However, since there is additional backend
6044 	 support that is required (calling dwarf2_emit_insn), we
6045 	 let dwarf2dbg.c call as_where on its own.  */
6046       break;
6047     }
6048 }
6049 
6050 /* Output debugging information to mark a function entry point or end point.
6051    END_P is zero for .func, and non-zero for .endfunc.  */
6052 
6053 void
s_func(int end_p)6054 s_func (int end_p)
6055 {
6056   do_s_func (end_p, NULL);
6057 }
6058 
6059 /* Subroutine of s_func so targets can choose a different default prefix.
6060    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
6061 
6062 static void
do_s_func(int end_p,const char * default_prefix)6063 do_s_func (int end_p, const char *default_prefix)
6064 {
6065   /* Record the current function so that we can issue an error message for
6066      misplaced .func,.endfunc, and also so that .endfunc needs no
6067      arguments.  */
6068   static char *current_name;
6069   static char *current_label;
6070 
6071   if (end_p)
6072     {
6073       if (current_name == NULL)
6074 	{
6075 	  as_bad (_("missing .func"));
6076 	  ignore_rest_of_line ();
6077 	  return;
6078 	}
6079 
6080       if (debug_type == DEBUG_STABS)
6081 	stabs_generate_asm_endfunc (current_name, current_label);
6082 
6083       current_name = current_label = NULL;
6084     }
6085   else /* ! end_p */
6086     {
6087       char *name, *label;
6088       char delim1, delim2;
6089 
6090       if (current_name != NULL)
6091 	{
6092 	  as_bad (_(".endfunc missing for previous .func"));
6093 	  ignore_rest_of_line ();
6094 	  return;
6095 	}
6096 
6097       delim1 = get_symbol_name (& name);
6098       name = xstrdup (name);
6099       *input_line_pointer = delim1;
6100       SKIP_WHITESPACE_AFTER_NAME ();
6101       if (*input_line_pointer != ',')
6102 	{
6103 	  if (default_prefix)
6104 	    {
6105 	      if (asprintf (&label, "%s%s", default_prefix, name) == -1)
6106 		as_fatal ("%s", xstrerror (errno));
6107 	    }
6108 	  else
6109 	    {
6110 	      char leading_char = bfd_get_symbol_leading_char (stdoutput);
6111 	      /* Missing entry point, use function's name with the leading
6112 		 char prepended.  */
6113 	      if (leading_char)
6114 		{
6115 		  if (asprintf (&label, "%c%s", leading_char, name) == -1)
6116 		    as_fatal ("%s", xstrerror (errno));
6117 		}
6118 	      else
6119 		label = name;
6120 	    }
6121 	}
6122       else
6123 	{
6124 	  ++input_line_pointer;
6125 	  SKIP_WHITESPACE ();
6126 	  delim2 = get_symbol_name (& label);
6127 	  label = xstrdup (label);
6128 	  restore_line_pointer (delim2);
6129 	}
6130 
6131       if (debug_type == DEBUG_STABS)
6132 	stabs_generate_asm_func (name, label);
6133 
6134       current_name = name;
6135       current_label = label;
6136     }
6137 
6138   demand_empty_rest_of_line ();
6139 }
6140 
6141 #ifdef HANDLE_BUNDLE
6142 
6143 void
s_bundle_align_mode(int arg ATTRIBUTE_UNUSED)6144 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED)
6145 {
6146   unsigned int align = get_absolute_expression ();
6147   SKIP_WHITESPACE ();
6148   demand_empty_rest_of_line ();
6149 
6150   if (align > (unsigned int) TC_ALIGN_LIMIT)
6151     as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6152 	      (unsigned int) TC_ALIGN_LIMIT);
6153 
6154   if (bundle_lock_frag != NULL)
6155     {
6156       as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6157       return;
6158     }
6159 
6160   bundle_align_p2 = align;
6161 }
6162 
6163 void
s_bundle_lock(int arg ATTRIBUTE_UNUSED)6164 s_bundle_lock (int arg ATTRIBUTE_UNUSED)
6165 {
6166   demand_empty_rest_of_line ();
6167 
6168   if (bundle_align_p2 == 0)
6169     {
6170       as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6171       return;
6172     }
6173 
6174   if (bundle_lock_depth == 0)
6175     {
6176       bundle_lock_frchain = frchain_now;
6177       bundle_lock_frag = start_bundle ();
6178     }
6179   ++bundle_lock_depth;
6180 }
6181 
6182 void
s_bundle_unlock(int arg ATTRIBUTE_UNUSED)6183 s_bundle_unlock (int arg ATTRIBUTE_UNUSED)
6184 {
6185   unsigned int size;
6186 
6187   demand_empty_rest_of_line ();
6188 
6189   if (bundle_lock_frag == NULL)
6190     {
6191       as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6192       return;
6193     }
6194 
6195   gas_assert (bundle_align_p2 > 0);
6196 
6197   gas_assert (bundle_lock_depth > 0);
6198   if (--bundle_lock_depth > 0)
6199     return;
6200 
6201   size = pending_bundle_size (bundle_lock_frag);
6202 
6203   if (size > (1U << bundle_align_p2))
6204     as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
6205 	    size, 1 << bundle_align_p2);
6206   else
6207     finish_bundle (bundle_lock_frag, size);
6208 
6209   bundle_lock_frag = NULL;
6210   bundle_lock_frchain = NULL;
6211 }
6212 
6213 #endif  /* HANDLE_BUNDLE */
6214 
6215 void
s_ignore(int arg ATTRIBUTE_UNUSED)6216 s_ignore (int arg ATTRIBUTE_UNUSED)
6217 {
6218   ignore_rest_of_line ();
6219 }
6220 
6221 void
read_print_statistics(FILE * file)6222 read_print_statistics (FILE *file)
6223 {
6224   hash_print_statistics (file, "pseudo-op table", po_hash);
6225 }
6226 
6227 /* Inserts the given line into the input stream.
6228 
6229    This call avoids macro/conditionals nesting checking, since the contents of
6230    the line are assumed to replace the contents of a line already scanned.
6231 
6232    An appropriate use of this function would be substitution of input lines when
6233    called by md_start_line_hook().  The given line is assumed to already be
6234    properly scrubbed.  */
6235 
6236 void
input_scrub_insert_line(const char * line)6237 input_scrub_insert_line (const char *line)
6238 {
6239   sb newline;
6240   size_t len = strlen (line);
6241   sb_build (&newline, len);
6242   sb_add_buffer (&newline, line, len);
6243   input_scrub_include_sb (&newline, input_line_pointer, 0);
6244   sb_kill (&newline);
6245   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
6246 }
6247 
6248 /* Insert a file into the input stream; the path must resolve to an actual
6249    file; no include path searching or dependency registering is performed.  */
6250 
6251 void
input_scrub_insert_file(char * path)6252 input_scrub_insert_file (char *path)
6253 {
6254   input_scrub_include_file (path, input_line_pointer);
6255   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
6256 }
6257 
6258 /* Find the end of a line, considering quotation and escaping of quotes.  */
6259 
6260 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6261 # define TC_SINGLE_QUOTE_STRINGS 1
6262 #endif
6263 
6264 static char *
_find_end_of_line(char * s,int mri_string,int insn ATTRIBUTE_UNUSED,int in_macro)6265 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
6266 		   int in_macro)
6267 {
6268   char inquote = '\0';
6269   int inescape = 0;
6270 
6271   while (!is_end_of_line[(unsigned char) *s]
6272 	 || (inquote && !ISCNTRL (*s))
6273 	 || (inquote == '\'' && flag_mri)
6274 #ifdef TC_EOL_IN_INSN
6275 	 || (insn && TC_EOL_IN_INSN (s))
6276 #endif
6277 	 /* PR 6926:  When we are parsing the body of a macro the sequence
6278 	    \@ is special - it refers to the invocation count.  If the @
6279 	    character happens to be registered as a line-separator character
6280 	    by the target, then the is_end_of_line[] test above will have
6281 	    returned true, but we need to ignore the line separating
6282 	    semantics in this particular case.  */
6283 	 || (in_macro && inescape && *s == '@')
6284 	)
6285     {
6286       if (mri_string && *s == '\'')
6287 	inquote ^= *s;
6288       else if (inescape)
6289 	inescape = 0;
6290       else if (*s == '\\')
6291 	inescape = 1;
6292       else if (!inquote
6293 	       ? *s == '"'
6294 #ifdef TC_SINGLE_QUOTE_STRINGS
6295 		 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
6296 #endif
6297 	       : *s == inquote)
6298 	inquote ^= *s;
6299       ++s;
6300     }
6301   if (inquote)
6302     as_warn (_("missing closing `%c'"), inquote);
6303   if (inescape && !ignore_input ())
6304     as_warn (_("stray `\\'"));
6305   return s;
6306 }
6307 
6308 char *
find_end_of_line(char * s,int mri_string)6309 find_end_of_line (char *s, int mri_string)
6310 {
6311   return _find_end_of_line (s, mri_string, 0, 0);
6312 }
6313