static void
s_atmp ()
{
register int temp;
if (strncmp (input_line_pointer, "sp", 2) == 0)
{
input_line_pointer += 2;
atmp = 2;
}
else if (strncmp (input_line_pointer, "fp", 2) == 0)
{
input_line_pointer += 2;
atmp = 3;
}
else if (strncmp (input_line_pointer, "r", 1) == 0)
{
input_line_pointer += 1;
temp = get_absolute_expression ();
if (temp >= 0 && temp <= 31)
atmp = temp;
else
as_bad ("Unknown temporary pseudo register");
}
else
{
as_bad ("Unknown temporary pseudo register");
}
demand_empty_rest_of_line ();
}
char *
dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
{
offsetT num;
char *filename;
int filename_len;
/* Continue to accept a bare string and pass it off. */
SKIP_WHITESPACE ();
if (*input_line_pointer == '"')
{
s_app_file (0);
return NULL;
}
num = get_absolute_expression ();
filename = demand_copy_C_string (&filename_len);
demand_empty_rest_of_line ();
if (num < 1)
{
as_bad (_("file number less than one"));
return NULL;
}
if (num < (int) files_in_use && files[num].filename != 0)
{
as_bad (_("file number %ld already allocated"), (long) num);
return NULL;
}
get_filenum (filename, num);
return filename;
}
static int
i386_intel_simplify_register (expressionS *e)
{
int reg_num;
if (this_operand < 0 || intel_state.in_offset)
{
as_bad (_("invalid use of register"));
return 0;
}
if (e->X_op == O_register)
reg_num = e->X_add_number;
else
reg_num = e->X_md - 1;
if (!intel_state.in_bracket)
{
if (i.op[this_operand].regs)
{
as_bad (_("invalid use of register"));
return 0;
}
if (i386_regtab[reg_num].reg_type.bitfield.sreg3
&& i386_regtab[reg_num].reg_num == RegFlat)
{
as_bad (_("invalid use of pseudo-register"));
return 0;
}
i.op[this_operand].regs = i386_regtab + reg_num;
}
else if (!intel_state.index
&& (i386_regtab[reg_num].reg_type.bitfield.regxmm
|| i386_regtab[reg_num].reg_type.bitfield.regymm
|| i386_regtab[reg_num].reg_type.bitfield.regzmm))
intel_state.index = i386_regtab + reg_num;
else if (!intel_state.base && !intel_state.in_scale)
intel_state.base = i386_regtab + reg_num;
else if (!intel_state.index)
{
if (intel_state.in_scale
|| current_templates->start->base_opcode == 0xf30f1b /* bndmk */
|| (current_templates->start->base_opcode & ~1) == 0x0f1a /* bnd{ld,st}x */
|| i386_regtab[reg_num].reg_type.bitfield.baseindex)
intel_state.index = i386_regtab + reg_num;
else
{
/* Convert base to index and make ESP/RSP the base. */
intel_state.index = intel_state.base;
intel_state.base = i386_regtab + reg_num;
}
}
else
{
/* esp is invalid as index */
intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM;
}
return 2;
}
symbolS *
make_expr_symbol (expressionS *expressionP)
{
#ifdef NOTYET
expressionS zero;
#endif
symbolS *symbolP;
#ifdef NOTYET
struct expr_symbol_line *n;
#endif
if (expressionP->X_op == O_symbol
&& expressionP->X_add_number == 0)
return expressionP->X_add_symbol;
#ifndef NOTYET
abort ();
#else
if (expressionP->X_op == O_big)
{
/* This won't work, because the actual value is stored in
generic_floating_point_number or generic_bignum, and we are
going to lose it if we haven't already. */
if (expressionP->X_add_number > 0)
as_bad (_("bignum invalid"));
else
as_bad (_("floating point number invalid"));
zero.X_op = O_constant;
zero.X_add_number = 0;
zero.X_unsigned = 0;
clean_up_expression (&zero);
expressionP = &zero;
}
/* Putting constant symbols in absolute_section rather than
expr_section is convenient for the old a.out code, for which
S_GET_SEGMENT does not always retrieve the value put in by
S_SET_SEGMENT. */
symbolP = symbol_create (FAKE_LABEL_NAME,
(expressionP->X_op == O_constant
? absolute_section
: expr_section),
0, &zero_address_frag);
symbol_set_value_expression (symbolP, expressionP);
if (expressionP->X_op == O_constant)
resolve_symbol_value (symbolP);
n = (struct expr_symbol_line *) xmalloc (sizeof *n);
n->sym = symbolP;
as_where (&n->file, &n->line);
n->next = expr_symbol_lines;
expr_symbol_lines = n;
#endif
return symbolP;
}
static int
parse_register_operand (char **ptr)
{
int reg;
char *s = *ptr;
if (*s != '$')
{
as_bad (_("expecting register"));
ignore_rest_of_line ();
return -1;
}
if (s[1] == 'f' && s[2] == 'p')
{
*ptr += 3;
return 0;
}
if (s[1] == 's' && s[2] == 'p')
{
*ptr += 3;
return 1;
}
if (s[1] == 'r')
{
reg = s[2] - '0';
if ((reg < 0) || (reg > 9))
{
as_bad (_("illegal register number"));
ignore_rest_of_line ();
return -1;
}
if (reg == 1)
{
int r2 = s[3] - '0';
if ((r2 >= 0) && (r2 <= 3))
{
reg = 10 + r2;
*ptr += 1;
}
}
}
else
{
as_bad (_("illegal register number"));
ignore_rest_of_line ();
return -1;
}
*ptr += 3;
return reg + 2;
}
void
dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
{
offsetT filenum, line, column;
filenum = get_absolute_expression ();
SKIP_WHITESPACE ();
line = get_absolute_expression ();
SKIP_WHITESPACE ();
column = get_absolute_expression ();
demand_empty_rest_of_line ();
if (filenum < 1)
{
as_bad (_("file number less than one"));
return;
}
if (filenum >= (int) files_in_use || files[filenum].filename == 0)
{
as_bad (_("unassigned file number %ld"), (long) filenum);
return;
}
current.filenum = filenum;
current.line = line;
current.column = column;
current.flags = DWARF2_FLAG_BEGIN_STMT;
loc_directive_seen = TRUE;
#ifndef NO_LISTING
if (listing)
{
if (files[filenum].dir)
{
size_t dir_len = strlen (dirs[files[filenum].dir]);
size_t file_len = strlen (files[filenum].filename);
char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
memcpy (cp, dirs[files[filenum].dir], dir_len);
cp[dir_len] = '/';
memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
cp[dir_len + file_len + 1] = '\0';
listing_source_file (cp);
}
else
listing_source_file (files[filenum].filename);
listing_source_line (line);
}
#endif
}
static void
frag_alloc_check (const struct obstack *ob)
{
if (ob->chunk_size == 0)
{
as_bad (_("attempt to allocate data in absolute section"));
subseg_set (text_section, 0);
}
if (mri_common_symbol != NULL)
{
as_bad (_("attempt to allocate data in common section"));
mri_common_symbol = NULL;
}
}
static int
parse_regnum(char **ptr)
{
int reg;
char *s = *ptr;
if (*s != '%') {
as_bad(_("not a register: %s"), s);
return -1;
}
s++;
// %fp alias for %14
if (s[0] == 'f' && s[1] == 'p') {
*ptr += 3;
return 14;
}
// %sp alias for %15
if (s[0] == 's' && s[1] == 'p') {
*ptr += 3;
return 15;
}
reg = *s - '0';
if ((reg < 0) || (reg > 9)) {
as_bad(_("illegal register number 1 %s"), s);
ignore_rest_of_line();
return -1;
}
s++;
if ((reg > 0) || (reg < 4)) {
int r2 = *s - '0';
if ((r2 >= 0) && (r2 <= 9)) {
reg = reg*10 + r2;
if (reg > 31) {
as_bad(_("illegal register number %d"), reg);
ignore_rest_of_line();
return -1;
}
*ptr += 1;
}
}
*ptr += 2;
return reg;
}
void
s_endif (int arg ATTRIBUTE_UNUSED)
{
struct conditional_frame *hold;
if (current_cframe == NULL)
{
as_bad (_("\".endif\" without \".if\""));
}
else
{
if (LISTING_SKIP_COND ()
&& current_cframe->ignoring
&& (current_cframe->previous_cframe == NULL
|| ! current_cframe->previous_cframe->ignoring))
listing_list (1);
hold = current_cframe;
current_cframe = current_cframe->previous_cframe;
obstack_free (&cond_obstack, hold);
} /* if one pop too many */
if (flag_mri)
{
while (! is_end_of_line[(unsigned char) *input_line_pointer])
++input_line_pointer;
}
demand_empty_rest_of_line ();
}
char *
input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer. */)
{
char *return_value; /* -> Last char of what we read, + 1. */
register int size;
if (f_in == (FILE *) 0)
return 0;
/* fflush (stdin); could be done here if you want to synchronise
stdin and stdout, for the case where our input file is stdin.
Since the assembler shouldn't do any output to stdout, we
don't bother to synch output and input. */
if (preprocess)
size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
else
size = fread (where, sizeof (char), BUFFER_SIZE, f_in);
if (size < 0)
{
as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
size = 0;
}
if (size)
return_value = where + size;
else
{
if (fclose (f_in))
as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
f_in = (FILE *) 0;
return_value = 0;
}
return return_value;
}
static unsigned
cfi_parse_reg (void)
{
int regno;
expressionS exp;
tc_parse_to_dw2regnum (&exp);
switch (exp.X_op)
{
case O_register:
case O_constant:
regno = exp.X_add_number;
break;
default:
regno = -1;
break;
}
if (regno < 0)
{
as_bad (_("bad register expression"));
regno = 0;
}
return regno;
}
static segT
make_debug_seg (segT cseg, char *name, int sflags)
{
segT save_seg = now_seg;
int save_subseg = now_subseg;
segT r;
flagword flags;
r = subseg_new (name, 0);
/* Check if code segment is marked as linked once. */
if (!cseg)
flags = 0;
else
flags = bfd_get_section_flags (stdoutput, cseg)
& (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
| SEC_LINK_DUPLICATES_SAME_CONTENTS);
/* Add standard section flags. */
flags |= sflags;
/* Apply possibly linked once flags to new generated segment, too. */
if (!bfd_set_section_flags (stdoutput, r, flags))
as_bad (_("bfd_set_section_flags: %s"),
bfd_errmsg (bfd_get_error ()));
/* Restore to previous segment. */
if (save_seg != NULL)
subseg_set (save_seg, save_subseg);
return r;
}
void
s_if (int arg)
{
expressionS operand;
struct conditional_frame cframe;
int t;
char *stop = NULL;
char stopc;
if (flag_mri)
stop = mri_comment_field (&stopc);
/* Leading whitespace is part of operand. */
SKIP_WHITESPACE ();
if (current_cframe != NULL && current_cframe->ignoring)
{
operand.X_add_number = 0;
while (! is_end_of_line[(unsigned char) *input_line_pointer])
++input_line_pointer;
}
else
{
expression (&operand);
if (operand.X_op != O_constant)
as_bad (_("non-constant expression in \".if\" statement"));
}
switch ((operatorT) arg)
{
case O_eq: t = operand.X_add_number == 0; break;
case O_ne: t = operand.X_add_number != 0; break;
case O_lt: t = operand.X_add_number < 0; break;
case O_le: t = operand.X_add_number <= 0; break;
case O_ge: t = operand.X_add_number >= 0; break;
case O_gt: t = operand.X_add_number > 0; break;
default:
abort ();
return;
}
/* If the above error is signaled, this will dispatch
using an undefined result. No big deal. */
initialize_cframe (&cframe);
cframe.ignoring = cframe.dead_tree || ! t;
current_cframe = ((struct conditional_frame *)
obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));
if (LISTING_SKIP_COND ()
&& cframe.ignoring
&& (cframe.previous_cframe == NULL
|| ! cframe.previous_cframe->ignoring))
listing_list (2);
if (flag_mri)
mri_comment_end (stop, stopc);
demand_empty_rest_of_line ();
}
void
s_else (int arg ATTRIBUTE_UNUSED)
{
if (current_cframe == NULL)
{
as_bad (_("\".else\" without matching \".if\""));
}
else if (current_cframe->else_seen)
{
as_bad (_("duplicate \"else\""));
as_bad_where (current_cframe->else_file_line.file,
current_cframe->else_file_line.line,
_("here is the previous \"else\""));
as_bad_where (current_cframe->if_file_line.file,
current_cframe->if_file_line.line,
_("here is the previous \"if\""));
}
else
{
as_where (¤t_cframe->else_file_line.file,
¤t_cframe->else_file_line.line);
current_cframe->ignoring =
current_cframe->dead_tree | !current_cframe->ignoring;
if (LISTING_SKIP_COND ()
&& (current_cframe->previous_cframe == NULL
|| ! current_cframe->previous_cframe->ignoring))
{
if (! current_cframe->ignoring)
listing_list (1);
else
listing_list (2);
}
current_cframe->else_seen = 1;
}
if (flag_mri)
{
while (! is_end_of_line[(unsigned char) *input_line_pointer])
++input_line_pointer;
}
demand_empty_rest_of_line ();
}
static
void
got_sig(
int sig)
{
as_bad("Interrupted by signal %d",sig);
exit(1);
}
void
cond_finish_check (int nest)
{
if (current_cframe != NULL && current_cframe->macro_nest >= nest)
{
if (nest >= 0)
as_bad (_("end of macro inside conditional"));
else
as_bad (_("end of file inside conditional"));
as_bad_where (current_cframe->if_file_line.file,
current_cframe->if_file_line.line,
_("here is the start of the unterminated conditional"));
if (current_cframe->else_seen)
as_bad_where (current_cframe->else_file_line.file,
current_cframe->else_file_line.line,
_("here is the \"else\" of the unterminated conditional"));
}
}
void
s_ifdef (int test_defined)
{
/* Points to name of symbol. */
char *name;
/* Points to symbol. */
symbolS *symbolP;
struct conditional_frame cframe;
char c;
/* Leading whitespace is part of operand. */
SKIP_WHITESPACE ();
name = input_line_pointer;
if (!is_name_beginner (*name))
{
as_bad (_("invalid identifier for \".ifdef\""));
obstack_1grow (&cond_obstack, 0);
ignore_rest_of_line ();
return;
}
c = get_symbol_end ();
symbolP = symbol_find (name);
*input_line_pointer = c;
initialize_cframe (&cframe);
if (cframe.dead_tree)
cframe.ignoring = 1;
else
{
int is_defined;
/* Use the same definition of 'defined' as .equiv so that a symbol
which has been referenced but not yet given a value/address is
considered to be undefined. */
is_defined =
symbolP != NULL
&& S_IS_DEFINED (symbolP)
&& S_GET_SEGMENT (symbolP) != reg_section;
cframe.ignoring = ! (test_defined ^ is_defined);
}
current_cframe = ((struct conditional_frame *)
obstack_copy (&cond_obstack, &cframe,
sizeof (cframe)));
if (LISTING_SKIP_COND ()
&& cframe.ignoring
&& (cframe.previous_cframe == NULL
|| ! cframe.previous_cframe->ignoring))
listing_list (2);
demand_empty_rest_of_line ();
}
static void
cfi_parse_separator (void)
{
SKIP_WHITESPACE ();
if (*input_line_pointer == ',')
input_line_pointer++;
else
as_bad (_("missing separator"));
}
static unsigned
cfi_parse_reg (void)
{
int regno;
expressionS exp;
#ifdef tc_regname_to_dw2regnum
SKIP_WHITESPACE ();
if (is_name_beginner (*input_line_pointer)
|| (*input_line_pointer == '%'
&& is_name_beginner (*++input_line_pointer)))
{
char *name, c;
name = input_line_pointer;
c = get_symbol_end ();
if ((regno = tc_regname_to_dw2regnum (name)) < 0)
{
as_bad (_("bad register expression"));
regno = 0;
}
*input_line_pointer = c;
return regno;
}
#endif
expression_and_evaluate (&exp);
switch (exp.X_op)
{
case O_register:
case O_constant:
regno = exp.X_add_number;
break;
default:
as_bad (_("bad register expression"));
regno = 0;
break;
}
return regno;
}
static char *
checkfor (char *ptr, char what)
{
if (*ptr == what)
ptr++;
else
as_bad (_("expected %c"), what);
return ptr;
}
static void
regword (int mode, const char *string)
{
int ok;
ok = CLASS_REG_WORD;
if (ok != mode)
{
as_bad (_("register is wrong size for a word %s"), string);
}
}
static void
regaddr (int mode, const char *string)
{
int ok;
ok = segmented_mode ? CLASS_REG_LONG : CLASS_REG_WORD;
if (ok != mode)
{
as_bad (_("register is wrong size for address %s"), string);
}
}
char *
dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
{
offsetT num;
char *filename;
int filename_len;
/* Continue to accept a bare string and pass it off. */
SKIP_WHITESPACE ();
if (*input_line_pointer == '"')
{
s_app_file (0);
return NULL;
}
num = get_absolute_expression ();
filename = demand_copy_C_string (&filename_len);
if (filename == NULL)
return NULL;
demand_empty_rest_of_line ();
if (num < 1)
{
as_bad (_("file number less than one"));
return NULL;
}
/* A .file directive implies compiler generated debug information is
being supplied. Turn off gas generated debug info. */
debug_type = DEBUG_NONE;
if (num < (int) files_in_use && files[num].filename != 0)
{
as_bad (_("file number %ld already allocated"), (long) num);
return NULL;
}
get_filenum (filename, num);
return filename;
}
void
cfi_add_CFA_offset (unsigned regno, offsetT offset)
{
unsigned int abs_data_align;
cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
if (offset % abs_data_align)
as_bad (_("register save offset not a multiple of %u"), abs_data_align);
}
static INLINE int i386_intel_check (const reg_entry *reg,
const reg_entry *base,
const reg_entry *index)
{
if ((this_operand >= 0 && reg != i.op[this_operand].regs)
|| base != intel_state.base || index != intel_state.index)
{
as_bad (_("invalid use of register"));
return 0;
}
return 1;
}
static void
scale_addr_delta (addressT *addr_delta)
{
static int printed_this = 0;
if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
{
if (!printed_this)
as_bad("unaligned opcodes detected in executable segment");
printed_this = 1;
}
*addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
}
void
md_operand (expressionS *op)
{
if (strncmp (input_line_pointer, "%hi16", 5) == 0)
{
if (pending_reloc)
as_bad (_("confusing relocation expressions"));
pending_reloc = BFD_RELOC_PJ_CODE_HI16;
input_line_pointer += 5;
expression (op);
}
if (strncmp (input_line_pointer, "%lo16", 5) == 0)
{
if (pending_reloc)
as_bad (_("confusing relocation expressions"));
pending_reloc = BFD_RELOC_PJ_CODE_LO16;
input_line_pointer += 5;
expression (op);
}
}
static size_t
input_file_get (char *buf, size_t buflen)
{
size_t size;
if (feof (f_in))
return 0;
size = fread (buf, sizeof (char), buflen, f_in);
if (ferror (f_in))
as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
return size;
}
static int
input_file_get (char *buf, int buflen)
{
int size;
size = fread (buf, sizeof (char), buflen, f_in);
if (size < 0)
{
as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
size = 0;
}
return size;
}
static void
dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
{
if (frchain_now->frch_cfi_data == NULL)
{
as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
ignore_rest_of_line ();
return;
}
cfi_end_fde (symbol_temp_new_now ());
demand_empty_rest_of_line ();
}
