/* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
- Copyright (C) 1998-2016 Free Software Foundation, Inc.
+ Copyright (C) 1998-2017 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
struct hash_control *const_hash; /* constant hash table */
struct hash_control *entry_hash; /* code entry hint hash table */
- /* If X_op is != O_absent, the registername for the instruction's
+ /* If X_op is != O_absent, the register name for the instruction's
qualifying predicate. If NULL, p0 is assumed for instructions
that are predictable. */
expressionS qp;
/* Map 's' to SHF_IA_64_SHORT. */
bfd_vma
-ia64_elf_section_letter (int letter, char **ptr_msg)
+ia64_elf_section_letter (int letter, const char **ptr_msg)
{
if (letter == 's')
return SHF_IA_64_SHORT;
as_bad (_("qualifying predicate not followed by instruction"));
}
-static void
-ia64_do_align (int nbytes)
-{
- char *saved_input_line_pointer = input_line_pointer;
-
- input_line_pointer = "";
- s_align_bytes (nbytes);
- input_line_pointer = saved_input_line_pointer;
-}
-
void
ia64_cons_align (int nbytes)
{
if (md.auto_align)
{
- char *saved_input_line_pointer = input_line_pointer;
- input_line_pointer = "";
- s_align_bytes (nbytes);
- input_line_pointer = saved_input_line_pointer;
+ int log;
+ for (log = 0; (nbytes & 1) != 1; nbytes >>= 1)
+ log++;
+
+ do_align (log, NULL, 0, 0);
}
}
static void
obj_elf_vms_common (int ignore ATTRIBUTE_UNUSED)
{
- char *sec_name;
+ const char *sec_name;
char *sym_name;
char c;
offsetT size;
alloc_record (unw_record_type t)
{
unw_rec_list *ptr;
- ptr = xmalloc (sizeof (*ptr));
+ ptr = XNEW (unw_rec_list);
memset (ptr, 0, sizeof (*ptr));
ptr->slot_number = SLOT_NUM_NOT_SET;
ptr->r.type = t;
if (!imask)
{
imask_size = (region->r.record.r.rlen * 2 + 7) / 8 + 1;
- imask = xmalloc (imask_size);
- memset (imask, 0, imask_size);
+ imask = XCNEWVEC (unsigned char, imask_size);
region->r.record.r.imask_size = imask_size;
region->r.record.r.mask.i = imask;
as_fatal (_("Only constant offsets are supported"));
break;
}
+ /* Fall through. */
case rs_fill:
s_index += 3 * (first_frag->fr_offset >> 4);
break;
for (ptr = list; ptr; ptr = ptr->next)
{
if (ptr->slot_number == SLOT_NUM_NOT_SET)
- as_bad (_(" Insn slot not set in unwind record."));
+ as_bad (_("Insn slot not set in unwind record."));
t = slot_index (ptr->slot_number, ptr->slot_frag,
first_addr, first_frag, before_relax);
switch (ptr->r.type)
e2.X_op = O_absent;
reg1 = e1.X_add_number;
- /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
+ /* Make sure it's a valid ar.xxx reg, OR its br0, aka 'rp'. */
if (e1.X_op != O_register)
{
as_bad (_("First operand to .save not a register"));
char *sec_name;
const char *prefix = special_section_name [sec_index];
const char *suffix;
- size_t prefix_len, suffix_len, sec_name_len;
sec_text_name = segment_name (text_seg);
text_name = sec_text_name;
suffix += sizeof (".gnu.linkonce.t.") - 1;
}
- prefix_len = strlen (prefix);
- suffix_len = strlen (suffix);
- sec_name_len = prefix_len + suffix_len;
- sec_name = alloca (sec_name_len + 1);
- memcpy (sec_name, prefix, prefix_len);
- memcpy (sec_name + prefix_len, suffix, suffix_len);
- sec_name [sec_name_len] = '\0';
+ sec_name = concat (prefix, suffix, NULL);
/* Handle COMDAT group. */
if ((text_seg->flags & SEC_LINK_ONCE) != 0
&& (elf_section_flags (text_seg) & SHF_GROUP) != 0)
{
char *section;
- size_t len, group_name_len;
const char *group_name = elf_group_name (text_seg);
if (group_name == NULL)
as_bad (_("Group section `%s' has no group signature"),
sec_text_name);
ignore_rest_of_line ();
+ free (sec_name);
return;
}
- /* We have to construct a fake section directive. */
- group_name_len = strlen (group_name);
- len = (sec_name_len
- + 16 /* ,"aG",@progbits, */
- + group_name_len /* ,group_name */
- + 7); /* ,comdat */
-
- section = alloca (len + 1);
- memcpy (section, sec_name, sec_name_len);
- memcpy (section + sec_name_len, ",\"aG\",@progbits,", 16);
- memcpy (section + sec_name_len + 16, group_name, group_name_len);
- memcpy (section + len - 7, ",comdat", 7);
- section [len] = '\0';
+
+ /* We have to construct a fake section directive. */
+ section = concat (sec_name, ",\"aG\",@progbits,", group_name, ",comdat", NULL);
set_section (section);
+ free (section);
}
else
{
}
elf_linked_to_section (now_seg) = text_seg;
+ free (sec_name);
}
static void
reg1 = e1.X_add_number;
val = e2.X_add_number;
- /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
+ /* Make sure it's a valid ar.xxx reg, OR its br0, aka 'rp'. */
if (e1.X_op != O_register)
{
as_bad (_("First operand to .%s not a register"), po);
lpc->prologue_count = count;
else
{
- label_prologue_count *new_lpc = xmalloc (sizeof (* new_lpc));
+ label_prologue_count *new_lpc = XNEW (label_prologue_count);
new_lpc->next = unwind.saved_prologue_counts;
new_lpc->label_number = lbl;
}
static void
-free_saved_prologue_counts ()
+free_saved_prologue_counts (void)
{
label_prologue_count *lpc = unwind.saved_prologue_counts;
label_prologue_count *next;
}
else
{
- pending = xmalloc (sizeof (*pending));
+ pending = XNEW (proc_pending);
pending->sym = sym;
last_pending = last_pending->next = pending;
}
}
last_pending->next = NULL;
demand_empty_rest_of_line ();
- ia64_do_align (16);
+ do_align (4, NULL, 0, 0);
unwind.prologue = 0;
unwind.prologue_count = 0;
S_SET_SIZE (sym, frag_now_fix () - S_GET_VALUE (sym));
else
{
- symbol_get_obj (sym)->size =
- (expressionS *) xmalloc (sizeof (expressionS));
+ symbol_get_obj (sym)->size = XNEW (expressionS);
symbol_get_obj (sym)->size->X_op = O_subtract;
symbol_get_obj (sym)->size->X_add_symbol
= symbol_new (FAKE_LABEL_NAME, now_seg,
if (!*drpp)
{
- *drpp = obstack_alloc (¬es, sizeof (*dr));
+ *drpp = XOBNEW (¬es, struct dynreg);
memset (*drpp, 0, sizeof (*dr));
}
- name = obstack_alloc (¬es, len + 1);
+ name = XOBNEWVEC (¬es, char, len + 1);
memcpy (name, start, len);
name[len] = '\0';
switch (kind)
{
case 'd':
- alignment = 8;
+ alignment = 3;
break;
case 'x':
case 'X':
- alignment = 16;
+ alignment = 4;
break;
case 'f':
default:
- alignment = 4;
+ alignment = 2;
break;
}
- ia64_do_align (alignment);
+ do_align (alignment, NULL, 0, 0);
float_cons (kind);
}
/* SOR must be an integer multiple of 8 */
if (e->X_op == O_constant && e->X_add_number & 0x7)
return OPERAND_OUT_OF_RANGE;
+ /* Fall through. */
case IA64_OPND_SOF:
case IA64_OPND_SOL:
if (e->X_op == O_constant)
case IA64_OPND_IMM14:
case IA64_OPND_IMM22:
relocatable = 1;
+ /* Fall through. */
case IA64_OPND_IMM1:
case IA64_OPND_IMM8:
case IA64_OPND_IMM8U4:
++CURR_SLOT.num_fixups;
return OPERAND_MATCH;
}
+ /* Fall through. */
case IA64_OPND_TAG13:
case IA64_OPND_TAG13b:
switch (e->X_op)
}
int
-md_parse_option (int c, char *arg)
+md_parse_option (int c, const char *arg)
{
switch (c)
labels. */
if (defining_tag)
{
- fix = obstack_alloc (¬es, sizeof (*fix));
+ fix = XOBNEW (¬es, struct label_fix);
fix->sym = sym;
fix->next = CURR_SLOT.tag_fixups;
fix->dw2_mark_labels = FALSE;
if (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)
{
md.last_text_seg = now_seg;
- fix = obstack_alloc (¬es, sizeof (*fix));
+ fix = XOBNEW (¬es, struct label_fix);
fix->sym = sym;
fix->next = CURR_SLOT.label_fixups;
fix->dw2_mark_labels = dwarf2_loc_mark_labels;
if (md.path == md.maxpaths)
{
md.maxpaths += 20;
- md.entry_labels = (const char **)
- xrealloc ((void *) md.entry_labels,
- md.maxpaths * sizeof (char *));
+ md.entry_labels = XRESIZEVEC (const char *, md.entry_labels,
+ md.maxpaths);
}
md.entry_labels[md.path++] = S_GET_NAME (sym);
}
}
}
- end = alloca (strlen (name) + 1);
- strcpy (end, name);
+ end = xstrdup (name);
name = ia64_canonicalize_symbol_name (end);
if ((dr = hash_find (md.dynreg_hash, name)))
{
bits. */
e->X_op = O_register;
e->X_add_number = dr->base | (dr->num_regs << 16);
+ free (end);
return 1;
}
+ free (end);
return 0;
}
{
specs[count++] = tmpl;
}
+ /* Fall through. */
case AR_RSC:
if (!rsrc_write &&
(regno == AR_BSPSTORE
if (qp_implieslen == qp_impliestotlen)
{
qp_impliestotlen += 20;
- qp_implies = (struct qp_imply *)
- xrealloc ((void *) qp_implies,
- qp_impliestotlen * sizeof (struct qp_imply));
+ qp_implies = XRESIZEVEC (struct qp_imply, qp_implies, qp_impliestotlen);
}
if (md.debug_dv)
fprintf (stderr, " Registering PR%d implies PR%d\n", p1, p2);
if (qp_mutexeslen == qp_mutexestotlen)
{
qp_mutexestotlen += 20;
- qp_mutexes = (struct qpmutex *)
- xrealloc ((void *) qp_mutexes,
- qp_mutexestotlen * sizeof (struct qpmutex));
+ qp_mutexes = XRESIZEVEC (struct qpmutex, qp_mutexes, qp_mutexestotlen);
}
if (md.debug_dv)
{
if (regdepslen == regdepstotlen)
{
regdepstotlen += 20;
- regdeps = (struct rsrc *)
- xrealloc ((void *) regdeps,
- regdepstotlen * sizeof (struct rsrc));
+ regdeps = XRESIZEVEC (struct rsrc, regdeps, regdepstotlen);
}
regdeps[regdepslen] = *spec;
case IA64_DVS_SPECIFIC:
if (md.debug_dv)
fprintf (stderr, "Implementation-specific, assume worst case...\n");
- /* ...fall through... */
+ /* Fall through. */
case IA64_DVS_INSTR:
if (md.debug_dv)
fprintf (stderr, "Inserting instr serialization\n");
void
md_assemble (char *str)
{
- char *saved_input_line_pointer, *mnemonic;
+ char *saved_input_line_pointer, *temp;
+ const char *mnemonic;
const struct pseudo_opcode *pdesc;
struct ia64_opcode *idesc;
unsigned char qp_regno;
/* extract the opcode (mnemonic): */
- ch = get_symbol_name (&mnemonic);
+ ch = get_symbol_name (&temp);
+ mnemonic = temp;
pdesc = (struct pseudo_opcode *) hash_find (md.pseudo_hash, mnemonic);
if (pdesc)
{
{
arelent *reloc;
- reloc = xmalloc (sizeof (*reloc));
- reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+ reloc = XNEW (arelent);
+ reloc->sym_ptr_ptr = XNEW (asymbol *);
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
reloc->addend = fixp->fx_offset;
#define MAX_LITTLENUMS 5
-char *
+const char *
md_atof (int type, char *lit, int *size)
{
LITTLENUM_TYPE words[MAX_LITTLENUMS];
goto out;
}
- h = (struct alias *) xmalloc (sizeof (struct alias));
+ h = XNEW (struct alias);
h->file = as_where (&h->line);
h->name = name;