/* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ 2008, 2009 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
#include "opcode/ia64.h"
#include "elf/ia64.h"
+#include "bfdver.h"
+#include <time.h>
#ifdef HAVE_LIMITS_H
#include <limits.h>
/* This is the default endianness. */
static int default_big_endian = TARGET_BYTES_BIG_ENDIAN;
-void (*ia64_number_to_chars) PARAMS ((char *, valueT, int));
+void (*ia64_number_to_chars) (char *, valueT, int);
-static void ia64_float_to_chars_bigendian
- PARAMS ((char *, LITTLENUM_TYPE *, int));
-static void ia64_float_to_chars_littleendian
- PARAMS ((char *, LITTLENUM_TYPE *, int));
-static void (*ia64_float_to_chars)
- PARAMS ((char *, LITTLENUM_TYPE *, int));
+static void ia64_float_to_chars_bigendian (char *, LITTLENUM_TYPE *, int);
+static void ia64_float_to_chars_littleendian (char *, LITTLENUM_TYPE *, int);
+
+static void (*ia64_float_to_chars) (char *, LITTLENUM_TYPE *, int);
static struct hash_control *alias_hash;
static struct hash_control *alias_name_hash;
#define CR_IFS 23
#define CR_IIM 24
#define CR_IHA 25
+#define CR_IIB0 26
+#define CR_IIB1 27
#define CR_LID 64
#define CR_IVR 65
#define CR_TPR 66
{"cr.ifs", CR_IFS},
{"cr.iim", CR_IIM},
{"cr.iha", CR_IHA},
+ {"cr.iib0", CR_IIB0},
+ {"cr.iib1", CR_IIB1},
{"cr.lid", CR_LID},
{"cr.ivr", CR_IVR},
{"cr.tpr", CR_TPR},
#define ENCODED_PSP_OFFSET(OFFSET) (((OFFSET) + 16) / 4)
-typedef void (*vbyte_func) PARAMS ((int, char *, char *));
+typedef void (*vbyte_func) (int, char *, char *);
/* Forward declarations: */
-static void set_section PARAMS ((char *name));
-static unsigned int set_regstack PARAMS ((unsigned int, unsigned int,
- unsigned int, unsigned int));
-static void dot_align (int);
-static void dot_radix PARAMS ((int));
-static void dot_special_section PARAMS ((int));
-static void dot_proc PARAMS ((int));
-static void dot_fframe PARAMS ((int));
-static void dot_vframe PARAMS ((int));
-static void dot_vframesp PARAMS ((int));
-static void dot_save PARAMS ((int));
-static void dot_restore PARAMS ((int));
-static void dot_restorereg PARAMS ((int));
-static void dot_handlerdata PARAMS ((int));
-static void dot_unwentry PARAMS ((int));
-static void dot_altrp PARAMS ((int));
-static void dot_savemem PARAMS ((int));
-static void dot_saveg PARAMS ((int));
-static void dot_savef PARAMS ((int));
-static void dot_saveb PARAMS ((int));
-static void dot_savegf PARAMS ((int));
-static void dot_spill PARAMS ((int));
-static void dot_spillreg PARAMS ((int));
-static void dot_spillmem PARAMS ((int));
-static void dot_label_state PARAMS ((int));
-static void dot_copy_state PARAMS ((int));
-static void dot_unwabi PARAMS ((int));
-static void dot_personality PARAMS ((int));
-static void dot_body PARAMS ((int));
-static void dot_prologue PARAMS ((int));
-static void dot_endp PARAMS ((int));
-static void dot_template PARAMS ((int));
-static void dot_regstk PARAMS ((int));
-static void dot_rot PARAMS ((int));
-static void dot_byteorder PARAMS ((int));
-static void dot_psr PARAMS ((int));
-static void dot_alias PARAMS ((int));
-static void dot_ln PARAMS ((int));
-static void cross_section PARAMS ((int ref, void (*cons) PARAMS((int)), int ua));
-static void dot_xdata PARAMS ((int));
-static void stmt_float_cons PARAMS ((int));
-static void stmt_cons_ua PARAMS ((int));
-static void dot_xfloat_cons PARAMS ((int));
-static void dot_xstringer PARAMS ((int));
-static void dot_xdata_ua PARAMS ((int));
-static void dot_xfloat_cons_ua PARAMS ((int));
-static void print_prmask PARAMS ((valueT mask));
-static void dot_pred_rel PARAMS ((int));
-static void dot_reg_val PARAMS ((int));
-static void dot_serialize PARAMS ((int));
-static void dot_dv_mode PARAMS ((int));
-static void dot_entry PARAMS ((int));
-static void dot_mem_offset PARAMS ((int));
-static void add_unwind_entry PARAMS((unw_rec_list *, int));
-static symbolS *declare_register PARAMS ((const char *name, unsigned int regnum));
-static void declare_register_set PARAMS ((const char *, unsigned int, unsigned int));
-static unsigned int operand_width PARAMS ((enum ia64_opnd));
-static enum operand_match_result operand_match PARAMS ((const struct ia64_opcode *idesc,
- int index,
- expressionS *e));
-static int parse_operand PARAMS ((expressionS *, int));
-static struct ia64_opcode * parse_operands PARAMS ((struct ia64_opcode *));
-static void build_insn PARAMS ((struct slot *, bfd_vma *));
-static void emit_one_bundle PARAMS ((void));
-static void fix_insn PARAMS ((fixS *, const struct ia64_operand *, valueT));
-static bfd_reloc_code_real_type ia64_gen_real_reloc_type PARAMS ((struct symbol *sym,
- bfd_reloc_code_real_type r_type));
-static void insn_group_break PARAMS ((int, int, int));
-static void mark_resource PARAMS ((struct ia64_opcode *, const struct ia64_dependency *,
- struct rsrc *, int depind, int path));
-static void add_qp_mutex PARAMS((valueT mask));
-static void add_qp_imply PARAMS((int p1, int p2));
-static void clear_qp_branch_flag PARAMS((valueT mask));
-static void clear_qp_mutex PARAMS((valueT mask));
-static void clear_qp_implies PARAMS((valueT p1_mask, valueT p2_mask));
-static int has_suffix_p PARAMS((const char *, const char *));
-static void clear_register_values PARAMS ((void));
-static void print_dependency PARAMS ((const char *action, int depind));
-static void instruction_serialization PARAMS ((void));
-static void data_serialization PARAMS ((void));
-static void remove_marked_resource PARAMS ((struct rsrc *));
-static int is_conditional_branch PARAMS ((struct ia64_opcode *));
-static int is_taken_branch PARAMS ((struct ia64_opcode *));
-static int is_interruption_or_rfi PARAMS ((struct ia64_opcode *));
-static int depends_on PARAMS ((int, struct ia64_opcode *));
-static int specify_resource PARAMS ((const struct ia64_dependency *,
- struct ia64_opcode *, int, struct rsrc [], int, int));
-static int check_dv PARAMS((struct ia64_opcode *idesc));
-static void check_dependencies PARAMS((struct ia64_opcode *));
-static void mark_resources PARAMS((struct ia64_opcode *));
-static void update_dependencies PARAMS((struct ia64_opcode *));
-static void note_register_values PARAMS((struct ia64_opcode *));
-static int qp_mutex PARAMS ((int, int, int));
-static int resources_match PARAMS ((struct rsrc *, struct ia64_opcode *, int, int, int));
-static void output_vbyte_mem PARAMS ((int, char *, char *));
-static void count_output PARAMS ((int, char *, char *));
-static void output_R1_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_R2_format PARAMS ((vbyte_func, int, int, unsigned long));
-static void output_R3_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_P1_format PARAMS ((vbyte_func, int));
-static void output_P2_format PARAMS ((vbyte_func, int, int));
-static void output_P3_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_P4_format PARAMS ((vbyte_func, unsigned char *, unsigned long));
-static void output_P5_format PARAMS ((vbyte_func, int, unsigned long));
-static void output_P6_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_P7_format PARAMS ((vbyte_func, unw_record_type, unsigned long, unsigned long));
-static void output_P8_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_P9_format PARAMS ((vbyte_func, int, int));
-static void output_P10_format PARAMS ((vbyte_func, int, int));
-static void output_B1_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_B2_format PARAMS ((vbyte_func, unsigned long, unsigned long));
-static void output_B3_format PARAMS ((vbyte_func, unsigned long, unsigned long));
-static void output_B4_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static char format_ab_reg PARAMS ((int, int));
-static void output_X1_format PARAMS ((vbyte_func, unw_record_type, int, int, unsigned long,
- unsigned long));
-static void output_X2_format PARAMS ((vbyte_func, int, int, int, int, int, unsigned long));
-static void output_X3_format PARAMS ((vbyte_func, unw_record_type, int, int, int, unsigned long,
- unsigned long));
-static void output_X4_format PARAMS ((vbyte_func, int, int, int, int, int, int, unsigned long));
-static unw_rec_list *output_endp PARAMS ((void));
-static unw_rec_list *output_prologue PARAMS ((void));
-static unw_rec_list *output_prologue_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_body PARAMS ((void));
-static unw_rec_list *output_mem_stack_f PARAMS ((unsigned int));
-static unw_rec_list *output_mem_stack_v PARAMS ((void));
-static unw_rec_list *output_psp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_psp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_rp_when PARAMS ((void));
-static unw_rec_list *output_rp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_rp_br PARAMS ((unsigned int));
-static unw_rec_list *output_rp_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_rp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_when PARAMS ((void));
-static unw_rec_list *output_pfs_gr PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_preds_when PARAMS ((void));
-static unw_rec_list *output_preds_gr PARAMS ((unsigned int));
-static unw_rec_list *output_preds_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_preds_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_fr_mem PARAMS ((unsigned int));
-static unw_rec_list *output_frgr_mem PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_gr_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_gr_mem PARAMS ((unsigned int));
-static unw_rec_list *output_br_mem PARAMS ((unsigned int));
-static unw_rec_list *output_br_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_spill_base PARAMS ((unsigned int));
-static unw_rec_list *output_unat_when PARAMS ((void));
-static unw_rec_list *output_unat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_unat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_unat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_lc_when PARAMS ((void));
-static unw_rec_list *output_lc_gr PARAMS ((unsigned int));
-static unw_rec_list *output_lc_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_lc_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_when PARAMS ((void));
-static unw_rec_list *output_fpsr_gr PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_when_gr PARAMS ((void));
-static unw_rec_list *output_priunat_when_mem PARAMS ((void));
-static unw_rec_list *output_priunat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_when PARAMS ((void));
-static unw_rec_list *output_bsp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_when PARAMS ((void));
-static unw_rec_list *output_bspstore_gr PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_when PARAMS ((void));
-static unw_rec_list *output_rnat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_unwabi PARAMS ((unsigned long, unsigned long));
-static unw_rec_list *output_epilogue PARAMS ((unsigned long));
-static unw_rec_list *output_label_state PARAMS ((unsigned long));
-static unw_rec_list *output_copy_state PARAMS ((unsigned long));
-static unw_rec_list *output_spill_psprel PARAMS ((unsigned int, unsigned int, unsigned int,
- unsigned int));
-static unw_rec_list *output_spill_sprel PARAMS ((unsigned int, unsigned int, unsigned int,
- unsigned int));
-static unw_rec_list *output_spill_reg PARAMS ((unsigned int, unsigned int, unsigned int,
- unsigned int, unsigned int));
-static void process_one_record PARAMS ((unw_rec_list *, vbyte_func));
-static void process_unw_records PARAMS ((unw_rec_list *, vbyte_func));
-static int calc_record_size PARAMS ((unw_rec_list *));
-static void set_imask PARAMS ((unw_rec_list *, unsigned long, unsigned long, unsigned int));
-static unsigned long slot_index PARAMS ((unsigned long, fragS *,
- unsigned long, fragS *,
- int));
-static unw_rec_list *optimize_unw_records PARAMS ((unw_rec_list *));
-static void fixup_unw_records PARAMS ((unw_rec_list *, int));
-static int parse_predicate_and_operand PARAMS ((expressionS *, unsigned *, const char *));
-static void convert_expr_to_ab_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int));
-static void convert_expr_to_xy_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int));
-static unsigned int get_saved_prologue_count PARAMS ((unsigned long));
-static void save_prologue_count PARAMS ((unsigned long, unsigned int));
-static void free_saved_prologue_counts PARAMS ((void));
+static void dot_alias (int);
+static int parse_operand_and_eval (expressionS *, int);
+static void emit_one_bundle (void);
+static bfd_reloc_code_real_type ia64_gen_real_reloc_type (struct symbol *,
+ bfd_reloc_code_real_type);
+static void insn_group_break (int, int, int);
+static void add_qp_mutex (valueT);
+static void add_qp_imply (int, int);
+static void clear_qp_mutex (valueT);
+static void clear_qp_implies (valueT, valueT);
+static void print_dependency (const char *, int);
+static void instruction_serialization (void);
+static void data_serialization (void);
+static void output_R3_format (vbyte_func, unw_record_type, unsigned long);
+static void output_B3_format (vbyte_func, unsigned long, unsigned long);
+static void output_B4_format (vbyte_func, unw_record_type, unsigned long);
+static void free_saved_prologue_counts (void);
/* Determine if application register REGNUM resides only in the integer
unit (as opposed to the memory unit). */
don't see any other way to accomplish the same thing without
changing obj-elf.c (which may be the Right Thing, in the end). */
static void
-set_section (name)
- char *name;
+set_section (char *name)
{
char *saved_input_line_pointer;
/* Map 's' to SHF_IA_64_SHORT. */
-int
-ia64_elf_section_letter (letter, ptr_msg)
- int letter;
- char **ptr_msg;
+bfd_vma
+ia64_elf_section_letter (int letter, char **ptr_msg)
{
if (letter == 's')
return SHF_IA_64_SHORT;
else if (letter == 'o')
return SHF_LINK_ORDER;
+#ifdef TE_VMS
+ else if (letter == 'O')
+ return SHF_IA_64_VMS_OVERLAID;
+ else if (letter == 'g')
+ return SHF_IA_64_VMS_GLOBAL;
+#endif
*ptr_msg = _("Bad .section directive: want a,o,s,w,x,M,S,G,T in string");
return -1;
/* Map SHF_IA_64_SHORT to SEC_SMALL_DATA. */
flagword
-ia64_elf_section_flags (flags, attr, type)
- flagword flags;
- int attr, type ATTRIBUTE_UNUSED;
+ia64_elf_section_flags (flagword flags,
+ bfd_vma attr,
+ int type ATTRIBUTE_UNUSED)
{
if (attr & SHF_IA_64_SHORT)
flags |= SEC_SMALL_DATA;
}
int
-ia64_elf_section_type (str, len)
- const char *str;
- size_t len;
+ia64_elf_section_type (const char *str, size_t len)
{
#define STREQ(s) ((len == sizeof (s) - 1) && (strncmp (str, s, sizeof (s) - 1) == 0))
}
static unsigned int
-set_regstack (ins, locs, outs, rots)
- unsigned int ins, locs, outs, rots;
+set_regstack (unsigned int ins,
+ unsigned int locs,
+ unsigned int outs,
+ unsigned int rots)
{
/* Size of frame. */
unsigned int sof;
}
void
-ia64_flush_insns ()
+ia64_flush_insns (void)
{
struct label_fix *lfix;
segT saved_seg;
dwarf2_where (&CURR_SLOT.debug_line);
CURR_SLOT.debug_line.flags |= DWARF2_FLAG_BASIC_BLOCK;
dwarf2_gen_line_info (frag_now_fix (), &CURR_SLOT.debug_line);
+ dwarf2_consume_line_info ();
}
CURR_SLOT.label_fixups = 0;
}
void
-ia64_cons_align (nbytes)
- int nbytes;
+ia64_cons_align (int nbytes)
{
if (md.auto_align)
{
/* Output COUNT bytes to a memory location. */
static char *vbyte_mem_ptr = NULL;
-void
-output_vbyte_mem (count, ptr, comment)
- int count;
- char *ptr;
- char *comment ATTRIBUTE_UNUSED;
+static void
+output_vbyte_mem (int count, char *ptr, char *comment ATTRIBUTE_UNUSED)
{
int x;
if (vbyte_mem_ptr == NULL)
/* Count the number of bytes required for records. */
static int vbyte_count = 0;
-void
-count_output (count, ptr, comment)
- int count;
- char *ptr ATTRIBUTE_UNUSED;
- char *comment ATTRIBUTE_UNUSED;
+static void
+count_output (int count,
+ char *ptr ATTRIBUTE_UNUSED,
+ char *comment ATTRIBUTE_UNUSED)
{
vbyte_count += count;
}
static void
-output_R1_format (f, rtype, rlen)
- vbyte_func f;
- unw_record_type rtype;
- int rlen;
+output_R1_format (vbyte_func f, unw_record_type rtype, int rlen)
{
int r = 0;
char byte;
}
static void
-output_R2_format (f, mask, grsave, rlen)
- vbyte_func f;
- int mask, grsave;
- unsigned long rlen;
+output_R2_format (vbyte_func f, int mask, int grsave, unsigned long rlen)
{
char bytes[20];
int count = 2;
}
static void
-output_R3_format (f, rtype, rlen)
- vbyte_func f;
- unw_record_type rtype;
- unsigned long rlen;
+output_R3_format (vbyte_func f, unw_record_type rtype, unsigned long rlen)
{
int r = 0, count;
char bytes[20];
}
static void
-output_P1_format (f, brmask)
- vbyte_func f;
- int brmask;
+output_P1_format (vbyte_func f, int brmask)
{
char byte;
byte = UNW_P1 | (brmask & 0x1f);
}
static void
-output_P2_format (f, brmask, gr)
- vbyte_func f;
- int brmask;
- int gr;
+output_P2_format (vbyte_func f, int brmask, int gr)
{
char bytes[2];
brmask = (brmask & 0x1f);
}
static void
-output_P3_format (f, rtype, reg)
- vbyte_func f;
- unw_record_type rtype;
- int reg;
+output_P3_format (vbyte_func f, unw_record_type rtype, int reg)
{
char bytes[2];
int r = 0;
}
static void
-output_P4_format (f, imask, imask_size)
- vbyte_func f;
- unsigned char *imask;
- unsigned long imask_size;
+output_P4_format (vbyte_func f, unsigned char *imask, unsigned long imask_size)
{
imask[0] = UNW_P4;
(*f) (imask_size, (char *) imask, NULL);
}
static void
-output_P5_format (f, grmask, frmask)
- vbyte_func f;
- int grmask;
- unsigned long frmask;
+output_P5_format (vbyte_func f, int grmask, unsigned long frmask)
{
char bytes[4];
grmask = (grmask & 0x0f);
}
static void
-output_P6_format (f, rtype, rmask)
- vbyte_func f;
- unw_record_type rtype;
- int rmask;
+output_P6_format (vbyte_func f, unw_record_type rtype, int rmask)
{
char byte;
int r = 0;
}
static void
-output_P7_format (f, rtype, w1, w2)
- vbyte_func f;
- unw_record_type rtype;
- unsigned long w1;
- unsigned long w2;
+output_P7_format (vbyte_func f,
+ unw_record_type rtype,
+ unsigned long w1,
+ unsigned long w2)
{
char bytes[20];
int count = 1;
}
static void
-output_P8_format (f, rtype, t)
- vbyte_func f;
- unw_record_type rtype;
- unsigned long t;
+output_P8_format (vbyte_func f, unw_record_type rtype, unsigned long t)
{
char bytes[20];
int r = 0;
}
static void
-output_P9_format (f, grmask, gr)
- vbyte_func f;
- int grmask;
- int gr;
+output_P9_format (vbyte_func f, int grmask, int gr)
{
char bytes[3];
bytes[0] = UNW_P9;
}
static void
-output_P10_format (f, abi, context)
- vbyte_func f;
- int abi;
- int context;
+output_P10_format (vbyte_func f, int abi, int context)
{
char bytes[3];
bytes[0] = UNW_P10;
}
static void
-output_B1_format (f, rtype, label)
- vbyte_func f;
- unw_record_type rtype;
- unsigned long label;
+output_B1_format (vbyte_func f, unw_record_type rtype, unsigned long label)
{
char byte;
int r = 0;
}
static void
-output_B2_format (f, ecount, t)
- vbyte_func f;
- unsigned long ecount;
- unsigned long t;
+output_B2_format (vbyte_func f, unsigned long ecount, unsigned long t)
{
char bytes[20];
int count = 1;
}
static void
-output_B3_format (f, ecount, t)
- vbyte_func f;
- unsigned long ecount;
- unsigned long t;
+output_B3_format (vbyte_func f, unsigned long ecount, unsigned long t)
{
char bytes[20];
int count = 1;
}
static void
-output_B4_format (f, rtype, label)
- vbyte_func f;
- unw_record_type rtype;
- unsigned long label;
+output_B4_format (vbyte_func f, unw_record_type rtype, unsigned long label)
{
char bytes[20];
int r = 0;
}
static char
-format_ab_reg (ab, reg)
- int ab;
- int reg;
+format_ab_reg (int ab, int reg)
{
int ret;
ab = (ab & 3);
}
static void
-output_X1_format (f, rtype, ab, reg, t, w1)
- vbyte_func f;
- unw_record_type rtype;
- int ab, reg;
- unsigned long t;
- unsigned long w1;
+output_X1_format (vbyte_func f,
+ unw_record_type rtype,
+ int ab,
+ int reg,
+ unsigned long t,
+ unsigned long w1)
{
char bytes[20];
int r = 0;
}
static void
-output_X2_format (f, ab, reg, x, y, treg, t)
- vbyte_func f;
- int ab, reg;
- int x, y, treg;
- unsigned long t;
+output_X2_format (vbyte_func f,
+ int ab,
+ int reg,
+ int x,
+ int y,
+ int treg,
+ unsigned long t)
{
char bytes[20];
int count = 3;
}
static void
-output_X3_format (f, rtype, qp, ab, reg, t, w1)
- vbyte_func f;
- unw_record_type rtype;
- int qp;
- int ab, reg;
- unsigned long t;
- unsigned long w1;
+output_X3_format (vbyte_func f,
+ unw_record_type rtype,
+ int qp,
+ int ab,
+ int reg,
+ unsigned long t,
+ unsigned long w1)
{
char bytes[20];
int r = 0;
}
static void
-output_X4_format (f, qp, ab, reg, x, y, treg, t)
- vbyte_func f;
- int qp;
- int ab, reg;
- int x, y, treg;
- unsigned long t;
+output_X4_format (vbyte_func f,
+ int qp,
+ int ab,
+ int reg,
+ int x,
+ int y,
+ int treg,
+ unsigned long t)
{
char bytes[20];
int count = 4;
body region. */
static unw_rec_list *
-output_endp ()
+output_endp (void)
{
unw_rec_list *ptr = alloc_record (endp);
return ptr;
}
static unw_rec_list *
-output_prologue ()
+output_prologue (void)
{
unw_rec_list *ptr = alloc_record (prologue);
memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
}
static unw_rec_list *
-output_prologue_gr (saved_mask, reg)
- unsigned int saved_mask;
- unsigned int reg;
+output_prologue_gr (unsigned int saved_mask, unsigned int reg)
{
unw_rec_list *ptr = alloc_record (prologue_gr);
memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
}
static unw_rec_list *
-output_body ()
+output_body (void)
{
unw_rec_list *ptr = alloc_record (body);
return ptr;
}
static unw_rec_list *
-output_mem_stack_f (size)
- unsigned int size;
+output_mem_stack_f (unsigned int size)
{
unw_rec_list *ptr = alloc_record (mem_stack_f);
ptr->r.record.p.size = size;
}
static unw_rec_list *
-output_mem_stack_v ()
+output_mem_stack_v (void)
{
unw_rec_list *ptr = alloc_record (mem_stack_v);
return ptr;
}
static unw_rec_list *
-output_psp_gr (gr)
- unsigned int gr;
+output_psp_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (psp_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_psp_sprel (offset)
- unsigned int offset;
+output_psp_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (psp_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_rp_when ()
+output_rp_when (void)
{
unw_rec_list *ptr = alloc_record (rp_when);
return ptr;
}
static unw_rec_list *
-output_rp_gr (gr)
- unsigned int gr;
+output_rp_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (rp_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_rp_br (br)
- unsigned int br;
+output_rp_br (unsigned int br)
{
unw_rec_list *ptr = alloc_record (rp_br);
ptr->r.record.p.r.br = br;
}
static unw_rec_list *
-output_rp_psprel (offset)
- unsigned int offset;
+output_rp_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (rp_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_rp_sprel (offset)
- unsigned int offset;
+output_rp_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (rp_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_pfs_when ()
+output_pfs_when (void)
{
unw_rec_list *ptr = alloc_record (pfs_when);
return ptr;
}
static unw_rec_list *
-output_pfs_gr (gr)
- unsigned int gr;
+output_pfs_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (pfs_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_pfs_psprel (offset)
- unsigned int offset;
+output_pfs_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (pfs_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_pfs_sprel (offset)
- unsigned int offset;
+output_pfs_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (pfs_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_preds_when ()
+output_preds_when (void)
{
unw_rec_list *ptr = alloc_record (preds_when);
return ptr;
}
static unw_rec_list *
-output_preds_gr (gr)
- unsigned int gr;
+output_preds_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (preds_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_preds_psprel (offset)
- unsigned int offset;
+output_preds_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (preds_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_preds_sprel (offset)
- unsigned int offset;
+output_preds_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (preds_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_fr_mem (mask)
- unsigned int mask;
+output_fr_mem (unsigned int mask)
{
unw_rec_list *ptr = alloc_record (fr_mem);
unw_rec_list *cur = ptr;
}
static unw_rec_list *
-output_frgr_mem (gr_mask, fr_mask)
- unsigned int gr_mask;
- unsigned int fr_mask;
+output_frgr_mem (unsigned int gr_mask, unsigned int fr_mask)
{
unw_rec_list *ptr = alloc_record (frgr_mem);
unw_rec_list *cur = ptr;
}
static unw_rec_list *
-output_gr_gr (mask, reg)
- unsigned int mask;
- unsigned int reg;
+output_gr_gr (unsigned int mask, unsigned int reg)
{
unw_rec_list *ptr = alloc_record (gr_gr);
unw_rec_list *cur = ptr;
}
static unw_rec_list *
-output_gr_mem (mask)
- unsigned int mask;
+output_gr_mem (unsigned int mask)
{
unw_rec_list *ptr = alloc_record (gr_mem);
unw_rec_list *cur = ptr;
}
static unw_rec_list *
-output_br_gr (mask, reg)
- unsigned int mask;
- unsigned int reg;
+output_br_gr (unsigned int mask, unsigned int reg)
{
unw_rec_list *ptr = alloc_record (br_gr);
unw_rec_list *cur = ptr;
}
static unw_rec_list *
-output_spill_base (offset)
- unsigned int offset;
+output_spill_base (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (spill_base);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_unat_when ()
+output_unat_when (void)
{
unw_rec_list *ptr = alloc_record (unat_when);
return ptr;
}
static unw_rec_list *
-output_unat_gr (gr)
- unsigned int gr;
+output_unat_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (unat_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_unat_psprel (offset)
- unsigned int offset;
+output_unat_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (unat_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_unat_sprel (offset)
- unsigned int offset;
+output_unat_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (unat_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_lc_when ()
+output_lc_when (void)
{
unw_rec_list *ptr = alloc_record (lc_when);
return ptr;
}
static unw_rec_list *
-output_lc_gr (gr)
- unsigned int gr;
+output_lc_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (lc_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_lc_psprel (offset)
- unsigned int offset;
+output_lc_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (lc_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_lc_sprel (offset)
- unsigned int offset;
+output_lc_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (lc_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_fpsr_when ()
+output_fpsr_when (void)
{
unw_rec_list *ptr = alloc_record (fpsr_when);
return ptr;
}
static unw_rec_list *
-output_fpsr_gr (gr)
- unsigned int gr;
+output_fpsr_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (fpsr_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_fpsr_psprel (offset)
- unsigned int offset;
+output_fpsr_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (fpsr_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_fpsr_sprel (offset)
- unsigned int offset;
+output_fpsr_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (fpsr_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_priunat_when_gr ()
+output_priunat_when_gr (void)
{
unw_rec_list *ptr = alloc_record (priunat_when_gr);
return ptr;
}
static unw_rec_list *
-output_priunat_when_mem ()
+output_priunat_when_mem (void)
{
unw_rec_list *ptr = alloc_record (priunat_when_mem);
return ptr;
}
static unw_rec_list *
-output_priunat_gr (gr)
- unsigned int gr;
+output_priunat_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (priunat_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_priunat_psprel (offset)
- unsigned int offset;
+output_priunat_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (priunat_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_priunat_sprel (offset)
- unsigned int offset;
+output_priunat_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (priunat_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_bsp_when ()
+output_bsp_when (void)
{
unw_rec_list *ptr = alloc_record (bsp_when);
return ptr;
}
static unw_rec_list *
-output_bsp_gr (gr)
- unsigned int gr;
+output_bsp_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (bsp_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_bsp_psprel (offset)
- unsigned int offset;
+output_bsp_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (bsp_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_bsp_sprel (offset)
- unsigned int offset;
+output_bsp_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (bsp_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_bspstore_when ()
+output_bspstore_when (void)
{
unw_rec_list *ptr = alloc_record (bspstore_when);
return ptr;
}
static unw_rec_list *
-output_bspstore_gr (gr)
- unsigned int gr;
+output_bspstore_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (bspstore_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_bspstore_psprel (offset)
- unsigned int offset;
+output_bspstore_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (bspstore_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_bspstore_sprel (offset)
- unsigned int offset;
+output_bspstore_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (bspstore_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_rnat_when ()
+output_rnat_when (void)
{
unw_rec_list *ptr = alloc_record (rnat_when);
return ptr;
}
static unw_rec_list *
-output_rnat_gr (gr)
- unsigned int gr;
+output_rnat_gr (unsigned int gr)
{
unw_rec_list *ptr = alloc_record (rnat_gr);
ptr->r.record.p.r.gr = gr;
}
static unw_rec_list *
-output_rnat_psprel (offset)
- unsigned int offset;
+output_rnat_psprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (rnat_psprel);
ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
}
static unw_rec_list *
-output_rnat_sprel (offset)
- unsigned int offset;
+output_rnat_sprel (unsigned int offset)
{
unw_rec_list *ptr = alloc_record (rnat_sprel);
ptr->r.record.p.off.sp = offset / 4;
}
static unw_rec_list *
-output_unwabi (abi, context)
- unsigned long abi;
- unsigned long context;
+output_unwabi (unsigned long abi, unsigned long context)
{
unw_rec_list *ptr = alloc_record (unwabi);
ptr->r.record.p.abi = abi;
}
static unw_rec_list *
-output_spill_psprel (ab, reg, offset, predicate)
- unsigned int ab;
- unsigned int reg;
- unsigned int offset;
- unsigned int predicate;
+output_spill_psprel (unsigned int ab,
+ unsigned int reg,
+ unsigned int offset,
+ unsigned int predicate)
{
unw_rec_list *ptr = alloc_record (predicate ? spill_psprel_p : spill_psprel);
ptr->r.record.x.ab = ab;
}
static unw_rec_list *
-output_spill_sprel (ab, reg, offset, predicate)
- unsigned int ab;
- unsigned int reg;
- unsigned int offset;
- unsigned int predicate;
+output_spill_sprel (unsigned int ab,
+ unsigned int reg,
+ unsigned int offset,
+ unsigned int predicate)
{
unw_rec_list *ptr = alloc_record (predicate ? spill_sprel_p : spill_sprel);
ptr->r.record.x.ab = ab;
}
static unw_rec_list *
-output_spill_reg (ab, reg, targ_reg, xy, predicate)
- unsigned int ab;
- unsigned int reg;
- unsigned int targ_reg;
- unsigned int xy;
- unsigned int predicate;
+output_spill_reg (unsigned int ab,
+ unsigned int reg,
+ unsigned int targ_reg,
+ unsigned int xy,
+ unsigned int predicate)
{
unw_rec_list *ptr = alloc_record (predicate ? spill_reg_p : spill_reg);
ptr->r.record.x.ab = ab;
specified function. */
static void
-process_one_record (ptr, f)
- unw_rec_list *ptr;
- vbyte_func f;
+process_one_record (unw_rec_list *ptr, vbyte_func f)
{
unsigned int fr_mask, gr_mask;
/* Given a unw_rec_list list, process all the records with
the specified function. */
static void
-process_unw_records (list, f)
- unw_rec_list *list;
- vbyte_func f;
+process_unw_records (unw_rec_list *list, vbyte_func f)
{
unw_rec_list *ptr;
for (ptr = list; ptr; ptr = ptr->next)
/* Determine the size of a record list in bytes. */
static int
-calc_record_size (list)
- unw_rec_list *list;
+calc_record_size (unw_rec_list *list)
{
vbyte_count = 0;
process_unw_records (list, count_output);
2: instruction saves next general reg
3: instruction saves next branch reg */
static void
-set_imask (region, regmask, t, type)
- unw_rec_list *region;
- unsigned long regmask;
- unsigned long t;
- unsigned int type;
+set_imask (unw_rec_list *region,
+ unsigned long regmask,
+ unsigned long t,
+ unsigned int type)
{
unsigned char *imask;
unsigned long imask_size;
containing FIRST_ADDR. If BEFORE_RELAX, then we use worst-case estimates
for frag sizes. */
-unsigned long
-slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
- unsigned long slot_addr;
- fragS *slot_frag;
- unsigned long first_addr;
- fragS *first_frag;
- int before_relax;
+static unsigned long
+slot_index (unsigned long slot_addr,
+ fragS *slot_frag,
+ unsigned long first_addr,
+ fragS *first_frag,
+ int before_relax)
{
- unsigned long index = 0;
+ unsigned long s_index = 0;
/* First time we are called, the initial address and frag are invalid. */
if (first_addr == 0)
/* We can get the final addresses only during and after
relaxation. */
if (first_frag->fr_next && first_frag->fr_next->fr_address)
- index += 3 * ((first_frag->fr_next->fr_address
+ s_index += 3 * ((first_frag->fr_next->fr_address
- first_frag->fr_address
- first_frag->fr_fix) >> 4);
}
case rs_align_test:
/* Take alignment into account. Assume the worst case
before relaxation. */
- index += 3 * ((1 << first_frag->fr_offset) >> 4);
+ s_index += 3 * ((1 << first_frag->fr_offset) >> 4);
break;
case rs_org:
break;
}
case rs_fill:
- index += 3 * (first_frag->fr_offset >> 4);
+ s_index += 3 * (first_frag->fr_offset >> 4);
break;
}
/* Add in the full size of the frag converted to instruction slots. */
- index += 3 * (first_frag->fr_fix >> 4);
+ s_index += 3 * (first_frag->fr_fix >> 4);
/* Subtract away the initial part before first_addr. */
- index -= (3 * ((first_addr >> 4) - (start_addr >> 4))
+ s_index -= (3 * ((first_addr >> 4) - (start_addr >> 4))
+ ((first_addr & 0x3) - (start_addr & 0x3)));
/* Move to the beginning of the next frag. */
}
/* Add in the used part of the last frag. */
- index += (3 * ((slot_addr >> 4) - (first_addr >> 4))
+ s_index += (3 * ((slot_addr >> 4) - (first_addr >> 4))
+ ((slot_addr & 0x3) - (first_addr & 0x3)));
- return index;
+ return s_index;
}
/* Optimize unwind record directives. */
static unw_rec_list *
-optimize_unw_records (list)
- unw_rec_list *list;
+optimize_unw_records (unw_rec_list *list)
{
if (!list)
return NULL;
within each record to generate an image. */
static void
-fixup_unw_records (list, before_relax)
- unw_rec_list *list;
- int before_relax;
+fixup_unw_records (unw_rec_list *list, int before_relax)
{
unw_rec_list *ptr, *region = 0;
unsigned long first_addr = 0, rlen = 0, t;
/* fr_var carries the max_chars that we created the fragment with.
We must, of course, have allocated enough memory earlier. */
- assert (frag->fr_var >= size);
+ gas_assert (frag->fr_var >= size);
return frag->fr_fix + size;
}
/* fr_var carries the max_chars that we created the fragment with.
We must, of course, have allocated enough memory earlier. */
- assert (frag->fr_var >= size);
+ gas_assert (frag->fr_var >= size);
/* Initialize the header area. fr_offset is initialized with
unwind.personality_routine. */
if (pad != 0)
md_number_to_chars (frag->fr_literal + len + 8 - md.pointer_size + pad, 0,
md.pointer_size - pad);
+ /* Fill the unwind personality with zeros. */
+ if (frag->fr_offset)
+ md_number_to_chars (frag->fr_literal + size - md.pointer_size, 0,
+ md.pointer_size);
frag->fr_fix += size;
frag->fr_type = rs_fill;
}
static int
-parse_predicate_and_operand (e, qp, po)
- expressionS * e;
- unsigned * qp;
- const char * po;
+parse_predicate_and_operand (expressionS *e, unsigned *qp, const char *po)
{
- int sep = parse_operand (e, ',');
+ int sep = parse_operand_and_eval (e, ',');
*qp = e->X_add_number - REG_P;
if (e->X_op != O_register || *qp > 63)
else if (*qp == 0)
as_warn (_("Pointless use of p0 as first operand to .%s"), po);
if (sep == ',')
- sep = parse_operand (e, ',');
+ sep = parse_operand_and_eval (e, ',');
else
e->X_op = O_absent;
return sep;
}
static void
-convert_expr_to_ab_reg (e, ab, regp, po, n)
- const expressionS *e;
- unsigned int *ab;
- unsigned int *regp;
- const char * po;
- int n;
+convert_expr_to_ab_reg (const expressionS *e,
+ unsigned int *ab,
+ unsigned int *regp,
+ const char *po,
+ int n)
{
unsigned int reg = e->X_add_number;
}
static void
-convert_expr_to_xy_reg (e, xy, regp, po, n)
- const expressionS *e;
- unsigned int *xy;
- unsigned int *regp;
- const char * po;
- int n;
+convert_expr_to_xy_reg (const expressionS *e,
+ unsigned int *xy,
+ unsigned int *regp,
+ const char *po,
+ int n)
{
unsigned int reg = e->X_add_number;
}
static void
-dot_radix (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_radix (int dummy ATTRIBUTE_UNUSED)
{
char *radix;
int ch;
/* .sbss, .bss etc. are macros that expand into ".section SECNAME". */
static void
-dot_special_section (which)
- int which;
+dot_special_section (int which)
{
set_section ((char *) special_section_name[which]);
}
}
static void
-add_unwind_entry (ptr, sep)
- unw_rec_list *ptr;
- int sep;
+add_unwind_entry (unw_rec_list *ptr, int sep)
{
if (ptr)
{
}
static void
-dot_fframe (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_fframe (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
int sep;
if (!in_prologue ("fframe"))
return;
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
if (e.X_op != O_constant)
{
}
static void
-dot_vframe (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_vframe (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
unsigned reg;
if (!in_prologue ("vframe"))
return;
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
reg = e.X_add_number - REG_GR;
if (e.X_op != O_register || reg > 127)
{
}
static void
-dot_vframesp (psp)
- int psp;
+dot_vframesp (int psp)
{
expressionS e;
int sep;
if (!in_prologue ("vframesp"))
return;
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
if (e.X_op != O_constant)
{
as_bad (_("Operand to .vframesp must be a constant (sp-relative offset)"));
}
static void
-dot_save (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_save (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
unsigned reg1, reg2;
if (!in_prologue ("save"))
return;
- sep = parse_operand (&e1, ',');
+ sep = parse_operand_and_eval (&e1, ',');
if (sep == ',')
- sep = parse_operand (&e2, ',');
+ sep = parse_operand_and_eval (&e2, ',');
else
e2.X_op = O_absent;
}
static void
-dot_restore (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_restore (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1;
unsigned long ecount; /* # of _additional_ regions to pop */
if (!in_body ("restore"))
return;
- sep = parse_operand (&e1, ',');
+ sep = parse_operand_and_eval (&e1, ',');
if (e1.X_op != O_register || e1.X_add_number != REG_GR + 12)
as_bad (_("First operand to .restore must be stack pointer (sp)"));
{
expressionS e2;
- sep = parse_operand (&e2, ',');
+ sep = parse_operand_and_eval (&e2, ',');
if (e2.X_op != O_constant || e2.X_add_number < 0)
{
as_bad (_("Second operand to .restore must be a constant >= 0"));
}
static void
-dot_restorereg (pred)
- int pred;
+dot_restorereg (int pred)
{
unsigned int qp, ab, reg;
expressionS e;
sep = parse_predicate_and_operand (&e, &qp, po);
else
{
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
qp = 0;
}
convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
}
static void
-dot_handlerdata (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_handlerdata (int dummy ATTRIBUTE_UNUSED)
{
if (!in_procedure ("handlerdata"))
return;
}
static void
-dot_unwentry (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_unwentry (int dummy ATTRIBUTE_UNUSED)
{
if (!in_procedure ("unwentry"))
return;
}
static void
-dot_altrp (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_altrp (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
unsigned reg;
if (!in_prologue ("altrp"))
return;
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
reg = e.X_add_number - REG_BR;
if (e.X_op != O_register || reg > 7)
{
}
static void
-dot_savemem (psprel)
- int psprel;
+dot_savemem (int psprel)
{
expressionS e1, e2;
int sep;
if (!in_prologue (po))
return;
- sep = parse_operand (&e1, ',');
+ sep = parse_operand_and_eval (&e1, ',');
if (sep == ',')
- sep = parse_operand (&e2, ',');
+ sep = parse_operand_and_eval (&e2, ',');
else
e2.X_op = O_absent;
}
static void
-dot_saveg (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_saveg (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
unsigned grmask;
if (!in_prologue ("save.g"))
return;
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
grmask = e.X_add_number;
if (e.X_op != O_constant
unsigned reg;
int n = popcount (grmask);
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
reg = e.X_add_number - REG_GR;
if (e.X_op != O_register || reg > 127)
{
}
static void
-dot_savef (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_savef (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
if (!in_prologue ("save.f"))
return;
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
if (e.X_op != O_constant
|| e.X_add_number <= 0
}
static void
-dot_saveb (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_saveb (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
unsigned brmask;
if (!in_prologue ("save.b"))
return;
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
brmask = e.X_add_number;
if (e.X_op != O_constant
unsigned reg;
int n = popcount (brmask);
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
reg = e.X_add_number - REG_GR;
if (e.X_op != O_register || reg > 127)
{
}
static void
-dot_savegf (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_savegf (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
if (!in_prologue ("save.gf"))
return;
- if (parse_operand (&e1, ',') == ',')
- parse_operand (&e2, 0);
+ if (parse_operand_and_eval (&e1, ',') == ',')
+ parse_operand_and_eval (&e2, 0);
else
e2.X_op = O_absent;
}
static void
-dot_spill (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_spill (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
if (!in_prologue ("spill"))
return;
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
if (e.X_op != O_constant)
{
}
static void
-dot_spillreg (pred)
- int pred;
+dot_spillreg (int pred)
{
int sep;
unsigned int qp, ab, xy, reg, treg;
sep = parse_predicate_and_operand (&e, &qp, po);
else
{
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
qp = 0;
}
convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
if (sep == ',')
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
else
e.X_op = O_absent;
convert_expr_to_xy_reg (&e, &xy, &treg, po, 2 + pred);
}
static void
-dot_spillmem (psprel)
- int psprel;
+dot_spillmem (int psprel)
{
expressionS e;
int pred = (psprel < 0), sep;
sep = parse_predicate_and_operand (&e, &qp, po);
else
{
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
qp = 0;
}
convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
if (sep == ',')
- sep = parse_operand (&e, ',');
+ sep = parse_operand_and_eval (&e, ',');
else
e.X_op = O_absent;
if (e.X_op != O_constant)
}
static unsigned int
-get_saved_prologue_count (lbl)
- unsigned long lbl;
+get_saved_prologue_count (unsigned long lbl)
{
label_prologue_count *lpc = unwind.saved_prologue_counts;
}
static void
-save_prologue_count (lbl, count)
- unsigned long lbl;
- unsigned int count;
+save_prologue_count (unsigned long lbl, unsigned int count)
{
label_prologue_count *lpc = unwind.saved_prologue_counts;
}
static void
-dot_label_state (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_label_state (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
if (!in_body ("label_state"))
return;
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
if (e.X_op == O_constant)
save_prologue_count (e.X_add_number, unwind.prologue_count);
else
}
static void
-dot_copy_state (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_copy_state (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
if (!in_body ("copy_state"))
return;
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
if (e.X_op == O_constant)
unwind.prologue_count = get_saved_prologue_count (e.X_add_number);
else
}
static void
-dot_unwabi (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_unwabi (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
unsigned char sep;
if (!in_prologue ("unwabi"))
return;
- sep = parse_operand (&e1, ',');
+ sep = parse_operand_and_eval (&e1, ',');
if (sep == ',')
- parse_operand (&e2, 0);
+ parse_operand_and_eval (&e2, 0);
else
e2.X_op = O_absent;
}
static void
-dot_personality (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_personality (int dummy ATTRIBUTE_UNUSED)
{
char *name, *p, c;
if (!in_procedure ("personality"))
}
static void
-dot_proc (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_proc (int dummy ATTRIBUTE_UNUSED)
{
char *name, *p, c;
symbolS *sym;
}
static void
-dot_body (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_body (int dummy ATTRIBUTE_UNUSED)
{
if (!in_procedure ("body"))
return;
}
static void
-dot_prologue (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_prologue (int dummy ATTRIBUTE_UNUSED)
{
unsigned mask = 0, grsave = 0;
if (!is_it_end_of_statement ())
{
expressionS e;
- int n, sep = parse_operand (&e, ',');
+ int n, sep = parse_operand_and_eval (&e, ',');
if (e.X_op != O_constant
|| e.X_add_number < 0
n = popcount (mask);
if (sep == ',')
- parse_operand (&e, 0);
+ parse_operand_and_eval (&e, 0);
else
e.X_op = O_absent;
if (e.X_op == O_constant
}
static void
-dot_endp (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_endp (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
int bytes_per_address;
}
static void
-dot_template (template)
- int template;
+dot_template (int template_val)
{
- CURR_SLOT.user_template = template;
+ CURR_SLOT.user_template = template_val;
}
static void
-dot_regstk (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_regstk (int dummy ATTRIBUTE_UNUSED)
{
int ins, locs, outs, rots;
}
static void
-dot_rot (type)
- int type;
+dot_rot (int type)
{
offsetT num_regs;
valueT num_alloced = 0;
/* First, remove existing names from hash table. */
for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
{
- hash_delete (md.dynreg_hash, dr->name);
+ hash_delete (md.dynreg_hash, dr->name, FALSE);
/* FIXME: Free dr->name. */
dr->num_regs = 0;
}
}
static void
-dot_byteorder (byteorder)
- int byteorder;
+dot_byteorder (int byteorder)
{
segment_info_type *seginfo = seg_info (now_seg);
}
static void
-dot_psr (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_psr (int dummy ATTRIBUTE_UNUSED)
{
char *option;
int ch;
}
static void
-dot_ln (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_ln (int dummy ATTRIBUTE_UNUSED)
{
new_logical_line (0, get_absolute_expression ());
demand_empty_rest_of_line ();
}
static void
-cross_section (ref, cons, ua)
- int ref;
- void (*cons) PARAMS((int));
- int ua;
+cross_section (int ref, void (*builder) (int), int ua)
{
char *start, *end;
int saved_auto_align;
end = input_line_pointer + 1; /* skip comma */
input_line_pointer = start;
md.keep_pending_output = 1;
- section_count = bfd_count_sections(stdoutput);
+ section_count = bfd_count_sections (stdoutput);
obj_elf_section (0);
- if (section_count != bfd_count_sections(stdoutput))
+ if (section_count != bfd_count_sections (stdoutput))
as_warn (_("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated."));
input_line_pointer = end;
saved_auto_align = md.auto_align;
if (ua)
md.auto_align = 0;
- (*cons) (ref);
+ (*builder) (ref);
if (ua)
md.auto_align = saved_auto_align;
obj_elf_previous (0);
}
static void
-dot_xdata (size)
- int size;
+dot_xdata (int size)
{
cross_section (size, cons, 0);
}
/* Why doesn't float_cons() call md_cons_align() the way cons() does? */
static void
-stmt_float_cons (kind)
- int kind;
+stmt_float_cons (int kind)
{
size_t alignment;
}
static void
-stmt_cons_ua (size)
- int size;
+stmt_cons_ua (int size)
{
int saved_auto_align = md.auto_align;
}
static void
-dot_xfloat_cons (kind)
- int kind;
+dot_xfloat_cons (int kind)
{
cross_section (kind, stmt_float_cons, 0);
}
}
static void
-dot_xdata_ua (size)
- int size;
+dot_xdata_ua (int size)
{
cross_section (size, cons, 1);
}
static void
-dot_xfloat_cons_ua (kind)
- int kind;
+dot_xfloat_cons_ua (int kind)
{
cross_section (kind, float_cons, 1);
}
/* .reg.val <regname>,value */
static void
-dot_reg_val (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_reg_val (int dummy ATTRIBUTE_UNUSED)
{
expressionS reg;
.serialize.instruction
*/
static void
-dot_serialize (type)
- int type;
+dot_serialize (int type)
{
insn_group_break (0, 0, 0);
if (type)
*/
static void
-dot_dv_mode (type)
- int type;
+dot_dv_mode (int type)
{
if (md.manual_bundling)
as_warn (_("Directive invalid within a bundle"));
}
static void
-print_prmask (mask)
- valueT mask;
+print_prmask (valueT mask)
{
int regno;
char *comma = "";
*/
static void
-dot_pred_rel (type)
- int type;
+dot_pred_rel (int type)
{
valueT mask = 0;
int count = 0;
int sep, regno;
expressionS pr, *pr1, *pr2;
- sep = parse_operand (&pr, ',');
+ sep = parse_operand_and_eval (&pr, ',');
if (pr.X_op == O_register
&& pr.X_add_number >= REG_P
&& pr.X_add_number <= REG_P + 63)
Otherwise, only global labels are considered entry points. */
static void
-dot_entry (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_entry (int dummy ATTRIBUTE_UNUSED)
{
const char *err;
char *name;
c = get_symbol_end ();
symbolP = symbol_find_or_make (name);
- err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (PTR) symbolP);
+ err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (void *) symbolP);
if (err)
as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
name, err);
"base" is used to distinguish between offsets from a different base. */
static void
-dot_mem_offset (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_mem_offset (int dummy ATTRIBUTE_UNUSED)
{
md.mem_offset.hint = 1;
md.mem_offset.offset = get_absolute_expression ();
the symbol table. */
static symbolS *
-declare_register (name, regnum)
- const char *name;
- unsigned int regnum;
+declare_register (const char *name, unsigned int regnum)
{
const char *err;
symbolS *sym;
sym = symbol_create (name, reg_section, regnum, &zero_address_frag);
- err = hash_insert (md.reg_hash, S_GET_NAME (sym), (PTR) sym);
+ err = hash_insert (md.reg_hash, S_GET_NAME (sym), (void *) sym);
if (err)
as_fatal ("Inserting \"%s\" into register table failed: %s",
name, err);
}
static void
-declare_register_set (prefix, num_regs, base_regnum)
- const char *prefix;
- unsigned int num_regs;
- unsigned int base_regnum;
+declare_register_set (const char *prefix,
+ unsigned int num_regs,
+ unsigned int base_regnum)
{
char name[8];
unsigned int i;
}
static unsigned int
-operand_width (opnd)
- enum ia64_opnd opnd;
+operand_width (enum ia64_opnd opnd)
{
const struct ia64_operand *odesc = &elf64_ia64_operands[opnd];
unsigned int bits = 0;
}
static enum operand_match_result
-operand_match (idesc, index, e)
- const struct ia64_opcode *idesc;
- int index;
- expressionS *e;
+operand_match (const struct ia64_opcode *idesc, int res_index, expressionS *e)
{
- enum ia64_opnd opnd = idesc->operands[index];
+ enum ia64_opnd opnd = idesc->operands[res_index];
int bits, relocatable = 0;
struct insn_fix *fix;
bfd_signed_vma val;
case IA64_OPND_CNT2a:
case IA64_OPND_LEN4:
case IA64_OPND_LEN6:
- bits = operand_width (idesc->operands[index]);
+ bits = operand_width (idesc->operands[res_index]);
if (e->X_op == O_constant)
{
if ((bfd_vma) (e->X_add_number - 1) < ((bfd_vma) 1 << bits))
e->X_op = O_symbol;
}
- fix->opnd = idesc->operands[index];
+ fix->opnd = idesc->operands[res_index];
fix->expr = *e;
fix->is_pcrel = 0;
++CURR_SLOT.num_fixups;
case IA64_OPND_MBTYPE4:
case IA64_OPND_MHTYPE8:
case IA64_OPND_POS6:
- bits = operand_width (idesc->operands[index]);
+ bits = operand_width (idesc->operands[res_index]);
if (e->X_op == O_constant)
{
if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
break;
case IA64_OPND_IMMU9:
- bits = operand_width (idesc->operands[index]);
+ bits = operand_width (idesc->operands[res_index]);
if (e->X_op == O_constant)
{
if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
case IA64_OPND_IMM8M1U8:
case IA64_OPND_IMM9a:
case IA64_OPND_IMM9b:
- bits = operand_width (idesc->operands[index]);
+ bits = operand_width (idesc->operands[res_index]);
if (relocatable && (e->X_op == O_symbol
|| e->X_op == O_subtract
|| e->X_op == O_pseudo_fixup))
{
fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups;
- if (idesc->operands[index] == IA64_OPND_IMM14)
+ if (idesc->operands[res_index] == IA64_OPND_IMM14)
fix->code = BFD_RELOC_IA64_IMM14;
else
fix->code = BFD_RELOC_IA64_IMM22;
e->X_op = O_symbol;
}
- fix->opnd = idesc->operands[index];
+ fix->opnd = idesc->operands[res_index];
fix->expr = *e;
fix->is_pcrel = 0;
++CURR_SLOT.num_fixups;
abort ();
fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code);
- fix->opnd = idesc->operands[index];
+ fix->opnd = idesc->operands[res_index];
fix->expr = *e;
fix->is_pcrel = 1;
++CURR_SLOT.num_fixups;
create a dummy reloc. This will not live past md_apply_fix. */
fix->code = BFD_RELOC_UNUSED;
fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code);
- fix->opnd = idesc->operands[index];
+ fix->opnd = idesc->operands[res_index];
fix->expr = *e;
fix->is_pcrel = 1;
++CURR_SLOT.num_fixups;
case IA64_OPND_LDXMOV:
fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups;
fix->code = BFD_RELOC_IA64_LDXMOV;
- fix->opnd = idesc->operands[index];
+ fix->opnd = idesc->operands[res_index];
fix->expr = *e;
fix->is_pcrel = 0;
++CURR_SLOT.num_fixups;
}
static int
-parse_operand (e, more)
- expressionS *e;
- int more;
+parse_operand (expressionS *e, int more)
{
int sep = '\0';
memset (e, 0, sizeof (*e));
e->X_op = O_absent;
SKIP_WHITESPACE ();
- expression_and_evaluate (e);
+ expression (e);
sep = *input_line_pointer;
if (more && (sep == ',' || sep == more))
++input_line_pointer;
return sep;
}
+static int
+parse_operand_and_eval (expressionS *e, int more)
+{
+ int sep = parse_operand (e, more);
+ resolve_expression (e);
+ return sep;
+}
+
+static int
+parse_operand_maybe_eval (expressionS *e, int more, enum ia64_opnd op)
+{
+ int sep = parse_operand (e, more);
+ switch (op)
+ {
+ case IA64_OPND_IMM14:
+ case IA64_OPND_IMM22:
+ case IA64_OPND_IMMU64:
+ case IA64_OPND_TGT25:
+ case IA64_OPND_TGT25b:
+ case IA64_OPND_TGT25c:
+ case IA64_OPND_TGT64:
+ case IA64_OPND_TAG13:
+ case IA64_OPND_TAG13b:
+ case IA64_OPND_LDXMOV:
+ break;
+ default:
+ resolve_expression (e);
+ break;
+ }
+ return sep;
+}
+
/* Returns the next entry in the opcode table that matches the one in
IDESC, and frees the entry in IDESC. If no matching entry is
found, NULL is returned instead. */
matches the specified operands, or NULL if no match is possible. */
static struct ia64_opcode *
-parse_operands (idesc)
- struct ia64_opcode *idesc;
+parse_operands (struct ia64_opcode *idesc)
{
int i = 0, highest_unmatched_operand, num_operands = 0, num_outputs = 0;
int error_pos, out_of_range_pos, curr_out_of_range_pos, sep = 0;
char *first_arg = 0, *end, *saved_input_pointer;
unsigned int sof;
- assert (strlen (idesc->name) <= 128);
+ gas_assert (strlen (idesc->name) <= 128);
strcpy (mnemonic, idesc->name);
if (idesc->operands[2] == IA64_OPND_SOF
{
if (i < NELEMS (CURR_SLOT.opnd))
{
- sep = parse_operand (CURR_SLOT.opnd + i, '=');
+ sep = parse_operand_maybe_eval (CURR_SLOT.opnd + i, '=',
+ idesc->operands[i]);
if (CURR_SLOT.opnd[i].X_op == O_absent)
break;
}
/* now we can parse the first arg: */
saved_input_pointer = input_line_pointer;
input_line_pointer = first_arg;
- sep = parse_operand (CURR_SLOT.opnd + 0, '=');
+ sep = parse_operand_maybe_eval (CURR_SLOT.opnd + 0, '=',
+ idesc->operands[0]);
if (sep != '=')
--num_outputs; /* force error */
input_line_pointer = saved_input_pointer;
}
static void
-build_insn (slot, insnp)
- struct slot *slot;
- bfd_vma *insnp;
+build_insn (struct slot *slot, bfd_vma *insnp)
{
const struct ia64_operand *odesc, *o2desc;
struct ia64_opcode *idesc = slot->idesc;
else if (slot->opnd[i].X_op == O_big)
{
/* This must be the value 0x10000000000000000. */
- assert (idesc->operands[i] == IA64_OPND_IMM8M1U8);
+ gas_assert (idesc->operands[i] == IA64_OPND_IMM8M1U8);
val = 0;
}
else
}
static void
-emit_one_bundle ()
+emit_one_bundle (void)
{
int manual_bundling_off = 0, manual_bundling = 0;
enum ia64_unit required_unit, insn_unit = 0;
enum ia64_insn_type type[3], insn_type;
- unsigned int template, orig_template;
+ unsigned int template_val, orig_template;
bfd_vma insn[3] = { -1, -1, -1 };
struct ia64_opcode *idesc;
int end_of_insn_group = 0, user_template = -1;
otherwise: */
if (md.slot[first].user_template >= 0)
- user_template = template = md.slot[first].user_template;
+ user_template = template_val = md.slot[first].user_template;
else
{
/* Auto select appropriate template. */
type[i] = md.slot[curr].idesc->type;
curr = (curr + 1) % NUM_SLOTS;
}
- template = best_template[type[0]][type[1]][type[2]];
+ template_val = best_template[type[0]][type[1]][type[2]];
}
/* initialize instructions with appropriate nops: */
for (i = 0; i < 3; ++i)
- insn[i] = nop[ia64_templ_desc[template].exec_unit[i]];
+ insn[i] = nop[ia64_templ_desc[template_val].exec_unit[i]];
f = frag_more (16);
MBB, BBB, MMB, and MFB. We don't handle anything other
than M and B slots because these are the only kind of
instructions that can have the IA64_OPCODE_LAST bit set. */
- required_template = template;
+ required_template = template_val;
switch (idesc->type)
{
case IA64_TYPE_M:
|| (required_slot == 2 && !manual_bundling_off)
|| (user_template >= 0
/* Changing from MMI to M;MI is OK. */
- && (template ^ required_template) > 1)))
+ && (template_val ^ required_template) > 1)))
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' must be last in instruction group"),
break;
i = required_slot;
- if (required_template != template)
+ if (required_template != template_val)
{
/* If we switch the template, we need to reset the NOPs
after slot i. The slot-types of the instructions ahead
middle, so we don't need another one emitted later. */
md.slot[curr].end_of_insn_group = 0;
}
- template = required_template;
+ template_val = required_template;
}
if (curr != first && md.slot[curr].label_fixups)
{
bundle. See if we can switch to an other template with
an appropriate boundary. */
- orig_template = template;
+ orig_template = template_val;
if (i == 1 && (user_template == 4
|| (user_template < 0
- && (ia64_templ_desc[template].exec_unit[0]
+ && (ia64_templ_desc[template_val].exec_unit[0]
== IA64_UNIT_M))))
{
- template = 5;
+ template_val = 5;
end_of_insn_group = 0;
}
else if (i == 2 && (user_template == 0
|| (user_template < 0
- && (ia64_templ_desc[template].exec_unit[1]
+ && (ia64_templ_desc[template_val].exec_unit[1]
== IA64_UNIT_I)))
/* This test makes sure we don't switch the template if
the next instruction is one that needs to be first in
first in the group! --davidm 99/12/16 */
&& (idesc->flags & IA64_OPCODE_FIRST) == 0)
{
- template = 1;
+ template_val = 1;
end_of_insn_group = 0;
}
else if (i == 1
/* can't fit this insn */
break;
- if (template != orig_template)
+ if (template_val != orig_template)
/* if we switch the template, we need to reset the NOPs
after slot i. The slot-types of the instructions ahead
of i never change, so we don't need to worry about
changing NOPs in front of this slot. */
for (j = i; j < 3; ++j)
- insn[j] = nop[ia64_templ_desc[template].exec_unit[j]];
+ insn[j] = nop[ia64_templ_desc[template_val].exec_unit[j]];
}
- required_unit = ia64_templ_desc[template].exec_unit[i];
+ required_unit = ia64_templ_desc[template_val].exec_unit[i];
/* resolve dynamic opcodes such as "break", "hint", and "nop": */
if (idesc->type == IA64_TYPE_DYN)
{
insn_unit = IA64_UNIT_M;
if (required_unit == IA64_UNIT_I
- || (required_unit == IA64_UNIT_F && template == 6))
+ || (required_unit == IA64_UNIT_F && template_val == 6))
insn_unit = IA64_UNIT_I;
}
else
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' does not fit into %s template"),
- idesc->name, ia64_templ_desc[template].name);
+ idesc->name, ia64_templ_desc[template_val].name);
/* Drop first insn so we don't livelock. */
--md.num_slots_in_use;
know (curr == first);
{
const char *where;
- if (template == 2)
+ if (template_val == 2)
where = "X slot";
else if (last_slot == 0)
where = "slots 2 or 3";
where = "slot 3";
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' can't go in %s of %s template"),
- idesc->name, where, ia64_templ_desc[template].name);
+ idesc->name, where, ia64_templ_desc[template_val].name);
}
}
else
know (md.num_slots_in_use < NUM_SLOTS);
- t0 = end_of_insn_group | (template << 1) | (insn[0] << 5) | (insn[1] << 46);
+ t0 = end_of_insn_group | (template_val << 1) | (insn[0] << 5) | (insn[1] << 46);
t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
number_to_chars_littleendian (f + 0, t0, 8);
}
int
-md_parse_option (c, arg)
- int c;
- char *arg;
+md_parse_option (int c, char *arg)
{
switch (c)
}
void
-md_show_usage (stream)
- FILE *stream;
+md_show_usage (FILE *stream)
{
fputs (_("\
IA-64 options:\n\
}
void
-ia64_after_parse_args ()
+ia64_after_parse_args (void)
{
if (debug_type == DEBUG_STABS)
as_fatal (_("--gstabs is not supported for ia64"));
up all the tables, etc. that the MD part of the assembler will need
that can be determined before arguments are parsed. */
void
-md_begin ()
+md_begin (void)
{
int i, j, k, t, goodness, best, ok;
const char *err;
for (i = 0; i < NELEMS (const_bits); ++i)
{
err = hash_insert (md.const_hash, const_bits[i].name,
- (PTR) (const_bits + i));
+ (void *) (const_bits + i));
if (err)
as_fatal (_("Inserting \"%s\" into constant hash table failed: %s"),
name, err);
options in md based on command line options. */
void
-ia64_init (argc, argv)
- int argc ATTRIBUTE_UNUSED;
- char **argv ATTRIBUTE_UNUSED;
+ia64_init (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
{
md.flags = MD_FLAGS_DEFAULT;
+#ifndef TE_VMS
+ /* Don't turn on dependency checking for VMS, doesn't work. */
md.detect_dv = 1;
+#endif
/* FIXME: We should change it to unwind_check_error someday. */
md.unwind_check = unwind_check_warning;
md.hint_b = hint_b_error;
/* Return a string for the target object file format. */
const char *
-ia64_target_format ()
+ia64_target_format (void)
{
if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
{
else
{
if (md.flags & EF_IA_64_ABI64)
-#ifdef TE_AIX50
+#if defined (TE_AIX50)
return "elf64-ia64-aix-little";
+#elif defined (TE_VMS)
+ {
+ md.flags |= EF_IA_64_ARCHVER_1;
+ return "elf64-ia64-vms";
+ }
#else
return "elf64-ia64-little";
#endif
}
void
-ia64_end_of_source ()
+ia64_end_of_source (void)
{
/* terminate insn group upon reaching end of file: */
insn_group_break (1, 0, 0);
}
void
-ia64_start_line ()
+ia64_start_line (void)
{
static int first;
static int defining_tag = 0;
int
-ia64_unrecognized_line (ch)
- int ch;
+ia64_unrecognized_line (int ch)
{
switch (ch)
{
}
void
-ia64_frob_label (sym)
- struct symbol *sym;
+ia64_frob_label (struct symbol *sym)
{
struct label_fix *fix;
that are declared but unused. This routine removes declared,
unused symbols from an object. */
int
-ia64_frob_symbol (sym)
- struct symbol *sym;
+ia64_frob_symbol (struct symbol *sym)
{
if ((S_GET_SEGMENT (sym) == &bfd_und_section && ! symbol_used_p (sym) &&
ELF_ST_VISIBILITY (S_GET_OTHER (sym)) == STV_DEFAULT)
#endif
void
-ia64_flush_pending_output ()
+ia64_flush_pending_output (void)
{
if (!md.keep_pending_output
&& bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)
of rotating registers or due to the indexing of indirect register
sets. */
int
-ia64_optimize_expr (l, op, r)
- expressionS *l;
- operatorT op;
- expressionS *r;
+ia64_optimize_expr (expressionS *l, operatorT op, expressionS *r)
{
if (op != O_index)
return 0;
}
int
-ia64_parse_name (name, e, nextcharP)
- char *name;
- expressionS *e;
- char *nextcharP;
+ia64_parse_name (char *name, expressionS *e, char *nextcharP)
{
struct const_desc *cdesc;
struct dynreg *dr = 0;
/* Remove the '#' suffix that indicates a symbol as opposed to a register. */
char *
-ia64_canonicalize_symbol_name (name)
- char *name;
+ia64_canonicalize_symbol_name (char *name)
{
size_t len = strlen (name), full = len;
through, and which use no resources if they do fall through. */
static int
-is_conditional_branch (idesc)
- struct ia64_opcode *idesc;
+is_conditional_branch (struct ia64_opcode *idesc)
{
/* br is a conditional branch. Everything that starts with br. except
br.ia, br.c{loop,top,exit}, and br.w{top,exit} is a conditional branch.
returns zero. */
static int
-is_taken_branch (idesc)
- struct ia64_opcode *idesc;
+is_taken_branch (struct ia64_opcode *idesc)
{
return ((is_conditional_branch (idesc) && CURR_SLOT.qp_regno == 0)
|| strncmp (idesc->name, "br.ia", 5) == 0);
doubt, returns zero. */
static int
-is_interruption_or_rfi (idesc)
- struct ia64_opcode *idesc;
+is_interruption_or_rfi (struct ia64_opcode *idesc)
{
if (strcmp (idesc->name, "rfi") == 0)
return 1;
-1 if there is no dependency. */
static int
-depends_on (depind, idesc)
- int depind;
- struct ia64_opcode *idesc;
+depends_on (int depind, struct ia64_opcode *idesc)
{
int i;
const struct ia64_opcode_dependency *dep = idesc->dependencies;
#define DV_REG 0
static int
-specify_resource (dep, idesc, type, specs, note, path)
- const struct ia64_dependency *dep;
- struct ia64_opcode *idesc;
- int type; /* is this a DV chk or a DV reg? */
- struct rsrc specs[MAX_SPECS]; /* returned specific resources */
- int note; /* resource note for this insn's usage */
- int path; /* which execution path to examine */
+specify_resource (const struct ia64_dependency *dep,
+ struct ia64_opcode *idesc,
+ /* is this a DV chk or a DV reg? */
+ int type,
+ /* returned specific resources */
+ struct rsrc specs[MAX_SPECS],
+ /* resource note for this insn's usage */
+ int note,
+ /* which execution path to examine */
+ int path)
{
int count = 0;
int i;
|| (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3))
{
- int index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
- ? 1 : !rsrc_write);
- int regno = CURR_SLOT.opnd[index].X_add_number - REG_GR;
+ int reg_index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
+ ? 1 : !rsrc_write);
+ int regno = CURR_SLOT.opnd[reg_index].X_add_number - REG_GR;
if (regno >= 0 && regno < NELEMS (gr_values)
&& KNOWN (regno))
{
}
break;
+ case IA64_RS_CR_IIB:
+ if (note != 0)
+ {
+ UNHANDLED;
+ }
+ else
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
+ && (regno == CR_IIB0 || regno == CR_IIB1))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
+ break;
+
case IA64_RS_CR_LRR:
if (note != 1)
{
if (idesc->operands[0] == IA64_OPND_CR3
|| idesc->operands[1] == IA64_OPND_CR3)
{
- int index =
+ int reg_index =
((idesc->operands[0] == IA64_OPND_CR3)
? 0 : 1);
int regno =
- CURR_SLOT.opnd[index].X_add_number - REG_CR;
+ CURR_SLOT.opnd[reg_index].X_add_number - REG_CR;
switch (regno)
{
case CR_ISR:
case CR_IFA:
case CR_IHA:
+ case CR_IIB0:
+ case CR_IIB1:
case CR_IIPA:
specs[count++] = tmpl;
break;
if (idesc->operands[0] == IA64_OPND_AR3
|| idesc->operands[1] == IA64_OPND_AR3)
{
- int index =
+ int reg_index =
((idesc->operands[0] == IA64_OPND_AR3)
? 0 : 1);
int regno =
- CURR_SLOT.opnd[index].X_add_number - REG_AR;
+ CURR_SLOT.opnd[reg_index].X_add_number - REG_AR;
if (regno == AR_ITC
|| regno == AR_RUC
- || (index == 0
+ || (reg_index == 0
&& (regno == AR_RSC
|| (regno >= AR_K0
&& regno <= AR_K7))))
QP of the marking instruction and a subsequent branch on the same QP. */
static void
-clear_qp_branch_flag (mask)
- valueT mask;
+clear_qp_branch_flag (valueT mask)
{
int i;
for (i = 0; i < regdepslen; i++)
Any changes to a PR clears the mutex relations which include that PR. */
static void
-clear_qp_mutex (mask)
- valueT mask;
+clear_qp_mutex (valueT mask)
{
int i;
indicates the implied PR. */
static void
-clear_qp_implies (p1_mask, p2_mask)
- valueT p1_mask;
- valueT p2_mask;
+clear_qp_implies (valueT p1_mask, valueT p2_mask)
{
int i;
/* Add the PRs specified to the list of implied relations. */
static void
-add_qp_imply (p1, p2)
- int p1, p2;
+add_qp_imply (int p1, int p2)
{
valueT mask;
valueT bit;
the mask. */
static void
-add_qp_mutex (mask)
- valueT mask;
+add_qp_mutex (valueT mask)
{
if (mask & 0x1)
abort ();
}
static int
-has_suffix_p (name, suffix)
- const char *name;
- const char *suffix;
+has_suffix_p (const char *name, const char *suffix)
{
size_t namelen = strlen (name);
size_t sufflen = strlen (suffix);
}
static void
-clear_register_values ()
+clear_register_values (void)
{
int i;
if (md.debug_dv)
have to examine a group of strings to identify them. */
static void
-note_register_values (idesc)
- struct ia64_opcode *idesc;
+note_register_values (struct ia64_opcode *idesc)
{
valueT qp_changemask = 0;
int i;
/* Return whether the given predicate registers are currently mutex. */
static int
-qp_mutex (p1, p2, path)
- int p1;
- int p2;
- int path;
+qp_mutex (int p1, int p2, int path)
{
int i;
valueT mask;
conflict. */
static int
-resources_match (rs, idesc, note, qp_regno, path)
- struct rsrc *rs;
- struct ia64_opcode *idesc;
- int note;
- int qp_regno;
- int path;
+resources_match (struct rsrc *rs,
+ struct ia64_opcode *idesc,
+ int note,
+ int qp_regno,
+ int path)
{
struct rsrc specs[MAX_SPECS];
int count;
instruction. */
static void
-insn_group_break (insert_stop, qp_regno, save_current)
- int insert_stop;
- int qp_regno;
- int save_current;
+insn_group_break (int insert_stop, int qp_regno, int save_current)
{
int i;
/* Add the given resource usage spec to the list of active dependencies. */
static void
-mark_resource (idesc, dep, spec, depind, path)
- struct ia64_opcode *idesc ATTRIBUTE_UNUSED;
- const struct ia64_dependency *dep ATTRIBUTE_UNUSED;
- struct rsrc *spec;
- int depind;
- int path;
+mark_resource (struct ia64_opcode *idesc ATTRIBUTE_UNUSED,
+ const struct ia64_dependency *dep ATTRIBUTE_UNUSED,
+ struct rsrc *spec,
+ int depind,
+ int path)
{
if (regdepslen == regdepstotlen)
{
}
static void
-print_dependency (action, depind)
- const char *action;
- int depind;
+print_dependency (const char *action, int depind)
{
if (md.debug_dv)
{
}
static void
-instruction_serialization ()
+instruction_serialization (void)
{
int i;
if (md.debug_dv)
}
static void
-data_serialization ()
+data_serialization (void)
{
int i = 0;
if (md.debug_dv)
/* Insert stops and serializations as needed to avoid DVs. */
static void
-remove_marked_resource (rs)
- struct rsrc *rs;
+remove_marked_resource (struct rsrc *rs)
{
switch (rs->dependency->semantics)
{
*/
static void
-check_dependencies (idesc)
- struct ia64_opcode *idesc;
+check_dependencies (struct ia64_opcode *idesc)
{
const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
int path;
/* Register new dependencies based on the given opcode. */
static void
-mark_resources (idesc)
- struct ia64_opcode *idesc;
+mark_resources (struct ia64_opcode *idesc)
{
int i;
const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
/* Remove dependencies when they no longer apply. */
static void
-update_dependencies (idesc)
- struct ia64_opcode *idesc;
+update_dependencies (struct ia64_opcode *idesc)
{
int i;
/* Examine the current instruction for dependency violations. */
static int
-check_dv (idesc)
- struct ia64_opcode *idesc;
+check_dv (struct ia64_opcode *idesc)
{
if (md.debug_dv)
{
/* Translate one line of assembly. Pseudo ops and labels do not show
here. */
void
-md_assemble (str)
- char *str;
+md_assemble (char *str)
{
char *saved_input_line_pointer, *mnemonic;
const struct pseudo_opcode *pdesc;
CURR_SLOT.idesc = idesc;
as_where (&CURR_SLOT.src_file, &CURR_SLOT.src_line);
dwarf2_where (&CURR_SLOT.debug_line);
+ dwarf2_consume_line_info ();
/* Add unwind entries, if there are any. */
if (unwind.current_entry)
Should be used for dynamic valued symbols only. */
symbolS *
-md_undefined_symbol (name)
- char *name ATTRIBUTE_UNUSED;
+md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
{
return 0;
}
the expression. */
void
-md_operand (e)
- expressionS *e;
+md_operand (expressionS *e)
{
switch (*input_line_pointer)
{
directives we don't want such adjustments since we need to have the
original symbol's name in the reloc. */
int
-ia64_fix_adjustable (fix)
- fixS *fix;
+ia64_fix_adjustable (fixS *fix)
{
/* Prevent all adjustments to global symbols */
if (S_IS_EXTERNAL (fix->fx_addsy) || S_IS_WEAK (fix->fx_addsy))
}
int
-ia64_force_relocation (fix)
- fixS *fix;
+ia64_force_relocation (fixS *fix)
{
switch (fix->fx_r_type)
{
/* Decide from what point a pc-relative relocation is relative to,
relative to the pc-relative fixup. Er, relatively speaking. */
long
-ia64_pcrel_from_section (fix, sec)
- fixS *fix;
- segT sec;
+ia64_pcrel_from_section (fixS *fix, segT sec)
{
unsigned long off = fix->fx_frag->fr_address + fix->fx_where;
void
ia64_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
{
- expressionS expr;
+ expressionS exp;
- expr.X_op = O_pseudo_fixup;
- expr.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym;
- expr.X_add_number = 0;
- expr.X_add_symbol = symbol;
- emit_expr (&expr, size);
+ exp.X_op = O_pseudo_fixup;
+ exp.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym;
+ exp.X_add_number = 0;
+ exp.X_add_symbol = symbol;
+ emit_expr (&exp, size);
}
/* This is called whenever some data item (not an instruction) needs a
fixup. We pick the right reloc code depending on the byteorder
currently in effect. */
void
-ia64_cons_fix_new (f, where, nbytes, exp)
- fragS *f;
- int where;
- int nbytes;
- expressionS *exp;
+ia64_cons_fix_new (fragS *f, int where, int nbytes, expressionS *exp)
{
bfd_reloc_code_real_type code;
fixS *fix;
symbols in the pseudo_func array, or NULL. */
static bfd_reloc_code_real_type
-ia64_gen_real_reloc_type (sym, r_type)
- struct symbol *sym;
- bfd_reloc_code_real_type r_type;
+ia64_gen_real_reloc_type (struct symbol *sym, bfd_reloc_code_real_type r_type)
{
- bfd_reloc_code_real_type new = 0;
+ bfd_reloc_code_real_type newr = 0;
const char *type = NULL, *suffix = "";
if (sym == NULL)
case FUNC_FPTR_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_FPTR64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_FPTR32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_FPTR32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_FPTR64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_FPTR64LSB; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_FPTR64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_FPTR32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_FPTR32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_FPTR64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_FPTR64LSB; break;
default: type = "FPTR"; break;
}
break;
case FUNC_GP_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_GPREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_GPREL64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_GPREL32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_GPREL32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_GPREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_GPREL64LSB; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_GPREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_GPREL64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_GPREL32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_GPREL32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_GPREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_GPREL64LSB; break;
default: type = "GPREL"; break;
}
break;
case FUNC_LT_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_LTOFF64I; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_LTOFF64I; break;
default: type = "LTOFF"; break;
}
break;
case FUNC_LT_RELATIVE_X:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22X; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22X; break;
default: type = "LTOFF"; suffix = "X"; break;
}
break;
case FUNC_PC_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PCREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PCREL64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_PCREL32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_PCREL32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PCREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PCREL64LSB; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PCREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PCREL64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_PCREL32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_PCREL32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PCREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PCREL64LSB; break;
default: type = "PCREL"; break;
}
break;
case FUNC_PLT_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PLTOFF22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PLTOFF64I; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PLTOFF64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PLTOFF64LSB;break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PLTOFF22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PLTOFF64I; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PLTOFF64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PLTOFF64LSB;break;
default: type = "PLTOFF"; break;
}
break;
case FUNC_SEC_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SECREL32MSB;break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SECREL32LSB;break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SECREL64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SECREL64LSB;break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SECREL32MSB;break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SECREL32LSB;break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SECREL64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SECREL64LSB;break;
default: type = "SECREL"; break;
}
break;
case FUNC_SEG_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SEGREL32MSB;break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SEGREL32LSB;break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SEGREL64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SEGREL64LSB;break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SEGREL32MSB;break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SEGREL32LSB;break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SEGREL64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SEGREL64LSB;break;
default: type = "SEGREL"; break;
}
break;
case FUNC_LTV_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_LTV32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_LTV32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_LTV64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_LTV64LSB; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_LTV32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_LTV32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_LTV64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_LTV64LSB; break;
default: type = "LTV"; break;
}
break;
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_FPTR22; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR22; break;
case BFD_RELOC_IA64_IMM64:
- new = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
case BFD_RELOC_IA64_DIR32MSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
case BFD_RELOC_IA64_DIR32LSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
default:
type = "LTOFF_FPTR"; break;
}
case FUNC_TP_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM14: new = BFD_RELOC_IA64_TPREL14; break;
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_TPREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_TPREL64I; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_TPREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_TPREL64LSB; break;
+ case BFD_RELOC_IA64_IMM14: newr = BFD_RELOC_IA64_TPREL14; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_TPREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_TPREL64I; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_TPREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_TPREL64LSB; break;
default: type = "TPREL"; break;
}
break;
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_TPREL22; break;
+ newr = BFD_RELOC_IA64_LTOFF_TPREL22; break;
default:
type = "LTOFF_TPREL"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_DTPMOD64MSB; break;
+ newr = BFD_RELOC_IA64_DTPMOD64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_DTPMOD64LSB; break;
+ newr = BFD_RELOC_IA64_DTPMOD64LSB; break;
default:
type = "DTPMOD"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
+ newr = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
default:
type = "LTOFF_DTPMOD"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_DIR32MSB:
- new = BFD_RELOC_IA64_DTPREL32MSB; break;
+ newr = BFD_RELOC_IA64_DTPREL32MSB; break;
case BFD_RELOC_IA64_DIR32LSB:
- new = BFD_RELOC_IA64_DTPREL32LSB; break;
+ newr = BFD_RELOC_IA64_DTPREL32LSB; break;
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_DTPREL64MSB; break;
+ newr = BFD_RELOC_IA64_DTPREL64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_DTPREL64LSB; break;
+ newr = BFD_RELOC_IA64_DTPREL64LSB; break;
case BFD_RELOC_IA64_IMM14:
- new = BFD_RELOC_IA64_DTPREL14; break;
+ newr = BFD_RELOC_IA64_DTPREL14; break;
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_DTPREL22; break;
+ newr = BFD_RELOC_IA64_DTPREL22; break;
case BFD_RELOC_IA64_IMM64:
- new = BFD_RELOC_IA64_DTPREL64I; break;
+ newr = BFD_RELOC_IA64_DTPREL64I; break;
default:
type = "DTPREL"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
+ newr = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
default:
type = "LTOFF_DTPREL"; break;
}
abort ();
}
- if (new)
- return new;
+ if (newr)
+ return newr;
else
{
int width;
/* Here is where generate the appropriate reloc for pseudo relocation
functions. */
void
-ia64_validate_fix (fix)
- fixS *fix;
+ia64_validate_fix (fixS *fix)
{
switch (fix->fx_r_type)
{
}
static void
-fix_insn (fix, odesc, value)
- fixS *fix;
- const struct ia64_operand *odesc;
- valueT value;
+fix_insn (fixS *fix, const struct ia64_operand *odesc, valueT value)
{
bfd_vma insn[3], t0, t1, control_bits;
const char *err;
else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62)
{
if (value & ~0x3fffffffffffffffULL)
- err = "integer operand out of range";
+ err = _("integer operand out of range");
insn[1] = (value >> 21) & 0x1ffffffffffLL;
insn[2] |= (((value & 0xfffff) << 6) | (((value >> 20) & 0x1) << 36));
}
err = (*odesc->insert) (odesc, value, insn + slot);
if (err)
- as_bad_where (fix->fx_file, fix->fx_line, err);
+ as_bad_where (fix->fx_file, fix->fx_line, "%s", err);
t0 = control_bits | (insn[0] << 5) | (insn[1] << 46);
t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
(if possible). */
void
-md_apply_fix (fix, valP, seg)
- fixS *fix;
- valueT *valP;
- segT seg ATTRIBUTE_UNUSED;
+md_apply_fix (fixS *fix, valueT *valP, segT seg ATTRIBUTE_UNUSED)
{
char *fixpos;
valueT value = *valP;
fixup used internally in the assembler. */
arelent *
-tc_gen_reloc (sec, fixp)
- asection *sec ATTRIBUTE_UNUSED;
- fixS *fixp;
+tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED, fixS *fixp)
{
arelent *reloc;
/* Handle ia64 specific semantics of the align directive. */
void
-ia64_md_do_align (n, fill, len, max)
- int n ATTRIBUTE_UNUSED;
- const char *fill ATTRIBUTE_UNUSED;
- int len ATTRIBUTE_UNUSED;
- int max ATTRIBUTE_UNUSED;
+ia64_md_do_align (int n ATTRIBUTE_UNUSED,
+ const char *fill ATTRIBUTE_UNUSED,
+ int len ATTRIBUTE_UNUSED,
+ int max ATTRIBUTE_UNUSED)
{
if (subseg_text_p (now_seg))
ia64_flush_insns ();
of an rs_align_code fragment. */
void
-ia64_handle_align (fragp)
- fragS *fragp;
+ia64_handle_align (fragS *fragp)
{
int bytes;
char *p;
- const unsigned char *nop;
+ const unsigned char *nop_type;
if (fragp->fr_type != rs_align_code)
return;
/* Check if this frag has to end with a stop bit. */
- nop = fragp->tc_frag_data ? le_nop_stop : le_nop;
+ nop_type = fragp->tc_frag_data ? le_nop_stop : le_nop;
bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
p = fragp->fr_literal + fragp->fr_fix;
}
/* Instruction bundles are always little-endian. */
- memcpy (p, nop, 16);
+ memcpy (p, nop_type, 16);
fragp->fr_var = 16;
}
}
void
-ia64_elf_section_change_hook (void)
+ia64_elf_section_change_hook (void)
{
if (elf_section_type (now_seg) == SHT_IA_64_UNWIND
&& elf_linked_to_section (now_seg) == NULL)
as_where (&h->file, &h->line);
h->name = name;
- error_string = hash_jam (ahash, alias, (PTR) h);
+ error_string = hash_jam (ahash, alias, (void *) h);
if (error_string)
{
as_fatal (_("inserting \"%s\" into %s alias hash table failed: %s"),
goto out;
}
- error_string = hash_jam (nhash, name, (PTR) alias);
+ error_string = hash_jam (nhash, name, (void *) alias);
if (error_string)
{
as_fatal (_("inserting \"%s\" into %s name hash table failed: %s"),
/* It renames the original symbol name to its alias. */
static void
-do_alias (const char *alias, PTR value)
+do_alias (const char *alias, void *value)
{
struct alias *h = (struct alias *) value;
symbolS *sym = symbol_find (h->name);
if (sym == NULL)
- as_warn_where (h->file, h->line,
- _("symbol `%s' aliased to `%s' is not used"),
- h->name, alias);
+ {
+#ifdef TE_VMS
+ /* Uses .alias extensively to alias CRTL functions to same with
+ decc$ prefix. Sometimes function gets optimized away and a
+ warning results, which should be suppressed. */
+ if (strncmp (alias, "decc$", 5) != 0)
+#endif
+ as_warn_where (h->file, h->line,
+ _("symbol `%s' aliased to `%s' is not used"),
+ h->name, alias);
+ }
else
S_SET_NAME (sym, (char *) alias);
}
/* It renames the original section name to its alias. */
static void
-do_secalias (const char *alias, PTR value)
+do_secalias (const char *alias, void *value)
{
struct alias *h = (struct alias *) value;
segT sec = bfd_get_section_by_name (stdoutput, h->name);
{
hash_traverse (secalias_hash, do_secalias);
}
+
+#ifdef TE_VMS
+#define NT_VMS_MHD 1
+#define NT_VMS_LNM 2
+
+/* Integrity VMS 8.x identifies it's ELF modules with a standard ELF
+ .note section. */
+
+/* Manufacture a VMS-like time string. */
+static void
+get_vms_time (char *Now)
+{
+ char *pnt;
+ time_t timeb;
+
+ time (&timeb);
+ pnt = ctime (&timeb);
+ pnt[3] = 0;
+ pnt[7] = 0;
+ pnt[10] = 0;
+ pnt[16] = 0;
+ pnt[24] = 0;
+ sprintf (Now, "%2s-%3s-%s %s", pnt + 8, pnt + 4, pnt + 20, pnt + 11);
+}
+
+void
+ia64_vms_note (void)
+{
+ char *p;
+ asection *seg = now_seg;
+ subsegT subseg = now_subseg;
+ Elf_Internal_Note i_note;
+ asection *secp = NULL;
+ char *bname;
+ char buf [256];
+ symbolS *sym;
+
+ /* Create the .note section. */
+
+ secp = subseg_new (".note", 0);
+ bfd_set_section_flags (stdoutput,
+ secp,
+ SEC_HAS_CONTENTS | SEC_READONLY);
+
+ /* Module header note. */
+ bname = xstrdup (lbasename (out_file_name));
+ if ((p = strrchr (bname, '.')))
+ *p = '\0';
+
+ i_note.namesz = 8;
+ i_note.descsz = 40 + strlen (bname);
+ i_note.type = NT_VMS_MHD;
+
+ p = frag_more (sizeof (i_note.namesz));
+ number_to_chars_littleendian (p, i_note.namesz, 8);
+
+ p = frag_more (sizeof (i_note.descsz));
+ number_to_chars_littleendian (p, i_note.descsz, 8);
+
+ p = frag_more (sizeof (i_note.type));
+ number_to_chars_littleendian (p, i_note.type, 8);
+
+ p = frag_more (8);
+ strcpy (p, "IPF/VMS");
+
+ get_vms_time (buf);
+ p = frag_more (17);
+ strcpy (p, buf);
+
+ p = frag_more (17);
+ strcpy (p, "24-FEB-2005 15:00");
+
+ p = frag_more (strlen (bname) + 1);
+ strcpy (p, bname);
+ free (bname);
+
+ p = frag_more (5);
+ strcpy (p, "V1.0");
+
+ frag_align (3, 0, 0);
+
+ /* Language processor name note. */
+ sprintf (buf, "GNU assembler version %s (%s) using BFD version %s",
+ VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
+
+ i_note.namesz = 8;
+ i_note.descsz = 1 + strlen (buf);
+ i_note.type = NT_VMS_LNM;
+
+ p = frag_more (sizeof (i_note.namesz));
+ number_to_chars_littleendian (p, i_note.namesz, 8);
+
+ p = frag_more (sizeof (i_note.descsz));
+ number_to_chars_littleendian (p, i_note.descsz, 8);
+
+ p = frag_more (sizeof (i_note.type));
+ number_to_chars_littleendian (p, i_note.type, 8);
+
+ p = frag_more (8);
+ strcpy (p, "IPF/VMS");
+
+ p = frag_more (strlen (buf) + 1);
+ strcpy (p, buf);
+
+ frag_align (3, 0, 0);
+
+ secp = subseg_new (".vms_display_name_info", 0);
+ bfd_set_section_flags (stdoutput,
+ secp,
+ SEC_HAS_CONTENTS | SEC_READONLY);
+
+ /* This symbol should be passed on the command line and be variable
+ according to language. */
+ sym = symbol_new ("__gnat_vms_display_name@gnat_demangler_rtl",
+ absolute_section, 0, &zero_address_frag);
+ symbol_table_insert (sym);
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING | BSF_DYNAMIC;
+
+ p = frag_more (4);
+ /* Format 3 of VMS demangler Spec. */
+ number_to_chars_littleendian (p, 3, 4);
+
+ p = frag_more (4);
+ /* Place holder for symbol table index of above symbol. */
+ number_to_chars_littleendian (p, -1, 4);
+
+ frag_align (3, 0, 0);
+
+ /* We probably can't restore the current segment, for there likely
+ isn't one yet... */
+ if (seg && subseg)
+ subseg_set (seg, subseg);
+}
+
+#endif /* TE_VMS */
projects / deliverable / binutils-gdb.git / blobdiff