/* read.c - read a source file -
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
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 "dw2gencfi.h"
#include "wchar.h"
+#include <limits.h>
+
#ifndef TC_START_LABEL
-#define TC_START_LABEL(x,y,z) (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. */
+bool input_from_string = false;
#if BITS_PER_CHAR != 8
/* The following table is indexed by[(char)] and will break if
/* 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
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);
/* Set up pseudo-op tables. */
-static struct hash_control *po_hash;
+struct po_entry
+{
+ const char *poc_name;
+
+ const pseudo_typeS *pop;
+};
+
+typedef struct po_entry po_entry_t;
+
+/* Hash function for a po_entry. */
+
+static hashval_t
+hash_po_entry (const void *e)
+{
+ const po_entry_t *entry = (const po_entry_t *) e;
+ return htab_hash_string (entry->poc_name);
+}
+
+/* Equality function for a po_entry. */
+
+static int
+eq_po_entry (const void *a, const void *b)
+{
+ const po_entry_t *ea = (const po_entry_t *) a;
+ const po_entry_t *eb = (const po_entry_t *) b;
+
+ return strcmp (ea->poc_name, eb->poc_name) == 0;
+}
+
+static po_entry_t *
+po_entry_alloc (const char *poc_name, const pseudo_typeS *pop)
+{
+ po_entry_t *entry = XNEW (po_entry_t);
+ entry->poc_name = poc_name;
+ entry->pop = pop;
+ return entry;
+}
+
+static const pseudo_typeS *
+po_entry_find (htab_t table, const char *poc_name)
+{
+ po_entry_t needle = { poc_name, NULL };
+ po_entry_t *entry = htab_find (table, &needle);
+ return entry != NULL ? entry->pop : NULL;
+}
+
+static struct htab *po_hash;
static const pseudo_typeS potable[] = {
{"abort", s_abort, 0},
{"common.s", s_mri_common, 1},
{"data", s_data, 0},
{"dc", cons, 2},
-#ifdef TC_ADDRESS_BYTES
{"dc.a", cons, 0},
-#endif
{"dc.b", cons, 1},
{"dc.d", float_cons, 'd'},
{"dc.l", cons, 4},
{"ds.b", s_space, 1},
{"ds.d", s_space, 8},
{"ds.l", s_space, 4},
- {"ds.p", s_space, 12},
+ {"ds.p", s_space, 'p'},
{"ds.s", s_space, 4},
{"ds.w", s_space, 2},
- {"ds.x", s_space, 12},
+ {"ds.x", s_space, 'x'},
{"debug", s_ignore, 0},
#ifdef S_SET_DESC
{"desc", s_desc, 0},
{"noformat", s_ignore, 0},
{"nolist", listing_list, 0}, /* Turn listing off. */
{"nopage", listing_nopage, 0},
+ {"nop", s_nop, 0},
+ {"nops", s_nops, 0},
{"octa", cons, 16},
{"offset", s_struct, 0},
{"org", s_org, 0},
{"weakref", s_weakref, 0},
{"word", cons, 2},
{"zero", s_space, 0},
+ {"2byte", cons, 2},
+ {"4byte", cons, 4},
+ {"8byte", cons, 8},
{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)
void
pop_insert (const pseudo_typeS *table)
{
- const char *errtxt;
const pseudo_typeS *pop;
for (pop = table; pop->poc_name; pop++)
{
- errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
- if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
- as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
- errtxt);
+ po_entry_t *elt = po_entry_alloc (pop->poc_name, pop);
+ if (htab_insert (po_hash, elt, 0) != NULL)
+ {
+ free (elt);
+ if (!pop_override_ok)
+ as_fatal (_("error constructing %s pseudo-op table"),
+ pop_table_name);
+ }
}
}
static void
pobegin (void)
{
- po_hash = hash_new ();
+ po_hash = htab_create_alloc (16, hash_po_entry, eq_po_entry, NULL,
+ xcalloc, xfree);
/* Do the target-specific pseudo ops. */
pop_table_name = "md";
/* 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. */
- record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER);
+ 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
/* 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"),
+ 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"),
- (unsigned int) insn_size, 1U << bundle_align_p2);
+ 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);
}
#endif /* HANDLE_BUNDLE */
+static bool
+in_bss (void)
+{
+ flagword flags = bfd_section_flags (now_seg);
+
+ return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS));
+}
+
+/* Guts of .align directive:
+ N is the power of two to which to align. A value of zero is accepted but
+ ignored: the default alignment of the section will be at least this.
+ FILL may be NULL, or it may point to the bytes of the fill pattern.
+ LEN is the length of whatever FILL points to, if anything. If LEN is zero
+ but FILL is not NULL then LEN is treated as if it were one.
+ MAX is the maximum number of characters to skip when doing the alignment,
+ or 0 if there is no maximum. */
+
+void
+do_align (unsigned int n, char *fill, unsigned int len, unsigned int max)
+{
+ if (now_seg == absolute_section || in_bss ())
+ {
+ if (fill != NULL)
+ while (len-- > 0)
+ if (*fill++ != '\0')
+ {
+ if (now_seg == absolute_section)
+ as_warn (_("ignoring fill value in absolute section"));
+ else
+ as_warn (_("ignoring fill value in section `%s'"),
+ segment_name (now_seg));
+ break;
+ }
+ fill = NULL;
+ len = 0;
+ }
+
+#ifdef md_flush_pending_output
+ md_flush_pending_output ();
+#endif
+
+#ifdef md_do_align
+ md_do_align (n, fill, len, max, just_record_alignment);
+#endif
+
+ /* Only make a frag if we HAVE to... */
+ if ((n > OCTETS_PER_BYTE_POWER) && !need_pass_2)
+ {
+ if (fill == NULL)
+ {
+ if (subseg_text_p (now_seg))
+ frag_align_code (n, max);
+ else
+ frag_align (n, 0, max);
+ }
+ else if (len <= 1)
+ frag_align (n, *fill, max);
+ else
+ frag_align_pattern (n, fill, len, max);
+ }
+
+#ifdef md_do_align
+ just_record_alignment: ATTRIBUTE_UNUSED_LABEL
+#endif
+
+ if (n > OCTETS_PER_BYTE_POWER)
+ record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
+}
+
/* We read the file, putting things into a web that represents what we
have been reading. */
void
-read_a_source_file (char *name)
+read_a_source_file (const char *name)
{
- char c;
+ char nul_char;
+ char next_char;
char *s; /* String of symbol, '\0' appended. */
- int temp;
- pseudo_typeS *pop;
+ long temp;
+ const pseudo_typeS *pop;
#ifdef WARN_COMMENTS
found_comment = 0;
#endif
while (input_line_pointer < buffer_limit)
{
- bfd_boolean was_new_line;
+ bool was_new_line;
/* We have more of this buffer to parse. */
/* We now have input_line_pointer->1st char of next line.
/* 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 = (char *) xmalloc (len + macro_nest + 2);
+ copy = XNEWVEC (char, len + macro_nest + 2);
memset (copy, '>', macro_nest);
copy[macro_nest] = ' ';
memcpy (copy + macro_nest + 1, input_line_pointer, len);
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 *line_start;
int mri_line_macro;
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);
else
line_label = symbol_create (line_start,
absolute_section,
- (valueT) 0,
- &zero_address_frag);
+ &zero_address_frag, 0);
- *input_line_pointer = c;
- if (c == ':')
+ next_char = restore_line_pointer (nul_char);
+ if (next_char == ':')
input_line_pointer++;
}
}
Each test is independent of all other tests at the (top)
level. */
do
- c = *input_line_pointer++;
- while (c == '\t' || c == ' ' || c == '\f');
+ nul_char = next_char = *input_line_pointer++;
+ while (next_char == '\t' || next_char == ' ' || next_char == '\f');
/* 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 (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, s, 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 ((c == '=' && input_line_pointer[1] == '=')
- || ((c == ' ' || c == '\t')
- && input_line_pointer[1] == '='
- && 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
)
{
{
char *s2 = s;
- strncpy (original_case_string, s2, sizeof (original_case_string));
+ strncpy (original_case_string, s2,
+ sizeof (original_case_string) - 1);
original_case_string[sizeof (original_case_string) - 1] = 0;
while (*s2)
{
/* The MRI assembler uses pseudo-ops without
a period. */
- pop = (pseudo_typeS *) hash_find (po_hash, s);
+ pop = po_entry_find (po_hash, s);
if (pop != NULL && pop->poc_handler == NULL)
pop = NULL;
}
{
/* 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 '.'. */
if (pop == NULL)
- pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
+ pop = po_entry_find (po_hash, s + 1);
if (pop && !pop->poc_handler)
pop = NULL;
{
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;
+ /* 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);
- c = *input_line_pointer;
+ 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)
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 (1);
- temp = c - '0';
+ temp = next_char - '0';
+
+ if (nul_char == '"')
+ ++ input_line_pointer;
/* Read the whole number. */
while (ISDIGIT (*input_line_pointer))
{
- temp = (temp * 10) + *input_line_pointer - '0';
+ const long digit = *input_line_pointer - '0';
+ if (temp > (LONG_MAX - digit) / 10)
+ {
+ as_bad (_("local label too large near %s"), backup);
+ temp = -1;
+ break;
+ }
+ temp = temp * 10 + digit;
++input_line_pointer;
}
+ /* Overflow: stop processing the label. */
+ if (temp == -1)
+ {
+ ignore_rest_of_line ();
+ continue;
+ }
+
if (LOCAL_LABELS_DOLLAR
&& *input_line_pointer == '$'
&& *(input_line_pointer + 1) == ':')
if (dollar_label_defined (temp))
{
- as_fatal (_("label \"%d$\" redefined"), temp);
+ as_fatal (_("label \"%ld$\" redefined"), temp);
}
define_dollar_label (temp);
}
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;
char *tmp_buf = 0;
s = input_line_pointer;
- if (strncmp (s, "APP\n", 4))
+ if (!startswith (s, "APP\n"))
{
/* We ignore it. */
ignore_rest_of_line ();
that goes with this #APP There is one. The specs
guarantee it... */
tmp_len = buffer_limit - s;
- tmp_buf = (char *) 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 = (char *) 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 (;;)
{
break;
}
- new_buf = (char *) xrealloc (new_buf, new_length + 100);
+ new_buf = XRESIZEVEC (char, new_buf, new_length + 100);
new_tmp = new_buf + new_length;
new_length += 100;
}
- if (tmp_buf)
- free (tmp_buf);
+ free (tmp_buf);
/* We've "scrubbed" input to the preferred format. In the
process we may have consumed the whole of the remaining
HANDLE_CONDITIONAL_ASSEMBLY (1);
#ifdef tc_unrecognized_line
- if (tc_unrecognized_line (c))
+ if (tc_unrecognized_line (next_char))
continue;
#endif
input_line_pointer--;
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
#endif
static void
-s_align (int arg, int bytes_p)
+s_align (signed int arg, int bytes_p)
{
unsigned int align_limit = TC_ALIGN_LIMIT;
- unsigned int align;
+ addressT align;
char *stop = NULL;
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)
if (align > align_limit)
{
align = align_limit;
- as_warn (_("alignment too large: %u assumed"), align);
+ as_warn (_("alignment too large: %u assumed"), align_limit);
}
if (*input_line_pointer != ',')
}
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);
}
char * name_end;
unsigned int C;
- start = name = xmalloc (len + 1);
+ start = name = XNEWVEC (char, len + 1);
name_end = name + SYM_NAME_CHUNK_LEN;
sofar = name - start;
len += SYM_NAME_CHUNK_LEN;
- start = xrealloc (start, len + 1);
+ start = XRESIZEVEC (char, start, len + 1);
name_end = start + len;
name = start + sofar;
}
if (mbstowcs (NULL, name, len) == (size_t) -1)
as_warn (_("symbol name not recognised in the current locale"));
}
- else if (is_name_beginner (c) || c == '\001')
+ else if (is_name_beginner (c) || (input_from_string && c == FAKE_LABEL_CHAR))
{
ptrdiff_t len;
name = input_line_pointer - 1;
- /* We accept \001 in a name in case this is
+ /* 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++)
- || c == '\001')
+ || (input_from_string && c == FAKE_LABEL_CHAR))
;
len = (input_line_pointer - name) - 1;
- start = xmalloc (len + 1);
+ start = XNEWVEC (char, len + 1);
memcpy (start, name, len);
start[len] = 0;
out:
if (flag_mri)
mri_comment_end (stop, stopc);
- if (name != NULL)
- free (name);
+ free (name);
return symbolP;
}
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;
- if (alc != NULL)
- free (alc);
+ c = restore_line_pointer (c);
+ free (alc);
if (*input_line_pointer != ',')
align = 0;
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"));
md_cons_align (1);
#endif
- get_known_segmented_expression (&rep_exp);
+ 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,
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);
eol = find_end_of_line (input_line_pointer, 0);
sb_build (&s, eol - input_line_pointer);
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
if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
as_warn (_(".linkonce is not supported for this object file format"));
- flags = bfd_get_section_flags (stdoutput, now_seg);
+ flags = bfd_section_flags (now_seg);
flags |= SEC_LINK_ONCE;
switch (type)
{
flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
break;
}
- if (!bfd_set_section_flags (stdoutput, now_seg, flags))
+ if (!bfd_set_section_flags (now_seg, flags))
as_bad (_("bfd_set_section_flags: %s"),
bfd_errmsg (bfd_get_error ()));
}
}
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;
{
bss_seg = subseg_new (".sbss", 1);
seg_info (bss_seg)->bss = 1;
- if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
+ if (!bfd_set_section_flags (bss_seg, SEC_ALLOC | SEC_SMALL_DATA))
as_warn (_("error setting flags for \".sbss\": %s"),
bfd_errmsg (bfd_get_error ()));
}
#endif
subseg_set (bss_seg, 1);
- if (align)
+ if (align > OCTETS_PER_BYTE_POWER)
{
record_alignment (bss_seg, align);
frag_align (align, 0, 0);
symbol_get_frag (symbolP)->fr_symbol = NULL;
symbol_set_frag (symbolP, frag_now);
- pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
+ pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size * OCTETS_PER_BYTE, NULL);
*pfrag = 0;
#ifdef S_SET_SIZE
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);
eol = find_end_of_line (input_line_pointer, 0);
sb_build (&s, eol - input_line_pointer);
}
if (((NO_PSEUDO_DOT || flag_m68k_mri)
- && hash_find (po_hash, name) != NULL)
+ && po_entry_find (po_hash, name) != NULL)
|| (!flag_m68k_mri
&& *name == '.'
- && hash_find (po_hash, name + 1) != NULL))
+ && po_entry_find (po_hash, name + 1) != NULL))
as_warn_where (file,
line,
_("attempt to redefine pseudo-op `%s' ignored"),
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. */
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 ();
flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
if (flags != SEC_NO_FLAGS)
{
- if (!bfd_set_section_flags (stdoutput, seg, flags))
+ if (!bfd_set_section_flags (seg, flags))
as_warn (_("error setting flags for \"%s\": %s"),
- bfd_section_name (stdoutput, seg),
+ bfd_section_name (seg),
bfd_errmsg (bfd_get_error ()));
}
}
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++ == ',');
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_non_macro_line_sb))
{
}
/* Like do_repeat except that any text matching EXPANDER in the
- block is replaced by the itteration count. */
+ block is replaced by the iteration count. */
void
-do_repeat_with_expander (int count,
+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))
{
sb_build (& processed, one.len);
sb_add_sb (& processed, & one);
sub = strstr (processed.ptr, expander);
- len = sprintf (sub, "%d", count);
+ len = sprintf (sub, "%lu", (unsigned long) count);
gas_assert (len < 8);
- strcpy (sub + len, sub + 8);
+ memmove (sub + len, sub + 8,
+ processed.ptr + processed.len - (sub + 8));
processed.len -= (8 - len);
sb_add_sb (& many, & processed);
sb_kill (& processed);
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);
&& !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
md_flush_pending_output ();
#endif
+ switch (mult)
+ {
+ case 'x':
+#ifdef X_PRECISION
+# ifndef P_PRECISION
+# define P_PRECISION X_PRECISION
+# define P_PRECISION_PAD X_PRECISION_PAD
+# endif
+ mult = (X_PRECISION + X_PRECISION_PAD) * sizeof (LITTLENUM_TYPE);
+ if (!mult)
+#endif
+ mult = 12;
+ break;
+
+ case 'p':
+#ifdef P_PRECISION
+ mult = (P_PRECISION + P_PRECISION_PAD) * sizeof (LITTLENUM_TYPE);
+ if (!mult)
+#endif
+ mult = 12;
+ break;
+ }
+
#ifdef md_cons_align
md_cons_align (1);
#endif
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 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);
}
-/* 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. */
-
void
-s_float_space (int float_type)
+s_nop (int ignore ATTRIBUTE_UNUSED)
{
- offsetT count;
- int flen;
- char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
- char *stop = NULL;
- char stopc = 0;
+ expressionS exp;
+ fragS *start;
+ addressT start_off;
+ offsetT frag_off;
+
+#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);
-
- count = get_absolute_expression ();
-
SKIP_WHITESPACE ();
- if (*input_line_pointer != ',')
- {
- as_bad (_("missing value"));
- ignore_rest_of_line ();
- if (flag_mri)
- mri_comment_end (stop, stopc);
- return;
- }
+ expression (&exp);
+ demand_empty_rest_of_line ();
- ++input_line_pointer;
+ start = frag_now;
+ start_off = frag_now_fix ();
+ do
+ {
+#ifdef md_emit_single_noop
+ md_emit_single_noop;
+#else
+ char *nop;
+
+#ifndef md_single_noop_insn
+#define md_single_noop_insn "nop"
+#endif
+ /* md_assemble might modify its argument, so
+ we must pass it a string that is writable. */
+ if (asprintf (&nop, "%s", md_single_noop_insn) < 0)
+ as_fatal ("%s", xstrerror (errno));
+
+ /* Some targets assume that they can update input_line_pointer
+ inside md_assemble, and, worse, that they can leave it
+ assigned to the string pointer that was provided as an
+ argument. So preserve ilp here. */
+ char *saved_ilp = input_line_pointer;
+ md_assemble (nop);
+ input_line_pointer = saved_ilp;
+ free (nop);
+#endif
+#ifdef md_flush_pending_output
+ md_flush_pending_output ();
+#endif
+ } while (exp.X_op == O_constant
+ && exp.X_add_number > 0
+ && frag_offset_ignore_align_p (start, frag_now, &frag_off)
+ && frag_off + frag_now_fix () < start_off + exp.X_add_number);
+}
+
+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
+
+ SKIP_WHITESPACE ();
+ expression (&exp);
+ /* Note - this expression is tested for an absolute value in
+ write.c:relax_segment(). */
+
+ SKIP_WHITESPACE ();
+ 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)
+ {
+ as_bad (_("unsupported variable nop control in .nops directive"));
+ val.X_op = O_constant;
+ val.X_add_number = 0;
+ }
+ else if (val.X_add_number < 0)
+ {
+ as_warn (_("negative nop control byte, ignored"));
+ val.X_add_number = 0;
+ }
+
+ demand_empty_rest_of_line ();
+
+ if (need_pass_2)
+ /* Ignore this directive if we are going to perform a second pass. */
+ return;
+
+ /* 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;
+}
+
+/* Obtain the size of a floating point number, given a type. */
+
+static int
+float_length (int float_type, int *pad_p)
+{
+ int length, pad = 0;
+
+ switch (float_type)
+ {
+ case 'b':
+ case 'B':
+ case 'h':
+ case 'H':
+ length = 2;
+ break;
+
+ case 'f':
+ case 'F':
+ case 's':
+ case 'S':
+ length = 4;
+ break;
+
+ case 'd':
+ case 'D':
+ case 'r':
+ case 'R':
+ length = 8;
+ break;
+
+ case 'x':
+ case 'X':
+#ifdef X_PRECISION
+ length = X_PRECISION * sizeof (LITTLENUM_TYPE);
+ pad = X_PRECISION_PAD * sizeof (LITTLENUM_TYPE);
+ if (!length)
+#endif
+ length = 12;
+ break;
+
+ case 'p':
+ case 'P':
+#ifdef P_PRECISION
+ length = P_PRECISION * sizeof (LITTLENUM_TYPE);
+ pad = P_PRECISION_PAD * sizeof (LITTLENUM_TYPE);
+ if (!length)
+#endif
+ length = 12;
+ break;
+
+ default:
+ as_bad (_("unknown floating type '%c'"), float_type);
+ length = -1;
+ break;
+ }
+
+ if (pad_p)
+ *pad_p = pad;
+
+ return length;
+}
+
+static int
+parse_one_float (int float_type, char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT])
+{
+ int length;
SKIP_WHITESPACE ();
/* Skip any 0{letter} that may be present. Don't even check if the
- * letter is legal. */
+ letter is legal. Someone may invent a "z" format and this routine
+ has no use for such information. Lusers beware: you get
+ diagnostics if your input is ill-conditioned. */
if (input_line_pointer[0] == '0'
&& ISALPHA (input_line_pointer[1]))
input_line_pointer += 2;
with the exact digits specified. */
if (input_line_pointer[0] == ':')
{
- flen = hex_float (float_type, temp);
- if (flen < 0)
+ ++input_line_pointer;
+ length = hex_float (float_type, temp);
+ if (length < 0)
{
ignore_rest_of_line ();
- if (flag_mri)
- mri_comment_end (stop, stopc);
- return;
+ return length;
}
}
else
{
- char *err;
+ const char *err;
- err = md_atof (float_type, temp, &flen);
- know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
- know (err != NULL || flen > 0);
+ err = md_atof (float_type, temp, &length);
+ know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
+ know (err != NULL || length > 0);
if (err)
{
as_bad (_("bad floating literal: %s"), err);
ignore_rest_of_line ();
- if (flag_mri)
- mri_comment_end (stop, stopc);
- return;
+ return -1;
}
}
+ return length;
+}
+
+/* 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. */
+
+void
+s_float_space (int float_type)
+{
+ offsetT count;
+ int flen;
+ char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
+ char *stop = NULL;
+ char stopc = 0;
+
+#ifdef md_cons_align
+ md_cons_align (1);
+#endif
+
+ if (flag_mri)
+ stop = mri_comment_field (&stopc);
+
+ count = get_absolute_expression ();
+
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer != ',')
+ {
+ int pad;
+
+ flen = float_length (float_type, &pad);
+ if (flen >= 0)
+ memset (temp, 0, flen += pad);
+ }
+ else
+ {
+ ++input_line_pointer;
+
+ flen = parse_one_float (float_type, temp);
+ }
+
+ if (flen < 0)
+ {
+ if (flag_mri)
+ mri_comment_end (stop, stopc);
+ return;
+ }
+
while (--count >= 0)
{
char *p;
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
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);
/* 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), TC_PARSE_CONS_RETURN_NONE)
-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), TC_PARSE_CONS_RETURN_NONE)
return;
}
-#ifdef TC_ADDRESS_BYTES
if (nbytes == 0)
nbytes = TC_ADDRESS_BYTES ();
-#endif
#ifdef md_cons_align
md_cons_align (nbytes);
else
#endif
{
+#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);
}
char *r_name;
int c;
struct reloc_list *reloc;
- struct _bfd_rel { char *name; bfd_reloc_code_real_type code; };
- static struct _bfd_rel bfd_relocs[] = {
+ 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 },
+ { "8", BFD_RELOC_8 },
{ "16", BFD_RELOC_16 },
{ "32", BFD_RELOC_32 },
{ "64", BFD_RELOC_64 }
};
- reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
+ reloc = XNEW (struct reloc_list);
if (flag_mri)
stop = mri_comment_field (&stopc);
goto err_out;
case O_constant:
exp.X_add_symbol = section_symbol (now_seg);
+ /* Mark the section symbol used in relocation so that it will be
+ included in the symbol table. */
+ symbol_mark_used_in_reloc (exp.X_add_symbol);
exp.X_op = O_symbol;
- /* Fall thru */
+ /* Fallthru */
case O_symbol:
if (exp.X_add_number == 0)
{
reloc->u.a.offset_sym = exp.X_add_symbol;
break;
}
- /* Fall thru */
+ /* Fallthru */
default:
reloc->u.a.offset_sym = make_expr_symbol (&exp);
break;
++input_line_pointer;
SKIP_WHITESPACE ();
- r_name = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (& r_name);
if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0)
{
unsigned int i;
}
exp.X_op = O_absent;
- SKIP_WHITESPACE ();
+ SKIP_WHITESPACE_AFTER_NAME ();
if (*input_line_pointer == ',')
{
++input_line_pointer;
break;
}
- as_where (&reloc->file, &reloc->line);
+ reloc->file = as_where (&reloc->line);
reloc->next = reloc_list;
reloc_list = reloc;
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)
{
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;
valueT get;
valueT use;
valueT mask;
- valueT hibit;
valueT unmask;
/* JF << of >= number of bits in the object is undefined. In
particular SPARC (Sun 4) has problems. */
if (nbytes >= sizeof (valueT))
{
+ know (nbytes == sizeof (valueT));
mask = 0;
- if (nbytes > sizeof (valueT))
- hibit = 0;
- else
- hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
}
else
{
/* Don't store these bits. */
mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
- hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
}
unmask = ~mask; /* Do store these bits. */
get = exp->X_add_number;
use = get & unmask;
- if ((get & mask) != 0
- && ((get & mask) != mask
- || (get & hibit) == 0))
- { /* 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
+ if ((get & mask) != 0 && (-get & mask) != 0)
+ {
+ char get_buf[128];
+ char use_buf[128];
+
+ /* These buffers help to ease the translation of the warning message. */
+ sprintf_vma (get_buf, get);
+ sprintf_vma (use_buf, use);
+ /* Leading bits contain both 0s & 1s. */
+ as_warn (_("value 0x%s truncated to 0x%s"), get_buf, use_buf);
}
/* Put bytes in right order. */
md_number_to_chars (p, use, (int) nbytes);
if (nbytes < size)
{
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 (_("bignum truncated to %d bytes"), nbytes);
+ as_warn (ngettext ("bignum truncated to %d byte",
+ "bignum truncated to %d bytes",
+ nbytes),
+ nbytes);
size = nbytes;
}
if (size > nbytes)
{
- as_bad (_("%s relocations do not fit in %u bytes\n"),
+ 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;
}
#endif
}
\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;
-{
- 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;
-
- 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. */
-
- 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. */
-
- value |= ((~(-1 << width) & exp->X_add_number)
- << ((BITS_PER_CHAR * nbytes) - bits_available));
-
- if ((bits_available -= width) == 0
- || is_it_end_of_statement ()
- || *input_line_pointer != ',')
- {
- break;
- } /* All the bitfields we're gonna get. */
-
- hold = ++input_line_pointer;
- (void) expression (exp);
- }
-
- exp->X_add_number = value;
- exp->X_op = O_constant;
- exp->X_unsigned = 1;
- exp->X_extrabit = 0;
- }
-}
-
-#endif /* BITFIELD_CONS_EXPRESSIONS */
-\f
/* Handle an MRI style string expression. */
#ifdef TC_M68K
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;
int i;
static int
hex_float (int float_type, char *bytes)
{
- int length;
+ int pad, length = float_length (float_type, &pad);
int i;
- switch (float_type)
- {
- case 'f':
- case 'F':
- case 's':
- case 'S':
- length = 4;
- break;
-
- case 'd':
- case 'D':
- case 'r':
- case 'R':
- length = 8;
- break;
-
- case 'x':
- case 'X':
- length = 12;
- break;
-
- case 'p':
- case 'P':
- length = 12;
- break;
-
- default:
- as_bad (_("unknown floating type type '%c'"), float_type);
- return -1;
- }
+ if (length < 0)
+ return length;
/* It would be nice if we could go through expression to parse the
hex constant, but if we get a bignum it's a pain to sort it into
memset (bytes, 0, length - i);
}
- return length;
+ memset (bytes + length, 0, pad);
+
+ return length + pad;
}
/* float_cons()
{
char *p;
int length; /* Number of chars in an object. */
- 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
do
{
- /* input_line_pointer->1st char of a flonum (we hope!). */
- SKIP_WHITESPACE ();
-
- /* Skip any 0{letter} that may be present. Don't even check if the
- letter is legal. Someone may invent a "z" format and this routine
- has no use for such information. Lusers beware: you get
- diagnostics if your input is ill-conditioned. */
- if (input_line_pointer[0] == '0'
- && ISALPHA (input_line_pointer[1]))
- input_line_pointer += 2;
-
- /* Accept :xxxx, where the x's are hex digits, for a floating
- point with the exact digits specified. */
- if (input_line_pointer[0] == ':')
- {
- ++input_line_pointer;
- length = hex_float (float_type, temp);
- if (length < 0)
- {
- ignore_rest_of_line ();
- return;
- }
- }
- else
- {
- err = md_atof (float_type, temp, &length);
- know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
- know (err != NULL || length > 0);
- if (err)
- {
- as_bad (_("bad floating literal: %s"), err);
- ignore_rest_of_line ();
- return;
- }
- }
+ length = parse_one_float (float_type, temp);
+ if (length < 0)
+ return;
if (!need_pass_2)
{
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)
{
int size = 0;
return size;
}
-static inline int
+static inline unsigned int
sizeof_uleb128 (valueT value)
{
int size = 0;
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)
{
char *orig = p;
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;
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
+void
emit_leb128_expr (expressionS *exp, int sign)
{
operatorT op = exp->X_op;
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
{
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);
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 == '"')
{
while (is_a_char (c = next_char_of_string ()))
stringer_append_char (c, bitsize);
+ /* Treat "a" "b" as "ab". Even if we are appending zeros. */
+ SKIP_ALL_WHITESPACE ();
+ if (*input_line_pointer == '"')
+ break;
+
if (append_zero)
stringer_append_char (0, bitsize);
- know (input_line_pointer[-1] == '\"');
-
#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
c = get_single_number ();
stringer_append_char (c, bitsize);
if (*input_line_pointer != '>')
- as_bad (_("expected <nn>"));
-
+ {
+ as_bad (_("expected <nn>"));
+ ignore_rest_of_line ();
+ return;
+ }
input_line_pointer++;
break;
case ',':
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;
bump_line_counters ();
break;
-#ifndef NO_STRING_ESCAPES
case '\\':
- switch (c = *input_line_pointer++)
+ if (!TC_STRING_ESCAPES)
+ break;
+ switch (c = *input_line_pointer++ & CHAR_MASK)
{
case 'b':
c = '\b';
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
break;
}
break;
-#endif /* ! defined (NO_STRING_ESCAPES) */
default:
break;
for (len = *len_pointer; len > 0; len--)
{
- if (*s == 0)
+ if (s[len - 1] == 0)
{
s = 0;
- len = 1;
*len_pointer = 0;
as_bad (_("this string may not contain \'\\0\'"));
+ break;
}
}
}
{
int i;
- path = (char *) 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++)
{
if (binfile)
{
long file_len;
+ struct stat filestat;
+ if (fstat (fileno (binfile), &filestat) != 0
+ || ! S_ISREG (filestat.st_mode)
+ || S_ISDIR (filestat.st_mode))
+ {
+ as_bad (_("unable to include `%s'"), path);
+ goto done;
+ }
+
register_dependency (path);
/* Compute the length of the file. */
as_warn (_("truncated file `%s', %ld of %ld bytes read"),
path, bytes, count);
}
-done:
+ done:
if (binfile != NULL)
fclose (binfile);
- if (path)
- free (path);
+ free (path);
}
/* .include -- include a file at this point. */
}
demand_empty_rest_of_line ();
- path = (char *) 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++)
{
free (path);
path = filename;
-gotit:
+ gotit:
/* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
register_dependency (path);
input_scrub_insert_file (path);
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 **) xrealloc (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)
{
++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)
size = pending_bundle_size (bundle_lock_frag);
- if (size > (1U << bundle_align_p2))
- as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
- size, 1 << bundle_align_p2);
+ 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);
void
read_print_statistics (FILE *file)
{
- hash_print_statistics (file, "pseudo-op table", po_hash);
+ htab_print_statistics (file, "pseudo-op table", po_hash);
}
/* Inserts the given line into the input stream.
{
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;
+}