mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-21 01:12:32 +08:00
Code Issues Packages Projects Releases Wiki Activity
d3c258602e
binutils-gdb/gas/config/tc-s390.c

2387 lines
63 KiB
C
Raw Blame History

/* tc-s390.c -- Assemble for the S390
Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
2009, 2010 Free Software Foundation, Inc.
Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
This file is part of GAS, the GNU Assembler.
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
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.
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, 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "struc-symbol.h"
#include "dwarf2dbg.h"
#include "dw2gencfi.h"
#include "opcode/s390.h"
#include "elf/s390.h"
/* The default architecture. */
#ifndef DEFAULT_ARCH
#define DEFAULT_ARCH "s390"
#endif
static char *default_arch = DEFAULT_ARCH;
/* Either 32 or 64, selects file format. */
static int s390_arch_size = 0;
/* If no -march option was given default to the highest available CPU.
Since with S/390 a newer CPU always supports everything from its
predecessors this will accept every valid asm input. */
static unsigned int current_cpu = S390_OPCODE_MAXCPU - 1;
static unsigned int current_mode_mask = 0;
/* Whether to use user friendly register names. Default is TRUE. */
#ifndef TARGET_REG_NAMES_P
#define TARGET_REG_NAMES_P TRUE
#endif
static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
/* Set to TRUE if we want to warn about zero base/index registers. */
static bfd_boolean warn_areg_zero = FALSE;
/* Generic assembler global variables which must be defined by all
targets. */
const char comment_chars[] = "#";
/* Characters which start a comment at the beginning of a line. */
const char line_comment_chars[] = "#";
/* Characters which may be used to separate multiple commands on a
single line. */
const char line_separator_chars[] = ";";
/* Characters which are used to indicate an exponent in a floating
point number. */
const char EXP_CHARS[] = "eE";
/* Characters which mean that a number is a floating point constant,
as in 0d1.0. */
const char FLT_CHARS[] = "dD";
/* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
int s390_cie_data_alignment;
/* The target specific pseudo-ops which we support. */
/* Define the prototypes for the pseudo-ops */
static void s390_byte (int);
static void s390_elf_cons (int);
static void s390_bss (int);
static void s390_insn (int);
static void s390_literals (int);
static void s390_machine (int);
const pseudo_typeS md_pseudo_table[] =
{
{ "align", s_align_bytes, 0 },
/* Pseudo-ops which must be defined. */
{ "bss", s390_bss, 0 },
{ "insn", s390_insn, 0 },
/* Pseudo-ops which must be overridden. */
{ "byte", s390_byte, 0 },
{ "short", s390_elf_cons, 2 },
{ "long", s390_elf_cons, 4 },
{ "quad", s390_elf_cons, 8 },
{ "ltorg", s390_literals, 0 },
{ "string", stringer, 8 + 1 },
{ "machine", s390_machine, 0 },
{ NULL, NULL, 0 }
};
/* Structure to hold information about predefined registers. */
struct pd_reg
{
char *name;
int value;
};
/* List of registers that are pre-defined:
Each access register has a predefined name of the form:
a<reg_num> which has the value <reg_num>.
Each control register has a predefined name of the form:
c<reg_num> which has the value <reg_num>.
Each general register has a predefined name of the form:
r<reg_num> which has the value <reg_num>.
Each floating point register a has predefined name of the form:
f<reg_num> which has the value <reg_num>.
There are individual registers as well:
sp has the value 15
lit has the value 12
The table is sorted. Suitable for searching by a binary search. */
static const struct pd_reg pre_defined_registers[] =
{
{ "a0", 0 }, /* Access registers */
{ "a1", 1 },
{ "a10", 10 },
{ "a11", 11 },
{ "a12", 12 },
{ "a13", 13 },
{ "a14", 14 },
{ "a15", 15 },
{ "a2", 2 },
{ "a3", 3 },
{ "a4", 4 },
{ "a5", 5 },
{ "a6", 6 },
{ "a7", 7 },
{ "a8", 8 },
{ "a9", 9 },
{ "c0", 0 }, /* Control registers */
{ "c1", 1 },
{ "c10", 10 },
{ "c11", 11 },
{ "c12", 12 },
{ "c13", 13 },
{ "c14", 14 },
{ "c15", 15 },
{ "c2", 2 },
{ "c3", 3 },
{ "c4", 4 },
{ "c5", 5 },
{ "c6", 6 },
{ "c7", 7 },
{ "c8", 8 },
{ "c9", 9 },
{ "f0", 0 }, /* Floating point registers */
{ "f1", 1 },
{ "f10", 10 },
{ "f11", 11 },
{ "f12", 12 },
{ "f13", 13 },
{ "f14", 14 },
{ "f15", 15 },
{ "f2", 2 },
{ "f3", 3 },
{ "f4", 4 },
{ "f5", 5 },
{ "f6", 6 },
{ "f7", 7 },
{ "f8", 8 },
{ "f9", 9 },
{ "lit", 13 }, /* Pointer to literal pool */
{ "r0", 0 }, /* General purpose registers */
{ "r1", 1 },
{ "r10", 10 },
{ "r11", 11 },
{ "r12", 12 },
{ "r13", 13 },
{ "r14", 14 },
{ "r15", 15 },
{ "r2", 2 },
{ "r3", 3 },
{ "r4", 4 },
{ "r5", 5 },
{ "r6", 6 },
{ "r7", 7 },
{ "r8", 8 },
{ "r9", 9 },
{ "sp", 15 }, /* Stack pointer */
};
#define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
/* Given NAME, find the register number associated with that name, return
the integer value associated with the given name or -1 on failure. */
static int
reg_name_search (const struct pd_reg *regs, int regcount, const char *name)
{
int middle, low, high;
int cmp;
low = 0;
high = regcount - 1;
do
{
middle = (low + high) / 2;
cmp = strcasecmp (name, regs[middle].name);
if (cmp < 0)
high = middle - 1;
else if (cmp > 0)
low = middle + 1;
else
return regs[middle].value;
}
while (low <= high);
return -1;
}
/*
* Summary of register_name().
*
* in: Input_line_pointer points to 1st char of operand.
*
* out: A expressionS.
* The operand may have been a register: in this case, X_op == O_register,
* X_add_number is set to the register number, and truth is returned.
* Input_line_pointer->(next non-blank) char after operand, or is in its
* original state.
*/
static bfd_boolean
register_name (expressionS *expressionP)
{
int reg_number;
char *name;
char *start;
char c;
/* Find the spelling of the operand. */
start = name = input_line_pointer;
if (name[0] == '%' && ISALPHA (name[1]))
name = ++input_line_pointer;
else
return FALSE;
c = get_symbol_end ();
reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
/* Put back the delimiting char. */
*input_line_pointer = c;
/* Look to see if it's in the register table. */
if (reg_number >= 0)
{
expressionP->X_op = O_register;
expressionP->X_add_number = reg_number;
/* Make the rest nice. */
expressionP->X_add_symbol = NULL;
expressionP->X_op_symbol = NULL;
return TRUE;
}
/* Reset the line as if we had not done anything. */
input_line_pointer = start;
return FALSE;
}
/* Local variables. */
/* Opformat hash table. */
static struct hash_control *s390_opformat_hash;
/* Opcode hash table. */
static struct hash_control *s390_opcode_hash = NULL;
/* Flags to set in the elf header */
static flagword s390_flags = 0;
symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
#ifndef WORKING_DOT_WORD
int md_short_jump_size = 4;
int md_long_jump_size = 4;
#endif
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 if not specified by an option. */
static void
init_default_arch (void)
{
if (strcmp (default_arch, "s390") == 0)
{
if (s390_arch_size == 0)
s390_arch_size = 32;
}
else if (strcmp (default_arch, "s390x") == 0)
{
if (s390_arch_size == 0)
s390_arch_size = 64;
}
else
as_fatal (_("Invalid default architecture, broken assembler."));
if (current_mode_mask == 0)
{
/* Default to z/Architecture mode if the CPU supports it. */
if (current_cpu < S390_OPCODE_Z900)
current_mode_mask = 1 << S390_OPCODE_ESA;
else
current_mode_mask = 1 << S390_OPCODE_ZARCH;
}
}
/* Called by TARGET_FORMAT. */
const char *
s390_target_format (void)
{
/* We don't get a chance to initialize anything before we're called,
so handle that now. */
init_default_arch ();
return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
}
/* Map a CPU string as given with -march= or .machine to the
respective enum s390_opcode_cpu_val value. 0xffffffff is returned
in case of an error. */
static unsigned int
s390_parse_cpu (char *arg)
{
if (strcmp (arg, "g5") == 0)
return S390_OPCODE_G5;
else if (strcmp (arg, "g6") == 0)
return S390_OPCODE_G6;
else if (strcmp (arg, "z900") == 0)
return S390_OPCODE_Z900;
else if (strcmp (arg, "z990") == 0)
return S390_OPCODE_Z990;
else if (strcmp (arg, "z9-109") == 0)
return S390_OPCODE_Z9_109;
else if (strcmp (arg, "z9-ec") == 0)
return S390_OPCODE_Z9_EC;
else if (strcmp (arg, "z10") == 0)
return S390_OPCODE_Z10;
else if (strcmp (arg, "z196") == 0)
return S390_OPCODE_Z196;
else if (strcmp (arg, "all") == 0)
return S390_OPCODE_MAXCPU - 1;
else
return -1;
}
int
md_parse_option (int c, char *arg)
{
switch (c)
{
/* -k: Ignore for FreeBSD compatibility. */
case 'k':
break;
case 'm':
if (arg != NULL && strcmp (arg, "regnames") == 0)
reg_names_p = TRUE;
else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
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)
{
current_cpu = s390_parse_cpu (arg + 5);
if (current_cpu == (unsigned int)-1)
{
as_bad (_("invalid switch -m%s"), arg);
return 0;
}
}
else
{
as_bad (_("invalid switch -m%s"), arg);
return 0;
}
break;
case 'A':
/* Option -A is deprecated. Still available for compatibility. */
if (arg != NULL && strcmp (arg, "esa") == 0)
current_cpu = S390_OPCODE_G5;
else if (arg != NULL && strcmp (arg, "esame") == 0)
current_cpu = S390_OPCODE_Z900;
else
as_bad (_("invalid architecture -A%s"), arg);
break;
/* -V: SVR4 argument to print version ID. */
case 'V':
print_version_id ();
break;
/* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
should be emitted or not. FIXME: Not implemented. */
case 'Q':
break;
default:
return 0;
}
return 1;
}
void
md_show_usage (FILE *stream)
{
fprintf (stream, _("\
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\
-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"));
}
/* Generate the hash table mapping mnemonics to struct s390_opcode.
This table is built at startup and whenever the CPU level is
changed using .machine. */
static void
s390_setup_opcodes (void)
{
register const struct s390_opcode *op;
const struct s390_opcode *op_end;
bfd_boolean dup_insn = FALSE;
const char *retval;
if (s390_opcode_hash != NULL)
hash_die (s390_opcode_hash);
/* Insert the opcodes into a hash table. */
s390_opcode_hash = hash_new ();
op_end = s390_opcodes + s390_num_opcodes;
for (op = s390_opcodes; op < op_end; op++)
{
while (op < op_end - 1 && strcmp(op->name, op[1].name) == 0)
{
if (op->min_cpu <= current_cpu && (op->modes & current_mode_mask))
break;
op++;
}
if (op->min_cpu <= current_cpu && (op->modes & current_mode_mask))
{
retval = hash_insert (s390_opcode_hash, op->name, (void *) op);
if (retval != (const char *) NULL)
{
as_bad (_("Internal assembler error for instruction %s"),
op->name);
dup_insn = TRUE;
}
}
while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0)
op++;
}
if (dup_insn)
abort ();
}
/* This function is called when the assembler starts up. It is called
after the options have been parsed and the output file has been
opened. */
void
md_begin (void)
{
register const struct s390_opcode *op;
const struct s390_opcode *op_end;
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."));
s390_cie_data_alignment = -s390_arch_size / 8;
/* Set the ELF flags if desired. */
if (s390_flags)
bfd_set_private_flags (stdoutput, s390_flags);
/* Insert the opcode formats into a hash table. */
s390_opformat_hash = hash_new ();
op_end = s390_opformats + s390_num_opformats;
for (op = s390_opformats; op < op_end; op++)
{
retval = hash_insert (s390_opformat_hash, op->name, (void *) op);
if (retval != (const char *) NULL)
as_bad (_("Internal assembler error for instruction format %s"),
op->name);
}
s390_setup_opcodes ();
record_alignment (text_section, 2);
record_alignment (data_section, 2);
record_alignment (bss_section, 2);
}
/* Called after all assembly has been done. */
void
s390_md_end (void)
{
if (s390_arch_size == 64)
bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64);
else
bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_31);
}
/* Insert an operand value into an instruction. */
static void
s390_insert_operand (unsigned char *insn,
const struct s390_operand *operand,
offsetT val,
char *file,
unsigned int line)
{
addressT uval;
int offset;
if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
{
offsetT min, max;
max = ((offsetT) 1 << (operand->bits - 1)) - 1;
min = - ((offsetT) 1 << (operand->bits - 1));
/* Halve PCREL operands. */
if (operand->flags & S390_OPERAND_PCREL)
val >>= 1;
/* Check for underflow / overflow. */
if (val < min || val > max)
{
const char *err =
_("operand out of range (%s not between %ld and %ld)");
char buf[100];
if (operand->flags & S390_OPERAND_PCREL)
{
val <<= 1;
min <<= 1;
max <<= 1;
}
sprint_value (buf, val);
if (file == (char *) NULL)
as_bad (err, buf, (int) min, (int) max);
else
as_bad_where (file, line, err, buf, (int) min, (int) max);
return;
}
/* val is ok, now restrict it to operand->bits bits. */
uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
/* val is restrict, now check for special case. */
if (operand->bits == 20 && operand->shift == 20)
uval = (uval >> 12) | ((uval & 0xfff) << 8);
}
else
{
addressT min, max;
max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1;
min = (offsetT) 0;
uval = (addressT) val;
/* Length x in an instructions has real length x+1. */
if (operand->flags & S390_OPERAND_LENGTH)
uval--;
/* Check for underflow / overflow. */
if (uval < min || uval > max)
{
if (operand->flags & S390_OPERAND_LENGTH)
{
uval++;
min++;
max++;
}
as_bad_value_out_of_range (_("operand"), uval, (offsetT) min, (offsetT) max, file, line);
return;
}
}
/* Insert fragments of the operand byte for byte. */
offset = operand->shift + operand->bits;
uval <<= (-offset) & 7;
insn += (offset - 1) / 8;
while (uval != 0)
{
*insn-- |= uval;
uval >>= 8;
}
}
struct map_tls
{
char *string;
int length;
bfd_reloc_code_real_type reloc;
};
/* Parse tls marker and return the desired relocation. */
static bfd_reloc_code_real_type
s390_tls_suffix (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_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;
struct map_bfd
{
char *string;
int length;
elf_suffix_type suffix;
};
/* Parse @got/@plt/@gotoff. and return the desired relocation. */
static elf_suffix_type
s390_elf_suffix (char **str_p, expressionS *exp_p)
{
static struct map_bfd mapping[] =
{
{ "got", 3, ELF_SUFFIX_GOT },
{ "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 }
};
struct map_bfd *ptr;
char *str = *str_p;
char *ident;
int len;
if (*str++ != '@')
return ELF_SUFFIX_NONE;
ident = str;
while (ISALNUM (*str))
str++;
len = str - ident;
for (ptr = &mapping[0]; ptr->length > 0; ptr++)
if (len == ptr->length
&& strncasecmp (ident, ptr->string, ptr->length) == 0)
{
if (exp_p->X_add_number != 0)
as_warn (_("identifier+constant@%s means identifier@%s+constant"),
ptr->string, ptr->string);
/* Now check for identifier@suffix+constant. */
if (*str == '-' || *str == '+')
{
char *orig_line = input_line_pointer;
expressionS new_exp;
input_line_pointer = str;
expression (&new_exp);
switch (new_exp.X_op)
{
case O_constant: /* X_add_number (a constant expression). */
exp_p->X_add_number += new_exp.X_add_number;
str = input_line_pointer;
break;
case O_symbol: /* X_add_symbol + X_add_number. */
/* this case is used for e.g. xyz@PLT+.Label. */
exp_p->X_add_number += new_exp.X_add_number;
exp_p->X_op_symbol = new_exp.X_add_symbol;
exp_p->X_op = O_add;
str = input_line_pointer;
break;
case O_uminus: /* (- X_add_symbol) + X_add_number. */
/* this case is used for e.g. xyz@PLT-.Label. */
exp_p->X_add_number += new_exp.X_add_number;
exp_p->X_op_symbol = new_exp.X_add_symbol;
exp_p->X_op = O_subtract;
str = input_line_pointer;
break;
default:
break;
}
/* If s390_elf_suffix has not been called with
&input_line_pointer as first parameter, we have
clobbered the input_line_pointer. We have to
undo that. */
if (&input_line_pointer != str_p)
input_line_pointer = orig_line;
}
*str_p = str;
return ptr->suffix;
}
return BFD_RELOC_UNUSED;
}
/* Structure used to hold a literal pool entry. */
struct s390_lpe
{
struct s390_lpe *next;
expressionS ex;
FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */
LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */
int nbytes;
bfd_reloc_code_real_type reloc;
symbolS *sym;
};
static struct s390_lpe *lpe_free_list = NULL;
static struct s390_lpe *lpe_list = NULL;
static struct s390_lpe *lpe_list_tail = NULL;
static symbolS *lp_sym = NULL;
static int lp_count = 0;
static int lpe_count = 0;
static int
s390_exp_compare (expressionS *exp1, expressionS *exp2)
{
if (exp1->X_op != exp2->X_op)
return 0;
switch (exp1->X_op)
{
case O_constant: /* X_add_number must be equal. */
case O_register:
return exp1->X_add_number == exp2->X_add_number;
case O_big:
as_bad (_("Can't handle O_big in s390_exp_compare"));
case O_symbol: /* X_add_symbol & X_add_number must be equal. */
case O_symbol_rva:
case O_uminus:
case O_bit_not:
case O_logical_not:
return (exp1->X_add_symbol == exp2->X_add_symbol)
&& (exp1->X_add_number == exp2->X_add_number);
case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
case O_divide:
case O_modulus:
case O_left_shift:
case O_right_shift:
case O_bit_inclusive_or:
case O_bit_or_not:
case O_bit_exclusive_or:
case O_bit_and:
case O_add:
case O_subtract:
case O_eq:
case O_ne:
case O_lt:
case O_le:
case O_ge:
case O_gt:
case O_logical_and:
case O_logical_or:
return (exp1->X_add_symbol == exp2->X_add_symbol)
&& (exp1->X_op_symbol == exp2->X_op_symbol)
&& (exp1->X_add_number == exp2->X_add_number);
default:
return 0;
}
}
/* Test for @lit and if its present make an entry in the literal pool and
modify the current expression to be an offset into the literal pool. */
static elf_suffix_type
s390_lit_suffix (char **str_p, expressionS *exp_p, elf_suffix_type suffix)
{
bfd_reloc_code_real_type reloc;
char tmp_name[64];
char *str = *str_p;
char *ident;
struct s390_lpe *lpe;
int nbytes, len;
if (*str++ != ':')
return suffix; /* No modification. */
/* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
ident = str;
while (ISALNUM (*str))
str++;
len = str - ident;
if (len != 4 || strncasecmp (ident, "lit", 3) != 0
|| (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
return suffix; /* no modification */
nbytes = ident[3] - '0';
reloc = BFD_RELOC_UNUSED;
if (suffix == ELF_SUFFIX_GOT)
{
if (nbytes == 2)
reloc = BFD_RELOC_390_GOT16;
else if (nbytes == 4)
reloc = BFD_RELOC_32_GOT_PCREL;
else if (nbytes == 8)
reloc = BFD_RELOC_390_GOT64;
}
else if (suffix == ELF_SUFFIX_PLT)
{
if (nbytes == 4)
reloc = BFD_RELOC_390_PLT32;
else if (nbytes == 8)
reloc = BFD_RELOC_390_PLT64;
}
if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
as_bad (_("Invalid suffix for literal pool entry"));
/* Search the pool if the new entry is a duplicate. */
if (exp_p->X_op == O_big)
{
/* Special processing for big numbers. */
for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
{
if (lpe->ex.X_op == O_big)
{
if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
{
if (memcmp (&generic_floating_point_number, &lpe->floatnum,
sizeof (FLONUM_TYPE)) == 0)
break;
}
else if (exp_p->X_add_number == lpe->ex.X_add_number)
{
if (memcmp (generic_bignum, lpe->bignum,
sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
break;
}
}
}
}
else
{
/* 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)
break;
}
if (lpe == NULL)
{
/* A new literal. */
if (lpe_free_list != NULL)
{
lpe = lpe_free_list;
lpe_free_list = lpe_free_list->next;
}
else
{
lpe = (struct s390_lpe *) xmalloc (sizeof (struct s390_lpe));
}
lpe->ex = *exp_p;
if (exp_p->X_op == O_big)
{
if (exp_p->X_add_number <= 0)
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));
else
as_bad (_("Big number is too big"));
}
lpe->nbytes = nbytes;
lpe->reloc = reloc;
/* Literal pool name defined ? */
if (lp_sym == NULL)
{
sprintf (tmp_name, ".L\001%i", lp_count);
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);
/* Add to literal pool list. */
lpe->next = NULL;
if (lpe_list_tail != NULL)
{
lpe_list_tail->next = lpe;
lpe_list_tail = lpe;
}
else
lpe_list = lpe_list_tail = lpe;
}
/* Now change exp_p to the offset into the literal pool.
Thats the expression: .L^Ax^By-.L^Ax */
exp_p->X_add_symbol = lpe->sym;
exp_p->X_op_symbol = lp_sym;
exp_p->X_op = O_subtract;
exp_p->X_add_number = 0;
*str_p = str;
/* We change the suffix type to ELF_SUFFIX_NONE, because
the difference of two local labels is just a number. */
return ELF_SUFFIX_NONE;
}
/* Like normal .long/.short/.word, except support @got, etc.
clobbers input_line_pointer, checks end-of-line. */
static void
s390_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long */)
{
expressionS exp;
elf_suffix_type suffix;
if (is_it_end_of_statement ())
{
demand_empty_rest_of_line ();
return;
}
do
{
expression (&exp);
if (exp.X_op == O_symbol
&& *input_line_pointer == '@'
&& (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
{
bfd_reloc_code_real_type reloc;
reloc_howto_type *reloc_howto;
int size;
char *where;
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
&& (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"),
reloc_howto->name, nbytes);
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. */
fix_new_exp (frag_now, where - frag_now->fr_literal,
size, &exp, FALSE, reloc);
}
else
as_bad (_("relocation not applicable"));
}
else
emit_expr (&exp, (unsigned int) nbytes);
}
while (*input_line_pointer++ == ',');
input_line_pointer--; /* Put terminator back into stream. */
demand_empty_rest_of_line ();
}
/* We need to keep a list of fixups. We can't simply generate them as
we go, because that would require us to first create the frag, and
that would screw up references to ``.''. */
struct s390_fixup
{
expressionS exp;
int opindex;
bfd_reloc_code_real_type reloc;
};
#define MAX_INSN_FIXUPS (4)
/* This routine is called for each instruction to be assembled. */
static char *
md_gather_operands (char *str,
unsigned char *insn,
const struct s390_opcode *opcode)
{
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++;
skip_optional = 0;
/* Gather the operands. */
fc = 0;
for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
{
char *hold;
operand = s390_operands + *opindex_ptr;
if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
{
/* We do an early skip. For D(X,B) constructions the index
register is skipped (X is optional). For D(L,B) the base
register will be the skipped operand, because L is NOT
optional. */
skip_optional = 0;
continue;
}
/* Gather the operand. */
hold = input_line_pointer;
input_line_pointer = str;
/* Parse the operand. */
if (! register_name (&ex))
expression (&ex);
str = input_line_pointer;
input_line_pointer = hold;
/* Write the operand to the insn. */
if (ex.X_op == O_illegal)
as_bad (_("illegal operand"));
else if (ex.X_op == O_absent)
{
/* No operands, check if all operands can be skipped. */
while (*opindex_ptr != 0 && operand->flags & S390_OPERAND_OPTIONAL)
{
if (operand->flags & S390_OPERAND_DISP)
{
/* An optional displacement makes the whole D(X,B)
D(L,B) or D(B) block optional. */
do {
operand = s390_operands + *(++opindex_ptr);
} while (!(operand->flags & S390_OPERAND_BASE));
}
operand = s390_operands + *(++opindex_ptr);
}
if (opindex_ptr[0] == '\0')
break;
as_bad (_("missing operand"));
}
else if (ex.X_op == O_register || ex.X_op == O_constant)
{
s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);
if (ex.X_op != O_register && ex.X_op != O_constant)
{
/* We need to generate a fixup for the
expression returned by s390_lit_suffix. */
if (fc >= MAX_INSN_FIXUPS)
as_fatal (_("too many fixups"));
fixups[fc].exp = ex;
fixups[fc].opindex = *opindex_ptr;
fixups[fc].reloc = BFD_RELOC_UNUSED;
++fc;
}
else
{
if ((operand->flags & S390_OPERAND_INDEX)
&& ex.X_add_number == 0
&& warn_areg_zero)
as_warn (_("index register specified but zero"));
if ((operand->flags & S390_OPERAND_BASE)
&& ex.X_add_number == 0
&& warn_areg_zero)
as_warn (_("base register specified but zero"));
if ((operand->flags & S390_OPERAND_GPR)
&& (operand->flags & S390_OPERAND_REG_PAIR)
&& (ex.X_add_number & 1))
as_fatal (_("odd numbered general purpose register specified as "
"register pair"));
if ((operand->flags & S390_OPERAND_FPR)
&& (operand->flags & S390_OPERAND_REG_PAIR)
&& ex.X_add_number != 0 && ex.X_add_number != 1
&& ex.X_add_number != 4 && ex.X_add_number != 5
&& ex.X_add_number != 8 && ex.X_add_number != 9
&& ex.X_add_number != 12 && ex.X_add_number != 13)
as_fatal (_("invalid floating point register pair. Valid fp "
"register pair operands are 0, 1, 4, 5, 8, 9, "
"12 or 13."));
s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
}
}
else
{
suffix = s390_elf_suffix (&str, &ex);
suffix = s390_lit_suffix (&str, &ex, suffix);
reloc = BFD_RELOC_UNUSED;
if (suffix == ELF_SUFFIX_GOT)
{
if ((operand->flags & S390_OPERAND_DISP) &&
(operand->bits == 12))
reloc = BFD_RELOC_390_GOT12;
else if ((operand->flags & S390_OPERAND_DISP) &&
(operand->bits == 20))
reloc = BFD_RELOC_390_GOT20;
else if ((operand->flags & S390_OPERAND_SIGNED)
&& (operand->bits == 16))
reloc = BFD_RELOC_390_GOT16;
else if ((operand->flags & S390_OPERAND_PCREL)
&& (operand->bits == 32))
reloc = BFD_RELOC_390_GOTENT;
}
else if (suffix == ELF_SUFFIX_PLT)
{
if ((operand->flags & S390_OPERAND_PCREL)
&& (operand->bits == 16))
reloc = BFD_RELOC_390_PLT16DBL;
else if ((operand->flags & S390_OPERAND_PCREL)
&& (operand->bits == 32))
reloc = BFD_RELOC_390_PLT32DBL;
}
else if (suffix == ELF_SUFFIX_GOTENT)
{
if ((operand->flags & S390_OPERAND_PCREL)
&& (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 ((operand->flags & S390_OPERAND_DISP)
&& (operand->bits == 20))
reloc = BFD_RELOC_390_TLS_GOTIE20;
}
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"));
/* We need to generate a fixup of type 'reloc' for this
expression. */
if (fc >= MAX_INSN_FIXUPS)
as_fatal (_("too many fixups"));
fixups[fc].exp = ex;
fixups[fc].opindex = *opindex_ptr;
fixups[fc].reloc = reloc;
++fc;
}
/* Check the next character. The call to expression has advanced
str past any whitespace. */
if (operand->flags & S390_OPERAND_DISP)
{
/* After a displacement a block in parentheses can start. */
if (*str != '(')
{
/* Check if parenthesized block can be skipped. If the next
operand is neiter an optional operand nor a base register
then we have a syntax error. */
operand = s390_operands + *(++opindex_ptr);
if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
as_bad (_("syntax error; missing '(' after displacement"));
/* Ok, skip all operands until S390_OPERAND_BASE. */
while (!(operand->flags & S390_OPERAND_BASE))
operand = s390_operands + *(++opindex_ptr);
/* If there is a next operand it must be separated by a comma. */
if (opindex_ptr[1] != '\0')
{
if (*str != ',')
{
while (opindex_ptr[1] != '\0')
{
operand = s390_operands + *(++opindex_ptr);
if (operand->flags & S390_OPERAND_OPTIONAL)
continue;
as_bad (_("syntax error; expected ,"));
break;
}
}
else
str++;
}
}
else
{
/* We found an opening parentheses. */
str++;
for (f = str; *f != '\0'; f++)
if (*f == ',' || *f == ')')
break;
/* If there is no comma until the closing parentheses OR
there is a comma right after the opening parentheses,
we have to skip optional operands. */
if (*f == ',' && f == str)
{
/* comma directly after '(' ? */
skip_optional = 1;
str++;
}
else
skip_optional = (*f != ',');
}
}
else if (operand->flags & S390_OPERAND_BASE)
{
/* After the base register the parenthesed block ends. */
if (*str++ != ')')
as_bad (_("syntax error; missing ')' after base register"));
skip_optional = 0;
/* If there is a next operand it must be separated by a comma. */
if (opindex_ptr[1] != '\0')
{
if (*str != ',')
{
while (opindex_ptr[1] != '\0')
{
operand = s390_operands + *(++opindex_ptr);
if (operand->flags & S390_OPERAND_OPTIONAL)
continue;
as_bad (_("syntax error; expected ,"));
break;
}
}
else
str++;
}
}
else
{
/* We can find an 'early' closing parentheses in e.g. D(L) instead
of D(L,B). In this case the base register has to be skipped. */
if (*str == ')')
{
operand = s390_operands + *(++opindex_ptr);
if (!(operand->flags & S390_OPERAND_BASE))
as_bad (_("syntax error; ')' not allowed here"));
str++;
}
/* If there is a next operand it must be separated by a comma. */
if (opindex_ptr[1] != '\0')
{
if (*str != ',')
{
while (opindex_ptr[1] != '\0')
{
operand = s390_operands + *(++opindex_ptr);
if (operand->flags & S390_OPERAND_OPTIONAL)
continue;
as_bad (_("syntax error; expected ,"));
break;
}
}
else
str++;
}
}
}
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;
if ((linefeed = strchr (str, '\n')) != NULL)
*linefeed = '\0';
as_bad (_("junk at end of line: `%s'"), str);
if (linefeed != NULL)
*linefeed = '\n';
}
/* 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
BFD_RELOC_UNUSED plus the operand index. This lets us easily
handle fixups for any operand type, although that is admittedly
not a very exciting feature. We pick a BFD reloc type in
md_apply_fix. */
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)
{
reloc_howto_type *reloc_howto;
fixS *fixP;
int size;
reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
if (!reloc_howto)
abort ();
size = bfd_get_reloc_size (reloc_howto);
if (size < 1 || size > 4)
abort ();
fixP = fix_new_exp (frag_now,
f - frag_now->fr_literal + (operand->shift/8),
size, &fixups[i].exp, reloc_howto->pc_relative,
fixups[i].reloc);
/* Turn off overflow checking in fixup_segment. This is necessary
because fixup_segment will signal an overflow for large 4 byte
quantities for GOT12 relocations. */
if ( fixups[i].reloc == BFD_RELOC_390_GOT12
|| fixups[i].reloc == BFD_RELOC_390_GOT20
|| fixups[i].reloc == BFD_RELOC_390_GOT16)
fixP->fx_no_overflow = 1;
}
else
fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
(operand->flags & S390_OPERAND_PCREL) != 0,
((bfd_reloc_code_real_type)
(fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
}
return str;
}
/* This routine is called for each instruction to be assembled. */
void
md_assemble (char *str)
{
const struct s390_opcode *opcode;
unsigned char insn[6];
char *s;
/* Get the opcode. */
for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
;
if (*s != '\0')
*s++ = '\0';
/* Look up the opcode in the hash table. */
opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
if (opcode == (const struct s390_opcode *) NULL)
{
as_bad (_("Unrecognized opcode: `%s'"), str);
return;
}
else if (!(opcode->modes & current_mode_mask))
{
as_bad (_("Opcode %s not available in this mode"), str);
return;
}
memcpy (insn, opcode->opcode, sizeof (insn));
md_gather_operands (s, insn, opcode);
}
#ifndef WORKING_DOT_WORD
/* Handle long and short jumps. We don't support these */
void
md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
char *ptr;
addressT from_addr, to_addr;
fragS *frag;
symbolS *to_symbol;
{
abort ();
}
void
md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
char *ptr;
addressT from_addr, to_addr;
fragS *frag;
symbolS *to_symbol;
{
abort ();
}
#endif
void
s390_bss (int ignore ATTRIBUTE_UNUSED)
{
/* We don't support putting frags in the BSS segment, we fake it
by marking in_bss, then looking at s_skip for clues. */
subseg_set (bss_section, 0);
demand_empty_rest_of_line ();
}
/* Pseudo-op handling. */
void
s390_insn (int ignore ATTRIBUTE_UNUSED)
{
expressionS exp;
const struct s390_opcode *opformat;
unsigned char insn[6];
char *s;
/* Get the opcode format. */
s = input_line_pointer;
while (*s != '\0' && *s != ',' && ! ISSPACE (*s))
s++;
if (*s != ',')
as_bad (_("Invalid .insn format\n"));
*s++ = '\0';
/* Look up the opcode in the hash table. */
opformat = (struct s390_opcode *)
hash_find (s390_opformat_hash, input_line_pointer);
if (opformat == (const struct s390_opcode *) NULL)
{
as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
return;
}
input_line_pointer = s;
expression (&exp);
if (exp.X_op == O_constant)
{
if ( ( opformat->oplen == 6
&& (addressT) exp.X_add_number < (1ULL << 48))
|| ( opformat->oplen == 4
&& (addressT) exp.X_add_number < (1ULL << 32))
|| ( opformat->oplen == 2
&& (addressT) exp.X_add_number < (1ULL << 16)))
md_number_to_chars ((char *) insn, exp.X_add_number, opformat->oplen);
else
as_bad (_("Invalid .insn format\n"));
}
else if (exp.X_op == O_big)
{
if (exp.X_add_number > 0
&& opformat->oplen == 6
&& generic_bignum[3] == 0)
{
md_number_to_chars ((char *) insn, generic_bignum[2], 2);
md_number_to_chars ((char *) &insn[2], generic_bignum[1], 2);
md_number_to_chars ((char *) &insn[4], generic_bignum[0], 2);
}
else
as_bad (_("Invalid .insn format\n"));
}
else
as_bad (_("second operand of .insn not a constant\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,
opformat);
if (s != NULL)
*s = '\n';
demand_empty_rest_of_line ();
}
/* The .byte pseudo-op. This is similar to the normal .byte
pseudo-op, but it can also take a single ASCII string. */
static void
s390_byte (int ignore ATTRIBUTE_UNUSED)
{
if (*input_line_pointer != '\"')
{
cons (1);
return;
}
/* Gather characters. A real double quote is doubled. Unusual
characters are not permitted. */
++input_line_pointer;
while (1)
{
char c;
c = *input_line_pointer++;
if (c == '\"')
{
if (*input_line_pointer != '\"')
break;
++input_line_pointer;
}
FRAG_APPEND_1_CHAR (c);
}
demand_empty_rest_of_line ();
}
/* The .ltorg pseudo-op.This emits all literals defined since the last
.ltorg or the invocation of gas. Literals are defined with the
@lit suffix. */
static void
s390_literals (int ignore ATTRIBUTE_UNUSED)
{
struct s390_lpe *lpe;
if (lp_sym == NULL || lpe_count == 0)
return; /* Nothing to be done. */
/* Emit symbol for start of literal pool. */
S_SET_SEGMENT (lp_sym, now_seg);
S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
lp_sym->sy_frag = frag_now;
while (lpe_list)
{
lpe = lpe_list;
lpe_list = lpe_list->next;
S_SET_SEGMENT (lpe->sym, now_seg);
S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
lpe->sym->sy_frag = frag_now;
/* Emit literal pool entry. */
if (lpe->reloc != BFD_RELOC_UNUSED)
{
reloc_howto_type *reloc_howto =
bfd_reloc_type_lookup (stdoutput, lpe->reloc);
int size = bfd_get_reloc_size (reloc_howto);
char *where;
if (size > lpe->nbytes)
as_bad (_("%s relocations do not fit in %d bytes"),
reloc_howto->name, lpe->nbytes);
where = frag_more (lpe->nbytes);
md_number_to_chars (where, 0, size);
fix_new_exp (frag_now, where - frag_now->fr_literal,
size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
}
else
{
if (lpe->ex.X_op == O_big)
{
if (lpe->ex.X_add_number <= 0)
generic_floating_point_number = lpe->floatnum;
else
memcpy (generic_bignum, lpe->bignum,
lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE));
}
emit_expr (&lpe->ex, lpe->nbytes);
}
lpe->next = lpe_free_list;
lpe_free_list = lpe;
}
lpe_list_tail = NULL;
lp_sym = NULL;
lp_count++;
lpe_count = 0;
}
/* The .machine pseudo op allows to switch to a different CPU level in
the asm listing. The current CPU setting can be stored on a stack
with .machine push and restored with .machined pop. */
static void
s390_machine (int ignore ATTRIBUTE_UNUSED)
{
char *cpu_string;
#define MAX_HISTORY 100
static unsigned int *cpu_history;
static int curr_hist;
SKIP_WHITESPACE ();
if (*input_line_pointer == '"')
{
int len;
cpu_string = demand_copy_C_string (&len);
}
else
{
char c;
cpu_string = input_line_pointer;
c = get_symbol_end ();
cpu_string = xstrdup (cpu_string);
*input_line_pointer = c;
}
if (cpu_string != NULL)
{
unsigned int old_cpu = current_cpu;
unsigned int new_cpu;
char *p;
for (p = cpu_string; *p != 0; p++)
*p = TOLOWER (*p);
if (strcmp (cpu_string, "push") == 0)
{
if (cpu_history == NULL)
cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
if (curr_hist >= MAX_HISTORY)
as_bad (_(".machine stack overflow"));
else
cpu_history[curr_hist++] = current_cpu;
}
else if (strcmp (cpu_string, "pop") == 0)
{
if (curr_hist <= 0)
as_bad (_(".machine stack underflow"));
else
current_cpu = cpu_history[--curr_hist];
}
else if ((new_cpu = s390_parse_cpu (cpu_string)) != (unsigned int)-1)
current_cpu = new_cpu;
else
as_bad (_("invalid machine `%s'"), cpu_string);
if (current_cpu != old_cpu)
s390_setup_opcodes ();
}
demand_empty_rest_of_line ();
}
char *
md_atof (int type, char *litp, int *sizep)
{
return ieee_md_atof (type, litp, sizep, TRUE);
}
/* Align a section (I don't know why this is machine dependent). */
valueT
md_section_align (asection *seg, valueT addr)
{
int align = bfd_get_section_alignment (stdoutput, seg);
return ((addr + (1 << align) - 1) & (-1 << align));
}
/* We don't have any form of relaxing. */
int
md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
asection *seg ATTRIBUTE_UNUSED)
{
abort ();
return 0;
}
/* Convert a machine dependent frag. We never generate these. */
void
md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
asection *sec ATTRIBUTE_UNUSED,
fragS *fragp ATTRIBUTE_UNUSED)
{
abort ();
}
symbolS *
md_undefined_symbol (char *name)
{
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;
}
return 0;
}
/* Functions concerning relocs. */
/* The location from which a PC relative jump should be calculated,
given a PC relative reloc. */
long
md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
{
return fixp->fx_frag->fr_address + fixp->fx_where;
}
/* Here we decide which fixups can be adjusted to make them relative to
the beginning of the section instead of the symbol. Basically we need
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 (fixS *fixP)
{
/* 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_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_390_PLT64
|| fixP->fx_r_type == BFD_RELOC_390_GOT12
|| fixP->fx_r_type == BFD_RELOC_390_GOT20
|| fixP->fx_r_type == BFD_RELOC_390_GOT16
|| 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_GOTPLT20
|| 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_GOTIE20
|| 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 1;
}
/* Return true if we must always emit a reloc for a type and false if
there is some hope of resolving it at assembly time. */
int
tc_s390_force_relocation (struct fix *fixp)
{
/* Ensure we emit a relocation for every reference to the global
offset table or to the procedure link table. */
switch (fixp->fx_r_type)
{
case BFD_RELOC_390_GOT12:
case BFD_RELOC_390_GOT20:
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_GOT64:
case BFD_RELOC_390_GOTENT:
case BFD_RELOC_390_PLT32:
case BFD_RELOC_390_PLT16DBL:
case BFD_RELOC_390_PLT32DBL:
case BFD_RELOC_390_PLT64:
case BFD_RELOC_390_GOTPLT12:
case BFD_RELOC_390_GOTPLT16:
case BFD_RELOC_390_GOTPLT20:
case BFD_RELOC_390_GOTPLT32:
case BFD_RELOC_390_GOTPLT64:
case BFD_RELOC_390_GOTPLTENT:
return 1;
default:
break;;
}
return generic_force_reloc (fixp);
}
/* Apply a fixup to the object code. This is called for all the
fixups we generated by the call to fix_new_exp, above. In the call
above we used a reloc code which was the largest legal reloc code
plus the operand index. Here we undo that to recover the operand
index. At this point all symbol values should be fully resolved,
and we attempt to completely resolve the reloc. If we can not do
that, we determine the correct reloc code and put it back in the
fixup. */
void
md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
{
char *where;
valueT value = *valP;
where = fixP->fx_frag->fr_literal + fixP->fx_where;
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_pcrel)
value += fixP->fx_frag->fr_address + fixP->fx_where;
}
else
fixP->fx_done = 1;
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;
operand = &s390_operands[opindex];
if (fixP->fx_done)
{
/* Insert the fully resolved operand value. */
s390_insert_operand ((unsigned char *) where, operand,
(offsetT) value, 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;
if (operand->bits == 12 && operand->shift == 20)
{
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;
}
else if (operand->bits == 20 && operand->shift == 20)
{
fixP->fx_size = 2;
fixP->fx_where += 2;
fixP->fx_r_type = BFD_RELOC_390_20;
}
else if (operand->bits == 8 && operand->shift == 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;
if (operand->flags & S390_OPERAND_PCREL)
{
fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
fixP->fx_offset += 2;
}
else
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;
}
else
{
char *sfile;
unsigned int sline;
/* 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,
_("unresolved expression that must be resolved"));
else
as_bad_where (fixP->fx_file, fixP->fx_line,
_("unsupported relocation type"));
fixP->fx_done = 1;
return;
}
}
else
{
switch (fixP->fx_r_type)
{
case BFD_RELOC_8:
if (fixP->fx_pcrel)
abort ();
if (fixP->fx_done)
md_number_to_chars (where, value, 1);
break;
case BFD_RELOC_390_12:
case BFD_RELOC_390_GOT12:
case BFD_RELOC_390_GOTPLT12:
if (fixP->fx_done)
{
unsigned short mop;
mop = bfd_getb16 ((unsigned char *) where);
mop |= (unsigned short) (value & 0xfff);
bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
}
break;
case BFD_RELOC_390_20:
case BFD_RELOC_390_GOT20:
case BFD_RELOC_390_GOTPLT20:
if (fixP->fx_done)
{
unsigned int mop;
mop = bfd_getb32 ((unsigned char *) where);
mop |= (unsigned int) ((value & 0xfff) << 8 |
(value & 0xff000) >> 12);
bfd_putb32 ((bfd_vma) mop, (unsigned char *) where);
}
break;
case BFD_RELOC_16:
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,
_("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)
: ""));
if (fixP->fx_done)
md_number_to_chars (where, value, 2);
break;
case BFD_RELOC_390_GOT16:
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)
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;
else
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)
md_number_to_chars (where, value, 4);
break;
case BFD_RELOC_32_GOT_PCREL:
case BFD_RELOC_390_PLTOFF32:
case BFD_RELOC_390_PLT32:
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)
md_number_to_chars (where, (offsetT) value >> 1, 4);
break;
case BFD_RELOC_32_GOTOFF:
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:
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;
else
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)
md_number_to_chars (where, value, 8);
break;
case BFD_RELOC_VTABLE_INHERIT:
case BFD_RELOC_VTABLE_ENTRY:
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_GOTIE20:
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:
S_SET_THREAD_LOCAL (fixP->fx_addsy);
/* Fully resolved at link time. */
break;
case BFD_RELOC_390_TLS_IEENT:
/* Fully resolved at link time. */
S_SET_THREAD_LOCAL (fixP->fx_addsy);
value += 2;
break;
default:
{
const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);
if (reloc_name != NULL)
as_fatal (_("Gas failure, reloc type %s\n"), reloc_name);
else
as_fatal (_("Gas failure, reloc type #%i\n"), fixP->fx_r_type);
}
}
fixP->fx_offset = value;
}
}
/* Generate a reloc for a fixup. */
arelent *
tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
{
bfd_reloc_code_real_type code;
arelent *reloc;
code = fixp->fx_r_type;
if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
{
if ( (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL)
|| (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
code = BFD_RELOC_390_GOTPC;
if (code == BFD_RELOC_390_PC32DBL)
code = BFD_RELOC_390_GOTPCDBL;
}
reloc = (arelent *) xmalloc (sizeof (arelent));
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
if (reloc->howto == NULL)
{
as_bad_where (fixp->fx_file, fixp->fx_line,
_("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);
gas_assert (reloc->howto != NULL);
}
reloc->addend = fixp->fx_offset;
return reloc;
}
void
s390_cfi_frame_initial_instructions (void)
{
cfi_add_CFA_def_cfa (15, s390_arch_size == 64 ? 160 : 96);
}
int
tc_s390_regname_to_dw2regnum (char *regname)
{
int regnum = -1;
if (regname[0] != 'c' && regname[0] != 'a')
{
regnum = reg_name_search (pre_defined_registers, REG_NAME_CNT, regname);
if (regname[0] == 'f' && regnum != -1)
regnum += 16;
}
else if (strcmp (regname, "ap") == 0)
regnum = 32;
else if (strcmp (regname, "cc") == 0)
regnum = 33;
return regnum;
}
void
s390_elf_final_processing (void)
{
if (s390_arch_size == 32 && (current_mode_mask & (1 << S390_OPCODE_ZARCH)))
elf_elfheader (stdoutput)->e_flags |= EF_S390_HIGH_GPRS;
}
Reference in New Issue View Git Blame Copy Permalink