/* read.c - read a source file -
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
#include "dw2gencfi.h"
#include "wchar.h"
+#include <limits.h>
+
#ifndef TC_START_LABEL
#define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
#endif
/* 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},
{"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},
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";
static bfd_boolean
in_bss (void)
{
- flagword flags = bfd_get_section_flags (stdoutput, now_seg);
+ flagword flags = bfd_section_flags (now_seg);
return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS));
}
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;
else
line_label = symbol_create (line_start,
absolute_section,
- (valueT) 0,
- &zero_address_frag);
+ &zero_address_frag, 0);
next_char = restore_line_pointer (nul_char);
if (next_char == ':')
{
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;
}
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;
/* 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);
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
out:
if (flag_mri)
mri_comment_end (stop, stopc);
- if (name != NULL)
- free (name);
+ free (name);
return symbolP;
}
sym = symbol_find_or_make (name);
c = restore_line_pointer (c);
- if (alc != NULL)
- free (alc);
+ free (alc);
if (*input_line_pointer != ',')
align = 0;
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 ()));
}
{
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 ()));
}
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
}
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"),
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 ()));
}
}
mri_comment_end (stop, stopc);
}
+void
+s_nop (int ignore ATTRIBUTE_UNUSED)
+{
+ 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
+
+ SKIP_WHITESPACE ();
+ expression (&exp);
+ demand_empty_rest_of_line ();
+
+ 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)
{
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;
val.X_add_number = 0;
}
- if (val.X_op == O_constant)
+ 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;
- }
+ 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;
}
- else
- as_bad (_("unsupported variable nop control in .nops directive"));
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;
}
/* This is like s_space, but the value is a floating point number with
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
/* Generate the appropriate fragments for a given expression to emit a
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;
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 ',':
bump_line_counters ();
break;
-#ifndef NO_STRING_ESCAPES
case '\\':
+ if (!TC_STRING_ESCAPES)
+ break;
switch (c = *input_line_pointer++ & CHAR_MASK)
{
case 'b':
break;
}
break;
-#endif /* ! defined (NO_STRING_ESCAPES) */
default:
break;
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. */
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);
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.
overruns should not occur. Saves the current input line pointer so that
it can be restored by calling restore_ilp().
- Does not support recursion.
-
- FIXME: This function is currently only used by stabs.c but that
- should be extended to other files in the gas source directory. */
+ Does not support recursion. */
void
temp_ilp (char *buf)