X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fread.c;h=8f93c2ba2b461a22440889e67875fb40a34275f4;hb=b0ee49d21ba0c4b7f9817db01dc247255eebd516;hp=b8bc536c79c991a92efc233643ebf44ba97ed23f;hpb=e4475e391f7e5f113775573a822acb55612ddbb7;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/read.c b/gas/read.c index b8bc536c79..8f93c2ba2b 100644 --- a/gas/read.c +++ b/gas/read.c @@ -1,32 +1,27 @@ /* read.c - read a source file - - Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, - 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. -This file is part of GAS, the GNU Assembler. + This file is part of GAS, the GNU Assembler. -GAS is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. + GAS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. -GAS is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + GAS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with GAS; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with GAS; see the file COPYING. If not, write to the Free + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ -#if 0 -/* If your chars aren't 8 bits, you will change this a bit. - But then, GNU isn't spozed to run on your machine anyway. +/* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF). + But then, GNU isn't supposed to run on your machine anyway. (RMS is so shortsighted sometimes.) */ -#define MASK_CHAR (0xFF) -#else #define MASK_CHAR ((int)(unsigned char) -1) -#endif /* This is the largest known floating point format (for now). It will grow when we do 4361 style flonums. */ @@ -41,12 +36,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "sb.h" #include "macro.h" #include "obstack.h" -#include "listing.h" #include "ecoff.h" #include "dw2gencfi.h" +#include "wchar.h" #ifndef TC_START_LABEL -#define TC_START_LABEL(x,y) (x == ':') +#define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':') #endif /* Set by the object-format or the target. */ @@ -67,6 +62,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #endif char *input_line_pointer; /*->next char of source file to parse. */ +bfd_boolean input_from_string = FALSE; #if BITS_PER_CHAR != 8 /* The following table is indexed by[(char)] and will break if @@ -75,7 +71,6 @@ die horribly; #endif #ifndef LEX_AT -/* The m88k unfortunately uses @ as a label beginner. */ #define LEX_AT 0 #endif @@ -101,7 +96,6 @@ die horribly; #endif #ifndef LEX_DOLLAR -/* The a29k assembler does not permits labels to start with $. */ #define LEX_DOLLAR 3 #endif @@ -131,7 +125,8 @@ char lex_type[256] = { }; /* In: a character. - Out: 1 if this character ends a line. */ + Out: 1 if this character ends a line. + 2 if this character is a line separator. */ char is_end_of_line[256] = { #ifdef CR_EOL 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */ @@ -155,7 +150,7 @@ char is_end_of_line[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */ }; -#ifdef IGNORE_OPCODE_CASE +#ifndef TC_CASE_SENSITIVE char original_case_string[128]; #endif @@ -172,7 +167,7 @@ int target_big_endian = TARGET_BYTES_BIG_ENDIAN; /* Variables for handling include file directory table. */ /* Table of pointers to directories to search for .include's. */ -char **include_dirs; +const char **include_dirs; /* How many are in the table. */ int include_dir_count; @@ -214,13 +209,46 @@ static int dwarf_file_string; #endif #endif -static void do_align (int, char *, int, int); +/* If the target defines the md_frag_max_var hook then we know + enough to implement the .bundle_align_mode features. */ +#ifdef md_frag_max_var +# define HANDLE_BUNDLE +#endif + +#ifdef HANDLE_BUNDLE +/* .bundle_align_mode sets this. Normally it's zero. When nonzero, + it's the exponent of the bundle size, and aligned instruction bundle + mode is in effect. */ +static unsigned int bundle_align_p2; + +/* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets + bundle_lock_frag to frag_now and then starts a new frag with + frag_align_code. At the same time, bundle_lock_frain gets frchain_now, + so that .bundle_unlock can verify that we didn't change segments. + .bundle_unlock resets both to NULL. If we detect a bundling violation, + then we reset bundle_lock_frchain to NULL as an indicator that we've + already diagnosed the error with as_bad and don't need a cascade of + redundant errors, but bundle_lock_frag remains set to indicate that + we are expecting to see .bundle_unlock. */ +static fragS *bundle_lock_frag; +static frchainS *bundle_lock_frchain; + +/* This is incremented by .bundle_lock and decremented by .bundle_unlock, + to allow nesting. */ +static unsigned int bundle_lock_depth; +#endif + +static void do_s_func (int end_p, const char *default_prefix); static void s_align (int, int); +static void s_altmacro (int); +static void s_bad_end (int); +static void s_reloc (int); static int hex_float (int, char *); static segT get_known_segmented_expression (expressionS * expP); static void pobegin (void); -static int get_line_sb (sb *); +static size_t get_non_macro_line_sb (sb *); static void generate_file_debug (void); +static char *_find_end_of_line (char *, int, int, int); void read_begin (void) @@ -235,15 +263,34 @@ read_begin (void) obstack_begin (¬es, chunksize); obstack_begin (&cond_obstack, chunksize); +#ifndef tc_line_separator_chars +#define tc_line_separator_chars line_separator_chars +#endif /* Use machine dependent syntax. */ - for (p = line_separator_chars; *p; p++) - is_end_of_line[(unsigned char) *p] = 1; + for (p = tc_line_separator_chars; *p; p++) + is_end_of_line[(unsigned char) *p] = 2; /* Use more. FIXME-SOMEDAY. */ if (flag_mri) lex_type['?'] = 3; } +#ifndef TC_ADDRESS_BYTES +#define TC_ADDRESS_BYTES address_bytes + +static inline int +address_bytes (void) +{ + /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to + contain an address. */ + int n = (stdoutput->arch_info->bits_per_address - 1) / 8; + n |= n >> 1; + n |= n >> 2; + n += 1; + return n; +} +#endif + /* Set up pseudo-op tables. */ static struct hash_control *po_hash; @@ -251,18 +298,27 @@ static struct hash_control *po_hash; static const pseudo_typeS potable[] = { {"abort", s_abort, 0}, {"align", s_align_ptwo, 0}, - {"ascii", stringer, 0}, - {"asciz", stringer, 1}, + {"altmacro", s_altmacro, 1}, + {"ascii", stringer, 8+0}, + {"asciz", stringer, 8+1}, {"balign", s_align_bytes, 0}, {"balignw", s_align_bytes, -2}, {"balignl", s_align_bytes, -4}, /* block */ +#ifdef HANDLE_BUNDLE + {"bundle_align_mode", s_bundle_align_mode, 0}, + {"bundle_lock", s_bundle_lock, 0}, + {"bundle_unlock", s_bundle_unlock, 0}, +#endif {"byte", cons, 1}, {"comm", s_comm, 0}, {"common", s_mri_common, 0}, {"common.s", s_mri_common, 1}, {"data", s_data, 0}, {"dc", cons, 2}, +#ifdef TC_ADDRESS_BYTES + {"dc.a", cons, 0}, +#endif {"dc.b", cons, 1}, {"dc.d", float_cons, 'd'}, {"dc.l", cons, 4}, @@ -299,16 +355,19 @@ static const pseudo_typeS potable[] = { {"endc", s_endif, 0}, {"endfunc", s_func, 1}, {"endif", s_endif, 0}, - {"endr", s_bad_endr, 0}, + {"endm", s_bad_end, 0}, + {"endr", s_bad_end, 1}, /* endef */ {"equ", s_set, 0}, {"equiv", s_set, 1}, + {"eqv", s_set, -1}, {"err", s_err, 0}, + {"error", s_errwarn, 1}, {"exitm", s_mexit, 0}, /* extend */ {"extern", s_ignore, 0}, /* We treat all undef as ext. */ {"appfile", s_app_file, 1}, - {"appline", s_app_line, 0}, + {"appline", s_app_line, 1}, {"fail", s_fail, 0}, {"file", s_app_file, 0}, {"fill", s_fill, 0}, @@ -319,6 +378,7 @@ static const pseudo_typeS potable[] = { {"globl", s_globl, 0}, {"hword", cons, 2}, {"if", s_if, (int) O_ne}, + {"ifb", s_ifb, 1}, {"ifc", s_ifc, 0}, {"ifdef", s_ifdef, 0}, {"ifeq", s_if, (int) O_eq}, @@ -327,6 +387,7 @@ static const pseudo_typeS potable[] = { {"ifgt", s_if, (int) O_gt}, {"ifle", s_if, (int) O_le}, {"iflt", s_if, (int) O_lt}, + {"ifnb", s_ifb, 0}, {"ifnc", s_ifc, 1}, {"ifndef", s_ifdef, 1}, {"ifne", s_if, (int) O_ne}, @@ -340,7 +401,8 @@ static const pseudo_typeS potable[] = { {"irpc", s_irp, 1}, {"irepc", s_irp, 1}, {"lcomm", s_lcomm, 0}, - {"lflags", listing_flags, 0}, /* Listing flags. */ + {"lflags", s_ignore, 0}, /* Listing flags. */ + {"linefile", s_app_line, 0}, {"linkonce", s_linkonce, 0}, {"list", listing_list, 1}, /* Turn listing on. */ {"llen", listing_psize, 1}, @@ -351,9 +413,11 @@ static const pseudo_typeS potable[] = { {"mri", s_mri, 0}, {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */ {"name", s_ignore, 0}, + {"noaltmacro", s_altmacro, 0}, {"noformat", s_ignore, 0}, {"nolist", listing_list, 0}, /* Turn listing off. */ {"nopage", listing_nopage, 0}, + {"nops", s_nops, 0}, {"octa", cons, 16}, {"offset", s_struct, 0}, {"org", s_org, 0}, @@ -366,6 +430,7 @@ static const pseudo_typeS potable[] = { {"psize", listing_psize, 0}, /* Set paper size. */ {"purgem", s_purgem, 0}, {"quad", cons, 8}, + {"reloc", s_reloc, 0}, {"rep", s_rept, 0}, {"rept", s_rept, 0}, {"rva", s_rva, 4}, @@ -383,7 +448,11 @@ static const pseudo_typeS potable[] = { {"stabd", s_stab, 'd'}, {"stabn", s_stab, 'n'}, {"stabs", s_stab, 's'}, - {"string", stringer, 1}, + {"string", stringer, 8+1}, + {"string8", stringer, 8+1}, + {"string16", stringer, 16+1}, + {"string32", stringer, 32+1}, + {"string64", stringer, 64+1}, {"struct", s_struct, 0}, /* tag */ {"text", s_text, 0}, @@ -408,11 +477,35 @@ static const pseudo_typeS potable[] = { {"xdef", s_globl, 0}, {"xref", s_ignore, 0}, {"xstabs", s_xstab, 's'}, + {"warning", s_errwarn, 0}, + {"weakref", s_weakref, 0}, {"word", cons, 2}, {"zero", s_space, 0}, {NULL, NULL, 0} /* End sentinel. */ }; +static offsetT +get_absolute_expr (expressionS *exp) +{ + expression_and_evaluate (exp); + + if (exp->X_op != O_constant) + { + if (exp->X_op != O_absent) + as_bad (_("bad or irreducible absolute expression")); + exp->X_add_number = 0; + } + return exp->X_add_number; +} + +offsetT +get_absolute_expression (void) +{ + expressionS exp; + + return get_absolute_expr (&exp); +} + static int pop_override_ok = 0; static const char *pop_table_name; @@ -460,19 +553,21 @@ pobegin (void) pop_table_name = "standard"; pop_insert (potable); -#ifdef TARGET_USE_CFIPOP + /* Now CFI ones. */ pop_table_name = "cfi"; pop_override_ok = 1; cfi_pop_insert (); -#endif } -#define HANDLE_CONDITIONAL_ASSEMBLY() \ +#define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \ if (ignore_input ()) \ { \ - while (!is_end_of_line[(unsigned char) *input_line_pointer++]) \ - if (input_line_pointer == buffer_limit) \ - break; \ + char *eol = find_end_of_line (input_line_pointer - (num_read), \ + flag_m68k_mri); \ + input_line_pointer = (input_line_pointer <= buffer_limit \ + && eol >= buffer_limit) \ + ? buffer_limit \ + : eol + 1; \ continue; \ } @@ -482,10 +577,10 @@ pobegin (void) static char *scrub_string; static char *scrub_string_end; -static int -scrub_from_string (char *buf, int buflen) +static size_t +scrub_from_string (char *buf, size_t buflen) { - int copy; + size_t copy; copy = scrub_string_end - scrub_string; if (copy > buflen) @@ -495,14 +590,233 @@ scrub_from_string (char *buf, int buflen) return copy; } +/* Helper function of read_a_source_file, which tries to expand a macro. */ +static int +try_macro (char term, const char *line) +{ + sb out; + const char *err; + macro_entry *macro; + + if (check_macro (line, &out, &err, ¯o)) + { + if (err != NULL) + as_bad ("%s", err); + *input_line_pointer++ = term; + input_scrub_include_sb (&out, + input_line_pointer, 1); + sb_kill (&out); + buffer_limit = + input_scrub_next_buffer (&input_line_pointer); +#ifdef md_macro_info + md_macro_info (macro); +#endif + return 1; + } + return 0; +} + +#ifdef HANDLE_BUNDLE +/* Start a new instruction bundle. Returns the rs_align_code frag that + will be used to align the new bundle. */ +static fragS * +start_bundle (void) +{ + fragS *frag = frag_now; + + frag_align_code (0, 0); + + while (frag->fr_type != rs_align_code) + frag = frag->fr_next; + + gas_assert (frag != frag_now); + + return frag; +} + +/* Calculate the maximum size after relaxation of the region starting + at the given frag and extending through frag_now (which is unfinished). */ +static unsigned int +pending_bundle_size (fragS *frag) +{ + unsigned int offset = frag->fr_fix; + unsigned int size = 0; + + gas_assert (frag != frag_now); + gas_assert (frag->fr_type == rs_align_code); + + while (frag != frag_now) + { + /* This should only happen in what will later become an error case. */ + if (frag == NULL) + return 0; + + size += frag->fr_fix; + if (frag->fr_type == rs_machine_dependent) + size += md_frag_max_var (frag); + + frag = frag->fr_next; + } + + gas_assert (frag == frag_now); + size += frag_now_fix (); + if (frag->fr_type == rs_machine_dependent) + size += md_frag_max_var (frag); + + gas_assert (size >= offset); + + return size - offset; +} + +/* Finish off the frag created to ensure bundle alignment. */ +static void +finish_bundle (fragS *frag, unsigned int size) +{ + gas_assert (bundle_align_p2 > 0); + gas_assert (frag->fr_type == rs_align_code); + + if (size > 1) + { + /* If there is more than a single byte, then we need to set up the + alignment frag. Otherwise we leave it at its initial state from + calling frag_align_code (0, 0), so that it does nothing. */ + frag->fr_offset = bundle_align_p2; + frag->fr_subtype = size - 1; + } + + /* We do this every time rather than just in s_bundle_align_mode + so that we catch any affected section without needing hooks all + over for all paths that do section changes. It's cheap enough. */ + if (bundle_align_p2 > OCTETS_PER_BYTE_POWER) + record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER); +} + +/* Assemble one instruction. This takes care of the bundle features + around calling md_assemble. */ +static void +assemble_one (char *line) +{ + fragS *insn_start_frag = NULL; + + if (bundle_lock_frchain != NULL && bundle_lock_frchain != frchain_now) + { + as_bad (_("cannot change section or subsection inside .bundle_lock")); + /* Clearing this serves as a marker that we have already complained. */ + bundle_lock_frchain = NULL; + } + + if (bundle_lock_frchain == NULL && bundle_align_p2 > 0) + insn_start_frag = start_bundle (); + + md_assemble (line); + + if (bundle_lock_frchain != NULL) + { + /* Make sure this hasn't pushed the locked sequence + past the bundle size. */ + unsigned int bundle_size = pending_bundle_size (bundle_lock_frag); + if (bundle_size > 1U << bundle_align_p2) + as_bad (_ (".bundle_lock sequence at %u bytes, " + "but .bundle_align_mode limit is %u bytes"), + bundle_size, 1U << bundle_align_p2); + } + else if (bundle_align_p2 > 0) + { + unsigned int insn_size = pending_bundle_size (insn_start_frag); + + if (insn_size > 1U << bundle_align_p2) + as_bad (_("single instruction is %u bytes long, " + "but .bundle_align_mode limit is %u bytes"), + insn_size, 1U << bundle_align_p2); + + finish_bundle (insn_start_frag, insn_size); + } +} + +#else /* !HANDLE_BUNDLE */ + +# define assemble_one(line) md_assemble(line) + +#endif /* HANDLE_BUNDLE */ + +static bfd_boolean +in_bss (void) +{ + flagword flags = bfd_section_flags (now_seg); + + return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS)); +} + +/* Guts of .align directive: + N is the power of two to which to align. A value of zero is accepted but + ignored: the default alignment of the section will be at least this. + FILL may be NULL, or it may point to the bytes of the fill pattern. + LEN is the length of whatever FILL points to, if anything. If LEN is zero + but FILL is not NULL then LEN is treated as if it were one. + MAX is the maximum number of characters to skip when doing the alignment, + or 0 if there is no maximum. */ + +void +do_align (unsigned int n, char *fill, unsigned int len, unsigned int max) +{ + if (now_seg == absolute_section || in_bss ()) + { + if (fill != NULL) + while (len-- > 0) + if (*fill++ != '\0') + { + if (now_seg == absolute_section) + as_warn (_("ignoring fill value in absolute section")); + else + as_warn (_("ignoring fill value in section `%s'"), + segment_name (now_seg)); + break; + } + fill = NULL; + len = 0; + } + +#ifdef md_flush_pending_output + md_flush_pending_output (); +#endif + +#ifdef md_do_align + md_do_align (n, fill, len, max, just_record_alignment); +#endif + + /* Only make a frag if we HAVE to... */ + if ((n > OCTETS_PER_BYTE_POWER) && !need_pass_2) + { + if (fill == NULL) + { + if (subseg_text_p (now_seg)) + frag_align_code (n, max); + else + frag_align (n, 0, max); + } + else if (len <= 1) + frag_align (n, *fill, max); + else + frag_align_pattern (n, fill, len, max); + } + +#ifdef md_do_align + just_record_alignment: ATTRIBUTE_UNUSED_LABEL +#endif + + if (n > OCTETS_PER_BYTE_POWER) + record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER); +} + /* We read the file, putting things into a web that represents what we have been reading. */ void -read_a_source_file (char *name) +read_a_source_file (const char *name) { - register char c; - register char *s; /* String of symbol, '\0' appended. */ - register int temp; + char nul_char; + char next_char; + char *s; /* String of symbol, '\0' appended. */ + int temp; pseudo_typeS *pop; #ifdef WARN_COMMENTS @@ -522,39 +836,83 @@ read_a_source_file (char *name) while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0) { /* We have another line to parse. */ - know (buffer_limit[-1] == '\n'); /* Must have a sentinel. */ +#ifndef NO_LISTING + /* In order to avoid listing macro expansion lines with labels + multiple times, keep track of which line was last issued. */ + static char *last_eol; + last_eol = NULL; +#endif while (input_line_pointer < buffer_limit) { + bfd_boolean was_new_line; /* We have more of this buffer to parse. */ /* We now have input_line_pointer->1st char of next line. If input_line_pointer [-1] == '\n' then we just scanned another line: so bump line counters. */ - if (is_end_of_line[(unsigned char) input_line_pointer[-1]]) + was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]]; + if (was_new_line) { + symbol_set_value_now (&dot_symbol); #ifdef md_start_line_hook md_start_line_hook (); #endif if (input_line_pointer[-1] == '\n') bump_line_counters (); + } + +#ifndef NO_LISTING + /* If listing is on, and we are expanding a macro, then give + the listing code the contents of the expanded line. */ + if (listing) + { + if ((listing & LISTING_MACEXP) && macro_nest > 0) + { + /* Find the end of the current expanded macro line. */ + s = find_end_of_line (input_line_pointer, flag_m68k_mri); + if (s != last_eol) + { + char *copy; + int len; + + last_eol = s; + /* Copy it for safe keeping. Also give an indication of + how much macro nesting is involved at this point. */ + len = s - input_line_pointer; + copy = XNEWVEC (char, len + macro_nest + 2); + memset (copy, '>', macro_nest); + copy[macro_nest] = ' '; + memcpy (copy + macro_nest + 1, input_line_pointer, len); + copy[macro_nest + 1 + len] = '\0'; + + /* Install the line with the listing facility. */ + listing_newline (copy); + } + } + else + listing_newline (NULL); + } +#endif + if (was_new_line) + { line_label = NULL; if (LABELS_WITHOUT_COLONS || flag_m68k_mri) { + next_char = * input_line_pointer; /* Text at the start of a line must be a label, we run down and stick a colon in. */ - if (is_name_beginner (*input_line_pointer)) + if (is_name_beginner (next_char) || next_char == '"') { - char *line_start = input_line_pointer; - char c; + char *line_start; int mri_line_macro; - LISTING_NEWLINE (); - HANDLE_CONDITIONAL_ASSEMBLY (); + HANDLE_CONDITIONAL_ASSEMBLY (0); - c = get_symbol_end (); + nul_char = get_symbol_name (& line_start); + next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char); /* In MRI mode, the EQU and MACRO pseudoops must be handled specially. */ @@ -588,8 +946,7 @@ read_a_source_file (char *name) symbol in the symbol table. */ if (!mri_line_macro #ifdef TC_START_LABEL_WITHOUT_COLON - && TC_START_LABEL_WITHOUT_COLON(c, - input_line_pointer) + && TC_START_LABEL_WITHOUT_COLON (nul_char, next_char) #endif ) line_label = colon (line_start); @@ -599,8 +956,8 @@ read_a_source_file (char *name) (valueT) 0, &zero_address_frag); - *input_line_pointer = c; - if (c == ':') + next_char = restore_line_pointer (nul_char); + if (next_char == ':') input_line_pointer++; } } @@ -612,72 +969,35 @@ read_a_source_file (char *name) Depending on what compiler is used, the order of these tests may vary to catch most common case 1st. - Each test is independent of all other tests at the (top) level. - PLEASE make a compiler that doesn't use this assembler. - It is crufty to waste a compiler's time encoding things for this - assembler, which then wastes more time decoding it. - (And communicating via (linear) files is silly! - If you must pass stuff, please pass a tree!) */ - if ((c = *input_line_pointer++) == '\t' - || c == ' ' - || c == '\f' - || c == 0) - c = *input_line_pointer++; - - know (c != ' '); /* No further leading whitespace. */ - -#ifndef NO_LISTING - /* If listing is on, and we are expanding a macro, then give - the listing code the contents of the expanded line. */ - if (listing) - { - if ((listing & LISTING_MACEXP) && macro_nest > 0) - { - char *copy; - int len; - - /* Find the end of the current expanded macro line. */ - for (s = input_line_pointer - 1; *s; ++s) - if (is_end_of_line[(unsigned char) *s]) - break; + Each test is independent of all other tests at the (top) + level. */ + do + nul_char = next_char = *input_line_pointer++; + while (next_char == '\t' || next_char == ' ' || next_char == '\f'); - /* Copy it for safe keeping. Also give an indication of - how much macro nesting is involved at this point. */ - len = s - (input_line_pointer - 1); - copy = (char *) xmalloc (len + macro_nest + 2); - memset (copy, '>', macro_nest); - copy[macro_nest] = ' '; - memcpy (copy + macro_nest + 1, input_line_pointer - 1, len); - copy[macro_nest + 1 + len] = '\0'; - - /* Install the line with the listing facility. */ - listing_newline (copy); - } - else - listing_newline (NULL); - } -#endif /* C is the 1st significant character. Input_line_pointer points after that character. */ - if (is_name_beginner (c)) + if (is_name_beginner (next_char) || next_char == '"') { + char *rest; + /* Want user-defined label or pseudo/opcode. */ - HANDLE_CONDITIONAL_ASSEMBLY (); + HANDLE_CONDITIONAL_ASSEMBLY (1); - s = --input_line_pointer; - c = get_symbol_end (); /* name's delimiter. */ + --input_line_pointer; + nul_char = get_symbol_name (& s); /* name's delimiter. */ + next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char); + rest = input_line_pointer + (nul_char == '"' ? 2 : 1); - /* C is character after symbol. - That character's place in the input line is now '\0'. + /* NEXT_CHAR is character after symbol. + The end of symbol in the input line is now '\0'. S points to the beginning of the symbol. [In case of pseudo-op, s->'.'.] - Input_line_pointer->'\0' where c was. */ - if (TC_START_LABEL (c, input_line_pointer)) + Input_line_pointer->'\0' where NUL_CHAR was. */ + if (TC_START_LABEL (s, nul_char, next_char)) { if (flag_m68k_mri) { - char *rest = input_line_pointer + 1; - /* In MRI mode, \tsym: set 0 is permitted. */ if (*rest == ':') ++rest; @@ -696,21 +1016,29 @@ read_a_source_file (char *name) } line_label = colon (s); /* User-defined label. */ - /* Put ':' back for error messages' sake. */ - *input_line_pointer++ = ':'; + restore_line_pointer (nul_char); + ++ input_line_pointer; #ifdef tc_check_label tc_check_label (line_label); #endif /* Input_line_pointer->after ':'. */ SKIP_WHITESPACE (); } - else if (c == '=' - || ((c == ' ' || c == '\t') - && input_line_pointer[1] == '=' + else if ((next_char == '=' && *rest == '=') + || ((next_char == ' ' || next_char == '\t') + && rest[0] == '=' + && rest[1] == '=')) + { + equals (s, -1); + demand_empty_rest_of_line (); + } + else if ((next_char == '=' + || ((next_char == ' ' || next_char == '\t') + && *rest == '=')) #ifdef TC_EQUAL_IN_INSN - && !TC_EQUAL_IN_INSN (c, input_line_pointer) + && !TC_EQUAL_IN_INSN (next_char, s) #endif - )) + ) { equals (s, 1); demand_empty_rest_of_line (); @@ -720,11 +1048,12 @@ read_a_source_file (char *name) /* Expect pseudo-op or machine instruction. */ pop = NULL; -#ifdef IGNORE_OPCODE_CASE +#ifndef TC_CASE_SENSITIVE { char *s2 = s; - strncpy (original_case_string, s2, sizeof (original_case_string)); + strncpy (original_case_string, s2, + sizeof (original_case_string) - 1); original_case_string[sizeof (original_case_string) - 1] = 0; while (*s2) @@ -736,8 +1065,8 @@ read_a_source_file (char *name) #endif if (NO_PSEUDO_DOT || flag_m68k_mri) { - /* The MRI assembler and the m88k use pseudo-ops - without a period. */ + /* The MRI assembler uses pseudo-ops without + a period. */ pop = (pseudo_typeS *) hash_find (po_hash, s); if (pop != NULL && pop->poc_handler == NULL) pop = NULL; @@ -748,7 +1077,7 @@ read_a_source_file (char *name) { /* PSEUDO - OP. - WARNING: c has next char, which may be end-of-line. + WARNING: next_char may be end-of-line. We lookup the pseudo-op table with s+1 because we already know that the pseudo-op begins with a '.'. */ @@ -791,18 +1120,27 @@ read_a_source_file (char *name) /* Print the error msg now, while we still can. */ if (pop == NULL) { - as_bad (_("unknown pseudo-op: `%s'"), s); - *input_line_pointer = c; + char *end = input_line_pointer; + + (void) restore_line_pointer (nul_char); s_ignore (0); + nul_char = next_char = *--input_line_pointer; + *input_line_pointer = '\0'; + if (! macro_defined || ! try_macro (next_char, s)) + { + *end = '\0'; + as_bad (_("unknown pseudo-op: `%s'"), s); + *input_line_pointer++ = nul_char; + } continue; } /* Put it back for error messages etc. */ - *input_line_pointer = c; + next_char = restore_line_pointer (nul_char); /* The following skip of whitespace is compulsory. A well shaped space is sometimes all that separates keyword from operands. */ - if (c == ' ' || c == '\t') + if (next_char == ' ' || next_char == '\t') input_line_pointer++; /* Input_line is restored. @@ -816,61 +1154,17 @@ read_a_source_file (char *name) } else { - int inquote = 0; -#ifdef QUOTES_IN_INSN - int inescape = 0; -#endif - - /* WARNING: c has char, which may be end-of-line. */ - /* Also: input_line_pointer->`\0` where c was. */ - *input_line_pointer = c; - while (!is_end_of_line[(unsigned char) *input_line_pointer] - || inquote -#ifdef TC_EOL_IN_INSN - || TC_EOL_IN_INSN (input_line_pointer) -#endif - ) - { - if (flag_m68k_mri && *input_line_pointer == '\'') - inquote = !inquote; -#ifdef QUOTES_IN_INSN - if (inescape) - inescape = 0; - else if (*input_line_pointer == '"') - inquote = !inquote; - else if (*input_line_pointer == '\\') - inescape = 1; -#endif - input_line_pointer++; - } - - c = *input_line_pointer; + /* WARNING: next_char may be end-of-line. */ + /* Also: input_line_pointer->`\0` where nul_char was. */ + (void) restore_line_pointer (nul_char); + input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0); + next_char = nul_char = *input_line_pointer; *input_line_pointer = '\0'; generate_lineno_debug (); - if (macro_defined) - { - sb out; - const char *err; - macro_entry *macro; - - if (check_macro (s, &out, &err, ¯o)) - { - if (err != NULL) - as_bad ("%s", err); - *input_line_pointer++ = c; - input_scrub_include_sb (&out, - input_line_pointer, 1); - sb_kill (&out); - buffer_limit = - input_scrub_next_buffer (&input_line_pointer); -#ifdef md_macro_info - md_macro_info (macro); -#endif - continue; - } - } + if (macro_defined && try_macro (next_char, s)) + continue; if (mri_pending_align) { @@ -883,9 +1177,14 @@ read_a_source_file (char *name) } } - md_assemble (s); /* Assemble 1 instruction. */ + assemble_one (s); /* Assemble 1 instruction. */ - *input_line_pointer++ = c; + /* PR 19630: The backend may have set ilp to NULL + if it encountered a catastrophic failure. */ + if (input_line_pointer == NULL) + as_fatal (_("unable to continue with assembly.")); + + *input_line_pointer++ = nul_char; /* We resume loop AFTER the end-of-line from this instruction. */ @@ -895,17 +1194,20 @@ read_a_source_file (char *name) } /* Empty statement? */ - if (is_end_of_line[(unsigned char) c]) + if (is_end_of_line[(unsigned char) next_char]) continue; - if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c)) + if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (next_char)) { /* local label ("4:") */ char *backup = input_line_pointer; - HANDLE_CONDITIONAL_ASSEMBLY (); + HANDLE_CONDITIONAL_ASSEMBLY (1); + + temp = next_char - '0'; - temp = c - '0'; + if (nul_char == '"') + ++ input_line_pointer; /* Read the whole number. */ while (ISDIGIT (*input_line_pointer)) @@ -939,9 +1241,9 @@ read_a_source_file (char *name) } input_line_pointer = backup; - } /* local label ("4:") */ + } - if (c && strchr (line_comment_chars, c)) + if (next_char && strchr (line_comment_chars, next_char)) { /* Its a comment. Better say APP or NO_APP. */ sb sbuf; char *ends; @@ -950,13 +1252,16 @@ read_a_source_file (char *name) unsigned int new_length; char *tmp_buf = 0; - bump_line_counters (); s = input_line_pointer; if (strncmp (s, "APP\n", 4)) - continue; /* We ignore it */ + { + /* We ignore it. */ + ignore_rest_of_line (); + continue; + } + bump_line_counters (); s += 4; - sb_new (&sbuf); ends = strstr (s, "#NO_APP\n"); if (!ends) @@ -969,7 +1274,7 @@ read_a_source_file (char *name) that goes with this #APP There is one. The specs guarantee it... */ tmp_len = buffer_limit - s; - tmp_buf = xmalloc (tmp_len + 1); + tmp_buf = XNEWVEC (char, tmp_len + 1); memcpy (tmp_buf, s, tmp_len); do { @@ -985,7 +1290,7 @@ read_a_source_file (char *name) else num = buffer_limit - buffer; - tmp_buf = xrealloc (tmp_buf, tmp_len + num); + tmp_buf = XRESIZEVEC (char, tmp_buf, tmp_len + num); memcpy (tmp_buf + tmp_len, buffer, num); tmp_len += num; } @@ -1006,12 +1311,12 @@ read_a_source_file (char *name) scrub_string_end = ends; new_length = ends - s; - new_buf = (char *) xmalloc (new_length); + new_buf = XNEWVEC (char, new_length); new_tmp = new_buf; for (;;) { - int space; - int size; + size_t space; + size_t size; space = (new_buf + new_length) - new_tmp; size = do_scrub_chars (scrub_from_string, new_tmp, space); @@ -1022,13 +1327,12 @@ read_a_source_file (char *name) break; } - new_buf = xrealloc (new_buf, new_length + 100); + new_buf = XRESIZEVEC (char, new_buf, new_length + 100); new_tmp = new_buf + new_length; new_length += 100; } - if (tmp_buf) - free (tmp_buf); + free (tmp_buf); /* We've "scrubbed" input to the preferred format. In the process we may have consumed the whole of the remaining @@ -1037,7 +1341,9 @@ read_a_source_file (char *name) actual macro expansion (possibly nested) and other input expansion work. Beware that in messages, line numbers and possibly file names will be incorrect. */ - sb_add_string (&sbuf, new_buf); + new_length = strlen (new_buf); + sb_build (&sbuf, new_length); + sb_add_buffer (&sbuf, new_buf, new_length); input_scrub_include_sb (&sbuf, input_line_pointer, 0); sb_kill (&sbuf); buffer_limit = input_scrub_next_buffer (&input_line_pointer); @@ -1045,23 +1351,31 @@ read_a_source_file (char *name) continue; } - HANDLE_CONDITIONAL_ASSEMBLY (); + HANDLE_CONDITIONAL_ASSEMBLY (1); #ifdef tc_unrecognized_line - if (tc_unrecognized_line (c)) + if (tc_unrecognized_line (next_char)) continue; #endif input_line_pointer--; - /* Report unknown char as ignored. */ - ignore_rest_of_line (); + /* Report unknown char as error. */ + demand_empty_rest_of_line (); } - -#ifdef md_after_pass_hook - md_after_pass_hook (); -#endif } quit: + symbol_set_value_now (&dot_symbol); + +#ifdef HANDLE_BUNDLE + if (bundle_lock_frag != NULL) + { + as_bad_where (bundle_lock_frag->fr_file, bundle_lock_frag->fr_line, + _(".bundle_lock with no matching .bundle_unlock")); + bundle_lock_frag = NULL; + bundle_lock_frchain = NULL; + bundle_lock_depth = 0; + } +#endif #ifdef md_cleanup md_cleanup (); @@ -1077,6 +1391,29 @@ read_a_source_file (char *name) #endif } +/* Convert O_constant expression EXP into the equivalent O_big representation. + Take the sign of the number from SIGN rather than X_add_number. */ + +static void +convert_to_bignum (expressionS *exp, int sign) +{ + valueT value; + unsigned int i; + + value = exp->X_add_number; + for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++) + { + generic_bignum[i] = value & LITTLENUM_MASK; + value >>= LITTLENUM_NUMBER_OF_BITS; + } + /* Add a sequence of sign bits if the top bit of X_add_number is not + the sign of the original value. */ + if ((exp->X_add_number < 0) == !sign) + generic_bignum[i++] = sign ? LITTLENUM_MASK : 0; + exp->X_op = O_big; + exp->X_add_number = i; +} + /* For most MRI pseudo-ops, the line actually ends at the first nonquoted space. This function looks for that point, stuffs a null in, and sets *STOPCP to the character that used to be there, and @@ -1133,74 +1470,29 @@ s_abort (int ignore ATTRIBUTE_UNUSED) as_fatal (_(".abort detected. Abandoning ship.")); } -/* Guts of .align directive. N is the power of two to which to align. - FILL may be NULL, or it may point to the bytes of the fill pattern. - LEN is the length of whatever FILL points to, if anything. MAX is - the maximum number of characters to skip when doing the alignment, - or 0 if there is no maximum. */ +/* Handle the .align pseudo-op. A positive ARG is a default alignment + (in bytes). A negative ARG is the negative of the length of the + fill pattern. BYTES_P is non-zero if the alignment value should be + interpreted as the byte boundary, rather than the power of 2. */ +#ifndef TC_ALIGN_LIMIT +#define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1) +#endif static void -do_align (int n, char *fill, int len, int max) +s_align (signed int arg, int bytes_p) { - if (now_seg == absolute_section) - { - if (fill != NULL) - while (len-- > 0) - if (*fill++ != '\0') - { - as_warn (_("ignoring fill value in absolute section")); - break; - } - fill = NULL; - len = 0; - } + unsigned int align_limit = TC_ALIGN_LIMIT; + unsigned int align; + char *stop = NULL; + char stopc = 0; + offsetT fill = 0; + unsigned int max; + int fill_p; -#ifdef md_do_align - md_do_align (n, fill, len, max, just_record_alignment); -#endif + if (flag_mri) + stop = mri_comment_field (&stopc); - /* Only make a frag if we HAVE to... */ - if (n != 0 && !need_pass_2) - { - if (fill == NULL) - { - if (subseg_text_p (now_seg)) - frag_align_code (n, max); - else - frag_align (n, 0, max); - } - else if (len <= 1) - frag_align (n, *fill, max); - else - frag_align_pattern (n, fill, len, max); - } - -#ifdef md_do_align - just_record_alignment: ATTRIBUTE_UNUSED_LABEL -#endif - - record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER); -} - -/* Handle the .align pseudo-op. A positive ARG is a default alignment - (in bytes). A negative ARG is the negative of the length of the - fill pattern. BYTES_P is non-zero if the alignment value should be - interpreted as the byte boundary, rather than the power of 2. */ - -static void -s_align (int arg, int bytes_p) -{ - register unsigned int align; - char *stop = NULL; - char stopc; - offsetT fill = 0; - int max; - int fill_p; - - if (flag_mri) - stop = mri_comment_field (&stopc); - - if (is_end_of_line[(unsigned char) *input_line_pointer]) + if (is_end_of_line[(unsigned char) *input_line_pointer]) { if (arg < 0) align = 0; @@ -1211,6 +1503,11 @@ s_align (int arg, int bytes_p) { align = get_absolute_expression (); SKIP_WHITESPACE (); + +#ifdef TC_ALIGN_ZERO_IS_DEFAULT + if (arg > 0 && align == 0) + align = arg; +#endif } if (bytes_p) @@ -1229,9 +1526,9 @@ s_align (int arg, int bytes_p) } } - if (align > 15) + if (align > align_limit) { - align = 15; + align = align_limit; as_warn (_("alignment too large: %u assumed"), align); } @@ -1269,15 +1566,16 @@ s_align (int arg, int bytes_p) } else { - int fill_len; + unsigned int fill_len; if (arg >= 0) fill_len = 1; else fill_len = -arg; + if (fill_len <= 1) { - char fill_char; + char fill_char = 0; fill_char = fill; do_align (align, &fill_char, fill_len, max); @@ -1287,7 +1585,12 @@ s_align (int arg, int bytes_p) char ab[16]; if ((size_t) fill_len > sizeof ab) - abort (); + { + as_warn (_("fill pattern too long, truncating to %u"), + (unsigned) sizeof ab); + fill_len = sizeof ab; + } + md_number_to_chars (ab, fill, fill_len); do_align (align, ab, fill_len, max); } @@ -1317,71 +1620,164 @@ s_align_ptwo (int arg) s_align (arg, 0); } +/* Switch in and out of alternate macro mode. */ + +static void +s_altmacro (int on) +{ + demand_empty_rest_of_line (); + macro_set_alternate (on); +} + +/* Read a symbol name from input_line_pointer. + + Stores the symbol name in a buffer and returns a pointer to this buffer. + The buffer is xalloc'ed. It is the caller's responsibility to free + this buffer. + + The name is not left in the i_l_p buffer as it may need processing + to handle escape characters. + + Advances i_l_p to the next non-whitespace character. + + If a symbol name could not be read, the routine issues an error + messages, skips to the end of the line and returns NULL. */ + +char * +read_symbol_name (void) +{ + char * name; + char * start; + char c; + + c = *input_line_pointer++; + + if (c == '"') + { +#define SYM_NAME_CHUNK_LEN 128 + ptrdiff_t len = SYM_NAME_CHUNK_LEN; + char * name_end; + unsigned int C; + + start = name = XNEWVEC (char, len + 1); + + name_end = name + SYM_NAME_CHUNK_LEN; + + while (is_a_char (C = next_char_of_string ())) + { + if (name >= name_end) + { + ptrdiff_t sofar; + + sofar = name - start; + len += SYM_NAME_CHUNK_LEN; + start = XRESIZEVEC (char, start, len + 1); + name_end = start + len; + name = start + sofar; + } + + *name++ = (char) C; + } + *name = 0; + + /* Since quoted symbol names can contain non-ASCII characters, + check the string and warn if it cannot be recognised by the + current character set. */ + if (mbstowcs (NULL, name, len) == (size_t) -1) + as_warn (_("symbol name not recognised in the current locale")); + } + else if (is_name_beginner (c) || (input_from_string && c == FAKE_LABEL_CHAR)) + { + ptrdiff_t len; + + name = input_line_pointer - 1; + + /* We accept FAKE_LABEL_CHAR in a name in case this is + being called with a constructed string. */ + while (is_part_of_name (c = *input_line_pointer++) + || (input_from_string && c == FAKE_LABEL_CHAR)) + ; + + len = (input_line_pointer - name) - 1; + start = XNEWVEC (char, len + 1); + + memcpy (start, name, len); + start[len] = 0; + + /* Skip a name ender char if one is present. */ + if (! is_name_ender (c)) + --input_line_pointer; + } + else + name = start = NULL; + + if (name == start) + { + as_bad (_("expected symbol name")); + ignore_rest_of_line (); + return NULL; + } + + SKIP_WHITESPACE (); + + return start; +} + + symbolS * s_comm_internal (int param, symbolS *(*comm_parse_extra) (int, symbolS *, addressT)) { char *name; - char c; - char *p; offsetT temp, size; symbolS *symbolP = NULL; char *stop = NULL; - char stopc; + char stopc = 0; expressionS exp; if (flag_mri) stop = mri_comment_field (&stopc); - name = input_line_pointer; - c = get_symbol_end (); - /* Just after name is now '\0'. */ - p = input_line_pointer; - *p = c; - - if (name == p) - { - as_bad (_("expected symbol name")); - discard_rest_of_line (); - goto out; - } - - SKIP_WHITESPACE (); + if ((name = read_symbol_name ()) == NULL) + goto out; /* Accept an optional comma after the name. The comma used to be required, but Irix 5 cc does not generate it for .lcomm. */ if (*input_line_pointer == ',') input_line_pointer++; - *p = 0; temp = get_absolute_expr (&exp); size = temp; -#ifdef BFD_ASSEMBLER - size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1; -#endif + size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1; if (exp.X_op == O_absent) { as_bad (_("missing size expression")); - *p = c; ignore_rest_of_line (); goto out; } else if (temp != size || !exp.X_unsigned) { as_warn (_("size (%ld) out of range, ignored"), (long) temp); - *p = c; ignore_rest_of_line (); goto out; } symbolP = symbol_find_or_make (name); - if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP)) + if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) + && !S_IS_COMMON (symbolP)) { - symbolP = NULL; - as_bad (_("symbol `%s' is already defined"), name); - *p = c; - ignore_rest_of_line (); - goto out; + if (!S_IS_VOLATILE (symbolP)) + { + symbolP = NULL; + as_bad (_("symbol `%s' is already defined"), name); + ignore_rest_of_line (); + goto out; + } + symbolP = symbol_clone (symbolP, 1); + S_SET_SEGMENT (symbolP, undefined_section); + S_SET_VALUE (symbolP, 0); + symbol_set_frag (symbolP, &zero_address_frag); + S_CLEAR_VOLATILE (symbolP); } size = S_GET_VALUE (symbolP); @@ -1391,27 +1787,20 @@ s_comm_internal (int param, as_warn (_("size of \"%s\" is already %ld; not changing to %ld"), name, (long) size, (long) temp); - *p = c; if (comm_parse_extra != NULL) symbolP = (*comm_parse_extra) (param, symbolP, size); else { S_SET_VALUE (symbolP, (valueT) size); S_SET_EXTERNAL (symbolP); -#ifdef OBJ_VMS - { - extern int flag_one; - if (size == 0 || !flag_one) - S_GET_OTHER (symbolP) = const_flag; - } -#endif + S_SET_SEGMENT (symbolP, bfd_com_section_ptr); } - know (symbolP == NULL || symbolP->sy_frag == &zero_address_frag); demand_empty_rest_of_line (); out: if (flag_mri) mri_comment_end (stop, stopc); + free (name); return symbolP; } @@ -1434,7 +1823,7 @@ s_mri_common (int small ATTRIBUTE_UNUSED) symbolS *sym; offsetT align; char *stop = NULL; - char stopc; + char stopc = 0; if (!flag_mri) { @@ -1448,7 +1837,7 @@ s_mri_common (int small ATTRIBUTE_UNUSED) name = input_line_pointer; if (!ISDIGIT (*name)) - c = get_symbol_end (); + c = get_symbol_name (& name); else { do @@ -1462,18 +1851,16 @@ s_mri_common (int small ATTRIBUTE_UNUSED) if (line_label != NULL) { - alc = (char *) xmalloc (strlen (S_GET_NAME (line_label)) - + (input_line_pointer - name) - + 1); + alc = XNEWVEC (char, strlen (S_GET_NAME (line_label)) + + (input_line_pointer - name) + 1); sprintf (alc, "%s%s", name, S_GET_NAME (line_label)); name = alc; } } sym = symbol_find_or_make (name); - *input_line_pointer = c; - if (alc != NULL) - free (alc); + c = restore_line_pointer (c); + free (alc); if (*input_line_pointer != ',') align = 0; @@ -1492,11 +1879,14 @@ s_mri_common (int small ATTRIBUTE_UNUSED) } S_SET_EXTERNAL (sym); + S_SET_SEGMENT (sym, bfd_com_section_ptr); mri_common_symbol = sym; #ifdef S_SET_ALIGN if (align != 0) S_SET_ALIGN (sym, align); +#else + (void) align; #endif if (line_label != NULL) @@ -1528,7 +1918,7 @@ void s_data (int ignore ATTRIBUTE_UNUSED) { segT section; - register int temp; + int temp; temp = get_absolute_expression (); if (flag_readonly_data_in_text) @@ -1541,9 +1931,6 @@ s_data (int ignore ATTRIBUTE_UNUSED) subseg_set (section, (subsegT) temp); -#ifdef OBJ_VMS - const_flag = 0; -#endif demand_empty_rest_of_line (); } @@ -1555,7 +1942,7 @@ s_data (int ignore ATTRIBUTE_UNUSED) .file. */ void -s_app_file_string (char *file) +s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED) { #ifdef LISTING if (listing) @@ -1563,24 +1950,21 @@ s_app_file_string (char *file) #endif register_dependency (file); #ifdef obj_app_file - obj_app_file (file); + obj_app_file (file, appfile); #endif } void s_app_file (int appfile) { - register char *s; + char *s; int length; /* Some assemblers tolerate immediately following '"'. */ if ((s = demand_copy_string (&length)) != 0) { - /* If this is a fake .appfile, a fake newline was inserted into - the buffer. Passing -2 to new_logical_line tells it to - account for it. */ int may_omit - = (!new_logical_line (s, appfile ? -2 : -1) && appfile); + = (!new_logical_line_flags (s, -1, 1) && appfile); /* In MRI mode, the preprocessor may have inserted an extraneous backquote. */ @@ -1591,36 +1975,127 @@ s_app_file (int appfile) demand_empty_rest_of_line (); if (!may_omit) - s_app_file_string (s); + s_app_file_string (s, appfile); } } +static int +get_linefile_number (int *flag) +{ + SKIP_WHITESPACE (); + + if (*input_line_pointer < '0' || *input_line_pointer > '9') + return 0; + + *flag = get_absolute_expression (); + + return 1; +} + /* Handle the .appline pseudo-op. This is automatically generated by do_scrub_chars when a preprocessor # line comment is seen. This default definition may be overridden by the object or CPU specific pseudo-ops. */ void -s_app_line (int ignore ATTRIBUTE_UNUSED) +s_app_line (int appline) { + char *file = NULL; int l; /* The given number is that of the next line. */ - l = get_absolute_expression () - 1; - if (l < 0) + if (appline) + l = get_absolute_expression (); + else if (!get_linefile_number (&l)) + { + ignore_rest_of_line (); + return; + } + + l--; + + if (l < -1) /* Some of the back ends can't deal with non-positive line numbers. - Besides, it's silly. */ + Besides, it's silly. GCC however will generate a line number of + zero when it is pre-processing builtins for assembler-with-cpp files: + + # 0 "" + + We do not want to barf on this, especially since such files are used + in the GCC and GDB testsuites. So we check for negative line numbers + rather than non-positive line numbers. */ as_warn (_("line numbers must be positive; line number %d rejected"), l + 1); else { - new_logical_line ((char *) NULL, l); + int flags = 0; + int length = 0; + + if (!appline) + { + SKIP_WHITESPACE (); + + if (*input_line_pointer == '"') + file = demand_copy_string (&length); + + if (file) + { + int this_flag; + + while (get_linefile_number (&this_flag)) + switch (this_flag) + { + /* From GCC's cpp documentation: + 1: start of a new file. + 2: returning to a file after having included + another file. + 3: following text comes from a system header file. + 4: following text should be treated as extern "C". + + 4 is nonsensical for the assembler; 3, we don't + care about, so we ignore it just in case a + system header file is included while + preprocessing assembly. So 1 and 2 are all we + care about, and they are mutually incompatible. + new_logical_line_flags() demands this. */ + case 1: + case 2: + if (flags && flags != (1 << this_flag)) + as_warn (_("incompatible flag %i in line directive"), + this_flag); + else + flags |= 1 << this_flag; + break; + + case 3: + case 4: + /* We ignore these. */ + break; + + default: + as_warn (_("unsupported flag %i in line directive"), + this_flag); + break; + } + + if (!is_end_of_line[(unsigned char)*input_line_pointer]) + file = 0; + } + } + + if (appline || file) + { + new_logical_line_flags (file, l, flags); #ifdef LISTING - if (listing) - listing_source_line (l); + if (listing) + listing_source_line (l); #endif + } } - demand_empty_rest_of_line (); + if (appline || file) + demand_empty_rest_of_line (); + else + ignore_rest_of_line (); } /* Handle the .end pseudo-op. Actually, the real work is done in @@ -1650,6 +2125,43 @@ s_err (int ignore ATTRIBUTE_UNUSED) demand_empty_rest_of_line (); } +/* Handle the .error and .warning pseudo-ops. */ + +void +s_errwarn (int err) +{ + int len; + /* The purpose for the conditional assignment is not to + internationalize the directive itself, but that we need a + self-contained message, one that can be passed like the + demand_copy_C_string return value, and with no assumption on the + location of the name of the directive within the message. */ + const char *msg + = (err ? _(".error directive invoked in source file") + : _(".warning directive invoked in source file")); + + if (!is_it_end_of_statement ()) + { + if (*input_line_pointer != '\"') + { + as_bad (_("%s argument must be a string"), + err ? ".error" : ".warning"); + ignore_rest_of_line (); + return; + } + + msg = demand_copy_C_string (&len); + if (msg == NULL) + return; + } + + if (err) + as_bad ("%s", msg); + else + as_warn ("%s", msg); + demand_empty_rest_of_line (); +} + /* Handle the MRI fail pseudo-op. */ void @@ -1657,7 +2169,7 @@ s_fail (int ignore ATTRIBUTE_UNUSED) { offsetT temp; char *stop = NULL; - char stopc; + char stopc = 0; if (flag_mri) stop = mri_comment_field (&stopc); @@ -1679,14 +2191,18 @@ s_fill (int ignore ATTRIBUTE_UNUSED) { expressionS rep_exp; long size = 1; - register long fill = 0; + long fill = 0; char *p; #ifdef md_flush_pending_output md_flush_pending_output (); #endif - get_known_segmented_expression (&rep_exp); +#ifdef md_cons_align + md_cons_align (1); +#endif + + expression (&rep_exp); if (*input_line_pointer == ',') { input_line_pointer++; @@ -1719,6 +2235,20 @@ s_fill (int ignore ATTRIBUTE_UNUSED) if (size && !need_pass_2) { + if (now_seg == absolute_section) + { + if (rep_exp.X_op != O_constant) + as_bad (_("non-constant fill count for absolute section")); + else if (fill && rep_exp.X_add_number != 0) + as_bad (_("attempt to fill absolute section with non-zero value")); + abs_section_offset += rep_exp.X_add_number * size; + } + else if (fill + && (rep_exp.X_op != O_constant || rep_exp.X_add_number != 0) + && in_bss ()) + as_bad (_("attempt to fill section `%s' with non-zero value"), + segment_name (now_seg)); + if (rep_exp.X_op == O_constant) { p = frag_var (rs_fill, (int) size, (int) size, @@ -1779,19 +2309,19 @@ s_globl (int ignore ATTRIBUTE_UNUSED) int c; symbolS *symbolP; char *stop = NULL; - char stopc; + char stopc = 0; if (flag_mri) stop = mri_comment_field (&stopc); do { - name = input_line_pointer; - c = get_symbol_end (); + if ((name = read_symbol_name ()) == NULL) + return; + symbolP = symbol_find_or_make (name); S_SET_EXTERNAL (symbolP); - *input_line_pointer = c; SKIP_WHITESPACE (); c = *input_line_pointer; if (c == ',') @@ -1801,6 +2331,8 @@ s_globl (int ignore ATTRIBUTE_UNUSED) if (is_end_of_line[(unsigned char) *input_line_pointer]) c = '\n'; } + + free (name); } while (c == ','); @@ -1815,21 +2347,23 @@ s_globl (int ignore ATTRIBUTE_UNUSED) void s_irp (int irpc) { - char *file; + char * eol; + const char * file; unsigned int line; sb s; const char *err; sb out; - as_where (&file, &line); + file = as_where (&line); - sb_new (&s); - while (!is_end_of_line[(unsigned char) *input_line_pointer]) - sb_add_char (&s, *input_line_pointer++); + eol = find_end_of_line (input_line_pointer, 0); + sb_build (&s, eol - input_line_pointer); + sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer); + input_line_pointer = eol; sb_new (&out); - err = expand_irp (irpc, 0, &s, &out, get_line_sb); + err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb); if (err != NULL) as_bad_where (file, line, "%s", err); @@ -1859,8 +2393,7 @@ s_linkonce (int ignore ATTRIBUTE_UNUSED) char *s; char c; - s = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (& s); if (strcasecmp (s, "discard") == 0) type = LINKONCE_DISCARD; else if (strcasecmp (s, "one_only") == 0) @@ -1872,20 +2405,19 @@ s_linkonce (int ignore ATTRIBUTE_UNUSED) else as_warn (_("unrecognized .linkonce type `%s'"), s); - *input_line_pointer = c; + (void) restore_line_pointer (c); } #ifdef obj_handle_link_once obj_handle_link_once (type); #else /* ! defined (obj_handle_link_once) */ -#ifdef BFD_ASSEMBLER { flagword flags; if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0) as_warn (_(".linkonce is not supported for this object file format")); - flags = bfd_get_section_flags (stdoutput, now_seg); + flags = bfd_section_flags (now_seg); flags |= SEC_LINK_ONCE; switch (type) { @@ -1904,20 +2436,17 @@ s_linkonce (int ignore ATTRIBUTE_UNUSED) flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; break; } - if (!bfd_set_section_flags (stdoutput, now_seg, flags)) + if (!bfd_set_section_flags (now_seg, flags)) as_bad (_("bfd_set_section_flags: %s"), bfd_errmsg (bfd_get_error ())); } -#else /* ! defined (BFD_ASSEMBLER) */ - as_warn (_(".linkonce is not supported for this object file format")); -#endif /* ! defined (BFD_ASSEMBLER) */ #endif /* ! defined (obj_handle_link_once) */ demand_empty_rest_of_line (); } void -bss_alloc (symbolS *symbolP, addressT size, int align) +bss_alloc (symbolS *symbolP, addressT size, unsigned int align) { char *pfrag; segT current_seg = now_seg; @@ -1933,17 +2462,15 @@ bss_alloc (symbolS *symbolP, addressT size, int align) { bss_seg = subseg_new (".sbss", 1); seg_info (bss_seg)->bss = 1; -#ifdef BFD_ASSEMBLER - if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC)) + if (!bfd_set_section_flags (bss_seg, SEC_ALLOC | SEC_SMALL_DATA)) as_warn (_("error setting flags for \".sbss\": %s"), bfd_errmsg (bfd_get_error ())); -#endif } } #endif subseg_set (bss_seg, 1); - if (align) + if (align > OCTETS_PER_BYTE_POWER) { record_alignment (bss_seg, align); frag_align (align, 0, 0); @@ -2058,59 +2585,33 @@ s_lcomm_bytes (int needs_align) void s_lsym (int ignore ATTRIBUTE_UNUSED) { - register char *name; - register char c; - register char *p; + char *name; expressionS exp; - register symbolS *symbolP; + symbolS *symbolP; /* We permit ANY defined expression: BSD4.2 demands constants. */ - name = input_line_pointer; - c = get_symbol_end (); - p = input_line_pointer; - *p = c; - - if (name == p) - { - as_bad (_("expected symbol name")); - discard_rest_of_line (); - return; - } - - SKIP_WHITESPACE (); + if ((name = read_symbol_name ()) == NULL) + return; if (*input_line_pointer != ',') { - *p = 0; as_bad (_("expected comma after \"%s\""), name); - *p = c; - ignore_rest_of_line (); - return; + goto err_out; } input_line_pointer++; - expression (&exp); + expression_and_evaluate (&exp); if (exp.X_op != O_constant && exp.X_op != O_register) { as_bad (_("bad expression")); - ignore_rest_of_line (); - return; + goto err_out; } - *p = 0; symbolP = symbol_find_or_make (name); - /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 && - symbolP->sy_desc == 0) out of this test because coff doesn't have - those fields, and I can't see when they'd ever be tripped. I - don't think I understand why they were here so I may have - introduced a bug. As recently as 1.37 didn't have this test - anyway. xoxorich. */ - - if (S_GET_SEGMENT (symbolP) == undefined_section - && S_GET_VALUE (symbolP) == 0) + if (S_GET_SEGMENT (symbolP) == undefined_section) { /* The name might be an undefined .global symbol; be sure to keep the "external" bit. */ @@ -2125,18 +2626,23 @@ s_lsym (int ignore ATTRIBUTE_UNUSED) as_bad (_("symbol `%s' is already defined"), name); } - *p = c; demand_empty_rest_of_line (); + free (name); + return; + + err_out: + ignore_rest_of_line (); + free (name); + return; } /* Read a line into an sb. Returns the character that ended the line or zero if there are no more lines. */ static int -get_line_sb (sb *line) +get_line_sb (sb *line, int in_macro) { - char quote1, quote2, inquote; - unsigned char c; + char *eol; if (input_line_pointer[-1] == '\n') bump_line_counters (); @@ -2148,45 +2654,28 @@ get_line_sb (sb *line) return 0; } - /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this - code needs to be changed. */ - if (!flag_m68k_mri) - quote1 = '"'; - else - quote1 = '\0'; - - quote2 = '\0'; - if (flag_m68k_mri) - quote2 = '\''; -#ifdef LEX_IS_STRINGQUOTE - quote2 = '\''; -#endif - - inquote = '\0'; - - while ((c = * input_line_pointer ++) != 0 - && (!is_end_of_line[c] - || (inquote != '\0' && c != '\n'))) - { - if (inquote == c) - inquote = '\0'; - else if (inquote == '\0') - { - if (c == quote1) - inquote = quote1; - else if (c == quote2) - inquote = quote2; - } - - sb_add_char (line, c); - } + eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro); + sb_add_buffer (line, input_line_pointer, eol - input_line_pointer); + input_line_pointer = eol; /* Don't skip multiple end-of-line characters, because that breaks support for the IA-64 stop bit (;;) which looks like two consecutive end-of-line characters but isn't. Instead just skip one end of line character and return the character skipped so that the caller can re-insert it if necessary. */ - return c; + return *input_line_pointer++; +} + +static size_t +get_non_macro_line_sb (sb *line) +{ + return get_line_sb (line, 0); +} + +static size_t +get_macro_line_sb (sb *line) +{ + return get_line_sb (line, 1); } /* Define a macro. This is an interface to macro.c. */ @@ -2194,31 +2683,41 @@ get_line_sb (sb *line) void s_macro (int ignore ATTRIBUTE_UNUSED) { - char *file; + char *eol; + const char * file; unsigned int line; sb s; - sb label; const char *err; const char *name; - as_where (&file, &line); + file = as_where (&line); - sb_new (&s); - while (!is_end_of_line[(unsigned char) *input_line_pointer]) - sb_add_char (&s, *input_line_pointer++); + eol = find_end_of_line (input_line_pointer, 0); + sb_build (&s, eol - input_line_pointer); + sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer); + input_line_pointer = eol; - sb_new (&label); if (line_label != NULL) - sb_add_string (&label, S_GET_NAME (line_label)); + { + sb label; + size_t len; - err = define_macro (0, &s, &label, get_line_sb, &name); + name = S_GET_NAME (line_label); + len = strlen (name); + sb_build (&label, len); + sb_add_buffer (&label, name, len); + err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name); + sb_kill (&label); + } + else + err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name); if (err != NULL) - as_bad_where (file, line, "%s", err); + as_bad_where (file, line, err, name); else { if (line_label != NULL) { - S_SET_SEGMENT (line_label, undefined_section); + S_SET_SEGMENT (line_label, absolute_section); S_SET_VALUE (line_label, 0); symbol_set_frag (line_label, &zero_address_frag); } @@ -2228,7 +2727,9 @@ s_macro (int ignore ATTRIBUTE_UNUSED) || (!flag_m68k_mri && *name == '.' && hash_find (po_hash, name + 1) != NULL)) - as_warn (_("attempt to redefine pseudo-op `%s' ignored"), + as_warn_where (file, + line, + _("attempt to redefine pseudo-op `%s' ignored"), name); } @@ -2241,8 +2742,13 @@ s_macro (int ignore ATTRIBUTE_UNUSED) void s_mexit (int ignore ATTRIBUTE_UNUSED) { - cond_exit_macro (macro_nest); - buffer_limit = input_scrub_next_buffer (&input_line_pointer); + if (macro_nest) + { + cond_exit_macro (macro_nest); + buffer_limit = input_scrub_next_buffer (&input_line_pointer); + } + else + as_warn (_("ignoring macro exit outside a macro definition.")); } /* Switch in and out of MRI mode. */ @@ -2250,10 +2756,15 @@ s_mexit (int ignore ATTRIBUTE_UNUSED) void s_mri (int ignore ATTRIBUTE_UNUSED) { - int on, old_flag; + int on; +#ifdef MRI_MODE_CHANGE + int old_flag; +#endif on = get_absolute_expression (); +#ifdef MRI_MODE_CHANGE old_flag = flag_mri; +#endif if (on != 0) { flag_mri = 1; @@ -2288,7 +2799,9 @@ s_mri (int ignore ATTRIBUTE_UNUSED) static void do_org (segT segment, expressionS *exp, int fill) { - if (segment != now_seg && segment != absolute_section) + if (segment != now_seg + && segment != absolute_section + && segment != expr_section) as_bad (_("invalid segment \"%s\""), segment_name (segment)); if (now_seg == absolute_section) @@ -2308,6 +2821,10 @@ do_org (segT segment, expressionS *exp, int fill) symbolS *sym = exp->X_add_symbol; offsetT off = exp->X_add_number * OCTETS_PER_BYTE; + if (fill && in_bss ()) + as_warn (_("ignoring fill value in section `%s'"), + segment_name (now_seg)); + if (exp->X_op != O_constant && exp->X_op != O_symbol) { /* Handle complex expressions. */ @@ -2323,9 +2840,9 @@ do_org (segT segment, expressionS *exp, int fill) void s_org (int ignore ATTRIBUTE_UNUSED) { - register segT segment; + segT segment; expressionS exp; - register long temp_fill; + long temp_fill; #ifdef md_flush_pending_output md_flush_pending_output (); @@ -2372,8 +2889,7 @@ s_org (int ignore ATTRIBUTE_UNUSED) called by the obj-format routine which handles section changing when in MRI mode. It will create a new section, and return it. It will set *TYPE to the section type: one of 'C' (code), 'D' (data), - 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the - flags will be set in the section. */ + 'M' (mixed), or 'R' (romable). The flags will be set in the section. */ void s_mri_sect (char *type ATTRIBUTE_UNUSED) @@ -2388,7 +2904,7 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED) name = input_line_pointer; if (!ISDIGIT (*name)) - c = get_symbol_end (); + c = get_symbol_name (& name); else { do @@ -2403,13 +2919,13 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED) name = xstrdup (name); - *input_line_pointer = c; + c = restore_line_pointer (c); seg = subseg_new (name, 0); - if (*input_line_pointer == ',') + if (c == ',') { - int align; + unsigned int align; ++input_line_pointer; align = get_absolute_expression (); @@ -2427,7 +2943,6 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED) as_bad (_("unrecognized section type")); ++input_line_pointer; -#ifdef BFD_ASSEMBLER { flagword flags; @@ -2440,13 +2955,12 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED) flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM; if (flags != SEC_NO_FLAGS) { - if (!bfd_set_section_flags (stdoutput, seg, flags)) + if (!bfd_set_section_flags (seg, flags)) as_warn (_("error setting flags for \"%s\": %s"), - bfd_section_name (stdoutput, seg), + bfd_section_name (seg), bfd_errmsg (bfd_get_error ())); } } -#endif } /* Ignore the HP type. */ @@ -2456,102 +2970,28 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED) demand_empty_rest_of_line (); #else /* ! TC_M68K */ -#ifdef TC_I960 + /* The MRI assembler seems to use different forms of .sect for + different targets. */ + as_bad ("MRI mode not supported for this target"); + ignore_rest_of_line (); +#endif /* ! TC_M68K */ +} - char *name; - char c; - segT seg; +/* Handle the .print pseudo-op. */ - SKIP_WHITESPACE (); +void +s_print (int ignore ATTRIBUTE_UNUSED) +{ + char *s; + int len; - name = input_line_pointer; - c = get_symbol_end (); + s = demand_copy_C_string (&len); + if (s != NULL) + printf ("%s\n", s); + demand_empty_rest_of_line (); +} - name = xstrdup (name); - - *input_line_pointer = c; - - seg = subseg_new (name, 0); - - if (*input_line_pointer != ',') - *type = 'C'; - else - { - char *sectype; - - ++input_line_pointer; - SKIP_WHITESPACE (); - sectype = input_line_pointer; - c = get_symbol_end (); - if (*sectype == '\0') - *type = 'C'; - else if (strcasecmp (sectype, "text") == 0) - *type = 'C'; - else if (strcasecmp (sectype, "data") == 0) - *type = 'D'; - else if (strcasecmp (sectype, "romdata") == 0) - *type = 'R'; - else - as_warn (_("unrecognized section type `%s'"), sectype); - *input_line_pointer = c; - } - - if (*input_line_pointer == ',') - { - char *seccmd; - - ++input_line_pointer; - SKIP_WHITESPACE (); - seccmd = input_line_pointer; - c = get_symbol_end (); - if (strcasecmp (seccmd, "absolute") == 0) - { - as_bad (_("absolute sections are not supported")); - *input_line_pointer = c; - ignore_rest_of_line (); - return; - } - else if (strcasecmp (seccmd, "align") == 0) - { - int align; - - *input_line_pointer = c; - align = get_absolute_expression (); - record_alignment (seg, align); - } - else - { - as_warn (_("unrecognized section command `%s'"), seccmd); - *input_line_pointer = c; - } - } - - demand_empty_rest_of_line (); - -#else /* ! TC_I960 */ - /* The MRI assembler seems to use different forms of .sect for - different targets. */ - as_bad ("MRI mode not supported for this target"); - ignore_rest_of_line (); -#endif /* ! TC_I960 */ -#endif /* ! TC_M68K */ -} - -/* Handle the .print pseudo-op. */ - -void -s_print (int ignore ATTRIBUTE_UNUSED) -{ - char *s; - int len; - - s = demand_copy_C_string (&len); - if (s != NULL) - printf ("%s\n", s); - demand_empty_rest_of_line (); -} - -/* Handle the .purgem pseudo-op. */ +/* Handle the .purgem pseudo-op. */ void s_purgem (int ignore ATTRIBUTE_UNUSED) @@ -2568,11 +3008,10 @@ s_purgem (int ignore ATTRIBUTE_UNUSED) char c; SKIP_WHITESPACE (); - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (& name); delete_macro (name); *input_line_pointer = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); } while (*input_line_pointer++ == ','); @@ -2580,12 +3019,14 @@ s_purgem (int ignore ATTRIBUTE_UNUSED) demand_empty_rest_of_line (); } -/* Handle the .rept pseudo-op. */ +/* Handle the .endm/.endr pseudo-ops. */ -void -s_bad_endr (int ignore ATTRIBUTE_UNUSED) +static void +s_bad_end (int endr) { - as_warn (_(".endr encountered without preceeding .rept, .irc, or .irp")); + as_warn (_(".end%c encountered without preceding %s"), + endr ? 'r' : 'm', + endr ? ".rept, .irp, or .irpc" : ".macro"); demand_empty_rest_of_line (); } @@ -2594,9 +3035,9 @@ s_bad_endr (int ignore ATTRIBUTE_UNUSED) void s_rept (int ignore ATTRIBUTE_UNUSED) { - int count; + size_t count; - count = get_absolute_expression (); + count = (size_t) get_absolute_expression (); do_repeat (count, "REPT", "ENDR"); } @@ -2605,19 +3046,25 @@ s_rept (int ignore ATTRIBUTE_UNUSED) different directives to be used as the start/end keys. */ void -do_repeat (int count, const char *start, const char *end) +do_repeat (size_t count, const char *start, const char *end) { sb one; sb many; + if (((ssize_t) count) < 0) + { + as_bad (_("negative count for %s - ignored"), start); + count = 0; + } + sb_new (&one); - if (!buffer_and_nest (start, end, &one, get_line_sb)) + if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb)) { as_bad (_("%s without %s"), start, end); return; } - sb_new (&many); + sb_build (&many, count * one.len); while (count-- > 0) sb_add_sb (&many, &one); @@ -2628,6 +3075,64 @@ do_repeat (int count, const char *start, const char *end) buffer_limit = input_scrub_next_buffer (&input_line_pointer); } +/* Like do_repeat except that any text matching EXPANDER in the + block is replaced by the iteration count. */ + +void +do_repeat_with_expander (size_t count, + const char * start, + const char * end, + const char * expander) +{ + sb one; + sb many; + + if (((ssize_t) count) < 0) + { + as_bad (_("negative count for %s - ignored"), start); + count = 0; + } + + sb_new (&one); + if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb)) + { + as_bad (_("%s without %s"), start, end); + return; + } + + sb_new (&many); + + if (expander != NULL && strstr (one.ptr, expander) != NULL) + { + while (count -- > 0) + { + int len; + char * sub; + sb processed; + + sb_build (& processed, one.len); + sb_add_sb (& processed, & one); + sub = strstr (processed.ptr, expander); + len = sprintf (sub, "%lu", (unsigned long) count); + gas_assert (len < 8); + memmove (sub + len, sub + 8, + processed.ptr + processed.len - (sub + 8)); + processed.len -= (8 - len); + sb_add_sb (& many, & processed); + sb_kill (& processed); + } + } + else + while (count-- > 0) + sb_add_sb (&many, &one); + + sb_kill (&one); + + input_scrub_include_sb (&many, input_line_pointer, 1); + sb_kill (&many); + buffer_limit = input_scrub_next_buffer (&input_line_pointer); +} + /* Skip to end of current repeat loop; EXTRA indicates how many additional input buffers to skip. Assumes that conditionals preceding the loop end are properly nested. @@ -2644,51 +3149,15 @@ end_repeat (int extra) buffer_limit = input_scrub_next_buffer (&input_line_pointer); } -/* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then - this is .equiv, and it is an error if the symbol is already - defined. */ - -void -s_set (int equiv) +static void +assign_symbol (char *name, int mode) { - register char *name; - register char delim; - register char *end_name; - register symbolS *symbolP; - - /* Especial apologies for the random logic: - this just grew, and could be parsed much more simply! - Dean in haste. */ - name = input_line_pointer; - delim = get_symbol_end (); - end_name = input_line_pointer; - *end_name = delim; - - if (name == end_name) - { - as_bad (_("expected symbol name")); - discard_rest_of_line (); - return; - } - - SKIP_WHITESPACE (); - - if (*input_line_pointer != ',') - { - *end_name = 0; - as_bad (_("expected comma after \"%s\""), name); - *end_name = delim; - ignore_rest_of_line (); - return; - } - - input_line_pointer++; - *end_name = 0; + symbolS *symbolP; if (name[0] == '.' && name[1] == '\0') { /* Turn '. = mumble' into a .org mumble. */ - register segT segment; + segT segment; expressionS exp; segment = get_known_segmented_expression (&exp); @@ -2696,13 +3165,13 @@ s_set (int equiv) if (!need_pass_2) do_org (segment, &exp, 0); - *end_name = delim; return; } if ((symbolP = symbol_find (name)) == NULL && (symbolP = md_undefined_symbol (name)) == NULL) { + symbolP = symbol_find_or_make (name); #ifndef NO_LISTING /* When doing symbol listings, play games with dummy fragments living outside the normal fragment chain to record the file and line info @@ -2710,34 +3179,71 @@ s_set (int equiv) if (listing & LISTING_SYMBOLS) { extern struct list_info_struct *listing_tail; - fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS)); - memset (dummy_frag, 0, sizeof (fragS)); - dummy_frag->fr_type = rs_fill; + fragS *dummy_frag = XCNEW (fragS); dummy_frag->line = listing_tail; - symbolP = symbol_new (name, undefined_section, 0, dummy_frag); dummy_frag->fr_symbol = symbolP; + symbol_set_frag (symbolP, dummy_frag); } - else #endif - symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag); - -#ifdef OBJ_COFF +#if defined (OBJ_COFF) && !defined (TE_PE) /* "set" symbols are local unless otherwise specified. */ SF_SET_LOCAL (symbolP); -#endif /* OBJ_COFF */ +#endif } - symbol_table_insert (symbolP); - - *end_name = delim; + if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) + { + if ((mode != 0 || !S_IS_VOLATILE (symbolP)) + && !S_CAN_BE_REDEFINED (symbolP)) + { + as_bad (_("symbol `%s' is already defined"), name); + ignore_rest_of_line (); + input_line_pointer--; + return; + } + /* If the symbol is volatile, copy the symbol and replace the + original with the copy, so that previous uses of the symbol will + retain the value of the symbol at the point of use. */ + else if (S_IS_VOLATILE (symbolP)) + symbolP = symbol_clone (symbolP, 1); + } - if (equiv - && S_IS_DEFINED (symbolP) - && S_GET_SEGMENT (symbolP) != reg_section) - as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP)); + if (mode == 0) + S_SET_VOLATILE (symbolP); + else if (mode < 0) + S_SET_FORWARD_REF (symbolP); pseudo_set (symbolP); +} + +/* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1, + then this is .equiv, and it is an error if the symbol is already + defined. If EQUIV is -1, the symbol additionally is a forward + reference. */ + +void +s_set (int equiv) +{ + char *name; + + /* Especial apologies for the random logic: + this just grew, and could be parsed much more simply! + Dean in haste. */ + if ((name = read_symbol_name ()) == NULL) + return; + + if (*input_line_pointer != ',') + { + as_bad (_("expected comma after \"%s\""), name); + ignore_rest_of_line (); + free (name); + return; + } + + input_line_pointer++; + assign_symbol (name, equiv); demand_empty_rest_of_line (); + free (name); } void @@ -2747,13 +3253,17 @@ s_space (int mult) expressionS val; char *p = 0; char *stop = NULL; - char stopc; + char stopc = 0; int bytes; #ifdef md_flush_pending_output md_flush_pending_output (); #endif +#ifdef md_cons_align + md_cons_align (1); +#endif + if (flag_mri) stop = mri_comment_field (&stopc); @@ -2769,12 +3279,12 @@ s_space (int mult) } else if (mri_common_symbol != NULL) { - valueT val; + valueT mri_val; - val = S_GET_VALUE (mri_common_symbol); - if ((val & 1) != 0) + mri_val = S_GET_VALUE (mri_common_symbol); + if ((mri_val & 1) != 0) { - S_SET_VALUE (mri_common_symbol, val + 1); + S_SET_VALUE (mri_common_symbol, mri_val + 1); if (line_label != NULL) { expressionS *symexp; @@ -2813,29 +3323,43 @@ s_space (int mult) val.X_add_number = 0; } - if (val.X_op != O_constant - || val.X_add_number < - 0x80 - || val.X_add_number > 0xff - || (mult != 0 && mult != 1 && val.X_add_number != 0)) + if ((val.X_op != O_constant + || val.X_add_number < - 0x80 + || val.X_add_number > 0xff + || (mult != 0 && mult != 1 && val.X_add_number != 0)) + && (now_seg != absolute_section && !in_bss ())) { + resolve_expression (&exp); if (exp.X_op != O_constant) as_bad (_("unsupported variable size or fill value")); else { offsetT i; - if (mult == 0) - mult = 1; - bytes = mult * exp.X_add_number; - for (i = 0; i < exp.X_add_number; i++) - emit_expr (&val, mult); + /* PR 20901: Check for excessive values. + FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */ + if (exp.X_add_number < 0 || exp.X_add_number > (1 << 10)) + as_bad (_("size value for space directive too large: %lx"), + (long) exp.X_add_number); + else + { + if (mult == 0) + mult = 1; + bytes = mult * exp.X_add_number; + + for (i = 0; i < exp.X_add_number; i++) + emit_expr (&val, mult); + } } } else { + if (now_seg == absolute_section || mri_common_symbol != NULL) + resolve_expression (&exp); + if (exp.X_op == O_constant) { - long repeat; + offsetT repeat; repeat = exp.X_add_number; if (mult) @@ -2853,6 +3377,8 @@ s_space (int mult) /* If we are in the absolute section, just bump the offset. */ if (now_seg == absolute_section) { + if (val.X_op != O_constant || val.X_add_number != 0) + as_warn (_("ignoring fill value in absolute section")); abs_section_offset += repeat; goto getout; } @@ -2890,7 +3416,10 @@ s_space (int mult) make_expr_symbol (&exp), (offsetT) 0, (char *) 0); } - if (p) + if ((val.X_op != O_constant || val.X_add_number != 0) && in_bss ()) + as_warn (_("ignoring fill value in section `%s'"), + segment_name (now_seg)); + else if (p) *p = val.X_add_number; } @@ -2908,6 +3437,58 @@ s_space (int mult) mri_comment_end (stop, stopc); } +void +s_nops (int ignore ATTRIBUTE_UNUSED) +{ + expressionS exp; + expressionS val; + +#ifdef md_flush_pending_output + md_flush_pending_output (); +#endif + +#ifdef md_cons_align + md_cons_align (1); +#endif + + expression (&exp); + + if (*input_line_pointer == ',') + { + ++input_line_pointer; + expression (&val); + } + else + { + val.X_op = O_constant; + val.X_add_number = 0; + } + + if (val.X_op == O_constant) + { + if (val.X_add_number < 0) + { + as_warn (_("negative nop control byte, ignored")); + val.X_add_number = 0; + } + + if (!need_pass_2) + { + /* Store the no-op instruction control byte in the first byte + of frag. */ + char *p; + symbolS *sym = make_expr_symbol (&exp); + p = frag_var (rs_space_nop, 1, 1, (relax_substateT) 0, + sym, (offsetT) 0, (char *) 0); + *p = val.X_add_number; + } + } + else + as_bad (_("unsupported variable nop control in .nops directive")); + + demand_empty_rest_of_line (); +} + /* This is like s_space, but the value is a floating point number with the given precision. This is for the MRI dcb.s pseudo-op and friends. */ @@ -2919,7 +3500,11 @@ s_float_space (int float_type) int flen; char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; char *stop = NULL; - char stopc; + char stopc = 0; + +#ifdef md_cons_align + md_cons_align (1); +#endif if (flag_mri) stop = mri_comment_field (&stopc); @@ -2961,11 +3546,11 @@ s_float_space (int float_type) } else { - char *err; + const char *err; err = md_atof (float_type, temp, &flen); know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); - know (flen > 0); + know (err != NULL || flen > 0); if (err) { as_bad (_("bad floating literal: %s"), err); @@ -2996,11 +3581,17 @@ void s_struct (int ignore ATTRIBUTE_UNUSED) { char *stop = NULL; - char stopc; + char stopc = 0; if (flag_mri) stop = mri_comment_field (&stopc); abs_section_offset = get_absolute_expression (); +#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) + /* The ELF backend needs to know that we are changing sections, so + that .previous works correctly. */ + if (IS_ELF) + obj_elf_section_change_hook (); +#endif subseg_set (absolute_section, 0); demand_empty_rest_of_line (); if (flag_mri) @@ -3010,63 +3601,175 @@ s_struct (int ignore ATTRIBUTE_UNUSED) void s_text (int ignore ATTRIBUTE_UNUSED) { - register int temp; + int temp; temp = get_absolute_expression (); subseg_set (text_section, (subsegT) temp); demand_empty_rest_of_line (); -#ifdef OBJ_VMS - const_flag &= ~IN_DEFAULT_SECTION; -#endif } - + +/* .weakref x, y sets x as an alias to y that, as long as y is not + referenced directly, will cause y to become a weak symbol. */ void -demand_empty_rest_of_line (void) +s_weakref (int ignore ATTRIBUTE_UNUSED) { + char *name; + symbolS *symbolP; + symbolS *symbolP2; + expressionS exp; + + if ((name = read_symbol_name ()) == NULL) + return; + + symbolP = symbol_find_or_make (name); + + if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) + { + if (!S_IS_VOLATILE (symbolP)) + { + as_bad (_("symbol `%s' is already defined"), name); + goto err_out; + } + symbolP = symbol_clone (symbolP, 1); + S_CLEAR_VOLATILE (symbolP); + } + SKIP_WHITESPACE (); - if (is_end_of_line[(unsigned char) *input_line_pointer]) - input_line_pointer++; + + if (*input_line_pointer != ',') + { + as_bad (_("expected comma after \"%s\""), name); + goto err_out; + } + + input_line_pointer++; + + SKIP_WHITESPACE (); + free (name); + + if ((name = read_symbol_name ()) == NULL) + return; + + if ((symbolP2 = symbol_find_noref (name, 1)) == NULL + && (symbolP2 = md_undefined_symbol (name)) == NULL) + { + symbolP2 = symbol_find_or_make (name); + S_SET_WEAKREFD (symbolP2); + } else - ignore_rest_of_line (); + { + symbolS *symp = symbolP2; + + while (S_IS_WEAKREFR (symp) && symp != symbolP) + { + expressionS *expP = symbol_get_value_expression (symp); + + gas_assert (expP->X_op == O_symbol + && expP->X_add_number == 0); + symp = expP->X_add_symbol; + } + if (symp == symbolP) + { + char *loop; + + loop = concat (S_GET_NAME (symbolP), + " => ", S_GET_NAME (symbolP2), (const char *) NULL); + + symp = symbolP2; + while (symp != symbolP) + { + char *old_loop = loop; - /* Return having already swallowed end-of-line. */ + symp = symbol_get_value_expression (symp)->X_add_symbol; + loop = concat (loop, " => ", S_GET_NAME (symp), + (const char *) NULL); + free (old_loop); + } + + as_bad (_("%s: would close weakref loop: %s"), + S_GET_NAME (symbolP), loop); + + free (loop); + free (name); + ignore_rest_of_line (); + return; + } + + /* Short-circuiting instead of just checking here might speed + things up a tiny little bit, but loop error messages would + miss intermediate links. */ + /* symbolP2 = symp; */ + } + + memset (&exp, 0, sizeof (exp)); + exp.X_op = O_symbol; + exp.X_add_symbol = symbolP2; + + S_SET_SEGMENT (symbolP, undefined_section); + symbol_set_value_expression (symbolP, &exp); + symbol_set_frag (symbolP, &zero_address_frag); + S_SET_WEAKREFR (symbolP); + + demand_empty_rest_of_line (); + free (name); + return; + + err_out: + ignore_rest_of_line (); + free (name); + return; } + + +/* Verify that we are at the end of a line. If not, issue an error and + skip to EOL. */ void -ignore_rest_of_line (void) +demand_empty_rest_of_line (void) { - /* For suspect lines: gives warning. */ - if (!is_end_of_line[(unsigned char) *input_line_pointer]) + SKIP_WHITESPACE (); + if (is_end_of_line[(unsigned char) *input_line_pointer]) + input_line_pointer++; + else { if (ISPRINT (*input_line_pointer)) - as_warn (_("rest of line ignored; first ignored character is `%c'"), + as_bad (_("junk at end of line, first unrecognized character is `%c'"), *input_line_pointer); else - as_warn (_("rest of line ignored; first ignored character valued 0x%x"), + as_bad (_("junk at end of line, first unrecognized character valued 0x%x"), *input_line_pointer); - - while (input_line_pointer < buffer_limit - && !is_end_of_line[(unsigned char) *input_line_pointer]) - input_line_pointer++; + ignore_rest_of_line (); } - input_line_pointer++; - /* Return pointing just after end-of-line. */ know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); } +/* Silently advance to the end of line. Use this after already having + issued an error about something bad. */ + void -discard_rest_of_line (void) +ignore_rest_of_line (void) { while (input_line_pointer < buffer_limit && !is_end_of_line[(unsigned char) *input_line_pointer]) input_line_pointer++; - input_line_pointer++; + input_line_pointer++; + + /* Return pointing just after end-of-line. */ + if (input_line_pointer <= buffer_limit) + know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); +} + +/* Sets frag for given symbol to zero_address_frag, except when the + symbol frag is already set to a dummy listing frag. */ - /* Return pointing just after end-of-line. */ - know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); +static void +set_zero_frag (symbolS *symbolP) +{ + if (symbol_get_frag (symbolP)->fr_type != rs_dummy) + symbol_set_frag (symbolP, &zero_address_frag); } /* In: Pointer to a symbol. @@ -3080,16 +3783,14 @@ void pseudo_set (symbolS *symbolP) { expressionS exp; -#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) - int ext; -#endif /* OBJ_AOUT or OBJ_BOUT */ + segT seg; know (symbolP); /* NULL pointer is logic error. */ -#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) - ext = S_IS_EXTERNAL (symbolP); -#endif /* OBJ_AOUT or OBJ_BOUT */ - (void) expression (&exp); + if (!S_IS_FORWARD_REF (symbolP)) + (void) expression (&exp); + else + (void) deferred_expression (&exp); if (exp.X_op == O_illegal) as_bad (_("illegal expression")); @@ -3103,6 +3804,7 @@ pseudo_set (symbolS *symbolP) as_bad (_("floating point number invalid")); } else if (exp.X_op == O_subtract + && !S_IS_FORWARD_REF (symbolP) && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol)) && (symbol_get_frag (exp.X_add_symbol) == symbol_get_frag (exp.X_op_symbol))) @@ -3112,6 +3814,12 @@ pseudo_set (symbolS *symbolP) - S_GET_VALUE (exp.X_op_symbol)); } + if (symbol_section_p (symbolP)) + { + as_bad ("attempt to set value of section symbol"); + return; + } + switch (exp.X_op) { case O_illegal: @@ -3121,51 +3829,62 @@ pseudo_set (symbolS *symbolP) /* Fall through. */ case O_constant: S_SET_SEGMENT (symbolP, absolute_section); -#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) - if (ext) - S_SET_EXTERNAL (symbolP); - else - S_CLEAR_EXTERNAL (symbolP); -#endif /* OBJ_AOUT or OBJ_BOUT */ S_SET_VALUE (symbolP, (valueT) exp.X_add_number); - if (exp.X_op != O_constant) - symbol_set_frag (symbolP, &zero_address_frag); + set_zero_frag (symbolP); break; case O_register: +#ifndef TC_GLOBAL_REGISTER_SYMBOL_OK + if (S_IS_EXTERNAL (symbolP)) + { + as_bad ("can't equate global symbol `%s' with register name", + S_GET_NAME (symbolP)); + return; + } +#endif S_SET_SEGMENT (symbolP, reg_section); S_SET_VALUE (symbolP, (valueT) exp.X_add_number); - symbol_set_frag (symbolP, &zero_address_frag); + set_zero_frag (symbolP); + symbol_get_value_expression (symbolP)->X_op = O_register; break; case O_symbol: - if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section - || exp.X_add_number != 0) - symbol_set_value_expression (symbolP, &exp); - else if (symbol_section_p (symbolP)) - as_bad ("attempt to set value of section symbol"); - else + seg = S_GET_SEGMENT (exp.X_add_symbol); + /* For x=undef+const, create an expression symbol. + For x=x+const, just update x except when x is an undefined symbol + For x=defined+const, evaluate x. */ + if (symbolP == exp.X_add_symbol + && (seg != undefined_section + || !symbol_constant_p (symbolP))) + { + *symbol_X_add_number (symbolP) += exp.X_add_number; + break; + } + else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section) { symbolS *s = exp.X_add_symbol; - S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s)); -#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) - if (ext) - S_SET_EXTERNAL (symbolP); - else - S_CLEAR_EXTERNAL (symbolP); -#endif /* OBJ_AOUT or OBJ_BOUT */ - S_SET_VALUE (symbolP, - exp.X_add_number + S_GET_VALUE (s)); + if (S_IS_COMMON (s)) + as_bad (_("`%s' can't be equated to common symbol `%s'"), + S_GET_NAME (symbolP), S_GET_NAME (s)); + + S_SET_SEGMENT (symbolP, seg); + S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s)); symbol_set_frag (symbolP, symbol_get_frag (s)); copy_symbol_attributes (symbolP, s); + break; } + S_SET_SEGMENT (symbolP, undefined_section); + symbol_set_value_expression (symbolP, &exp); + copy_symbol_attributes (symbolP, exp.X_add_symbol); + set_zero_frag (symbolP); break; default: - /* The value is some complex expression. - FIXME: Should we set the segment to anything? */ + /* The value is some complex expression. */ + S_SET_SEGMENT (symbolP, expr_section); symbol_set_value_expression (symbolP, &exp); + set_zero_frag (symbolP); break; } } @@ -3188,7 +3907,6 @@ pseudo_set (symbolS *symbolP) /* Some targets need to parse the expression in various fancy ways. You can define TC_PARSE_CONS_EXPRESSION to do whatever you like (for example, the HPPA does this). Otherwise, you can define - BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these are defined, which is the normal case, then only simple expressions are permitted. */ @@ -3199,20 +3917,17 @@ parse_mri_cons (expressionS *exp, unsigned int nbytes); #endif #ifndef TC_PARSE_CONS_EXPRESSION -#ifdef BITFIELD_CONS_EXPRESSIONS -#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES) -static void -parse_bitfield_cons (expressionS *exp, unsigned int nbytes); -#endif #ifdef REPEAT_CONS_EXPRESSIONS -#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES) +#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \ + (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE) static void parse_repeat_cons (expressionS *exp, unsigned int nbytes); #endif /* If we haven't gotten one yet, just call expression. */ #ifndef TC_PARSE_CONS_EXPRESSION -#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP) +#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \ + (expression (EXP), TC_PARSE_CONS_RETURN_NONE) #endif #endif @@ -3220,7 +3935,7 @@ void do_parse_cons_expression (expressionS *exp, int nbytes ATTRIBUTE_UNUSED) { - TC_PARSE_CONS_EXPRESSION (exp, nbytes); + (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes); } @@ -3228,13 +3943,13 @@ do_parse_cons_expression (expressionS *exp, Clobbers input_line_pointer and checks end-of-line. */ static void -cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */ +cons_worker (int nbytes, /* 1=.byte, 2=.word, 4=.long. */ int rva) { int c; expressionS exp; char *stop = NULL; - char stopc; + char stopc = 0; #ifdef md_flush_pending_output md_flush_pending_output (); @@ -3251,6 +3966,11 @@ cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */ return; } +#ifdef TC_ADDRESS_BYTES + if (nbytes == 0) + nbytes = TC_ADDRESS_BYTES (); +#endif + #ifdef md_cons_align md_cons_align (nbytes); #endif @@ -3258,12 +3978,30 @@ cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */ c = 0; do { + TC_PARSE_CONS_RETURN_TYPE ret = TC_PARSE_CONS_RETURN_NONE; +#ifdef TC_CONS_FIX_CHECK + fixS **cur_fix = &frchain_now->fix_tail; + + if (*cur_fix != NULL) + cur_fix = &(*cur_fix)->fx_next; +#endif + #ifdef TC_M68K if (flag_m68k_mri) parse_mri_cons (&exp, (unsigned int) nbytes); else #endif - TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes); + { +#if 0 + if (*input_line_pointer == '"') + { + as_bad (_("unexpected `\"' in expression")); + ignore_rest_of_line (); + return; + } +#endif + ret = TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes); + } if (rva) { @@ -3272,7 +4010,10 @@ cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */ else as_fatal (_("rva without symbol")); } - emit_expr (&exp, (unsigned int) nbytes); + emit_expr_with_reloc (&exp, (unsigned int) nbytes, ret); +#ifdef TC_CONS_FIX_CHECK + TC_CONS_FIX_CHECK (&exp, nbytes, *cur_fix); +#endif ++c; } while (*input_line_pointer++ == ','); @@ -3303,21 +4044,159 @@ s_rva (int size) cons_worker (size, 1); } +/* .reloc offset, reloc_name, symbol+addend. */ + +static void +s_reloc (int ignore ATTRIBUTE_UNUSED) +{ + char *stop = NULL; + char stopc = 0; + expressionS exp; + char *r_name; + int c; + struct reloc_list *reloc; + struct _bfd_rel { const char * name; bfd_reloc_code_real_type code; }; + static struct _bfd_rel bfd_relocs[] = + { + { "NONE", BFD_RELOC_NONE }, + { "8", BFD_RELOC_8 }, + { "16", BFD_RELOC_16 }, + { "32", BFD_RELOC_32 }, + { "64", BFD_RELOC_64 } + }; + + reloc = XNEW (struct reloc_list); + + if (flag_mri) + stop = mri_comment_field (&stopc); + + expression (&exp); + switch (exp.X_op) + { + case O_illegal: + case O_absent: + case O_big: + case O_register: + as_bad (_("missing or bad offset expression")); + goto err_out; + case O_constant: + exp.X_add_symbol = section_symbol (now_seg); + exp.X_op = O_symbol; + /* Fallthru */ + case O_symbol: + if (exp.X_add_number == 0) + { + reloc->u.a.offset_sym = exp.X_add_symbol; + break; + } + /* Fallthru */ + default: + reloc->u.a.offset_sym = make_expr_symbol (&exp); + break; + } + + SKIP_WHITESPACE (); + if (*input_line_pointer != ',') + { + as_bad (_("missing reloc type")); + goto err_out; + } + + ++input_line_pointer; + SKIP_WHITESPACE (); + c = get_symbol_name (& r_name); + if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0) + { + unsigned int i; + + for (reloc->u.a.howto = NULL, i = 0; i < ARRAY_SIZE (bfd_relocs); i++) + if (strcasecmp (r_name + 10, bfd_relocs[i].name) == 0) + { + reloc->u.a.howto = bfd_reloc_type_lookup (stdoutput, + bfd_relocs[i].code); + break; + } + } + else + reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name); + *input_line_pointer = c; + if (reloc->u.a.howto == NULL) + { + as_bad (_("unrecognized reloc type")); + goto err_out; + } + + exp.X_op = O_absent; + SKIP_WHITESPACE_AFTER_NAME (); + if (*input_line_pointer == ',') + { + ++input_line_pointer; + expression (&exp); + } + switch (exp.X_op) + { + case O_illegal: + case O_big: + case O_register: + as_bad (_("bad reloc expression")); + err_out: + ignore_rest_of_line (); + free (reloc); + if (flag_mri) + mri_comment_end (stop, stopc); + return; + case O_absent: + reloc->u.a.sym = NULL; + reloc->u.a.addend = 0; + break; + case O_constant: + reloc->u.a.sym = NULL; + reloc->u.a.addend = exp.X_add_number; + break; + case O_symbol: + reloc->u.a.sym = exp.X_add_symbol; + reloc->u.a.addend = exp.X_add_number; + break; + default: + reloc->u.a.sym = make_expr_symbol (&exp); + reloc->u.a.addend = 0; + break; + } + + reloc->file = as_where (&reloc->line); + reloc->next = reloc_list; + reloc_list = reloc; + + demand_empty_rest_of_line (); + if (flag_mri) + mri_comment_end (stop, stopc); +} + /* Put the contents of expression EXP into the object file using NBYTES bytes. If need_pass_2 is 1, this does nothing. */ void emit_expr (expressionS *exp, unsigned int nbytes) +{ + emit_expr_with_reloc (exp, nbytes, TC_PARSE_CONS_RETURN_NONE); +} + +void +emit_expr_with_reloc (expressionS *exp, + unsigned int nbytes, + TC_PARSE_CONS_RETURN_TYPE reloc) { operatorT op; - register char *p; + char *p; valueT extra_digit = 0; /* Don't do anything if we are going to make another pass. */ if (need_pass_2) return; + frag_grow (nbytes); dot_value = frag_now_fix (); + dot_frag = frag_now; #ifndef NO_LISTING #ifdef OBJ_ELF @@ -3388,15 +4267,6 @@ emit_expr (expressionS *exp, unsigned int nbytes) op = exp->X_op; - /* Allow `.word 0' in the absolute section. */ - if (now_seg == absolute_section) - { - if (op != O_constant || exp->X_add_number != 0) - as_bad (_("attempt to store value in absolute section")); - abs_section_offset += nbytes; - return; - } - /* Handle a negative bignum. */ if (op == O_uminus && exp->X_add_number == 0 @@ -3446,8 +4316,28 @@ emit_expr (expressionS *exp, unsigned int nbytes) op = O_constant; } + /* Allow `.word 0' in the absolute section. */ + if (now_seg == absolute_section) + { + if (op != O_constant || exp->X_add_number != 0) + as_bad (_("attempt to store value in absolute section")); + abs_section_offset += nbytes; + return; + } + + /* Allow `.word 0' in BSS style sections. */ + if ((op != O_constant || exp->X_add_number != 0) && in_bss ()) + as_bad (_("attempt to store non-zero value in section `%s'"), + segment_name (now_seg)); + p = frag_more ((int) nbytes); + if (reloc != TC_PARSE_CONS_RETURN_NONE) + { + emit_expr_fix (exp, nbytes, frag_now, p, reloc); + return; + } + #ifndef WORKING_DOT_WORD /* If we have the difference of two symbols in a word, save it on the broken_words list. See the code in write.c. */ @@ -3455,7 +4345,7 @@ emit_expr (expressionS *exp, unsigned int nbytes) { struct broken_word *x; - x = (struct broken_word *) xmalloc (sizeof (struct broken_word)); + x = XNEW (struct broken_word); x->next_broken_word = broken_words; broken_words = x; x->seg = now_seg; @@ -3477,31 +4367,18 @@ emit_expr (expressionS *exp, unsigned int nbytes) pass to md_number_to_chars, handle it as a bignum. */ if (op == O_constant && nbytes > sizeof (valueT)) { - valueT val; - int gencnt; - - if (!exp->X_unsigned && exp->X_add_number < 0) - extra_digit = (valueT) -1; - val = (valueT) exp->X_add_number; - gencnt = 0; - do - { - generic_bignum[gencnt] = val & LITTLENUM_MASK; - val >>= LITTLENUM_NUMBER_OF_BITS; - ++gencnt; - } - while (val != 0); - op = exp->X_op = O_big; - exp->X_add_number = gencnt; + extra_digit = exp->X_unsigned ? 0 : -1; + convert_to_bignum (exp, !exp->X_unsigned); + op = O_big; } if (op == O_constant) { - register valueT get; - register valueT use; - register valueT mask; + valueT get; + valueT use; + valueT mask; valueT hibit; - register valueT unmask; + valueT unmask; /* JF << of >= number of bits in the object is undefined. In particular SPARC (Sun 4) has problems. */ @@ -3532,9 +4409,20 @@ emit_expr (expressionS *exp, unsigned int nbytes) if ((get & mask) != 0 && ((get & mask) != mask || (get & hibit) == 0)) - { /* Leading bits contain both 0s & 1s. */ + { + /* Leading bits contain both 0s & 1s. */ +#if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG +#ifndef __MSVCRT__ + as_warn (_("value 0x%llx truncated to 0x%llx"), + (unsigned long long) get, (unsigned long long) use); +#else + as_warn (_("value 0x%I64x truncated to 0x%I64x"), + (unsigned long long) get, (unsigned long long) use); +#endif +#else as_warn (_("value 0x%lx truncated to 0x%lx"), (unsigned long) get, (unsigned long) use); +#endif } /* Put bytes in right order. */ md_number_to_chars (p, use, (int) nbytes); @@ -3544,15 +4432,53 @@ emit_expr (expressionS *exp, unsigned int nbytes) unsigned int size; LITTLENUM_TYPE *nums; - know (nbytes % CHARS_PER_LITTLENUM == 0); - size = exp->X_add_number * CHARS_PER_LITTLENUM; if (nbytes < size) { - as_warn (_("bignum truncated to %d bytes"), nbytes); + int i = nbytes / CHARS_PER_LITTLENUM; + + if (i != 0) + { + LITTLENUM_TYPE sign = 0; + if ((generic_bignum[--i] + & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0) + sign = ~(LITTLENUM_TYPE) 0; + + while (++i < exp->X_add_number) + if (generic_bignum[i] != sign) + break; + } + else if (nbytes == 1) + { + /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably). + Check that bits 8.. of generic_bignum[0] match bit 7 + and that they match all of generic_bignum[1..exp->X_add_number]. */ + LITTLENUM_TYPE sign = (generic_bignum[0] & (1 << 7)) ? -1 : 0; + LITTLENUM_TYPE himask = LITTLENUM_MASK & ~ 0xFF; + + if ((generic_bignum[0] & himask) == (sign & himask)) + { + while (++i < exp->X_add_number) + if (generic_bignum[i] != sign) + break; + } + } + + if (i < exp->X_add_number) + as_warn (ngettext ("bignum truncated to %d byte", + "bignum truncated to %d bytes", + nbytes), + nbytes); size = nbytes; } + if (nbytes == 1) + { + md_number_to_chars (p, (valueT) generic_bignum[0], 1); + return; + } + know (nbytes % CHARS_PER_LITTLENUM == 0); + if (target_big_endian) { while (nbytes > size) @@ -3592,209 +4518,79 @@ emit_expr (expressionS *exp, unsigned int nbytes) } } else - { - memset (p, 0, nbytes); - - /* Now we need to generate a fixS to record the symbol value. - This is easy for BFD. For other targets it can be more - complex. For very complex cases (currently, the HPPA and - NS32K), you can define TC_CONS_FIX_NEW to do whatever you - want. For simpler cases, you can define TC_CONS_RELOC to be - the name of the reloc code that should be stored in the fixS. - If neither is defined, the code uses NO_RELOC if it is - defined, and otherwise uses 0. */ - -#ifdef BFD_ASSEMBLER -#ifdef TC_CONS_FIX_NEW - TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); -#else - { - bfd_reloc_code_real_type r; - - switch (nbytes) - { - case 1: - r = BFD_RELOC_8; - break; - case 2: - r = BFD_RELOC_16; - break; - case 4: - r = BFD_RELOC_32; - break; - case 8: - r = BFD_RELOC_64; - break; - default: - as_bad (_("unsupported BFD relocation size %u"), nbytes); - r = BFD_RELOC_32; - break; - } - fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, - 0, r); - } -#endif -#else -#ifdef TC_CONS_FIX_NEW - TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); -#else - /* Figure out which reloc number to use. Use TC_CONS_RELOC if - it is defined, otherwise use NO_RELOC if it is defined, - otherwise use 0. */ -#ifndef TC_CONS_RELOC -#ifdef NO_RELOC -#define TC_CONS_RELOC NO_RELOC -#else -#define TC_CONS_RELOC 0 -#endif -#endif - fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0, - TC_CONS_RELOC); -#endif /* TC_CONS_FIX_NEW */ -#endif /* BFD_ASSEMBLER */ - } + emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE); } - -#ifdef BITFIELD_CONS_EXPRESSIONS - -/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as - w:x,y:z, where w and y are bitwidths and x and y are values. They - then pack them all together. We do a little better in that we allow - them in words, longs, etc. and we'll pack them in target byte order - for you. - - The rules are: pack least significant bit first, if a field doesn't - entirely fit, put it in the next unit. Overflowing the bitfield is - explicitly *not* even a warning. The bitwidth should be considered - a "mask". - To use this function the tc-XXX.h file should define - BITFIELD_CONS_EXPRESSIONS. */ - -static void -parse_bitfield_cons (exp, nbytes) - expressionS *exp; - unsigned int nbytes; +void +emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p, + TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED) { - unsigned int bits_available = BITS_PER_CHAR * nbytes; - char *hold = input_line_pointer; - - (void) expression (exp); - - if (*input_line_pointer == ':') - { - /* Bitfields. */ - long value = 0; - - for (;;) - { - unsigned long width; + int offset = 0; + unsigned int size = nbytes; - if (*input_line_pointer != ':') - { - input_line_pointer = hold; - break; - } /* Next piece is not a bitfield. */ - - /* In the general case, we can't allow - full expressions with symbol - differences and such. The relocation - entries for symbols not defined in this - assembly would require arbitrary field - widths, positions, and masks which most - of our current object formats don't - support. - - In the specific case where a symbol - *is* defined in this assembly, we - *could* build fixups and track it, but - this could lead to confusion for the - backends. I'm lazy. I'll take any - SEG_ABSOLUTE. I think that means that - you can use a previous .set or - .equ type symbol. xoxorich. */ - - if (exp->X_op == O_absent) - { - as_warn (_("using a bit field width of zero")); - exp->X_add_number = 0; - exp->X_op = O_constant; - } /* Implied zero width bitfield. */ - - if (exp->X_op != O_constant) - { - *input_line_pointer = '\0'; - as_bad (_("field width \"%s\" too complex for a bitfield"), hold); - *input_line_pointer = ':'; - demand_empty_rest_of_line (); - return; - } /* Too complex. */ - - if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) - { - as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"), - width, nbytes, (BITS_PER_CHAR * nbytes)); - width = BITS_PER_CHAR * nbytes; - } /* Too big. */ + memset (p, 0, size); - if (width > bits_available) - { - /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */ - input_line_pointer = hold; - exp->X_add_number = value; - break; - } /* Won't fit. */ - - /* Skip ':'. */ - hold = ++input_line_pointer; - - (void) expression (exp); - if (exp->X_op != O_constant) - { - char cache = *input_line_pointer; - - *input_line_pointer = '\0'; - as_bad (_("field value \"%s\" too complex for a bitfield"), hold); - *input_line_pointer = cache; - demand_empty_rest_of_line (); - return; - } /* Too complex. */ + /* Generate a fixS to record the symbol value. */ - value |= ((~(-1 << width) & exp->X_add_number) - << ((BITS_PER_CHAR * nbytes) - bits_available)); +#ifdef TC_CONS_FIX_NEW + TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r); +#else + if (r != TC_PARSE_CONS_RETURN_NONE) + { + reloc_howto_type *reloc_howto; - if ((bits_available -= width) == 0 - || is_it_end_of_statement () - || *input_line_pointer != ',') - { - break; - } /* All the bitfields we're gonna get. */ + reloc_howto = bfd_reloc_type_lookup (stdoutput, r); + size = bfd_get_reloc_size (reloc_howto); - hold = ++input_line_pointer; - (void) expression (exp); + if (size > nbytes) + { + as_bad (ngettext ("%s relocations do not fit in %u byte", + "%s relocations do not fit in %u bytes", + nbytes), + reloc_howto->name, nbytes); + return; } - - exp->X_add_number = value; - exp->X_op = O_constant; - exp->X_unsigned = 1; + else if (target_big_endian) + offset = nbytes - size; } + else + switch (size) + { + case 1: + r = BFD_RELOC_8; + break; + case 2: + r = BFD_RELOC_16; + break; + case 3: + r = BFD_RELOC_24; + break; + case 4: + r = BFD_RELOC_32; + break; + case 8: + r = BFD_RELOC_64; + break; + default: + as_bad (_("unsupported BFD relocation size %u"), size); + return; + } + fix_new_exp (frag, p - frag->fr_literal + offset, size, + exp, 0, r); +#endif } - -#endif /* BITFIELD_CONS_EXPRESSIONS */ /* Handle an MRI style string expression. */ #ifdef TC_M68K static void -parse_mri_cons (exp, nbytes) - expressionS *exp; - unsigned int nbytes; +parse_mri_cons (expressionS *exp, unsigned int nbytes) { if (*input_line_pointer != '\'' && (input_line_pointer[1] != '\'' || (*input_line_pointer != 'A' && *input_line_pointer != 'E'))) - TC_PARSE_CONS_EXPRESSION (exp, nbytes); + (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes); else { unsigned int scan; @@ -3860,12 +4656,10 @@ parse_mri_cons (exp, nbytes) To use this for a target, define REPEAT_CONS_EXPRESSIONS. */ static void -parse_repeat_cons (exp, nbytes) - expressionS *exp; - unsigned int nbytes; +parse_repeat_cons (expressionS *exp, unsigned int nbytes) { expressionS count; - register int i; + int i; expression (exp); @@ -4000,16 +4794,31 @@ hex_float (int float_type, char *bytes) void float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ - register int float_type /* 'f':.ffloat ... 'F':.float ... */) + int float_type /* 'f':.ffloat ... 'F':.float ... */) { - register char *p; + char *p; int length; /* Number of chars in an object. */ - register char *err; /* Error from scanning floating literal. */ + const char *err; /* Error from scanning floating literal. */ char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; - if (is_it_end_of_statement ()) + if (is_it_end_of_statement ()) + { + demand_empty_rest_of_line (); + return; + } + + if (now_seg == absolute_section) + { + as_bad (_("attempt to store float in absolute section")); + ignore_rest_of_line (); + return; + } + + if (in_bss ()) { - demand_empty_rest_of_line (); + as_bad (_("attempt to store float in section `%s'"), + segment_name (now_seg)); + ignore_rest_of_line (); return; } @@ -4017,6 +4826,10 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ md_flush_pending_output (); #endif +#ifdef md_cons_align + md_cons_align (1); +#endif + do { /* input_line_pointer->1st char of a flonum (we hope!). */ @@ -4046,7 +4859,7 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ { err = md_atof (float_type, temp, &length); know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); - know (length > 0); + know (err != NULL || length > 0); if (err) { as_bad (_("bad floating literal: %s"), err); @@ -4092,13 +4905,29 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ demand_empty_rest_of_line (); } -/* Return the size of a LEB128 value. */ +/* LEB128 Encoding. -static inline int + Note - we are using the DWARF standard's definition of LEB128 encoding + where each 7-bit value is a stored in a byte, *not* an octet. This + means that on targets where a byte contains multiple octets there is + a *huge waste of space*. (This also means that we do not have to + have special versions of these functions for when OCTETS_PER_BYTE_POWER + is non-zero). + + If the 7-bit values were to be packed into N-bit bytes (where N > 8) + we would then have to consider whether multiple, successive LEB128 + values should be packed into the bytes without padding (bad idea) or + whether each LEB128 number is padded out to a whole number of bytes. + Plus you have to decide on the endianness of packing octets into a + byte. */ + +/* Return the size of a LEB128 value in bytes. */ + +static inline unsigned int sizeof_sleb128 (offsetT value) { - register int size = 0; - register unsigned byte; + int size = 0; + unsigned byte; do { @@ -4115,15 +4944,13 @@ sizeof_sleb128 (offsetT value) return size; } -static inline int +static inline unsigned int sizeof_uleb128 (valueT value) { - register int size = 0; - register unsigned byte; + int size = 0; do { - byte = (value & 0x7f); value >>= 7; size += 1; } @@ -4132,7 +4959,7 @@ sizeof_uleb128 (valueT value) return size; } -int +unsigned int sizeof_leb128 (valueT value, int sign) { if (sign) @@ -4141,13 +4968,13 @@ sizeof_leb128 (valueT value, int sign) return sizeof_uleb128 (value); } -/* Output a LEB128 value. */ +/* Output a LEB128 value. Returns the number of bytes used. */ -static inline int +static inline unsigned int output_sleb128 (char *p, offsetT value) { - register char *orig = p; - register int more; + char *orig = p; + int more; do { @@ -4170,7 +4997,7 @@ output_sleb128 (char *p, offsetT value) return p - orig; } -static inline int +static inline unsigned int output_uleb128 (char *p, valueT value) { char *orig = p; @@ -4178,6 +5005,7 @@ output_uleb128 (char *p, valueT value) do { unsigned byte = (value & 0x7f); + value >>= 7; if (value != 0) /* More bytes to follow. */ @@ -4190,7 +5018,7 @@ output_uleb128 (char *p, valueT value) return p - orig; } -int +unsigned int output_leb128 (char *p, valueT value, int sign) { if (sign) @@ -4201,10 +5029,11 @@ output_leb128 (char *p, valueT value, int sign) /* Do the same for bignums. We combine sizeof with output here in that we don't output for NULL values of P. It isn't really as critical as - for "normal" values that this be streamlined. */ + for "normal" values that this be streamlined. Returns the number of + bytes used. */ -static inline int -output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size) +static inline unsigned int +output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size) { char *orig = p; valueT val = 0; @@ -4212,42 +5041,54 @@ output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size) unsigned byte; /* Strip leading sign extensions off the bignum. */ - while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1) + while (size > 1 + && bignum[size - 1] == LITTLENUM_MASK + && bignum[size - 2] > LITTLENUM_MASK / 2) size--; do { - if (loaded < 7 && size > 0) - { - val |= (*bignum << loaded); - loaded += 8 * CHARS_PER_LITTLENUM; - size--; - bignum++; - } - - byte = val & 0x7f; - loaded -= 7; - val >>= 7; + /* OR in the next part of the littlenum. */ + val |= (*bignum << loaded); + loaded += LITTLENUM_NUMBER_OF_BITS; + size--; + bignum++; - if (size == 0) + /* Add bytes until there are less than 7 bits left in VAL + or until every non-sign bit has been written. */ + do { - if ((val == 0 && (byte & 0x40) == 0) - || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0 - && (byte & 0x40) != 0)) + byte = val & 0x7f; + loaded -= 7; + val >>= 7; + if (size > 0 + || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1)) byte |= 0x80; + + if (orig) + *p = byte; + p++; } + while ((byte & 0x80) != 0 && loaded >= 7); + } + while (size > 0); + /* Mop up any left-over bits (of which there will be less than 7). */ + if ((byte & 0x80) != 0) + { + /* Sign-extend VAL. */ + if (val & (1 << (loaded - 1))) + val |= ~0U << loaded; if (orig) - *p = byte; + *p = val & 0x7f; p++; } - while (byte & 0x80); return p - orig; } -static inline int -output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size) +static inline unsigned int +output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size) { char *orig = p; valueT val = 0; @@ -4285,8 +5126,8 @@ output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size) return p - orig; } -static int -output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign) +static unsigned int +output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size, int sign) { if (sign) return output_big_sleb128 (p, bignum, size); @@ -4295,13 +5136,13 @@ output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign) } /* Generate the appropriate fragments for a given expression to emit a - leb128 value. */ + leb128 value. SIGN is 1 for sleb, 0 for uleb. */ -void +static void emit_leb128_expr (expressionS *exp, int sign) { operatorT op = exp->X_op; - int nbytes; + unsigned int nbytes; if (op == O_absent || op == O_illegal) { @@ -4320,10 +5161,32 @@ emit_leb128_expr (expressionS *exp, int sign) as_warn (_("register value used as expression")); op = O_constant; } + else if (op == O_constant + && sign + && (exp->X_add_number < 0) == !exp->X_extrabit) + { + /* We're outputting a signed leb128 and the sign of X_add_number + doesn't reflect the sign of the original value. Convert EXP + to a correctly-extended bignum instead. */ + convert_to_bignum (exp, exp->X_extrabit); + op = O_big; + } + + if (now_seg == absolute_section) + { + if (op != O_constant || exp->X_add_number != 0) + as_bad (_("attempt to store value in absolute section")); + abs_section_offset++; + return; + } + + if ((op != O_constant || exp->X_add_number != 0) && in_bss ()) + as_bad (_("attempt to store non-zero value in section `%s'"), + segment_name (now_seg)); /* Let check_eh_frame know that data is being emitted. nbytes == -1 is a signal that this is leb128 data. It shouldn't optimize this away. */ - nbytes = -1; + nbytes = (unsigned int) -1; if (check_eh_frame (exp, &nbytes)) abort (); @@ -4337,23 +5200,33 @@ emit_leb128_expr (expressionS *exp, int sign) /* If we've got a constant, emit the thing directly right now. */ valueT value = exp->X_add_number; - int size; + unsigned int size; char *p; size = sizeof_leb128 (value, sign); p = frag_more (size); - output_leb128 (p, value, sign); + if (output_leb128 (p, value, sign) > size) + abort (); } else if (op == O_big) { /* O_big is a different sort of constant. */ - - int size; + int nbr_digits = exp->X_add_number; + unsigned int size; char *p; - size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); + /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with + a signed number. Unary operators like - or ~ always extend the + bignum to its largest size. */ + if (exp->X_unsigned + && nbr_digits < SIZE_OF_LARGE_NUMBER + && generic_bignum[nbr_digits - 1] == LITTLENUM_MASK) + generic_bignum[nbr_digits++] = 0; + + size = output_big_leb128 (NULL, generic_bignum, nbr_digits, sign); p = frag_more (size); - output_big_leb128 (p, generic_bignum, exp->X_add_number, sign); + if (output_big_leb128 (p, generic_bignum, nbr_digits, sign) > size) + abort (); } else { @@ -4372,6 +5245,10 @@ s_leb128 (int sign) { expressionS exp; +#ifdef md_flush_pending_output + md_flush_pending_output (); +#endif + do { expression (&exp); @@ -4383,22 +5260,77 @@ s_leb128 (int sign) demand_empty_rest_of_line (); } -/* We read 0 or more ',' separated, double-quoted strings. +static void +stringer_append_char (int c, int bitsize) +{ + if (c && in_bss ()) + as_bad (_("attempt to store non-empty string in section `%s'"), + segment_name (now_seg)); + + if (!target_big_endian) + FRAG_APPEND_1_CHAR (c); + + switch (bitsize) + { + case 64: + FRAG_APPEND_1_CHAR (0); + FRAG_APPEND_1_CHAR (0); + FRAG_APPEND_1_CHAR (0); + FRAG_APPEND_1_CHAR (0); + /* Fall through. */ + case 32: + FRAG_APPEND_1_CHAR (0); + FRAG_APPEND_1_CHAR (0); + /* Fall through. */ + case 16: + FRAG_APPEND_1_CHAR (0); + /* Fall through. */ + case 8: + break; + default: + /* Called with invalid bitsize argument. */ + abort (); + break; + } + if (target_big_endian) + FRAG_APPEND_1_CHAR (c); +} + +/* Worker to do .ascii etc statements. + Reads 0 or more ',' separated, double-quoted strings. Caller should have checked need_pass_2 is FALSE because we don't - check it. */ + check it. + Checks for end-of-line. + BITS_APPENDZERO says how many bits are in a target char. + The bottom bit is set if a NUL char should be appended to the strings. */ void -stringer (/* Worker to do .ascii etc statements. */ - /* Checks end-of-line. */ - register int append_zero /* 0: don't append '\0', else 1. */) +stringer (int bits_appendzero) { - register unsigned int c; + const int bitsize = bits_appendzero & ~7; + const int append_zero = bits_appendzero & 1; + unsigned int c; +#if !defined(NO_LISTING) && defined (OBJ_ELF) char *start; +#endif #ifdef md_flush_pending_output md_flush_pending_output (); #endif +#ifdef md_cons_align + md_cons_align (1); +#endif + + /* If we have been switched into the abs_section then we + will not have an obstack onto which we can hang strings. */ + if (now_seg == absolute_section) + { + as_bad (_("strings must be placed into a section")); + ignore_rest_of_line (); + return; + } + /* The following awkward logic is to parse ZERO or more strings, comma separated. Recall a string expression includes spaces before the opening '\"' and spaces after the closing '\"'. @@ -4413,14 +5345,6 @@ stringer (/* Worker to do .ascii etc statements. */ { c = ','; /* Do loop. */ } - /* If we have been switched into the abs_section then we - will not have an obstack onto which we can hang strings. */ - if (now_seg == absolute_section) - { - as_bad (_("strings must be placed into a section")); - c = 0; - ignore_rest_of_line (); - } while (c == ',' || c == '<' || c == '"') { @@ -4429,19 +5353,17 @@ stringer (/* Worker to do .ascii etc statements. */ { case '\"': ++input_line_pointer; /*->1st char of string. */ +#if !defined(NO_LISTING) && defined (OBJ_ELF) start = input_line_pointer; +#endif + while (is_a_char (c = next_char_of_string ())) - { - FRAG_APPEND_1_CHAR (c); - } + stringer_append_char (c, bitsize); + if (append_zero) - { - FRAG_APPEND_1_CHAR (0); - } - know (input_line_pointer[-1] == '\"'); + stringer_append_char (0, bitsize); -#ifndef NO_LISTING -#ifdef OBJ_ELF +#if !defined(NO_LISTING) && defined (OBJ_ELF) /* In ELF, when gcc is emitting DWARF 1 debugging output, it will emit .string with a filename in the .debug section after a sequence of constants. See the comment in @@ -4457,17 +5379,18 @@ stringer (/* Worker to do .ascii etc statements. */ listing_source_file (start); input_line_pointer[-1] = c; } -#endif #endif break; case '<': input_line_pointer++; c = get_single_number (); - FRAG_APPEND_1_CHAR (c); + stringer_append_char (c, bitsize); if (*input_line_pointer != '>') { as_bad (_("expected ")); + ignore_rest_of_line (); + return; } input_line_pointer++; break; @@ -4480,7 +5403,7 @@ stringer (/* Worker to do .ascii etc statements. */ } demand_empty_rest_of_line (); -} /* stringer() */ +} /* FIXME-SOMEDAY: I had trouble here on characters with the high bits set. We'll probably also have trouble with @@ -4490,11 +5413,17 @@ stringer (/* Worker to do .ascii etc statements. */ unsigned int next_char_of_string (void) { - register unsigned int c; + unsigned int c; c = *input_line_pointer++ & CHAR_MASK; switch (c) { + case 0: + /* PR 20902: Do not advance past the end of the buffer. */ + -- input_line_pointer; + c = NOT_A_CHAR; + break; + case '\"': c = NOT_A_CHAR; break; @@ -4504,9 +5433,10 @@ next_char_of_string (void) bump_line_counters (); break; -#ifndef NO_STRING_ESCAPES case '\\': - switch (c = *input_line_pointer++) + if (!TC_STRING_ESCAPES) + break; + switch (c = *input_line_pointer++ & CHAR_MASK) { case 'b': c = '\b'; @@ -4557,7 +5487,7 @@ next_char_of_string (void) number = number * 8 + c - '0'; } - c = number & 0xff; + c = number & CHAR_MASK; } --input_line_pointer; break; @@ -4579,7 +5509,7 @@ next_char_of_string (void) number = number * 16 + c - 'a' + 10; c = *input_line_pointer++; } - c = number & 0xff; + c = number & CHAR_MASK; --input_line_pointer; } break; @@ -4591,6 +5521,12 @@ next_char_of_string (void) bump_line_counters (); break; + case 0: + /* Do not advance past the end of the buffer. */ + -- input_line_pointer; + c = NOT_A_CHAR; + break; + default: #ifdef ONLY_STANDARD_ESCAPES @@ -4601,7 +5537,6 @@ next_char_of_string (void) break; } break; -#endif /* ! defined (NO_STRING_ESCAPES) */ default: break; @@ -4610,9 +5545,9 @@ next_char_of_string (void) } static segT -get_segmented_expression (register expressionS *expP) +get_segmented_expression (expressionS *expP) { - register segT retval; + segT retval; retval = expression (expP); if (expP->X_op == O_illegal @@ -4628,11 +5563,11 @@ get_segmented_expression (register expressionS *expP) } static segT -get_known_segmented_expression (register expressionS *expP) +get_known_segmented_expression (expressionS *expP) { - register segT retval; + segT retval = get_segmented_expression (expP); - if ((retval = get_segmented_expression (expP)) == undefined_section) + if (retval == undefined_section) { /* There is no easy way to extract the undefined symbol from the expression. */ @@ -4646,29 +5581,7 @@ get_known_segmented_expression (register expressionS *expP) expP->X_op = O_constant; expP->X_add_number = 0; } - know (retval == absolute_section || SEG_NORMAL (retval)); - return (retval); -} - -offsetT -get_absolute_expr (expressionS *exp) -{ - expression (exp); - if (exp->X_op != O_constant) - { - if (exp->X_op != O_absent) - as_bad (_("bad or irreducible absolute expression")); - exp->X_add_number = 0; - } - return exp->X_add_number; -} - -offsetT -get_absolute_expression (void) -{ - expressionS exp; - - return get_absolute_expr (&exp); + return retval; } char /* Return terminator. */ @@ -4685,11 +5598,11 @@ get_absolute_expression_and_terminator (long *val_pointer /* Return value of exp char * demand_copy_C_string (int *len_pointer) { - register char *s; + char *s; if ((s = demand_copy_string (len_pointer)) != 0) { - register int len; + int len; for (len = *len_pointer; len > 0; len--) { @@ -4712,8 +5625,8 @@ demand_copy_C_string (int *len_pointer) char * demand_copy_string (int *lenP) { - register unsigned int c; - register int len; + unsigned int c; + int len; char *retval; len = 0; @@ -4730,11 +5643,11 @@ demand_copy_string (int *lenP) /* JF this next line is so demand_copy_C_string will return a null terminated string. */ obstack_1grow (¬es, '\0'); - retval = obstack_finish (¬es); + retval = (char *) obstack_finish (¬es); } else { - as_warn (_("missing string")); + as_bad (_("missing string")); retval = NULL; ignore_rest_of_line (); } @@ -4758,13 +5671,14 @@ is_it_end_of_statement (void) void equals (char *sym_name, int reassign) { - register symbolS *symbolP; /* Symbol we are working with. */ char *stop = NULL; - char stopc; + char stopc = 0; input_line_pointer++; if (*input_line_pointer == '=') input_line_pointer++; + if (reassign < 0 && *input_line_pointer == '=') + input_line_pointer++; while (*input_line_pointer == ' ' || *input_line_pointer == '\t') input_line_pointer++; @@ -4772,45 +5686,11 @@ equals (char *sym_name, int reassign) if (flag_mri) stop = mri_comment_field (&stopc); - if (sym_name[0] == '.' && sym_name[1] == '\0') - { - /* Turn '. = mumble' into a .org mumble. */ - register segT segment; - expressionS exp; - - segment = get_known_segmented_expression (&exp); - if (!need_pass_2) - do_org (segment, &exp, 0); - } - else - { -#ifdef OBJ_COFF - int local; - - symbolP = symbol_find (sym_name); - local = symbolP == NULL; - if (local) -#endif /* OBJ_COFF */ - symbolP = symbol_find_or_make (sym_name); - /* Permit register names to be redefined. */ - if (!reassign - && S_IS_DEFINED (symbolP) - && S_GET_SEGMENT (symbolP) != reg_section) - as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP)); - -#ifdef OBJ_COFF - /* "set" symbols are local unless otherwise specified. */ - if (local) - SF_SET_LOCAL (symbolP); -#endif /* OBJ_COFF */ - - pseudo_set (symbolP); - } + assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign); if (flag_mri) { - /* Check garbage after the expression. */ - ignore_rest_of_line (); + demand_empty_rest_of_line (); mri_comment_end (stop, stopc); } } @@ -4833,6 +5713,10 @@ s_incbin (int x ATTRIBUTE_UNUSED) md_flush_pending_output (); #endif +#ifdef md_cons_align + md_cons_align (1); +#endif + SKIP_WHITESPACE (); filename = demand_copy_string (& len); if (filename == NULL) @@ -4868,7 +5752,7 @@ s_incbin (int x ATTRIBUTE_UNUSED) { int i; - path = xmalloc ((unsigned long) len + include_dir_maxlen + 5); + path = XNEWVEC (char, (unsigned long) len + include_dir_maxlen + 5); for (i = 0; i < include_dir_count; i++) { @@ -4899,13 +5783,13 @@ s_incbin (int x ATTRIBUTE_UNUSED) } file_len = ftell (binfile); - /* If a count was not specified use the size of the file. */ + /* If a count was not specified use the remainder of the file. */ if (count == 0) - count = file_len; + count = file_len - skip; - if (skip + count > file_len) + if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len) { - as_bad (_("skip (%ld) + count (%ld) larger than file size (%ld)"), + as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"), skip, count, file_len); goto done; } @@ -4924,11 +5808,10 @@ s_incbin (int x ATTRIBUTE_UNUSED) as_warn (_("truncated file `%s', %ld of %ld bytes read"), path, bytes, count); } -done: + done: if (binfile != NULL) fclose (binfile); - if (path) - free (path); + free (path); } /* .include -- include a file at this point. */ @@ -4938,7 +5821,7 @@ s_include (int arg ATTRIBUTE_UNUSED) { char *filename; int i; - FILE *try; + FILE *try_file; char *path; if (!flag_m68k_mri) @@ -4965,29 +5848,30 @@ s_include (int arg ATTRIBUTE_UNUSED) } obstack_1grow (¬es, '\0'); - filename = obstack_finish (¬es); + filename = (char *) obstack_finish (¬es); while (!is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; } demand_empty_rest_of_line (); - path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ ); + path = XNEWVEC (char, (unsigned long) i + + include_dir_maxlen + 5 /* slop */ ); for (i = 0; i < include_dir_count; i++) { strcpy (path, include_dirs[i]); strcat (path, "/"); strcat (path, filename); - if (0 != (try = fopen (path, FOPEN_RT))) + if (0 != (try_file = fopen (path, FOPEN_RT))) { - fclose (try); + fclose (try_file); goto gotit; } } free (path); path = filename; -gotit: + gotit: /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */ register_dependency (path); input_scrub_insert_file (path); @@ -5000,16 +5884,15 @@ add_include_dir (char *path) if (include_dir_count == 0) { - include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs)); + include_dirs = XNEWVEC (const char *, 2); include_dirs[0] = "."; /* Current dir. */ include_dir_count = 2; } else { include_dir_count++; - include_dirs = - (char **) realloc (include_dirs, - include_dir_count * sizeof (*include_dirs)); + include_dirs = XRESIZEVEC (const char *, include_dirs, + include_dir_count); } include_dirs[include_dir_count - 1] = path; /* New one. */ @@ -5066,7 +5949,7 @@ s_func (int end_p) /* Subroutine of s_func so targets can choose a different default prefix. If DEFAULT_PREFIX is NULL, use the target's "leading char". */ -void +static void do_s_func (int end_p, const char *default_prefix) { /* Record the current function so that we can issue an error message for @@ -5101,25 +5984,27 @@ do_s_func (int end_p, const char *default_prefix) return; } - name = input_line_pointer; - delim1 = get_symbol_end (); + delim1 = get_symbol_name (& name); name = xstrdup (name); *input_line_pointer = delim1; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != ',') { if (default_prefix) - asprintf (&label, "%s%s", default_prefix, name); + { + if (asprintf (&label, "%s%s", default_prefix, name) == -1) + as_fatal ("%s", xstrerror (errno)); + } else { - char leading_char = 0; -#ifdef BFD_ASSEMBLER - leading_char = bfd_get_symbol_leading_char (stdoutput); -#endif + char leading_char = bfd_get_symbol_leading_char (stdoutput); /* Missing entry point, use function's name with the leading char prepended. */ if (leading_char) - asprintf (&label, "%c%s", leading_char, name); + { + if (asprintf (&label, "%c%s", leading_char, name) == -1) + as_fatal ("%s", xstrerror (errno)); + } else label = name; } @@ -5128,10 +6013,9 @@ do_s_func (int end_p, const char *default_prefix) { ++input_line_pointer; SKIP_WHITESPACE (); - label = input_line_pointer; - delim2 = get_symbol_end (); + delim2 = get_symbol_name (& label); label = xstrdup (label); - *input_line_pointer = delim2; + restore_line_pointer (delim2); } if (debug_type == DEBUG_STABS) @@ -5144,14 +6028,85 @@ do_s_func (int end_p, const char *default_prefix) demand_empty_rest_of_line (); } +#ifdef HANDLE_BUNDLE + void -s_ignore (int arg ATTRIBUTE_UNUSED) +s_bundle_align_mode (int arg ATTRIBUTE_UNUSED) { - while (!is_end_of_line[(unsigned char) *input_line_pointer]) + unsigned int align = get_absolute_expression (); + SKIP_WHITESPACE (); + demand_empty_rest_of_line (); + + if (align > (unsigned int) TC_ALIGN_LIMIT) + as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"), + (unsigned int) TC_ALIGN_LIMIT); + + if (bundle_lock_frag != NULL) { - ++input_line_pointer; + as_bad (_("cannot change .bundle_align_mode inside .bundle_lock")); + return; } - ++input_line_pointer; + + bundle_align_p2 = align; +} + +void +s_bundle_lock (int arg ATTRIBUTE_UNUSED) +{ + demand_empty_rest_of_line (); + + if (bundle_align_p2 == 0) + { + as_bad (_(".bundle_lock is meaningless without .bundle_align_mode")); + return; + } + + if (bundle_lock_depth == 0) + { + bundle_lock_frchain = frchain_now; + bundle_lock_frag = start_bundle (); + } + ++bundle_lock_depth; +} + +void +s_bundle_unlock (int arg ATTRIBUTE_UNUSED) +{ + unsigned int size; + + demand_empty_rest_of_line (); + + if (bundle_lock_frag == NULL) + { + as_bad (_(".bundle_unlock without preceding .bundle_lock")); + return; + } + + gas_assert (bundle_align_p2 > 0); + + gas_assert (bundle_lock_depth > 0); + if (--bundle_lock_depth > 0) + return; + + size = pending_bundle_size (bundle_lock_frag); + + if (size > 1U << bundle_align_p2) + as_bad (_(".bundle_lock sequence is %u bytes, " + "but bundle size is only %u bytes"), + size, 1u << bundle_align_p2); + else + finish_bundle (bundle_lock_frag, size); + + bundle_lock_frag = NULL; + bundle_lock_frchain = NULL; +} + +#endif /* HANDLE_BUNDLE */ + +void +s_ignore (int arg ATTRIBUTE_UNUSED) +{ + ignore_rest_of_line (); } void @@ -5173,8 +6128,9 @@ void input_scrub_insert_line (const char *line) { sb newline; - sb_new (&newline); - sb_add_string (&newline, line); + size_t len = strlen (line); + sb_build (&newline, len); + sb_add_buffer (&newline, line, len); input_scrub_include_sb (&newline, input_line_pointer, 0); sb_kill (&newline); buffer_limit = input_scrub_next_buffer (&input_line_pointer); @@ -5189,3 +6145,102 @@ input_scrub_insert_file (char *path) input_scrub_include_file (path, input_line_pointer); buffer_limit = input_scrub_next_buffer (&input_line_pointer); } + +/* Find the end of a line, considering quotation and escaping of quotes. */ + +#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS) +# define TC_SINGLE_QUOTE_STRINGS 1 +#endif + +static char * +_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED, + int in_macro) +{ + char inquote = '\0'; + int inescape = 0; + + while (!is_end_of_line[(unsigned char) *s] + || (inquote && !ISCNTRL (*s)) + || (inquote == '\'' && flag_mri) +#ifdef TC_EOL_IN_INSN + || (insn && TC_EOL_IN_INSN (s)) +#endif + /* PR 6926: When we are parsing the body of a macro the sequence + \@ is special - it refers to the invocation count. If the @ + character happens to be registered as a line-separator character + by the target, then the is_end_of_line[] test above will have + returned true, but we need to ignore the line separating + semantics in this particular case. */ + || (in_macro && inescape && *s == '@') + ) + { + if (mri_string && *s == '\'') + inquote ^= *s; + else if (inescape) + inescape = 0; + else if (*s == '\\') + inescape = 1; + else if (!inquote + ? *s == '"' +#ifdef TC_SINGLE_QUOTE_STRINGS + || (TC_SINGLE_QUOTE_STRINGS && *s == '\'') +#endif + : *s == inquote) + inquote ^= *s; + ++s; + } + if (inquote) + as_warn (_("missing closing `%c'"), inquote); + if (inescape && !ignore_input ()) + as_warn (_("stray `\\'")); + return s; +} + +char * +find_end_of_line (char *s, int mri_string) +{ + return _find_end_of_line (s, mri_string, 0, 0); +} + +static char *saved_ilp = NULL; +static char *saved_limit; + +/* Use BUF as a temporary input pointer for calling other functions in this + file. BUF must be a C string, so that its end can be found by strlen. + Also sets the buffer_limit variable (local to this file) so that buffer + overruns should not occur. Saves the current input line pointer so that + it can be restored by calling restore_ilp(). + + Does not support recursion. */ + +void +temp_ilp (char *buf) +{ + gas_assert (saved_ilp == NULL); + gas_assert (buf != NULL); + + saved_ilp = input_line_pointer; + saved_limit = buffer_limit; + /* Prevent the assert in restore_ilp from triggering if + the input_line_pointer has not yet been initialised. */ + if (saved_ilp == NULL) + saved_limit = saved_ilp = (char *) ""; + + input_line_pointer = buf; + buffer_limit = buf + strlen (buf); + input_from_string = TRUE; +} + +/* Restore a saved input line pointer. */ + +void +restore_ilp (void) +{ + gas_assert (saved_ilp != NULL); + + input_line_pointer = saved_ilp; + buffer_limit = saved_limit; + input_from_string = FALSE; + + saved_ilp = NULL; +}