/* tc-s390.c -- Assemble for the S390
- Copyright 2000, 2001 Free Software Foundation, Inc.
+ Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
This file is part of GAS, the GNU Assembler.
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ 02111-1307, USA. */
#include <stdio.h>
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "struc-symbol.h"
+#include "dwarf2dbg.h"
#include "opcode/s390.h"
#include "elf/s390.h"
#endif
static char *default_arch = DEFAULT_ARCH;
/* Either 32 or 64, selects file format. */
-static int s390_arch_size;
-/* Current architecture. Start with the smallest instruction set. */
-static enum s390_opcode_arch_val current_architecture = S390_OPCODE_ESA;
-static int current_arch_mask = 1 << S390_OPCODE_ESA;
-static int current_arch_requested = 0;
+static int s390_arch_size = 0;
-/* Whether to use user friendly register names. Default is true. */
+static unsigned int current_mode_mask = 0;
+static unsigned int current_cpu = -1U;
+
+/* Whether to use user friendly register names. Default is TRUE. */
#ifndef TARGET_REG_NAMES_P
-#define TARGET_REG_NAMES_P true
+#define TARGET_REG_NAMES_P TRUE
#endif
-static boolean reg_names_p = TARGET_REG_NAMES_P;
+static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
/* Set to TRUE if we want to warn about zero base/index registers. */
-static boolean warn_areg_zero = FALSE;
+static bfd_boolean warn_areg_zero = FALSE;
/* Generic assembler global variables which must be defined by all
targets. */
const pseudo_typeS md_pseudo_table[] =
{
{ "align", s_align_bytes, 0 },
- /* Pseudo-ops which must be defined. */
+ /* Pseudo-ops which must be defined. */
{ "bss", s390_bss, 0 },
{ "insn", s390_insn, 0 },
/* Pseudo-ops which must be overridden. */
sp has the value 15
lit has the value 12
- The table is sorted. Suitable for searching by a binary search. */
+ The table is sorted. Suitable for searching by a binary search. */
static const struct pd_reg pre_defined_registers[] =
{
static int reg_name_search
PARAMS ((const struct pd_reg *, int, const char *));
-static boolean register_name PARAMS ((expressionS *));
+static bfd_boolean register_name PARAMS ((expressionS *));
static void init_default_arch PARAMS ((void));
static void s390_insert_operand
PARAMS ((unsigned char *, const struct s390_operand *, offsetT, char *,
* original state.
*/
-static boolean
+static bfd_boolean
register_name (expressionP)
expressionS *expressionP;
{
if (name[0] == '%' && ISALPHA (name[1]))
name = ++input_line_pointer;
else
- return false;
+ return FALSE;
c = get_symbol_end ();
reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
/* Make the rest nice. */
expressionP->X_add_symbol = NULL;
expressionP->X_op_symbol = NULL;
- return true;
+ return TRUE;
}
/* Reset the line as if we had not done anything. */
input_line_pointer = start;
- return false;
+ return FALSE;
}
/* Local variables. */
const int md_long_jump_size = 4;
#endif
-CONST char *md_shortopts = "A:m:kVQ:";
+const char *md_shortopts = "A:m:kVQ:";
struct option md_longopts[] = {
{NULL, no_argument, NULL, 0}
};
size_t md_longopts_size = sizeof (md_longopts);
/* Initialize the default opcode arch and word size from the default
- architecture name. */
+ architecture name if not specified by an option. */
static void
init_default_arch ()
{
- if (current_arch_requested)
- return;
-
if (strcmp (default_arch, "s390") == 0)
{
- s390_arch_size = 32;
- current_architecture = S390_OPCODE_ESA;
+ if (s390_arch_size == 0)
+ s390_arch_size = 32;
+ if (current_mode_mask == 0)
+ current_mode_mask = 1 << S390_OPCODE_ESA;
+ if (current_cpu == -1U)
+ current_cpu = S390_OPCODE_G5;
}
else if (strcmp (default_arch, "s390x") == 0)
{
- s390_arch_size = 64;
- current_architecture = S390_OPCODE_ESAME;
+ if (s390_arch_size == 0)
+ s390_arch_size = 64;
+ if (current_mode_mask == 0)
+ current_mode_mask = 1 << S390_OPCODE_ZARCH;
+ if (current_cpu == -1U)
+ current_cpu = S390_OPCODE_Z900;
}
else
as_fatal ("Invalid default architecture, broken assembler.");
- current_arch_mask = 1 << current_architecture;
}
/* Called by TARGET_FORMAT. */
break;
case 'm':
if (arg != NULL && strcmp (arg, "regnames") == 0)
- reg_names_p = true;
+ reg_names_p = TRUE;
else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
- reg_names_p = false;
+ reg_names_p = FALSE;
else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0)
warn_areg_zero = TRUE;
+ else if (arg != NULL && strcmp (arg, "31") == 0)
+ s390_arch_size = 32;
+
+ else if (arg != NULL && strcmp (arg, "64") == 0)
+ s390_arch_size = 64;
+
+ else if (arg != NULL && strcmp (arg, "esa") == 0)
+ current_mode_mask = 1 << S390_OPCODE_ESA;
+
+ else if (arg != NULL && strcmp (arg, "zarch") == 0)
+ current_mode_mask = 1 << S390_OPCODE_ZARCH;
+
+ else if (arg != NULL && strncmp (arg, "arch=", 5) == 0)
+ {
+ if (strcmp (arg + 5, "g5") == 0)
+ current_cpu = S390_OPCODE_G5;
+ else if (strcmp (arg + 5, "g6") == 0)
+ current_cpu = S390_OPCODE_G6;
+ else if (strcmp (arg + 5, "z900") == 0)
+ current_cpu = S390_OPCODE_Z900;
+ else
+ {
+ as_bad (_("invalid switch -m%s"), arg);
+ return 0;
+ }
+ }
+
else
{
as_bad (_("invalid switch -m%s"), arg);
break;
case 'A':
+ /* Option -A is deprecated. Still available for compatability. */
if (arg != NULL && strcmp (arg, "esa") == 0)
- {
- current_architecture = S390_OPCODE_ESA;
- s390_arch_size = 32;
- }
+ current_cpu = S390_OPCODE_G5;
else if (arg != NULL && strcmp (arg, "esame") == 0)
- {
- current_architecture = S390_OPCODE_ESAME;
- s390_arch_size = 64;
- }
+ current_cpu = S390_OPCODE_Z900;
else
as_bad ("invalid architecture -A%s", arg);
- current_arch_mask = 1 << current_architecture;
- current_arch_requested = 1;
break;
/* -V: SVR4 argument to print version ID. */
S390 options:\n\
-mregnames Allow symbolic names for registers\n\
-mwarn-areg-zero Warn about zero base/index registers\n\
- -mno-regnames Do not allow symbolic names for registers\n"));
+ -mno-regnames Do not allow symbolic names for registers\n\
+ -m31 Set file format to 31 bit format\n\
+ -m64 Set file format to 64 bit format\n"));
fprintf (stream, _("\
-V print assembler version number\n\
-Qy, -Qn ignored\n"));
{
register const struct s390_opcode *op;
const struct s390_opcode *op_end;
- boolean dup_insn = false;
+ bfd_boolean dup_insn = FALSE;
const char *retval;
+ /* Give a warning if the combination -m64-bit and -Aesa is used. */
+ if (s390_arch_size == 64 && current_cpu < S390_OPCODE_Z900)
+ as_warn ("The 64 bit file format is used without esame instructions.");
+
/* Set the ELF flags if desired. */
if (s390_flags)
bfd_set_private_flags (stdoutput, s390_flags);
{
as_bad (_("Internal assembler error for instruction format %s"),
op->name);
- dup_insn = true;
+ dup_insn = TRUE;
}
}
if (retval != (const char *) NULL)
{
as_bad (_("Internal assembler error for instruction %s"), op->name);
- dup_insn = true;
+ dup_insn = TRUE;
}
}
s390_md_end ()
{
if (s390_arch_size == 64)
- bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esame);
+ bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64);
else
- bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esa);
+ bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_31);
}
void
{
addressT min, max;
- max = (((addressT) 1 << (operand->bits - 1))<<1) - 1;
+ max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1;
min = (offsetT) 0;
uval = (addressT) val;
/* Length x in an instructions has real length x+1. */
/* Insert fragments of the operand byte for byte. */
offset = operand->shift + operand->bits;
uval <<= (-offset) & 7;
- insn += (offset - 1)/8;
+ insn += (offset - 1) / 8;
while (uval != 0)
{
*insn-- |= uval;
}
}
+struct map_tls
+ {
+ char *string;
+ int length;
+ bfd_reloc_code_real_type reloc;
+ };
+
+static bfd_reloc_code_real_type s390_tls_suffix
+ PARAMS ((char **, expressionS *));
+
+/* Parse tls marker and return the desired relocation. */
+static bfd_reloc_code_real_type
+s390_tls_suffix (str_p, exp_p)
+ char **str_p;
+ expressionS *exp_p;
+{
+ static struct map_tls mapping[] =
+ {
+ { "tls_load", 8, BFD_RELOC_390_TLS_LOAD },
+ { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL },
+ { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL },
+ { NULL, 0, BFD_RELOC_UNUSED }
+ };
+ struct map_tls *ptr;
+ char *orig_line;
+ char *str;
+ char *ident;
+ int len;
+
+ str = *str_p;
+ if (*str++ != ':')
+ return BFD_RELOC_UNUSED;
+
+ ident = str;
+ while (ISIDNUM (*str))
+ str++;
+ len = str - ident;
+ if (*str++ != ':')
+ return BFD_RELOC_UNUSED;
+
+ orig_line = input_line_pointer;
+ input_line_pointer = str;
+ expression (exp_p);
+ str = input_line_pointer;
+ if (&input_line_pointer != str_p)
+ input_line_pointer = orig_line;
+
+ if (exp_p->X_op != O_symbol)
+ return BFD_RELOC_UNUSED;
+
+ for (ptr = &mapping[0]; ptr->length > 0; ptr++)
+ if (len == ptr->length
+ && strncasecmp (ident, ptr->string, ptr->length) == 0)
+ {
+ /* Found a matching tls suffix. */
+ *str_p = str;
+ return ptr->reloc;
+ }
+ return BFD_RELOC_UNUSED;
+}
+
/* Structure used to hold suffixes. */
typedef enum
{
ELF_SUFFIX_NONE = 0,
ELF_SUFFIX_GOT,
ELF_SUFFIX_PLT,
- ELF_SUFFIX_GOTENT
+ ELF_SUFFIX_GOTENT,
+ ELF_SUFFIX_GOTOFF,
+ ELF_SUFFIX_GOTPLT,
+ ELF_SUFFIX_PLTOFF,
+ ELF_SUFFIX_TLS_GD,
+ ELF_SUFFIX_TLS_GOTIE,
+ ELF_SUFFIX_TLS_IE,
+ ELF_SUFFIX_TLS_LDM,
+ ELF_SUFFIX_TLS_LDO,
+ ELF_SUFFIX_TLS_LE
}
elf_suffix_type;
{ "got12", 5, ELF_SUFFIX_GOT },
{ "plt", 3, ELF_SUFFIX_PLT },
{ "gotent", 6, ELF_SUFFIX_GOTENT },
+ { "gotoff", 6, ELF_SUFFIX_GOTOFF },
+ { "gotplt", 6, ELF_SUFFIX_GOTPLT },
+ { "pltoff", 6, ELF_SUFFIX_PLTOFF },
+ { "tlsgd", 5, ELF_SUFFIX_TLS_GD },
+ { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE },
+ { "indntpoff", 9, ELF_SUFFIX_TLS_IE },
+ { "tlsldm", 6, ELF_SUFFIX_TLS_LDM },
+ { "dtpoff", 6, ELF_SUFFIX_TLS_LDO },
+ { "ntpoff", 6, ELF_SUFFIX_TLS_LE },
{ NULL, 0, ELF_SUFFIX_NONE }
};
static int lpe_count = 0;
static int
-s390_exp_compare(exp1, exp2)
+s390_exp_compare (exp1, exp2)
expressionS *exp1;
expressionS *exp2;
{
&& (exp1->X_op_symbol == exp2->X_op_symbol)
&& (exp1->X_add_number == exp2->X_add_number);
default:
- return 0;
- }
+ return 0;
+ }
}
/* Test for @lit and if its present make an entry in the literal pool and
/* Processing for 'normal' data types. */
for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
if (lpe->nbytes == nbytes && lpe->reloc == reloc
- && s390_exp_compare(exp_p, &lpe->ex) != 0)
+ && s390_exp_compare (exp_p, &lpe->ex) != 0)
break;
}
}
else
{
- lpe = (struct s390_lpe *) xmalloc(sizeof (struct s390_lpe));
+ lpe = (struct s390_lpe *) xmalloc (sizeof (struct s390_lpe));
}
lpe->ex = *exp_p;
lpe->floatnum = generic_floating_point_number;
else if (exp_p->X_add_number <= 4)
memcpy (lpe->bignum, generic_bignum,
- exp_p->X_add_number*sizeof (LITTLENUM_TYPE));
+ exp_p->X_add_number * sizeof (LITTLENUM_TYPE));
else
as_bad (_("Big number is too big"));
}
if (lp_sym == NULL)
{
sprintf (tmp_name, ".L\001%i", lp_count);
- lp_sym = symbol_make(tmp_name);
+ lp_sym = symbol_make (tmp_name);
}
/* Make name for literal pool entry. */
sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
lpe_count++;
- lpe->sym = symbol_make(tmp_name);
+ lpe->sym = symbol_make (tmp_name);
/* Add to literal pool list. */
lpe->next = NULL;
int size;
char *where;
- if (nbytes == 2 && suffix == ELF_SUFFIX_GOT)
- reloc = BFD_RELOC_390_GOT16;
- else if (nbytes == 4 && suffix == ELF_SUFFIX_GOT)
- reloc = BFD_RELOC_32_GOT_PCREL;
- else if (nbytes == 8 && suffix == ELF_SUFFIX_GOT)
- reloc = BFD_RELOC_390_GOT64;
- else if (nbytes == 4 && suffix == ELF_SUFFIX_PLT)
- reloc = BFD_RELOC_390_PLT32;
- else if (nbytes == 8 && suffix == ELF_SUFFIX_PLT)
- reloc = BFD_RELOC_390_PLT64;
+ if (nbytes == 2)
+ {
+ static bfd_reloc_code_real_type tab2[] =
+ {
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
+ BFD_RELOC_390_GOT16, /* ELF_SUFFIX_GOT */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_PLT */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
+ BFD_RELOC_16_GOTOFF, /* ELF_SUFFIX_GOTOFF */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTPLT */
+ BFD_RELOC_390_PLTOFF16, /* ELF_SUFFIX_PLTOFF */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GD */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GOTIE */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_IE */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDM */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDO */
+ BFD_RELOC_UNUSED /* ELF_SUFFIX_TLS_LE */
+ };
+ reloc = tab2[suffix];
+ }
+ else if (nbytes == 4)
+ {
+ static bfd_reloc_code_real_type tab4[] =
+ {
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
+ BFD_RELOC_32_GOT_PCREL, /* ELF_SUFFIX_GOT */
+ BFD_RELOC_390_PLT32, /* ELF_SUFFIX_PLT */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
+ BFD_RELOC_32_GOTOFF, /* ELF_SUFFIX_GOTOFF */
+ BFD_RELOC_390_GOTPLT32, /* ELF_SUFFIX_GOTPLT */
+ BFD_RELOC_390_PLTOFF32, /* ELF_SUFFIX_PLTOFF */
+ BFD_RELOC_390_TLS_GD32, /* ELF_SUFFIX_TLS_GD */
+ BFD_RELOC_390_TLS_GOTIE32, /* ELF_SUFFIX_TLS_GOTIE */
+ BFD_RELOC_390_TLS_IE32, /* ELF_SUFFIX_TLS_IE */
+ BFD_RELOC_390_TLS_LDM32, /* ELF_SUFFIX_TLS_LDM */
+ BFD_RELOC_390_TLS_LDO32, /* ELF_SUFFIX_TLS_LDO */
+ BFD_RELOC_390_TLS_LE32 /* ELF_SUFFIX_TLS_LE */
+ };
+ reloc = tab4[suffix];
+ }
+ else if (nbytes == 8)
+ {
+ static bfd_reloc_code_real_type tab8[] =
+ {
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
+ BFD_RELOC_390_GOT64, /* ELF_SUFFIX_GOT */
+ BFD_RELOC_390_PLT64, /* ELF_SUFFIX_PLT */
+ BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
+ BFD_RELOC_390_GOTOFF64, /* ELF_SUFFIX_GOTOFF */
+ BFD_RELOC_390_GOTPLT64, /* ELF_SUFFIX_GOTPLT */
+ BFD_RELOC_390_PLTOFF64, /* ELF_SUFFIX_PLTOFF */
+ BFD_RELOC_390_TLS_GD64, /* ELF_SUFFIX_TLS_GD */
+ BFD_RELOC_390_TLS_GOTIE64, /* ELF_SUFFIX_TLS_GOTIE */
+ BFD_RELOC_390_TLS_IE64, /* ELF_SUFFIX_TLS_IE */
+ BFD_RELOC_390_TLS_LDM64, /* ELF_SUFFIX_TLS_LDM */
+ BFD_RELOC_390_TLS_LDO64, /* ELF_SUFFIX_TLS_LDO */
+ BFD_RELOC_390_TLS_LE64 /* ELF_SUFFIX_TLS_LE */
+ };
+ reloc = tab8[suffix];
+ }
else
reloc = BFD_RELOC_UNUSED;
- if (reloc != BFD_RELOC_UNUSED)
+ if (reloc != BFD_RELOC_UNUSED
+ && (reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc)))
{
- reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
size = bfd_get_reloc_size (reloc_howto);
if (size > nbytes)
as_bad (_("%s relocations do not fit in %d bytes"),
where = frag_more (nbytes);
md_number_to_chars (where, 0, size);
/* To make fixup_segment do the pc relative conversion the
- pcrel parameter on the fix_new_exp call needs to be false. */
+ pcrel parameter on the fix_new_exp call needs to be FALSE. */
fix_new_exp (frag_now, where - frag_now->fr_literal,
- size, &exp, false, reloc);
+ size, &exp, FALSE, reloc);
}
else
as_bad (_("relocation not applicable"));
}
while (*input_line_pointer++ == ',');
- input_line_pointer--; /* Put terminator back into stream. */
+ input_line_pointer--; /* Put terminator back into stream. */
demand_empty_rest_of_line ();
}
struct s390_fixup fixups[MAX_INSN_FIXUPS];
const struct s390_operand *operand;
const unsigned char *opindex_ptr;
+ expressionS ex;
elf_suffix_type suffix;
bfd_reloc_code_real_type reloc;
int skip_optional;
char *f;
int fc, i;
- while (ISSPACE (*str)) str++;
+ while (ISSPACE (*str))
+ str++;
parentheses = 0;
skip_optional = 0;
fc = 0;
for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
{
- expressionS ex;
char *hold;
operand = s390_operands + *opindex_ptr;
hold = input_line_pointer;
input_line_pointer = str;
- if (! register_name (&ex)) /* parse the operand */
+ /* Parse the operand. */
+ if (! register_name (&ex))
expression (&ex);
str = input_line_pointer;
{
if ((operand->flags & S390_OPERAND_INDEX)
&& ex.X_add_number == 0
- && warn_areg_zero == TRUE)
+ && warn_areg_zero)
as_warn ("index register specified but zero");
if ((operand->flags & S390_OPERAND_BASE)
&& ex.X_add_number == 0
- && warn_areg_zero == TRUE)
+ && warn_areg_zero)
as_warn ("base register specified but zero");
s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
}
&& (operand->bits == 32))
reloc = BFD_RELOC_390_GOTENT;
}
+ else if (suffix == ELF_SUFFIX_GOTOFF)
+ {
+ if ((operand->flags & S390_OPERAND_SIGNED)
+ && (operand->bits == 16))
+ reloc = BFD_RELOC_16_GOTOFF;
+ }
+ else if (suffix == ELF_SUFFIX_PLTOFF)
+ {
+ if ((operand->flags & S390_OPERAND_SIGNED)
+ && (operand->bits == 16))
+ reloc = BFD_RELOC_390_PLTOFF16;
+ }
+ else if (suffix == ELF_SUFFIX_GOTPLT)
+ {
+ if ((operand->flags & S390_OPERAND_DISP)
+ && (operand->bits == 12))
+ reloc = BFD_RELOC_390_GOTPLT12;
+ else if ((operand->flags & S390_OPERAND_SIGNED)
+ && (operand->bits == 16))
+ reloc = BFD_RELOC_390_GOTPLT16;
+ else if ((operand->flags & S390_OPERAND_PCREL)
+ && (operand->bits == 32))
+ reloc = BFD_RELOC_390_GOTPLTENT;
+ }
+ else if (suffix == ELF_SUFFIX_TLS_GOTIE)
+ {
+ if ((operand->flags & S390_OPERAND_DISP)
+ && (operand->bits == 12))
+ reloc = BFD_RELOC_390_TLS_GOTIE12;
+ }
+ else if (suffix == ELF_SUFFIX_TLS_IE)
+ {
+ if ((operand->flags & S390_OPERAND_PCREL)
+ && (operand->bits == 32))
+ reloc = BFD_RELOC_390_TLS_IEENT;
+ }
if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
as_bad (_("invalid operand suffix"));
while (ISSPACE (*str))
++str;
+ /* Check for tls instruction marker. */
+ reloc = s390_tls_suffix (&str, &ex);
+ if (reloc != BFD_RELOC_UNUSED)
+ {
+ /* We need to generate a fixup of type 'reloc' for this
+ instruction. */
+ if (fc >= MAX_INSN_FIXUPS)
+ as_fatal (_("too many fixups"));
+ fixups[fc].exp = ex;
+ fixups[fc].opindex = -1;
+ fixups[fc].reloc = reloc;
+ ++fc;
+ }
+
if (*str != '\0')
{
char *linefeed;
/* Write out the instruction. */
f = frag_more (opcode->oplen);
memcpy (f, insn, opcode->oplen);
+ dwarf2_emit_insn (opcode->oplen);
/* Create any fixups. At this point we do not use a
bfd_reloc_code_real_type, but instead just use the
md_apply_fix3. */
for (i = 0; i < fc; i++)
{
+
+ if (fixups[i].opindex < 0)
+ {
+ /* Create tls instruction marker relocation. */
+ fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->oplen,
+ &fixups[i].exp, 0, fixups[i].reloc);
+ continue;
+ }
+
operand = s390_operands + fixups[i].opindex;
if (fixups[i].reloc != BFD_RELOC_UNUSED)
as_bad (_("Unrecognized opcode: `%s'"), str);
return;
}
- else if (!(opcode->architecture & current_arch_mask))
+ else if (!(opcode->modes & current_mode_mask))
{
- as_bad ("Opcode %s not available in this architecture", str);
+ as_bad ("Opcode %s not available in this mode", str);
+ return;
+ }
+ else if (opcode->min_cpu > current_cpu)
+ {
+ as_bad ("Opcode %s not available for this cpu", str);
return;
}
expression (&exp);
if (exp.X_op == O_constant)
{
- if ( ((opformat->oplen == 6) && (exp.X_op > 0) && (exp.X_op < (1ULL << 48)))
- || ((opformat->oplen == 4) && (exp.X_op > 0) && (exp.X_op < (1ULL << 32)))
- || ((opformat->oplen == 2) && (exp.X_op > 0) && (exp.X_op < (1ULL << 16))))
+ if ( (opformat->oplen == 6 && exp.X_op > 0 && exp.X_op < (1ULL << 48))
+ || (opformat->oplen == 4 && exp.X_op > 0 && exp.X_op < (1ULL << 32))
+ || (opformat->oplen == 2 && exp.X_op > 0 && exp.X_op < (1ULL << 16)))
md_number_to_chars (insn, exp.X_add_number, opformat->oplen);
else
as_bad (_("Invalid .insn format\n"));
if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',')
as_bad (_("missing comma after insn constant\n"));
-
+
if ((s = strchr (input_line_pointer, '\n')) != NULL)
*s = '\0';
input_line_pointer = md_gather_operands (input_line_pointer, insn,
struct s390_lpe *lpe;
if (lp_sym == NULL || lpe_count == 0)
- return; /* nothing to be done */
+ return; /* Nothing to be done. */
/* Emit symbol for start of literal pool. */
S_SET_SEGMENT (lp_sym, now_seg);
generic_floating_point_number = lpe->floatnum;
else
memcpy (generic_bignum, lpe->bignum,
- lpe->ex.X_add_number*sizeof (LITTLENUM_TYPE));
+ lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE));
}
emit_expr (&lpe->ex, lpe->nbytes);
}
md_undefined_symbol (name)
char *name;
{
- if (*name == '_' && *(name+1) == 'G'
+ if (*name == '_' && *(name + 1) == 'G'
&& strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
- {
- if (!GOT_symbol)
- {
- if (symbol_find (name))
- as_bad (_("GOT already in symbol table"));
- GOT_symbol = symbol_new (name, undefined_section,
- (valueT) 0, &zero_address_frag);
- }
- return GOT_symbol;
- }
+ {
+ if (!GOT_symbol)
+ {
+ if (symbol_find (name))
+ as_bad (_("GOT already in symbol table"));
+ GOT_symbol = symbol_new (name, undefined_section,
+ (valueT) 0, &zero_address_frag);
+ }
+ return GOT_symbol;
+ }
return 0;
}
to make sure that the dynamic relocations are done correctly, so in
some cases we force the original symbol to be used. */
int
-tc_s390_fix_adjustable(fixP)
- fixS * fixP;
+tc_s390_fix_adjustable (fixP)
+ fixS *fixP;
{
- /* Prevent all adjustments to global symbols. */
- if (S_IS_EXTERN (fixP->fx_addsy))
- return 0;
- if (S_IS_WEAK (fixP->fx_addsy))
+ /* Don't adjust references to merge sections. */
+ if ((S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0)
return 0;
/* adjust_reloc_syms doesn't know about the GOT. */
- if ( fixP->fx_r_type == BFD_RELOC_32_GOTOFF
+ if ( fixP->fx_r_type == BFD_RELOC_16_GOTOFF
+ || fixP->fx_r_type == BFD_RELOC_32_GOTOFF
+ || fixP->fx_r_type == BFD_RELOC_390_GOTOFF64
+ || fixP->fx_r_type == BFD_RELOC_390_PLTOFF16
+ || fixP->fx_r_type == BFD_RELOC_390_PLTOFF32
+ || fixP->fx_r_type == BFD_RELOC_390_PLTOFF64
|| fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
|| fixP->fx_r_type == BFD_RELOC_390_PLT32
|| fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
|| fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
|| fixP->fx_r_type == BFD_RELOC_390_GOT64
|| fixP->fx_r_type == BFD_RELOC_390_GOTENT
+ || fixP->fx_r_type == BFD_RELOC_390_GOTPLT12
+ || fixP->fx_r_type == BFD_RELOC_390_GOTPLT16
+ || fixP->fx_r_type == BFD_RELOC_390_GOTPLT32
+ || fixP->fx_r_type == BFD_RELOC_390_GOTPLT64
+ || fixP->fx_r_type == BFD_RELOC_390_GOTPLTENT
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LOAD
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GDCALL
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LDCALL
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GD32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GD64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE12
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_IE32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_IE64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_IEENT
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LE32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LE64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO32
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO64
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPMOD
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPOFF
+ || fixP->fx_r_type == BFD_RELOC_390_TLS_TPOFF
|| fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
|| fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
return 0;
}
/* Return true if we must always emit a reloc for a type and false if
- there is some hope of resolving it a assembly time. */
+ there is some hope of resolving it at assembly time. */
int
tc_s390_force_relocation (fixp)
struct fix *fixp;
case BFD_RELOC_390_GOT12:
case BFD_RELOC_32_GOT_PCREL:
case BFD_RELOC_32_GOTOFF:
+ case BFD_RELOC_390_GOTOFF64:
+ case BFD_RELOC_390_PLTOFF16:
+ case BFD_RELOC_390_PLTOFF32:
+ case BFD_RELOC_390_PLTOFF64:
case BFD_RELOC_390_GOTPC:
case BFD_RELOC_390_GOT16:
case BFD_RELOC_390_GOTPCDBL:
case BFD_RELOC_390_PLT16DBL:
case BFD_RELOC_390_PLT32DBL:
case BFD_RELOC_390_PLT64:
- case BFD_RELOC_VTABLE_INHERIT:
- case BFD_RELOC_VTABLE_ENTRY:
+ case BFD_RELOC_390_GOTPLT12:
+ case BFD_RELOC_390_GOTPLT16:
+ case BFD_RELOC_390_GOTPLT32:
+ case BFD_RELOC_390_GOTPLT64:
+ case BFD_RELOC_390_GOTPLTENT:
return 1;
default:
- return 0;
+ break;;
}
+
+ return generic_force_reloc (fixp);
}
/* Apply a fixup to the object code. This is called for all the
that, we determine the correct reloc code and put it back in the
fixup. */
-int
-md_apply_fix3 (fixp, valuep, seg)
- fixS *fixp;
- valueT *valuep;
- segT seg;
+void
+md_apply_fix3 (fixP, valP, seg)
+ fixS *fixP;
+ valueT *valP;
+ segT seg ATTRIBUTE_UNUSED;
{
char *where;
- valueT value;
+ valueT value = *valP;
- value = *valuep;
- where = fixp->fx_frag->fr_literal + fixp->fx_where;
+ where = fixP->fx_frag->fr_literal + fixP->fx_where;
- if (fixp->fx_subsy != NULL)
- {
- if ((fixp->fx_addsy != NULL
- && S_GET_SEGMENT (fixp->fx_addsy) == S_GET_SEGMENT (fixp->fx_subsy)
- && SEG_NORMAL (S_GET_SEGMENT (fixp->fx_addsy)))
- || (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section))
- value += S_GET_VALUE (fixp->fx_subsy);
- if (!S_IS_DEFINED (fixp->fx_subsy))
- as_bad_where (fixp->fx_file, fixp->fx_line,
- _("unresolved fx_subsy symbol that must be resolved"));
- value -= S_GET_VALUE(fixp->fx_subsy);
-
- if (S_GET_SEGMENT (fixp->fx_subsy) == seg && ! fixp->fx_pcrel)
- value += MD_PCREL_FROM_SECTION (fixp, seg);
- }
-
- if (fixp->fx_addsy != NULL)
+ if (fixP->fx_subsy != NULL)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "cannot emit relocation %s against subsy symbol %s",
+ bfd_get_reloc_code_name (fixP->fx_r_type),
+ S_GET_NAME (fixP->fx_subsy));
+
+ if (fixP->fx_addsy != NULL)
{
- if ((fixp->fx_subsy != NULL
- && S_GET_SEGMENT (fixp->fx_addsy) == S_GET_SEGMENT (fixp->fx_subsy)
- && SEG_NORMAL (S_GET_SEGMENT(fixp->fx_addsy)))
- || (S_GET_SEGMENT (fixp->fx_addsy) == seg
- && fixp->fx_pcrel && TC_RELOC_RTSYM_LOC_FIXUP (fixp))
- || (!fixp->fx_pcrel
- && S_GET_SEGMENT (fixp->fx_addsy) == absolute_section)
- || (S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
- && !bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy))
- && TC_FIX_ADJUSTABLE(fixp)))
- value -= S_GET_VALUE (fixp->fx_addsy);
-
- if (fixp->fx_pcrel)
- value += fixp->fx_frag->fr_address + fixp->fx_where;
+ if (fixP->fx_pcrel)
+ value += fixP->fx_frag->fr_address + fixP->fx_where;
}
else
- fixp->fx_done = 1;
+ fixP->fx_done = 1;
- if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
+ if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
{
const struct s390_operand *operand;
int opindex;
- opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
+ opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
operand = &s390_operands[opindex];
- if (fixp->fx_done)
+ if (fixP->fx_done)
{
/* Insert the fully resolved operand value. */
s390_insert_operand (where, operand, (offsetT) value,
- fixp->fx_file, fixp->fx_line);
-
- return 1;
+ fixP->fx_file, fixP->fx_line);
+ return;
}
/* Determine a BFD reloc value based on the operand information.
We are only prepared to turn a few of the operands into
relocs. */
- fixp->fx_offset = value;
+ fixP->fx_offset = value;
if (operand->bits == 12 && operand->shift == 20)
{
- fixp->fx_size = 2;
- fixp->fx_where += 2;
- fixp->fx_r_type = BFD_RELOC_390_12;
+ fixP->fx_size = 2;
+ fixP->fx_where += 2;
+ fixP->fx_r_type = BFD_RELOC_390_12;
}
else if (operand->bits == 12 && operand->shift == 36)
{
- fixp->fx_size = 2;
- fixp->fx_where += 4;
- fixp->fx_r_type = BFD_RELOC_390_12;
+ fixP->fx_size = 2;
+ fixP->fx_where += 4;
+ fixP->fx_r_type = BFD_RELOC_390_12;
}
else if (operand->bits == 8 && operand->shift == 8)
{
- fixp->fx_size = 1;
- fixp->fx_where += 1;
- fixp->fx_r_type = BFD_RELOC_8;
+ fixP->fx_size = 1;
+ fixP->fx_where += 1;
+ fixP->fx_r_type = BFD_RELOC_8;
}
else if (operand->bits == 16 && operand->shift == 16)
{
- fixp->fx_size = 2;
- fixp->fx_where += 2;
+ fixP->fx_size = 2;
+ fixP->fx_where += 2;
if (operand->flags & S390_OPERAND_PCREL)
{
- fixp->fx_r_type = BFD_RELOC_390_PC16DBL;
- fixp->fx_offset += 2;
+ fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
+ fixP->fx_offset += 2;
}
else
- fixp->fx_r_type = BFD_RELOC_16;
+ fixP->fx_r_type = BFD_RELOC_16;
}
else if (operand->bits == 32 && operand->shift == 16
&& (operand->flags & S390_OPERAND_PCREL))
{
- fixp->fx_size = 4;
- fixp->fx_where += 2;
- fixp->fx_offset += 2;
- fixp->fx_r_type = BFD_RELOC_390_PC32DBL;
+ fixP->fx_size = 4;
+ fixP->fx_where += 2;
+ fixP->fx_offset += 2;
+ fixP->fx_r_type = BFD_RELOC_390_PC32DBL;
}
else
{
/* Use expr_symbol_where to see if this is an expression
symbol. */
- if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
- as_bad_where (fixp->fx_file, fixp->fx_line,
+ if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
+ as_bad_where (fixP->fx_file, fixP->fx_line,
_("unresolved expression that must be resolved"));
else
- as_bad_where (fixp->fx_file, fixp->fx_line,
+ as_bad_where (fixP->fx_file, fixP->fx_line,
_("unsupported relocation type"));
- fixp->fx_done = 1;
- return 1;
+ fixP->fx_done = 1;
+ return;
}
}
else
{
- switch (fixp->fx_r_type)
+ switch (fixP->fx_r_type)
{
case BFD_RELOC_8:
- if (fixp->fx_pcrel)
+ if (fixP->fx_pcrel)
abort ();
- if (fixp->fx_done)
+ if (fixP->fx_done)
md_number_to_chars (where, value, 1);
break;
case BFD_RELOC_390_12:
case BFD_RELOC_390_GOT12:
- if (fixp->fx_done)
+ case BFD_RELOC_390_GOTPLT12:
+ if (fixP->fx_done)
{
unsigned short mop;
case BFD_RELOC_GPREL16:
case BFD_RELOC_16_GOT_PCREL:
case BFD_RELOC_16_GOTOFF:
- if (fixp->fx_pcrel)
- as_bad_where (fixp->fx_file, fixp->fx_line,
+ if (fixP->fx_pcrel)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
"cannot emit PC relative %s relocation%s%s",
- bfd_get_reloc_code_name (fixp->fx_r_type),
- fixp->fx_addsy != NULL ? " against " : "",
- (fixp->fx_addsy != NULL
- ? S_GET_NAME (fixp->fx_addsy)
+ bfd_get_reloc_code_name (fixP->fx_r_type),
+ fixP->fx_addsy != NULL ? " against " : "",
+ (fixP->fx_addsy != NULL
+ ? S_GET_NAME (fixP->fx_addsy)
: ""));
- if (fixp->fx_done)
+ if (fixP->fx_done)
md_number_to_chars (where, value, 2);
break;
case BFD_RELOC_390_GOT16:
- if (fixp->fx_done)
+ case BFD_RELOC_390_PLTOFF16:
+ case BFD_RELOC_390_GOTPLT16:
+ if (fixP->fx_done)
md_number_to_chars (where, value, 2);
break;
case BFD_RELOC_390_PC16DBL:
case BFD_RELOC_390_PLT16DBL:
value += 2;
- if (fixp->fx_done)
+ if (fixP->fx_done)
md_number_to_chars (where, (offsetT) value >> 1, 2);
break;
case BFD_RELOC_32:
- if (fixp->fx_pcrel)
- fixp->fx_r_type = BFD_RELOC_32_PCREL;
+ if (fixP->fx_pcrel)
+ fixP->fx_r_type = BFD_RELOC_32_PCREL;
else
- fixp->fx_r_type = BFD_RELOC_32;
- if (fixp->fx_done)
+ fixP->fx_r_type = BFD_RELOC_32;
+ if (fixP->fx_done)
md_number_to_chars (where, value, 4);
break;
case BFD_RELOC_32_PCREL:
case BFD_RELOC_32_BASEREL:
- fixp->fx_r_type = BFD_RELOC_32_PCREL;
- if (fixp->fx_done)
+ fixP->fx_r_type = BFD_RELOC_32_PCREL;
+ if (fixP->fx_done)
md_number_to_chars (where, value, 4);
break;
case BFD_RELOC_32_GOT_PCREL:
+ case BFD_RELOC_390_PLTOFF32:
case BFD_RELOC_390_PLT32:
- if (fixp->fx_done)
+ case BFD_RELOC_390_GOTPLT32:
+ if (fixP->fx_done)
md_number_to_chars (where, value, 4);
break;
case BFD_RELOC_390_PC32DBL:
case BFD_RELOC_390_PLT32DBL:
case BFD_RELOC_390_GOTPCDBL:
case BFD_RELOC_390_GOTENT:
+ case BFD_RELOC_390_GOTPLTENT:
value += 2;
- if (fixp->fx_done)
+ if (fixP->fx_done)
md_number_to_chars (where, (offsetT) value >> 1, 4);
break;
case BFD_RELOC_32_GOTOFF:
- if (fixp->fx_done)
+ if (fixP->fx_done)
md_number_to_chars (where, value, sizeof (int));
break;
+ case BFD_RELOC_390_GOTOFF64:
+ if (fixP->fx_done)
+ md_number_to_chars (where, value, 8);
+ break;
+
case BFD_RELOC_390_GOT64:
+ case BFD_RELOC_390_PLTOFF64:
case BFD_RELOC_390_PLT64:
- if (fixp->fx_done)
+ case BFD_RELOC_390_GOTPLT64:
+ if (fixP->fx_done)
md_number_to_chars (where, value, 8);
break;
case BFD_RELOC_64:
- if (fixp->fx_pcrel)
- fixp->fx_r_type = BFD_RELOC_64_PCREL;
+ if (fixP->fx_pcrel)
+ fixP->fx_r_type = BFD_RELOC_64_PCREL;
else
- fixp->fx_r_type = BFD_RELOC_64;
- if (fixp->fx_done)
+ fixP->fx_r_type = BFD_RELOC_64;
+ if (fixP->fx_done)
md_number_to_chars (where, value, 8);
break;
case BFD_RELOC_64_PCREL:
- fixp->fx_r_type = BFD_RELOC_64_PCREL;
- if (fixp->fx_done)
+ fixP->fx_r_type = BFD_RELOC_64_PCREL;
+ if (fixP->fx_done)
md_number_to_chars (where, value, 8);
break;
case BFD_RELOC_VTABLE_INHERIT:
case BFD_RELOC_VTABLE_ENTRY:
- fixp->fx_done = 0;
- return 1;
+ fixP->fx_done = 0;
+ return;
+
+ case BFD_RELOC_390_TLS_LOAD:
+ case BFD_RELOC_390_TLS_GDCALL:
+ case BFD_RELOC_390_TLS_LDCALL:
+ case BFD_RELOC_390_TLS_GD32:
+ case BFD_RELOC_390_TLS_GD64:
+ case BFD_RELOC_390_TLS_GOTIE12:
+ case BFD_RELOC_390_TLS_GOTIE32:
+ case BFD_RELOC_390_TLS_GOTIE64:
+ case BFD_RELOC_390_TLS_LDM32:
+ case BFD_RELOC_390_TLS_LDM64:
+ case BFD_RELOC_390_TLS_IE32:
+ case BFD_RELOC_390_TLS_IE64:
+ case BFD_RELOC_390_TLS_LE32:
+ case BFD_RELOC_390_TLS_LE64:
+ case BFD_RELOC_390_TLS_LDO32:
+ case BFD_RELOC_390_TLS_LDO64:
+ case BFD_RELOC_390_TLS_DTPMOD:
+ case BFD_RELOC_390_TLS_DTPOFF:
+ case BFD_RELOC_390_TLS_TPOFF:
+ /* Fully resolved at link time. */
+ break;
+ case BFD_RELOC_390_TLS_IEENT:
+ /* Fully resolved at link time. */
+ value += 2;
+ break;
default:
{
- const char *reloc_name = bfd_get_reloc_code_name (fixp->fx_r_type);
+ const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);
if (reloc_name != NULL)
fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name);
else
- fprintf (stderr, "Gas failure, reloc type #%i\n", fixp->fx_r_type);
+ fprintf (stderr, "Gas failure, reloc type #%i\n", fixP->fx_r_type);
fflush (stderr);
abort ();
}
}
- fixp->fx_offset = value;
+ fixP->fx_offset = value;
}
-
- return 1;
}
/* Generate a reloc for a fixup. */
if (reloc->howto == NULL)
{
as_bad_where (fixp->fx_file, fixp->fx_line,
- _("cannot represent relocation type %s"),
- bfd_get_reloc_code_name (code));
+ _("cannot represent relocation type %s"),
+ bfd_get_reloc_code_name (code));
/* Set howto to a garbage value so that we can keep going. */
reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
assert (reloc->howto != NULL);
projects / deliverable / binutils-gdb.git / blobdiff