/* read.c - read a source file -
- Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 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, 51 Franklin Street - Fifth Floor, Boston, MA
-02110-1301, 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 your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
- But then, GNU isn't spozed to run on your machine anyway.
+ But then, GNU isn't supposed to run on your machine anyway.
(RMS is so shortsighted sometimes.) */
#define MASK_CHAR ((int)(unsigned char) -1)
#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. */
#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
};
/* 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 */
/* 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;
#endif
#endif
+/* 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 do_align (int, char *, int, int);
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);
+static char *_find_end_of_line (char *, int, int, int);
\f
void
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)
{"abort", s_abort, 0},
{"align", s_align_ptwo, 0},
{"altmacro", s_altmacro, 1},
- {"ascii", stringer, 0},
- {"asciz", stringer, 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},
/* 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},
{"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},
{"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},
{"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},
{"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},
{"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. */
get_absolute_expr (expressionS *exp)
{
expression_and_evaluate (exp);
+
if (exp->X_op != O_constant)
{
if (exp->X_op != O_absent)
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
}
\f
-#define HANDLE_CONDITIONAL_ASSEMBLY() \
+#define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
if (ignore_input ()) \
{ \
- char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
+ 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 \
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)
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_get_section_flags (stdoutput, 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
last_eol = NULL;
#endif
- know (buffer_limit[-1] == '\n'); /* Must have a sentinel. */
-
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. */
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);
(valueT) 0,
&zero_address_frag);
- *input_line_pointer = c;
- if (c == ':')
+ next_char = restore_line_pointer (nul_char);
+ if (next_char == ':')
input_line_pointer++;
}
}
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. */
- s = find_end_of_line (input_line_pointer - 1, flag_m68k_mri);
-
- if (s != last_eol)
- {
- 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 - 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';
+ 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');
- /* 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;
}
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 (input_line_pointer[1] == '='
- && (c == '='
- || ((c == ' ' || c == '\t')
- && input_line_pointer[2] == '=')))
+ else if ((next_char == '=' && *rest == '=')
+ || ((next_char == ' ' || next_char == '\t')
+ && rest[0] == '='
+ && rest[1] == '='))
{
equals (s, -1);
demand_empty_rest_of_line ();
}
- else if ((c == '='
- || ((c == ' ' || c == '\t')
- && input_line_pointer[1] == '='))
+ else if ((next_char == '='
+ || ((next_char == ' ' || next_char == '\t')
+ && *rest == '='))
#ifdef TC_EQUAL_IN_INSN
- && !TC_EQUAL_IN_INSN (c, s)
+ && !TC_EQUAL_IN_INSN (next_char, s)
#endif
- )
+ )
{
equals (s, 1);
demand_empty_rest_of_line ();
{
/* 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 '.'. */
{
char *end = input_line_pointer;
- *input_line_pointer = c;
+ (void) restore_line_pointer (nul_char);
s_ignore (0);
- c = *--input_line_pointer;
+ nul_char = next_char = *--input_line_pointer;
*input_line_pointer = '\0';
- if (! macro_defined || ! try_macro (c, s))
+ if (! macro_defined || ! try_macro (next_char, s))
{
*end = '\0';
as_bad (_("unknown pseudo-op: `%s'"), s);
- *input_line_pointer++ = c;
+ *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.
}
else
{
- /* WARNING: c has char, which may be end-of-line. */
- /* Also: input_line_pointer->`\0` where c was. */
- *input_line_pointer = c;
- input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1);
- 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 && try_macro (c, s))
+ if (macro_defined && try_macro (next_char, s))
continue;
if (mri_pending_align)
}
}
- 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. */
}
/* 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 = c - '0';
+ temp = next_char - '0';
+
+ if (nul_char == '"')
+ ++ input_line_pointer;
/* Read the whole number. */
while (ISDIGIT (*input_line_pointer))
}
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;
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)
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
{
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;
}
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);
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;
}
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);
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. */
+ /* 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 ();
}
/* Convert O_constant expression EXP into the equivalent O_big representation.
- Take the sign of the number from X_unsigned rather than X_add_number. */
+ Take the sign of the number from SIGN rather than X_add_number. */
static void
-convert_to_bignum (expressionS *exp)
+convert_to_bignum (expressionS *exp, int sign)
{
valueT value;
unsigned int i;
}
/* 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) != !exp->X_unsigned)
- generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
+ if ((exp->X_add_number < 0) == !sign)
+ generic_bignum[i++] = sign ? LITTLENUM_MASK : 0;
exp->X_op = O_big;
exp->X_add_number = i;
}
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. */
-
-static void
-do_align (int n, char *fill, int len, int max)
-{
- 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;
- }
-
-#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 != 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. */
-
-#define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
+#ifndef TC_ALIGN_LIMIT
+#define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
+#endif
static void
-s_align (int arg, int bytes_p)
+s_align (signed int arg, int bytes_p)
{
- unsigned int align_limit = ALIGN_LIMIT;
+ unsigned int align_limit = TC_ALIGN_LIMIT;
unsigned int align;
char *stop = NULL;
- char stopc;
+ char stopc = 0;
offsetT fill = 0;
- int max;
+ unsigned int max;
int fill_p;
if (flag_mri)
{
align = get_absolute_expression ();
SKIP_WHITESPACE ();
+
+#ifdef TC_ALIGN_ZERO_IS_DEFAULT
+ if (arg > 0 && align == 0)
+ align = arg;
+#endif
}
if (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);
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);
}
/* Switch in and out of alternate macro mode. */
-void
+static void
s_altmacro (int on)
{
demand_empty_rest_of_line ();
macro_set_alternate (on);
}
-symbolS *
-s_comm_internal (int param,
- symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
+/* 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 * name;
+ char * start;
char c;
- char *p;
- offsetT temp, size;
- symbolS *symbolP = NULL;
- char *stop = NULL;
- char stopc;
- 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;
+ c = *input_line_pointer++;
- if (name == p)
+ if (c == '"')
{
- as_bad (_("expected symbol name"));
- ignore_rest_of_line ();
- goto out;
- }
+#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;
+ offsetT temp, size;
+ symbolS *symbolP = NULL;
+ char *stop = NULL;
+ char stopc = 0;
+ expressionS exp;
+
+ if (flag_mri)
+ stop = mri_comment_field (&stopc);
+
+ 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 == ',')
temp = get_absolute_expr (&exp);
size = temp;
- size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
+ size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
if (exp.X_op == O_absent)
{
as_bad (_("missing size expression"));
goto out;
}
- *p = 0;
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);
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);
}
demand_empty_rest_of_line ();
out:
if (flag_mri)
mri_comment_end (stop, stopc);
+ if (name != NULL)
+ free (name);
return symbolP;
}
symbolS *sym;
offsetT align;
char *stop = NULL;
- char stopc;
+ char stopc = 0;
if (!flag_mri)
{
name = input_line_pointer;
if (!ISDIGIT (*name))
- c = get_symbol_end ();
+ c = get_symbol_name (& name);
else
{
do
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;
+ c = restore_line_pointer (c);
if (alc != NULL)
free (alc);
}
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)
s_data (int ignore ATTRIBUTE_UNUSED)
{
segT section;
- register int temp;
+ int temp;
temp = get_absolute_expression ();
if (flag_readonly_data_in_text)
subseg_set (section, (subsegT) temp);
-#ifdef OBJ_VMS
- const_flag = 0;
-#endif
demand_empty_rest_of_line ();
}
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. */
}
}
+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 (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. GCC however will generate a line number of
zero when it is pre-processing builtins for assembler-with-cpp files:
- # 0 "<built-in>"
+ # 0 "<built-in>"
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
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
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. */
- char *msg
+ const char *msg
= (err ? _(".error directive invoked in source file")
: _(".warning directive invoked in source file"));
{
offsetT temp;
char *stop = NULL;
- char stopc;
+ char stopc = 0;
if (flag_mri)
stop = mri_comment_field (&stopc);
{
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++;
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,
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 == ',')
if (is_end_of_line[(unsigned char) *input_line_pointer])
c = '\n';
}
+
+ free (name);
}
while (c == ',');
void
s_irp (int irpc)
{
- char *file, *eol;
+ 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);
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);
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)
else
as_warn (_("unrecognized .linkonce type `%s'"), s);
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
#ifdef obj_handle_link_once
}
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;
#endif
subseg_set (bss_seg, 1);
- if (align)
+ if (align > OCTETS_PER_BYTE_POWER)
{
record_alignment (bss_seg, align);
frag_align (align, 0, 0);
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"));
- ignore_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++;
&& 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. */
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 *eol;
return 0;
}
- eol = find_end_of_line (input_line_pointer, flag_m68k_mri);
+ 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;
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. */
void
s_macro (int ignore ATTRIBUTE_UNUSED)
{
- char *file, *eol;
+ char *eol;
+ const char * file;
unsigned int line;
sb s;
const char *err;
const char *name;
- as_where (&file, &line);
+ file = as_where (&line);
- sb_new (&s);
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;
if (line_label != NULL)
{
sb label;
+ size_t len;
- sb_new (&label);
- sb_add_string (&label, S_GET_NAME (line_label));
- err = define_macro (0, &s, &label, get_line_sb, file, line, &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_line_sb, file, line, &name);
+ err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
if (err != NULL)
as_bad_where (file, line, err, name);
else
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. */
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;
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)
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. */
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 ();
name = input_line_pointer;
if (!ISDIGIT (*name))
- c = get_symbol_end ();
+ c = get_symbol_name (& name);
else
{
do
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 ();
demand_empty_rest_of_line ();
#else /* ! TC_M68K */
-#ifdef TC_I960
-
- char *name;
- char c;
- segT seg;
-
- SKIP_WHITESPACE ();
-
- name = input_line_pointer;
- c = get_symbol_end ();
-
- 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 */
}
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++ == ',');
static void
s_bad_end (int endr)
{
- as_warn (_(".end%c encountered without preceeding %s"),
+ as_warn (_(".end%c encountered without preceding %s"),
endr ? 'r' : 'm',
endr ? ".rept, .irp, or .irpc" : ".macro");
demand_empty_rest_of_line ();
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");
}
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);
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.
if (listing & LISTING_SYMBOLS)
{
extern struct list_info_struct *listing_tail;
- fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
+ fragS *dummy_frag = XCNEW (fragS);
dummy_frag->line = listing_tail;
dummy_frag->fr_symbol = symbolP;
symbol_set_frag (symbolP, dummy_frag);
}
#endif
-#ifdef OBJ_COFF
+#if defined (OBJ_COFF) && !defined (TE_PE)
/* "set" symbols are local unless otherwise specified. */
SF_SET_LOCAL (symbolP);
#endif
}
- if (S_IS_DEFINED (symbolP))
+ if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
{
- /* Permit register names to be redefined. */
if ((mode != 0 || !S_IS_VOLATILE (symbolP))
- && S_GET_SEGMENT (symbolP) != reg_section)
+ && !S_CAN_BE_REDEFINED (symbolP))
{
as_bad (_("symbol `%s' is already defined"), name);
- symbolP = symbol_clone (symbolP, 0);
+ 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)
- /* This could be avoided when the symbol wasn't used so far, but
- the comment in struc-symbol.h says this flag isn't reliable. */
- && (1 || symbol_used_p (symbolP)))
+ else if (S_IS_VOLATILE (symbolP))
symbolP = symbol_clone (symbolP, 1);
}
s_set (int equiv)
{
char *name;
- char delim;
- char *end_name;
/* 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"));
- ignore_rest_of_line ();
- return;
- }
-
- SKIP_WHITESPACE ();
+ if ((name = read_symbol_name ()) == NULL)
+ return;
if (*input_line_pointer != ',')
{
- *end_name = 0;
as_bad (_("expected comma after \"%s\""), name);
- *end_name = delim;
ignore_rest_of_line ();
+ free (name);
return;
}
input_line_pointer++;
- *end_name = 0;
-
assign_symbol (name, equiv);
- *end_name = delim;
-
demand_empty_rest_of_line ();
+ free (name);
}
void
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);
}
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;
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)
{
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 (exp.X_op == O_constant)
{
- long repeat;
+ offsetT repeat;
repeat = exp.X_add_number;
if (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;
}
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;
}
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. */
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);
}
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);
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)
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
+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 (*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
+ {
+ 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;
+
+ 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;
}
\f
*input_line_pointer);
ignore_rest_of_line ();
}
-
+
/* Return pointing just after end-of-line. */
know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
}
input_line_pointer++;
/* Return pointing just after end-of-line. */
- know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
+ 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
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);
set_zero_frag (symbolP);
+ symbol_get_value_expression (symbolP)->X_op = O_register;
break;
case O_symbol:
symbolS *s = exp.X_add_symbol;
if (S_IS_COMMON (s))
- as_bad (_("`%s' can't be equated to common symbol '%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_SEGMENT (symbolP, undefined_section);
symbol_set_value_expression (symbolP, &exp);
+ copy_symbol_attributes (symbolP, exp.X_add_symbol);
set_zero_frag (symbolP);
break;
/* 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. */
#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
do_parse_cons_expression (expressionS *exp,
int nbytes ATTRIBUTE_UNUSED)
{
- TC_PARSE_CONS_EXPRESSION (exp, nbytes);
+ (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
}
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 ();
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)
{
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++ == ',');
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
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
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. */
{
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;
if (op == O_constant && nbytes > sizeof (valueT))
{
extra_digit = exp->X_unsigned ? 0 : -1;
- convert_to_bignum (exp);
+ 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. */
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);
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)
}
}
else
- {
- memset (p, 0, nbytes);
-
- /* Now we need to generate a fixS to record the symbol value. */
-
-#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
- }
+ emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE);
}
-\f
-#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 */
\f
/* 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;
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);
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 ())
return;
}
+ if (now_seg == absolute_section)
+ {
+ as_bad (_("attempt to store float in absolute section"));
+ ignore_rest_of_line ();
+ return;
+ }
+
+ if (in_bss ())
+ {
+ as_bad (_("attempt to store float in section `%s'"),
+ segment_name (now_seg));
+ ignore_rest_of_line ();
+ return;
+ }
+
#ifdef md_flush_pending_output
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!). */
{
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);
demand_empty_rest_of_line ();
}
\f
-/* 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
{
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;
}
return size;
}
-int
+unsigned int
sizeof_leb128 (valueT value, int sign)
{
if (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
{
return p - orig;
}
-static inline int
+static inline unsigned int
output_uleb128 (char *p, valueT value)
{
char *orig = p;
do
{
unsigned byte = (value & 0x7f);
+
value >>= 7;
if (value != 0)
/* More bytes to follow. */
return p - orig;
}
-int
+unsigned int
output_leb128 (char *p, valueT value, int sign)
{
if (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;
{
/* Sign-extend VAL. */
if (val & (1 << (loaded - 1)))
- val |= ~0 << loaded;
+ val |= ~0U << loaded;
if (orig)
*p = val & 0x7f;
p++;
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;
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);
}
/* Generate the appropriate fragments for a given expression to emit a
- leb128 value. */
+ leb128 value. SIGN is 1 for sleb, 0 for uleb. */
static void
emit_leb128_expr (expressionS *exp, int sign)
}
else if (op == O_constant
&& sign
- && (exp->X_add_number < 0) != !exp->X_unsigned)
+ && (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);
+ 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 = (unsigned int) -1;
/* 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
{
demand_empty_rest_of_line ();
}
\f
-/* 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 '\"'.
{
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 == '"')
{
{
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
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 <nn>"));
+ ignore_rest_of_line ();
+ return;
}
input_line_pointer++;
break;
}
demand_empty_rest_of_line ();
-} /* stringer() */
+}
\f
/* FIXME-SOMEDAY: I had trouble here on characters with the
high bits set. We'll probably also have trouble with
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;
#ifndef NO_STRING_ESCAPES
case '\\':
- switch (c = *input_line_pointer++)
+ switch (c = *input_line_pointer++ & CHAR_MASK)
{
case 'b':
c = '\b';
number = number * 8 + c - '0';
}
- c = number & 0xff;
+ c = number & CHAR_MASK;
}
--input_line_pointer;
break;
number = number * 16 + c - 'a' + 10;
c = *input_line_pointer++;
}
- c = number & 0xff;
+ c = number & CHAR_MASK;
--input_line_pointer;
}
break;
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
}
\f
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
}
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. */
expP->X_op = O_constant;
expP->X_add_number = 0;
}
- know (retval == absolute_section || SEG_NORMAL (retval));
- return (retval);
+ return retval;
}
char /* Return terminator. */
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--)
{
char *
demand_copy_string (int *lenP)
{
- register unsigned int c;
- register int len;
+ unsigned int c;
+ int len;
char *retval;
len = 0;
/* 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
{
equals (char *sym_name, int reassign)
{
char *stop = NULL;
- char stopc;
+ char stopc = 0;
input_line_pointer++;
if (*input_line_pointer == '=')
md_flush_pending_output ();
#endif
+#ifdef md_cons_align
+ md_cons_align (1);
+#endif
+
SKIP_WHITESPACE ();
filename = demand_copy_string (& len);
if (filename == NULL)
{
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++)
{
{
char *filename;
int i;
- FILE *try;
+ FILE *try_file;
char *path;
if (!flag_m68k_mri)
}
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;
}
}
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. */
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 = 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;
}
{
++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)
demand_empty_rest_of_line ();
}
\f
+#ifdef HANDLE_BUNDLE
+
+void
+s_bundle_align_mode (int arg ATTRIBUTE_UNUSED)
+{
+ 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)
+ {
+ as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
+ return;
+ }
+
+ 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 */
+\f
void
s_ignore (int arg ATTRIBUTE_UNUSED)
{
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);
#endif
static char *
-_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
+_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
+ int in_macro)
{
char inquote = '\0';
int inescape = 0;
#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 == '\'')
}
if (inquote)
as_warn (_("missing closing `%c'"), inquote);
- if (inescape)
+ 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);
+ 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;
}