/* read.c - read a source file -
Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+02110-1301, USA. */
-#if 0
-/* If your chars aren't 8 bits, you will change this a bit.
+/* 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.
(RMS is so shortsighted sometimes.) */
-#define MASK_CHAR (0xFF)
-#else
#define MASK_CHAR ((int)(unsigned char) -1)
-#endif
/* This is the largest known floating point format (for now). It will
grow when we do 4361 style flonums. */
#endif
#endif
+static void do_s_func (int end_p, const char *default_prefix);
static void do_align (int, char *, int, int);
static void s_align (int, int);
static void s_altmacro (int);
+static void s_bad_end (int);
static int hex_float (int, char *);
static segT get_known_segmented_expression (expressionS * expP);
static void pobegin (void);
static int get_line_sb (sb *);
static void generate_file_debug (void);
+static char *_find_end_of_line (char *, int, int);
\f
void
read_begin (void)
lex_type['?'] = 3;
}
\f
+#ifndef TC_ADDRESS_BYTES
+#ifdef BFD_ASSEMBLER
+#define TC_ADDRESS_BYTES address_bytes
+
+static inline int
+address_bytes (void)
+{
+ /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
+ contain an address. */
+ int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
+ n |= n >> 1;
+ n |= n >> 2;
+ n += 1;
+ return n;
+}
+#endif
+#endif
+
/* Set up pseudo-op tables. */
static struct hash_control *po_hash;
{"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},
{"endc", s_endif, 0},
{"endfunc", s_func, 1},
{"endif", s_endif, 0},
- {"endr", s_bad_endr, 0},
+ {"endm", s_bad_end, 0},
+ {"endr", s_bad_end, 1},
/* endef */
{"equ", s_set, 0},
{"equiv", s_set, 1},
{"globl", s_globl, 0},
{"hword", cons, 2},
{"if", s_if, (int) O_ne},
+ {"ifb", s_ifb, 1},
{"ifc", s_ifc, 0},
{"ifdef", s_ifdef, 0},
{"ifeq", s_if, (int) O_eq},
{"ifgt", s_if, (int) O_gt},
{"ifle", s_if, (int) O_le},
{"iflt", s_if, (int) O_lt},
+ {"ifnb", s_ifb, 0},
{"ifnc", s_ifc, 1},
{"ifndef", s_ifdef, 1},
{"ifne", s_if, (int) O_ne},
{NULL, NULL, 0} /* End sentinel. */
};
+static offsetT
+get_absolute_expr (expressionS *exp)
+{
+ expression (exp);
+ if (exp->X_op != O_constant)
+ {
+ if (exp->X_op != O_absent)
+ as_bad (_("bad or irreducible absolute expression"));
+ exp->X_add_number = 0;
+ }
+ return exp->X_add_number;
+}
+
+offsetT
+get_absolute_expression (void)
+{
+ expressionS exp;
+
+ return get_absolute_expr (&exp);
+}
+
static int pop_override_ok = 0;
static const char *pop_table_name;
#define HANDLE_CONDITIONAL_ASSEMBLY() \
if (ignore_input ()) \
{ \
- while (!is_end_of_line[(unsigned char) *input_line_pointer++]) \
- if (input_line_pointer == buffer_limit) \
- break; \
+ char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
+ input_line_pointer = (input_line_pointer <= buffer_limit \
+ && eol >= buffer_limit) \
+ ? buffer_limit \
+ : eol + 1; \
continue; \
}
return copy;
}
+/* Helper function of read_a_source_file, which tries to expand a macro. */
+static int
+try_macro (char term, const char *line)
+{
+ sb out;
+ const char *err;
+ macro_entry *macro;
+
+ if (check_macro (line, &out, &err, ¯o))
+ {
+ if (err != NULL)
+ as_bad ("%s", err);
+ *input_line_pointer++ = term;
+ input_scrub_include_sb (&out,
+ input_line_pointer, 1);
+ sb_kill (&out);
+ buffer_limit =
+ input_scrub_next_buffer (&input_line_pointer);
+#ifdef md_macro_info
+ md_macro_info (macro);
+#endif
+ return 1;
+ }
+ return 0;
+}
+
/* We read the file, putting things into a web that represents what we
have been reading. */
void
while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
{ /* We have another line to parse. */
+#ifndef NO_LISTING
+ /* In order to avoid listing macro expansion lines with labels
+ multiple times, keep track of which line was last issued. */
+ static char *last_eol;
+
+ last_eol = NULL;
+#endif
know (buffer_limit[-1] == '\n'); /* Must have a sentinel. */
while (input_line_pointer < buffer_limit)
int len;
/* Find the end of the current expanded macro line. */
- for (s = input_line_pointer - 1; *s; ++s)
- if (is_end_of_line[(unsigned char) *s])
- break;
+ s = find_end_of_line (input_line_pointer - 1, flag_m68k_mri);
- /* Copy it for safe keeping. Also give an indication of
- how much macro nesting is involved at this point. */
- len = s - (input_line_pointer - 1);
- copy = (char *) xmalloc (len + macro_nest + 2);
- memset (copy, '>', macro_nest);
- copy[macro_nest] = ' ';
- memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
- copy[macro_nest + 1 + len] = '\0';
-
- /* Install the line with the listing facility. */
- listing_newline (copy);
+ if (s != last_eol)
+ {
+ last_eol = s;
+ /* Copy it for safe keeping. Also give an indication of
+ how much macro nesting is involved at this point. */
+ len = s - (input_line_pointer - 1);
+ copy = (char *) xmalloc (len + macro_nest + 2);
+ memset (copy, '>', macro_nest);
+ copy[macro_nest] = ' ';
+ memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
+ copy[macro_nest + 1 + len] = '\0';
+
+ /* Install the line with the listing facility. */
+ listing_newline (copy);
+ }
}
else
listing_newline (NULL);
/* Input_line_pointer->after ':'. */
SKIP_WHITESPACE ();
}
- 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, input_line_pointer)
+ && !TC_EQUAL_IN_INSN (c, s)
#endif
- ))
+ )
{
equals (s, 1);
demand_empty_rest_of_line ();
/* Print the error msg now, while we still can. */
if (pop == NULL)
{
- as_bad (_("unknown pseudo-op: `%s'"), s);
+ char *end = input_line_pointer;
+
*input_line_pointer = c;
s_ignore (0);
+ c = *--input_line_pointer;
+ *input_line_pointer = '\0';
+ if (! macro_defined || ! try_macro (c, s))
+ {
+ *end = '\0';
+ as_bad (_("unknown pseudo-op: `%s'"), s);
+ *input_line_pointer++ = c;
+ }
continue;
}
}
else
{
- int inquote = 0;
-#ifdef QUOTES_IN_INSN
- int inescape = 0;
-#endif
-
/* WARNING: c has char, which may be end-of-line. */
/* Also: input_line_pointer->`\0` where c was. */
*input_line_pointer = c;
- while (!is_end_of_line[(unsigned char) *input_line_pointer]
- || inquote
-#ifdef TC_EOL_IN_INSN
- || TC_EOL_IN_INSN (input_line_pointer)
-#endif
- )
- {
- if (flag_m68k_mri && *input_line_pointer == '\'')
- inquote = !inquote;
-#ifdef QUOTES_IN_INSN
- if (inescape)
- inescape = 0;
- else if (*input_line_pointer == '"')
- inquote = !inquote;
- else if (*input_line_pointer == '\\')
- inescape = 1;
-#endif
- input_line_pointer++;
- }
-
+ input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1);
c = *input_line_pointer;
*input_line_pointer = '\0';
generate_lineno_debug ();
- if (macro_defined)
- {
- sb out;
- const char *err;
- macro_entry *macro;
-
- if (check_macro (s, &out, &err, ¯o))
- {
- if (err != NULL)
- as_bad ("%s", err);
- *input_line_pointer++ = c;
- input_scrub_include_sb (&out,
- input_line_pointer, 1);
- sb_kill (&out);
- buffer_limit =
- input_scrub_next_buffer (&input_line_pointer);
-#ifdef md_macro_info
- md_macro_info (macro);
-#endif
- continue;
- }
- }
+ if (macro_defined && try_macro (c, s))
+ continue;
if (mri_pending_align)
{
#endif
}
+/* 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. */
+
+static void
+convert_to_bignum (expressionS *exp)
+{
+ valueT value;
+ unsigned int i;
+
+ value = exp->X_add_number;
+ for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
+ {
+ generic_bignum[i] = value & LITTLENUM_MASK;
+ value >>= LITTLENUM_NUMBER_OF_BITS;
+ }
+ /* Add a sequence of sign bits if the top bit of X_add_number is not
+ the sign of the original value. */
+ if ((exp->X_add_number < 0) != !exp->X_unsigned)
+ generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
+ exp->X_op = O_big;
+ exp->X_add_number = i;
+}
+
/* For most MRI pseudo-ops, the line actually ends at the first
nonquoted space. This function looks for that point, stuffs a null
in, and sets *STOPCP to the character that used to be there, and
fill pattern. BYTES_P is non-zero if the alignment value should be
interpreted as the byte boundary, rather than the power of 2. */
+#ifdef BFD_ASSEMBLER
+#define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
+#else
+#define ALIGN_LIMIT 15
+#endif
+
static void
s_align (int arg, int bytes_p)
{
- register unsigned int align;
+ unsigned int align_limit = ALIGN_LIMIT;
+ unsigned int align;
char *stop = NULL;
char stopc;
offsetT fill = 0;
}
}
- if (align > 15)
+ if (align > align_limit)
{
- align = 15;
+ align = align_limit;
as_warn (_("alignment too large: %u assumed"), align);
}
if (name == p)
{
as_bad (_("expected symbol name"));
- discard_rest_of_line ();
+ ignore_rest_of_line ();
goto out;
}
if (*input_line_pointer == ',')
input_line_pointer++;
- *p = 0;
temp = get_absolute_expr (&exp);
size = temp;
#ifdef BFD_ASSEMBLER
if (exp.X_op == O_absent)
{
as_bad (_("missing size expression"));
- *p = c;
ignore_rest_of_line ();
goto out;
}
else if (temp != size || !exp.X_unsigned)
{
as_warn (_("size (%ld) out of range, ignored"), (long) temp);
- *p = c;
ignore_rest_of_line ();
goto out;
}
+ *p = 0;
symbolP = symbol_find_or_make (name);
if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
{
#endif
}
- know (symbolP == NULL || symbolP->sy_frag == &zero_address_frag);
demand_empty_rest_of_line ();
out:
if (flag_mri)
.file. */
void
-s_app_file_string (char *file, int appfile)
+s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
{
#ifdef LISTING
if (listing)
{
as_bad (_("%s argument must be a string"),
err ? ".error" : ".warning");
- discard_rest_of_line ();
+ ignore_rest_of_line ();
return;
}
void
s_irp (int irpc)
{
- char *file;
+ char *file, *eol;
unsigned int line;
sb s;
const char *err;
as_where (&file, &line);
sb_new (&s);
- while (!is_end_of_line[(unsigned char) *input_line_pointer])
- sb_add_char (&s, *input_line_pointer++);
+ eol = find_end_of_line (input_line_pointer, 0);
+ sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
+ input_line_pointer = eol;
sb_new (&out);
if (name == p)
{
as_bad (_("expected symbol name"));
- discard_rest_of_line ();
+ ignore_rest_of_line ();
return;
}
static int
get_line_sb (sb *line)
{
- char quote1, quote2, inquote;
- unsigned char c;
+ char *eol;
if (input_line_pointer[-1] == '\n')
bump_line_counters ();
return 0;
}
- /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
- code needs to be changed. */
- if (!flag_m68k_mri)
- quote1 = '"';
- else
- quote1 = '\0';
-
- quote2 = '\0';
- if (flag_m68k_mri)
- quote2 = '\'';
-#ifdef LEX_IS_STRINGQUOTE
- quote2 = '\'';
-#endif
-
- inquote = '\0';
-
- while ((c = * input_line_pointer ++) != 0
- && (!is_end_of_line[c]
- || (inquote != '\0' && c != '\n')))
- {
- if (inquote == c)
- inquote = '\0';
- else if (inquote == '\0')
- {
- if (c == quote1)
- inquote = quote1;
- else if (c == quote2)
- inquote = quote2;
- }
-
- sb_add_char (line, c);
- }
+ eol = find_end_of_line (input_line_pointer, flag_m68k_mri);
+ sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
+ input_line_pointer = eol;
/* Don't skip multiple end-of-line characters, because that breaks support
for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
characters but isn't. Instead just skip one end of line character and
return the character skipped so that the caller can re-insert it if
necessary. */
- return c;
+ return *input_line_pointer++;
}
/* Define a macro. This is an interface to macro.c. */
void
s_macro (int ignore ATTRIBUTE_UNUSED)
{
- char *file;
+ char *file, *eol;
unsigned int line;
sb s;
- sb label;
const char *err;
const char *name;
as_where (&file, &line);
sb_new (&s);
- while (!is_end_of_line[(unsigned char) *input_line_pointer])
- sb_add_char (&s, *input_line_pointer++);
+ eol = find_end_of_line (input_line_pointer, 0);
+ sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
+ input_line_pointer = eol;
- sb_new (&label);
if (line_label != NULL)
- sb_add_string (&label, S_GET_NAME (line_label));
+ {
+ sb label;
- err = define_macro (0, &s, &label, get_line_sb, &name);
+ sb_new (&label);
+ sb_add_string (&label, S_GET_NAME (line_label));
+ err = define_macro (0, &s, &label, get_line_sb, file, line, &name);
+ sb_kill (&label);
+ }
+ else
+ err = define_macro (0, &s, NULL, get_line_sb, file, line, &name);
if (err != NULL)
- as_bad_where (file, line, "%s", err);
+ as_bad_where (file, line, err, name);
else
{
if (line_label != NULL)
{
- S_SET_SEGMENT (line_label, undefined_section);
+ S_SET_SEGMENT (line_label, absolute_section);
S_SET_VALUE (line_label, 0);
symbol_set_frag (line_label, &zero_address_frag);
}
|| (!flag_m68k_mri
&& *name == '.'
&& hash_find (po_hash, name + 1) != NULL))
- as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
+ as_warn_where (file,
+ line,
+ _("attempt to redefine pseudo-op `%s' ignored"),
name);
}
demand_empty_rest_of_line ();
}
-/* Handle the .rept pseudo-op. */
+/* Handle the .endm/.endr pseudo-ops. */
-void
-s_bad_endr (int ignore ATTRIBUTE_UNUSED)
+static void
+s_bad_end (int endr)
{
- as_warn (_(".endr encountered without preceeding .rept, .irc, or .irp"));
+ as_warn (_(".end%c encountered without preceeding %s"),
+ endr ? 'r' : 'm',
+ endr ? ".rept, .irp, or .irpc" : ".macro");
demand_empty_rest_of_line ();
}
buffer_limit = input_scrub_next_buffer (&input_line_pointer);
}
-/* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
- this is .equiv, and it is an error if the symbol is already
- defined. */
-
-void
-s_set (int equiv)
+static void
+assign_symbol (char *name, int no_reassign)
{
- register char *name;
- register char delim;
- register char *end_name;
- register symbolS *symbolP;
-
- /* Especial apologies for the random logic:
- this just grew, and could be parsed much more simply!
- Dean in haste. */
- name = input_line_pointer;
- delim = get_symbol_end ();
- end_name = input_line_pointer;
- *end_name = delim;
-
- if (name == end_name)
- {
- as_bad (_("expected symbol name"));
- discard_rest_of_line ();
- return;
- }
-
- SKIP_WHITESPACE ();
-
- if (*input_line_pointer != ',')
- {
- *end_name = 0;
- as_bad (_("expected comma after \"%s\""), name);
- *end_name = delim;
- ignore_rest_of_line ();
- return;
- }
-
- input_line_pointer++;
- *end_name = 0;
+ symbolS *symbolP;
if (name[0] == '.' && name[1] == '\0')
{
/* Turn '. = mumble' into a .org mumble. */
- register segT segment;
+ segT segment;
expressionS exp;
segment = get_known_segmented_expression (&exp);
if (!need_pass_2)
do_org (segment, &exp, 0);
- *end_name = delim;
return;
}
if ((symbolP = symbol_find (name)) == NULL
&& (symbolP = md_undefined_symbol (name)) == NULL)
{
+ symbolP = symbol_find_or_make (name);
#ifndef NO_LISTING
/* When doing symbol listings, play games with dummy fragments living
outside the normal fragment chain to record the file and line info
if (listing & LISTING_SYMBOLS)
{
extern struct list_info_struct *listing_tail;
- fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
- memset (dummy_frag, 0, sizeof (fragS));
- dummy_frag->fr_type = rs_fill;
+ fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
dummy_frag->line = listing_tail;
- symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
dummy_frag->fr_symbol = symbolP;
+ symbol_set_frag (symbolP, dummy_frag);
}
- else
#endif
- symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
-
#ifdef OBJ_COFF
/* "set" symbols are local unless otherwise specified. */
SF_SET_LOCAL (symbolP);
-#endif /* OBJ_COFF */
+#endif
}
- symbol_table_insert (symbolP);
-
- *end_name = delim;
-
- if (equiv
+ /* Permit register names to be redefined. */
+ if (no_reassign
&& S_IS_DEFINED (symbolP)
&& S_GET_SEGMENT (symbolP) != reg_section)
- as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
+ as_bad (_("symbol `%s' is already defined"), name);
pseudo_set (symbolP);
+}
+
+/* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
+ this is .equiv, and it is an error if the symbol is already
+ defined. */
+
+void
+s_set (int equiv)
+{
+ 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 (*input_line_pointer != ',')
+ {
+ *end_name = 0;
+ as_bad (_("expected comma after \"%s\""), name);
+ *end_name = delim;
+ ignore_rest_of_line ();
+ return;
+ }
+
+ input_line_pointer++;
+ *end_name = 0;
+
+ assign_symbol (name, equiv);
+ *end_name = delim;
+
demand_empty_rest_of_line ();
}
know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
}
-void
-discard_rest_of_line (void)
-{
- while (input_line_pointer < buffer_limit
- && !is_end_of_line[(unsigned char) *input_line_pointer])
- input_line_pointer++;
-
- input_line_pointer++;
+/* Sets frag for given symbol to zero_address_frag, except when the
+ symbol frag is already set to a dummy listing frag. */
- /* Return pointing just after end-of-line. */
- know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
+static void
+set_zero_frag (symbolS *symbolP)
+{
+ if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
+ symbol_set_frag (symbolP, &zero_address_frag);
}
/* In: Pointer to a symbol.
pseudo_set (symbolS *symbolP)
{
expressionS exp;
+ segT seg;
#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
int ext;
#endif /* OBJ_AOUT or OBJ_BOUT */
know (symbolP); /* NULL pointer is logic error. */
-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
- ext = S_IS_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */
(void) expression (&exp);
- S_GET_VALUE (exp.X_op_symbol));
}
+ if (symbol_section_p (symbolP))
+ {
+ as_bad ("attempt to set value of section symbol");
+ return;
+ }
+#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
+ ext = S_IS_EXTERNAL (symbolP);
+#endif /* OBJ_AOUT or OBJ_BOUT */
+
switch (exp.X_op)
{
case O_illegal:
/* Fall through. */
case O_constant:
S_SET_SEGMENT (symbolP, absolute_section);
-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
- if (ext)
- S_SET_EXTERNAL (symbolP);
- else
- S_CLEAR_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */
S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
- if (exp.X_op != O_constant)
- symbol_set_frag (symbolP, &zero_address_frag);
+ set_zero_frag (symbolP);
break;
case O_register:
S_SET_SEGMENT (symbolP, reg_section);
S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
- symbol_set_frag (symbolP, &zero_address_frag);
+ set_zero_frag (symbolP);
break;
case O_symbol:
- if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
- || exp.X_add_number != 0)
- symbol_set_value_expression (symbolP, &exp);
- else if (symbol_section_p (symbolP))
- as_bad ("attempt to set value of section symbol");
- else
+ seg = S_GET_SEGMENT (exp.X_add_symbol);
+ /* For x=undef+const, create an expression symbol.
+ For x=x+const, just update x except when x is an undefined symbol
+ For x=defined+const, evaluate x. */
+ if (symbolP == exp.X_add_symbol
+ && (seg != undefined_section
+ || !symbol_constant_p (symbolP)))
+ {
+ *symbol_X_add_number (symbolP) += exp.X_add_number;
+ break;
+ }
+ else if (seg != undefined_section)
{
symbolS *s = exp.X_add_symbol;
- S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
- if (ext)
- S_SET_EXTERNAL (symbolP);
- else
- S_CLEAR_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */
- S_SET_VALUE (symbolP,
- exp.X_add_number + S_GET_VALUE (s));
+ if (S_IS_COMMON (s))
+ as_bad (_("`%s' can't be equated to common symbol '%s'"),
+ S_GET_NAME (symbolP), S_GET_NAME (s));
+
+ S_SET_SEGMENT (symbolP, seg);
+ S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
symbol_set_frag (symbolP, symbol_get_frag (s));
copy_symbol_attributes (symbolP, s);
+ break;
}
- break;
+ /* Fall thru */
default:
/* The value is some complex expression.
- FIXME: Should we set the segment to anything? */
+ Set segment and frag back to that of a newly created symbol. */
+ S_SET_SEGMENT (symbolP, undefined_section);
symbol_set_value_expression (symbolP, &exp);
+ set_zero_frag (symbolP);
break;
}
+
+#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
+ if (ext)
+ S_SET_EXTERNAL (symbolP);
+ else
+ S_CLEAR_EXTERNAL (symbolP);
+#endif /* OBJ_AOUT or OBJ_BOUT */
}
\f
/* cons()
return;
}
+#ifdef TC_ADDRESS_BYTES
+ if (nbytes == 0)
+ nbytes = TC_ADDRESS_BYTES ();
+#endif
+
#ifdef md_cons_align
md_cons_align (nbytes);
#endif
pass to md_number_to_chars, handle it as a bignum. */
if (op == O_constant && nbytes > sizeof (valueT))
{
- valueT val;
- int gencnt;
-
- if (!exp->X_unsigned && exp->X_add_number < 0)
- extra_digit = (valueT) -1;
- val = (valueT) exp->X_add_number;
- gencnt = 0;
- do
- {
- generic_bignum[gencnt] = val & LITTLENUM_MASK;
- val >>= LITTLENUM_NUMBER_OF_BITS;
- ++gencnt;
- }
- while (val != 0);
- op = exp->X_op = O_big;
- exp->X_add_number = gencnt;
+ extra_digit = exp->X_unsigned ? 0 : -1;
+ convert_to_bignum (exp);
+ op = O_big;
}
if (op == O_constant)
unsigned byte;
/* Strip leading sign extensions off the bignum. */
- while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
+ while (size > 1
+ && bignum[size - 1] == LITTLENUM_MASK
+ && bignum[size - 2] > LITTLENUM_MASK / 2)
size--;
do
{
- if (loaded < 7 && size > 0)
- {
- val |= (*bignum << loaded);
- loaded += 8 * CHARS_PER_LITTLENUM;
- size--;
- bignum++;
- }
+ /* OR in the next part of the littlenum. */
+ val |= (*bignum << loaded);
+ loaded += LITTLENUM_NUMBER_OF_BITS;
+ size--;
+ bignum++;
- byte = val & 0x7f;
- loaded -= 7;
- val >>= 7;
-
- if (size == 0)
+ /* Add bytes until there are less than 7 bits left in VAL
+ or until every non-sign bit has been written. */
+ do
{
- if ((val == 0 && (byte & 0x40) == 0)
- || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
- && (byte & 0x40) != 0))
+ byte = val & 0x7f;
+ loaded -= 7;
+ val >>= 7;
+ if (size > 0
+ || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
byte |= 0x80;
+
+ if (orig)
+ *p = byte;
+ p++;
}
+ while ((byte & 0x80) != 0 && loaded >= 7);
+ }
+ while (size > 0);
+ /* Mop up any left-over bits (of which there will be less than 7). */
+ if ((byte & 0x80) != 0)
+ {
+ /* Sign-extend VAL. */
+ if (val & (1 << (loaded - 1)))
+ val |= ~0 << loaded;
if (orig)
- *p = byte;
+ *p = val & 0x7f;
p++;
}
- while (byte & 0x80);
return p - orig;
}
/* Generate the appropriate fragments for a given expression to emit a
leb128 value. */
-void
+static void
emit_leb128_expr (expressionS *exp, int sign)
{
operatorT op = exp->X_op;
- int nbytes;
+ unsigned int nbytes;
if (op == O_absent || op == O_illegal)
{
as_warn (_("register value used as expression"));
op = O_constant;
}
+ else if (op == O_constant
+ && sign
+ && (exp->X_add_number < 0) != !exp->X_unsigned)
+ {
+ /* 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);
+ op = O_big;
+ }
/* Let check_eh_frame know that data is being emitted. nbytes == -1 is
a signal that this is leb128 data. It shouldn't optimize this away. */
- nbytes = -1;
+ nbytes = (unsigned int) -1;
if (check_eh_frame (exp, &nbytes))
abort ();
return (retval);
}
-offsetT
-get_absolute_expr (expressionS *exp)
-{
- expression (exp);
- if (exp->X_op != O_constant)
- {
- if (exp->X_op != O_absent)
- as_bad (_("bad or irreducible absolute expression"));
- exp->X_add_number = 0;
- }
- return exp->X_add_number;
-}
-
-offsetT
-get_absolute_expression (void)
-{
- expressionS exp;
-
- return get_absolute_expr (&exp);
-}
-
char /* Return terminator. */
get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
{
void
equals (char *sym_name, int reassign)
{
- register symbolS *symbolP; /* Symbol we are working with. */
char *stop = NULL;
char stopc;
if (flag_mri)
stop = mri_comment_field (&stopc);
- if (sym_name[0] == '.' && sym_name[1] == '\0')
- {
- /* Turn '. = mumble' into a .org mumble. */
- register segT segment;
- expressionS exp;
-
- segment = get_known_segmented_expression (&exp);
- if (!need_pass_2)
- do_org (segment, &exp, 0);
- }
- else
- {
-#ifdef OBJ_COFF
- int local;
-
- symbolP = symbol_find (sym_name);
- local = symbolP == NULL;
- if (local)
-#endif /* OBJ_COFF */
- symbolP = symbol_find_or_make (sym_name);
- /* Permit register names to be redefined. */
- if (!reassign
- && S_IS_DEFINED (symbolP)
- && S_GET_SEGMENT (symbolP) != reg_section)
- as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
-
-#ifdef OBJ_COFF
- /* "set" symbols are local unless otherwise specified. */
- if (local)
- SF_SET_LOCAL (symbolP);
-#endif /* OBJ_COFF */
-
- pseudo_set (symbolP);
- }
+ assign_symbol (sym_name, !reassign);
if (flag_mri)
{
- /* Check garbage after the expression. */
demand_empty_rest_of_line ();
mri_comment_end (stop, stopc);
}
}
file_len = ftell (binfile);
- /* If a count was not specified use the size of the file. */
+ /* If a count was not specified use the remainder of the file. */
if (count == 0)
- count = file_len;
+ count = file_len - skip;
- if (skip + count > file_len)
+ if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
{
- as_bad (_("skip (%ld) + count (%ld) larger than file size (%ld)"),
+ as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
skip, count, file_len);
goto done;
}
/* Subroutine of s_func so targets can choose a different default prefix.
If DEFAULT_PREFIX is NULL, use the target's "leading char". */
-void
+static void
do_s_func (int end_p, const char *default_prefix)
{
/* Record the current function so that we can issue an error message for
void
s_ignore (int arg ATTRIBUTE_UNUSED)
{
- while (!is_end_of_line[(unsigned char) *input_line_pointer])
- {
- ++input_line_pointer;
- }
- ++input_line_pointer;
+ ignore_rest_of_line ();
}
void
input_scrub_include_file (path, input_line_pointer);
buffer_limit = input_scrub_next_buffer (&input_line_pointer);
}
+
+/* Find the end of a line, considering quotation and escaping of quotes. */
+
+#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
+# define TC_SINGLE_QUOTE_STRINGS 1
+#endif
+
+static char *
+_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
+{
+ char inquote = '\0';
+ int inescape = 0;
+
+ while (!is_end_of_line[(unsigned char) *s]
+ || (inquote && !ISCNTRL (*s))
+ || (inquote == '\'' && flag_mri)
+#ifdef TC_EOL_IN_INSN
+ || (insn && TC_EOL_IN_INSN (s))
+#endif
+ )
+ {
+ if (mri_string && *s == '\'')
+ inquote ^= *s;
+ else if (inescape)
+ inescape = 0;
+ else if (*s == '\\')
+ inescape = 1;
+ else if (!inquote
+ ? *s == '"'
+#ifdef TC_SINGLE_QUOTE_STRINGS
+ || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
+#endif
+ : *s == inquote)
+ inquote ^= *s;
+ ++s;
+ }
+ if (inquote)
+ as_warn (_("missing closing `%c'"), inquote);
+ if (inescape)
+ as_warn (_("stray `\\'"));
+ return s;
+}
+
+char *
+find_end_of_line (char *s, int mri_string)
+{
+ return _find_end_of_line (s, mri_string, 0);
+}
projects / deliverable / binutils-gdb.git / blobdiff