/* 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, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2014 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
#include "obstack.h"
#include "ecoff.h"
#include "dw2gencfi.h"
+#include "wchar.h"
#ifndef TC_START_LABEL
#define TC_START_LABEL(x,y,z) (x == ':')
#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);
-#ifdef OBJ_ELF
-static void s_gnu_attribute (int);
-#endif
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_non_macro_line_sb (sb *);
+static size_t get_non_macro_line_sb (sb *);
static void generate_file_debug (void);
static char *_find_end_of_line (char *, int, int, int);
\f
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++)
+ for (p = tc_line_separator_chars; *p; p++)
is_end_of_line[(unsigned char) *p] = 2;
/* Use more. FIXME-SOMEDAY. */
{"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},
{"func", s_func, 0},
{"global", s_globl, 0},
{"globl", s_globl, 0},
-#ifdef OBJ_ELF
- {"gnu_attribute", s_gnu_attribute, 0},
-#endif
{"hword", cons, 2},
{"if", s_if, (int) O_ne},
{"ifb", s_ifb, 1},
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() \
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. */
+ 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"),
+ (unsigned int) 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 */
+
/* We read the file, putting things into a web that represents what we
have been reading. */
void
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
/* Input_line_pointer->after ':'. */
SKIP_WHITESPACE ();
}
- else if ((c == '=' && input_line_pointer[1] == '=')
+ else if ((c == '=' && input_line_pointer[1] == '=')
|| ((c == ' ' || c == '\t')
&& input_line_pointer[1] == '='
&& input_line_pointer[2] == '='))
equals (s, -1);
demand_empty_rest_of_line ();
}
- else if ((c == '='
- || ((c == ' ' || c == '\t')
- && input_line_pointer[1] == '='))
+ else if ((c == '='
+ || ((c == ' ' || c == '\t')
+ && input_line_pointer[1] == '='))
#ifdef TC_EQUAL_IN_INSN
- && !TC_EQUAL_IN_INSN (c, s)
+ && !TC_EQUAL_IN_INSN (c, s)
#endif
- )
+ )
{
equals (s, 1);
demand_empty_rest_of_line ();
}
}
- md_assemble (s); /* Assemble 1 instruction. */
+ assemble_one (s); /* Assemble 1 instruction. */
*input_line_pointer++ = c;
bump_line_counters ();
s += 4;
- sb_new (&sbuf);
ends = strstr (s, "#NO_APP\n");
if (!ends)
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);
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);
/* 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;
}
macro_set_alternate (on);
}
+/* Read a symbol name from input_line_pointer.
+
+ Stores the symbol name in a buffer and returns a pointer to this buffer.
+ The buffer is xalloc'ed. It is the caller's responsibility to free
+ this buffer.
+
+ The name is not left in the i_l_p buffer as it may need processing
+ to handle escape characters.
+
+ Advances i_l_p to the next non-whitespace character.
+
+ If a symbol name could not be read, the routine issues an error
+ messages, skips to the end of the line and returns NULL. */
+
+static char *
+read_symbol_name (void)
+{
+ char * name;
+ char * start;
+ char c;
+
+ c = *input_line_pointer++;
+
+ if (c == '"')
+ {
+#define SYM_NAME_CHUNK_LEN 128
+ ptrdiff_t len = SYM_NAME_CHUNK_LEN;
+ char * name_end;
+ unsigned int C;
+
+ start = name = xmalloc (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 = xrealloc (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) || c == '\001')
+ {
+ ptrdiff_t len;
+
+ name = input_line_pointer - 1;
+
+ /* We accept \001 in a name in case this is
+ being called with a constructed string. */
+ while (is_part_of_name (c = *input_line_pointer++)
+ || c == '\001')
+ ;
+
+ len = (input_line_pointer - name) - 1;
+ start = xmalloc (len + 1);
+
+ memcpy (start, name, len);
+ start[len] = 0;
+
+ /* Skip a name ender char if one is present. */
+ if (! is_name_ender (c))
+ --input_line_pointer;
+ }
+ else
+ name = start = NULL;
+
+ if (name == start)
+ {
+ as_bad (_("expected symbol name"));
+ ignore_rest_of_line ();
+ return NULL;
+ }
+
+ SKIP_WHITESPACE ();
+
+ return start;
+}
+
+
symbolS *
s_comm_internal (int param,
symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
{
char *name;
- char c;
- char *p;
offsetT temp, size;
symbolS *symbolP = NULL;
char *stop = NULL;
if (flag_mri)
stop = mri_comment_field (&stopc);
- name = input_line_pointer;
- c = get_symbol_end ();
- /* Just after name is now '\0'. */
- p = input_line_pointer;
- *p = c;
-
- if (name == p)
- {
- as_bad (_("expected symbol name"));
- ignore_rest_of_line ();
- goto out;
- }
-
- SKIP_WHITESPACE ();
+ if ((name = read_symbol_name ()) == NULL)
+ goto out;
/* Accept an optional comma after the name. The comma used to be
required, but Irix 5 cc does not generate it for .lcomm. */
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) || 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;
}
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);
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
-#ifdef OBJ_VMS
- {
- extern int flag_one;
- if (size == 0 || !flag_one)
- S_GET_OTHER (symbolP) = const_flag;
- }
-#endif
}
demand_empty_rest_of_line ();
out:
if (flag_mri)
mri_comment_end (stop, stopc);
+ if (name != NULL)
+ free (name);
return symbolP;
}
#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 '"'. */
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
/* From GCC's cpp documentation:
1: start of a new file.
2: returning to a file after having included
- another file.
+ another file.
3: following text comes from a system header file.
4: following text should be treated as extern "C".
{
expressionS rep_exp;
long size = 1;
- register long fill = 0;
+ long fill = 0;
char *p;
#ifdef md_flush_pending_output
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 == ',');
mri_comment_end (stop, stopc);
}
-#ifdef OBJ_ELF
-#define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
-
-static inline int
-skip_past_char (char ** str, char c)
-{
- if (**str == c)
- {
- (*str)++;
- return 0;
- }
- else
- return -1;
-}
-#define skip_past_comma(str) skip_past_char (str, ',')
-
-/* Parse an attribute directive for VENDOR.
- Returns the attribute number read, or zero on error. */
-int
-s_vendor_attribute (int vendor)
-{
- expressionS exp;
- int type;
- int tag;
- unsigned int i = 0;
- char *s = NULL;
-
- /* Read the first number or name. */
- skip_whitespace (input_line_pointer);
- s = input_line_pointer;
- if (ISDIGIT (*input_line_pointer))
- {
- expression (& exp);
- if (exp.X_op != O_constant)
- goto bad;
- tag = exp.X_add_number;
- }
- else
- {
- char *name;
-
- /* A name may contain '_', but no other punctuation. */
- for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
- ++input_line_pointer)
- i++;
- if (i == 0)
- goto bad;
-
- name = (char *) alloca (i + 1);
- memcpy (name, s, i);
- name[i] = '\0';
-
-#ifndef CONVERT_SYMBOLIC_ATTRIBUTE
-#define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
-#endif
-
- tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
- if (tag == -1)
- {
- as_bad (_("Attribute name not recognised: %s"), name);
- ignore_rest_of_line ();
- return 0;
- }
- }
-
- type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
-
- if (skip_past_comma (&input_line_pointer) == -1)
- goto bad;
- if (type & 1)
- {
- expression (& exp);
- if (exp.X_op != O_constant)
- {
- as_bad (_("expected numeric constant"));
- ignore_rest_of_line ();
- return 0;
- }
- i = exp.X_add_number;
- }
- if ((type & 3) == 3
- && skip_past_comma (&input_line_pointer) == -1)
- {
- as_bad (_("expected comma"));
- ignore_rest_of_line ();
- return 0;
- }
- if (type & 2)
- {
- int len;
-
- skip_whitespace (input_line_pointer);
- if (*input_line_pointer != '"')
- goto bad_string;
- s = demand_copy_C_string (&len);
- }
-
- switch (type & 3)
- {
- case 3:
- bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
- break;
- case 2:
- bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
- break;
- case 1:
- bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
- break;
- default:
- abort ();
- }
-
- demand_empty_rest_of_line ();
- return tag;
-bad_string:
- as_bad (_("bad string constant"));
- ignore_rest_of_line ();
- return 0;
-bad:
- as_bad (_("expected <tag> , <value>"));
- ignore_rest_of_line ();
- return 0;
-}
-
-/* Parse a .gnu_attribute directive. */
-
-static void
-s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
-{
- s_vendor_attribute (OBJ_ATTR_GNU);
-}
-#endif /* OBJ_ELF */
-
/* Handle the MRI IRP and IRPC pseudo-ops. */
void
as_where (&file, &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;
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);
if (S_GET_SEGMENT (symbolP) == undefined_section)
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
return *input_line_pointer++;
}
-static int
+static size_t
get_non_macro_line_sb (sb *line)
{
return get_line_sb (line, 0);
}
-static int
+static size_t
get_macro_line_sb (sb *line)
{
return get_line_sb (line, 1);
as_where (&file, &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));
+ 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);
}
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)
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 ();
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 ();
return;
}
- sb_new (&many);
+ sb_build (&many, count * one.len);
while (count-- > 0)
sb_add_sb (&many, &one);
char * sub;
sb processed;
- sb_new (& processed);
+ sb_build (& processed, one.len);
sb_add_sb (& processed, & one);
sub = strstr (processed.ptr, expander);
len = sprintf (sub, "%d", count);
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) || 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);
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
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
s_weakref (int ignore ATTRIBUTE_UNUSED)
{
char *name;
- char delim;
- char *end_name;
symbolS *symbolP;
symbolS *symbolP2;
expressionS exp;
- name = input_line_pointer;
- delim = get_symbol_end ();
- end_name = input_line_pointer;
-
- if (name == end_name)
- {
- as_bad (_("expected symbol name"));
- *end_name = delim;
- ignore_rest_of_line ();
- return;
- }
+ if ((name = read_symbol_name ()) == NULL)
+ return;
symbolP = symbol_find_or_make (name);
if (!S_IS_VOLATILE (symbolP))
{
as_bad (_("symbol `%s' is already defined"), name);
- *end_name = delim;
- ignore_rest_of_line ();
- return;
+ goto err_out;
}
symbolP = symbol_clone (symbolP, 1);
S_CLEAR_VOLATILE (symbolP);
}
- *end_name = delim;
-
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
- *end_name = 0;
as_bad (_("expected comma after \"%s\""), name);
- *end_name = delim;
- ignore_rest_of_line ();
- return;
+ goto err_out;
}
input_line_pointer++;
SKIP_WHITESPACE ();
+ free (name);
- name = input_line_pointer;
- delim = get_symbol_end ();
- end_name = input_line_pointer;
-
- if (name == end_name)
- {
- as_bad (_("expected symbol name"));
- ignore_rest_of_line ();
- return;
- }
+ if ((name = read_symbol_name ()) == NULL)
+ return;
if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
&& (symbolP2 = md_undefined_symbol (name)) == NULL)
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);
S_GET_NAME (symbolP), loop);
free (loop);
-
- *end_name = delim;
+ free (name);
ignore_rest_of_line ();
return;
}
/* symbolP2 = symp; */
}
- *end_name = delim;
-
memset (&exp, 0, sizeof (exp));
exp.X_op = O_symbol;
exp.X_add_symbol = symbolP2;
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]]);
}
#ifndef TC_PARSE_CONS_EXPRESSION
#ifdef BITFIELD_CONS_EXPRESSIONS
-#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
+#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)
+#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;
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 (*input_line_pointer == '"')
+ {
+ as_bad (_("unexpected `\"' in expression"));
+ ignore_rest_of_line ();
+ return;
+ }
+ 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++ == ',');
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;
- /* Grow the current frag now so that dot_value does not get invalidated
- if the frag were to fill up in the frag_more() call below. */
frag_grow (nbytes);
dot_value = frag_now_fix ();
+ dot_frag = frag_now;
#ifndef NO_LISTING
#ifdef OBJ_ELF
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. */
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. */
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;
+ }
+ if (i < exp->X_add_number)
+ as_warn (_("bignum truncated to %d bytes"), 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
- emit_expr_fix (exp, nbytes, frag_now, p);
+ emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE);
}
void
-emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
+emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p,
+ TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED)
{
- memset (p, 0, nbytes);
+ int offset = 0;
+ unsigned int size = nbytes;
+
+ memset (p, 0, size);
/* Generate a fixS to record the symbol value. */
#ifdef TC_CONS_FIX_NEW
- TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
+ TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r);
#else
- {
- bfd_reloc_code_real_type r;
+ if (r != TC_PARSE_CONS_RETURN_NONE)
+ {
+ reloc_howto_type *reloc_howto;
+
+ reloc_howto = bfd_reloc_type_lookup (stdoutput, r);
+ size = bfd_get_reloc_size (reloc_howto);
- switch (nbytes)
+ if (size > nbytes)
+ {
+ as_bad (_("%s relocations do not fit in %u bytes\n"),
+ reloc_howto->name, nbytes);
+ return;
+ }
+ else if (target_big_endian)
+ offset = nbytes - size;
+ }
+ else
+ switch (size)
{
case 1:
r = BFD_RELOC_8;
r = BFD_RELOC_64;
break;
default:
- as_bad (_("unsupported BFD relocation size %u"), nbytes);
- r = BFD_RELOC_32;
- break;
+ as_bad (_("unsupported BFD relocation size %u"), size);
+ return;
}
- fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
- 0, r);
- }
+ fix_new_exp (frag, p - frag->fr_literal + offset, size,
+ exp, 0, r);
#endif
}
\f
exp->X_add_number = value;
exp->X_op = O_constant;
exp->X_unsigned = 1;
+ exp->X_extrabit = 0;
}
}
#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;
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. */
+ char *err; /* Error from scanning floating literal. */
char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
if (is_it_end_of_statement ())
static inline int
sizeof_sleb128 (offsetT value)
{
- register int size = 0;
- register unsigned byte;
+ int size = 0;
+ unsigned byte;
do
{
static inline int
sizeof_uleb128 (valueT value)
{
- register int size = 0;
- register unsigned byte;
+ int size = 0;
do
{
- byte = (value & 0x7f);
value >>= 7;
size += 1;
}
static inline int
output_sleb128 (char *p, offsetT value)
{
- register char *orig = p;
- register int more;
+ char *orig = p;
+ int more;
do
{
}
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;
}
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 ();
{
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 ()))
stringer_append_char (c, bitsize);
know (input_line_pointer[-1] == '\"');
-#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
input_line_pointer[-1] = c;
}
#endif
-#endif
break;
case '<':
unsigned int
next_char_of_string (void)
{
- register unsigned int c;
+ unsigned int c;
c = *input_line_pointer++ & CHAR_MASK;
switch (c)
}
\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;
demand_empty_rest_of_line ();
path = (char *) xmalloc ((unsigned long) i
- + include_dir_maxlen + 5 /* slop */ );
+ + include_dir_maxlen + 5 /* slop */ );
for (i = 0; i < include_dir_count; i++)
{
{
include_dir_count++;
include_dirs =
- (char **) realloc (include_dirs,
- include_dir_count * sizeof (*include_dirs));
+ (char **) xrealloc (include_dirs,
+ include_dir_count * sizeof (*include_dirs));
}
include_dirs[include_dir_count - 1] = path; /* New one. */
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 only %u"),
+ size, 1 << 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);
projects / platform / upstream / binutils.git / blobdiff