/* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ the Free Software Foundation; either version 3, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
IND_DTR,
IND_ITR,
IND_IBR,
- IND_MEM,
IND_MSR,
IND_PKR,
IND_PMC,
{
struct label_fix *next;
struct symbol *sym;
+ bfd_boolean dw2_mark_labels;
};
/* This is the endianness of the current section. */
/* 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;
/* Characters which may be used to separate multiple commands on a
single line. */
-const char line_separator_chars[] = ";";
+const char line_separator_chars[] = ";{}";
/* Characters which are used to indicate an exponent in a floating
point number. */
struct hash_control *const_hash; /* constant hash table */
struct hash_control *entry_hash; /* code entry hint hash table */
- symbolS *regsym[REG_NUM];
-
/* If X_op is != O_absent, the registername for the instruction's
qualifying predicate. If NULL, p0 is assumed for instructions
- that are predicatable. */
+ that are predictable. */
expressionS qp;
/* Optimize for which CPU. */
int pointer_size; /* size in bytes of a pointer */
int pointer_size_shift; /* shift size of a pointer for alignment */
+
+ symbolS *indregsym[IND_RR - IND_CPUID + 1];
}
md;
#define AR_BSP 17
#define AR_BSPSTORE 18
#define AR_RNAT 19
+#define AR_FCR 21
+#define AR_EFLAG 24
+#define AR_CSD 25
+#define AR_SSD 26
+#define AR_CFLG 27
+#define AR_FSR 28
+#define AR_FIR 29
+#define AR_FDR 30
+#define AR_CCV 32
#define AR_UNAT 36
#define AR_FPSR 40
#define AR_ITC 44
+#define AR_RUC 45
#define AR_PFS 64
#define AR_LC 65
+#define AR_EC 66
static const struct
{
const char *name;
- int regnum;
+ unsigned int regnum;
}
ar[] =
{
- {"ar.k0", 0}, {"ar.k1", 1}, {"ar.k2", 2}, {"ar.k3", 3},
- {"ar.k4", 4}, {"ar.k5", 5}, {"ar.k6", 6}, {"ar.k7", 7},
- {"ar.rsc", 16}, {"ar.bsp", 17},
- {"ar.bspstore", 18}, {"ar.rnat", 19},
- {"ar.fcr", 21}, {"ar.eflag", 24},
- {"ar.csd", 25}, {"ar.ssd", 26},
- {"ar.cflg", 27}, {"ar.fsr", 28},
- {"ar.fir", 29}, {"ar.fdr", 30},
- {"ar.ccv", 32}, {"ar.unat", 36},
- {"ar.fpsr", 40}, {"ar.itc", 44},
- {"ar.pfs", 64}, {"ar.lc", 65},
- {"ar.ec", 66},
+ {"ar.k0", AR_K0}, {"ar.k1", AR_K0 + 1},
+ {"ar.k2", AR_K0 + 2}, {"ar.k3", AR_K0 + 3},
+ {"ar.k4", AR_K0 + 4}, {"ar.k5", AR_K0 + 5},
+ {"ar.k6", AR_K0 + 6}, {"ar.k7", AR_K7},
+ {"ar.rsc", AR_RSC}, {"ar.bsp", AR_BSP},
+ {"ar.bspstore", AR_BSPSTORE}, {"ar.rnat", AR_RNAT},
+ {"ar.fcr", AR_FCR}, {"ar.eflag", AR_EFLAG},
+ {"ar.csd", AR_CSD}, {"ar.ssd", AR_SSD},
+ {"ar.cflg", AR_CFLG}, {"ar.fsr", AR_FSR},
+ {"ar.fir", AR_FIR}, {"ar.fdr", AR_FDR},
+ {"ar.ccv", AR_CCV}, {"ar.unat", AR_UNAT},
+ {"ar.fpsr", AR_FPSR}, {"ar.itc", AR_ITC},
+ {"ar.ruc", AR_RUC}, {"ar.pfs", AR_PFS},
+ {"ar.lc", AR_LC}, {"ar.ec", AR_EC},
};
+/* control registers: */
+
+#define CR_DCR 0
+#define CR_ITM 1
+#define CR_IVA 2
+#define CR_PTA 8
+#define CR_GPTA 9
#define CR_IPSR 16
#define CR_ISR 17
#define CR_IIP 19
#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
#define CR_EOI 67
#define CR_IRR0 68
#define CR_IRR3 71
+#define CR_ITV 72
+#define CR_PMV 73
+#define CR_CMCV 74
#define CR_LRR0 80
#define CR_LRR1 81
-/* control registers: */
static const struct
{
const char *name;
- int regnum;
+ unsigned int regnum;
}
cr[] =
{
- {"cr.dcr", 0},
- {"cr.itm", 1},
- {"cr.iva", 2},
- {"cr.pta", 8},
- {"cr.gpta", 9},
- {"cr.ipsr", 16},
- {"cr.isr", 17},
- {"cr.iip", 19},
- {"cr.ifa", 20},
- {"cr.itir", 21},
- {"cr.iipa", 22},
- {"cr.ifs", 23},
- {"cr.iim", 24},
- {"cr.iha", 25},
- {"cr.lid", 64},
- {"cr.ivr", 65},
- {"cr.tpr", 66},
- {"cr.eoi", 67},
- {"cr.irr0", 68},
- {"cr.irr1", 69},
- {"cr.irr2", 70},
- {"cr.irr3", 71},
- {"cr.itv", 72},
- {"cr.pmv", 73},
- {"cr.cmcv", 74},
- {"cr.lrr0", 80},
- {"cr.lrr1", 81}
+ {"cr.dcr", CR_DCR},
+ {"cr.itm", CR_ITM},
+ {"cr.iva", CR_IVA},
+ {"cr.pta", CR_PTA},
+ {"cr.gpta", CR_GPTA},
+ {"cr.ipsr", CR_IPSR},
+ {"cr.isr", CR_ISR},
+ {"cr.iip", CR_IIP},
+ {"cr.ifa", CR_IFA},
+ {"cr.itir", CR_ITIR},
+ {"cr.iipa", CR_IIPA},
+ {"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},
+ {"cr.eoi", CR_EOI},
+ {"cr.irr0", CR_IRR0},
+ {"cr.irr1", CR_IRR0 + 1},
+ {"cr.irr2", CR_IRR0 + 2},
+ {"cr.irr3", CR_IRR3},
+ {"cr.itv", CR_ITV},
+ {"cr.pmv", CR_PMV},
+ {"cr.cmcv", CR_CMCV},
+ {"cr.lrr0", CR_LRR0},
+ {"cr.lrr1", CR_LRR1}
};
#define PSR_MFL 4
static const struct
{
const char *name;
- int regnum;
+ unsigned int regnum;
}
indirect_reg[] =
{
0x0008000000LL, /* M-unit nop */
0x4000000000LL, /* B-unit nop */
0x0008000000LL, /* F-unit nop */
- 0x0008000000LL, /* L-"unit" nop */
+ 0x0000000000LL, /* L-"unit" nop immediate */
0x0008000000LL, /* X-unit nop */
};
unwind_record r;
unsigned long slot_number;
fragS *slot_frag;
- unsigned long next_slot_number;
- fragS *next_slot_frag;
struct unw_rec_list *next;
} unw_rec_list;
unsigned int prologue_count;
} label_prologue_count;
+typedef struct proc_pending
+{
+ symbolS *sym;
+ struct proc_pending *next;
+} proc_pending;
+
static struct
{
/* Maintain a list of unwind entries for the current function. */
unw_rec_list *list;
unw_rec_list *tail;
- /* Any unwind entires that should be attached to the current slot
+ /* Any unwind entries that should be attached to the current slot
that an insn is being constructed for. */
unw_rec_list *current_entry;
/* These are used to create the unwind table entry for this function. */
- symbolS *proc_start;
+ proc_pending proc_pending;
symbolS *info; /* pointer to unwind info */
symbolS *personality_routine;
segT saved_text_seg;
/* TRUE if processing unwind directives in a prologue region. */
unsigned int prologue : 1;
unsigned int prologue_mask : 4;
+ unsigned int prologue_gr : 7;
unsigned int body : 1;
unsigned int insn : 1;
unsigned int prologue_count; /* number of .prologues seen so far */
/* Prologue counts at previous .label_state directives. */
struct label_prologue_count * saved_prologue_counts;
+
+ /* List of split up .save-s. */
+ unw_p_record *pending_saves;
} unwind;
/* The input value is a negated offset from psp, and specifies an address
#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_vframepsp PARAMS ((int));
-static void dot_save PARAMS ((int));
-static void dot_restore PARAMS ((int));
-static void dot_restorereg PARAMS ((int));
-static void dot_restorereg_p 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_spillreg_p PARAMS ((int));
-static void dot_spillmem_p 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 *ptr));
-static symbolS *declare_register PARAMS ((const char *name, int regnum));
-static void declare_register_set PARAMS ((const char *, int, 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 *e));
-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));
-static unw_rec_list *output_spill_sprel PARAMS ((unsigned int, unsigned int, unsigned int));
-static unw_rec_list *output_spill_psprel_p PARAMS ((unsigned int, unsigned int, unsigned int,
- unsigned int));
-static unw_rec_list *output_spill_sprel_p 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));
-static unw_rec_list *output_spill_reg_p 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 convert_expr_to_ab_reg PARAMS ((expressionS *, unsigned int *, unsigned int *));
-static int convert_expr_to_xy_reg PARAMS ((expressionS *, unsigned int *, unsigned 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 (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;
+ia64_elf_section_letter (int letter, char **ptr_msg)
{
if (letter == 's')
return SHF_IA_64_SHORT;
/* 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,
+ int 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;
sof = ins + locs + outs;
if (sof > 96)
{
- as_bad ("Size of frame exceeds maximum of 96 registers");
+ as_bad (_("Size of frame exceeds maximum of 96 registers"));
return 0;
}
if (rots > sof)
{
- as_warn ("Size of rotating registers exceeds frame size");
+ as_warn (_("Size of rotating registers exceeds frame size"));
return 0;
}
md.in.base = REG_GR + 32;
}
void
-ia64_flush_insns ()
+ia64_flush_insns (void)
{
struct label_fix *lfix;
segT saved_seg;
subsegT saved_subseg;
unw_rec_list *ptr;
+ bfd_boolean mark;
if (!md.last_text_seg)
return;
emit_one_bundle (); /* force out queued instructions */
/* In case there are labels following the last instruction, resolve
- those now: */
+ those now. */
+ mark = FALSE;
for (lfix = CURR_SLOT.label_fixups; lfix; lfix = lfix->next)
{
- S_SET_VALUE (lfix->sym, frag_now_fix ());
- symbol_set_frag (lfix->sym, frag_now);
+ symbol_set_value_now (lfix->sym);
+ mark |= lfix->dw2_mark_labels;
}
- CURR_SLOT.label_fixups = 0;
- for (lfix = CURR_SLOT.tag_fixups; lfix; lfix = lfix->next)
+ if (mark)
{
- S_SET_VALUE (lfix->sym, frag_now_fix ());
- symbol_set_frag (lfix->sym, frag_now);
+ 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;
+
+ for (lfix = CURR_SLOT.tag_fixups; lfix; lfix = lfix->next)
+ symbol_set_value_now (lfix->sym);
CURR_SLOT.tag_fixups = 0;
/* In case there are unwind directives following the last instruction,
subseg_set (saved_seg, saved_subseg);
if (md.qp.X_op == O_register)
- as_bad ("qualifying predicate not followed by instruction");
+ as_bad (_("qualifying predicate not followed by instruction"));
}
static void
}
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;
if (rtype == body)
r = 1;
else if (rtype != prologue)
- as_bad ("record type is not valid");
+ as_bad (_("record type is not valid"));
byte = UNW_R1 | (r << 5) | (rlen & 0x1f);
(*f) (1, &byte, NULL);
}
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];
if (rtype == body)
r = 1;
else if (rtype != prologue)
- as_bad ("record type is not valid");
+ as_bad (_("record type is not valid"));
bytes[0] = (UNW_R3 | r);
count = output_leb128 (bytes + 1, rlen, 0);
(*f) (count + 1, bytes, NULL);
}
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;
r = 11;
break;
default:
- as_bad ("Invalid record type for P3 format.");
+ as_bad (_("Invalid record type for P3 format."));
}
bytes[0] = (UNW_P3 | (r >> 1));
bytes[1] = (((r & 1) << 7) | reg);
}
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;
if (rtype == gr_mem)
r = 1;
else if (rtype != fr_mem)
- as_bad ("Invalid record type for format P6");
+ as_bad (_("Invalid record type for format P6"));
byte = (UNW_P6 | (r << 4) | (rmask & 0x0f));
(*f) (1, &byte, NULL);
}
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;
if (rtype == copy_state)
r = 1;
else if (rtype != label_state)
- as_bad ("Invalid record type for format B1");
+ as_bad (_("Invalid record type for format B1"));
byte = (UNW_B1 | (r << 5) | (label & 0x1f));
(*f) (1, &byte, NULL);
}
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;
if (rtype == copy_state)
r = 1;
else if (rtype != label_state)
- as_bad ("Invalid record type for format B1");
+ as_bad (_("Invalid record type for format B1"));
bytes[0] = (UNW_B4 | (r << 3));
count += output_leb128 (bytes + 1, label, 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;
if (rtype == spill_sprel)
r = 1;
else if (rtype != spill_psprel)
- as_bad ("Invalid record type for format X1");
+ as_bad (_("Invalid record type for format X1"));
bytes[1] = ((r << 7) | format_ab_reg (ab, reg));
count += output_leb128 (bytes + 2, t, 0);
count += output_leb128 (bytes + count, w1, 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;
if (rtype == spill_sprel_p)
r = 1;
else if (rtype != spill_psprel_p)
- as_bad ("Invalid record type for format X3");
+ as_bad (_("Invalid record type for format X3"));
bytes[1] = ((r << 7) | (qp & 0x3f));
bytes[2] = format_ab_reg (ab, reg);
count += output_leb128 (bytes + 3, t, 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;
(*f) (count, bytes, NULL);
}
+/* This function checks whether there are any outstanding .save-s and
+ discards them if so. */
+
+static void
+check_pending_save (void)
+{
+ if (unwind.pending_saves)
+ {
+ unw_rec_list *cur, *prev;
+
+ as_warn (_("Previous .save incomplete"));
+ for (cur = unwind.list, prev = NULL; cur; )
+ if (&cur->r.record.p == unwind.pending_saves)
+ {
+ if (prev)
+ prev->next = cur->next;
+ else
+ unwind.list = cur->next;
+ if (cur == unwind.tail)
+ unwind.tail = prev;
+ if (cur == unwind.current_entry)
+ unwind.current_entry = cur->next;
+ /* Don't free the first discarded record, it's being used as
+ terminator for (currently) br_gr and gr_gr processing, and
+ also prevents leaving a dangling pointer to it in its
+ predecessor. */
+ cur->r.record.p.grmask = 0;
+ cur->r.record.p.brmask = 0;
+ cur->r.record.p.frmask = 0;
+ prev = cur->r.record.p.next;
+ cur->r.record.p.next = NULL;
+ cur = prev;
+ break;
+ }
+ else
+ {
+ prev = cur;
+ cur = cur->next;
+ }
+ while (cur)
+ {
+ prev = cur;
+ cur = cur->r.record.p.next;
+ free (prev);
+ }
+ unwind.pending_saves = NULL;
+ }
+}
+
/* This function allocates a record list structure, and initializes fields. */
static unw_rec_list *
{
unw_rec_list *ptr;
ptr = xmalloc (sizeof (*ptr));
- ptr->next = NULL;
+ memset (ptr, 0, sizeof (*ptr));
ptr->slot_number = SLOT_NUM_NOT_SET;
ptr->r.type = t;
- ptr->next_slot_number = 0;
- ptr->next_slot_frag = 0;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.br = br;
+ ptr->r.record.p.r.br = br;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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);
- ptr->r.record.p.rmask = mask;
- return ptr;
+ unw_rec_list *cur = ptr;
+
+ ptr->r.record.p.frmask = mask;
+ unwind.pending_saves = &ptr->r.record.p;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ mask &= ~(mask & (~mask + 1));
+ if (!mask)
+ return ptr;
+ cur = alloc_record (fr_mem);
+ cur->r.record.p.frmask = mask;
+ /* Retain only least significant bit. */
+ prev->r.record.p.frmask ^= mask;
+ prev->r.record.p.next = cur;
+ }
}
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);
- ptr->r.record.p.grmask = gr_mask;
- ptr->r.record.p.frmask = fr_mask;
- return ptr;
+ unw_rec_list *cur = ptr;
+
+ unwind.pending_saves = &cur->r.record.p;
+ cur->r.record.p.frmask = fr_mask;
+ while (fr_mask)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ fr_mask &= ~(fr_mask & (~fr_mask + 1));
+ if (!gr_mask && !fr_mask)
+ return ptr;
+ cur = alloc_record (frgr_mem);
+ cur->r.record.p.frmask = fr_mask;
+ /* Retain only least significant bit. */
+ prev->r.record.p.frmask ^= fr_mask;
+ prev->r.record.p.next = cur;
+ }
+ cur->r.record.p.grmask = gr_mask;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ gr_mask &= ~(gr_mask & (~gr_mask + 1));
+ if (!gr_mask)
+ return ptr;
+ cur = alloc_record (frgr_mem);
+ cur->r.record.p.grmask = gr_mask;
+ /* Retain only least significant bit. */
+ prev->r.record.p.grmask ^= gr_mask;
+ prev->r.record.p.next = cur;
+ }
}
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;
+
ptr->r.record.p.grmask = mask;
- ptr->r.record.p.gr = reg;
- return ptr;
+ ptr->r.record.p.r.gr = reg;
+ unwind.pending_saves = &ptr->r.record.p;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ mask &= ~(mask & (~mask + 1));
+ if (!mask)
+ return ptr;
+ cur = alloc_record (gr_gr);
+ cur->r.record.p.grmask = mask;
+ /* Indicate this record shouldn't be output. */
+ cur->r.record.p.r.gr = REG_NUM;
+ /* Retain only least significant bit. */
+ prev->r.record.p.grmask ^= mask;
+ prev->r.record.p.next = cur;
+ }
}
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);
- ptr->r.record.p.rmask = mask;
- return ptr;
+ unw_rec_list *cur = ptr;
+
+ ptr->r.record.p.grmask = mask;
+ unwind.pending_saves = &ptr->r.record.p;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ mask &= ~(mask & (~mask + 1));
+ if (!mask)
+ return ptr;
+ cur = alloc_record (gr_mem);
+ cur->r.record.p.grmask = mask;
+ /* Retain only least significant bit. */
+ prev->r.record.p.grmask ^= mask;
+ prev->r.record.p.next = cur;
+ }
}
static unw_rec_list *
output_br_mem (unsigned int mask)
{
unw_rec_list *ptr = alloc_record (br_mem);
+ unw_rec_list *cur = ptr;
+
ptr->r.record.p.brmask = mask;
- return ptr;
+ unwind.pending_saves = &ptr->r.record.p;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ mask &= ~(mask & (~mask + 1));
+ if (!mask)
+ return ptr;
+ cur = alloc_record (br_mem);
+ cur->r.record.p.brmask = mask;
+ /* Retain only least significant bit. */
+ prev->r.record.p.brmask ^= mask;
+ prev->r.record.p.next = cur;
+ }
}
static unw_rec_list *
-output_br_gr (save_mask, reg)
- unsigned int save_mask;
- unsigned int reg;
+output_br_gr (unsigned int mask, unsigned int reg)
{
unw_rec_list *ptr = alloc_record (br_gr);
- ptr->r.record.p.brmask = save_mask;
- ptr->r.record.p.gr = reg;
- return ptr;
+ unw_rec_list *cur = ptr;
+
+ ptr->r.record.p.brmask = mask;
+ ptr->r.record.p.r.gr = reg;
+ unwind.pending_saves = &ptr->r.record.p;
+ for (;;)
+ {
+ unw_rec_list *prev = cur;
+
+ /* Clear least significant set bit. */
+ mask &= ~(mask & (~mask + 1));
+ if (!mask)
+ return ptr;
+ cur = alloc_record (br_gr);
+ cur->r.record.p.brmask = mask;
+ /* Indicate this record shouldn't be output. */
+ cur->r.record.p.r.gr = REG_NUM;
+ /* Retain only least significant bit. */
+ prev->r.record.p.brmask ^= mask;
+ prev->r.record.p.next = cur;
+ }
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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.gr = gr;
+ ptr->r.record.p.r.gr = gr;
return ptr;
}
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.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
return ptr;
}
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.spoff = offset / 4;
+ ptr->r.record.p.off.sp = offset / 4;
return ptr;
}
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)
- unsigned int ab;
- unsigned int reg;
- unsigned int offset;
+output_spill_psprel (unsigned int ab,
+ unsigned int reg,
+ unsigned int offset,
+ unsigned int predicate)
{
- unw_rec_list *ptr = alloc_record (spill_psprel);
+ unw_rec_list *ptr = alloc_record (predicate ? spill_psprel_p : spill_psprel);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.pspoff = ENCODED_PSP_OFFSET (offset);
- return ptr;
-}
-
-static unw_rec_list *
-output_spill_sprel (ab, reg, offset)
- unsigned int ab;
- unsigned int reg;
- unsigned int offset;
-{
- unw_rec_list *ptr = alloc_record (spill_sprel);
- ptr->r.record.x.ab = ab;
- ptr->r.record.x.reg = reg;
- ptr->r.record.x.spoff = offset / 4;
- return ptr;
-}
-
-static unw_rec_list *
-output_spill_psprel_p (ab, reg, offset, predicate)
- unsigned int ab;
- unsigned int reg;
- unsigned int offset;
- unsigned int predicate;
-{
- unw_rec_list *ptr = alloc_record (spill_psprel_p);
- ptr->r.record.x.ab = ab;
- ptr->r.record.x.reg = reg;
- ptr->r.record.x.pspoff = ENCODED_PSP_OFFSET (offset);
+ ptr->r.record.x.where.pspoff = ENCODED_PSP_OFFSET (offset);
ptr->r.record.x.qp = predicate;
return ptr;
}
static unw_rec_list *
-output_spill_sprel_p (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 (spill_sprel_p);
+ unw_rec_list *ptr = alloc_record (predicate ? spill_sprel_p : spill_sprel);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.spoff = offset / 4;
+ ptr->r.record.x.where.spoff = offset / 4;
ptr->r.record.x.qp = predicate;
return ptr;
}
static unw_rec_list *
-output_spill_reg (ab, reg, targ_reg, xy)
- unsigned int ab;
- unsigned int reg;
- unsigned int targ_reg;
- unsigned int xy;
+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 (spill_reg);
+ unw_rec_list *ptr = alloc_record (predicate ? spill_reg_p : spill_reg);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.treg = targ_reg;
- ptr->r.record.x.xy = xy;
- return ptr;
-}
-
-static unw_rec_list *
-output_spill_reg_p (ab, reg, targ_reg, xy, predicate)
- unsigned int ab;
- unsigned int reg;
- unsigned int targ_reg;
- unsigned int xy;
- unsigned int predicate;
-{
- unw_rec_list *ptr = alloc_record (spill_reg_p);
- ptr->r.record.x.ab = ab;
- ptr->r.record.x.reg = reg;
- ptr->r.record.x.treg = targ_reg;
+ ptr->r.record.x.where.reg = targ_reg;
ptr->r.record.x.xy = xy;
ptr->r.record.x.qp = predicate;
return ptr;
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 long fr_mask, gr_mask;
+ unsigned int fr_mask, gr_mask;
switch (ptr->r.type)
{
case bsp_gr:
case bspstore_gr:
case rnat_gr:
- output_P3_format (f, ptr->r.type, ptr->r.record.p.gr);
+ output_P3_format (f, ptr->r.type, ptr->r.record.p.r.gr);
break;
case rp_br:
- output_P3_format (f, rp_br, ptr->r.record.p.br);
+ output_P3_format (f, rp_br, ptr->r.record.p.r.br);
break;
case psp_sprel:
- output_P7_format (f, psp_sprel, ptr->r.record.p.spoff, 0);
+ output_P7_format (f, psp_sprel, ptr->r.record.p.off.sp, 0);
break;
case rp_when:
case pfs_when:
case lc_psprel:
case fpsr_psprel:
case spill_base:
- output_P7_format (f, ptr->r.type, ptr->r.record.p.pspoff, 0);
+ output_P7_format (f, ptr->r.type, ptr->r.record.p.off.psp, 0);
break;
case rp_sprel:
case pfs_sprel:
case bsp_sprel:
case bspstore_sprel:
case rnat_sprel:
- output_P8_format (f, ptr->r.type, ptr->r.record.p.spoff);
+ output_P8_format (f, ptr->r.type, ptr->r.record.p.off.sp);
break;
case gr_gr:
- output_P9_format (f, ptr->r.record.p.grmask, ptr->r.record.p.gr);
+ if (ptr->r.record.p.r.gr < REG_NUM)
+ {
+ const unw_rec_list *cur = ptr;
+
+ gr_mask = cur->r.record.p.grmask;
+ while ((cur = cur->r.record.p.next) != NULL)
+ gr_mask |= cur->r.record.p.grmask;
+ output_P9_format (f, gr_mask, ptr->r.record.p.r.gr);
+ }
break;
case br_gr:
- output_P2_format (f, ptr->r.record.p.brmask, ptr->r.record.p.gr);
+ if (ptr->r.record.p.r.gr < REG_NUM)
+ {
+ const unw_rec_list *cur = ptr;
+
+ gr_mask = cur->r.record.p.brmask;
+ while ((cur = cur->r.record.p.next) != NULL)
+ gr_mask |= cur->r.record.p.brmask;
+ output_P2_format (f, gr_mask, ptr->r.record.p.r.gr);
+ }
break;
case spill_mask:
- as_bad ("spill_mask record unimplemented.");
+ as_bad (_("spill_mask record unimplemented."));
break;
case priunat_when_gr:
case priunat_when_mem:
case bsp_psprel:
case bspstore_psprel:
case rnat_psprel:
- output_P8_format (f, ptr->r.type, ptr->r.record.p.pspoff);
+ output_P8_format (f, ptr->r.type, ptr->r.record.p.off.psp);
break;
case unwabi:
output_P10_format (f, ptr->r.record.p.abi, ptr->r.record.p.context);
case spill_psprel:
output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
ptr->r.record.x.reg, ptr->r.record.x.t,
- ptr->r.record.x.pspoff);
+ ptr->r.record.x.where.pspoff);
break;
case spill_sprel:
output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
ptr->r.record.x.reg, ptr->r.record.x.t,
- ptr->r.record.x.spoff);
+ ptr->r.record.x.where.spoff);
break;
case spill_reg:
output_X2_format (f, ptr->r.record.x.ab, ptr->r.record.x.reg,
ptr->r.record.x.xy >> 1, ptr->r.record.x.xy,
- ptr->r.record.x.treg, ptr->r.record.x.t);
+ ptr->r.record.x.where.reg, ptr->r.record.x.t);
break;
case spill_psprel_p:
output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
ptr->r.record.x.ab, ptr->r.record.x.reg,
- ptr->r.record.x.t, ptr->r.record.x.pspoff);
+ ptr->r.record.x.t, ptr->r.record.x.where.pspoff);
break;
case spill_sprel_p:
output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
ptr->r.record.x.ab, ptr->r.record.x.reg,
- ptr->r.record.x.t, ptr->r.record.x.spoff);
+ ptr->r.record.x.t, ptr->r.record.x.where.spoff);
break;
case spill_reg_p:
output_X4_format (f, ptr->r.record.x.qp, ptr->r.record.x.ab,
ptr->r.record.x.reg, ptr->r.record.x.xy >> 1,
- ptr->r.record.x.xy, ptr->r.record.x.treg,
+ ptr->r.record.x.xy, ptr->r.record.x.where.reg,
ptr->r.record.x.t);
break;
default:
- as_bad ("record_type_not_valid");
+ as_bad (_("record_type_not_valid"));
break;
}
}
/* 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);
return vbyte_count;
}
+/* Return the number of bits set in the input value.
+ Perhaps this has a better place... */
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# define popcount __builtin_popcount
+#else
+static int
+popcount (unsigned x)
+{
+ static const unsigned char popcnt[16] =
+ {
+ 0, 1, 1, 2,
+ 1, 2, 2, 3,
+ 1, 2, 2, 3,
+ 2, 3, 3, 4
+ };
+
+ if (x < NELEMS (popcnt))
+ return popcnt[x];
+ return popcnt[x % NELEMS (popcnt)] + popcount (x / NELEMS (popcnt));
+}
+#endif
+
/* Update IMASK bitmask to reflect the fact that one or more registers
of type TYPE are saved starting at instruction with index T. If N
bits are set in REGMASK, it is assumed that instructions T through
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;
{
if (i >= imask_size)
{
- as_bad ("Ignoring attempt to spill beyond end of region");
+ as_bad (_("Ignoring attempt to spill beyond end of region"));
return;
}
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;
break;
case rs_space:
- as_fatal ("only constant space allocation is supported");
+ as_fatal (_("Only constant space allocation is supported"));
break;
case rs_align:
case rs_org:
if (first_frag->fr_symbol)
{
- as_fatal ("only constant offsets are supported");
+ as_fatal (_("Only constant offsets are supported"));
break;
}
case rs_fill:
/* Move to the beginning of the next frag. */
first_frag = first_frag->fr_next;
first_addr = (unsigned long) &first_frag->fr_literal;
+
+ /* This can happen if there is section switching in the middle of a
+ function, causing the frag chain for the function to be broken.
+ It is too difficult to recover safely from this problem, so we just
+ exit with an error. */
+ if (first_frag == NULL)
+ as_fatal (_("Section switching in code is not supported."));
}
/* Add in the used part of the last frag. */
/* 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;
for (ptr = list; ptr; ptr = ptr->next)
{
if (ptr->slot_number == SLOT_NUM_NOT_SET)
- as_bad (" Insn slot not set in unwind record.");
+ as_bad (_(" Insn slot not set in unwind record."));
t = slot_index (ptr->slot_number, ptr->slot_frag,
first_addr, first_frag, before_relax);
switch (ptr->r.type)
case frgr_mem:
if (!region)
{
- as_bad ("frgr_mem record before region record!");
+ as_bad (_("frgr_mem record before region record!"));
return;
}
region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
case fr_mem:
if (!region)
{
- as_bad ("fr_mem record before region record!");
+ as_bad (_("fr_mem record before region record!"));
return;
}
- region->r.record.r.mask.fr_mem |= ptr->r.record.p.rmask;
- set_imask (region, ptr->r.record.p.rmask, t, 1);
+ region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
+ set_imask (region, ptr->r.record.p.frmask, t, 1);
break;
case gr_mem:
if (!region)
{
- as_bad ("gr_mem record before region record!");
+ as_bad (_("gr_mem record before region record!"));
return;
}
- region->r.record.r.mask.gr_mem |= ptr->r.record.p.rmask;
- set_imask (region, ptr->r.record.p.rmask, t, 2);
+ region->r.record.r.mask.gr_mem |= ptr->r.record.p.grmask;
+ set_imask (region, ptr->r.record.p.grmask, t, 2);
break;
case br_mem:
if (!region)
{
- as_bad ("br_mem record before region record!");
+ as_bad (_("br_mem record before region record!"));
return;
}
region->r.record.r.mask.br_mem |= ptr->r.record.p.brmask;
case gr_gr:
if (!region)
{
- as_bad ("gr_gr record before region record!");
+ as_bad (_("gr_gr record before region record!"));
return;
}
set_imask (region, ptr->r.record.p.grmask, t, 2);
case br_gr:
if (!region)
{
- as_bad ("br_gr record before region record!");
+ as_bad (_("br_gr record before region record!"));
return;
}
set_imask (region, ptr->r.record.p.brmask, t, 3);
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
-convert_expr_to_ab_reg (e, ab, regp)
- expressionS *e;
- unsigned int *ab;
- unsigned int *regp;
+parse_predicate_and_operand (expressionS *e, unsigned *qp, const char *po)
+{
+ int sep = parse_operand (e, ',');
+
+ *qp = e->X_add_number - REG_P;
+ if (e->X_op != O_register || *qp > 63)
+ {
+ as_bad (_("First operand to .%s must be a predicate"), po);
+ *qp = 0;
+ }
+ else if (*qp == 0)
+ as_warn (_("Pointless use of p0 as first operand to .%s"), po);
+ if (sep == ',')
+ sep = parse_operand (e, ',');
+ else
+ e->X_op = O_absent;
+ return sep;
+}
+
+static void
+convert_expr_to_ab_reg (const expressionS *e,
+ unsigned int *ab,
+ unsigned int *regp,
+ const char *po,
+ int n)
{
- unsigned int reg;
+ unsigned int reg = e->X_add_number;
+
+ *ab = *regp = 0; /* Anything valid is good here. */
if (e->X_op != O_register)
- return 0;
+ reg = REG_GR; /* Anything invalid is good here. */
- reg = e->X_add_number;
if (reg >= (REG_GR + 4) && reg <= (REG_GR + 7))
{
*ab = 0;
case REG_AR + AR_LC: *regp = 10; break;
default:
- return 0;
+ as_bad (_("Operand %d to .%s must be a preserved register"), n, po);
+ break;
}
}
- return 1;
}
-static int
-convert_expr_to_xy_reg (e, xy, regp)
- expressionS *e;
- unsigned int *xy;
- unsigned int *regp;
+static void
+convert_expr_to_xy_reg (const expressionS *e,
+ unsigned int *xy,
+ unsigned int *regp,
+ const char *po,
+ int n)
{
- unsigned int reg;
+ unsigned int reg = e->X_add_number;
- if (e->X_op != O_register)
- return 0;
+ *xy = *regp = 0; /* Anything valid is good here. */
- reg = e->X_add_number;
+ if (e->X_op != O_register)
+ reg = REG_GR; /* Anything invalid is good here. */
- if (/* reg >= REG_GR && */ reg <= (REG_GR + 127))
+ if (reg >= (REG_GR + 1) && reg <= (REG_GR + 127))
{
*xy = 0;
*regp = reg - REG_GR;
}
- else if (reg >= REG_FR && reg <= (REG_FR + 127))
+ else if (reg >= (REG_FR + 2) && reg <= (REG_FR + 127))
{
*xy = 1;
*regp = reg - REG_FR;
*regp = reg - REG_BR;
}
else
- return -1;
- return 1;
+ as_bad (_("Operand %d to .%s must be a writable register"), n, po);
}
static void
}
static void
-dot_radix (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_radix (int dummy ATTRIBUTE_UNUSED)
{
- int radix;
+ char *radix;
+ int ch;
SKIP_WHITESPACE ();
- radix = *input_line_pointer++;
- if (radix != 'C' && !is_end_of_line[(unsigned char) radix])
- {
- as_bad ("Radix `%c' unsupported", *input_line_pointer);
- ignore_rest_of_line ();
- return;
- }
+ if (is_it_end_of_statement ())
+ return;
+ radix = input_line_pointer;
+ ch = get_symbol_end ();
+ ia64_canonicalize_symbol_name (radix);
+ if (strcasecmp (radix, "C"))
+ as_bad (_("Radix `%s' unsupported or invalid"), radix);
+ *input_line_pointer = ch;
+ demand_empty_rest_of_line ();
}
/* Helper function for .loc directives. If the assembler is not generating
/* .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]);
}
{
if (md.unwind_check == unwind_check_warning)
{
- as_warn (".%s outside of %s", directive, region);
+ as_warn (_(".%s outside of %s"), directive, region);
return -1;
}
else
{
- as_bad (".%s outside of %s", directive, region);
+ as_bad (_(".%s outside of %s"), directive, region);
ignore_rest_of_line ();
return 0;
}
static int
in_procedure (const char *directive)
{
- if (unwind.proc_start
+ if (unwind.proc_pending.sym
&& (!unwind.saved_text_seg || strcmp (directive, "endp") == 0))
return 1;
return unwind_diagnostic ("procedure", directive);
in_prologue (const char *directive)
{
int in = in_procedure (directive);
- if (in)
- {
- /* We are in a procedure. Check if we are in a prologue. */
- if (unwind.prologue)
- return 1;
- /* We only want to issue one message. */
- if (in == 1)
- return unwind_diagnostic ("prologue", directive);
- else
- return -1;
- }
- return 0;
+
+ if (in > 0 && !unwind.prologue)
+ in = unwind_diagnostic ("prologue", directive);
+ check_pending_save ();
+ return in;
}
/* Return 1 if a directive is in a body, -1 if a directive isn't in
in_body (const char *directive)
{
int in = in_procedure (directive);
- if (in)
- {
- /* We are in a procedure. Check if we are in a body. */
- if (unwind.body)
- return 1;
- /* We only want to issue one message. */
- if (in == 1)
- return unwind_diagnostic ("body region", directive);
- else
- return -1;
- }
- return 0;
+
+ if (in > 0 && !unwind.body)
+ in = unwind_diagnostic ("body region", directive);
+ return in;
}
static void
-add_unwind_entry (ptr)
- unw_rec_list *ptr;
+add_unwind_entry (unw_rec_list *ptr, int sep)
{
- if (unwind.tail)
- unwind.tail->next = ptr;
- else
- unwind.list = ptr;
- unwind.tail = ptr;
+ if (ptr)
+ {
+ if (unwind.tail)
+ unwind.tail->next = ptr;
+ else
+ unwind.list = ptr;
+ unwind.tail = ptr;
+
+ /* The current entry can in fact be a chain of unwind entries. */
+ if (unwind.current_entry == NULL)
+ unwind.current_entry = ptr;
+ }
/* The current entry can in fact be a chain of unwind entries. */
if (unwind.current_entry == NULL)
unwind.current_entry = ptr;
+
+ if (sep == ',')
+ {
+ /* Parse a tag permitted for the current directive. */
+ int ch;
+
+ SKIP_WHITESPACE ();
+ ch = get_symbol_end ();
+ /* FIXME: For now, just issue a warning that this isn't implemented. */
+ {
+ static int warned;
+
+ if (!warned)
+ {
+ warned = 1;
+ as_warn (_("Tags on unwind pseudo-ops aren't supported, yet"));
+ }
+ }
+ *input_line_pointer = ch;
+ }
+ if (sep != NOT_A_CHAR)
+ demand_empty_rest_of_line ();
}
static void
-dot_fframe (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_fframe (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
+ int sep;
if (!in_prologue ("fframe"))
return;
- parse_operand (&e);
+ sep = parse_operand (&e, ',');
if (e.X_op != O_constant)
- as_bad ("Operand to .fframe must be a constant");
- else
- add_unwind_entry (output_mem_stack_f (e.X_add_number));
+ {
+ as_bad (_("First operand to .fframe must be a constant"));
+ e.X_add_number = 0;
+ }
+ add_unwind_entry (output_mem_stack_f (e.X_add_number), sep);
}
static void
-dot_vframe (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_vframe (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
unsigned reg;
+ int sep;
if (!in_prologue ("vframe"))
return;
- parse_operand (&e);
+ sep = parse_operand (&e, ',');
reg = e.X_add_number - REG_GR;
- if (e.X_op == O_register && reg < 128)
+ if (e.X_op != O_register || reg > 127)
{
- add_unwind_entry (output_mem_stack_v ());
- if (! (unwind.prologue_mask & 2))
- add_unwind_entry (output_psp_gr (reg));
+ as_bad (_("First operand to .vframe must be a general register"));
+ reg = 0;
}
- else
- as_bad ("First operand to .vframe must be a general register");
+ add_unwind_entry (output_mem_stack_v (), sep);
+ if (! (unwind.prologue_mask & 2))
+ add_unwind_entry (output_psp_gr (reg), NOT_A_CHAR);
+ else if (reg != unwind.prologue_gr
+ + (unsigned) popcount (unwind.prologue_mask & (-2 << 1)))
+ as_warn (_("Operand of .vframe contradicts .prologue"));
}
static void
-dot_vframesp (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_vframesp (int psp)
{
expressionS e;
+ int sep;
- if (!in_prologue ("vframesp"))
- return;
-
- parse_operand (&e);
- if (e.X_op == O_constant)
- {
- add_unwind_entry (output_mem_stack_v ());
- add_unwind_entry (output_psp_sprel (e.X_add_number));
- }
- else
- as_bad ("Operand to .vframesp must be a constant (sp-relative offset)");
-}
-
-static void
-dot_vframepsp (dummy)
- int dummy ATTRIBUTE_UNUSED;
-{
- expressionS e;
+ if (psp)
+ as_warn (_(".vframepsp is meaningless, assuming .vframesp was meant"));
- if (!in_prologue ("vframepsp"))
+ if (!in_prologue ("vframesp"))
return;
- parse_operand (&e);
- if (e.X_op == O_constant)
+ sep = parse_operand (&e, ',');
+ if (e.X_op != O_constant)
{
- add_unwind_entry (output_mem_stack_v ());
- add_unwind_entry (output_psp_sprel (e.X_add_number));
+ as_bad (_("Operand to .vframesp must be a constant (sp-relative offset)"));
+ e.X_add_number = 0;
}
- else
- as_bad ("Operand to .vframepsp must be a constant (psp-relative offset)");
+ add_unwind_entry (output_mem_stack_v (), sep);
+ add_unwind_entry (output_psp_sprel (e.X_add_number), NOT_A_CHAR);
}
static void
-dot_save (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_save (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
+ unsigned reg1, reg2;
int sep;
- int reg1, reg2;
if (!in_prologue ("save"))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- as_bad ("No second operand to .save");
- sep = parse_operand (&e2);
+ sep = parse_operand (&e1, ',');
+ if (sep == ',')
+ sep = parse_operand (&e2, ',');
+ else
+ e2.X_op = O_absent;
reg1 = e1.X_add_number;
- reg2 = e2.X_add_number - REG_GR;
-
/* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
- if (e1.X_op == O_register)
+ if (e1.X_op != O_register)
{
- if (e2.X_op == O_register && reg2 >= 0 && reg2 < 128)
- {
- switch (reg1)
- {
- case REG_AR + AR_BSP:
- add_unwind_entry (output_bsp_when ());
- add_unwind_entry (output_bsp_gr (reg2));
- break;
- case REG_AR + AR_BSPSTORE:
- add_unwind_entry (output_bspstore_when ());
- add_unwind_entry (output_bspstore_gr (reg2));
- break;
- case REG_AR + AR_RNAT:
- add_unwind_entry (output_rnat_when ());
- add_unwind_entry (output_rnat_gr (reg2));
- break;
- case REG_AR + AR_UNAT:
- add_unwind_entry (output_unat_when ());
- add_unwind_entry (output_unat_gr (reg2));
- break;
- case REG_AR + AR_FPSR:
- add_unwind_entry (output_fpsr_when ());
- add_unwind_entry (output_fpsr_gr (reg2));
- break;
- case REG_AR + AR_PFS:
- add_unwind_entry (output_pfs_when ());
- if (! (unwind.prologue_mask & 4))
- add_unwind_entry (output_pfs_gr (reg2));
- break;
- case REG_AR + AR_LC:
- add_unwind_entry (output_lc_when ());
- add_unwind_entry (output_lc_gr (reg2));
- break;
- case REG_BR:
- add_unwind_entry (output_rp_when ());
- if (! (unwind.prologue_mask & 8))
- add_unwind_entry (output_rp_gr (reg2));
- break;
- case REG_PR:
- add_unwind_entry (output_preds_when ());
- if (! (unwind.prologue_mask & 1))
- add_unwind_entry (output_preds_gr (reg2));
- break;
- case REG_PRIUNAT:
- add_unwind_entry (output_priunat_when_gr ());
- add_unwind_entry (output_priunat_gr (reg2));
- break;
- default:
- as_bad ("First operand not a valid register");
- }
- }
- else
- as_bad (" Second operand not a valid register");
+ as_bad (_("First operand to .save not a register"));
+ reg1 = REG_PR; /* Anything valid is good here. */
+ }
+ reg2 = e2.X_add_number - REG_GR;
+ if (e2.X_op != O_register || reg2 > 127)
+ {
+ as_bad (_("Second operand to .save not a valid register"));
+ reg2 = 0;
+ }
+ switch (reg1)
+ {
+ case REG_AR + AR_BSP:
+ add_unwind_entry (output_bsp_when (), sep);
+ add_unwind_entry (output_bsp_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_BSPSTORE:
+ add_unwind_entry (output_bspstore_when (), sep);
+ add_unwind_entry (output_bspstore_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_RNAT:
+ add_unwind_entry (output_rnat_when (), sep);
+ add_unwind_entry (output_rnat_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_UNAT:
+ add_unwind_entry (output_unat_when (), sep);
+ add_unwind_entry (output_unat_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_FPSR:
+ add_unwind_entry (output_fpsr_when (), sep);
+ add_unwind_entry (output_fpsr_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_PFS:
+ add_unwind_entry (output_pfs_when (), sep);
+ if (! (unwind.prologue_mask & 4))
+ add_unwind_entry (output_pfs_gr (reg2), NOT_A_CHAR);
+ else if (reg2 != unwind.prologue_gr
+ + (unsigned) popcount (unwind.prologue_mask & (-4 << 1)))
+ as_warn (_("Second operand of .save contradicts .prologue"));
+ break;
+ case REG_AR + AR_LC:
+ add_unwind_entry (output_lc_when (), sep);
+ add_unwind_entry (output_lc_gr (reg2), NOT_A_CHAR);
+ break;
+ case REG_BR:
+ add_unwind_entry (output_rp_when (), sep);
+ if (! (unwind.prologue_mask & 8))
+ add_unwind_entry (output_rp_gr (reg2), NOT_A_CHAR);
+ else if (reg2 != unwind.prologue_gr)
+ as_warn (_("Second operand of .save contradicts .prologue"));
+ break;
+ case REG_PR:
+ add_unwind_entry (output_preds_when (), sep);
+ if (! (unwind.prologue_mask & 1))
+ add_unwind_entry (output_preds_gr (reg2), NOT_A_CHAR);
+ else if (reg2 != unwind.prologue_gr
+ + (unsigned) popcount (unwind.prologue_mask & (-1 << 1)))
+ as_warn (_("Second operand of .save contradicts .prologue"));
+ break;
+ case REG_PRIUNAT:
+ add_unwind_entry (output_priunat_when_gr (), sep);
+ add_unwind_entry (output_priunat_gr (reg2), NOT_A_CHAR);
+ break;
+ default:
+ as_bad (_("First operand to .save not a valid register"));
+ add_unwind_entry (NULL, sep);
+ break;
}
- else
- as_bad ("First operand not a register");
}
static void
-dot_restore (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_restore (int dummy ATTRIBUTE_UNUSED)
{
- expressionS e1, e2;
+ expressionS e1;
unsigned long ecount; /* # of _additional_ regions to pop */
int sep;
if (!in_body ("restore"))
return;
- sep = parse_operand (&e1);
+ sep = parse_operand (&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)");
- return;
- }
+ as_bad (_("First operand to .restore must be stack pointer (sp)"));
if (sep == ',')
{
- parse_operand (&e2);
+ expressionS e2;
+
+ sep = parse_operand (&e2, ',');
if (e2.X_op != O_constant || e2.X_add_number < 0)
{
- as_bad ("Second operand to .restore must be a constant >= 0");
- return;
+ as_bad (_("Second operand to .restore must be a constant >= 0"));
+ e2.X_add_number = 0;
}
ecount = e2.X_add_number;
}
if (ecount >= unwind.prologue_count)
{
- as_bad ("Epilogue count of %lu exceeds number of nested prologues (%u)",
+ as_bad (_("Epilogue count of %lu exceeds number of nested prologues (%u)"),
ecount + 1, unwind.prologue_count);
- return;
+ ecount = 0;
}
- add_unwind_entry (output_epilogue (ecount));
+ add_unwind_entry (output_epilogue (ecount), sep);
if (ecount < unwind.prologue_count)
unwind.prologue_count -= ecount + 1;
}
static void
-dot_restorereg (dummy)
- int dummy ATTRIBUTE_UNUSED;
-{
- unsigned int ab, reg;
- expressionS e;
-
- if (!in_procedure ("restorereg"))
- return;
-
- parse_operand (&e);
-
- if (!convert_expr_to_ab_reg (&e, &ab, ®))
- {
- as_bad ("First operand to .restorereg must be a preserved register");
- return;
- }
- add_unwind_entry (output_spill_reg (ab, reg, 0, 0));
-}
-
-static void
-dot_restorereg_p (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_restorereg (int pred)
{
unsigned int qp, ab, reg;
- expressionS e1, e2;
+ expressionS e;
int sep;
+ const char * const po = pred ? "restorereg.p" : "restorereg";
- if (!in_procedure ("restorereg.p"))
+ if (!in_procedure (po))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- {
- as_bad ("No second operand to .restorereg.p");
- return;
- }
-
- parse_operand (&e2);
-
- qp = e1.X_add_number - REG_P;
- if (e1.X_op != O_register || qp > 63)
+ if (pred)
+ sep = parse_predicate_and_operand (&e, &qp, po);
+ else
{
- as_bad ("First operand to .restorereg.p must be a predicate");
- return;
+ sep = parse_operand (&e, ',');
+ qp = 0;
}
+ convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
- if (!convert_expr_to_ab_reg (&e2, &ab, ®))
- {
- as_bad ("Second operand to .restorereg.p must be a preserved register");
- return;
- }
- add_unwind_entry (output_spill_reg_p (ab, reg, 0, 0, qp));
+ add_unwind_entry (output_spill_reg (ab, reg, 0, 0, qp), sep);
}
static char *special_linkonce_name[] =
text_name = sec_text_name;
if (strncmp (text_name, "_info", 5) == 0)
{
- as_bad ("Illegal section name `%s' (causes unwind section name clash)",
+ as_bad (_("Illegal section name `%s' (causes unwind section name clash)"),
text_name);
ignore_rest_of_line ();
return;
if (group_name == NULL)
{
- as_bad ("Group section `%s' has no group signature",
+ as_bad (_("Group section `%s' has no group signature"),
sec_text_name);
ignore_rest_of_line ();
return;
/* Mark the end of the unwind info, so that we can compute the size of the
last unwind region. */
- add_unwind_entry (output_endp ());
+ add_unwind_entry (output_endp (), NOT_A_CHAR);
/* Force out pending instructions, to make sure all unwind records have
a valid slot_number field. */
}
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);
+ parse_operand (&e, 0);
reg = e.X_add_number - REG_BR;
- if (e.X_op == O_register && reg < 8)
- add_unwind_entry (output_rp_br (reg));
- else
- as_bad ("First operand not a valid branch register");
+ if (e.X_op != O_register || reg > 7)
+ {
+ as_bad (_("First operand to .altrp not a valid branch register"));
+ reg = 0;
+ }
+ add_unwind_entry (output_rp_br (reg), 0);
}
static void
-dot_savemem (psprel)
- int psprel;
+dot_savemem (int psprel)
{
expressionS e1, e2;
int sep;
int reg1, val;
+ const char * const po = psprel ? "savepsp" : "savesp";
- if (!in_prologue (psprel ? "savepsp" : "savesp"))
+ if (!in_prologue (po))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- as_bad ("No second operand to .save%ssp", psprel ? "p" : "");
- sep = parse_operand (&e2);
+ sep = parse_operand (&e1, ',');
+ if (sep == ',')
+ sep = parse_operand (&e2, ',');
+ else
+ e2.X_op = O_absent;
reg1 = e1.X_add_number;
val = e2.X_add_number;
/* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
- if (e1.X_op == O_register)
+ if (e1.X_op != O_register)
{
- if (e2.X_op == O_constant)
- {
- switch (reg1)
- {
- case REG_AR + AR_BSP:
- add_unwind_entry (output_bsp_when ());
- add_unwind_entry ((psprel
- ? output_bsp_psprel
- : output_bsp_sprel) (val));
- break;
- case REG_AR + AR_BSPSTORE:
- add_unwind_entry (output_bspstore_when ());
- add_unwind_entry ((psprel
- ? output_bspstore_psprel
- : output_bspstore_sprel) (val));
- break;
- case REG_AR + AR_RNAT:
- add_unwind_entry (output_rnat_when ());
- add_unwind_entry ((psprel
- ? output_rnat_psprel
- : output_rnat_sprel) (val));
- break;
- case REG_AR + AR_UNAT:
- add_unwind_entry (output_unat_when ());
- add_unwind_entry ((psprel
- ? output_unat_psprel
- : output_unat_sprel) (val));
- break;
- case REG_AR + AR_FPSR:
- add_unwind_entry (output_fpsr_when ());
- add_unwind_entry ((psprel
- ? output_fpsr_psprel
- : output_fpsr_sprel) (val));
- break;
- case REG_AR + AR_PFS:
- add_unwind_entry (output_pfs_when ());
- add_unwind_entry ((psprel
- ? output_pfs_psprel
- : output_pfs_sprel) (val));
- break;
- case REG_AR + AR_LC:
- add_unwind_entry (output_lc_when ());
- add_unwind_entry ((psprel
- ? output_lc_psprel
- : output_lc_sprel) (val));
- break;
- case REG_BR:
- add_unwind_entry (output_rp_when ());
- add_unwind_entry ((psprel
- ? output_rp_psprel
- : output_rp_sprel) (val));
- break;
- case REG_PR:
- add_unwind_entry (output_preds_when ());
- add_unwind_entry ((psprel
- ? output_preds_psprel
- : output_preds_sprel) (val));
- break;
- case REG_PRIUNAT:
- add_unwind_entry (output_priunat_when_mem ());
- add_unwind_entry ((psprel
- ? output_priunat_psprel
- : output_priunat_sprel) (val));
- break;
- default:
- as_bad ("First operand not a valid register");
- }
- }
- else
- as_bad (" Second operand not a valid constant");
+ as_bad (_("First operand to .%s not a register"), po);
+ reg1 = REG_PR; /* Anything valid is good here. */
+ }
+ if (e2.X_op != O_constant)
+ {
+ as_bad (_("Second operand to .%s not a constant"), po);
+ val = 0;
+ }
+
+ switch (reg1)
+ {
+ case REG_AR + AR_BSP:
+ add_unwind_entry (output_bsp_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_bsp_psprel
+ : output_bsp_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_BSPSTORE:
+ add_unwind_entry (output_bspstore_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_bspstore_psprel
+ : output_bspstore_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_RNAT:
+ add_unwind_entry (output_rnat_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_rnat_psprel
+ : output_rnat_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_UNAT:
+ add_unwind_entry (output_unat_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_unat_psprel
+ : output_unat_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_FPSR:
+ add_unwind_entry (output_fpsr_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_fpsr_psprel
+ : output_fpsr_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_PFS:
+ add_unwind_entry (output_pfs_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_pfs_psprel
+ : output_pfs_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_AR + AR_LC:
+ add_unwind_entry (output_lc_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_lc_psprel
+ : output_lc_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_BR:
+ add_unwind_entry (output_rp_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_rp_psprel
+ : output_rp_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_PR:
+ add_unwind_entry (output_preds_when (), sep);
+ add_unwind_entry ((psprel
+ ? output_preds_psprel
+ : output_preds_sprel) (val), NOT_A_CHAR);
+ break;
+ case REG_PRIUNAT:
+ add_unwind_entry (output_priunat_when_mem (), sep);
+ add_unwind_entry ((psprel
+ ? output_priunat_psprel
+ : output_priunat_sprel) (val), NOT_A_CHAR);
+ break;
+ default:
+ as_bad (_("First operand to .%s not a valid register"), po);
+ add_unwind_entry (NULL, sep);
+ break;
}
- else
- as_bad ("First operand not a register");
}
static void
-dot_saveg (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_saveg (int dummy ATTRIBUTE_UNUSED)
{
- expressionS e1, e2;
+ expressionS e;
+ unsigned grmask;
int sep;
if (!in_prologue ("save.g"))
return;
- sep = parse_operand (&e1);
- if (sep == ',')
- parse_operand (&e2);
+ sep = parse_operand (&e, ',');
- if (e1.X_op != O_constant)
- as_bad ("First operand to .save.g must be a constant.");
- else
+ grmask = e.X_add_number;
+ if (e.X_op != O_constant
+ || e.X_add_number <= 0
+ || e.X_add_number > 0xf)
{
- int grmask = e1.X_add_number;
- if (sep != ',')
- add_unwind_entry (output_gr_mem (grmask));
- else
+ as_bad (_("First operand to .save.g must be a positive 4-bit constant"));
+ grmask = 0;
+ }
+
+ if (sep == ',')
+ {
+ unsigned reg;
+ int n = popcount (grmask);
+
+ parse_operand (&e, 0);
+ reg = e.X_add_number - REG_GR;
+ if (e.X_op != O_register || reg > 127)
{
- int reg = e2.X_add_number - REG_GR;
- if (e2.X_op == O_register && reg >= 0 && reg < 128)
- add_unwind_entry (output_gr_gr (grmask, reg));
- else
- as_bad ("Second operand is an invalid register.");
+ as_bad (_("Second operand to .save.g must be a general register"));
+ reg = 0;
}
+ else if (reg > 128U - n)
+ {
+ as_bad (_("Second operand to .save.g must be the first of %d general registers"), n);
+ reg = 0;
+ }
+ add_unwind_entry (output_gr_gr (grmask, reg), 0);
}
+ else
+ add_unwind_entry (output_gr_mem (grmask), 0);
}
static void
-dot_savef (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_savef (int dummy ATTRIBUTE_UNUSED)
{
- expressionS e1;
- int sep;
+ expressionS e;
if (!in_prologue ("save.f"))
return;
- sep = parse_operand (&e1);
+ parse_operand (&e, 0);
- if (e1.X_op != O_constant)
- as_bad ("Operand to .save.f must be a constant.");
- else
- add_unwind_entry (output_fr_mem (e1.X_add_number));
+ if (e.X_op != O_constant
+ || e.X_add_number <= 0
+ || e.X_add_number > 0xfffff)
+ {
+ as_bad (_("Operand to .save.f must be a positive 20-bit constant"));
+ e.X_add_number = 0;
+ }
+ add_unwind_entry (output_fr_mem (e.X_add_number), 0);
}
static void
-dot_saveb (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_saveb (int dummy ATTRIBUTE_UNUSED)
{
- expressionS e1, e2;
- unsigned int reg;
- unsigned char sep;
- int brmask;
+ expressionS e;
+ unsigned brmask;
+ int sep;
if (!in_prologue ("save.b"))
return;
- sep = parse_operand (&e1);
- if (e1.X_op != O_constant)
+ sep = parse_operand (&e, ',');
+
+ brmask = e.X_add_number;
+ if (e.X_op != O_constant
+ || e.X_add_number <= 0
+ || e.X_add_number > 0x1f)
{
- as_bad ("First operand to .save.b must be a constant.");
- return;
+ as_bad (_("First operand to .save.b must be a positive 5-bit constant"));
+ brmask = 0;
}
- brmask = e1.X_add_number;
if (sep == ',')
{
- sep = parse_operand (&e2);
- reg = e2.X_add_number - REG_GR;
- if (e2.X_op != O_register || reg > 127)
+ unsigned reg;
+ int n = popcount (brmask);
+
+ parse_operand (&e, 0);
+ reg = e.X_add_number - REG_GR;
+ if (e.X_op != O_register || reg > 127)
{
- as_bad ("Second operand to .save.b must be a general register.");
- return;
+ as_bad (_("Second operand to .save.b must be a general register"));
+ reg = 0;
+ }
+ else if (reg > 128U - n)
+ {
+ as_bad (_("Second operand to .save.b must be the first of %d general registers"), n);
+ reg = 0;
}
- add_unwind_entry (output_br_gr (brmask, e2.X_add_number));
+ add_unwind_entry (output_br_gr (brmask, reg), 0);
}
else
- add_unwind_entry (output_br_mem (brmask));
-
- if (!is_end_of_line[sep] && !is_it_end_of_statement ())
- demand_empty_rest_of_line ();
+ add_unwind_entry (output_br_mem (brmask), 0);
}
static void
-dot_savegf (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_savegf (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
- int sep;
if (!in_prologue ("save.gf"))
return;
- sep = parse_operand (&e1);
- if (sep == ',')
- parse_operand (&e2);
-
- if (e1.X_op != O_constant || sep != ',' || e2.X_op != O_constant)
- as_bad ("Both operands of .save.gf must be constants.");
+ if (parse_operand (&e1, ',') == ',')
+ parse_operand (&e2, 0);
else
- {
- int grmask = e1.X_add_number;
- int frmask = e2.X_add_number;
- add_unwind_entry (output_frgr_mem (grmask, frmask));
- }
-}
-
-static void
-dot_spill (dummy)
- int dummy ATTRIBUTE_UNUSED;
-{
- expressionS e;
- unsigned char sep;
-
- if (!in_prologue ("spill"))
- return;
-
- sep = parse_operand (&e);
- if (!is_end_of_line[sep] && !is_it_end_of_statement ())
- demand_empty_rest_of_line ();
+ e2.X_op = O_absent;
- if (e.X_op != O_constant)
- as_bad ("Operand to .spill must be a constant");
- else
- add_unwind_entry (output_spill_base (e.X_add_number));
-}
-
-static void
-dot_spillreg (dummy)
- int dummy ATTRIBUTE_UNUSED;
-{
- int sep;
- unsigned int ab, xy, reg, treg;
- expressionS e1, e2;
-
- if (!in_procedure ("spillreg"))
- return;
-
- sep = parse_operand (&e1);
- if (sep != ',')
+ if (e1.X_op != O_constant
+ || e1.X_add_number < 0
+ || e1.X_add_number > 0xf)
{
- as_bad ("No second operand to .spillreg");
- return;
+ as_bad (_("First operand to .save.gf must be a non-negative 4-bit constant"));
+ e1.X_op = O_absent;
+ e1.X_add_number = 0;
}
-
- parse_operand (&e2);
-
- if (!convert_expr_to_ab_reg (&e1, &ab, ®))
+ if (e2.X_op != O_constant
+ || e2.X_add_number < 0
+ || e2.X_add_number > 0xfffff)
{
- as_bad ("First operand to .spillreg must be a preserved register");
- return;
+ as_bad (_("Second operand to .save.gf must be a non-negative 20-bit constant"));
+ e2.X_op = O_absent;
+ e2.X_add_number = 0;
}
+ if (e1.X_op == O_constant
+ && e2.X_op == O_constant
+ && e1.X_add_number == 0
+ && e2.X_add_number == 0)
+ as_bad (_("Operands to .save.gf may not be both zero"));
- if (!convert_expr_to_xy_reg (&e2, &xy, &treg))
- {
- as_bad ("Second operand to .spillreg must be a register");
- return;
- }
-
- add_unwind_entry (output_spill_reg (ab, reg, treg, xy));
+ add_unwind_entry (output_frgr_mem (e1.X_add_number, e2.X_add_number), 0);
}
static void
-dot_spillmem (psprel)
- int psprel;
+dot_spill (int dummy ATTRIBUTE_UNUSED)
{
- expressionS e1, e2;
- int sep;
- unsigned int ab, reg;
+ expressionS e;
- if (!in_procedure ("spillmem"))
+ if (!in_prologue ("spill"))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- {
- as_bad ("Second operand missing");
- return;
- }
-
- parse_operand (&e2);
+ parse_operand (&e, 0);
- if (!convert_expr_to_ab_reg (&e1, &ab, ®))
- {
- as_bad ("First operand to .spill%s must be a preserved register",
- psprel ? "psp" : "sp");
- return;
- }
-
- if (e2.X_op != O_constant)
+ if (e.X_op != O_constant)
{
- as_bad ("Second operand to .spill%s must be a constant",
- psprel ? "psp" : "sp");
- return;
+ as_bad (_("Operand to .spill must be a constant"));
+ e.X_add_number = 0;
}
-
- if (psprel)
- add_unwind_entry (output_spill_psprel (ab, reg, e2.X_add_number));
- else
- add_unwind_entry (output_spill_sprel (ab, reg, e2.X_add_number));
+ add_unwind_entry (output_spill_base (e.X_add_number), 0);
}
static void
-dot_spillreg_p (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_spillreg (int pred)
{
int sep;
- unsigned int ab, xy, reg, treg;
- expressionS e1, e2, e3;
- unsigned int qp;
+ unsigned int qp, ab, xy, reg, treg;
+ expressionS e;
+ const char * const po = pred ? "spillreg.p" : "spillreg";
- if (!in_procedure ("spillreg.p"))
+ if (!in_procedure (po))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- {
- as_bad ("No second and third operand to .spillreg.p");
- return;
- }
-
- sep = parse_operand (&e2);
- if (sep != ',')
- {
- as_bad ("No third operand to .spillreg.p");
- return;
- }
-
- parse_operand (&e3);
-
- qp = e1.X_add_number - REG_P;
-
- if (e1.X_op != O_register || qp > 63)
- {
- as_bad ("First operand to .spillreg.p must be a predicate");
- return;
- }
-
- if (!convert_expr_to_ab_reg (&e2, &ab, ®))
+ if (pred)
+ sep = parse_predicate_and_operand (&e, &qp, po);
+ else
{
- as_bad ("Second operand to .spillreg.p must be a preserved register");
- return;
+ sep = parse_operand (&e, ',');
+ qp = 0;
}
+ convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
- if (!convert_expr_to_xy_reg (&e3, &xy, &treg))
- {
- as_bad ("Third operand to .spillreg.p must be a register");
- return;
- }
+ if (sep == ',')
+ sep = parse_operand (&e, ',');
+ else
+ e.X_op = O_absent;
+ convert_expr_to_xy_reg (&e, &xy, &treg, po, 2 + pred);
- add_unwind_entry (output_spill_reg_p (ab, reg, treg, xy, qp));
+ add_unwind_entry (output_spill_reg (ab, reg, treg, xy, qp), sep);
}
static void
-dot_spillmem_p (psprel)
- int psprel;
+dot_spillmem (int psprel)
{
- expressionS e1, e2, e3;
- int sep;
- unsigned int ab, reg;
- unsigned int qp;
-
- if (!in_procedure ("spillmem.p"))
- return;
-
- sep = parse_operand (&e1);
- if (sep != ',')
- {
- as_bad ("Second operand missing");
- return;
- }
+ expressionS e;
+ int pred = (psprel < 0), sep;
+ unsigned int qp, ab, reg;
+ const char * po;
- parse_operand (&e2);
- if (sep != ',')
+ if (pred)
{
- as_bad ("Second operand missing");
- return;
+ psprel = ~psprel;
+ po = psprel ? "spillpsp.p" : "spillsp.p";
}
+ else
+ po = psprel ? "spillpsp" : "spillsp";
- parse_operand (&e3);
-
- qp = e1.X_add_number - REG_P;
- if (e1.X_op != O_register || qp > 63)
- {
- as_bad ("First operand to .spill%s_p must be a predicate",
- psprel ? "psp" : "sp");
- return;
- }
+ if (!in_procedure (po))
+ return;
- if (!convert_expr_to_ab_reg (&e2, &ab, ®))
+ if (pred)
+ sep = parse_predicate_and_operand (&e, &qp, po);
+ else
{
- as_bad ("Second operand to .spill%s_p must be a preserved register",
- psprel ? "psp" : "sp");
- return;
+ sep = parse_operand (&e, ',');
+ qp = 0;
}
+ convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred);
- if (e3.X_op != O_constant)
+ if (sep == ',')
+ sep = parse_operand (&e, ',');
+ else
+ e.X_op = O_absent;
+ if (e.X_op != O_constant)
{
- as_bad ("Third operand to .spill%s_p must be a constant",
- psprel ? "psp" : "sp");
- return;
+ as_bad (_("Operand %d to .%s must be a constant"), 2 + pred, po);
+ e.X_add_number = 0;
}
if (psprel)
- add_unwind_entry (output_spill_psprel_p (ab, reg, e3.X_add_number, qp));
+ add_unwind_entry (output_spill_psprel (ab, reg, e.X_add_number, qp), sep);
else
- add_unwind_entry (output_spill_sprel_p (ab, reg, e3.X_add_number, qp));
+ add_unwind_entry (output_spill_sprel (ab, reg, e.X_add_number, qp), sep);
}
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;
if (lpc != NULL)
return lpc->prologue_count;
- as_bad ("Missing .label_state %ld", lbl);
+ as_bad (_("Missing .label_state %ld"), lbl);
return 1;
}
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);
- if (e.X_op != O_constant)
+ parse_operand (&e, 0);
+ if (e.X_op == O_constant)
+ save_prologue_count (e.X_add_number, unwind.prologue_count);
+ else
{
- as_bad ("Operand to .label_state must be a constant");
- return;
+ as_bad (_("Operand to .label_state must be a constant"));
+ e.X_add_number = 0;
}
- add_unwind_entry (output_label_state (e.X_add_number));
- save_prologue_count (e.X_add_number, unwind.prologue_count);
+ add_unwind_entry (output_label_state (e.X_add_number), 0);
}
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);
- if (e.X_op != O_constant)
+ parse_operand (&e, 0);
+ if (e.X_op == O_constant)
+ unwind.prologue_count = get_saved_prologue_count (e.X_add_number);
+ else
{
- as_bad ("Operand to .copy_state must be a constant");
- return;
+ as_bad (_("Operand to .copy_state must be a constant"));
+ e.X_add_number = 0;
}
- add_unwind_entry (output_copy_state (e.X_add_number));
- unwind.prologue_count = get_saved_prologue_count (e.X_add_number);
+ add_unwind_entry (output_copy_state (e.X_add_number), 0);
}
static void
-dot_unwabi (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_unwabi (int dummy ATTRIBUTE_UNUSED)
{
expressionS e1, e2;
unsigned char sep;
- if (!in_procedure ("unwabi"))
+ if (!in_prologue ("unwabi"))
return;
- sep = parse_operand (&e1);
- if (sep != ',')
- {
- as_bad ("Second operand to .unwabi missing");
- return;
- }
- sep = parse_operand (&e2);
- if (!is_end_of_line[sep] && !is_it_end_of_statement ())
- demand_empty_rest_of_line ();
+ sep = parse_operand (&e1, ',');
+ if (sep == ',')
+ parse_operand (&e2, 0);
+ else
+ e2.X_op = O_absent;
if (e1.X_op != O_constant)
{
- as_bad ("First operand to .unwabi must be a constant");
- return;
+ as_bad (_("First operand to .unwabi must be a constant"));
+ e1.X_add_number = 0;
}
if (e2.X_op != O_constant)
{
- as_bad ("Second operand to .unwabi must be a constant");
- return;
+ as_bad (_("Second operand to .unwabi must be a constant"));
+ e2.X_add_number = 0;
}
- add_unwind_entry (output_unwabi (e1.X_add_number, e2.X_add_number));
+ add_unwind_entry (output_unwabi (e1.X_add_number, e2.X_add_number), 0);
}
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;
+ proc_pending *pending, *last_pending;
+
+ if (unwind.proc_pending.sym)
+ {
+ (md.unwind_check == unwind_check_warning
+ ? as_warn
+ : as_bad) (_("Missing .endp after previous .proc"));
+ while (unwind.proc_pending.next)
+ {
+ pending = unwind.proc_pending.next;
+ unwind.proc_pending.next = pending->next;
+ free (pending);
+ }
+ }
+ last_pending = NULL;
- unwind.proc_start = 0;
/* Parse names of main and alternate entry points and mark them as
function symbols: */
while (1)
c = get_symbol_end ();
p = input_line_pointer;
if (!*name)
- as_bad ("Empty argument of .proc");
+ as_bad (_("Empty argument of .proc"));
else
{
sym = symbol_find_or_make (name);
if (S_IS_DEFINED (sym))
- as_bad ("`%s' was already defined", name);
- else if (unwind.proc_start == 0)
+ as_bad (_("`%s' was already defined"), name);
+ else if (!last_pending)
+ {
+ unwind.proc_pending.sym = sym;
+ last_pending = &unwind.proc_pending;
+ }
+ else
{
- unwind.proc_start = sym;
+ pending = xmalloc (sizeof (*pending));
+ pending->sym = sym;
+ last_pending = last_pending->next = pending;
}
symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
}
break;
++input_line_pointer;
}
- if (unwind.proc_start == 0)
- unwind.proc_start = expr_build_dot ();
+ if (!last_pending)
+ {
+ unwind.proc_pending.sym = expr_build_dot ();
+ last_pending = &unwind.proc_pending;
+ }
+ last_pending->next = NULL;
demand_empty_rest_of_line ();
ia64_do_align (16);
}
static void
-dot_body (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_body (int dummy ATTRIBUTE_UNUSED)
{
if (!in_procedure ("body"))
return;
if (!unwind.prologue && !unwind.body && unwind.insn)
- as_warn ("Initial .body should precede any instructions");
+ as_warn (_("Initial .body should precede any instructions"));
+ check_pending_save ();
unwind.prologue = 0;
unwind.prologue_mask = 0;
unwind.body = 1;
- add_unwind_entry (output_body ());
- demand_empty_rest_of_line ();
+ add_unwind_entry (output_body (), 0);
}
static void
-dot_prologue (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_prologue (int dummy ATTRIBUTE_UNUSED)
{
- unsigned char sep;
- int mask = 0, grsave = 0;
+ unsigned mask = 0, grsave = 0;
if (!in_procedure ("prologue"))
return;
if (unwind.prologue)
{
- as_bad (".prologue within prologue");
+ as_bad (_(".prologue within prologue"));
ignore_rest_of_line ();
return;
}
if (!unwind.body && unwind.insn)
- as_warn ("Initial .prologue should precede any instructions");
+ as_warn (_("Initial .prologue should precede any instructions"));
if (!is_it_end_of_statement ())
{
- expressionS e1, e2;
- sep = parse_operand (&e1);
- if (sep != ',')
- as_bad ("No second operand to .prologue");
- sep = parse_operand (&e2);
- if (!is_end_of_line[sep] && !is_it_end_of_statement ())
- demand_empty_rest_of_line ();
-
- if (e1.X_op == O_constant)
- {
- mask = e1.X_add_number;
+ expressionS e;
+ int n, sep = parse_operand (&e, ',');
- if (e2.X_op == O_constant)
- grsave = e2.X_add_number;
- else if (e2.X_op == O_register
- && (grsave = e2.X_add_number - REG_GR) < 128)
- ;
- else
- as_bad ("Second operand not a constant or general register");
+ if (e.X_op != O_constant
+ || e.X_add_number < 0
+ || e.X_add_number > 0xf)
+ as_bad (_("First operand to .prologue must be a positive 4-bit constant"));
+ else if (e.X_add_number == 0)
+ as_warn (_("Pointless use of zero first operand to .prologue"));
+ else
+ mask = e.X_add_number;
+ n = popcount (mask);
- add_unwind_entry (output_prologue_gr (mask, grsave));
- }
+ if (sep == ',')
+ parse_operand (&e, 0);
else
- as_bad ("First operand not a constant");
+ e.X_op = O_absent;
+ if (e.X_op == O_constant
+ && e.X_add_number >= 0
+ && e.X_add_number < 128)
+ {
+ if (md.unwind_check == unwind_check_error)
+ as_warn (_("Using a constant as second operand to .prologue is deprecated"));
+ grsave = e.X_add_number;
+ }
+ else if (e.X_op != O_register
+ || (grsave = e.X_add_number - REG_GR) > 127)
+ {
+ as_bad (_("Second operand to .prologue must be a general register"));
+ grsave = 0;
+ }
+ else if (grsave > 128U - n)
+ {
+ as_bad (_("Second operand to .prologue must be the first of %d general registers"), n);
+ grsave = 0;
+ }
+
}
+
+ if (mask)
+ add_unwind_entry (output_prologue_gr (mask, grsave), 0);
else
- add_unwind_entry (output_prologue ());
+ add_unwind_entry (output_prologue (), 0);
unwind.prologue = 1;
unwind.prologue_mask = mask;
+ unwind.prologue_gr = grsave;
unwind.body = 0;
++unwind.prologue_count;
}
static void
-dot_endp (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_endp (int dummy ATTRIBUTE_UNUSED)
{
expressionS e;
- char *ptr;
int bytes_per_address;
long where;
segT saved_seg;
subsegT saved_subseg;
- char *name, *default_name, *p, c;
- symbolS *sym;
+ proc_pending *pending;
int unwind_check = md.unwind_check;
md.unwind_check = unwind_check_error;
/* Need space for 3 pointers for procedure start, procedure end,
and unwind info. */
- ptr = frag_more (3 * md.pointer_size);
+ memset (frag_more (3 * md.pointer_size), 0, 3 * md.pointer_size);
where = frag_now_fix () - (3 * md.pointer_size);
bytes_per_address = bfd_arch_bits_per_address (stdoutput) / 8;
e.X_op = O_pseudo_fixup;
e.X_op_symbol = pseudo_func[FUNC_SEG_RELATIVE].u.sym;
e.X_add_number = 0;
- if (!S_IS_LOCAL (unwind.proc_start)
- && S_IS_DEFINED (unwind.proc_start))
- e.X_add_symbol = symbol_temp_new (S_GET_SEGMENT (unwind.proc_start),
- S_GET_VALUE (unwind.proc_start),
- symbol_get_frag (unwind.proc_start));
+ if (!S_IS_LOCAL (unwind.proc_pending.sym)
+ && S_IS_DEFINED (unwind.proc_pending.sym))
+ e.X_add_symbol = symbol_temp_new (S_GET_SEGMENT (unwind.proc_pending.sym),
+ S_GET_VALUE (unwind.proc_pending.sym),
+ symbol_get_frag (unwind.proc_pending.sym));
else
- e.X_add_symbol = unwind.proc_start;
+ e.X_add_symbol = unwind.proc_pending.sym;
ia64_cons_fix_new (frag_now, where, bytes_per_address, &e);
e.X_op = O_pseudo_fixup;
ia64_cons_fix_new (frag_now, where + (bytes_per_address * 2),
bytes_per_address, &e);
}
- else
- md_number_to_chars (ptr + (bytes_per_address * 2), 0,
- bytes_per_address);
-
}
subseg_set (saved_seg, saved_subseg);
- if (unwind.proc_start)
- default_name = (char *) S_GET_NAME (unwind.proc_start);
- else
- default_name = NULL;
-
- /* Parse names of main and alternate entry points and set symbol sizes. */
- while (1)
+ /* Set symbol sizes. */
+ pending = &unwind.proc_pending;
+ if (S_GET_NAME (pending->sym))
{
- SKIP_WHITESPACE ();
- name = input_line_pointer;
- c = get_symbol_end ();
- p = input_line_pointer;
- if (!*name)
- {
- if (md.unwind_check == unwind_check_warning)
- {
- if (default_name)
- {
- as_warn ("Empty argument of .endp. Use the default name `%s'",
- default_name);
- name = default_name;
- }
- else
- as_warn ("Empty argument of .endp");
- }
- else
- as_bad ("Empty argument of .endp");
- }
- if (*name)
+ do
{
- sym = symbol_find (name);
- if (!sym
- && md.unwind_check == unwind_check_warning
- && default_name
- && default_name != name)
- {
- /* We have a bad name. Try the default one if needed. */
- as_warn ("`%s' was not defined within procedure. Use the default name `%s'",
- name, default_name);
- name = default_name;
- sym = symbol_find (name);
- }
- if (!sym || !S_IS_DEFINED (sym))
- as_bad ("`%s' was not defined within procedure", name);
- else if (unwind.proc_start
- && (symbol_get_bfdsym (sym)->flags & BSF_FUNCTION)
- && S_GET_SIZE (sym) == 0 && symbol_get_obj (sym)->size == NULL)
+ symbolS *sym = pending->sym;
+
+ if (!S_IS_DEFINED (sym))
+ as_bad (_("`%s' was not defined within procedure"), S_GET_NAME (sym));
+ else if (S_GET_SIZE (sym) == 0
+ && symbol_get_obj (sym)->size == NULL)
{
- fragS *fr = symbol_get_frag (unwind.proc_start);
fragS *frag = symbol_get_frag (sym);
- /* Check whether the function label is at or beyond last
- .proc directive. */
- while (fr && fr != frag)
- fr = fr->fr_next;
- if (fr)
+ if (frag)
{
if (frag == frag_now && SEG_NORMAL (now_seg))
S_SET_SIZE (sym, frag_now_fix () - S_GET_VALUE (sym));
}
}
}
+ } while ((pending = pending->next) != NULL);
+ }
+
+ /* Parse names of main and alternate entry points. */
+ while (1)
+ {
+ char *name, *p, c;
+
+ SKIP_WHITESPACE ();
+ name = input_line_pointer;
+ c = get_symbol_end ();
+ p = input_line_pointer;
+ if (!*name)
+ (md.unwind_check == unwind_check_warning
+ ? as_warn
+ : as_bad) (_("Empty argument of .endp"));
+ else
+ {
+ symbolS *sym = symbol_find (name);
+
+ for (pending = &unwind.proc_pending; pending; pending = pending->next)
+ {
+ if (sym == pending->sym)
+ {
+ pending->sym = NULL;
+ break;
+ }
+ }
+ if (!sym || !pending)
+ as_warn (_("`%s' was not specified with previous .proc"), name);
}
*p = c;
SKIP_WHITESPACE ();
++input_line_pointer;
}
demand_empty_rest_of_line ();
- unwind.proc_start = unwind.info = 0;
+
+ /* Deliberately only checking for the main entry point here; the
+ language spec even says all arguments to .endp are ignored. */
+ if (unwind.proc_pending.sym
+ && S_GET_NAME (unwind.proc_pending.sym)
+ && strcmp (S_GET_NAME (unwind.proc_pending.sym), FAKE_LABEL_NAME))
+ as_warn (_("`%s' should be an operand to this .endp"),
+ S_GET_NAME (unwind.proc_pending.sym));
+ while (unwind.proc_pending.next)
+ {
+ pending = unwind.proc_pending.next;
+ unwind.proc_pending.next = pending->next;
+ free (pending);
+ }
+ unwind.proc_pending.sym = unwind.info = NULL;
}
static void
-dot_template (template)
- int template;
+dot_template (int template)
{
CURR_SLOT.user_template = template;
}
static void
-dot_regstk (dummy)
- int dummy ATTRIBUTE_UNUSED;
+dot_regstk (int dummy ATTRIBUTE_UNUSED)
{
int ins, locs, outs, rots;
return;
err:
- as_bad ("Comma expected");
+ as_bad (_("Comma expected"));
ignore_rest_of_line ();
}
static void
-dot_rot (type)
- int type;
+dot_rot (int type)
{
- unsigned num_regs, num_alloced = 0;
+ offsetT num_regs;
+ valueT num_alloced = 0;
struct dynreg **drpp, *dr;
int ch, base_reg = 0;
char *name, *start;
/* 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;
}
SKIP_WHITESPACE ();
if (*input_line_pointer != '[')
{
- as_bad ("Expected '['");
+ as_bad (_("Expected '['"));
goto err;
}
++input_line_pointer; /* skip '[' */
if (*input_line_pointer++ != ']')
{
- as_bad ("Expected ']'");
+ as_bad (_("Expected ']'"));
+ goto err;
+ }
+ if (num_regs <= 0)
+ {
+ as_bad (_("Number of elements must be positive"));
goto err;
}
SKIP_WHITESPACE ();
case DYNREG_GR:
if (num_alloced > md.rot.num_regs)
{
- as_bad ("Used more than the declared %d rotating registers",
+ as_bad (_("Used more than the declared %d rotating registers"),
md.rot.num_regs);
goto err;
}
case DYNREG_FR:
if (num_alloced > 96)
{
- as_bad ("Used more than the available 96 rotating registers");
+ as_bad (_("Used more than the available 96 rotating registers"));
goto err;
}
break;
case DYNREG_PR:
if (num_alloced > 48)
{
- as_bad ("Used more than the available 48 rotating registers");
+ as_bad (_("Used more than the available 48 rotating registers"));
goto err;
}
break;
if (hash_insert (md.dynreg_hash, name, dr))
{
- as_bad ("Attempt to redefine register set `%s'", name);
+ as_bad (_("Attempt to redefine register set `%s'"), name);
obstack_free (¬es, name);
goto err;
}
}
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;
else if (strcmp (option, "abi64") == 0)
md.flags |= EF_IA_64_ABI64;
else
- as_bad ("Unknown psr option `%s'", option);
+ as_bad (_("Unknown psr option `%s'"), option);
*input_line_pointer = ch;
SKIP_WHITESPACE ();
}
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 (*cons) (int), int ua)
{
char *start, *end;
int saved_auto_align;
if (input_line_pointer == start)
{
- as_bad ("Missing section name");
+ as_bad (_("Missing section name"));
ignore_rest_of_line ();
return;
}
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
- as_bad ("Comma expected after section name");
+ as_bad (_("Comma expected after section name"));
ignore_rest_of_line ();
return;
}
section_count = bfd_count_sections(stdoutput);
obj_elf_section (0);
if (section_count != bfd_count_sections(stdoutput))
- as_warn ("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated.");
+ as_warn (_("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated."));
input_line_pointer = end;
saved_auto_align = md.auto_align;
if (ua)
}
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_xstringer (zero)
- int zero;
+dot_xstringer (int zero)
{
cross_section (zero, stringer, 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;
- expression (®);
+ expression_and_evaluate (®);
if (reg.X_op != O_register)
{
as_bad (_("Register name expected"));
.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;
SKIP_WHITESPACE ();
}
- SKIP_WHITESPACE ();
while (1)
{
valueT bits = 1;
- int regno;
+ int sep, regno;
expressionS pr, *pr1, *pr2;
- expression (&pr);
+ sep = parse_operand (&pr, ',');
if (pr.X_op == O_register
&& pr.X_add_number >= REG_P
&& pr.X_add_number <= REG_P + 63)
if (mask & bits)
as_warn (_("Duplicate predicate register ignored"));
mask |= bits;
- if (*input_line_pointer != ',')
+ if (sep != ',')
break;
- ++input_line_pointer;
- SKIP_WHITESPACE ();
}
switch (type)
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 ();
{ "fframe", dot_fframe, 0 },
{ "vframe", dot_vframe, 0 },
{ "vframesp", dot_vframesp, 0 },
- { "vframepsp", dot_vframepsp, 0 },
+ { "vframepsp", dot_vframesp, 1 },
{ "save", dot_save, 0 },
{ "restore", dot_restore, 0 },
{ "restorereg", dot_restorereg, 0 },
- { "restorereg.p", dot_restorereg_p, 0 },
+ { "restorereg.p", dot_restorereg, 1 },
{ "handlerdata", dot_handlerdata, 0 },
{ "unwentry", dot_unwentry, 0 },
{ "altrp", dot_altrp, 0 },
{ "spillreg", dot_spillreg, 0 },
{ "spillsp", dot_spillmem, 0 },
{ "spillpsp", dot_spillmem, 1 },
- { "spillreg.p", dot_spillreg_p, 0 },
- { "spillsp.p", dot_spillmem_p, 0 },
- { "spillpsp.p", dot_spillmem_p, 1 },
+ { "spillreg.p", dot_spillreg, 1 },
+ { "spillsp.p", dot_spillmem, ~0 },
+ { "spillpsp.p", dot_spillmem, ~1 },
{ "label_state", dot_label_state, 0 },
{ "copy_state", dot_copy_state, 0 },
{ "unwabi", dot_unwabi, 0 },
{ "xreal8", dot_xfloat_cons, 'd' },
{ "xreal10", dot_xfloat_cons, 'x' },
{ "xreal16", dot_xfloat_cons, 'X' },
- { "xstring", dot_xstringer, 0 },
- { "xstringz", dot_xstringer, 1 },
+ { "xstring", dot_xstringer, 8 + 0 },
+ { "xstringz", dot_xstringer, 8 + 1 },
/* unaligned versions: */
{ "xdata2.ua", dot_xdata_ua, 2 },
{ "real8", stmt_float_cons, 'd' },
{ "real10", stmt_float_cons, 'x' },
{ "real16", stmt_float_cons, 'X' },
- { "string", stringer, 0 },
- { "stringz", stringer, 1 },
+ { "string", stringer, 8 + 0 },
+ { "stringz", stringer, 8 + 1 },
/* unaligned versions: */
{ "data2.ua", stmt_cons_ua, 2 },
the symbol table. */
static symbolS *
-declare_register (name, regnum)
- const char *name;
- int regnum;
+declare_register (const char *name, unsigned int regnum)
{
const char *err;
symbolS *sym;
- sym = symbol_new (name, reg_section, regnum, &zero_address_frag);
+ 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;
- int num_regs;
- int base_regnum;
+declare_register_set (const char *prefix,
+ unsigned int num_regs,
+ unsigned int base_regnum)
{
char name[8];
- int i;
+ unsigned int i;
for (i = 0; i < num_regs; ++i)
{
- sprintf (name, "%s%u", prefix, i);
+ snprintf (name, sizeof (name), "%s%u", prefix, i);
declare_register (name, base_regnum + 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 index, expressionS *e)
{
enum ia64_opnd opnd = idesc->operands[index];
int bits, relocatable = 0;
return OPERAND_MATCH;
break;
+ case IA64_OPND_IMMU5b:
+ if (e->X_op == O_constant)
+ {
+ val = e->X_add_number;
+ if (val >= 32 && val <= 63)
+ return OPERAND_MATCH;
+ else
+ return OPERAND_OUT_OF_RANGE;
+ }
+ break;
+
case IA64_OPND_CCNT5:
case IA64_OPND_CNT5:
case IA64_OPND_CNT6:
case O_symbol:
fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups;
/* There are no external relocs for TAG13/TAG13b fields, so we
- create a dummy reloc. This will not live past md_apply_fix3. */
+ 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];
}
static int
-parse_operand (e)
- expressionS *e;
+parse_operand (expressionS *e, int more)
{
int sep = '\0';
memset (e, 0, sizeof (*e));
e->X_op = O_absent;
SKIP_WHITESPACE ();
- if (*input_line_pointer != '}')
- expression (e);
- sep = *input_line_pointer++;
-
- if (sep == '}')
- {
- if (!md.manual_bundling)
- as_warn ("Found '}' when manual bundling is off");
- else
- CURR_SLOT.manual_bundling_off = 1;
- md.manual_bundling = 0;
- sep = '\0';
- }
+ expression_and_evaluate (e);
+ sep = *input_line_pointer;
+ if (more && (sep == ',' || sep == more))
+ ++input_line_pointer;
return sep;
}
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;
end = strchr (input_line_pointer, '=');
if (!end)
{
- as_bad ("Expected separator `='");
+ as_bad (_("Expected separator `='"));
return 0;
}
input_line_pointer = end + 1;
{
if (i < NELEMS (CURR_SLOT.opnd))
{
- sep = parse_operand (CURR_SLOT.opnd + i);
+ sep = parse_operand (CURR_SLOT.opnd + i, '=');
if (CURR_SLOT.opnd[i].X_op == O_absent)
break;
}
{
expressionS dummy;
- sep = parse_operand (&dummy);
+ sep = parse_operand (&dummy, '=');
if (dummy.X_op == O_absent)
break;
}
if (sep == '=')
{
if (num_outputs > 0)
- as_bad ("Duplicate equal sign (=) in instruction");
+ as_bad (_("Duplicate equal sign (=) in instruction"));
else
num_outputs = i + 1;
}
}
if (sep != '\0')
{
- as_bad ("Illegal operand separator `%c'", sep);
+ as_bad (_("Illegal operand separator `%c'"), sep);
return 0;
}
if (idesc->operands[2] == IA64_OPND_SOF
|| idesc->operands[1] == IA64_OPND_SOF)
{
- /* map alloc r1=ar.pfs,i,l,o,r to alloc r1=ar.pfs,(i+l+o),(i+l),r */
+ /* Map alloc r1=ar.pfs,i,l,o,r to alloc r1=ar.pfs,(i+l+o),(i+l),r.
+ Note, however, that due to that mapping operand numbers in error
+ messages for any of the constant operands will not be correct. */
know (strcmp (idesc->name, "alloc") == 0);
- i = (CURR_SLOT.opnd[1].X_op == O_register
- && CURR_SLOT.opnd[1].X_add_number == REG_AR + AR_PFS) ? 2 : 1;
- if (num_operands == i + 3 /* first_arg not included in this count! */
- && CURR_SLOT.opnd[i].X_op == O_constant
- && CURR_SLOT.opnd[i + 1].X_op == O_constant
- && CURR_SLOT.opnd[i + 2].X_op == O_constant
- && CURR_SLOT.opnd[i + 3].X_op == O_constant)
- {
- sof = set_regstack (CURR_SLOT.opnd[i].X_add_number,
- CURR_SLOT.opnd[i + 1].X_add_number,
- CURR_SLOT.opnd[i + 2].X_add_number,
- CURR_SLOT.opnd[i + 3].X_add_number);
-
- /* 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);
- if (sep != '=')
- --num_outputs; /* force error */
- input_line_pointer = saved_input_pointer;
-
- CURR_SLOT.opnd[i].X_add_number = sof;
- CURR_SLOT.opnd[i + 1].X_add_number
- = sof - CURR_SLOT.opnd[i + 2].X_add_number;
- CURR_SLOT.opnd[i + 2] = CURR_SLOT.opnd[i + 3];
- }
+ /* The first operand hasn't been parsed/initialized, yet (but
+ num_operands intentionally doesn't account for that). */
+ i = num_operands > 4 ? 2 : 1;
+#define FORCE_CONST(n) (CURR_SLOT.opnd[n].X_op == O_constant \
+ ? CURR_SLOT.opnd[n].X_add_number \
+ : 0)
+ sof = set_regstack (FORCE_CONST(i),
+ FORCE_CONST(i + 1),
+ FORCE_CONST(i + 2),
+ FORCE_CONST(i + 3));
+#undef FORCE_CONST
+
+ /* 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, '=');
+ if (sep != '=')
+ --num_outputs; /* force error */
+ input_line_pointer = saved_input_pointer;
+
+ CURR_SLOT.opnd[i].X_add_number = sof;
+ if (CURR_SLOT.opnd[i + 1].X_op == O_constant
+ && CURR_SLOT.opnd[i + 2].X_op == O_constant)
+ CURR_SLOT.opnd[i + 1].X_add_number
+ = sof - CURR_SLOT.opnd[i + 2].X_add_number;
+ else
+ CURR_SLOT.opnd[i + 1].X_op = O_illegal;
+ CURR_SLOT.opnd[i + 2] = CURR_SLOT.opnd[i + 3];
}
highest_unmatched_operand = -4;
if (!idesc)
{
if (expected_operand)
- as_bad ("Operand %u of `%s' should be %s",
+ as_bad (_("Operand %u of `%s' should be %s"),
error_pos + 1, mnemonic,
elf64_ia64_operands[expected_operand].desc);
else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 1))
- as_bad ("Wrong number of output operands");
+ as_bad (_("Wrong number of output operands"));
else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 2))
- as_bad ("Wrong number of input operands");
+ as_bad (_("Wrong number of input operands"));
else
- as_bad ("Operand mismatch");
+ as_bad (_("Operand mismatch"));
return 0;
}
case 0:
break;
default:
- as_warn ("Invalid use of `%c%d' as output operand", reg_class, regno);
+ as_warn (_("Invalid use of `%c%d' as output operand"), reg_class, regno);
break;
case 'm':
- as_warn ("Invalid use of `r%d' as base update address operand", regno);
+ as_warn (_("Invalid use of `r%d' as base update address operand"), regno);
break;
}
}
else
reg_class = 0;
if (reg_class)
- as_warn ("Invalid duplicate use of `%c%d'", reg_class, reg1);
+ as_warn (_("Invalid duplicate use of `%c%d'"), reg_class, reg1);
}
else if (((reg1 >= REG_FR && reg1 <= REG_FR + 31
&& reg2 >= REG_FR && reg2 <= REG_FR + 31)
|| (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
&& reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127))
&& ! ((reg1 ^ reg2) & 1))
- as_warn ("Invalid simultaneous use of `f%d' and `f%d'",
+ as_warn (_("Invalid simultaneous use of `f%d' and `f%d'"),
reg1 - REG_FR, reg2 - REG_FR);
else if ((reg1 >= REG_FR && reg1 <= REG_FR + 31
&& reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127)
|| (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
&& reg2 >= REG_FR && reg2 <= REG_FR + 31))
- as_warn ("Dangerous simultaneous use of `f%d' and `f%d'",
+ as_warn (_("Dangerous simultaneous use of `f%d' and `f%d'"),
reg1 - REG_FR, reg2 - REG_FR);
return idesc;
}
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;
err = (*odesc->insert) (odesc, val, &insn);
if (err)
as_bad_where (slot->src_file, slot->src_line,
- "Bad operand value: %s", err);
+ _("Bad operand value: %s"), err);
if (idesc->flags & IA64_OPCODE_PSEUDO)
{
if ((idesc->flags & IA64_OPCODE_F2_EQ_F3)
}
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;
struct ia64_opcode *idesc;
int end_of_insn_group = 0, user_template = -1;
int n, i, j, first, curr, last_slot;
- unw_rec_list *ptr, *last_ptr, *end_ptr;
bfd_vma t0 = 0, t1 = 0;
struct label_fix *lfix;
+ bfd_boolean mark_label;
struct insn_fix *ifix;
char mnemonic[16];
fixS *fix;
int addr_mod;
first = (md.curr_slot + NUM_SLOTS - md.num_slots_in_use) % NUM_SLOTS;
- know (first >= 0 & first < NUM_SLOTS);
+ know (first >= 0 && first < NUM_SLOTS);
n = MIN (3, md.num_slots_in_use);
/* Determine template: user user_template if specified, best match
for (i = 0; i < 3 && md.num_slots_in_use > 0; ++i)
{
/* If we have unwind records, we may need to update some now. */
- ptr = md.slot[curr].unwind_record;
+ unw_rec_list *ptr = md.slot[curr].unwind_record;
+ unw_rec_list *end_ptr = NULL;
+
if (ptr)
{
/* Find the last prologue/body record in the list for the current
issued. This matters because there may have been nops emitted
meanwhile. Any non-prologue non-body record followed by a
prologue/body record must also refer to the current point. */
- last_ptr = NULL;
- end_ptr = md.slot[(curr + 1) % NUM_SLOTS].unwind_record;
- for (; ptr != end_ptr; ptr = ptr->next)
+ unw_rec_list *last_ptr;
+
+ for (j = 1; end_ptr == NULL && j < md.num_slots_in_use; ++j)
+ end_ptr = md.slot[(curr + j) % NUM_SLOTS].unwind_record;
+ for (last_ptr = NULL; ptr != end_ptr; ptr = ptr->next)
if (ptr->r.type == prologue || ptr->r.type == prologue_gr
|| ptr->r.type == body)
last_ptr = ptr;
if (manual_bundling && !manual_bundling_off)
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "`%s' must be last in bundle", idesc->name);
+ _("`%s' must be last in bundle"), idesc->name);
if (i < 2)
manual_bundling = -1; /* Suppress meaningless post-loop errors. */
}
default:
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "Internal error: don't know how to force %s to end"
- "of instruction group", idesc->name);
+ _("Internal error: don't know how to force %s to end of instruction group"),
+ idesc->name);
required_slot = i;
break;
}
&& (template ^ required_template) > 1)))
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "`%s' must be last in instruction group",
+ _("`%s' must be last in instruction group"),
idesc->name);
if (i < 2 && required_slot == 2 && !manual_bundling_off)
manual_bundling = -1; /* Suppress meaningless post-loop errors. */
changing NOPs in front of this slot. */
for (j = i; j < 3; ++j)
insn[j] = nop[ia64_templ_desc[required_template].exec_unit[j]];
+
+ /* We just picked a template that includes the stop bit in the
+ middle, so we don't need another one emitted later. */
+ md.slot[curr].end_of_insn_group = 0;
}
template = required_template;
}
if (manual_bundling)
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "Label must be first in a bundle");
+ _("Label must be first in a bundle"));
manual_bundling = -1; /* Suppress meaningless post-loop errors. */
}
/* This insn must go into the first slot of a bundle. */
case hint_b_ok:
break;
case hint_b_warning:
- as_warn ("hint in B unit may be treated as nop");
+ as_warn (_("hint in B unit may be treated as nop"));
break;
case hint_b_error:
/* When manual bundling is off and there is no
if (!manual_bundling && user_template < 0)
insn_unit = IA64_UNIT_I;
else
- as_bad ("hint in B unit can't be used");
+ as_bad (_("hint in B unit can't be used"));
break;
}
}
insn_unit = IA64_UNIT_I;
}
else
- as_fatal ("emit_one_bundle: unexpected dynamic op");
+ as_fatal (_("emit_one_bundle: unexpected dynamic op"));
- sprintf (mnemonic, "%s.%c", idesc->name, "?imbfxx"[insn_unit]);
+ snprintf (mnemonic, sizeof (mnemonic), "%s.%c",
+ idesc->name, "?imbfxx"[insn_unit]);
opnd1 = idesc->operands[0];
opnd2 = idesc->operands[1];
ia64_free_opcode (idesc);
if (insn_unit != required_unit)
continue; /* Try next slot. */
- if (debug_type == DEBUG_DWARF2 || md.slot[curr].loc_directive_seen)
+ /* Now is a good time to fix up the labels for this insn. */
+ mark_label = FALSE;
+ for (lfix = md.slot[curr].label_fixups; lfix; lfix = lfix->next)
+ {
+ S_SET_VALUE (lfix->sym, frag_now_fix () - 16);
+ symbol_set_frag (lfix->sym, frag_now);
+ mark_label |= lfix->dw2_mark_labels;
+ }
+ for (lfix = md.slot[curr].tag_fixups; lfix; lfix = lfix->next)
+ {
+ S_SET_VALUE (lfix->sym, frag_now_fix () - 16 + i);
+ symbol_set_frag (lfix->sym, frag_now);
+ }
+
+ if (debug_type == DEBUG_DWARF2
+ || md.slot[curr].loc_directive_seen
+ || mark_label)
{
bfd_vma addr = frag_now->fr_address + frag_now_fix () - 16 + i;
md.slot[curr].loc_directive_seen = 0;
+ if (mark_label)
+ md.slot[curr].debug_line.flags |= DWARF2_FLAG_BASIC_BLOCK;
+
dwarf2_gen_line_info (addr, &md.slot[curr].debug_line);
}
/* Set slot numbers for all remaining unwind records belonging to the
current insn. There can not be any prologue/body unwind records
here. */
- end_ptr = md.slot[(curr + 1) % NUM_SLOTS].unwind_record;
for (; ptr != end_ptr; ptr = ptr->next)
{
ptr->slot_number = (unsigned long) f + i;
--md.num_slots_in_use;
last_slot = i;
- /* now is a good time to fix up the labels for this insn: */
- for (lfix = md.slot[curr].label_fixups; lfix; lfix = lfix->next)
- {
- S_SET_VALUE (lfix->sym, frag_now_fix () - 16);
- symbol_set_frag (lfix->sym, frag_now);
- }
- /* and fix up the tags also. */
- for (lfix = md.slot[curr].tag_fixups; lfix; lfix = lfix->next)
- {
- S_SET_VALUE (lfix->sym, frag_now_fix () - 16 + i);
- symbol_set_frag (lfix->sym, frag_now);
- }
-
for (j = 0; j < md.slot[curr].num_fixups; ++j)
{
ifix = md.slot[curr].fixup + j;
fix = fix_new_exp (frag_now, frag_now_fix () - 16 + i, 8,
&ifix->expr, ifix->is_pcrel, ifix->code);
fix->tc_fix_data.opnd = ifix->opnd;
- fix->fx_plt = (fix->fx_r_type == BFD_RELOC_IA64_PLTOFF22);
fix->fx_file = md.slot[curr].src_file;
fix->fx_line = md.slot[curr].src_line;
}
curr = (curr + 1) % NUM_SLOTS;
idesc = md.slot[curr].idesc;
}
- if (manual_bundling > 0)
+
+ /* A user template was specified, but the first following instruction did
+ not fit. This can happen with or without manual bundling. */
+ if (md.num_slots_in_use > 0 && last_slot < 0)
+ {
+ 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);
+ /* Drop first insn so we don't livelock. */
+ --md.num_slots_in_use;
+ know (curr == first);
+ ia64_free_opcode (md.slot[curr].idesc);
+ memset (md.slot + curr, 0, sizeof (md.slot[curr]));
+ md.slot[curr].user_template = -1;
+ }
+ else if (manual_bundling > 0)
{
if (md.num_slots_in_use > 0)
{
if (last_slot >= 2)
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "`%s' does not fit into bundle", idesc->name);
- else if (last_slot < 0)
- {
- 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);
- /* Drop first insn so we don't livelock. */
- --md.num_slots_in_use;
- know (curr == first);
- ia64_free_opcode (md.slot[curr].idesc);
- memset (md.slot + curr, 0, sizeof (md.slot[curr]));
- md.slot[curr].user_template = -1;
- }
+ _("`%s' does not fit into bundle"), idesc->name);
else
{
const char *where;
else
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",
+ _("`%s' can't go in %s of %s template"),
idesc->name, where, ia64_templ_desc[template].name);
}
}
else
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
- "Missing '}' at end of file");
+ _("Missing '}' at end of file"));
}
+
know (md.num_slots_in_use < NUM_SLOTS);
t0 = end_of_insn_group | (template << 1) | (insn[0] << 5) | (insn[1] << 46);
number_to_chars_littleendian (f + 0, t0, 8);
number_to_chars_littleendian (f + 8, t1, 8);
-
- if (unwind.list)
- {
- unwind.list->next_slot_number = (unsigned long) f + 16;
- unwind.list->next_slot_frag = frag_now;
- }
}
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"));
return result;
}
-/* Add a bit of extra goodness if a nop of type F or B would fit
- in TEMPL at SLOT. */
+/* For Itanium 1, add a bit of extra goodness if a nop of type F or B would fit
+ in TEMPL at SLOT. For Itanium 2, add a bit of extra goodness if a nop of
+ type M or I would fit in TEMPL at SLOT. */
static inline int
extra_goodness (int templ, int slot)
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, total, ar_base, cr_base, goodness, best, regnum, ok;
+ int i, j, k, t, goodness, best, ok;
const char *err;
char name[8];
{
if (match (t, j, 1))
{
- if (match (t, k, 2))
+ if ((t == 2 && j == IA64_TYPE_X) || match (t, k, 2))
goodness = 3 + 3 + 3;
else
goodness = 3 + 3 + extra_goodness (t, 2);
}
else if (match (t, i, 1))
{
- if (match (t, j, 2))
+ if ((t == 2 && i == IA64_TYPE_X) || match (t, j, 2))
goodness = 3 + 3;
else
goodness = 3 + extra_goodness (t, 2);
}
}
+#ifdef DEBUG_TEMPLATES
+ /* For debugging changes to the best_template calculations. We don't care
+ about combinations with invalid instructions, so start the loops at 1. */
+ for (i = 0; i < IA64_NUM_TYPES; ++i)
+ for (j = 0; j < IA64_NUM_TYPES; ++j)
+ for (k = 0; k < IA64_NUM_TYPES; ++k)
+ {
+ char type_letter[IA64_NUM_TYPES] = { 'n', 'a', 'i', 'm', 'b', 'f',
+ 'x', 'd' };
+ fprintf (stderr, "%c%c%c %s\n", type_letter[i], type_letter[j],
+ type_letter[k],
+ ia64_templ_desc[best_template[i][j][k]].name);
+ }
+#endif
+
for (i = 0; i < NUM_SLOTS; ++i)
md.slot[i].user_template = -1;
err = hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
(void *) (pseudo_opcode + i));
if (err)
- as_fatal ("ia64.md_begin: can't hash `%s': %s",
+ as_fatal (_("ia64.md_begin: can't hash `%s': %s"),
pseudo_opcode[i].name, err);
}
md.entry_hash = hash_new ();
/* general registers: */
-
- total = 128;
- for (i = 0; i < total; ++i)
- {
- sprintf (name, "r%d", i - REG_GR);
- md.regsym[i] = declare_register (name, i);
- }
+ declare_register_set ("r", 128, REG_GR);
+ declare_register ("gp", REG_GR + 1);
+ declare_register ("sp", REG_GR + 12);
+ declare_register ("tp", REG_GR + 13);
+ declare_register_set ("ret", 4, REG_GR + 8);
/* floating point registers: */
- total += 128;
- for (; i < total; ++i)
- {
- sprintf (name, "f%d", i - REG_FR);
- md.regsym[i] = declare_register (name, i);
- }
-
- /* application registers: */
- total += 128;
- ar_base = i;
- for (; i < total; ++i)
- {
- sprintf (name, "ar%d", i - REG_AR);
- md.regsym[i] = declare_register (name, i);
- }
+ declare_register_set ("f", 128, REG_FR);
+ declare_register_set ("farg", 8, REG_FR + 8);
+ declare_register_set ("fret", 8, REG_FR + 8);
- /* control registers: */
- total += 128;
- cr_base = i;
- for (; i < total; ++i)
- {
- sprintf (name, "cr%d", i - REG_CR);
- md.regsym[i] = declare_register (name, i);
- }
+ /* branch registers: */
+ declare_register_set ("b", 8, REG_BR);
+ declare_register ("rp", REG_BR + 0);
/* predicate registers: */
- total += 64;
- for (; i < total; ++i)
- {
- sprintf (name, "p%d", i - REG_P);
- md.regsym[i] = declare_register (name, i);
- }
+ declare_register_set ("p", 64, REG_P);
+ declare_register ("pr", REG_PR);
+ declare_register ("pr.rot", REG_PR_ROT);
- /* branch registers: */
- total += 8;
- for (; i < total; ++i)
- {
- sprintf (name, "b%d", i - REG_BR);
- md.regsym[i] = declare_register (name, i);
- }
+ /* application registers: */
+ declare_register_set ("ar", 128, REG_AR);
+ for (i = 0; i < NELEMS (ar); ++i)
+ declare_register (ar[i].name, REG_AR + ar[i].regnum);
+
+ /* control registers: */
+ declare_register_set ("cr", 128, REG_CR);
+ for (i = 0; i < NELEMS (cr); ++i)
+ declare_register (cr[i].name, REG_CR + cr[i].regnum);
- md.regsym[REG_IP] = declare_register ("ip", REG_IP);
- md.regsym[REG_CFM] = declare_register ("cfm", REG_CFM);
- md.regsym[REG_PR] = declare_register ("pr", REG_PR);
- md.regsym[REG_PR_ROT] = declare_register ("pr.rot", REG_PR_ROT);
- md.regsym[REG_PSR] = declare_register ("psr", REG_PSR);
- md.regsym[REG_PSR_L] = declare_register ("psr.l", REG_PSR_L);
- md.regsym[REG_PSR_UM] = declare_register ("psr.um", REG_PSR_UM);
+ declare_register ("ip", REG_IP);
+ declare_register ("cfm", REG_CFM);
+ declare_register ("psr", REG_PSR);
+ declare_register ("psr.l", REG_PSR_L);
+ declare_register ("psr.um", REG_PSR_UM);
for (i = 0; i < NELEMS (indirect_reg); ++i)
{
- regnum = indirect_reg[i].regnum;
- md.regsym[regnum] = declare_register (indirect_reg[i].name, regnum);
- }
-
- /* define synonyms for application registers: */
- for (i = REG_AR; i < REG_AR + NELEMS (ar); ++i)
- md.regsym[i] = declare_register (ar[i - REG_AR].name,
- REG_AR + ar[i - REG_AR].regnum);
+ unsigned int regnum = indirect_reg[i].regnum;
- /* define synonyms for control registers: */
- for (i = REG_CR; i < REG_CR + NELEMS (cr); ++i)
- md.regsym[i] = declare_register (cr[i - REG_CR].name,
- REG_CR + cr[i - REG_CR].regnum);
-
- declare_register ("gp", REG_GR + 1);
- declare_register ("sp", REG_GR + 12);
- declare_register ("rp", REG_BR + 0);
+ md.indregsym[regnum - IND_CPUID] = declare_register (indirect_reg[i].name, regnum);
+ }
/* pseudo-registers used to specify unwind info: */
declare_register ("psp", REG_PSP);
- declare_register_set ("ret", 4, REG_GR + 8);
- declare_register_set ("farg", 8, REG_FR + 8);
- declare_register_set ("fret", 8, REG_FR + 8);
-
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",
+ 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;
md.detect_dv = 1;
/* 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)
{
}
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;
+
+ if (!first) {
+ /* Make sure we don't reference input_line_pointer[-1] when that's
+ not valid. */
+ first = 1;
+ return;
+ }
+
if (md.qp.X_op == O_register)
- as_bad ("qualifying predicate not followed by instruction");
+ as_bad (_("qualifying predicate not followed by instruction"));
md.qp.X_op = O_absent;
if (ignore_input ())
else
insn_group_break (1, 0, 0);
}
-}
-
-/* This is a hook for ia64_frob_label, so that it can distinguish tags from
- labels. */
-static int defining_tag = 0;
-
-int
-ia64_unrecognized_line (ch)
- int ch;
-{
- switch (ch)
+ else if (input_line_pointer[-1] == '{')
{
- case '(':
- expression (&md.qp);
- if (*input_line_pointer++ != ')')
- {
- as_bad ("Expected ')'");
- return 0;
- }
- if (md.qp.X_op != O_register)
- {
- as_bad ("Qualifying predicate expected");
- return 0;
- }
- if (md.qp.X_add_number < REG_P || md.qp.X_add_number >= REG_P + 64)
- {
- as_bad ("Predicate register expected");
- return 0;
- }
- return 1;
-
- case '{':
if (md.manual_bundling)
- as_warn ("Found '{' when manual bundling is already turned on");
+ as_warn (_("Found '{' when manual bundling is already turned on"));
else
CURR_SLOT.manual_bundling_on = 1;
md.manual_bundling = 1;
else
as_warn (_("Found '{' after explicit switch to automatic mode"));
}
- return 1;
-
- case '}':
+ }
+ else if (input_line_pointer[-1] == '}')
+ {
if (!md.manual_bundling)
- as_warn ("Found '}' when manual bundling is off");
+ as_warn (_("Found '}' when manual bundling is off"));
else
PREV_SLOT.manual_bundling_off = 1;
md.manual_bundling = 0;
&& !md.mode_explicitly_set
&& !md.default_explicit_mode)
dot_dv_mode ('A');
+ }
+}
- /* Allow '{' to follow on the same line. We also allow ";;", but that
- happens automatically because ';' is an end of line marker. */
- SKIP_WHITESPACE ();
- if (input_line_pointer[0] == '{')
+/* This is a hook for ia64_frob_label, so that it can distinguish tags from
+ labels. */
+static int defining_tag = 0;
+
+int
+ia64_unrecognized_line (int ch)
+{
+ switch (ch)
+ {
+ case '(':
+ expression_and_evaluate (&md.qp);
+ if (*input_line_pointer++ != ')')
{
- input_line_pointer++;
- return ia64_unrecognized_line ('{');
+ as_bad (_("Expected ')'"));
+ return 0;
+ }
+ if (md.qp.X_op != O_register)
+ {
+ as_bad (_("Qualifying predicate expected"));
+ return 0;
+ }
+ if (md.qp.X_add_number < REG_P || md.qp.X_add_number >= REG_P + 64)
+ {
+ as_bad (_("Predicate register expected"));
+ return 0;
}
-
- demand_empty_rest_of_line ();
return 1;
case '[':
if (md.qp.X_op == O_register)
{
- as_bad ("Tag must come before qualifying predicate.");
+ as_bad (_("Tag must come before qualifying predicate."));
return 0;
}
{
/* Put ':' back for error messages' sake. */
*input_line_pointer++ = ':';
- as_bad ("Expected ':'");
+ as_bad (_("Expected ':'"));
return 0;
}
*input_line_pointer++ = ':';
if (*input_line_pointer++ != ']')
{
- as_bad ("Expected ']'");
+ as_bad (_("Expected ']'"));
return 0;
}
if (! tag)
{
- as_bad ("Tag name expected");
+ as_bad (_("Tag name expected"));
return 0;
}
return 1;
}
void
-ia64_frob_label (sym)
- struct symbol *sym;
+ia64_frob_label (struct symbol *sym)
{
struct label_fix *fix;
fix = obstack_alloc (¬es, sizeof (*fix));
fix->sym = sym;
fix->next = CURR_SLOT.tag_fixups;
+ fix->dw2_mark_labels = FALSE;
CURR_SLOT.tag_fixups = fix;
return;
fix = obstack_alloc (¬es, sizeof (*fix));
fix->sym = sym;
fix->next = CURR_SLOT.label_fixups;
+ fix->dw2_mark_labels = dwarf2_loc_mark_labels;
CURR_SLOT.label_fixups = fix;
/* Keep track of how many code entry points we've seen. */
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)
{
- unsigned num_regs;
-
- if (op == O_index)
+ if (op != O_index)
+ return 0;
+ resolve_expression (l);
+ if (l->X_op == O_register)
{
- if (l->X_op == O_register && r->X_op == O_constant)
+ unsigned num_regs = l->X_add_number >> 16;
+
+ resolve_expression (r);
+ if (num_regs)
{
- num_regs = (l->X_add_number >> 16);
- if ((unsigned) r->X_add_number >= num_regs)
+ /* Left side is a .rotX-allocated register. */
+ if (r->X_op != O_constant)
{
- if (!num_regs)
- as_bad ("No current frame");
- else
- as_bad ("Index out of range 0..%u", num_regs - 1);
+ as_bad (_("Rotating register index must be a non-negative constant"));
+ r->X_add_number = 0;
+ }
+ else if ((valueT) r->X_add_number >= num_regs)
+ {
+ as_bad (_("Index out of range 0..%u"), num_regs - 1);
r->X_add_number = 0;
}
l->X_add_number = (l->X_add_number & 0xffff) + r->X_add_number;
return 1;
}
- else if (l->X_op == O_register && r->X_op == O_register)
+ else if (l->X_add_number >= IND_CPUID && l->X_add_number <= IND_RR)
{
- if (l->X_add_number < IND_CPUID || l->X_add_number > IND_RR
- || l->X_add_number == IND_MEM)
+ if (r->X_op != O_register
+ || r->X_add_number < REG_GR
+ || r->X_add_number > REG_GR + 127)
{
- as_bad ("Indirect register set name expected");
- l->X_add_number = IND_CPUID;
+ as_bad (_("Indirect register index must be a general register"));
+ r->X_add_number = REG_GR;
}
l->X_op = O_index;
- l->X_op_symbol = md.regsym[l->X_add_number];
+ l->X_op_symbol = md.indregsym[l->X_add_number - IND_CPUID];
l->X_add_number = r->X_add_number;
return 1;
}
}
- return 0;
+ as_bad (_("Index can only be applied to rotating or indirect registers"));
+ /* Fall back to some register use of which has as little as possible
+ side effects, to minimize subsequent error messages. */
+ l->X_op = O_register;
+ l->X_add_number = REG_GR + 3;
+ return 1;
}
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;
end = input_line_pointer;
if (*nextcharP != '(')
{
- as_bad ("Expected '('");
+ as_bad (_("Expected '('"));
break;
}
/* Skip '('. */
expression (e);
if (*input_line_pointer != ')')
{
- as_bad ("Missing ')'");
+ as_bad (_("Missing ')'"));
goto done;
}
/* Skip ')'. */
{
if (e->X_op != O_pseudo_fixup)
{
- as_bad ("Not a symbolic expression");
+ as_bad (_("Not a symbolic expression"));
goto done;
}
if (idx != FUNC_LT_RELATIVE)
{
- as_bad ("Illegal combination of relocation functions");
+ as_bad (_("Illegal combination of relocation functions"));
goto done;
}
switch (S_GET_VALUE (e->X_op_symbol))
case FUNC_TP_RELATIVE:
idx = FUNC_LT_TP_RELATIVE; break;
default:
- as_bad ("Illegal combination of relocation functions");
+ as_bad (_("Illegal combination of relocation functions"));
goto done;
}
}
if (regnum >= dr->num_regs)
{
if (!dr->num_regs)
- as_bad ("No current frame");
+ as_bad (_("No current frame"));
else
- as_bad ("Register number out of range 0..%u",
+ as_bad (_("Register number out of range 0..%u"),
dr->num_regs - 1);
regnum = 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;
if (len <= 0)
{
if (full > 0)
- as_bad ("Standalone `#' is illegal");
+ as_bad (_("Standalone `#' is illegal"));
}
else if (len < full - 1)
- as_warn ("Redundant `#' suffix operators");
+ as_warn (_("Redundant `#' suffix operators"));
name[len] = '\0';
return name;
}
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;
cannot statically be determined, all source registers are marked used.
12) This insn only reads the specified predicate register when that
register is the PR[qp].
- 13) This reference to ld-c only applies to teh GR whose value is loaded
+ 13) This reference to ld-c only applies to the GR whose value is loaded
with data returned from memory, not the post-incremented address register.
14) The RSE resource includes the implementation-specific RSE internal
state resources. At least one (and possibly more) of these resources are
IC:rse-writers.
15+16) Represents reserved instructions, which the assembler does not
generate.
+ 17) CR[TPR] has a RAW dependency only between mov-to-CR-TPR and
+ mov-to-PSR-l or ssm instructions that set PSR.i, PSR.pp or PSR.up.
Memory resources (i.e. locations in memory) are *not* marked or tracked by
this code; there are no dependency violations based on memory access.
#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;
}
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)
{
case CR_ISR:
case CR_IFA:
case CR_IHA:
+ case CR_IIB0:
+ case CR_IIB1:
case CR_IIPA:
specs[count++] = tmpl;
break;
CURR_SLOT.opnd[index].X_add_number - REG_AR;
if (regno == AR_ITC
+ || regno == AR_RUC
|| (index == 0
- && (regno == AR_ITC
- || regno == AR_RSC
+ && (regno == AR_RSC
|| (regno >= AR_K0
&& regno <= AR_K7))))
{
break;
case IA64_RS_CRX:
- /* Handle all CR[REG] resources */
- if (note == 0 || note == 1)
+ /* Handle all CR[REG] resources.
+ ??? FIXME: The rule 17 isn't really handled correctly. */
+ if (note == 0 || note == 1 || note == 17)
{
if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
{
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;
int certain = (matchtype == 1 && CURR_SLOT.qp_regno == 0);
if (path != 0)
- sprintf (pathmsg, " when entry is at label '%s'",
+ snprintf (pathmsg, sizeof (pathmsg),
+ " when entry is at label '%s'",
md.entry_labels[path - 1]);
if (matchtype == 1 && rs->index >= 0)
- sprintf (indexmsg, ", specific resource number is %d",
+ snprintf (indexmsg, sizeof (indexmsg),
+ ", specific resource number is %d",
rs->index);
- sprintf (msg, "Use of '%s' %s %s dependency '%s' (%s)%s%s",
+ snprintf (msg, sizeof (msg),
+ "Use of '%s' %s %s dependency '%s' (%s)%s%s",
idesc->name,
(certain ? "violates" : "may violate"),
dv_mode[dep->mode], dep->name,
{
as_warn ("%s", msg);
if (path < md.path)
- as_warn (_("Only the first path encountering the conflict "
- "is reported"));
+ as_warn (_("Only the first path encountering the conflict is reported"));
as_warn_where (rs->file, rs->line,
- _("This is the location of the "
- "conflicting usage"));
+ _("This is the location of the conflicting usage"));
/* Don't bother checking other paths, to avoid duplicating
the same warning */
break;
/* 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;
*input_line_pointer = ch;
if (!idesc)
{
- as_bad ("Unknown opcode `%s'", mnemonic);
+ as_bad (_("Unknown opcode `%s'"), mnemonic);
goto done;
}
else if (ar_is_only_in_memory_unit (CURR_SLOT.opnd[rop].X_add_number))
unit = 'm';
if (unit != 'a' && unit != idesc->name [4])
- as_bad ("AR %d can only be accessed by %c-unit",
+ as_bad (_("AR %d can only be accessed by %c-unit"),
(int) (CURR_SLOT.opnd[rop].X_add_number - REG_AR),
TOUPPER (unit));
}
case hint_b_ok:
break;
case hint_b_warning:
- as_warn ("hint.b may be treated as nop");
+ as_warn (_("hint.b may be treated as nop"));
break;
case hint_b_error:
- as_bad ("hint.b shouldn't be used");
+ as_bad (_("hint.b shouldn't be used"));
break;
}
}
if ((flags & IA64_OPCODE_NO_PRED) != 0 && qp_regno != 0)
{
- as_bad ("`%s' cannot be predicated", idesc->name);
+ as_bad (_("`%s' cannot be predicated"), idesc->name);
goto done;
}
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 entry, if there is one. */
+ /* Add unwind entries, if there are any. */
if (unwind.current_entry)
{
CURR_SLOT.unwind_record = unwind.current_entry;
unwind.current_entry = NULL;
}
- if (unwind.proc_start && S_IS_DEFINED (unwind.proc_start))
+ if (unwind.pending_saves)
+ {
+ if (unwind.pending_saves->next)
+ {
+ /* Attach the next pending save to the next slot so that its
+ slot number will get set correctly. */
+ add_unwind_entry (unwind.pending_saves->next, NOT_A_CHAR);
+ unwind.pending_saves = &unwind.pending_saves->next->r.record.p;
+ }
+ else
+ unwind.pending_saves = NULL;
+ }
+ if (unwind.proc_pending.sym && S_IS_DEFINED (unwind.proc_pending.sym))
unwind.insn = 1;
/* Check for dependency violations. */
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)
{
case '[':
++input_line_pointer;
- expression (e);
+ expression_and_evaluate (e);
if (*input_line_pointer != ']')
{
- as_bad ("Closing bracket missing");
+ as_bad (_("Closing bracket missing"));
goto err;
}
else
{
- if (e->X_op != O_register)
- as_bad ("Register expected as index");
+ if (e->X_op != O_register
+ || e->X_add_number < REG_GR
+ || e->X_add_number > REG_GR + 127)
+ {
+ as_bad (_("Index must be a general register"));
+ e->X_add_number = REG_GR;
+ }
++input_line_pointer;
e->X_op = O_index;
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;
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;
/* FALLTHRU */
default:
- as_bad ("Unsupported fixup size %d", nbytes);
+ as_bad (_("Unsupported fixup size %d"), nbytes);
ignore_rest_of_line ();
return;
}
fix = fix_new_exp (f, where, nbytes, exp, 0, code);
/* We need to store the byte order in effect in case we're going
to fix an 8 or 16 bit relocation (for which there no real
- relocs available). See md_apply_fix3(). */
+ relocs available). See md_apply_fix(). */
fix->tc_fix_data.bigendian = target_big_endian;
}
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;
const char *type = NULL, *suffix = "";
case BFD_RELOC_IA64_DIR32LSB: width = 32; suffix = "LSB"; break;
case BFD_RELOC_IA64_DIR64MSB: width = 64; suffix = "MSB"; break;
case BFD_RELOC_IA64_DIR64LSB: width = 64; suffix = "LSB"; break;
+ case BFD_RELOC_UNUSED: width = 13; break;
case BFD_RELOC_IA64_IMM14: width = 14; break;
case BFD_RELOC_IA64_IMM22: width = 22; break;
case BFD_RELOC_IA64_IMM64: width = 64; suffix = "I"; break;
}
/* This should be an error, but since previously there wasn't any
- diagnostic here, dont't make it fail because of this for now. */
- as_warn ("Cannot express %s%d%s relocation", type, width, suffix);
+ diagnostic here, don't make it fail because of this for now. */
+ as_warn (_("Cannot express %s%d%s relocation"), type, width, suffix);
return r_type;
}
}
/* 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)
{
case BFD_RELOC_IA64_LTOFF_FPTR64I:
if (fix->fx_offset != 0)
as_bad_where (fix->fx_file, fix->fx_line,
- "No addend allowed in @fptr() relocation");
+ _("No addend allowed in @fptr() relocation"));
break;
default:
break;
}
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;
(if possible). */
void
-md_apply_fix3 (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;
/* This must be a TAG13 or TAG13b operand. There are no external
relocs defined for them, so we must give an error. */
as_bad_where (fix->fx_file, fix->fx_line,
- "%s must have a constant value",
+ _("%s must have a constant value"),
elf64_ia64_operands[fix->tc_fix_data.opnd].desc);
fix->fx_done = 1;
return;
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;
if (!reloc->howto)
{
as_bad_where (fixp->fx_file, fixp->fx_line,
- "Cannot represent %s relocation in object file",
+ _("Cannot represent %s relocation in object file"),
bfd_get_reloc_code_name (fixp->fx_r_type));
+ free (reloc);
+ return NULL;
}
return reloc;
}
#define MAX_LITTLENUMS 5
char *
-md_atof (type, lit, size)
- int type;
- char *lit;
- int *size;
+md_atof (int type, char *lit, int *size)
{
LITTLENUM_TYPE words[MAX_LITTLENUMS];
char *t;
default:
*size = 0;
- return "Bad call to MD_ATOF()";
+ return _("Unrecognized or unsupported floating point constant");
}
t = atof_ieee (input_line_pointer, type, words);
if (t)
else
*size = prec * sizeof (LITTLENUM_TYPE);
- return 0;
+ return NULL;
}
/* 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;
}
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)
{
char *file; /* The file where the directive is seen. */
unsigned int line; /* The line number the directive is at. */
- const char *name; /* The orignale name of the symbol. */
+ const char *name; /* The original name of the symbol. */
};
/* Called for .alias and .secalias directives. If SECTION is 1, it is
if (name == end_name)
{
as_bad (_("expected symbol name"));
- discard_rest_of_line ();
+ ignore_rest_of_line ();
return;
}
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);
/* 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);
projects / binutils.git / blobdiff