/* tc-s390.c -- Assemble for the S390
- Copyright (C) 2000-2017 Free Software Foundation, Inc.
+ Copyright (C) 2000-2023 Free Software Foundation, Inc.
Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
This file is part of GAS, the GNU Assembler.
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
-#include "struc-symbol.h"
#include "dwarf2dbg.h"
#include "dw2gencfi.h"
/* Set to TRUE if the highgprs flag in the ELF header needs to be set
for the output file. */
-static bfd_boolean set_highgprs_p = FALSE;
+static bool set_highgprs_p = false;
/* 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 bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
+static bool 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;
+static bool warn_areg_zero = false;
/* Generic assembler global variables which must be defined by all
targets. */
* original state.
*/
-static bfd_boolean
+static bool
register_name (expressionS *expressionP)
{
int reg_number;
if (name[0] == '%' && ISALPHA (name[1]))
name = ++input_line_pointer;
else
- return FALSE;
+ return false;
c = get_symbol_name (&name);
reg_number = reg_name_search (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. */
/* Opformat hash table. */
-static struct hash_control *s390_opformat_hash;
+static htab_t s390_opformat_hash;
/* Opcode hash table. */
-static struct hash_control *s390_opcode_hash = NULL;
+static htab_t s390_opcode_hash = NULL;
/* Flags to set in the elf header */
static flagword s390_flags = 0;
In case of an error, S390_OPCODE_MAXCPU is returned. */
static unsigned int
-s390_parse_cpu (const char * arg,
- unsigned int * ret_flags,
- bfd_boolean allow_extensions)
+s390_parse_cpu (const char *arg,
+ unsigned int *ret_flags,
+ bool allow_extensions)
{
static struct
{
S390_INSTR_FLAG_HTM },
{ STRING_COMMA_LEN ("z13"), STRING_COMMA_LEN ("arch11"),
S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX },
- { STRING_COMMA_LEN ("arch12"), STRING_COMMA_LEN (""),
+ { STRING_COMMA_LEN ("z14"), STRING_COMMA_LEN ("arch12"),
+ S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX },
+ { STRING_COMMA_LEN ("z15"), STRING_COMMA_LEN ("arch13"),
+ S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX },
+ { STRING_COMMA_LEN ("z16"), STRING_COMMA_LEN ("arch14"),
S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX }
};
static struct
{
- const char * name;
+ const char *name;
unsigned int mask;
- bfd_boolean on;
+ bool on;
} cpu_flags[] =
{
- { "htm", S390_INSTR_FLAG_HTM, TRUE },
- { "nohtm", S390_INSTR_FLAG_HTM, FALSE },
- { "vx", S390_INSTR_FLAG_VX, TRUE },
- { "novx", S390_INSTR_FLAG_VX, FALSE }
+ { "htm", S390_INSTR_FLAG_HTM, true },
+ { "nohtm", S390_INSTR_FLAG_HTM, false },
+ { "vx", S390_INSTR_FLAG_VX, true },
+ { "novx", S390_INSTR_FLAG_VX, false }
};
unsigned int icpu;
char *ilp_bak;
icpu = S390_OPCODE_MAXCPU;
- if (strncmp (arg, "all", 3) == 0 && (arg[3] == 0 || arg[3] == '+'))
+ if (startswith (arg, "all") && (arg[3] == 0 || arg[3] == '+'))
{
icpu = S390_OPCODE_MAXCPU - 1;
arg += 3;
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;
+ warn_areg_zero = true;
else if (arg != NULL && strcmp (arg, "31") == 0)
s390_arch_size = 32;
else if (arg != NULL && strcmp (arg, "zarch") == 0)
{
if (s390_arch_size == 32)
- set_highgprs_p = TRUE;
+ set_highgprs_p = true;
current_mode_mask = 1 << S390_OPCODE_ZARCH;
}
- else if (arg != NULL && strncmp (arg, "arch=", 5) == 0)
+ else if (arg != NULL && startswith (arg, "arch="))
{
- current_cpu = s390_parse_cpu (arg + 5, ¤t_flags, FALSE);
+ current_cpu = s390_parse_cpu (arg + 5, ¤t_flags, false);
if (current_cpu == S390_OPCODE_MAXCPU)
{
as_bad (_("invalid switch -m%s"), arg);
{
const struct s390_opcode *op;
const struct s390_opcode *op_end;
- bfd_boolean dup_insn = FALSE;
- const char *retval;
+ bool dup_insn = false;
if (s390_opcode_hash != NULL)
- hash_die (s390_opcode_hash);
+ htab_delete (s390_opcode_hash);
/* Insert the opcodes into a hash table. */
- s390_opcode_hash = hash_new ();
+ s390_opcode_hash = str_htab_create ();
op_end = s390_opcodes + s390_num_opcodes;
for (op = s390_opcodes; op < op_end; op++)
f = (op->flags & S390_INSTR_FLAG_FACILITY_MASK);
use_opcode = ((f & current_flags) == f);
}
- if (use_opcode)
+ if (use_opcode
+ && str_hash_insert (s390_opcode_hash, op->name, op, 0) != NULL)
{
- 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;
- }
+ as_bad (_("duplicate %s"), op->name);
+ dup_insn = true;
}
while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0)
{
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)
bfd_set_private_flags (stdoutput, s390_flags);
/* Insert the opcode formats into a hash table. */
- s390_opformat_hash = hash_new ();
+ s390_opformat_hash = str_htab_create ();
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);
- }
+ if (str_hash_insert (s390_opformat_hash, op->name, op, 0) != NULL)
+ as_fatal (_("duplicate %s"), op->name);
s390_setup_opcodes ();
/* Called after all assembly has been done. */
void
-s390_md_end (void)
+s390_md_finish (void)
{
if (s390_arch_size == 64)
bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64);
if (val < min || val > max)
{
const char *err =
- _("operand out of range (%s not between %ld and %ld)");
- char buf[100];
+ _("operand out of range (%" PRId64 " not between %" PRId64
+ " and %" PRId64 ")");
if (operand->flags & S390_OPERAND_PCREL)
{
- val <<= 1;
- min <<= 1;
- max <<= 1;
+ val = (offsetT) ((addressT) val << 1);
+ min = (offsetT) ((addressT) min << 1);
+ max = (offsetT) ((addressT) max << 1);
}
- sprint_value (buf, val);
if (file == (char *) NULL)
- as_bad (err, buf, (int) min, (int) max);
+ as_bad (err, (int64_t) val, (int64_t) min, (int64_t) max);
else
- as_bad_where (file, line, err, buf, (int) min, (int) max);
+ as_bad_where (file, line,
+ err, (int64_t) val, (int64_t) min, (int64_t) max);
return;
}
/* val is ok, now restrict it to operand->bits bits. */
return ptr->suffix;
}
- return BFD_RELOC_UNUSED;
+ return ELF_SUFFIX_NONE;
}
/* Structure used to hold a literal pool entry. */
{
size = bfd_get_reloc_size (reloc_howto);
if (size > nbytes)
- as_bad (_("%s relocations do not fit in %d bytes"),
+ as_bad (ngettext ("%s relocations do not fit in %d byte",
+ "%s relocations do not fit in %d bytes",
+ nbytes),
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);
+ size, &exp, false, reloc);
}
else
as_bad (_("relocation not applicable"));
demand_empty_rest_of_line ();
}
+/* Return true if all remaining operands in the opcode with
+ OPCODE_FLAGS can be skipped. */
+static bool
+skip_optargs_p (unsigned int opcode_flags, const unsigned char *opindex_ptr)
+{
+ if ((opcode_flags & (S390_INSTR_FLAG_OPTPARM | S390_INSTR_FLAG_OPTPARM2))
+ && opindex_ptr[0] != '\0'
+ && opindex_ptr[1] == '\0')
+ return true;
+
+ if ((opcode_flags & S390_INSTR_FLAG_OPTPARM2)
+ && opindex_ptr[0] != '\0'
+ && opindex_ptr[1] != '\0'
+ && opindex_ptr[2] == '\0')
+ return true;
+ return false;
+}
+
/* 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 ``.''. */
/* Parse the operand. */
if (! register_name (&ex))
- expression (&ex);
+ {
+ expression (&ex);
+ resolve_register (&ex);
+ }
str = input_line_pointer;
input_line_pointer = hold;
while (!(operand->flags & S390_OPERAND_BASE))
operand = s390_operands + *(++opindex_ptr);
+ if (*str == '\0' && skip_optargs_p (opcode->flags, &opindex_ptr[1]))
+ continue;
+
/* If there is a next operand it must be separated by a comma. */
if (opindex_ptr[1] != '\0')
{
if (*str++ != ')')
as_bad (_("syntax error; missing ')' after base register"));
skip_optional = 0;
+
+ if (*str == '\0' && skip_optargs_p (opcode->flags, &opindex_ptr[1]))
+ continue;
+
/* If there is a next operand it must be separated by a comma. */
if (opindex_ptr[1] != '\0')
{
str++;
}
- if ((opcode->flags & (S390_INSTR_FLAG_OPTPARM
- | S390_INSTR_FLAG_OPTPARM2))
- && opindex_ptr[1] != '\0'
- && opindex_ptr[2] == '\0'
- && *str == '\0')
- continue;
-
- if ((opcode->flags & S390_INSTR_FLAG_OPTPARM2)
- && opindex_ptr[1] != '\0'
- && opindex_ptr[2] != '\0'
- && opindex_ptr[3] == '\0'
- && *str == '\0')
+ if (*str == '\0' && skip_optargs_p (opcode->flags, &opindex_ptr[1]))
continue;
/* If there is a next operand it must be separated by a comma. */
md_apply_fix. */
for (i = 0; i < fc; i++)
{
+ fixS *fixP;
if (fixups[i].opindex < 0)
{
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);
fixP->fx_pcrel_adjust = operand->shift / 8;
}
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)));
+ fixP = 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)));
+ /* s390_insert_operand () does the range checking. */
+ if (operand->flags & S390_OPERAND_PCREL)
+ fixP->fx_no_overflow = 1;
}
return str;
}
*s++ = '\0';
/* Look up the opcode in the hash table. */
- opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
+ opcode = (struct s390_opcode *) str_hash_find (s390_opcode_hash, str);
if (opcode == (const struct s390_opcode *) NULL)
{
as_bad (_("Unrecognized opcode: `%s'"), str);
/* Look up the opcode in the hash table. */
opformat = (struct s390_opcode *)
- hash_find (s390_opformat_hash, input_line_pointer);
+ str_hash_find (s390_opformat_hash, input_line_pointer);
if (opformat == (const struct s390_opcode *) NULL)
{
as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
/* 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;
+ symbol_set_frag (lp_sym, frag_now);
while (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;
+ symbol_set_frag (lpe->sym, frag_now);
/* Emit literal pool entry. */
if (lpe->reloc != BFD_RELOC_UNUSED)
char *where;
if (size > lpe->nbytes)
- as_bad (_("%s relocations do not fit in %d bytes"),
+ as_bad (ngettext ("%s relocations do not fit in %d byte",
+ "%s relocations do not fit in %d bytes",
+ lpe->nbytes),
reloc_howto->name, lpe->nbytes);
where = frag_more (lpe->nbytes);
md_number_to_chars (where, 0, size);
#define MAX_HISTORY 100
-/* The .machine pseudo op allows to switch to a different CPU level in
+/* The .machine pseudo op allows one 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 .machine pop. */
}
}
else
- new_cpu = s390_parse_cpu (cpu_string, &new_flags, TRUE);
+ new_cpu = s390_parse_cpu (cpu_string, &new_flags, true);
if (new_cpu == S390_OPCODE_MAXCPU)
as_bad (_("invalid machine `%s'"), cpu_string);
demand_empty_rest_of_line ();
}
-/* The .machinemode pseudo op allows to switch to a different
+/* The .machinemode pseudo op allows one to switch to a different
architecture mode in the asm listing. The current architecture
mode setting can be stored on a stack with .machinemode push and
restored with .machinemode pop. */
else if (strcmp (mode_string, "zarch") == 0)
{
if (s390_arch_size == 32)
- set_highgprs_p = TRUE;
+ set_highgprs_p = true;
current_mode_mask = 1 << S390_OPCODE_ZARCH;
}
else if (strcmp (mode_string, "zarch_nohighgprs") == 0)
const char *
md_atof (int type, char *litp, int *sizep)
{
- return ieee_md_atof (type, litp, sizep, TRUE);
+ 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);
+ int align = bfd_section_alignment (seg);
return ((addr + (1 << align) - 1) & -(1 << align));
}
if (symbol_find (name))
as_bad (_("GOT already in symbol table"));
GOT_symbol = symbol_new (name, undefined_section,
- (valueT) 0, &zero_address_frag);
+ &zero_address_frag, 0);
}
return GOT_symbol;
}
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));
+ as_bad_subtract (fixP);
if (fixP->fx_addsy != NULL)
{
}
else if (operand->bits == 20 && operand->shift == 20)
{
- fixP->fx_size = 2;
+ fixP->fx_size = 4;
fixP->fx_where += 2;
fixP->fx_r_type = BFD_RELOC_390_20;
}