/* tc-mn10300.c -- Assembler code for the Matsushita 10300
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1996-2019 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
};
-/* Set linkrelax here to avoid fixups in most sections. */
-int linkrelax = 1;
-
static int current_machine;
/* Fixups. */
{ "pc", AM33 },
{ "psw", 0 },
{ "sp", 0 },
+ { "ssp", 0 },
+ { "usp", 0 },
};
#define OTHER_REG_NAME_CNT ARRAY_SIZE (other_registers)
/* Perform a binary search of the given register table REGS to see
- if NAME is a valid regiter name. Returns the register number from
+ if NAME is a valid register name. Returns the register number from
the array on success, or -1 on failure. */
static int
char c;
/* Find the spelling of the operand. */
- start = name = input_line_pointer;
+ start = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&name);
reg_number = reg_name_search (table, table_length, name);
/* Put back the delimiting char. */
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
/* Look to see if it's in the register table. */
if (reg_number >= 0)
char c;
/* Find the spelling of the operand. */
- start = name = input_line_pointer;
+ start = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&name);
reg_number = reg_name_search (other_registers, ARRAY_SIZE (other_registers), name);
/* Put back the delimiting char. */
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
/* Look to see if it's in the register table. */
if (reg_number == 0
}
int
-md_parse_option (int c ATTRIBUTE_UNUSED, char *arg ATTRIBUTE_UNUSED)
+md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED)
{
return 0;
}
return 0;
}
-char *
+const char *
md_atof (int type, char *litp, int *sizep)
{
return ieee_md_atof (type, litp, sizep, FALSE);
valueT
md_section_align (asection *seg, valueT addr)
{
- int align = bfd_get_section_alignment (stdoutput, seg);
+ int align = bfd_section_alignment (seg);
- return ((addr + (1 << align) - 1) & (-1 << align));
+ return ((addr + (1 << align) - 1) & -(1 << align));
}
void
md_begin (void)
{
- char *prev_name = "";
+ const char *prev_name = "";
const struct mn10300_opcode *op;
mn10300_hash = hash_new ();
as_warn (_("could not set architecture and machine"));
current_machine = AM33_2;
-#else
+#else
if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, MN103))
as_warn (_("could not set architecture and machine"));
current_machine = MN103;
#endif
+
+ /* Set linkrelax here to avoid fixups in most sections. */
+ linkrelax = 1;
}
static symbolS *GOT_symbol;
}
void
-mn10300_cons_fix_new (fragS *frag, int off, int size, expressionS *exp)
+mn10300_cons_fix_new (fragS *frag, int off, int size, expressionS *exp,
+ bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)
{
struct mn10300_fixup fixup;
as_bad (_("unsupported BFD relocation size %u"), size);
fixup.reloc = BFD_RELOC_UNUSED;
}
-
+
fix_new_exp (frag, off, size, &fixup.exp, 0, fixup.reloc);
}
}
else if (operand->flags & MN10300_OPERAND_SP)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "sp") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_RREG)
}
else if (operand->flags & MN10300_OPERAND_FPCR)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "fpcr") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_USP)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "usp") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_SSP)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "ssp") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_MSP)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "msp") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_PC)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "pc") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_EPSW)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "epsw") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_PLUS)
}
else if (operand->flags & MN10300_OPERAND_PSW)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "psw") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_MDR)
{
- char *start = input_line_pointer;
- char c = get_symbol_end ();
+ char *start;
+ char c = get_symbol_name (&start);
if (strcasecmp (start, "mdr") != 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
input_line_pointer = hold;
str = hold;
goto error;
}
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
goto keep_going;
}
else if (operand->flags & MN10300_OPERAND_REG_LIST)
if (*input_line_pointer == ',')
input_line_pointer++;
- start = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&start);
if (strcasecmp (start, "d2") == 0)
{
value |= 0x80;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (strcasecmp (start, "d3") == 0)
{
value |= 0x40;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (strcasecmp (start, "a2") == 0)
{
value |= 0x20;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (strcasecmp (start, "a3") == 0)
{
value |= 0x10;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (strcasecmp (start, "other") == 0)
{
value |= 0x08;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (HAVE_AM33
&& strcasecmp (start, "exreg0") == 0)
{
value |= 0x04;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (HAVE_AM33
&& strcasecmp (start, "exreg1") == 0)
{
value |= 0x02;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (HAVE_AM33
&& strcasecmp (start, "exother") == 0)
{
value |= 0x01;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else if (HAVE_AM33
&& strcasecmp (start, "all") == 0)
{
value |= 0xff;
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
}
else
{
as the size of a pointer, so we need a union to convert
the opindex field of the fr_cgen structure into a char *
so that it can be stored in the frag. We do not have
- to worry about loosing accuracy as we are not going to
+ to worry about losing accuracy as we are not going to
be even close to the 32bit limit of the int. */
union
{
&& fixups[i].reloc != BFD_RELOC_32_GOT_PCREL
&& fixups[i].reloc != BFD_RELOC_32_GOTOFF
&& fixups[i].reloc != BFD_RELOC_32_PLT_PCREL
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_GD
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LD
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LDO
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_GOTIE
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_IE
+ && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LE
&& fixups[i].reloc != BFD_RELOC_MN10300_GOT32)
{
reloc_howto_type *reloc_howto;
static arelent * relocs[MAX_RELOC_EXPANSION + 1];
arelent *reloc;
- reloc = xmalloc (sizeof (arelent));
+ reloc = XNEW (arelent);
reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
if (reloc->howto == NULL)
asec = S_GET_SEGMENT (fixp->fx_addsy);
ssec = S_GET_SEGMENT (fixp->fx_subsy);
- reloc->sym_ptr_ptr = NULL;
-
/* If we have a difference between two (non-absolute) symbols we must
generate two relocs (one for each symbol) and allow the linker to
resolve them - relaxation may change the distances between symbols,
even local symbols defined in the same section. */
if (ssec != absolute_section || asec != absolute_section)
{
- arelent * reloc2 = xmalloc (sizeof * reloc);
+ arelent * reloc2 = XNEW (arelent);
relocs[0] = reloc2;
relocs[1] = reloc;
reloc2->address = reloc->address;
reloc2->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_MN10300_SYM_DIFF);
reloc2->addend = - S_GET_VALUE (fixp->fx_subsy);
- reloc2->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
+ reloc2->sym_ptr_ptr = XNEW (asymbol *);
*reloc2->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
- reloc->addend = fixp->fx_offset;
+ reloc->addend = fixp->fx_offset;
if (asec == absolute_section)
- reloc->addend += S_GET_VALUE (fixp->fx_addsy);
-
- reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
- *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
+ {
+ reloc->addend += S_GET_VALUE (fixp->fx_addsy);
+ reloc->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+ }
+ else
+ {
+ reloc->sym_ptr_ptr = XNEW (asymbol *);
+ *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
+ }
fixp->fx_pcrel = 0;
fixp->fx_done = 1;
return relocs;
}
- if (reloc->sym_ptr_ptr)
- free (reloc->sym_ptr_ptr);
free (reloc);
return & no_relocs;
}
}
else
{
- reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
+ reloc->sym_ptr_ptr = XNEW (asymbol *);
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
reloc->addend = fixp->fx_offset;
}
has_known_symbol_location (fragS * fragp, asection * sec)
{
symbolS * sym = fragp->fr_symbol;
-
+
return sym != NULL
&& S_IS_DEFINED (sym)
&& ! S_IS_WEAK (sym)
case BFD_RELOC_MN10300_ALIGN:
fixP->fx_done = 1;
return;
-
+
case BFD_RELOC_NONE:
default:
as_bad_where (fixP->fx_file, fixP->fx_line,
/* Likewise, do not adjust symbols that won't be merged, or debug
symbols, because they too break relaxation. We do want to adjust
- other mergable symbols, like .rodata, because code relaxations
+ other mergeable symbols, like .rodata, because code relaxations
need section-relative symbols to properly relax them. */
if (! (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_MERGE))
return FALSE;
}
static inline char *
-mn10300_end_of_match (char *cont, char *what)
+mn10300_end_of_match (char *cont, const char *what)
{
int len = strlen (what);
return cont + len;
return NULL;
-}
+}
int
mn10300_parse_name (char const *name,
}
exprP->X_add_symbol = symbol_find_or_make (name);
-
+
if (*nextcharP != '@')
goto no_suffix;
else if ((next_end = mn10300_end_of_match (next + 1, "GOTOFF")))
reloc_type = BFD_RELOC_MN10300_GOT32;
else if ((next_end = mn10300_end_of_match (next + 1, "PLT")))
reloc_type = BFD_RELOC_32_PLT_PCREL;
+ else if ((next_end = mn10300_end_of_match (next + 1, "tlsgd")))
+ reloc_type = BFD_RELOC_MN10300_TLS_GD;
+ else if ((next_end = mn10300_end_of_match (next + 1, "tlsldm")))
+ reloc_type = BFD_RELOC_MN10300_TLS_LD;
+ else if ((next_end = mn10300_end_of_match (next + 1, "dtpoff")))
+ reloc_type = BFD_RELOC_MN10300_TLS_LDO;
+ else if ((next_end = mn10300_end_of_match (next + 1, "gotntpoff")))
+ reloc_type = BFD_RELOC_MN10300_TLS_GOTIE;
+ else if ((next_end = mn10300_end_of_match (next + 1, "indntpoff")))
+ reloc_type = BFD_RELOC_MN10300_TLS_IE;
+ else if ((next_end = mn10300_end_of_match (next + 1, "tpoff")))
+ reloc_type = BFD_RELOC_MN10300_TLS_LE;
else
goto no_suffix;
&& now_seg != bss_section
/* Do not create relocs for the merging sections - such
relocs will prevent the contents from being merged. */
- && (bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE) == 0)
+ && (bfd_section_flags (now_seg) & SEC_MERGE) == 0)
/* Create a new fixup to record the alignment request. The symbol is
- irrelevent but must be present so we use the absolute section symbol.
+ irrelevant but must be present so we use the absolute section symbol.
The offset from the symbol is used to record the power-of-two alignment
value. The size is set to 0 because the frag may already be aligned,
thus causing cvt_frag_to_fill to reduce the size of the frag to zero. */
projects / deliverable / binutils-gdb.git / blobdiff