1991-04-04 18:19:53 +00:00
|
|
|
|
/* tc-sparc.c -- Assemble for the SPARC
|
1992-02-15 21:09:34 +00:00
|
|
|
|
Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
This file is part of GAS, the GNU Assembler.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
GAS is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
1991-06-20 21:47:57 +00:00
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
1991-04-04 18:19:53 +00:00
|
|
|
|
any later version.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
GAS is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <ctype.h>
|
|
|
|
|
|
|
|
|
|
#include "as.h"
|
1994-03-31 21:54:06 +00:00
|
|
|
|
#include "subsegs.h"
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* careful, this file includes data *declarations* */
|
1992-01-28 20:38:08 +00:00
|
|
|
|
#include "opcode/sparc.h"
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1993-10-21 19:50:57 +00:00
|
|
|
|
static void sparc_ip PARAMS ((char *));
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1994-07-28 23:36:16 +00:00
|
|
|
|
#ifdef sparcv9
|
|
|
|
|
static enum sparc_architecture current_architecture = v9;
|
|
|
|
|
#else
|
1991-05-22 01:18:42 +00:00
|
|
|
|
static enum sparc_architecture current_architecture = v6;
|
1994-07-28 23:36:16 +00:00
|
|
|
|
#endif
|
1993-02-24 11:24:14 +00:00
|
|
|
|
static int architecture_requested;
|
|
|
|
|
static int warn_on_bump;
|
1991-05-22 01:18:42 +00:00
|
|
|
|
|
1993-06-25 09:51:47 +00:00
|
|
|
|
extern int target_big_endian;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
const relax_typeS md_relax_table[1];
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* handle of the OPCODE hash table */
|
1994-07-28 23:36:16 +00:00
|
|
|
|
static struct hash_control *op_hash;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1993-10-21 19:50:57 +00:00
|
|
|
|
static void s_data1 PARAMS ((void));
|
|
|
|
|
static void s_seg PARAMS ((int));
|
|
|
|
|
static void s_proc PARAMS ((int));
|
|
|
|
|
static void s_reserve PARAMS ((int));
|
|
|
|
|
static void s_common PARAMS ((int));
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
const pseudo_typeS md_pseudo_table[] =
|
|
|
|
|
{
|
|
|
|
|
{"align", s_align_bytes, 0}, /* Defaulting is invalid (0) */
|
|
|
|
|
{"common", s_common, 0},
|
|
|
|
|
{"global", s_globl, 0},
|
|
|
|
|
{"half", cons, 2},
|
|
|
|
|
{"optim", s_ignore, 0},
|
|
|
|
|
{"proc", s_proc, 0},
|
|
|
|
|
{"reserve", s_reserve, 0},
|
|
|
|
|
{"seg", s_seg, 0},
|
|
|
|
|
{"skip", s_space, 0},
|
|
|
|
|
{"word", cons, 4},
|
1993-02-24 11:24:14 +00:00
|
|
|
|
#ifndef NO_V9
|
1993-10-21 19:50:57 +00:00
|
|
|
|
{"xword", cons, 8},
|
1993-08-06 16:10:40 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
{"uaxword", cons, 8},
|
|
|
|
|
#endif
|
1993-02-24 11:24:14 +00:00
|
|
|
|
#endif
|
1993-08-04 23:10:43 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
/* these are specific to sparc/svr4 */
|
|
|
|
|
{"pushsection", obj_elf_section, 0},
|
|
|
|
|
{"popsection", obj_elf_previous, 0},
|
|
|
|
|
{"uaword", cons, 4},
|
|
|
|
|
{"uahalf", cons, 2},
|
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{NULL, 0, 0},
|
1991-04-04 18:19:53 +00:00
|
|
|
|
};
|
|
|
|
|
|
1991-05-22 01:18:42 +00:00
|
|
|
|
const int md_short_jump_size = 4;
|
|
|
|
|
const int md_long_jump_size = 4;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
const int md_reloc_size = 12; /* Size of relocation record */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* This array holds the chars that always start a comment. If the
|
|
|
|
|
pre-processor is disabled, these aren't very useful */
|
1991-05-22 01:18:42 +00:00
|
|
|
|
const char comment_chars[] = "!"; /* JF removed '|' from comment_chars */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* This array holds the chars that only start a comment at the beginning of
|
|
|
|
|
a line. If the line seems to have the form '# 123 filename'
|
|
|
|
|
.line and .file directives will appear in the pre-processed output */
|
|
|
|
|
/* Note that input_file.c hand checks for '#' at the beginning of the
|
|
|
|
|
first line of the input file. This is because the compiler outputs
|
|
|
|
|
#NO_APP at the beginning of its output. */
|
1991-05-22 01:18:42 +00:00
|
|
|
|
/* Also note that comments started like this one will always
|
|
|
|
|
work if '/' isn't otherwise defined. */
|
|
|
|
|
const char line_comment_chars[] = "#";
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
const char line_separator_chars[] = "";
|
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
/* Chars that can be used to separate mant from exp in floating point nums */
|
1991-05-22 01:18:42 +00:00
|
|
|
|
const char EXP_CHARS[] = "eE";
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Chars that mean this number is a floating point constant */
|
|
|
|
|
/* As in 0f12.456 */
|
|
|
|
|
/* or 0d1.2345e12 */
|
1991-05-22 01:18:42 +00:00
|
|
|
|
const char FLT_CHARS[] = "rRsSfFdDxXpP";
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
|
1993-10-25 17:45:17 +00:00
|
|
|
|
changed in read.c. Ideally it shouldn't have to know about it at all,
|
|
|
|
|
but nothing is ideal around here. */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
static unsigned char octal[256];
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#define isoctal(c) octal[(unsigned char) (c)]
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static unsigned char toHex[256];
|
|
|
|
|
|
|
|
|
|
struct sparc_it
|
|
|
|
|
{
|
|
|
|
|
char *error;
|
|
|
|
|
unsigned long opcode;
|
|
|
|
|
struct nlist *nlistp;
|
|
|
|
|
expressionS exp;
|
|
|
|
|
int pcrel;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
bfd_reloc_code_real_type reloc;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct sparc_it the_insn, set_insn;
|
|
|
|
|
|
1994-03-31 21:54:06 +00:00
|
|
|
|
static INLINE int
|
|
|
|
|
in_signed_range (val, max)
|
|
|
|
|
bfd_signed_vma val, max;
|
|
|
|
|
{
|
|
|
|
|
if (max <= 0)
|
|
|
|
|
abort ();
|
|
|
|
|
if (val > max)
|
|
|
|
|
return 0;
|
|
|
|
|
if (val < ~max)
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
#if 0
|
1993-02-24 11:24:14 +00:00
|
|
|
|
static void print_insn PARAMS ((struct sparc_it *insn));
|
1991-04-04 18:19:53 +00:00
|
|
|
|
#endif
|
1993-02-24 11:24:14 +00:00
|
|
|
|
static int getExpression PARAMS ((char *str));
|
1992-02-15 21:09:34 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
static char *expr_end;
|
|
|
|
|
static int special_case;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Instructions that require wierd handling because they're longer than
|
|
|
|
|
* 4 bytes.
|
|
|
|
|
*/
|
|
|
|
|
#define SPECIAL_CASE_SET 1
|
|
|
|
|
#define SPECIAL_CASE_FDIV 2
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* sort of like s_lcomm
|
|
|
|
|
*
|
|
|
|
|
*/
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#ifndef OBJ_ELF
|
1992-01-28 20:38:08 +00:00
|
|
|
|
static int max_alignment = 15;
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#endif
|
1992-01-28 20:38:08 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static void
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_reserve (ignore)
|
|
|
|
|
int ignore;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
char *name;
|
|
|
|
|
char *p;
|
|
|
|
|
char c;
|
|
|
|
|
int align;
|
|
|
|
|
int size;
|
|
|
|
|
int temp;
|
|
|
|
|
symbolS *symbolP;
|
|
|
|
|
|
|
|
|
|
name = input_line_pointer;
|
|
|
|
|
c = get_symbol_end ();
|
|
|
|
|
p = input_line_pointer;
|
|
|
|
|
*p = c;
|
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
|
|
|
|
|
|
if (*input_line_pointer != ',')
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Expected comma after name");
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
++input_line_pointer;
|
|
|
|
|
|
|
|
|
|
if ((size = get_absolute_expression ()) < 0)
|
|
|
|
|
{
|
|
|
|
|
as_bad ("BSS length (%d.) <0! Ignored.", size);
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
} /* bad length */
|
|
|
|
|
|
|
|
|
|
*p = 0;
|
|
|
|
|
symbolP = symbol_find_or_make (name);
|
|
|
|
|
*p = c;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (strncmp (input_line_pointer, ",\"bss\"", 6) != 0
|
|
|
|
|
&& strncmp (input_line_pointer, ",\".bss\"", 7) != 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1994-07-28 23:36:16 +00:00
|
|
|
|
as_bad ("bad .reserve segment -- expected BSS segment");
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
1993-10-25 17:45:17 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (input_line_pointer[2] == '.')
|
|
|
|
|
input_line_pointer += 7;
|
|
|
|
|
else
|
|
|
|
|
input_line_pointer += 6;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
|
|
|
|
|
|
if (*input_line_pointer == ',')
|
|
|
|
|
{
|
|
|
|
|
++input_line_pointer;
|
|
|
|
|
|
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
|
if (*input_line_pointer == '\n')
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Missing alignment");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
align = get_absolute_expression ();
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#ifndef OBJ_ELF
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (align > max_alignment)
|
|
|
|
|
{
|
|
|
|
|
align = max_alignment;
|
|
|
|
|
as_warn ("Alignment too large: %d. assumed.", align);
|
|
|
|
|
}
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#endif
|
|
|
|
|
if (align < 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
align = 0;
|
|
|
|
|
as_warn ("Alignment negative. 0 assumed.");
|
1991-04-04 18:19:53 +00:00
|
|
|
|
}
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
|
|
|
|
record_alignment (bss_section, align);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
/* convert to a power of 2 alignment */
|
|
|
|
|
for (temp = 0; (align & 1) == 0; align >>= 1, ++temp);;
|
|
|
|
|
|
|
|
|
|
if (align != 1)
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Alignment not a power of 2");
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
} /* not a power of two */
|
|
|
|
|
|
|
|
|
|
align = temp;
|
|
|
|
|
} /* if has optional alignment */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
else
|
|
|
|
|
align = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if ((S_GET_SEGMENT (symbolP) == bss_section
|
|
|
|
|
|| !S_IS_DEFINED (symbolP))
|
|
|
|
|
#ifdef OBJ_AOUT
|
|
|
|
|
&& S_GET_OTHER (symbolP) == 0
|
1992-11-23 20:42:33 +00:00
|
|
|
|
&& S_GET_DESC (symbolP) == 0
|
1993-07-07 16:58:29 +00:00
|
|
|
|
#endif
|
|
|
|
|
)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
if (! need_pass_2)
|
|
|
|
|
{
|
1993-10-21 19:50:57 +00:00
|
|
|
|
char *pfrag;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
segT current_seg = now_seg;
|
|
|
|
|
subsegT current_subseg = now_subseg;
|
|
|
|
|
|
|
|
|
|
subseg_set (bss_section, 1); /* switch to bss */
|
|
|
|
|
|
|
|
|
|
if (align)
|
|
|
|
|
frag_align (align, 0); /* do alignment */
|
|
|
|
|
|
|
|
|
|
/* detach from old frag */
|
|
|
|
|
if (S_GET_SEGMENT(symbolP) == bss_section)
|
|
|
|
|
symbolP->sy_frag->fr_symbol = NULL;
|
|
|
|
|
|
|
|
|
|
symbolP->sy_frag = frag_now;
|
1993-10-21 19:50:57 +00:00
|
|
|
|
pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
|
|
|
|
|
size, (char *)0);
|
|
|
|
|
*pfrag = 0;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
|
|
|
|
S_SET_SEGMENT (symbolP, bss_section);
|
|
|
|
|
|
|
|
|
|
subseg_set (current_seg, current_subseg);
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
as_warn("Ignoring attempt to re-define symbol %s.", name);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
} /* if not redefining */
|
|
|
|
|
|
|
|
|
|
demand_empty_rest_of_line ();
|
1993-02-24 11:24:14 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
static void
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_common (ignore)
|
|
|
|
|
int ignore;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
char *name;
|
|
|
|
|
char c;
|
|
|
|
|
char *p;
|
|
|
|
|
int temp, size;
|
|
|
|
|
symbolS *symbolP;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
name = input_line_pointer;
|
|
|
|
|
c = get_symbol_end ();
|
|
|
|
|
/* just after name is now '\0' */
|
|
|
|
|
p = input_line_pointer;
|
|
|
|
|
*p = c;
|
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
|
if (*input_line_pointer != ',')
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Expected comma after symbol-name");
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
input_line_pointer++; /* skip ',' */
|
|
|
|
|
if ((temp = get_absolute_expression ()) < 0)
|
|
|
|
|
{
|
|
|
|
|
as_bad (".COMMon length (%d.) <0! Ignored.", temp);
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
1993-06-25 09:51:47 +00:00
|
|
|
|
size = temp;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
*p = 0;
|
|
|
|
|
symbolP = symbol_find_or_make (name);
|
|
|
|
|
*p = c;
|
|
|
|
|
if (S_IS_DEFINED (symbolP))
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Ignoring attempt to re-define symbol");
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (S_GET_VALUE (symbolP) != 0)
|
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
if (S_GET_VALUE (symbolP) != size)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
as_warn ("Length of .comm \"%s\" is already %ld. Not changed to %d.",
|
|
|
|
|
S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
|
1992-08-01 23:20:55 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
#ifndef OBJ_ELF
|
1993-10-21 19:50:57 +00:00
|
|
|
|
S_SET_VALUE (symbolP, (valueT) size);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
S_SET_EXTERNAL (symbolP);
|
1993-02-24 11:24:14 +00:00
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
know (symbolP->sy_frag == &zero_address_frag);
|
1993-02-24 11:24:14 +00:00
|
|
|
|
if (*input_line_pointer != ',')
|
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
as_bad ("Expected comma after common length");
|
1993-02-24 11:24:14 +00:00
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
input_line_pointer++;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
|
if (*input_line_pointer != '"')
|
1993-06-25 09:51:47 +00:00
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
temp = get_absolute_expression ();
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#ifndef OBJ_ELF
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (temp > max_alignment)
|
|
|
|
|
{
|
|
|
|
|
temp = max_alignment;
|
|
|
|
|
as_warn ("Common alignment too large: %d. assumed", temp);
|
|
|
|
|
}
|
1993-09-10 16:01:07 +00:00
|
|
|
|
#endif
|
|
|
|
|
if (temp < 0)
|
1993-07-07 16:58:29 +00:00
|
|
|
|
{
|
|
|
|
|
temp = 0;
|
|
|
|
|
as_warn ("Common alignment negative; 0 assumed");
|
|
|
|
|
}
|
1993-07-08 19:09:19 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (symbolP->local)
|
|
|
|
|
{
|
1993-07-08 18:40:50 +00:00
|
|
|
|
segT old_sec;
|
|
|
|
|
int old_subsec;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
char *p;
|
1993-07-08 18:40:50 +00:00
|
|
|
|
int align;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
|
1993-07-08 18:40:50 +00:00
|
|
|
|
allocate_bss:
|
|
|
|
|
old_sec = now_seg;
|
|
|
|
|
old_subsec = now_subseg;
|
|
|
|
|
align = temp;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
record_alignment (bss_section, align);
|
|
|
|
|
subseg_set (bss_section, 0);
|
|
|
|
|
if (align)
|
|
|
|
|
frag_align (align, 0);
|
|
|
|
|
if (S_GET_SEGMENT (symbolP) == bss_section)
|
|
|
|
|
symbolP->sy_frag->fr_symbol = 0;
|
|
|
|
|
symbolP->sy_frag = frag_now;
|
|
|
|
|
p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
|
|
|
|
|
(char *) 0);
|
|
|
|
|
*p = 0;
|
|
|
|
|
S_SET_SEGMENT (symbolP, bss_section);
|
|
|
|
|
S_CLEAR_EXTERNAL (symbolP);
|
|
|
|
|
subseg_set (old_sec, old_subsec);
|
|
|
|
|
}
|
|
|
|
|
else
|
1993-07-08 19:09:19 +00:00
|
|
|
|
#endif
|
1993-07-07 16:58:29 +00:00
|
|
|
|
{
|
1993-07-08 18:40:50 +00:00
|
|
|
|
allocate_common:
|
1993-10-21 19:50:57 +00:00
|
|
|
|
S_SET_VALUE (symbolP, (valueT) size);
|
1994-07-28 23:36:16 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
S_SET_ALIGN (symbolP, temp);
|
|
|
|
|
#endif
|
1993-07-07 16:58:29 +00:00
|
|
|
|
S_SET_EXTERNAL (symbolP);
|
|
|
|
|
/* should be common, but this is how gas does it for now */
|
1994-07-28 23:36:16 +00:00
|
|
|
|
S_SET_SEGMENT (symbolP, bfd_und_section_ptr);
|
1993-07-07 16:58:29 +00:00
|
|
|
|
}
|
1993-06-25 09:51:47 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
input_line_pointer++;
|
1993-07-08 18:40:50 +00:00
|
|
|
|
/* @@ Some use the dot, some don't. Can we get some consistency?? */
|
|
|
|
|
if (*input_line_pointer == '.')
|
|
|
|
|
input_line_pointer++;
|
|
|
|
|
/* @@ Some say data, some say bss. */
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (strncmp (input_line_pointer, "bss\"", 4)
|
1993-07-08 18:40:50 +00:00
|
|
|
|
&& strncmp (input_line_pointer, "data\"", 5))
|
1993-07-07 16:58:29 +00:00
|
|
|
|
{
|
1993-07-08 18:40:50 +00:00
|
|
|
|
while (*--input_line_pointer != '"')
|
|
|
|
|
;
|
|
|
|
|
input_line_pointer--;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
goto bad_common_segment;
|
|
|
|
|
}
|
|
|
|
|
while (*input_line_pointer++ != '"')
|
|
|
|
|
;
|
1993-07-08 18:40:50 +00:00
|
|
|
|
goto allocate_common;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
|
return;
|
1993-07-08 18:40:50 +00:00
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
bad_common_segment:
|
|
|
|
|
p = input_line_pointer;
|
|
|
|
|
while (*p && *p != '\n')
|
|
|
|
|
p++;
|
|
|
|
|
c = *p;
|
|
|
|
|
*p = '\0';
|
|
|
|
|
as_bad ("bad .common segment %s", input_line_pointer + 1);
|
|
|
|
|
*p = c;
|
|
|
|
|
input_line_pointer = p;
|
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
static void
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_seg (ignore)
|
|
|
|
|
int ignore;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
|
|
|
|
|
{
|
|
|
|
|
input_line_pointer += 6;
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_text (0);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
|
|
|
|
|
{
|
|
|
|
|
input_line_pointer += 6;
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_data (0);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (strncmp (input_line_pointer, "\"data1\"", 7) == 0)
|
|
|
|
|
{
|
|
|
|
|
input_line_pointer += 7;
|
|
|
|
|
s_data1 ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (strncmp (input_line_pointer, "\"bss\"", 5) == 0)
|
|
|
|
|
{
|
|
|
|
|
input_line_pointer += 5;
|
|
|
|
|
/* We only support 2 segments -- text and data -- for now, so
|
1993-02-24 11:24:14 +00:00
|
|
|
|
things in the "bss segment" will have to go into data for now.
|
|
|
|
|
You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
|
|
|
|
|
subseg_set (data_section, 255); /* FIXME-SOMEDAY */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
as_bad ("Unknown segment type");
|
|
|
|
|
demand_empty_rest_of_line ();
|
1993-12-16 21:31:22 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
s_data1 ()
|
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
subseg_set (data_section, 1);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
demand_empty_rest_of_line ();
|
1993-12-16 21:31:22 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static void
|
1993-10-21 19:50:57 +00:00
|
|
|
|
s_proc (ignore)
|
|
|
|
|
int ignore;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-09-10 16:01:07 +00:00
|
|
|
|
while (!is_end_of_line[(unsigned char) *input_line_pointer])
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
++input_line_pointer;
|
|
|
|
|
}
|
|
|
|
|
++input_line_pointer;
|
1993-12-16 21:31:22 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#ifndef NO_V9
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
struct priv_reg_entry
|
|
|
|
|
{
|
|
|
|
|
char *name;
|
|
|
|
|
int regnum;
|
|
|
|
|
};
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
1992-08-01 23:20:55 +00:00
|
|
|
|
struct priv_reg_entry priv_reg_table[] =
|
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{"tpc", 0},
|
|
|
|
|
{"tnpc", 1},
|
|
|
|
|
{"tstate", 2},
|
|
|
|
|
{"tt", 3},
|
|
|
|
|
{"tick", 4},
|
|
|
|
|
{"tba", 5},
|
|
|
|
|
{"pstate", 6},
|
|
|
|
|
{"tl", 7},
|
|
|
|
|
{"pil", 8},
|
|
|
|
|
{"cwp", 9},
|
|
|
|
|
{"cansave", 10},
|
|
|
|
|
{"canrestore", 11},
|
|
|
|
|
{"cleanwin", 12},
|
|
|
|
|
{"otherwin", 13},
|
|
|
|
|
{"wstate", 14},
|
1993-07-07 16:58:29 +00:00
|
|
|
|
{"fq", 15},
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{"ver", 31},
|
|
|
|
|
{"", -1}, /* end marker */
|
1992-08-01 23:20:55 +00:00
|
|
|
|
};
|
|
|
|
|
|
1993-06-25 09:51:47 +00:00
|
|
|
|
struct membar_masks
|
|
|
|
|
{
|
|
|
|
|
char *name;
|
1993-10-21 19:50:57 +00:00
|
|
|
|
unsigned int len;
|
|
|
|
|
unsigned int mask;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define MEMBAR_MASKS_SIZE 7
|
|
|
|
|
|
1994-07-28 23:36:16 +00:00
|
|
|
|
static const struct membar_masks membar_masks[MEMBAR_MASKS_SIZE] =
|
1993-06-25 09:51:47 +00:00
|
|
|
|
{
|
|
|
|
|
{"Sync", 4, 0x40},
|
|
|
|
|
{"MemIssue", 8, 0x20},
|
|
|
|
|
{"Lookaside", 9, 0x10},
|
|
|
|
|
{"StoreStore", 10, 0x08},
|
|
|
|
|
{"LoadStore", 9, 0x04},
|
|
|
|
|
{"StoreLoad", 9, 0x02},
|
|
|
|
|
{"LoadLoad", 8, 0x01},
|
|
|
|
|
};
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static int
|
|
|
|
|
cmp_reg_entry (p, q)
|
1992-08-01 23:20:55 +00:00
|
|
|
|
struct priv_reg_entry *p, *q;
|
|
|
|
|
{
|
|
|
|
|
return strcmp (q->name, p->name);
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
/* This function is called once, at assembler startup time. It should
|
|
|
|
|
set up all the tables, etc. that the MD part of the assembler will need. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
void
|
|
|
|
|
md_begin ()
|
|
|
|
|
{
|
1993-10-21 19:50:57 +00:00
|
|
|
|
register const char *retval = NULL;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
int lose = 0;
|
|
|
|
|
register unsigned int i = 0;
|
|
|
|
|
|
|
|
|
|
op_hash = hash_new ();
|
|
|
|
|
|
|
|
|
|
while (i < NUMOPCODES)
|
|
|
|
|
{
|
|
|
|
|
const char *name = sparc_opcodes[i].name;
|
|
|
|
|
retval = hash_insert (op_hash, name, &sparc_opcodes[i]);
|
1993-10-21 19:50:57 +00:00
|
|
|
|
if (retval != NULL)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "internal error: can't hash `%s': %s\n",
|
|
|
|
|
sparc_opcodes[i].name, retval);
|
|
|
|
|
lose = 1;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
|
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
|
|
|
|
|
sparc_opcodes[i].name, sparc_opcodes[i].args);
|
|
|
|
|
lose = 1;
|
|
|
|
|
}
|
|
|
|
|
++i;
|
|
|
|
|
}
|
|
|
|
|
while (i < NUMOPCODES
|
|
|
|
|
&& !strcmp (sparc_opcodes[i].name, name));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (lose)
|
|
|
|
|
as_fatal ("Broken assembler. No assembly attempted.");
|
|
|
|
|
|
|
|
|
|
for (i = '0'; i < '8'; ++i)
|
|
|
|
|
octal[i] = 1;
|
|
|
|
|
for (i = '0'; i <= '9'; ++i)
|
|
|
|
|
toHex[i] = i - '0';
|
|
|
|
|
for (i = 'a'; i <= 'f'; ++i)
|
|
|
|
|
toHex[i] = i + 10 - 'a';
|
|
|
|
|
for (i = 'A'; i <= 'F'; ++i)
|
|
|
|
|
toHex[i] = i + 10 - 'A';
|
|
|
|
|
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#ifndef NO_V9
|
1992-11-23 20:42:33 +00:00
|
|
|
|
qsort (priv_reg_table, sizeof (priv_reg_table) / sizeof (priv_reg_table[0]),
|
|
|
|
|
sizeof (priv_reg_table[0]), cmp_reg_entry);
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#endif
|
1993-06-25 09:51:47 +00:00
|
|
|
|
|
|
|
|
|
target_big_endian = 1;
|
1993-10-25 17:45:17 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
void
|
|
|
|
|
md_assemble (str)
|
|
|
|
|
char *str;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *toP;
|
|
|
|
|
int rsd;
|
|
|
|
|
|
|
|
|
|
know (str);
|
|
|
|
|
sparc_ip (str);
|
|
|
|
|
|
|
|
|
|
/* See if "set" operand is absolute and small; skip sethi if so. */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
if (special_case == SPECIAL_CASE_SET
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
&& the_insn.exp.X_op == O_constant)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
if (the_insn.exp.X_add_number >= -(1 << 12)
|
|
|
|
|
&& the_insn.exp.X_add_number < (1 << 12))
|
|
|
|
|
{
|
|
|
|
|
the_insn.opcode = 0x80102000 /* or %g0,imm,... */
|
|
|
|
|
| (the_insn.opcode & 0x3E000000) /* dest reg */
|
|
|
|
|
| (the_insn.exp.X_add_number & 0x1FFF); /* imm */
|
|
|
|
|
special_case = 0; /* No longer special */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_NONE; /* No longer relocated */
|
1992-08-01 23:20:55 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
toP = frag_more (4);
|
|
|
|
|
/* put out the opcode */
|
1993-07-07 16:58:29 +00:00
|
|
|
|
md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
/* put out the symbol-dependent stuff */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
if (the_insn.reloc != BFD_RELOC_NONE)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
fix_new_exp (frag_now, /* which frag */
|
|
|
|
|
(toP - frag_now->fr_literal), /* where */
|
|
|
|
|
4, /* size */
|
|
|
|
|
&the_insn.exp,
|
|
|
|
|
the_insn.pcrel,
|
|
|
|
|
the_insn.reloc);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
switch (special_case)
|
|
|
|
|
{
|
|
|
|
|
case SPECIAL_CASE_SET:
|
|
|
|
|
special_case = 0;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
assert (the_insn.reloc == BFD_RELOC_HI22);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
/* See if "set" operand has no low-order bits; skip OR if so. */
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
if (the_insn.exp.X_op == O_constant
|
1992-11-23 20:42:33 +00:00
|
|
|
|
&& ((the_insn.exp.X_add_number & 0x3FF) == 0))
|
|
|
|
|
return;
|
|
|
|
|
toP = frag_more (4);
|
|
|
|
|
rsd = (the_insn.opcode >> 25) & 0x1f;
|
|
|
|
|
the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
|
1993-07-07 16:58:29 +00:00
|
|
|
|
md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
fix_new_exp (frag_now, /* which frag */
|
|
|
|
|
(toP - frag_now->fr_literal), /* where */
|
|
|
|
|
4, /* size */
|
|
|
|
|
&the_insn.exp,
|
|
|
|
|
the_insn.pcrel,
|
|
|
|
|
BFD_RELOC_LO10);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
case SPECIAL_CASE_FDIV:
|
|
|
|
|
/* According to information leaked from Sun, the "fdiv" instructions
|
1992-12-15 03:46:14 +00:00
|
|
|
|
on early SPARC machines would produce incorrect results sometimes.
|
|
|
|
|
The workaround is to add an fmovs of the destination register to
|
|
|
|
|
itself just after the instruction. This was true on machines
|
|
|
|
|
with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
special_case = 0;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
assert (the_insn.reloc == BFD_RELOC_NONE);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
toP = frag_more (4);
|
|
|
|
|
rsd = (the_insn.opcode >> 25) & 0x1f;
|
|
|
|
|
the_insn.opcode = 0x81A00020 | (rsd << 25) | rsd; /* fmovs dest,dest */
|
1993-07-07 16:58:29 +00:00
|
|
|
|
md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
case 0:
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
as_fatal ("failed sanity check.");
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1994-07-28 23:36:16 +00:00
|
|
|
|
/* Implement big shift right. */
|
|
|
|
|
static bfd_vma
|
|
|
|
|
BSR (val, amount)
|
|
|
|
|
bfd_vma val;
|
|
|
|
|
int amount;
|
|
|
|
|
{
|
|
|
|
|
if (sizeof (bfd_vma) <= 4 && amount >= 32)
|
|
|
|
|
as_fatal ("Support for 64-bit arithmetic not compiled in.");
|
|
|
|
|
return val >> amount;
|
|
|
|
|
}
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static void
|
|
|
|
|
sparc_ip (str)
|
|
|
|
|
char *str;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *error_message = "";
|
|
|
|
|
char *s;
|
|
|
|
|
const char *args;
|
|
|
|
|
char c;
|
|
|
|
|
struct sparc_opcode *insn;
|
|
|
|
|
char *argsStart;
|
|
|
|
|
unsigned long opcode;
|
|
|
|
|
unsigned int mask = 0;
|
|
|
|
|
int match = 0;
|
|
|
|
|
int comma = 0;
|
|
|
|
|
long immediate_max = 0;
|
|
|
|
|
|
|
|
|
|
for (s = str; islower (*s) || (*s >= '0' && *s <= '3'); ++s)
|
|
|
|
|
;
|
|
|
|
|
switch (*s)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case '\0':
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ',':
|
|
|
|
|
comma = 1;
|
|
|
|
|
|
|
|
|
|
/*FALLTHROUGH */
|
|
|
|
|
|
|
|
|
|
case ' ':
|
|
|
|
|
*s++ = '\0';
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
as_bad ("Unknown opcode: `%s'", str);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
if ((insn = (struct sparc_opcode *) hash_find (op_hash, str)) == NULL)
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Unknown opcode: `%s'", str);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (comma)
|
|
|
|
|
{
|
|
|
|
|
*--s = ',';
|
|
|
|
|
}
|
|
|
|
|
argsStart = s;
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
opcode = insn->match;
|
|
|
|
|
memset (&the_insn, '\0', sizeof (the_insn));
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_NONE;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
/*
|
1992-12-15 03:46:14 +00:00
|
|
|
|
* Build the opcode, checking as we go to make
|
|
|
|
|
* sure that the operands match
|
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
|
for (args = insn->args;; ++args)
|
|
|
|
|
{
|
|
|
|
|
switch (*args)
|
|
|
|
|
{
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#ifndef NO_V9
|
1992-11-23 20:42:33 +00:00
|
|
|
|
case 'K':
|
|
|
|
|
{
|
1993-10-21 19:50:57 +00:00
|
|
|
|
int kmask = 0;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Parse a series of masks. */
|
|
|
|
|
if (*s == '#')
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
while (*s == '#')
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
++s;
|
|
|
|
|
for (i = 0; i < MEMBAR_MASKS_SIZE; i++)
|
|
|
|
|
if (!strncmp (s, membar_masks[i].name,
|
|
|
|
|
membar_masks[i].len))
|
|
|
|
|
break;
|
|
|
|
|
if (i < MEMBAR_MASKS_SIZE)
|
|
|
|
|
{
|
1993-10-21 19:50:57 +00:00
|
|
|
|
kmask |= membar_masks[i].mask;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
s += membar_masks[i].len;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid membar mask name";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (*s == '|')
|
|
|
|
|
++s;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
1993-06-25 09:51:47 +00:00
|
|
|
|
}
|
1993-12-16 21:31:22 +00:00
|
|
|
|
else
|
1993-06-25 09:51:47 +00:00
|
|
|
|
{
|
1993-12-16 21:31:22 +00:00
|
|
|
|
expressionS exp;
|
|
|
|
|
char *hold;
|
1993-10-25 18:08:33 +00:00
|
|
|
|
char *send;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
|
1993-12-16 21:31:22 +00:00
|
|
|
|
hold = input_line_pointer;
|
|
|
|
|
input_line_pointer = s;
|
|
|
|
|
expression (&exp);
|
|
|
|
|
send = input_line_pointer;
|
|
|
|
|
input_line_pointer = hold;
|
|
|
|
|
|
|
|
|
|
kmask = exp.X_add_number;
|
|
|
|
|
if (exp.X_op != O_constant
|
|
|
|
|
|| kmask < 0
|
|
|
|
|
|| kmask > 127)
|
1993-06-25 09:51:47 +00:00
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid membar mask number";
|
|
|
|
|
goto error;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
1993-12-16 21:31:22 +00:00
|
|
|
|
|
1993-10-25 18:08:33 +00:00
|
|
|
|
s = send;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
1993-12-16 21:31:22 +00:00
|
|
|
|
|
1993-10-21 19:50:57 +00:00
|
|
|
|
opcode |= SIMM13 (kmask);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case '*':
|
1993-06-25 09:51:47 +00:00
|
|
|
|
{
|
|
|
|
|
int prefetch_fcn = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-06-25 09:51:47 +00:00
|
|
|
|
/* Parse a prefetch function. */
|
|
|
|
|
if (*s == '#')
|
|
|
|
|
{
|
|
|
|
|
s += 1;
|
|
|
|
|
if (!strncmp (s, "n_reads", 7))
|
|
|
|
|
prefetch_fcn = 0, s += 7;
|
|
|
|
|
else if (!strncmp (s, "one_read", 8))
|
|
|
|
|
prefetch_fcn = 1, s += 8;
|
|
|
|
|
else if (!strncmp (s, "n_writes", 8))
|
|
|
|
|
prefetch_fcn = 2, s += 8;
|
|
|
|
|
else if (!strncmp (s, "one_write", 9))
|
|
|
|
|
prefetch_fcn = 3, s += 9;
|
|
|
|
|
else if (!strncmp (s, "page", 4))
|
|
|
|
|
prefetch_fcn = 4, s += 4;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid prefetch function name";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
while (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
prefetch_fcn = prefetch_fcn * 10 + *s - '0';
|
|
|
|
|
++s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prefetch_fcn < 0 || prefetch_fcn > 31)
|
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid prefetch function number";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": unrecognizable prefetch function";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
opcode |= RD (prefetch_fcn);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
case '!':
|
|
|
|
|
case '?':
|
|
|
|
|
/* Parse a privileged register. */
|
|
|
|
|
if (*s == '%')
|
|
|
|
|
{
|
|
|
|
|
struct priv_reg_entry *p = priv_reg_table;
|
1993-10-21 19:50:57 +00:00
|
|
|
|
unsigned int len = 9999999; /* init to make gcc happy */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
s += 1;
|
|
|
|
|
while (p->name[0] > s[0])
|
|
|
|
|
p++;
|
|
|
|
|
while (p->name[0] == s[0])
|
|
|
|
|
{
|
|
|
|
|
len = strlen (p->name);
|
|
|
|
|
if (strncmp (p->name, s, len) == 0)
|
|
|
|
|
break;
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
if (p->name[0] != s[0])
|
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
error_message = ": unrecognizable privileged register";
|
1992-11-23 20:42:33 +00:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (*args == '?')
|
|
|
|
|
opcode |= (p->regnum << 14);
|
|
|
|
|
else
|
|
|
|
|
opcode |= (p->regnum << 25);
|
|
|
|
|
s += len;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
error_message = ": unrecognizable privileged register";
|
1992-11-23 20:42:33 +00:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
1992-08-01 23:20:55 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
case 'M':
|
|
|
|
|
case 'm':
|
|
|
|
|
if (strncmp (s, "%asr", 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 4;
|
1992-08-01 23:20:55 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
long num = 0;
|
|
|
|
|
|
|
|
|
|
while (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
num = num * 10 + *s - '0';
|
|
|
|
|
++s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (num < 16 || 31 < num)
|
|
|
|
|
{
|
|
|
|
|
error_message = ": asr number must be between 15 and 31";
|
|
|
|
|
goto error;
|
|
|
|
|
} /* out of range */
|
|
|
|
|
|
|
|
|
|
opcode |= (*args == 'M' ? RS1 (num) : RD (num));
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": expecting %asrN";
|
|
|
|
|
goto error;
|
|
|
|
|
} /* if %asr followed by a number. */
|
|
|
|
|
|
|
|
|
|
} /* if %asr */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
#ifndef NO_V9
|
|
|
|
|
case 'I':
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_11;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
immediate_max = 0x03FF;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'j':
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_10;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
immediate_max = 0x01FF;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'k':
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = /* RELOC_WDISP2_14 */ BFD_RELOC_SPARC_WDISP16;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
the_insn.pcrel = 1;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'G':
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_WDISP19;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
the_insn.pcrel = 1;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'N':
|
|
|
|
|
if (*s == 'p' && s[1] == 'n')
|
|
|
|
|
{
|
|
|
|
|
s += 2;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'T':
|
|
|
|
|
if (*s == 'p' && s[1] == 't')
|
|
|
|
|
{
|
|
|
|
|
s += 2;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'z':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%icc", 4) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 4;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'Z':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%xcc", 4) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 4;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '6':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%fcc0", 5) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 5;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '7':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%fcc1", 5) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 5;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '8':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%fcc2", 5) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 5;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '9':
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
1992-11-23 23:40:18 +00:00
|
|
|
|
if (strncmp (s, "%fcc3", 5) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1992-11-23 23:40:18 +00:00
|
|
|
|
s += 5;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'P':
|
|
|
|
|
if (strncmp (s, "%pc", 3) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 3;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'W':
|
|
|
|
|
if (strncmp (s, "%tick", 5) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 5;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
#endif /* NO_V9 */
|
|
|
|
|
|
|
|
|
|
case '\0': /* end of args */
|
|
|
|
|
if (*s == '\0')
|
|
|
|
|
{
|
|
|
|
|
match = 1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '+':
|
|
|
|
|
if (*s == '+')
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (*s == '-')
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '[': /* these must match exactly */
|
|
|
|
|
case ']':
|
|
|
|
|
case ',':
|
|
|
|
|
case ' ':
|
|
|
|
|
if (*s++ == *args)
|
|
|
|
|
continue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case '#': /* must be at least one digit */
|
|
|
|
|
if (isdigit (*s++))
|
|
|
|
|
{
|
|
|
|
|
while (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
++s;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'C': /* coprocessor state register */
|
|
|
|
|
if (strncmp (s, "%csr", 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'b': /* next operand is a coprocessor register */
|
|
|
|
|
case 'c':
|
|
|
|
|
case 'D':
|
|
|
|
|
if (*s++ == '%' && *s++ == 'c' && isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
mask = *s++;
|
|
|
|
|
if (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
mask = 10 * (mask - '0') + (*s++ - '0');
|
|
|
|
|
if (mask >= 32)
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
mask -= '0';
|
|
|
|
|
}
|
|
|
|
|
switch (*args)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case 'b':
|
|
|
|
|
opcode |= mask << 14;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'c':
|
|
|
|
|
opcode |= mask;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'D':
|
|
|
|
|
opcode |= mask << 25;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'r': /* next operand must be a register */
|
|
|
|
|
case '1':
|
|
|
|
|
case '2':
|
|
|
|
|
case 'd':
|
|
|
|
|
if (*s++ == '%')
|
|
|
|
|
{
|
|
|
|
|
switch (c = *s++)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case 'f': /* frame pointer */
|
|
|
|
|
if (*s++ == 'p')
|
|
|
|
|
{
|
|
|
|
|
mask = 0x1e;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 'g': /* global register */
|
|
|
|
|
if (isoctal (c = *s++))
|
|
|
|
|
{
|
|
|
|
|
mask = c - '0';
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 'i': /* in register */
|
|
|
|
|
if (isoctal (c = *s++))
|
|
|
|
|
{
|
|
|
|
|
mask = c - '0' + 24;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 'l': /* local register */
|
|
|
|
|
if (isoctal (c = *s++))
|
|
|
|
|
{
|
|
|
|
|
mask = (c - '0' + 16);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 'o': /* out register */
|
|
|
|
|
if (isoctal (c = *s++))
|
|
|
|
|
{
|
|
|
|
|
mask = (c - '0' + 8);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 's': /* stack pointer */
|
|
|
|
|
if (*s++ == 'p')
|
|
|
|
|
{
|
|
|
|
|
mask = 0xe;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
case 'r': /* any register */
|
|
|
|
|
if (!isdigit (c = *s++))
|
|
|
|
|
{
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
case '0':
|
|
|
|
|
case '1':
|
|
|
|
|
case '2':
|
|
|
|
|
case '3':
|
|
|
|
|
case '4':
|
|
|
|
|
case '5':
|
|
|
|
|
case '6':
|
|
|
|
|
case '7':
|
|
|
|
|
case '8':
|
|
|
|
|
case '9':
|
|
|
|
|
if (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
|
1992-08-01 23:20:55 +00:00
|
|
|
|
{
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
c -= '0';
|
|
|
|
|
}
|
|
|
|
|
mask = c;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
/*
|
1992-08-01 23:20:55 +00:00
|
|
|
|
* Got the register, now figure out where
|
|
|
|
|
* it goes in the opcode.
|
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
|
switch (*args)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case '1':
|
|
|
|
|
opcode |= mask << 14;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case '2':
|
|
|
|
|
opcode |= mask;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'd':
|
|
|
|
|
opcode |= mask << 25;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'r':
|
|
|
|
|
opcode |= (mask << 25) | (mask << 14);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'e': /* next operand is a floating point register */
|
|
|
|
|
case 'v':
|
|
|
|
|
case 'V':
|
|
|
|
|
|
|
|
|
|
case 'f':
|
|
|
|
|
case 'B':
|
|
|
|
|
case 'R':
|
|
|
|
|
|
|
|
|
|
case 'g':
|
|
|
|
|
case 'H':
|
|
|
|
|
case 'J':
|
|
|
|
|
{
|
|
|
|
|
char format;
|
|
|
|
|
|
|
|
|
|
if (*s++ == '%'
|
|
|
|
|
&& ((format = *s) == 'f')
|
|
|
|
|
&& isdigit (*++s))
|
|
|
|
|
{
|
|
|
|
|
for (mask = 0; isdigit (*s); ++s)
|
|
|
|
|
{
|
|
|
|
|
mask = 10 * mask + (*s - '0');
|
|
|
|
|
} /* read the number */
|
|
|
|
|
|
|
|
|
|
if ((*args == 'v'
|
|
|
|
|
|| *args == 'B'
|
|
|
|
|
|| *args == 'H')
|
|
|
|
|
&& (mask & 1))
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
} /* register must be even numbered */
|
|
|
|
|
|
|
|
|
|
if ((*args == 'V'
|
|
|
|
|
|| *args == 'R'
|
|
|
|
|
|| *args == 'J')
|
|
|
|
|
&& (mask & 3))
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
} /* register must be multiple of 4 */
|
|
|
|
|
|
1991-08-14 00:26:06 +00:00
|
|
|
|
#ifndef NO_V9
|
1993-07-07 16:58:29 +00:00
|
|
|
|
if (mask >= 64)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
error_message = ": There are only 64 f registers; [0-63]";
|
|
|
|
|
goto error;
|
|
|
|
|
} /* on error */
|
|
|
|
|
if (mask >= 32)
|
|
|
|
|
{
|
|
|
|
|
mask -= 31;
|
|
|
|
|
} /* wrap high bit */
|
|
|
|
|
#else
|
|
|
|
|
if (mask >= 32)
|
|
|
|
|
{
|
|
|
|
|
error_message = ": There are only 32 f registers; [0-31]";
|
|
|
|
|
goto error;
|
|
|
|
|
} /* on error */
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
} /* if not an 'f' register. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
switch (*args)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case 'v':
|
|
|
|
|
case 'V':
|
|
|
|
|
case 'e':
|
|
|
|
|
opcode |= RS1 (mask);
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case 'f':
|
|
|
|
|
case 'B':
|
|
|
|
|
case 'R':
|
|
|
|
|
opcode |= RS2 (mask);
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'g':
|
|
|
|
|
case 'H':
|
|
|
|
|
case 'J':
|
|
|
|
|
opcode |= RD (mask);
|
|
|
|
|
continue;
|
|
|
|
|
} /* pack it in. */
|
|
|
|
|
|
|
|
|
|
know (0);
|
|
|
|
|
break;
|
|
|
|
|
} /* float arg */
|
|
|
|
|
|
|
|
|
|
case 'F':
|
|
|
|
|
if (strncmp (s, "%fsr", 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'h': /* high 22 bits */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_HI22;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'l': /* 22 bit PC relative immediate */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_WDISP22;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
the_insn.pcrel = 1;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'L': /* 30 bit immediate */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_32_PCREL_S2;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
the_insn.pcrel = 1;
|
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'n': /* 22 bit immediate */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC22;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
goto immediate;
|
|
|
|
|
|
|
|
|
|
case 'i': /* 13 bit immediate */
|
1994-03-31 21:54:06 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC13;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
immediate_max = 0x0FFF;
|
|
|
|
|
|
|
|
|
|
/*FALLTHROUGH */
|
|
|
|
|
|
|
|
|
|
immediate:
|
|
|
|
|
if (*s == ' ')
|
|
|
|
|
s++;
|
|
|
|
|
if (*s == '%')
|
|
|
|
|
{
|
|
|
|
|
if ((c = s[1]) == 'h' && s[2] == 'i')
|
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_HI22;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
s += 3;
|
|
|
|
|
}
|
|
|
|
|
else if (c == 'l' && s[2] == 'o')
|
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_LO10;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
s += 3;
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
#ifndef NO_V9
|
1992-11-23 20:42:33 +00:00
|
|
|
|
else if (c == 'u'
|
|
|
|
|
&& s[2] == 'h'
|
|
|
|
|
&& s[3] == 'i')
|
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_HH22;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
s += 4;
|
|
|
|
|
}
|
|
|
|
|
else if (c == 'u'
|
|
|
|
|
&& s[2] == 'l'
|
|
|
|
|
&& s[3] == 'o')
|
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
the_insn.reloc = BFD_RELOC_SPARC_HM10;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
s += 4;
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
#endif /* NO_V9 */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
/* Note that if the getExpression() fails, we will still
|
|
|
|
|
have created U entries in the symbol table for the
|
|
|
|
|
'symbols' in the input string. Try not to create U
|
|
|
|
|
symbols for registers, etc. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1993-10-25 17:45:17 +00:00
|
|
|
|
/* This stuff checks to see if the expression ends in
|
|
|
|
|
+%reg. If it does, it removes the register from
|
|
|
|
|
the expression, and re-sets 's' to point to the
|
|
|
|
|
right place. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
char *s1;
|
|
|
|
|
|
|
|
|
|
for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++);;
|
|
|
|
|
|
|
|
|
|
if (s1 != s && isdigit (s1[-1]))
|
|
|
|
|
{
|
|
|
|
|
if (s1[-2] == '%' && s1[-3] == '+')
|
|
|
|
|
{
|
|
|
|
|
s1 -= 3;
|
|
|
|
|
*s1 = '\0';
|
|
|
|
|
(void) getExpression (s);
|
|
|
|
|
*s1 = '+';
|
|
|
|
|
s = s1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (strchr ("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
|
|
|
|
|
{
|
|
|
|
|
s1 -= 4;
|
|
|
|
|
*s1 = '\0';
|
|
|
|
|
(void) getExpression (s);
|
|
|
|
|
*s1 = '+';
|
|
|
|
|
s = s1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
(void) getExpression (s);
|
|
|
|
|
s = expr_end;
|
|
|
|
|
|
1993-10-25 17:45:17 +00:00
|
|
|
|
if (the_insn.exp.X_op == O_constant
|
|
|
|
|
&& the_insn.exp.X_add_symbol == 0
|
|
|
|
|
&& the_insn.exp.X_op_symbol == 0)
|
|
|
|
|
{
|
1992-11-06 01:59:36 +00:00
|
|
|
|
#ifndef NO_V9
|
1994-03-31 21:54:06 +00:00
|
|
|
|
/* Handle %uhi/%ulo by moving the upper word to the lower
|
|
|
|
|
one and pretending it's %hi/%lo. We also need to watch
|
|
|
|
|
for %hi/%lo: the top word needs to be zeroed otherwise
|
|
|
|
|
fixup_segment will complain the value is too big. */
|
1993-10-25 17:45:17 +00:00
|
|
|
|
switch (the_insn.reloc)
|
|
|
|
|
{
|
|
|
|
|
case BFD_RELOC_SPARC_HH22:
|
|
|
|
|
the_insn.reloc = BFD_RELOC_HI22;
|
1994-07-28 23:36:16 +00:00
|
|
|
|
the_insn.exp.X_add_number = BSR (the_insn.exp.X_add_number, 32);
|
1993-10-25 17:45:17 +00:00
|
|
|
|
break;
|
|
|
|
|
case BFD_RELOC_SPARC_HM10:
|
|
|
|
|
the_insn.reloc = BFD_RELOC_LO10;
|
1994-07-28 23:36:16 +00:00
|
|
|
|
the_insn.exp.X_add_number = BSR (the_insn.exp.X_add_number, 32);
|
1993-10-25 17:45:17 +00:00
|
|
|
|
break;
|
1993-12-16 21:31:22 +00:00
|
|
|
|
default:
|
|
|
|
|
break;
|
1994-03-31 21:54:06 +00:00
|
|
|
|
case BFD_RELOC_HI22:
|
|
|
|
|
case BFD_RELOC_LO10:
|
|
|
|
|
the_insn.exp.X_add_number &= 0xffffffff;
|
|
|
|
|
break;
|
1993-10-25 17:45:17 +00:00
|
|
|
|
}
|
1992-11-06 01:59:36 +00:00
|
|
|
|
#endif
|
1994-03-31 21:54:06 +00:00
|
|
|
|
/* For pc-relative call instructions, we reject
|
|
|
|
|
constants to get better code. */
|
|
|
|
|
if (the_insn.pcrel
|
|
|
|
|
&& the_insn.reloc == BFD_RELOC_32_PCREL_S2
|
|
|
|
|
&& in_signed_range (the_insn.exp.X_add_number, 0x3fff)
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
error_message = ": PC-relative operand can't be a constant";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
/* Check for invalid constant values. Don't warn if
|
|
|
|
|
constant was inside %hi or %lo, since these
|
|
|
|
|
truncate the constant to fit. */
|
|
|
|
|
if (immediate_max != 0
|
|
|
|
|
&& the_insn.reloc != BFD_RELOC_LO10
|
|
|
|
|
&& the_insn.reloc != BFD_RELOC_HI22
|
1994-03-31 21:54:06 +00:00
|
|
|
|
&& !in_signed_range (the_insn.exp.X_add_number,
|
|
|
|
|
immediate_max)
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
if (the_insn.pcrel)
|
|
|
|
|
/* Who knows? After relocation, we may be within
|
|
|
|
|
range. Let the linker figure it out. */
|
|
|
|
|
{
|
|
|
|
|
the_insn.exp.X_op = O_symbol;
|
|
|
|
|
the_insn.exp.X_add_symbol = section_symbol (absolute_section);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
/* Immediate value is non-pcrel, and out of
|
|
|
|
|
range. */
|
|
|
|
|
as_bad ("constant value %ld out of range (%ld .. %ld)",
|
|
|
|
|
the_insn.exp.X_add_number,
|
|
|
|
|
~immediate_max, immediate_max);
|
|
|
|
|
}
|
1993-10-25 17:45:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
/* Reset to prevent extraneous range check. */
|
|
|
|
|
immediate_max = 0;
|
|
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'a':
|
|
|
|
|
if (*s++ == 'a')
|
|
|
|
|
{
|
|
|
|
|
opcode |= ANNUL;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'A':
|
|
|
|
|
{
|
1993-06-25 09:51:47 +00:00
|
|
|
|
#ifdef NO_V9
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *push = input_line_pointer;
|
|
|
|
|
expressionS e;
|
|
|
|
|
|
|
|
|
|
input_line_pointer = s;
|
|
|
|
|
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
expression (&e);
|
|
|
|
|
if (e.X_op == O_constant)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
opcode |= e.X_add_number << 5;
|
|
|
|
|
s = input_line_pointer;
|
|
|
|
|
input_line_pointer = push;
|
|
|
|
|
continue;
|
|
|
|
|
} /* if absolute */
|
|
|
|
|
|
|
|
|
|
break;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
#else
|
|
|
|
|
int asi = 0;
|
|
|
|
|
|
|
|
|
|
/* Parse an asi. */
|
|
|
|
|
if (*s == '#')
|
|
|
|
|
{
|
|
|
|
|
s += 1;
|
|
|
|
|
if (!strncmp (s, "ASI_AIUP", 8))
|
|
|
|
|
asi = 0x10, s += 8;
|
|
|
|
|
else if (!strncmp (s, "ASI_AIUS", 8))
|
|
|
|
|
asi = 0x11, s += 8;
|
|
|
|
|
else if (!strncmp (s, "ASI_PNF", 7))
|
|
|
|
|
asi = 0x82, s += 7;
|
|
|
|
|
else if (!strncmp (s, "ASI_SNF", 7))
|
|
|
|
|
asi = 0x83, s += 7;
|
|
|
|
|
else if (!strncmp (s, "ASI_P", 5))
|
|
|
|
|
asi = 0x80, s += 5;
|
|
|
|
|
else if (!strncmp (s, "ASI_S", 5))
|
|
|
|
|
asi = 0x81, s += 5;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid asi name";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (isdigit (*s))
|
|
|
|
|
{
|
|
|
|
|
char *push = input_line_pointer;
|
|
|
|
|
input_line_pointer = s;
|
|
|
|
|
asi = get_absolute_expression ();
|
|
|
|
|
s = input_line_pointer;
|
|
|
|
|
input_line_pointer = push;
|
|
|
|
|
|
|
|
|
|
if (asi < 0 || asi > 255)
|
|
|
|
|
{
|
|
|
|
|
error_message = ": invalid asi number";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error_message = ": unrecognizable asi";
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
opcode |= ASI (asi);
|
|
|
|
|
continue;
|
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
|
} /* alternate space */
|
|
|
|
|
|
|
|
|
|
case 'p':
|
|
|
|
|
if (strncmp (s, "%psr", 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'q': /* floating point queue */
|
|
|
|
|
if (strncmp (s, "%fq", 3) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 3;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'Q': /* coprocessor queue */
|
|
|
|
|
if (strncmp (s, "%cq", 3) == 0)
|
|
|
|
|
{
|
|
|
|
|
s += 3;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'S':
|
|
|
|
|
if (strcmp (str, "set") == 0)
|
|
|
|
|
{
|
|
|
|
|
special_case = SPECIAL_CASE_SET;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (strncmp (str, "fdiv", 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
special_case = SPECIAL_CASE_FDIV;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#ifndef NO_V9
|
1992-11-23 20:42:33 +00:00
|
|
|
|
case 'o':
|
|
|
|
|
if (strncmp (s, "%asi", 4) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 's':
|
|
|
|
|
if (strncmp (s, "%fprs", 5) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 5;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'E':
|
|
|
|
|
if (strncmp (s, "%ccr", 4) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
1992-08-01 23:20:55 +00:00
|
|
|
|
#endif /* NO_V9 */
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
case 't':
|
|
|
|
|
if (strncmp (s, "%tbr", 4) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
case 'w':
|
|
|
|
|
if (strncmp (s, "%wim", 4) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 4;
|
|
|
|
|
continue;
|
|
|
|
|
|
1994-07-28 23:36:16 +00:00
|
|
|
|
#ifndef NO_V9
|
|
|
|
|
case 'x':
|
|
|
|
|
{
|
|
|
|
|
char *push = input_line_pointer;
|
|
|
|
|
expressionS e;
|
|
|
|
|
|
|
|
|
|
input_line_pointer = s;
|
|
|
|
|
expression (&e);
|
|
|
|
|
if (e.X_op == O_constant)
|
|
|
|
|
{
|
|
|
|
|
int n = e.X_add_number;
|
|
|
|
|
if (n != e.X_add_number || (n & ~0x1ff) != 0)
|
|
|
|
|
as_bad ("OPF immediate operand out of range (0-0x1ff)");
|
|
|
|
|
else
|
|
|
|
|
opcode |= e.X_add_number << 5;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
as_bad ("non-immediate OPF operand, ignored");
|
|
|
|
|
s = input_line_pointer;
|
|
|
|
|
input_line_pointer = push;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
case 'y':
|
|
|
|
|
if (strncmp (s, "%y", 2) != 0)
|
|
|
|
|
break;
|
|
|
|
|
s += 2;
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
as_fatal ("failed sanity check.");
|
|
|
|
|
} /* switch on arg code */
|
|
|
|
|
break;
|
|
|
|
|
} /* for each arg that we expect */
|
|
|
|
|
error:
|
|
|
|
|
if (match == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Args don't match. */
|
|
|
|
|
if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
|
|
|
|
|
&& !strcmp (insn->name, insn[1].name))
|
|
|
|
|
{
|
|
|
|
|
++insn;
|
|
|
|
|
s = argsStart;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
as_bad ("Illegal operands%s", error_message);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1994-07-28 23:36:16 +00:00
|
|
|
|
if (insn->architecture > current_architecture
|
|
|
|
|
|| (insn->architecture != current_architecture
|
|
|
|
|
&& current_architecture > v8))
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
if ((!architecture_requested || warn_on_bump)
|
1994-07-28 23:36:16 +00:00
|
|
|
|
&& !ARCHITECTURES_CONFLICT_P (current_architecture,
|
|
|
|
|
insn->architecture)
|
|
|
|
|
&& !ARCHITECTURES_CONFLICT_P (insn->architecture,
|
|
|
|
|
current_architecture))
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
if (warn_on_bump)
|
|
|
|
|
{
|
|
|
|
|
as_warn ("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
|
|
|
|
|
architecture_pname[current_architecture],
|
|
|
|
|
architecture_pname[insn->architecture],
|
|
|
|
|
str);
|
|
|
|
|
} /* if warning */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
current_architecture = insn->architecture;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1994-07-28 23:36:16 +00:00
|
|
|
|
as_bad ("Architecture mismatch on \"%s\".", str);
|
|
|
|
|
as_tsktsk (" (Requires %s; current architecture is %s.)",
|
|
|
|
|
architecture_pname[insn->architecture],
|
|
|
|
|
architecture_pname[current_architecture]);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return;
|
|
|
|
|
} /* if bump ok else error */
|
|
|
|
|
} /* if architecture higher */
|
|
|
|
|
} /* if no match */
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
} /* forever looking for a match */
|
|
|
|
|
|
|
|
|
|
the_insn.opcode = opcode;
|
1993-12-16 21:31:22 +00:00
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
getExpression (str)
|
|
|
|
|
char *str;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *save_in;
|
|
|
|
|
segT seg;
|
|
|
|
|
|
|
|
|
|
save_in = input_line_pointer;
|
|
|
|
|
input_line_pointer = str;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
seg = expression (&the_insn.exp);
|
1993-09-10 16:01:07 +00:00
|
|
|
|
if (seg != absolute_section
|
|
|
|
|
&& seg != text_section
|
|
|
|
|
&& seg != data_section
|
|
|
|
|
&& seg != bss_section
|
|
|
|
|
&& seg != undefined_section)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
|
|
|
|
the_insn.error = "bad segment";
|
|
|
|
|
expr_end = input_line_pointer;
|
|
|
|
|
input_line_pointer = save_in;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
expr_end = input_line_pointer;
|
|
|
|
|
input_line_pointer = save_in;
|
|
|
|
|
return 0;
|
|
|
|
|
} /* getExpression() */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
This is identical to the md_atof in m68k.c. I think this is right,
|
|
|
|
|
but I'm not sure.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
Turn a string in input_line_pointer into a floating point constant of type
|
|
|
|
|
type, and store the appropriate bytes in *litP. The number of LITTLENUMS
|
|
|
|
|
emitted is stored in *sizeP . An error message is returned, or NULL on OK.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Equal to MAX_PRECISION in atof-ieee.c */
|
|
|
|
|
#define MAX_LITTLENUMS 6
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *
|
|
|
|
|
md_atof (type, litP, sizeP)
|
|
|
|
|
char type;
|
|
|
|
|
char *litP;
|
|
|
|
|
int *sizeP;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
int prec;
|
|
|
|
|
LITTLENUM_TYPE words[MAX_LITTLENUMS];
|
|
|
|
|
LITTLENUM_TYPE *wordP;
|
|
|
|
|
char *t;
|
|
|
|
|
char *atof_ieee ();
|
|
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
case 'f':
|
|
|
|
|
case 'F':
|
|
|
|
|
case 's':
|
|
|
|
|
case 'S':
|
|
|
|
|
prec = 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'd':
|
|
|
|
|
case 'D':
|
|
|
|
|
case 'r':
|
|
|
|
|
case 'R':
|
|
|
|
|
prec = 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'x':
|
|
|
|
|
case 'X':
|
|
|
|
|
prec = 6;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'p':
|
|
|
|
|
case 'P':
|
|
|
|
|
prec = 6;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
*sizeP = 0;
|
|
|
|
|
return "Bad call to MD_ATOF()";
|
|
|
|
|
}
|
|
|
|
|
t = atof_ieee (input_line_pointer, type, words);
|
|
|
|
|
if (t)
|
|
|
|
|
input_line_pointer = t;
|
|
|
|
|
*sizeP = prec * sizeof (LITTLENUM_TYPE);
|
|
|
|
|
for (wordP = words; prec--;)
|
|
|
|
|
{
|
1993-07-07 16:58:29 +00:00
|
|
|
|
md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
|
1992-11-23 20:42:33 +00:00
|
|
|
|
litP += sizeof (LITTLENUM_TYPE);
|
|
|
|
|
}
|
1993-06-25 09:51:47 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Write out big-endian.
|
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
|
void
|
|
|
|
|
md_number_to_chars (buf, val, n)
|
|
|
|
|
char *buf;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
valueT val;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
int n;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1993-12-16 21:31:22 +00:00
|
|
|
|
number_to_chars_bigendian (buf, val, n);
|
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Apply a fixS to the frags, now that we know the value it ought to
|
|
|
|
|
hold. */
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
int
|
|
|
|
|
md_apply_fix (fixP, value)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
fixS *fixP;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
valueT *value;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
offsetT val;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
|
|
|
|
val = *value;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
|
|
fixP->fx_addnumber = val; /* Remember value for emit_reloc */
|
|
|
|
|
|
1993-10-21 19:50:57 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
/* FIXME: SPARC ELF relocations don't use an addend in the data
|
|
|
|
|
field itself. This whole approach should be somehow combined
|
|
|
|
|
with the calls to bfd_perform_relocation. */
|
|
|
|
|
if (fixP->fx_addsy != NULL)
|
|
|
|
|
return 1;
|
|
|
|
|
#endif
|
|
|
|
|
|
1993-12-16 21:31:22 +00:00
|
|
|
|
/* This is a hack. There should be a better way to
|
|
|
|
|
handle this. Probably in terms of howto fields, once
|
|
|
|
|
we can look at these fixups in terms of howtos. */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
if (fixP->fx_r_type == BFD_RELOC_32_PCREL_S2 && fixP->fx_addsy)
|
1993-12-16 21:31:22 +00:00
|
|
|
|
val += fixP->fx_where + fixP->fx_frag->fr_address;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1994-09-07 23:58:32 +00:00
|
|
|
|
#ifdef OBJ_AOUT
|
|
|
|
|
/* FIXME: More ridiculous gas reloc hacking. If we are going to
|
|
|
|
|
generate a reloc, then we just want to let the reloc addend set
|
|
|
|
|
the value. We do not want to also stuff the addend into the
|
|
|
|
|
object file. Including the addend in the object file works when
|
|
|
|
|
doing a static link, because the linker will ignore the object
|
|
|
|
|
file contents. However, the dynamic linker does not ignore the
|
|
|
|
|
object file contents. */
|
|
|
|
|
if (fixP->fx_addsy != NULL
|
|
|
|
|
&& fixP->fx_r_type != BFD_RELOC_32_PCREL_S2)
|
|
|
|
|
val = 0;
|
|
|
|
|
#endif
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
switch (fixP->fx_r_type)
|
|
|
|
|
{
|
1993-09-10 16:01:07 +00:00
|
|
|
|
case BFD_RELOC_16:
|
|
|
|
|
buf[0] = val >> 8;
|
|
|
|
|
buf[1] = val;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_32:
|
1993-08-06 16:10:40 +00:00
|
|
|
|
buf[0] = val >> 24;
|
|
|
|
|
buf[1] = val >> 16;
|
|
|
|
|
buf[2] = val >> 8;
|
|
|
|
|
buf[3] = val;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_32_PCREL_S2:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
val = (val >>= 2) + 1;
|
|
|
|
|
buf[0] |= (val >> 24) & 0x3f;
|
|
|
|
|
buf[1] = (val >> 16);
|
|
|
|
|
buf[2] = val >> 8;
|
|
|
|
|
buf[3] = val;
|
|
|
|
|
break;
|
|
|
|
|
|
1991-05-22 01:18:42 +00:00
|
|
|
|
#ifndef NO_V9
|
1993-08-04 23:10:43 +00:00
|
|
|
|
case BFD_RELOC_64:
|
1994-07-28 23:36:16 +00:00
|
|
|
|
{
|
|
|
|
|
bfd_vma valh = BSR (val, 32);
|
|
|
|
|
buf[0] = valh >> 24;
|
|
|
|
|
buf[1] = valh >> 16;
|
|
|
|
|
buf[2] = valh >> 8;
|
|
|
|
|
buf[3] = valh;
|
|
|
|
|
buf[4] = val >> 24;
|
|
|
|
|
buf[5] = val >> 16;
|
|
|
|
|
buf[6] = val >> 8;
|
|
|
|
|
buf[7] = val;
|
|
|
|
|
}
|
1993-08-04 23:10:43 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_11:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (((val > 0) && (val & ~0x7ff))
|
|
|
|
|
|| ((val < 0) && (~(val - 1) & ~0x7ff)))
|
|
|
|
|
{
|
|
|
|
|
as_bad ("relocation overflow.");
|
|
|
|
|
} /* on overflow */
|
|
|
|
|
|
|
|
|
|
buf[2] |= (val >> 8) & 0x7;
|
|
|
|
|
buf[3] = val & 0xff;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_10:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (((val > 0) && (val & ~0x3ff))
|
|
|
|
|
|| ((val < 0) && (~(val - 1) & ~0x3ff)))
|
|
|
|
|
{
|
|
|
|
|
as_bad ("relocation overflow.");
|
|
|
|
|
} /* on overflow */
|
|
|
|
|
|
|
|
|
|
buf[2] |= (val >> 8) & 0x3;
|
|
|
|
|
buf[3] = val & 0xff;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_WDISP16:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (((val > 0) && (val & ~0x3fffc))
|
|
|
|
|
|| ((val < 0) && (~(val - 1) & ~0x3fffc)))
|
|
|
|
|
{
|
|
|
|
|
as_bad ("relocation overflow.");
|
|
|
|
|
} /* on overflow */
|
|
|
|
|
|
|
|
|
|
val = (val >>= 2) + 1;
|
1992-12-15 03:46:14 +00:00
|
|
|
|
buf[1] |= ((val >> 14) & 0x3) << 4;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
buf[2] |= (val >> 8) & 0x3f;
|
|
|
|
|
buf[3] = val & 0xff;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_WDISP19:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (((val > 0) && (val & ~0x1ffffc))
|
|
|
|
|
|| ((val < 0) && (~(val - 1) & ~0x1ffffc)))
|
|
|
|
|
{
|
|
|
|
|
as_bad ("relocation overflow.");
|
|
|
|
|
} /* on overflow */
|
|
|
|
|
|
|
|
|
|
val = (val >>= 2) + 1;
|
|
|
|
|
buf[1] |= (val >> 16) & 0x7;
|
|
|
|
|
buf[2] = (val >> 8) & 0xff;
|
|
|
|
|
buf[3] = val & 0xff;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_HH22:
|
1994-07-28 23:36:16 +00:00
|
|
|
|
val = BSR (val, 32);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
/* intentional fallthrough */
|
1991-05-22 01:18:42 +00:00
|
|
|
|
#endif /* NO_V9 */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-07-07 16:58:29 +00:00
|
|
|
|
#ifndef NO_V9
|
|
|
|
|
case BFD_RELOC_SPARC_LM22:
|
|
|
|
|
#endif
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_HI22:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (!fixP->fx_addsy)
|
|
|
|
|
{
|
|
|
|
|
buf[1] |= (val >> 26) & 0x3f;
|
|
|
|
|
buf[2] = val >> 18;
|
|
|
|
|
buf[3] = val >> 10;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
buf[2] = 0;
|
|
|
|
|
buf[3] = 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_SPARC22:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (val & ~0x003fffff)
|
|
|
|
|
{
|
|
|
|
|
as_bad ("relocation overflow");
|
|
|
|
|
} /* on overflow */
|
|
|
|
|
buf[1] |= (val >> 16) & 0x3f;
|
|
|
|
|
buf[2] = val >> 8;
|
|
|
|
|
buf[3] = val & 0xff;
|
|
|
|
|
break;
|
|
|
|
|
|
1991-07-10 02:45:05 +00:00
|
|
|
|
#ifndef NO_V9
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_HM10:
|
1994-07-28 23:36:16 +00:00
|
|
|
|
val = BSR (val, 32);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
/* intentional fallthrough */
|
1991-07-10 02:45:05 +00:00
|
|
|
|
#endif /* NO_V9 */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_LO10:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
if (!fixP->fx_addsy)
|
|
|
|
|
{
|
|
|
|
|
buf[2] |= (val >> 8) & 0x03;
|
|
|
|
|
buf[3] = val;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
buf[3] = 0;
|
|
|
|
|
break;
|
1994-03-31 21:54:06 +00:00
|
|
|
|
|
|
|
|
|
case BFD_RELOC_SPARC13:
|
|
|
|
|
if (! in_signed_range (val, 0x1fff))
|
|
|
|
|
as_bad ("relocation overflow");
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
buf[2] |= (val >> 8) & 0x1f;
|
|
|
|
|
buf[3] = val;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_SPARC_WDISP22:
|
1994-07-28 23:36:16 +00:00
|
|
|
|
val = (val >> 2) + 1;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
/* FALLTHROUGH */
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_SPARC_BASE22:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
buf[1] |= (val >> 16) & 0x3f;
|
|
|
|
|
buf[2] = val >> 8;
|
|
|
|
|
buf[3] = val;
|
|
|
|
|
break;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_NONE:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
default:
|
1993-02-24 11:24:14 +00:00
|
|
|
|
as_bad ("bad or unhandled relocation type: 0x%02x", fixP->fx_r_type);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
1994-03-31 21:54:06 +00:00
|
|
|
|
/* Are we finished with this relocation now? */
|
|
|
|
|
if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
|
|
|
|
|
fixP->fx_done = 1;
|
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1993-02-24 11:24:14 +00:00
|
|
|
|
/* Translate internal representation of relocation info to BFD target
|
|
|
|
|
format. */
|
|
|
|
|
arelent *
|
|
|
|
|
tc_gen_reloc (section, fixp)
|
|
|
|
|
asection *section;
|
|
|
|
|
fixS *fixp;
|
|
|
|
|
{
|
|
|
|
|
arelent *reloc;
|
|
|
|
|
bfd_reloc_code_real_type code;
|
|
|
|
|
|
|
|
|
|
reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
|
|
|
|
|
assert (reloc != 0);
|
|
|
|
|
|
|
|
|
|
reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
|
|
|
|
|
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
|
|
|
|
|
|
|
|
|
|
switch (fixp->fx_r_type)
|
|
|
|
|
{
|
1993-09-10 16:01:07 +00:00
|
|
|
|
case BFD_RELOC_16:
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_32:
|
|
|
|
|
case BFD_RELOC_HI22:
|
|
|
|
|
case BFD_RELOC_LO10:
|
|
|
|
|
case BFD_RELOC_32_PCREL_S2:
|
1994-03-31 21:54:06 +00:00
|
|
|
|
case BFD_RELOC_SPARC13:
|
1993-02-24 11:24:14 +00:00
|
|
|
|
case BFD_RELOC_SPARC_BASE13:
|
1993-06-25 09:51:47 +00:00
|
|
|
|
case BFD_RELOC_SPARC_WDISP22:
|
1993-08-04 23:10:43 +00:00
|
|
|
|
case BFD_RELOC_64:
|
1993-07-07 16:58:29 +00:00
|
|
|
|
case BFD_RELOC_SPARC_10:
|
|
|
|
|
case BFD_RELOC_SPARC_11:
|
|
|
|
|
case BFD_RELOC_SPARC_HH22:
|
|
|
|
|
case BFD_RELOC_SPARC_HM10:
|
|
|
|
|
case BFD_RELOC_SPARC_LM22:
|
|
|
|
|
case BFD_RELOC_SPARC_PC_HH22:
|
|
|
|
|
case BFD_RELOC_SPARC_PC_HM10:
|
|
|
|
|
case BFD_RELOC_SPARC_PC_LM22:
|
1993-02-24 11:24:14 +00:00
|
|
|
|
code = fixp->fx_r_type;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
|
1994-04-05 18:16:37 +00:00
|
|
|
|
if (reloc->howto == 0)
|
|
|
|
|
{
|
|
|
|
|
as_bad_where (fixp->fx_file, fixp->fx_line,
|
1994-09-07 23:58:32 +00:00
|
|
|
|
"internal error: can't export reloc type %d (`%s')",
|
|
|
|
|
fixp->fx_r_type, bfd_get_reloc_code_name (code));
|
1994-04-05 18:16:37 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
1993-12-16 21:31:22 +00:00
|
|
|
|
assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
|
|
|
|
|
|
|
|
|
|
/* @@ Why fx_addnumber sometimes and fx_offset other times? */
|
|
|
|
|
if (reloc->howto->pc_relative == 0)
|
|
|
|
|
reloc->addend = fixp->fx_addnumber;
|
1994-03-31 21:54:06 +00:00
|
|
|
|
#if defined (OBJ_ELF) || defined (OBJ_COFF)
|
|
|
|
|
else if ((fixp->fx_addsy->bsym->flags & BSF_SECTION_SYM) != 0)
|
|
|
|
|
reloc->addend = (section->vma
|
|
|
|
|
+ fixp->fx_addnumber
|
|
|
|
|
+ md_pcrel_from (fixp));
|
|
|
|
|
#endif
|
1993-12-16 21:31:22 +00:00
|
|
|
|
else
|
1994-01-06 23:17:44 +00:00
|
|
|
|
reloc->addend = fixp->fx_offset - reloc->address;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
|
|
|
|
|
return reloc;
|
|
|
|
|
}
|
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
/* for debugging only */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
static void
|
|
|
|
|
print_insn (insn)
|
|
|
|
|
struct sparc_it *insn;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1993-12-16 21:31:22 +00:00
|
|
|
|
const char *const Reloc[] = {
|
1992-11-23 20:42:33 +00:00
|
|
|
|
"RELOC_8",
|
|
|
|
|
"RELOC_16",
|
|
|
|
|
"RELOC_32",
|
|
|
|
|
"RELOC_DISP8",
|
|
|
|
|
"RELOC_DISP16",
|
|
|
|
|
"RELOC_DISP32",
|
|
|
|
|
"RELOC_WDISP30",
|
|
|
|
|
"RELOC_WDISP22",
|
|
|
|
|
"RELOC_HI22",
|
|
|
|
|
"RELOC_22",
|
|
|
|
|
"RELOC_13",
|
|
|
|
|
"RELOC_LO10",
|
|
|
|
|
"RELOC_SFA_BASE",
|
|
|
|
|
"RELOC_SFA_OFF13",
|
|
|
|
|
"RELOC_BASE10",
|
|
|
|
|
"RELOC_BASE13",
|
|
|
|
|
"RELOC_BASE22",
|
|
|
|
|
"RELOC_PC10",
|
|
|
|
|
"RELOC_PC22",
|
|
|
|
|
"RELOC_JMP_TBL",
|
|
|
|
|
"RELOC_SEGOFF16",
|
|
|
|
|
"RELOC_GLOB_DAT",
|
|
|
|
|
"RELOC_JMP_SLOT",
|
|
|
|
|
"RELOC_RELATIVE",
|
|
|
|
|
"NO_RELOC"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (insn->error)
|
1993-12-16 21:31:22 +00:00
|
|
|
|
fprintf (stderr, "ERROR: %s\n");
|
1992-11-23 20:42:33 +00:00
|
|
|
|
fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
|
|
|
|
|
fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
|
|
|
|
|
fprintf (stderr, "exp = {\n");
|
|
|
|
|
fprintf (stderr, "\t\tX_add_symbol = %s\n",
|
|
|
|
|
((insn->exp.X_add_symbol != NULL)
|
|
|
|
|
? ((S_GET_NAME (insn->exp.X_add_symbol) != NULL)
|
|
|
|
|
? S_GET_NAME (insn->exp.X_add_symbol)
|
|
|
|
|
: "???")
|
|
|
|
|
: "0"));
|
|
|
|
|
fprintf (stderr, "\t\tX_sub_symbol = %s\n",
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|
((insn->exp.X_op_symbol != NULL)
|
|
|
|
|
? (S_GET_NAME (insn->exp.X_op_symbol)
|
|
|
|
|
? S_GET_NAME (insn->exp.X_op_symbol)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
: "???")
|
|
|
|
|
: "0"));
|
|
|
|
|
fprintf (stderr, "\t\tX_add_number = %d\n",
|
|
|
|
|
insn->exp.X_add_number);
|
|
|
|
|
fprintf (stderr, "}\n");
|
1993-12-16 21:31:22 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
#endif
|
1994-06-03 17:42:27 +00:00
|
|
|
|
|
1991-05-22 01:18:42 +00:00
|
|
|
|
/*
|
|
|
|
|
* md_parse_option
|
|
|
|
|
* Invocation line includes a switch not recognized by the base assembler.
|
|
|
|
|
* See if it's a processor-specific option. These are:
|
|
|
|
|
*
|
|
|
|
|
* -bump
|
|
|
|
|
* Warn on architecture bumps. See also -A.
|
|
|
|
|
*
|
1994-07-28 23:36:16 +00:00
|
|
|
|
* -Av6, -Av7, -Av8, -Av9, -Asparclite
|
1991-05-22 01:18:42 +00:00
|
|
|
|
* Select the architecture. Instructions or features not
|
|
|
|
|
* supported by the selected architecture cause fatal errors.
|
|
|
|
|
*
|
|
|
|
|
* The default is to start at v6, and bump the architecture up
|
|
|
|
|
* whenever an instruction is seen at a higher level.
|
|
|
|
|
*
|
|
|
|
|
* If -bump is specified, a warning is printing when bumping to
|
|
|
|
|
* higher levels.
|
|
|
|
|
*
|
|
|
|
|
* If an architecture is specified, all instructions must match
|
|
|
|
|
* that architecture. Any higher level instructions are flagged
|
1992-11-23 20:42:33 +00:00
|
|
|
|
* as errors.
|
1991-05-22 01:18:42 +00:00
|
|
|
|
*
|
|
|
|
|
* if both an architecture and -bump are specified, the
|
|
|
|
|
* architecture starts at the specified level, but bumps are
|
|
|
|
|
* warnings.
|
|
|
|
|
*
|
1993-02-24 23:30:59 +00:00
|
|
|
|
* Note:
|
1992-08-01 23:20:55 +00:00
|
|
|
|
* Bumping between incompatible architectures is always an
|
|
|
|
|
* error. For example, from sparclite to v9.
|
1991-05-22 01:18:42 +00:00
|
|
|
|
*/
|
1993-02-24 23:30:59 +00:00
|
|
|
|
|
1994-06-03 17:42:27 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
CONST char *md_shortopts = "A:VQ:sq";
|
|
|
|
|
#else
|
|
|
|
|
CONST char *md_shortopts = "A:";
|
|
|
|
|
#endif
|
|
|
|
|
struct option md_longopts[] = {
|
|
|
|
|
#define OPTION_BUMP (OPTION_MD_BASE)
|
|
|
|
|
{"bump", no_argument, NULL, OPTION_BUMP},
|
|
|
|
|
#define OPTION_SPARC (OPTION_MD_BASE + 1)
|
|
|
|
|
{"sparc", no_argument, NULL, OPTION_SPARC},
|
|
|
|
|
{NULL, no_argument, NULL, 0}
|
|
|
|
|
};
|
|
|
|
|
size_t md_longopts_size = sizeof(md_longopts);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1994-06-03 17:42:27 +00:00
|
|
|
|
int
|
|
|
|
|
md_parse_option (c, arg)
|
|
|
|
|
int c;
|
|
|
|
|
char *arg;
|
|
|
|
|
{
|
|
|
|
|
switch (c)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
{
|
1994-06-03 17:42:27 +00:00
|
|
|
|
case OPTION_BUMP:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
warn_on_bump = 1;
|
1994-06-03 17:42:27 +00:00
|
|
|
|
break;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1994-06-03 17:42:27 +00:00
|
|
|
|
case 'A':
|
|
|
|
|
{
|
|
|
|
|
char *p = arg;
|
|
|
|
|
const char **arch;
|
|
|
|
|
|
|
|
|
|
for (arch = architecture_pname; *arch != NULL; ++arch)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp (p, *arch) == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
|
break;
|
1994-06-03 17:42:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*arch == NULL)
|
|
|
|
|
{
|
|
|
|
|
as_bad ("invalid architecture -A%s", p);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1994-07-28 23:36:16 +00:00
|
|
|
|
enum sparc_architecture new_arch = arch - architecture_pname;
|
|
|
|
|
#ifdef NO_V9
|
|
|
|
|
if (new_arch == v9)
|
|
|
|
|
{
|
|
|
|
|
as_error ("v9 support not compiled in");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
current_architecture = new_arch;
|
1994-06-03 17:42:27 +00:00
|
|
|
|
architecture_requested = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OPTION_SPARC:
|
|
|
|
|
/* Ignore -sparc, used by SunOS make default .s.o rule. */
|
|
|
|
|
break;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
1993-06-25 09:51:47 +00:00
|
|
|
|
#ifdef OBJ_ELF
|
1994-06-03 17:42:27 +00:00
|
|
|
|
case 'V':
|
1993-06-25 09:51:47 +00:00
|
|
|
|
print_version_id ();
|
1994-06-03 17:42:27 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'Q':
|
1993-06-25 09:51:47 +00:00
|
|
|
|
/* Qy - do emit .comment
|
|
|
|
|
Qn - do not emit .comment */
|
1994-06-03 17:42:27 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 's':
|
1993-06-25 09:51:47 +00:00
|
|
|
|
/* use .stab instead of .stab.excl */
|
1994-06-03 17:42:27 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'q':
|
1994-05-27 16:58:05 +00:00
|
|
|
|
/* quick -- native assembler does fewer checks */
|
1994-06-03 17:42:27 +00:00
|
|
|
|
break;
|
1993-06-25 09:51:47 +00:00
|
|
|
|
#endif
|
1994-06-03 17:42:27 +00:00
|
|
|
|
|
|
|
|
|
default:
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1994-06-03 17:42:27 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
md_show_usage (stream)
|
|
|
|
|
FILE *stream;
|
|
|
|
|
{
|
1994-07-28 23:36:16 +00:00
|
|
|
|
const char **arch;
|
|
|
|
|
fprintf(stream, "SPARC options:\n");
|
|
|
|
|
for (arch = architecture_pname; *arch; arch++)
|
|
|
|
|
{
|
|
|
|
|
if (arch != architecture_pname)
|
|
|
|
|
fprintf (stream, " | ");
|
|
|
|
|
fprintf (stream, "-A%s", *arch);
|
|
|
|
|
}
|
|
|
|
|
fprintf (stream, "\n\
|
1994-06-03 17:42:27 +00:00
|
|
|
|
specify variant of SPARC architecture\n\
|
|
|
|
|
-bump warn when assembler switches architectures\n\
|
|
|
|
|
-sparc ignored\n");
|
|
|
|
|
#ifdef OBJ_ELF
|
|
|
|
|
fprintf(stream, "\
|
|
|
|
|
-V print assembler version number\n\
|
|
|
|
|
-q ignored\n\
|
|
|
|
|
-Qy, -Qn ignored\n\
|
|
|
|
|
-s ignored\n");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
1991-04-04 18:19:53 +00:00
|
|
|
|
/* We have no need to default values of symbols. */
|
|
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
symbolS *
|
|
|
|
|
md_undefined_symbol (name)
|
|
|
|
|
char *name;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return 0;
|
|
|
|
|
} /* md_undefined_symbol() */
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Parse an operand that is machine-specific.
|
|
|
|
|
We just return without modifying the expression if we have nothing
|
|
|
|
|
to do. */
|
|
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
void
|
|
|
|
|
md_operand (expressionP)
|
|
|
|
|
expressionS *expressionP;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1993-02-24 11:24:14 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Round up a section size to the appropriate boundary. */
|
1993-07-07 16:58:29 +00:00
|
|
|
|
valueT
|
1992-11-23 20:42:33 +00:00
|
|
|
|
md_section_align (segment, size)
|
|
|
|
|
segT segment;
|
1993-07-07 16:58:29 +00:00
|
|
|
|
valueT size;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1994-05-19 19:44:02 +00:00
|
|
|
|
#ifndef OBJ_ELF
|
|
|
|
|
/* This is not right for ELF; a.out wants it, and COFF will force
|
|
|
|
|
the alignment anyways. */
|
|
|
|
|
valueT align = (valueT) 1 << (valueT) (stdoutput->xvec->align_power_min);
|
|
|
|
|
valueT newsize;
|
|
|
|
|
/* turn alignment value into a mask */
|
|
|
|
|
align--;
|
|
|
|
|
newsize = (size + align) & ~align;
|
|
|
|
|
return newsize;
|
|
|
|
|
#else
|
1993-08-04 23:10:43 +00:00
|
|
|
|
return size;
|
1994-05-19 19:44:02 +00:00
|
|
|
|
#endif
|
1993-02-24 11:24:14 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
|
|
|
|
/* Exactly what point is a PC-relative offset relative TO?
|
|
|
|
|
On the sparc, they're relative to the address of the offset, plus
|
|
|
|
|
its size. This gets us to the following instruction.
|
|
|
|
|
(??? Is this right? FIXME-SOON) */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
long
|
|
|
|
|
md_pcrel_from (fixP)
|
|
|
|
|
fixS *fixP;
|
1991-04-04 18:19:53 +00:00
|
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
|
1993-02-24 11:24:14 +00:00
|
|
|
|
}
|
1991-04-04 18:19:53 +00:00
|
|
|
|
|
1992-02-13 09:13:54 +00:00
|
|
|
|
/* end of tc-sparc.c */
|