X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fconfig%2Ftc-ia64.c;h=f908ba51fa30c893a918780515d5d6eab7180a30;hb=a7e12755d57879884c523cae1cf009efc9da933c;hp=2ac758660ddeab33442abe2d749cfff734f875e0;hpb=cb3b8d911b227c9ae3ab62ba175688721f86f23e;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/config/tc-ia64.c b/gas/config/tc-ia64.c index 2ac758660d..f908ba51fa 100644 --- a/gas/config/tc-ia64.c +++ b/gas/config/tc-ia64.c @@ -1,13 +1,12 @@ /* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture. - Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 - Free Software Foundation, Inc. + Copyright (C) 1998-2020 Free Software Foundation, Inc. Contributed by David Mosberger-Tang This file is part of GAS, the GNU Assembler. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 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, @@ -50,6 +49,8 @@ #include "opcode/ia64.h" #include "elf/ia64.h" +#include "bfdver.h" +#include #ifdef HAVE_LIMITS_H #include @@ -101,6 +102,9 @@ enum reloc_func FUNC_LT_DTP_RELATIVE, FUNC_LT_TP_RELATIVE, FUNC_IPLT_RELOC, +#ifdef TE_VMS + FUNC_SLOTCOUNT_RELOC, +#endif }; enum reg_symbol @@ -109,7 +113,8 @@ enum reg_symbol REG_FR = (REG_GR + 128), REG_AR = (REG_FR + 128), REG_CR = (REG_AR + 128), - REG_P = (REG_CR + 128), + REG_DAHR = (REG_CR + 128), + REG_P = (REG_DAHR + 8), REG_BR = (REG_P + 64), REG_IP = (REG_BR + 8), REG_CFM, @@ -128,6 +133,7 @@ enum reg_symbol IND_PKR, IND_PMC, IND_PMD, + IND_DAHR, IND_RR, /* The following pseudo-registers are used for unwind directives only: */ REG_PSP, @@ -161,20 +167,23 @@ struct label_fix bfd_boolean dw2_mark_labels; }; +#ifdef TE_VMS +/* An internally used relocation. */ +#define DUMMY_RELOC_IA64_SLOTCOUNT (BFD_RELOC_UNUSED + 1) +#endif + /* This is the endianness of the current section. */ extern int target_big_endian; /* 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; @@ -225,9 +234,9 @@ static struct struct hash_control *const_hash; /* constant hash table */ struct hash_control *entry_hash; /* code entry hint hash table */ - /* If X_op is != O_absent, the registername for the instruction's + /* If X_op is != O_absent, the register name for the instruction's qualifying predicate. If NULL, p0 is assumed for instructions - that are predicatable. */ + that are predictable. */ expressionS qp; /* Optimize for which CPU. */ @@ -293,7 +302,7 @@ static struct struct label_fix *tag_fixups; struct unw_rec_list *unwind_record; /* Unwind directive. */ expressionS opnd[6]; - char *src_file; + const char *src_file; unsigned int src_line; struct dwarf2_line_info debug_line; } @@ -366,6 +375,7 @@ static unsigned char le_nop_stop[16] = #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 @@ -389,8 +399,8 @@ ar[] = {"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.pfs", AR_PFS}, {"ar.lc", AR_LC}, - {"ar.ec", AR_EC}, + {"ar.ruc", AR_RUC}, {"ar.pfs", AR_PFS}, + {"ar.lc", AR_LC}, {"ar.ec", AR_EC}, }; /* control registers: */ @@ -409,6 +419,8 @@ ar[] = #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 @@ -442,6 +454,8 @@ cr[] = {"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}, @@ -526,6 +540,7 @@ indirect_reg[] = { "pkr", IND_PKR }, { "pmc", IND_PMC }, { "pmd", IND_PMD }, + { "dahr", IND_DAHR }, { "rr", IND_RR }, }; @@ -570,6 +585,9 @@ pseudo_func[] = { NULL, 0, { 0 } }, /* placeholder for FUNC_LT_DTP_RELATIVE */ { NULL, 0, { 0 } }, /* placeholder for FUNC_LT_TP_RELATIVE */ { "iplt", PSEUDO_FUNC_RELOC, { 0 } }, +#ifdef TE_VMS + { "slotcount", PSEUDO_FUNC_RELOC, { 0 } }, +#endif /* mbtype4 constants: */ { "alt", PSEUDO_FUNC_CONST, { 0xa } }, @@ -593,12 +611,18 @@ pseudo_func[] = /* hint constants: */ { "pause", PSEUDO_FUNC_CONST, { 0x0 } }, + { "priority", PSEUDO_FUNC_CONST, { 0x1 } }, + + /* tf constants: */ + { "clz", PSEUDO_FUNC_CONST, { 32 } }, + { "mpy", PSEUDO_FUNC_CONST, { 33 } }, + { "datahints", PSEUDO_FUNC_CONST, { 34 } }, /* unwind-related constants: */ { "svr4", PSEUDO_FUNC_CONST, { ELFOSABI_NONE } }, { "hpux", PSEUDO_FUNC_CONST, { ELFOSABI_HPUX } }, { "nt", PSEUDO_FUNC_CONST, { 2 } }, /* conflicts w/ELFOSABI_NETBSD */ - { "linux", PSEUDO_FUNC_CONST, { ELFOSABI_LINUX } }, + { "linux", PSEUDO_FUNC_CONST, { ELFOSABI_GNU } }, { "freebsd", PSEUDO_FUNC_CONST, { ELFOSABI_FREEBSD } }, { "openvms", PSEUDO_FUNC_CONST, { ELFOSABI_OPENVMS } }, { "nsk", PSEUDO_FUNC_CONST, { ELFOSABI_NSK } }, @@ -648,7 +672,7 @@ static struct rsrc { int insn_srlz; /* current insn serialization state */ int data_srlz; /* current data serialization state */ int qp_regno; /* qualifying predicate for this usage */ - char *file; /* what file marked this dependency */ + const char *file; /* what file marked this dependency */ unsigned int line; /* what line marked this dependency */ struct mem_offset mem_offset; /* optional memory offset hint */ enum { CMP_NONE, CMP_OR, CMP_AND } cmp_type; /* OR or AND compare? */ @@ -743,7 +767,7 @@ static struct 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; @@ -775,211 +799,26 @@ static struct #define ENCODED_PSP_OFFSET(OFFSET) (((OFFSET) + 16) / 4) -typedef void (*vbyte_func) PARAMS ((int, char *, char *)); +typedef void (*vbyte_func) (int, char *, char *); /* Forward declarations: */ -static void set_section PARAMS ((char *name)); -static unsigned int set_regstack PARAMS ((unsigned int, unsigned int, - unsigned int, unsigned int)); -static void dot_align (int); -static void dot_radix PARAMS ((int)); -static void dot_special_section PARAMS ((int)); -static void dot_proc PARAMS ((int)); -static void dot_fframe PARAMS ((int)); -static void dot_vframe PARAMS ((int)); -static void dot_vframesp PARAMS ((int)); -static void dot_save PARAMS ((int)); -static void dot_restore PARAMS ((int)); -static void dot_restorereg PARAMS ((int)); -static void dot_handlerdata PARAMS ((int)); -static void dot_unwentry PARAMS ((int)); -static void dot_altrp PARAMS ((int)); -static void dot_savemem PARAMS ((int)); -static void dot_saveg PARAMS ((int)); -static void dot_savef PARAMS ((int)); -static void dot_saveb PARAMS ((int)); -static void dot_savegf PARAMS ((int)); -static void dot_spill PARAMS ((int)); -static void dot_spillreg PARAMS ((int)); -static void dot_spillmem PARAMS ((int)); -static void dot_label_state PARAMS ((int)); -static void dot_copy_state PARAMS ((int)); -static void dot_unwabi PARAMS ((int)); -static void dot_personality PARAMS ((int)); -static void dot_body PARAMS ((int)); -static void dot_prologue PARAMS ((int)); -static void dot_endp PARAMS ((int)); -static void dot_template PARAMS ((int)); -static void dot_regstk PARAMS ((int)); -static void dot_rot PARAMS ((int)); -static void dot_byteorder PARAMS ((int)); -static void dot_psr PARAMS ((int)); -static void dot_alias PARAMS ((int)); -static void dot_ln PARAMS ((int)); -static void cross_section PARAMS ((int ref, void (*cons) PARAMS((int)), int ua)); -static void dot_xdata PARAMS ((int)); -static void stmt_float_cons PARAMS ((int)); -static void stmt_cons_ua PARAMS ((int)); -static void dot_xfloat_cons PARAMS ((int)); -static void dot_xstringer PARAMS ((int)); -static void dot_xdata_ua PARAMS ((int)); -static void dot_xfloat_cons_ua PARAMS ((int)); -static void print_prmask PARAMS ((valueT mask)); -static void dot_pred_rel PARAMS ((int)); -static void dot_reg_val PARAMS ((int)); -static void dot_serialize PARAMS ((int)); -static void dot_dv_mode PARAMS ((int)); -static void dot_entry PARAMS ((int)); -static void dot_mem_offset PARAMS ((int)); -static void add_unwind_entry PARAMS((unw_rec_list *, int)); -static symbolS *declare_register PARAMS ((const char *name, unsigned int regnum)); -static void declare_register_set PARAMS ((const char *, unsigned int, unsigned int)); -static unsigned int operand_width PARAMS ((enum ia64_opnd)); -static enum operand_match_result operand_match PARAMS ((const struct ia64_opcode *idesc, - int index, - expressionS *e)); -static int parse_operand PARAMS ((expressionS *, int)); -static struct ia64_opcode * parse_operands PARAMS ((struct ia64_opcode *)); -static void build_insn PARAMS ((struct slot *, bfd_vma *)); -static void emit_one_bundle PARAMS ((void)); -static void fix_insn PARAMS ((fixS *, const struct ia64_operand *, valueT)); -static bfd_reloc_code_real_type ia64_gen_real_reloc_type PARAMS ((struct symbol *sym, - bfd_reloc_code_real_type r_type)); -static void insn_group_break PARAMS ((int, int, int)); -static void mark_resource PARAMS ((struct ia64_opcode *, const struct ia64_dependency *, - struct rsrc *, int depind, int path)); -static void add_qp_mutex PARAMS((valueT mask)); -static void add_qp_imply PARAMS((int p1, int p2)); -static void clear_qp_branch_flag PARAMS((valueT mask)); -static void clear_qp_mutex PARAMS((valueT mask)); -static void clear_qp_implies PARAMS((valueT p1_mask, valueT p2_mask)); -static int has_suffix_p PARAMS((const char *, const char *)); -static void clear_register_values PARAMS ((void)); -static void print_dependency PARAMS ((const char *action, int depind)); -static void instruction_serialization PARAMS ((void)); -static void data_serialization PARAMS ((void)); -static void remove_marked_resource PARAMS ((struct rsrc *)); -static int is_conditional_branch PARAMS ((struct ia64_opcode *)); -static int is_taken_branch PARAMS ((struct ia64_opcode *)); -static int is_interruption_or_rfi PARAMS ((struct ia64_opcode *)); -static int depends_on PARAMS ((int, struct ia64_opcode *)); -static int specify_resource PARAMS ((const struct ia64_dependency *, - struct ia64_opcode *, int, struct rsrc [], int, int)); -static int check_dv PARAMS((struct ia64_opcode *idesc)); -static void check_dependencies PARAMS((struct ia64_opcode *)); -static void mark_resources PARAMS((struct ia64_opcode *)); -static void update_dependencies PARAMS((struct ia64_opcode *)); -static void note_register_values PARAMS((struct ia64_opcode *)); -static int qp_mutex PARAMS ((int, int, int)); -static int resources_match PARAMS ((struct rsrc *, struct ia64_opcode *, int, int, int)); -static void output_vbyte_mem PARAMS ((int, char *, char *)); -static void count_output PARAMS ((int, char *, char *)); -static void output_R1_format PARAMS ((vbyte_func, unw_record_type, int)); -static void output_R2_format PARAMS ((vbyte_func, int, int, unsigned long)); -static void output_R3_format PARAMS ((vbyte_func, unw_record_type, unsigned long)); -static void output_P1_format PARAMS ((vbyte_func, int)); -static void output_P2_format PARAMS ((vbyte_func, int, int)); -static void output_P3_format PARAMS ((vbyte_func, unw_record_type, int)); -static void output_P4_format PARAMS ((vbyte_func, unsigned char *, unsigned long)); -static void output_P5_format PARAMS ((vbyte_func, int, unsigned long)); -static void output_P6_format PARAMS ((vbyte_func, unw_record_type, int)); -static void output_P7_format PARAMS ((vbyte_func, unw_record_type, unsigned long, unsigned long)); -static void output_P8_format PARAMS ((vbyte_func, unw_record_type, unsigned long)); -static void output_P9_format PARAMS ((vbyte_func, int, int)); -static void output_P10_format PARAMS ((vbyte_func, int, int)); -static void output_B1_format PARAMS ((vbyte_func, unw_record_type, unsigned long)); -static void output_B2_format PARAMS ((vbyte_func, unsigned long, unsigned long)); -static void output_B3_format PARAMS ((vbyte_func, unsigned long, unsigned long)); -static void output_B4_format PARAMS ((vbyte_func, unw_record_type, unsigned long)); -static char format_ab_reg PARAMS ((int, int)); -static void output_X1_format PARAMS ((vbyte_func, unw_record_type, int, int, unsigned long, - unsigned long)); -static void output_X2_format PARAMS ((vbyte_func, int, int, int, int, int, unsigned long)); -static void output_X3_format PARAMS ((vbyte_func, unw_record_type, int, int, int, unsigned long, - unsigned long)); -static void output_X4_format PARAMS ((vbyte_func, int, int, int, int, int, int, unsigned long)); -static unw_rec_list *output_endp PARAMS ((void)); -static unw_rec_list *output_prologue PARAMS ((void)); -static unw_rec_list *output_prologue_gr PARAMS ((unsigned int, unsigned int)); -static unw_rec_list *output_body PARAMS ((void)); -static unw_rec_list *output_mem_stack_f PARAMS ((unsigned int)); -static unw_rec_list *output_mem_stack_v PARAMS ((void)); -static unw_rec_list *output_psp_gr PARAMS ((unsigned int)); -static unw_rec_list *output_psp_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_rp_when PARAMS ((void)); -static unw_rec_list *output_rp_gr PARAMS ((unsigned int)); -static unw_rec_list *output_rp_br PARAMS ((unsigned int)); -static unw_rec_list *output_rp_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_rp_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_pfs_when PARAMS ((void)); -static unw_rec_list *output_pfs_gr PARAMS ((unsigned int)); -static unw_rec_list *output_pfs_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_pfs_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_preds_when PARAMS ((void)); -static unw_rec_list *output_preds_gr PARAMS ((unsigned int)); -static unw_rec_list *output_preds_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_preds_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_fr_mem PARAMS ((unsigned int)); -static unw_rec_list *output_frgr_mem PARAMS ((unsigned int, unsigned int)); -static unw_rec_list *output_gr_gr PARAMS ((unsigned int, unsigned int)); -static unw_rec_list *output_gr_mem PARAMS ((unsigned int)); -static unw_rec_list *output_br_mem PARAMS ((unsigned int)); -static unw_rec_list *output_br_gr PARAMS ((unsigned int, unsigned int)); -static unw_rec_list *output_spill_base PARAMS ((unsigned int)); -static unw_rec_list *output_unat_when PARAMS ((void)); -static unw_rec_list *output_unat_gr PARAMS ((unsigned int)); -static unw_rec_list *output_unat_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_unat_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_lc_when PARAMS ((void)); -static unw_rec_list *output_lc_gr PARAMS ((unsigned int)); -static unw_rec_list *output_lc_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_lc_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_fpsr_when PARAMS ((void)); -static unw_rec_list *output_fpsr_gr PARAMS ((unsigned int)); -static unw_rec_list *output_fpsr_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_fpsr_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_priunat_when_gr PARAMS ((void)); -static unw_rec_list *output_priunat_when_mem PARAMS ((void)); -static unw_rec_list *output_priunat_gr PARAMS ((unsigned int)); -static unw_rec_list *output_priunat_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_priunat_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_bsp_when PARAMS ((void)); -static unw_rec_list *output_bsp_gr PARAMS ((unsigned int)); -static unw_rec_list *output_bsp_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_bsp_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_bspstore_when PARAMS ((void)); -static unw_rec_list *output_bspstore_gr PARAMS ((unsigned int)); -static unw_rec_list *output_bspstore_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_bspstore_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_rnat_when PARAMS ((void)); -static unw_rec_list *output_rnat_gr PARAMS ((unsigned int)); -static unw_rec_list *output_rnat_psprel PARAMS ((unsigned int)); -static unw_rec_list *output_rnat_sprel PARAMS ((unsigned int)); -static unw_rec_list *output_unwabi PARAMS ((unsigned long, unsigned long)); -static unw_rec_list *output_epilogue PARAMS ((unsigned long)); -static unw_rec_list *output_label_state PARAMS ((unsigned long)); -static unw_rec_list *output_copy_state PARAMS ((unsigned long)); -static unw_rec_list *output_spill_psprel PARAMS ((unsigned int, unsigned int, unsigned int, - unsigned int)); -static unw_rec_list *output_spill_sprel PARAMS ((unsigned int, unsigned int, unsigned int, - unsigned int)); -static unw_rec_list *output_spill_reg PARAMS ((unsigned int, unsigned int, unsigned int, - unsigned int, unsigned int)); -static void process_one_record PARAMS ((unw_rec_list *, vbyte_func)); -static void process_unw_records PARAMS ((unw_rec_list *, vbyte_func)); -static int calc_record_size PARAMS ((unw_rec_list *)); -static void set_imask PARAMS ((unw_rec_list *, unsigned long, unsigned long, unsigned int)); -static unsigned long slot_index PARAMS ((unsigned long, fragS *, - unsigned long, fragS *, - int)); -static unw_rec_list *optimize_unw_records PARAMS ((unw_rec_list *)); -static void fixup_unw_records PARAMS ((unw_rec_list *, int)); -static int parse_predicate_and_operand PARAMS ((expressionS *, unsigned *, const char *)); -static void convert_expr_to_ab_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int)); -static void convert_expr_to_xy_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int)); -static unsigned int get_saved_prologue_count PARAMS ((unsigned long)); -static void save_prologue_count PARAMS ((unsigned long, unsigned int)); -static void free_saved_prologue_counts PARAMS ((void)); +static void dot_alias (int); +static int parse_operand_and_eval (expressionS *, int); +static void emit_one_bundle (void); +static bfd_reloc_code_real_type ia64_gen_real_reloc_type (struct symbol *, + bfd_reloc_code_real_type); +static void insn_group_break (int, int, int); +static void add_qp_mutex (valueT); +static void add_qp_imply (int, int); +static void clear_qp_mutex (valueT); +static void clear_qp_implies (valueT, valueT); +static void print_dependency (const char *, int); +static void instruction_serialization (void); +static void data_serialization (void); +static void output_R3_format (vbyte_func, unw_record_type, unsigned long); +static void output_B3_format (vbyte_func, unsigned long, unsigned long); +static void output_B4_format (vbyte_func, unw_record_type, unsigned long); +static void free_saved_prologue_counts (void); /* Determine if application register REGNUM resides only in the integer unit (as opposed to the memory unit). */ @@ -990,7 +829,7 @@ ar_is_only_in_integer_unit (int reg) return reg >= 64 && reg <= 111; } -/* Determine if application register REGNUM resides only in the memory +/* Determine if application register REGNUM resides only in the memory unit (as opposed to the integer unit). */ static int ar_is_only_in_memory_unit (int reg) @@ -1004,8 +843,7 @@ ar_is_only_in_memory_unit (int reg) 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; @@ -1017,26 +855,30 @@ set_section (name) /* Map 's' to SHF_IA_64_SHORT. */ -int -ia64_elf_section_letter (letter, ptr_msg) - int letter; - char **ptr_msg; +bfd_vma +ia64_elf_section_letter (int letter, const char **ptr_msg) { if (letter == 's') return SHF_IA_64_SHORT; else if (letter == 'o') return SHF_LINK_ORDER; +#ifdef TE_VMS + else if (letter == 'O') + return SHF_IA_64_VMS_OVERLAID; + else if (letter == 'g') + return SHF_IA_64_VMS_GLOBAL; +#endif - *ptr_msg = _("Bad .section directive: want a,o,s,w,x,M,S,G,T in string"); + *ptr_msg = _("bad .section directive: want a,o,s,w,x,M,S,G,T in string"); return -1; } /* Map SHF_IA_64_SHORT to SEC_SMALL_DATA. */ flagword -ia64_elf_section_flags (flags, attr, type) - flagword flags; - int attr, type ATTRIBUTE_UNUSED; +ia64_elf_section_flags (flagword flags, + bfd_vma attr, + int type ATTRIBUTE_UNUSED) { if (attr & SHF_IA_64_SHORT) flags |= SEC_SMALL_DATA; @@ -1044,9 +886,7 @@ ia64_elf_section_flags (flags, attr, type) } 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)) @@ -1070,8 +910,10 @@ ia64_elf_section_type (str, len) } 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; @@ -1079,12 +921,12 @@ set_regstack (ins, locs, outs, rots) 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; @@ -1099,7 +941,7 @@ set_regstack (ins, locs, outs, rots) } void -ia64_flush_insns () +ia64_flush_insns (void) { struct label_fix *lfix; segT saved_seg; @@ -1131,6 +973,7 @@ ia64_flush_insns () 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; @@ -1179,40 +1022,161 @@ ia64_flush_insns () 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 -ia64_do_align (int nbytes) +void +ia64_cons_align (int nbytes) { - char *saved_input_line_pointer = input_line_pointer; + if (md.auto_align) + { + int log; + for (log = 0; (nbytes & 1) != 1; nbytes >>= 1) + log++; - input_line_pointer = ""; - s_align_bytes (nbytes); - input_line_pointer = saved_input_line_pointer; + do_align (log, NULL, 0, 0); + } } -void -ia64_cons_align (nbytes) - int nbytes; -{ - if (md.auto_align) +#ifdef TE_VMS + +/* .vms_common section, symbol, size, alignment */ + +static void +obj_elf_vms_common (int ignore ATTRIBUTE_UNUSED) +{ + const char *sec_name; + char *sym_name; + char c; + offsetT size; + offsetT cur_size; + offsetT temp; + symbolS *symbolP; + segT current_seg = now_seg; + subsegT current_subseg = now_subseg; + offsetT log_align; + + /* Section name. */ + sec_name = obj_elf_section_name (); + if (sec_name == NULL) + return; + + /* Symbol name. */ + SKIP_WHITESPACE (); + if (*input_line_pointer == ',') + { + input_line_pointer++; + SKIP_WHITESPACE (); + } + else + { + as_bad (_("expected ',' after section name")); + ignore_rest_of_line (); + return; + } + + c = get_symbol_name (&sym_name); + + if (input_line_pointer == sym_name) + { + (void) restore_line_pointer (c); + as_bad (_("expected symbol name")); + ignore_rest_of_line (); + return; + } + + symbolP = symbol_find_or_make (sym_name); + (void) restore_line_pointer (c); + + if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) + && !S_IS_COMMON (symbolP)) + { + as_bad (_("Ignoring attempt to re-define symbol")); + ignore_rest_of_line (); + return; + } + + /* Symbol size. */ + SKIP_WHITESPACE (); + if (*input_line_pointer == ',') + { + input_line_pointer++; + SKIP_WHITESPACE (); + } + else + { + as_bad (_("expected ',' after symbol name")); + ignore_rest_of_line (); + return; + } + + temp = get_absolute_expression (); + size = temp; + size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1; + if (temp != size) + { + as_warn (_("size (%ld) out of range, ignored"), (long) temp); + ignore_rest_of_line (); + return; + } + + /* Alignment. */ + SKIP_WHITESPACE (); + if (*input_line_pointer == ',') + { + input_line_pointer++; + SKIP_WHITESPACE (); + } + else + { + as_bad (_("expected ',' after symbol size")); + ignore_rest_of_line (); + return; + } + + log_align = get_absolute_expression (); + + demand_empty_rest_of_line (); + + obj_elf_change_section + (sec_name, SHT_NOBITS, + SHF_ALLOC | SHF_WRITE | SHF_IA_64_VMS_OVERLAID | SHF_IA_64_VMS_GLOBAL, + 0, NULL, 1, 0); + + S_SET_VALUE (symbolP, 0); + S_SET_SIZE (symbolP, size); + S_SET_EXTERNAL (symbolP); + S_SET_SEGMENT (symbolP, now_seg); + + symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT; + + record_alignment (now_seg, log_align); + + cur_size = bfd_section_size (now_seg); + if ((int) size > cur_size) { - char *saved_input_line_pointer = input_line_pointer; - input_line_pointer = ""; - s_align_bytes (nbytes); - input_line_pointer = saved_input_line_pointer; + char *pfrag + = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL, + (valueT)size - (valueT)cur_size, NULL); + *pfrag = 0; + bfd_set_section_size (now_seg, size); } + + /* Switch back to current segment. */ + subseg_set (current_seg, current_subseg); + +#ifdef md_elf_section_change_hook + md_elf_section_change_hook (); +#endif } +#endif /* TE_VMS */ + /* 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) @@ -1226,20 +1190,16 @@ output_vbyte_mem (count, ptr, comment) /* 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; @@ -1252,17 +1212,14 @@ output_R1_format (f, rtype, rlen) 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; @@ -1276,10 +1233,7 @@ output_R2_format (f, mask, grsave, rlen) } 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]; @@ -1292,16 +1246,14 @@ output_R3_format (f, rtype, rlen) 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); @@ -1309,10 +1261,7 @@ output_P1_format (f, brmask) } 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); @@ -1322,10 +1271,7 @@ output_P2_format (f, brmask, gr) } 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; @@ -1369,7 +1315,7 @@ output_P3_format (f, rtype, reg) 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); @@ -1377,20 +1323,14 @@ output_P3_format (f, rtype, 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); @@ -1403,10 +1343,7 @@ output_P5_format (f, grmask, frmask) } 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; @@ -1414,17 +1351,16 @@ output_P6_format (f, rtype, rmask) 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; @@ -1489,10 +1425,7 @@ output_P7_format (f, rtype, w1, w2) } 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; @@ -1566,10 +1499,7 @@ output_P8_format (f, rtype, t) } 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; @@ -1579,10 +1509,7 @@ output_P9_format (f, grmask, gr) } 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; @@ -1592,10 +1519,7 @@ output_P10_format (f, abi, context) } 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; @@ -1607,17 +1531,14 @@ output_B1_format (f, rtype, label) 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; @@ -1632,10 +1553,7 @@ output_B2_format (f, ecount, t) } 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; @@ -1651,10 +1569,7 @@ output_B3_format (f, ecount, t) } 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; @@ -1668,7 +1583,7 @@ output_B4_format (f, rtype, label) 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); @@ -1676,9 +1591,7 @@ output_B4_format (f, rtype, label) } static char -format_ab_reg (ab, reg) - int ab; - int reg; +format_ab_reg (int ab, int reg) { int ret; ab = (ab & 3); @@ -1688,12 +1601,12 @@ format_ab_reg (ab, reg) } 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; @@ -1703,7 +1616,7 @@ output_X1_format (f, rtype, ab, reg, t, w1) 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); @@ -1711,11 +1624,13 @@ output_X1_format (f, rtype, ab, reg, t, w1) } 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; @@ -1727,13 +1642,13 @@ output_X2_format (f, ab, reg, x, y, treg, t) } 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; @@ -1743,7 +1658,7 @@ output_X3_format (f, rtype, qp, ab, reg, t, w1) 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); @@ -1752,12 +1667,14 @@ output_X3_format (f, rtype, qp, ab, reg, t, w1) } 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; @@ -1779,7 +1696,7 @@ check_pending_save (void) { unw_rec_list *cur, *prev; - as_warn ("Previous .save incomplete"); + as_warn (_("Previous .save incomplete")); for (cur = unwind.list, prev = NULL; cur; ) if (&cur->r.record.p == unwind.pending_saves) { @@ -1824,7 +1741,7 @@ static unw_rec_list * alloc_record (unw_record_type t) { unw_rec_list *ptr; - ptr = xmalloc (sizeof (*ptr)); + ptr = XNEW (unw_rec_list); memset (ptr, 0, sizeof (*ptr)); ptr->slot_number = SLOT_NUM_NOT_SET; ptr->r.type = t; @@ -1835,14 +1752,14 @@ alloc_record (unw_record_type t) 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)); @@ -1850,9 +1767,7 @@ output_prologue () } 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)); @@ -1862,15 +1777,14 @@ output_prologue_gr (saved_mask, reg) } 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; @@ -1878,15 +1792,14 @@ output_mem_stack_f (size) } static unw_rec_list * -output_mem_stack_v () +output_mem_stack_v (void) { unw_rec_list *ptr = alloc_record (mem_stack_v); return ptr; } static unw_rec_list * -output_psp_gr (gr) - unsigned int gr; +output_psp_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (psp_gr); ptr->r.record.p.r.gr = gr; @@ -1894,8 +1807,7 @@ output_psp_gr (gr) } static unw_rec_list * -output_psp_sprel (offset) - unsigned int offset; +output_psp_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (psp_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -1903,15 +1815,14 @@ output_psp_sprel (offset) } static unw_rec_list * -output_rp_when () +output_rp_when (void) { unw_rec_list *ptr = alloc_record (rp_when); return ptr; } static unw_rec_list * -output_rp_gr (gr) - unsigned int gr; +output_rp_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (rp_gr); ptr->r.record.p.r.gr = gr; @@ -1919,8 +1830,7 @@ output_rp_gr (gr) } static unw_rec_list * -output_rp_br (br) - unsigned int br; +output_rp_br (unsigned int br) { unw_rec_list *ptr = alloc_record (rp_br); ptr->r.record.p.r.br = br; @@ -1928,8 +1838,7 @@ output_rp_br (br) } static unw_rec_list * -output_rp_psprel (offset) - unsigned int offset; +output_rp_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (rp_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -1937,8 +1846,7 @@ output_rp_psprel (offset) } static unw_rec_list * -output_rp_sprel (offset) - unsigned int offset; +output_rp_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (rp_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -1946,15 +1854,14 @@ output_rp_sprel (offset) } static unw_rec_list * -output_pfs_when () +output_pfs_when (void) { unw_rec_list *ptr = alloc_record (pfs_when); return ptr; } static unw_rec_list * -output_pfs_gr (gr) - unsigned int gr; +output_pfs_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (pfs_gr); ptr->r.record.p.r.gr = gr; @@ -1962,8 +1869,7 @@ output_pfs_gr (gr) } static unw_rec_list * -output_pfs_psprel (offset) - unsigned int offset; +output_pfs_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (pfs_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -1971,8 +1877,7 @@ output_pfs_psprel (offset) } static unw_rec_list * -output_pfs_sprel (offset) - unsigned int offset; +output_pfs_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (pfs_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -1980,15 +1885,14 @@ output_pfs_sprel (offset) } static unw_rec_list * -output_preds_when () +output_preds_when (void) { unw_rec_list *ptr = alloc_record (preds_when); return ptr; } static unw_rec_list * -output_preds_gr (gr) - unsigned int gr; +output_preds_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (preds_gr); ptr->r.record.p.r.gr = gr; @@ -1996,8 +1900,7 @@ output_preds_gr (gr) } static unw_rec_list * -output_preds_psprel (offset) - unsigned int offset; +output_preds_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (preds_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2005,8 +1908,7 @@ output_preds_psprel (offset) } static unw_rec_list * -output_preds_sprel (offset) - unsigned int offset; +output_preds_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (preds_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2014,8 +1916,7 @@ output_preds_sprel (offset) } static unw_rec_list * -output_fr_mem (mask) - unsigned int mask; +output_fr_mem (unsigned int mask) { unw_rec_list *ptr = alloc_record (fr_mem); unw_rec_list *cur = ptr; @@ -2039,9 +1940,7 @@ output_fr_mem (mask) } static unw_rec_list * -output_frgr_mem (gr_mask, fr_mask) - unsigned int gr_mask; - unsigned int fr_mask; +output_frgr_mem (unsigned int gr_mask, unsigned int fr_mask) { unw_rec_list *ptr = alloc_record (frgr_mem); unw_rec_list *cur = ptr; @@ -2080,9 +1979,7 @@ output_frgr_mem (gr_mask, fr_mask) } 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; @@ -2109,8 +2006,7 @@ output_gr_gr (mask, reg) } static unw_rec_list * -output_gr_mem (mask) - unsigned int mask; +output_gr_mem (unsigned int mask) { unw_rec_list *ptr = alloc_record (gr_mem); unw_rec_list *cur = ptr; @@ -2158,9 +2054,7 @@ output_br_mem (unsigned int mask) } static unw_rec_list * -output_br_gr (mask, reg) - unsigned int mask; - unsigned int reg; +output_br_gr (unsigned int mask, unsigned int reg) { unw_rec_list *ptr = alloc_record (br_gr); unw_rec_list *cur = ptr; @@ -2187,8 +2081,7 @@ output_br_gr (mask, reg) } static unw_rec_list * -output_spill_base (offset) - unsigned int offset; +output_spill_base (unsigned int offset) { unw_rec_list *ptr = alloc_record (spill_base); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2196,15 +2089,14 @@ output_spill_base (offset) } static unw_rec_list * -output_unat_when () +output_unat_when (void) { unw_rec_list *ptr = alloc_record (unat_when); return ptr; } static unw_rec_list * -output_unat_gr (gr) - unsigned int gr; +output_unat_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (unat_gr); ptr->r.record.p.r.gr = gr; @@ -2212,8 +2104,7 @@ output_unat_gr (gr) } static unw_rec_list * -output_unat_psprel (offset) - unsigned int offset; +output_unat_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (unat_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2221,8 +2112,7 @@ output_unat_psprel (offset) } static unw_rec_list * -output_unat_sprel (offset) - unsigned int offset; +output_unat_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (unat_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2230,15 +2120,14 @@ output_unat_sprel (offset) } static unw_rec_list * -output_lc_when () +output_lc_when (void) { unw_rec_list *ptr = alloc_record (lc_when); return ptr; } static unw_rec_list * -output_lc_gr (gr) - unsigned int gr; +output_lc_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (lc_gr); ptr->r.record.p.r.gr = gr; @@ -2246,8 +2135,7 @@ output_lc_gr (gr) } static unw_rec_list * -output_lc_psprel (offset) - unsigned int offset; +output_lc_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (lc_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2255,8 +2143,7 @@ output_lc_psprel (offset) } static unw_rec_list * -output_lc_sprel (offset) - unsigned int offset; +output_lc_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (lc_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2264,15 +2151,14 @@ output_lc_sprel (offset) } static unw_rec_list * -output_fpsr_when () +output_fpsr_when (void) { unw_rec_list *ptr = alloc_record (fpsr_when); return ptr; } static unw_rec_list * -output_fpsr_gr (gr) - unsigned int gr; +output_fpsr_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (fpsr_gr); ptr->r.record.p.r.gr = gr; @@ -2280,8 +2166,7 @@ output_fpsr_gr (gr) } static unw_rec_list * -output_fpsr_psprel (offset) - unsigned int offset; +output_fpsr_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (fpsr_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2289,8 +2174,7 @@ output_fpsr_psprel (offset) } static unw_rec_list * -output_fpsr_sprel (offset) - unsigned int offset; +output_fpsr_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (fpsr_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2298,22 +2182,21 @@ output_fpsr_sprel (offset) } static unw_rec_list * -output_priunat_when_gr () +output_priunat_when_gr (void) { unw_rec_list *ptr = alloc_record (priunat_when_gr); return ptr; } static unw_rec_list * -output_priunat_when_mem () +output_priunat_when_mem (void) { unw_rec_list *ptr = alloc_record (priunat_when_mem); return ptr; } static unw_rec_list * -output_priunat_gr (gr) - unsigned int gr; +output_priunat_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (priunat_gr); ptr->r.record.p.r.gr = gr; @@ -2321,8 +2204,7 @@ output_priunat_gr (gr) } static unw_rec_list * -output_priunat_psprel (offset) - unsigned int offset; +output_priunat_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (priunat_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2330,8 +2212,7 @@ output_priunat_psprel (offset) } static unw_rec_list * -output_priunat_sprel (offset) - unsigned int offset; +output_priunat_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (priunat_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2339,15 +2220,14 @@ output_priunat_sprel (offset) } static unw_rec_list * -output_bsp_when () +output_bsp_when (void) { unw_rec_list *ptr = alloc_record (bsp_when); return ptr; } static unw_rec_list * -output_bsp_gr (gr) - unsigned int gr; +output_bsp_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (bsp_gr); ptr->r.record.p.r.gr = gr; @@ -2355,8 +2235,7 @@ output_bsp_gr (gr) } static unw_rec_list * -output_bsp_psprel (offset) - unsigned int offset; +output_bsp_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (bsp_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2364,8 +2243,7 @@ output_bsp_psprel (offset) } static unw_rec_list * -output_bsp_sprel (offset) - unsigned int offset; +output_bsp_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (bsp_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2373,15 +2251,14 @@ output_bsp_sprel (offset) } static unw_rec_list * -output_bspstore_when () +output_bspstore_when (void) { unw_rec_list *ptr = alloc_record (bspstore_when); return ptr; } static unw_rec_list * -output_bspstore_gr (gr) - unsigned int gr; +output_bspstore_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (bspstore_gr); ptr->r.record.p.r.gr = gr; @@ -2389,8 +2266,7 @@ output_bspstore_gr (gr) } static unw_rec_list * -output_bspstore_psprel (offset) - unsigned int offset; +output_bspstore_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (bspstore_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2398,8 +2274,7 @@ output_bspstore_psprel (offset) } static unw_rec_list * -output_bspstore_sprel (offset) - unsigned int offset; +output_bspstore_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (bspstore_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2407,15 +2282,14 @@ output_bspstore_sprel (offset) } static unw_rec_list * -output_rnat_when () +output_rnat_when (void) { unw_rec_list *ptr = alloc_record (rnat_when); return ptr; } static unw_rec_list * -output_rnat_gr (gr) - unsigned int gr; +output_rnat_gr (unsigned int gr) { unw_rec_list *ptr = alloc_record (rnat_gr); ptr->r.record.p.r.gr = gr; @@ -2423,8 +2297,7 @@ output_rnat_gr (gr) } static unw_rec_list * -output_rnat_psprel (offset) - unsigned int offset; +output_rnat_psprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (rnat_psprel); ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset); @@ -2432,8 +2305,7 @@ output_rnat_psprel (offset) } static unw_rec_list * -output_rnat_sprel (offset) - unsigned int offset; +output_rnat_sprel (unsigned int offset) { unw_rec_list *ptr = alloc_record (rnat_sprel); ptr->r.record.p.off.sp = offset / 4; @@ -2441,9 +2313,7 @@ output_rnat_sprel (offset) } 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; @@ -2476,11 +2346,10 @@ output_copy_state (unsigned long label) } static unw_rec_list * -output_spill_psprel (ab, reg, offset, predicate) - unsigned int ab; - unsigned int reg; - unsigned int offset; - unsigned int predicate; +output_spill_psprel (unsigned int ab, + unsigned int reg, + unsigned int offset, + unsigned int predicate) { unw_rec_list *ptr = alloc_record (predicate ? spill_psprel_p : spill_psprel); ptr->r.record.x.ab = ab; @@ -2491,11 +2360,10 @@ output_spill_psprel (ab, reg, offset, predicate) } static unw_rec_list * -output_spill_sprel (ab, reg, offset, predicate) - unsigned int ab; - unsigned int reg; - unsigned int offset; - unsigned int predicate; +output_spill_sprel (unsigned int ab, + unsigned int reg, + unsigned int offset, + unsigned int predicate) { unw_rec_list *ptr = alloc_record (predicate ? spill_sprel_p : spill_sprel); ptr->r.record.x.ab = ab; @@ -2506,12 +2374,11 @@ output_spill_sprel (ab, reg, offset, predicate) } static unw_rec_list * -output_spill_reg (ab, reg, targ_reg, xy, predicate) - unsigned int ab; - unsigned int reg; - unsigned int targ_reg; - unsigned int xy; - unsigned int predicate; +output_spill_reg (unsigned int ab, + unsigned int reg, + unsigned int targ_reg, + unsigned int xy, + unsigned int predicate) { unw_rec_list *ptr = alloc_record (predicate ? spill_reg_p : spill_reg); ptr->r.record.x.ab = ab; @@ -2526,9 +2393,7 @@ output_spill_reg (ab, reg, targ_reg, xy, predicate) specified function. */ static void -process_one_record (ptr, f) - unw_rec_list *ptr; - vbyte_func f; +process_one_record (unw_rec_list *ptr, vbyte_func f) { unsigned int fr_mask, gr_mask; @@ -2656,7 +2521,7 @@ process_one_record (ptr, f) } 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: @@ -2713,7 +2578,7 @@ process_one_record (ptr, f) ptr->r.record.x.t); break; default: - as_bad ("record_type_not_valid"); + as_bad (_("record_type_not_valid")); break; } } @@ -2721,9 +2586,7 @@ process_one_record (ptr, f) /* 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) @@ -2732,8 +2595,7 @@ process_unw_records (list, f) /* 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); @@ -2773,11 +2635,10 @@ popcount (unsigned x) 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; @@ -2789,8 +2650,7 @@ set_imask (region, regmask, t, type) if (!imask) { imask_size = (region->r.record.r.rlen * 2 + 7) / 8 + 1; - imask = xmalloc (imask_size); - memset (imask, 0, imask_size); + imask = XCNEWVEC (unsigned char, imask_size); region->r.record.r.imask_size = imask_size; region->r.record.r.mask.i = imask; @@ -2802,7 +2662,7 @@ set_imask (region, regmask, t, type) { 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; } @@ -2823,15 +2683,14 @@ set_imask (region, regmask, t, type) containing FIRST_ADDR. If BEFORE_RELAX, then we use worst-case estimates for frag sizes. */ -unsigned long -slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax) - unsigned long slot_addr; - fragS *slot_frag; - unsigned long first_addr; - fragS *first_frag; - int before_relax; +static unsigned long +slot_index (unsigned long slot_addr, + fragS *slot_frag, + unsigned long first_addr, + fragS *first_frag, + int before_relax) { - unsigned long index = 0; + unsigned long s_index = 0; /* First time we are called, the initial address and frag are invalid. */ if (first_addr == 0) @@ -2849,7 +2708,7 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax) /* We can get the final addresses only during and after relaxation. */ if (first_frag->fr_next && first_frag->fr_next->fr_address) - index += 3 * ((first_frag->fr_next->fr_address + s_index += 3 * ((first_frag->fr_next->fr_address - first_frag->fr_address - first_frag->fr_fix) >> 4); } @@ -2862,7 +2721,7 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax) break; case rs_space: - as_fatal ("only constant space allocation is supported"); + as_fatal (_("Only constant space allocation is supported")); break; case rs_align: @@ -2870,24 +2729,25 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax) case rs_align_test: /* Take alignment into account. Assume the worst case before relaxation. */ - index += 3 * ((1 << first_frag->fr_offset) >> 4); + s_index += 3 * ((1 << first_frag->fr_offset) >> 4); break; case rs_org: if (first_frag->fr_symbol) { - as_fatal ("only constant offsets are supported"); + as_fatal (_("Only constant offsets are supported")); break; } + /* Fall through. */ case rs_fill: - index += 3 * (first_frag->fr_offset >> 4); + s_index += 3 * (first_frag->fr_offset >> 4); break; } /* Add in the full size of the frag converted to instruction slots. */ - index += 3 * (first_frag->fr_fix >> 4); + s_index += 3 * (first_frag->fr_fix >> 4); /* Subtract away the initial part before first_addr. */ - index -= (3 * ((first_addr >> 4) - (start_addr >> 4)) + s_index -= (3 * ((first_addr >> 4) - (start_addr >> 4)) + ((first_addr & 0x3) - (start_addr & 0x3))); /* Move to the beginning of the next frag. */ @@ -2899,20 +2759,19 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax) 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."); + as_fatal (_("Section switching in code is not supported.")); } /* Add in the used part of the last frag. */ - index += (3 * ((slot_addr >> 4) - (first_addr >> 4)) + s_index += (3 * ((slot_addr >> 4) - (first_addr >> 4)) + ((slot_addr & 0x3) - (first_addr & 0x3))); - return index; + return s_index; } /* Optimize unwind record directives. */ static unw_rec_list * -optimize_unw_records (list) - unw_rec_list *list; +optimize_unw_records (unw_rec_list *list) { if (!list) return NULL; @@ -2933,9 +2792,7 @@ optimize_unw_records (list) 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; @@ -2944,7 +2801,7 @@ fixup_unw_records (list, before_relax) 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) @@ -3018,7 +2875,7 @@ fixup_unw_records (list, before_relax) 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; @@ -3029,7 +2886,7 @@ fixup_unw_records (list, before_relax) 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.frmask; @@ -3038,7 +2895,7 @@ fixup_unw_records (list, before_relax) 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.grmask; @@ -3047,7 +2904,7 @@ fixup_unw_records (list, before_relax) 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; @@ -3057,7 +2914,7 @@ fixup_unw_records (list, before_relax) 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); @@ -3065,7 +2922,7 @@ fixup_unw_records (list, before_relax) 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); @@ -3104,13 +2961,13 @@ ia64_estimate_size_before_relax (fragS *frag, /* fr_var carries the max_chars that we created the fragment with. We must, of course, have allocated enough memory earlier. */ - assert (frag->fr_var >= size); + gas_assert (frag->fr_var >= size); return frag->fr_fix + size; } /* This function converts a rs_machine_dependent variant frag into a - normal fill frag with the unwind image from the the record list. */ + normal fill frag with the unwind image from the record list. */ void ia64_convert_frag (fragS *frag) { @@ -3135,7 +2992,7 @@ ia64_convert_frag (fragS *frag) /* fr_var carries the max_chars that we created the fragment with. We must, of course, have allocated enough memory earlier. */ - assert (frag->fr_var >= size); + gas_assert (frag->fr_var >= size); /* Initialize the header area. fr_offset is initialized with unwind.personality_routine. */ @@ -3164,6 +3021,10 @@ ia64_convert_frag (fragS *frag) 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; @@ -3172,35 +3033,31 @@ ia64_convert_frag (fragS *frag) } static int -parse_predicate_and_operand (e, qp, po) - expressionS * e; - unsigned * qp; - const char * po; +parse_predicate_and_operand (expressionS *e, unsigned *qp, const char *po) { - int sep = parse_operand (e, ','); + int sep = parse_operand_and_eval (e, ','); *qp = e->X_add_number - REG_P; if (e->X_op != O_register || *qp > 63) { - as_bad ("First operand to .%s must be a predicate", po); + 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); + as_warn (_("Pointless use of p0 as first operand to .%s"), po); if (sep == ',') - sep = parse_operand (e, ','); + sep = parse_operand_and_eval (e, ','); else e->X_op = O_absent; return sep; } static void -convert_expr_to_ab_reg (e, ab, regp, po, n) - const expressionS *e; - unsigned int *ab; - unsigned int *regp; - const char * po; - int n; +convert_expr_to_ab_reg (const expressionS *e, + unsigned int *ab, + unsigned int *regp, + const char *po, + int n) { unsigned int reg = e->X_add_number; @@ -3243,19 +3100,18 @@ convert_expr_to_ab_reg (e, ab, regp, po, n) case REG_AR + AR_LC: *regp = 10; break; default: - as_bad ("Operand %d to .%s must be a preserved register", n, po); + as_bad (_("Operand %d to .%s must be a preserved register"), n, po); break; } } } static void -convert_expr_to_xy_reg (e, xy, regp, po, n) - const expressionS *e; - unsigned int *xy; - unsigned int *regp; - const char * po; - int n; +convert_expr_to_xy_reg (const expressionS *e, + unsigned int *xy, + unsigned int *regp, + const char *po, + int n) { unsigned int reg = e->X_add_number; @@ -3280,7 +3136,7 @@ convert_expr_to_xy_reg (e, xy, regp, po, n) *regp = reg - REG_BR; } else - as_bad ("Operand %d to .%s must be a writable register", n, po); + as_bad (_("Operand %d to .%s must be a writable register"), n, po); } static void @@ -3292,8 +3148,7 @@ dot_align (int arg) } static void -dot_radix (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_radix (int dummy ATTRIBUTE_UNUSED) { char *radix; int ch; @@ -3302,12 +3157,11 @@ dot_radix (dummy) if (is_it_end_of_statement ()) return; - radix = input_line_pointer; - ch = get_symbol_end (); + ch = get_symbol_name (&radix); ia64_canonicalize_symbol_name (radix); if (strcasecmp (radix, "C")) - as_bad ("Radix `%s' unsupported or invalid", radix); - *input_line_pointer = ch; + as_bad (_("Radix `%s' unsupported or invalid"), radix); + (void) restore_line_pointer (ch); demand_empty_rest_of_line (); } @@ -3324,8 +3178,7 @@ dot_loc (int x) /* .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]); } @@ -3337,12 +3190,12 @@ unwind_diagnostic (const char * region, const char *directive) { 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; } @@ -3394,9 +3247,7 @@ in_body (const char *directive) } static void -add_unwind_entry (ptr, sep) - unw_rec_list *ptr; - int sep; +add_unwind_entry (unw_rec_list *ptr, int sep) { if (ptr) { @@ -3417,11 +3268,12 @@ add_unwind_entry (ptr, sep) if (sep == ',') { + char *name; /* Parse a tag permitted for the current directive. */ int ch; SKIP_WHITESPACE (); - ch = get_symbol_end (); + ch = get_symbol_name (&name); /* FIXME: For now, just issue a warning that this isn't implemented. */ { static int warned; @@ -3429,18 +3281,17 @@ add_unwind_entry (ptr, sep) if (!warned) { warned = 1; - as_warn ("Tags on unwind pseudo-ops aren't supported, yet"); + as_warn (_("Tags on unwind pseudo-ops aren't supported, yet")); } } - *input_line_pointer = ch; + (void) restore_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; @@ -3448,19 +3299,18 @@ dot_fframe (dummy) if (!in_prologue ("fframe")) return; - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); if (e.X_op != O_constant) { - as_bad ("First operand to .fframe must be a constant"); + 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; @@ -3469,38 +3319,37 @@ dot_vframe (dummy) if (!in_prologue ("vframe")) return; - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); reg = e.X_add_number - REG_GR; if (e.X_op != O_register || reg > 127) { - as_bad ("First operand to .vframe must be a general register"); + as_bad (_("First operand to .vframe must be a general register")); reg = 0; } 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"); + + (unsigned) popcount (unwind.prologue_mask & -(2 << 1))) + as_warn (_("Operand of .vframe contradicts .prologue")); } static void -dot_vframesp (psp) - int psp; +dot_vframesp (int psp) { expressionS e; int sep; if (psp) - as_warn (".vframepsp is meaningless, assuming .vframesp was meant"); + as_warn (_(".vframepsp is meaningless, assuming .vframesp was meant")); if (!in_prologue ("vframesp")) return; - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); if (e.X_op != O_constant) { - as_bad ("Operand to .vframesp must be a constant (sp-relative offset)"); + as_bad (_("Operand to .vframesp must be a constant (sp-relative offset)")); e.X_add_number = 0; } add_unwind_entry (output_mem_stack_v (), sep); @@ -3508,8 +3357,7 @@ dot_vframesp (psp) } static void -dot_save (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_save (int dummy ATTRIBUTE_UNUSED) { expressionS e1, e2; unsigned reg1, reg2; @@ -3518,23 +3366,23 @@ dot_save (dummy) if (!in_prologue ("save")) return; - sep = parse_operand (&e1, ','); + sep = parse_operand_and_eval (&e1, ','); if (sep == ',') - sep = parse_operand (&e2, ','); + sep = parse_operand_and_eval (&e2, ','); else e2.X_op = O_absent; reg1 = e1.X_add_number; - /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */ + /* Make sure it's a valid ar.xxx reg, OR its br0, aka 'rp'. */ if (e1.X_op != O_register) { - as_bad ("First operand to .save not a register"); + 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"); + as_bad (_("Second operand to .save not a valid register")); reg2 = 0; } switch (reg1) @@ -3564,8 +3412,8 @@ dot_save (dummy) 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"); + + (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); @@ -3576,30 +3424,29 @@ dot_save (dummy) 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"); + 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"); + + (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"); + as_bad (_("First operand to .save not a valid register")); add_unwind_entry (NULL, sep); break; } } static void -dot_restore (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_restore (int dummy ATTRIBUTE_UNUSED) { expressionS e1; unsigned long ecount; /* # of _additional_ regions to pop */ @@ -3608,18 +3455,18 @@ dot_restore (dummy) if (!in_body ("restore")) return; - sep = parse_operand (&e1, ','); + sep = parse_operand_and_eval (&e1, ','); if (e1.X_op != O_register || e1.X_add_number != REG_GR + 12) - as_bad ("First operand to .restore must be stack pointer (sp)"); + as_bad (_("First operand to .restore must be stack pointer (sp)")); if (sep == ',') { expressionS e2; - sep = parse_operand (&e2, ','); + sep = parse_operand_and_eval (&e2, ','); if (e2.X_op != O_constant || e2.X_add_number < 0) { - as_bad ("Second operand to .restore must be a constant >= 0"); + as_bad (_("Second operand to .restore must be a constant >= 0")); e2.X_add_number = 0; } ecount = e2.X_add_number; @@ -3629,7 +3476,7 @@ dot_restore (dummy) 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); ecount = 0; } @@ -3643,8 +3490,7 @@ dot_restore (dummy) } static void -dot_restorereg (pred) - int pred; +dot_restorereg (int pred) { unsigned int qp, ab, reg; expressionS e; @@ -3658,7 +3504,7 @@ dot_restorereg (pred) sep = parse_predicate_and_operand (&e, &qp, po); else { - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); qp = 0; } convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred); @@ -3666,7 +3512,7 @@ dot_restorereg (pred) add_unwind_entry (output_spill_reg (ab, reg, 0, 0, qp), sep); } -static char *special_linkonce_name[] = +static const char *special_linkonce_name[] = { ".gnu.linkonce.ia64unw.", ".gnu.linkonce.ia64unwi." }; @@ -3711,13 +3557,12 @@ start_unwind_section (const segT text_seg, int sec_index) char *sec_name; const char *prefix = special_section_name [sec_index]; const char *suffix; - size_t prefix_len, suffix_len, sec_name_len; sec_text_name = segment_name (text_seg); text_name = sec_text_name; 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; @@ -3735,52 +3580,37 @@ start_unwind_section (const segT text_seg, int sec_index) suffix += sizeof (".gnu.linkonce.t.") - 1; } - prefix_len = strlen (prefix); - suffix_len = strlen (suffix); - sec_name_len = prefix_len + suffix_len; - sec_name = alloca (sec_name_len + 1); - memcpy (sec_name, prefix, prefix_len); - memcpy (sec_name + prefix_len, suffix, suffix_len); - sec_name [sec_name_len] = '\0'; + sec_name = concat (prefix, suffix, NULL); /* Handle COMDAT group. */ if ((text_seg->flags & SEC_LINK_ONCE) != 0 && (elf_section_flags (text_seg) & SHF_GROUP) != 0) { char *section; - size_t len, group_name_len; const char *group_name = elf_group_name (text_seg); if (group_name == NULL) { - as_bad ("Group section `%s' has no group signature", + as_bad (_("Group section `%s' has no group signature"), sec_text_name); ignore_rest_of_line (); + free (sec_name); return; } - /* We have to construct a fake section directive. */ - group_name_len = strlen (group_name); - len = (sec_name_len - + 16 /* ,"aG",@progbits, */ - + group_name_len /* ,group_name */ - + 7); /* ,comdat */ - - section = alloca (len + 1); - memcpy (section, sec_name, sec_name_len); - memcpy (section + sec_name_len, ",\"aG\",@progbits,", 16); - memcpy (section + sec_name_len + 16, group_name, group_name_len); - memcpy (section + len - 7, ",comdat", 7); - section [len] = '\0'; + + /* We have to construct a fake section directive. */ + section = concat (sec_name, ",\"aG\",@progbits,", group_name, ",comdat", NULL); set_section (section); + free (section); } else { set_section (sec_name); - bfd_set_section_flags (stdoutput, now_seg, - SEC_LOAD | SEC_ALLOC | SEC_READONLY); + bfd_set_section_flags (now_seg, SEC_LOAD | SEC_ALLOC | SEC_READONLY); } elf_linked_to_section (now_seg) = text_seg; + free (sec_name); } static void @@ -3831,7 +3661,7 @@ generate_unwind_image (const segT text_seg) /* Set expression which points to start of unwind descriptor area. */ unwind.info = expr_build_dot (); - + frag_var (rs_machine_dependent, size, size, 0, 0, (offsetT) (long) unwind.personality_routine, (char *) list); @@ -3869,8 +3699,7 @@ generate_unwind_image (const segT text_seg) } static void -dot_handlerdata (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_handlerdata (int dummy ATTRIBUTE_UNUSED) { if (!in_procedure ("handlerdata")) return; @@ -3888,8 +3717,7 @@ dot_handlerdata (dummy) } static void -dot_unwentry (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_unwentry (int dummy ATTRIBUTE_UNUSED) { if (!in_procedure ("unwentry")) return; @@ -3898,8 +3726,7 @@ dot_unwentry (dummy) } static void -dot_altrp (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_altrp (int dummy ATTRIBUTE_UNUSED) { expressionS e; unsigned reg; @@ -3907,19 +3734,18 @@ dot_altrp (dummy) if (!in_prologue ("altrp")) return; - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); reg = e.X_add_number - REG_BR; if (e.X_op != O_register || reg > 7) { - as_bad ("First operand to .altrp not a valid branch register"); + 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; @@ -3929,24 +3755,24 @@ dot_savemem (psprel) if (!in_prologue (po)) return; - sep = parse_operand (&e1, ','); + sep = parse_operand_and_eval (&e1, ','); if (sep == ',') - sep = parse_operand (&e2, ','); + sep = parse_operand_and_eval (&e2, ','); else e2.X_op = O_absent; reg1 = e1.X_add_number; val = e2.X_add_number; - /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */ + /* Make sure it's a valid ar.xxx reg, OR its br0, aka 'rp'. */ if (e1.X_op != O_register) { - as_bad ("First operand to .%s not a register", po); + 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); + as_bad (_("Second operand to .%s not a constant"), po); val = 0; } @@ -4013,15 +3839,14 @@ dot_savemem (psprel) : output_priunat_sprel) (val), NOT_A_CHAR); break; default: - as_bad ("First operand to .%s not a valid register", po); + as_bad (_("First operand to .%s not a valid register"), po); add_unwind_entry (NULL, sep); break; } } static void -dot_saveg (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_saveg (int dummy ATTRIBUTE_UNUSED) { expressionS e; unsigned grmask; @@ -4030,14 +3855,14 @@ dot_saveg (dummy) if (!in_prologue ("save.g")) return; - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); grmask = e.X_add_number; if (e.X_op != O_constant || e.X_add_number <= 0 || e.X_add_number > 0xf) { - as_bad ("First operand to .save.g must be a positive 4-bit constant"); + as_bad (_("First operand to .save.g must be a positive 4-bit constant")); grmask = 0; } @@ -4046,16 +3871,16 @@ dot_saveg (dummy) unsigned reg; int n = popcount (grmask); - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); reg = e.X_add_number - REG_GR; if (e.X_op != O_register || reg > 127) { - as_bad ("Second operand to .save.g must be a general 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); + 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); @@ -4065,29 +3890,27 @@ dot_saveg (dummy) } static void -dot_savef (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_savef (int dummy ATTRIBUTE_UNUSED) { expressionS e; if (!in_prologue ("save.f")) return; - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); if (e.X_op != O_constant || e.X_add_number <= 0 || e.X_add_number > 0xfffff) { - as_bad ("Operand to .save.f must be a positive 20-bit constant"); + 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 e; unsigned brmask; @@ -4096,14 +3919,14 @@ dot_saveb (dummy) if (!in_prologue ("save.b")) return; - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); brmask = e.X_add_number; if (e.X_op != O_constant || e.X_add_number <= 0 || e.X_add_number > 0x1f) { - as_bad ("First operand to .save.b must be a positive 5-bit constant"); + as_bad (_("First operand to .save.b must be a positive 5-bit constant")); brmask = 0; } @@ -4112,16 +3935,16 @@ dot_saveb (dummy) unsigned reg; int n = popcount (brmask); - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); reg = e.X_add_number - REG_GR; if (e.X_op != O_register || reg > 127) { - as_bad ("Second operand to .save.b must be a general register"); + 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); + 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, reg), 0); @@ -4131,16 +3954,15 @@ dot_saveb (dummy) } static void -dot_savegf (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_savegf (int dummy ATTRIBUTE_UNUSED) { expressionS e1, e2; if (!in_prologue ("save.gf")) return; - if (parse_operand (&e1, ',') == ',') - parse_operand (&e2, 0); + if (parse_operand_and_eval (&e1, ',') == ',') + parse_operand_and_eval (&e2, 0); else e2.X_op = O_absent; @@ -4148,7 +3970,7 @@ dot_savegf (dummy) || e1.X_add_number < 0 || e1.X_add_number > 0xf) { - as_bad ("First operand to .save.gf must be a non-negative 4-bit constant"); + 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; } @@ -4156,7 +3978,7 @@ dot_savegf (dummy) || e2.X_add_number < 0 || e2.X_add_number > 0xfffff) { - as_bad ("Second operand to .save.gf must be a non-negative 20-bit constant"); + 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; } @@ -4164,33 +3986,31 @@ dot_savegf (dummy) && 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"); + as_bad (_("Operands to .save.gf may not be both zero")); add_unwind_entry (output_frgr_mem (e1.X_add_number, e2.X_add_number), 0); } static void -dot_spill (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_spill (int dummy ATTRIBUTE_UNUSED) { expressionS e; if (!in_prologue ("spill")) return; - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); if (e.X_op != O_constant) { - as_bad ("Operand to .spill must be a constant"); + as_bad (_("Operand to .spill must be a constant")); e.X_add_number = 0; } add_unwind_entry (output_spill_base (e.X_add_number), 0); } static void -dot_spillreg (pred) - int pred; +dot_spillreg (int pred) { int sep; unsigned int qp, ab, xy, reg, treg; @@ -4204,13 +4024,13 @@ dot_spillreg (pred) sep = parse_predicate_and_operand (&e, &qp, po); else { - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); qp = 0; } convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred); if (sep == ',') - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); else e.X_op = O_absent; convert_expr_to_xy_reg (&e, &xy, &treg, po, 2 + pred); @@ -4219,8 +4039,7 @@ dot_spillreg (pred) } static void -dot_spillmem (psprel) - int psprel; +dot_spillmem (int psprel) { expressionS e; int pred = (psprel < 0), sep; @@ -4242,18 +4061,18 @@ dot_spillmem (psprel) sep = parse_predicate_and_operand (&e, &qp, po); else { - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); qp = 0; } convert_expr_to_ab_reg (&e, &ab, ®, po, 1 + pred); if (sep == ',') - sep = parse_operand (&e, ','); + sep = parse_operand_and_eval (&e, ','); else e.X_op = O_absent; if (e.X_op != O_constant) { - as_bad ("Operand %d to .%s must be a constant", 2 + pred, po); + as_bad (_("Operand %d to .%s must be a constant"), 2 + pred, po); e.X_add_number = 0; } @@ -4264,8 +4083,7 @@ dot_spillmem (psprel) } 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; @@ -4275,14 +4093,12 @@ get_saved_prologue_count (lbl) 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; @@ -4293,7 +4109,7 @@ save_prologue_count (lbl, count) lpc->prologue_count = count; else { - label_prologue_count *new_lpc = xmalloc (sizeof (* new_lpc)); + label_prologue_count *new_lpc = XNEW (label_prologue_count); new_lpc->next = unwind.saved_prologue_counts; new_lpc->label_number = lbl; @@ -4303,7 +4119,7 @@ save_prologue_count (lbl, count) } static void -free_saved_prologue_counts () +free_saved_prologue_counts (void) { label_prologue_count *lpc = unwind.saved_prologue_counts; label_prologue_count *next; @@ -4319,48 +4135,45 @@ free_saved_prologue_counts () } static void -dot_label_state (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_label_state (int dummy ATTRIBUTE_UNUSED) { expressionS e; if (!in_body ("label_state")) return; - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); if (e.X_op == O_constant) save_prologue_count (e.X_add_number, unwind.prologue_count); else { - as_bad ("Operand to .label_state must be a constant"); + 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), 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, 0); + parse_operand_and_eval (&e, 0); if (e.X_op == O_constant) unwind.prologue_count = get_saved_prologue_count (e.X_add_number); else { - as_bad ("Operand to .copy_state must be a constant"); + 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), 0); } static void -dot_unwabi (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_unwabi (int dummy ATTRIBUTE_UNUSED) { expressionS e1, e2; unsigned char sep; @@ -4368,21 +4181,21 @@ dot_unwabi (dummy) if (!in_prologue ("unwabi")) return; - sep = parse_operand (&e1, ','); + sep = parse_operand_and_eval (&e1, ','); if (sep == ',') - parse_operand (&e2, 0); + parse_operand_and_eval (&e2, 0); else e2.X_op = O_absent; if (e1.X_op != O_constant) { - as_bad ("First operand to .unwabi must be a constant"); + 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"); + as_bad (_("Second operand to .unwabi must be a constant")); e2.X_add_number = 0; } @@ -4390,26 +4203,24 @@ dot_unwabi (dummy) } static void -dot_personality (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_personality (int dummy ATTRIBUTE_UNUSED) { char *name, *p, c; + if (!in_procedure ("personality")) return; SKIP_WHITESPACE (); - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (&name); p = input_line_pointer; unwind.personality_routine = symbol_find_or_make (name); unwind.force_unwind_entry = 1; *p = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); demand_empty_rest_of_line (); } static void -dot_proc (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_proc (int dummy ATTRIBUTE_UNUSED) { char *name, *p, c; symbolS *sym; @@ -4419,7 +4230,7 @@ dot_proc (dummy) { (md.unwind_check == unwind_check_warning ? as_warn - : as_bad) ("Missing .endp after previous .proc"); + : as_bad) (_("Missing .endp after previous .proc")); while (unwind.proc_pending.next) { pending = unwind.proc_pending.next; @@ -4434,16 +4245,15 @@ dot_proc (dummy) while (1) { SKIP_WHITESPACE (); - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (&name); 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); + as_bad (_("`%s' was already defined"), name); else if (!last_pending) { unwind.proc_pending.sym = sym; @@ -4451,14 +4261,14 @@ dot_proc (dummy) } else { - pending = xmalloc (sizeof (*pending)); + pending = XNEW (proc_pending); pending->sym = sym; last_pending = last_pending->next = pending; } symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION; } *p = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != ',') break; ++input_line_pointer; @@ -4470,7 +4280,7 @@ dot_proc (dummy) } last_pending->next = NULL; demand_empty_rest_of_line (); - ia64_do_align (16); + do_align (4, NULL, 0, 0); unwind.prologue = 0; unwind.prologue_count = 0; @@ -4481,13 +4291,12 @@ dot_proc (dummy) } 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; @@ -4498,8 +4307,7 @@ dot_body (dummy) } static void -dot_prologue (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_prologue (int dummy ATTRIBUTE_UNUSED) { unsigned mask = 0, grsave = 0; @@ -4507,52 +4315,53 @@ dot_prologue (dummy) 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 e; - int n, sep = parse_operand (&e, ','); + int n, sep = parse_operand_and_eval (&e, ','); if (e.X_op != O_constant || e.X_add_number < 0 || e.X_add_number > 0xf) - as_bad ("First operand to .prologue must be a positive 4-bit constant"); + 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"); + as_warn (_("Pointless use of zero first operand to .prologue")); else mask = e.X_add_number; - n = popcount (mask); + + n = popcount (mask); if (sep == ',') - parse_operand (&e, 0); + parse_operand_and_eval (&e, 0); else e.X_op = O_absent; + if (e.X_op == O_constant && 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"); + 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"); + 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); + as_bad (_("Second operand to .prologue must be the first of %d general registers"), n); grsave = 0; } - } if (mask) @@ -4568,8 +4377,7 @@ dot_prologue (dummy) } static void -dot_endp (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_endp (int dummy ATTRIBUTE_UNUSED) { expressionS e; int bytes_per_address; @@ -4632,14 +4440,15 @@ dot_endp (dummy) symbol_get_frag (unwind.proc_pending.sym)); else e.X_add_symbol = unwind.proc_pending.sym; - ia64_cons_fix_new (frag_now, where, bytes_per_address, &e); + ia64_cons_fix_new (frag_now, where, bytes_per_address, &e, + BFD_RELOC_NONE); e.X_op = O_pseudo_fixup; e.X_op_symbol = pseudo_func[FUNC_SEG_RELATIVE].u.sym; e.X_add_number = 0; e.X_add_symbol = proc_end; ia64_cons_fix_new (frag_now, where + bytes_per_address, - bytes_per_address, &e); + bytes_per_address, &e, BFD_RELOC_NONE); if (unwind.info) { @@ -4648,7 +4457,7 @@ dot_endp (dummy) e.X_add_number = 0; e.X_add_symbol = unwind.info; ia64_cons_fix_new (frag_now, where + (bytes_per_address * 2), - bytes_per_address, &e); + bytes_per_address, &e, BFD_RELOC_NONE); } } subseg_set (saved_seg, saved_subseg); @@ -4662,7 +4471,7 @@ dot_endp (dummy) symbolS *sym = pending->sym; if (!S_IS_DEFINED (sym)) - as_bad ("`%s' was not defined within procedure", S_GET_NAME (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) { @@ -4674,8 +4483,7 @@ dot_endp (dummy) S_SET_SIZE (sym, frag_now_fix () - S_GET_VALUE (sym)); else { - symbol_get_obj (sym)->size = - (expressionS *) xmalloc (sizeof (expressionS)); + symbol_get_obj (sym)->size = XNEW (expressionS); symbol_get_obj (sym)->size->X_op = O_subtract; symbol_get_obj (sym)->size->X_add_symbol = symbol_new (FAKE_LABEL_NAME, now_seg, @@ -4694,13 +4502,12 @@ dot_endp (dummy) char *name, *p, c; SKIP_WHITESPACE (); - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (&name); p = input_line_pointer; if (!*name) (md.unwind_check == unwind_check_warning ? as_warn - : as_bad) ("Empty argument of .endp"); + : as_bad) (_("Empty argument of .endp")); else { symbolS *sym = symbol_find (name); @@ -4714,10 +4521,10 @@ dot_endp (dummy) } } if (!sym || !pending) - as_warn ("`%s' was not specified with previous .proc", name); + as_warn (_("`%s' was not specified with previous .proc"), name); } *p = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != ',') break; ++input_line_pointer; @@ -4729,7 +4536,7 @@ dot_endp (dummy) 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", + as_warn (_("`%s' should be an operand to this .endp"), S_GET_NAME (unwind.proc_pending.sym)); while (unwind.proc_pending.next) { @@ -4741,15 +4548,13 @@ dot_endp (dummy) } static void -dot_template (template) - int template; +dot_template (int template_val) { - CURR_SLOT.user_template = template; + CURR_SLOT.user_template = template_val; } static void -dot_regstk (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_regstk (int dummy ATTRIBUTE_UNUSED) { int ins, locs, outs, rots; @@ -4772,13 +4577,12 @@ dot_regstk (dummy) 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) { offsetT num_regs; valueT num_alloced = 0; @@ -4798,7 +4602,7 @@ dot_rot (type) /* 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; } @@ -4806,15 +4610,14 @@ dot_rot (type) drpp = &md.dynreg[type]; while (1) { - start = input_line_pointer; - ch = get_symbol_end (); + ch = get_symbol_name (&start); len = strlen (ia64_canonicalize_symbol_name (start)); *input_line_pointer = ch; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != '[') { - as_bad ("Expected '['"); + as_bad (_("Expected '['")); goto err; } ++input_line_pointer; /* skip '[' */ @@ -4823,12 +4626,12 @@ dot_rot (type) if (*input_line_pointer++ != ']') { - as_bad ("Expected ']'"); + as_bad (_("Expected ']'")); goto err; } if (num_regs <= 0) { - as_bad ("Number of elements must be positive"); + as_bad (_("Number of elements must be positive")); goto err; } SKIP_WHITESPACE (); @@ -4839,7 +4642,7 @@ dot_rot (type) 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; } @@ -4847,14 +4650,14 @@ dot_rot (type) 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; @@ -4865,11 +4668,11 @@ dot_rot (type) if (!*drpp) { - *drpp = obstack_alloc (¬es, sizeof (*dr)); + *drpp = XOBNEW (¬es, struct dynreg); memset (*drpp, 0, sizeof (*dr)); } - name = obstack_alloc (¬es, len + 1); + name = XOBNEWVEC (¬es, char, len + 1); memcpy (name, start, len); name[len] = '\0'; @@ -4882,7 +4685,7 @@ dot_rot (type) 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; } @@ -4900,8 +4703,7 @@ dot_rot (type) } static void -dot_byteorder (byteorder) - int byteorder; +dot_byteorder (int byteorder) { segment_info_type *seginfo = seg_info (now_seg); @@ -4931,16 +4733,14 @@ dot_byteorder (byteorder) } static void -dot_psr (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_psr (int dummy ATTRIBUTE_UNUSED) { char *option; int ch; while (1) { - option = input_line_pointer; - ch = get_symbol_end (); + ch = get_symbol_name (&option); if (strcmp (option, "lsb") == 0) md.flags &= ~EF_IA_64_BE; else if (strcmp (option, "msb") == 0) @@ -4950,10 +4750,10 @@ dot_psr (dummy) 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 (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != ',') break; @@ -4964,55 +4764,36 @@ dot_psr (dummy) } static void -dot_ln (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_ln (int dummy ATTRIBUTE_UNUSED) { new_logical_line (0, get_absolute_expression ()); demand_empty_rest_of_line (); } static void -cross_section (ref, cons, ua) - int ref; - void (*cons) PARAMS((int)); - int ua; +cross_section (int ref, void (*builder) (int), int ua) { char *start, *end; int saved_auto_align; unsigned int section_count; + char *name; + char c; SKIP_WHITESPACE (); start = input_line_pointer; - if (*start == '"') + c = get_symbol_name (&name); + if (input_line_pointer == start) { - int len; - char *name; - - name = demand_copy_C_string (&len); - obstack_free(¬es, name); - if (!name) - { - ignore_rest_of_line (); - return; - } - } - else - { - char c = get_symbol_end (); - - if (input_line_pointer == start) - { - as_bad ("Missing section name"); - ignore_rest_of_line (); - return; - } - *input_line_pointer = c; + as_bad (_("Missing section name")); + ignore_rest_of_line (); + return; } + * input_line_pointer = c; + SKIP_WHITESPACE_AFTER_NAME (); end = input_line_pointer; - 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; } @@ -5020,15 +4801,15 @@ cross_section (ref, cons, ua) end = input_line_pointer + 1; /* skip comma */ input_line_pointer = start; md.keep_pending_output = 1; - section_count = bfd_count_sections(stdoutput); + section_count = bfd_count_sections (stdoutput); obj_elf_section (0); - if (section_count != bfd_count_sections(stdoutput)) - as_warn ("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated."); + if (section_count != bfd_count_sections (stdoutput)) + as_warn (_("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated.")); input_line_pointer = end; saved_auto_align = md.auto_align; if (ua) md.auto_align = 0; - (*cons) (ref); + (*builder) (ref); if (ua) md.auto_align = saved_auto_align; obj_elf_previous (0); @@ -5036,8 +4817,7 @@ cross_section (ref, cons, ua) } static void -dot_xdata (size) - int size; +dot_xdata (int size) { cross_section (size, cons, 0); } @@ -5045,34 +4825,32 @@ dot_xdata (size) /* 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; switch (kind) { case 'd': - alignment = 8; + alignment = 3; break; case 'x': case 'X': - alignment = 16; + alignment = 4; break; case 'f': default: - alignment = 4; + alignment = 2; break; } - ia64_do_align (alignment); + do_align (alignment, NULL, 0, 0); float_cons (kind); } static void -stmt_cons_ua (size) - int size; +stmt_cons_ua (int size) { int saved_auto_align = md.auto_align; @@ -5082,29 +4860,25 @@ stmt_cons_ua (size) } 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); } @@ -5112,8 +4886,7 @@ dot_xfloat_cons_ua (kind) /* .reg.val ,value */ static void -dot_reg_val (dummy) - int dummy ATTRIBUTE_UNUSED; +dot_reg_val (int dummy ATTRIBUTE_UNUSED) { expressionS reg; @@ -5149,8 +4922,7 @@ dot_reg_val (dummy) .serialize.instruction */ static void -dot_serialize (type) - int type; +dot_serialize (int type) { insn_group_break (0, 0, 0); if (type) @@ -5170,8 +4942,7 @@ dot_serialize (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")); @@ -5207,11 +4978,10 @@ dot_dv_mode (type) } static void -print_prmask (mask) - valueT mask; +print_prmask (valueT mask) { int regno; - char *comma = ""; + const char *comma = ""; for (regno = 0; regno < 64; regno++) { if (mask & ((valueT) 1 << regno)) @@ -5230,8 +5000,7 @@ print_prmask (mask) */ static void -dot_pred_rel (type) - int type; +dot_pred_rel (int type) { valueT mask = 0; int count = 0; @@ -5254,8 +5023,11 @@ dot_pred_rel (type) } else if (*input_line_pointer == '@') { - char *form = ++input_line_pointer; - char c = get_symbol_end(); + char *form; + char c; + + ++input_line_pointer; + c = get_symbol_name (&form); if (strcmp (form, "mutex") == 0) type = 'm'; @@ -5263,7 +5035,7 @@ dot_pred_rel (type) type = 'c'; else if (strcmp (form, "imply") == 0) type = 'i'; - *input_line_pointer = c; + (void) restore_line_pointer (c); } else { @@ -5282,14 +5054,13 @@ dot_pred_rel (type) SKIP_WHITESPACE (); } - SKIP_WHITESPACE (); while (1) { valueT bits = 1; - int regno; + int sep, regno; expressionS pr, *pr1, *pr2; - expression_and_evaluate (&pr); + sep = parse_operand_and_eval (&pr, ','); if (pr.X_op == O_register && pr.X_add_number >= REG_P && pr.X_add_number <= REG_P + 63) @@ -5336,10 +5107,8 @@ dot_pred_rel (type) 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) @@ -5395,8 +5164,7 @@ dot_pred_rel (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; @@ -5405,17 +5173,16 @@ dot_entry (dummy) do { - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (&name); 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); *input_line_pointer = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); c = *input_line_pointer; if (c == ',') { @@ -5434,8 +5201,7 @@ dot_entry (dummy) "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 (); @@ -5530,8 +5296,8 @@ const pseudo_typeS md_pseudo_table[] = { "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 }, @@ -5567,6 +5333,10 @@ const pseudo_typeS md_pseudo_table[] = {"4byte", stmt_cons_ua, 4}, {"8byte", stmt_cons_ua, 8}, +#ifdef TE_VMS + {"vms_common", obj_elf_vms_common, 0}, +#endif + { NULL, 0, 0 } }; @@ -5588,8 +5358,8 @@ pseudo_opcode[] = { "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 }, @@ -5606,16 +5376,14 @@ pseudo_opcode[] = the symbol table. */ static symbolS * -declare_register (name, regnum) - const char *name; - unsigned int regnum; +declare_register (const char *name, unsigned int regnum) { const char *err; symbolS *sym; sym = symbol_create (name, reg_section, regnum, &zero_address_frag); - err = hash_insert (md.reg_hash, S_GET_NAME (sym), (PTR) sym); + err = hash_insert (md.reg_hash, S_GET_NAME (sym), (void *) sym); if (err) as_fatal ("Inserting \"%s\" into register table failed: %s", name, err); @@ -5624,24 +5392,22 @@ declare_register (name, regnum) } static void -declare_register_set (prefix, num_regs, base_regnum) - const char *prefix; - unsigned int num_regs; - unsigned int base_regnum; +declare_register_set (const char *prefix, + unsigned int num_regs, + unsigned int base_regnum) { char name[8]; unsigned int i; 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; @@ -5655,12 +5421,9 @@ operand_width (opnd) } static enum operand_match_result -operand_match (idesc, index, e) - const struct ia64_opcode *idesc; - int index; - expressionS *e; +operand_match (const struct ia64_opcode *idesc, int res_index, expressionS *e) { - enum ia64_opnd opnd = idesc->operands[index]; + enum ia64_opnd opnd = idesc->operands[res_index]; int bits, relocatable = 0; struct insn_fix *fix; bfd_signed_vma val; @@ -5770,6 +5533,12 @@ operand_match (idesc, index, e) return OPERAND_MATCH; break; + case IA64_OPND_DAHR3: + if (e->X_op == O_register && e->X_add_number >= REG_DAHR + && e->X_add_number < REG_DAHR + 8) + return OPERAND_MATCH; + break; + case IA64_OPND_F1: case IA64_OPND_F2: case IA64_OPND_F3: @@ -5814,6 +5583,7 @@ operand_match (idesc, index, e) case IA64_OPND_PKR_R3: case IA64_OPND_PMC_R3: case IA64_OPND_PMD_R3: + case IA64_OPND_DAHR_R3: case IA64_OPND_RR_R3: if (e->X_op == O_index && e->X_op_symbol && (S_GET_VALUE (e->X_op_symbol) - IND_CPUID @@ -5830,7 +5600,7 @@ operand_match (idesc, index, e) case IA64_OPND_CNT2a: case IA64_OPND_LEN4: case IA64_OPND_LEN6: - bits = operand_width (idesc->operands[index]); + bits = operand_width (idesc->operands[res_index]); if (e->X_op == O_constant) { if ((bfd_vma) (e->X_add_number - 1) < ((bfd_vma) 1 << bits)) @@ -5865,6 +5635,7 @@ operand_match (idesc, index, e) /* SOR must be an integer multiple of 8 */ if (e->X_op == O_constant && e->X_add_number & 0x7) return OPERAND_OUT_OF_RANGE; + /* Fall through. */ case IA64_OPND_SOF: case IA64_OPND_SOL: if (e->X_op == O_constant) @@ -5904,7 +5675,7 @@ operand_match (idesc, index, e) e->X_op = O_symbol; } - fix->opnd = idesc->operands[index]; + fix->opnd = idesc->operands[res_index]; fix->expr = *e; fix->is_pcrel = 0; ++CURR_SLOT.num_fixups; @@ -5914,6 +5685,17 @@ operand_match (idesc, index, e) 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: @@ -5923,12 +5705,14 @@ operand_match (idesc, index, e) case IA64_OPND_IMMU2: case IA64_OPND_IMMU7a: case IA64_OPND_IMMU7b: + case IA64_OPND_IMMU16: + case IA64_OPND_IMMU19: case IA64_OPND_IMMU21: case IA64_OPND_IMMU24: case IA64_OPND_MBTYPE4: case IA64_OPND_MHTYPE8: case IA64_OPND_POS6: - bits = operand_width (idesc->operands[index]); + bits = operand_width (idesc->operands[res_index]); if (e->X_op == O_constant) { if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits)) @@ -5939,7 +5723,7 @@ operand_match (idesc, index, e) break; case IA64_OPND_IMMU9: - bits = operand_width (idesc->operands[index]); + bits = operand_width (idesc->operands[res_index]); if (e->X_op == O_constant) { if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits)) @@ -6007,6 +5791,7 @@ operand_match (idesc, index, e) case IA64_OPND_IMM14: case IA64_OPND_IMM22: relocatable = 1; + /* Fall through. */ case IA64_OPND_IMM1: case IA64_OPND_IMM8: case IA64_OPND_IMM8U4: @@ -6015,14 +5800,14 @@ operand_match (idesc, index, e) case IA64_OPND_IMM8M1U8: case IA64_OPND_IMM9a: case IA64_OPND_IMM9b: - bits = operand_width (idesc->operands[index]); + bits = operand_width (idesc->operands[res_index]); if (relocatable && (e->X_op == O_symbol || e->X_op == O_subtract || e->X_op == O_pseudo_fixup)) { fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups; - if (idesc->operands[index] == IA64_OPND_IMM14) + if (idesc->operands[res_index] == IA64_OPND_IMM14) fix->code = BFD_RELOC_IA64_IMM14; else fix->code = BFD_RELOC_IA64_IMM22; @@ -6034,7 +5819,7 @@ operand_match (idesc, index, e) e->X_op = O_symbol; } - fix->opnd = idesc->operands[index]; + fix->opnd = idesc->operands[res_index]; fix->expr = *e; fix->is_pcrel = 0; ++CURR_SLOT.num_fixups; @@ -6054,9 +5839,8 @@ operand_match (idesc, index, e) /* Sign-extend 32-bit unsigned numbers, so that the following range checks will work. */ val = e->X_add_number; - if (((val & (~(bfd_vma) 0 << 32)) == 0) - && ((val & ((bfd_vma) 1 << 31)) != 0)) - val = ((val << 32) >> 32); + if ((val & (~(bfd_vma) 0 << 32)) == 0) + val = (val ^ ((bfd_vma) 1 << 31)) - ((bfd_vma) 1 << 31); /* Check for 0x100000000. This is valid because 0x100000000-1 is the same as ((uint32_t) -1). */ @@ -6094,9 +5878,8 @@ operand_match (idesc, index, e) /* Sign-extend 32-bit unsigned numbers, so that the following range checks will work. */ val = e->X_add_number; - if (((val & (~(bfd_vma) 0 << 32)) == 0) - && ((val & ((bfd_vma) 1 << 31)) != 0)) - val = ((val << 32) >> 32); + if ((val & (~(bfd_vma) 0 << 32)) == 0) + val = (val ^ ((bfd_vma) 1 << 31)) - ((bfd_vma) 1 << 31); } else val = e->X_add_number; @@ -6140,12 +5923,13 @@ operand_match (idesc, index, e) abort (); fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code); - fix->opnd = idesc->operands[index]; + fix->opnd = idesc->operands[res_index]; fix->expr = *e; fix->is_pcrel = 1; ++CURR_SLOT.num_fixups; return OPERAND_MATCH; } + /* Fall through. */ case IA64_OPND_TAG13: case IA64_OPND_TAG13b: switch (e->X_op) @@ -6159,7 +5943,7 @@ operand_match (idesc, index, e) create a dummy reloc. This will not live past md_apply_fix. */ fix->code = BFD_RELOC_UNUSED; fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code); - fix->opnd = idesc->operands[index]; + fix->opnd = idesc->operands[res_index]; fix->expr = *e; fix->is_pcrel = 1; ++CURR_SLOT.num_fixups; @@ -6173,12 +5957,45 @@ operand_match (idesc, index, e) case IA64_OPND_LDXMOV: fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups; fix->code = BFD_RELOC_IA64_LDXMOV; - fix->opnd = idesc->operands[index]; + fix->opnd = idesc->operands[res_index]; fix->expr = *e; fix->is_pcrel = 0; ++CURR_SLOT.num_fixups; return OPERAND_MATCH; + case IA64_OPND_STRD5b: + if (e->X_op == O_constant) + { + /* 5-bit signed scaled by 64 */ + if ((e->X_add_number <= ( 0xf << 6 )) + && (e->X_add_number >= -( 0x10 << 6 ))) + { + + /* Must be a multiple of 64 */ + if ((e->X_add_number & 0x3f) != 0) + as_warn (_("stride must be a multiple of 64; lower 6 bits ignored")); + + e->X_add_number &= ~ 0x3f; + return OPERAND_MATCH; + } + else + return OPERAND_OUT_OF_RANGE; + } + break; + case IA64_OPND_CNT6a: + if (e->X_op == O_constant) + { + /* 6-bit unsigned biased by 1 -- count 0 is meaningless */ + if ((e->X_add_number <= 64) + && (e->X_add_number > 0) ) + { + return OPERAND_MATCH; + } + else + return OPERAND_OUT_OF_RANGE; + } + break; + default: break; } @@ -6186,22 +6003,52 @@ operand_match (idesc, index, e) } static int -parse_operand (e, more) - expressionS *e; - int more; +parse_operand (expressionS *e, int more) { int sep = '\0'; memset (e, 0, sizeof (*e)); e->X_op = O_absent; SKIP_WHITESPACE (); - expression_and_evaluate (e); + expression (e); sep = *input_line_pointer; if (more && (sep == ',' || sep == more)) ++input_line_pointer; return sep; } +static int +parse_operand_and_eval (expressionS *e, int more) +{ + int sep = parse_operand (e, more); + resolve_expression (e); + return sep; +} + +static int +parse_operand_maybe_eval (expressionS *e, int more, enum ia64_opnd op) +{ + int sep = parse_operand (e, more); + switch (op) + { + case IA64_OPND_IMM14: + case IA64_OPND_IMM22: + case IA64_OPND_IMMU64: + case IA64_OPND_TGT25: + case IA64_OPND_TGT25b: + case IA64_OPND_TGT25c: + case IA64_OPND_TGT64: + case IA64_OPND_TAG13: + case IA64_OPND_TAG13b: + case IA64_OPND_LDXMOV: + break; + default: + resolve_expression (e); + break; + } + return sep; +} + /* Returns the next entry in the opcode table that matches the one in IDESC, and frees the entry in IDESC. If no matching entry is found, NULL is returned instead. */ @@ -6218,8 +6065,7 @@ get_next_opcode (struct ia64_opcode *idesc) 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; @@ -6231,7 +6077,7 @@ parse_operands (idesc) char *first_arg = 0, *end, *saved_input_pointer; unsigned int sof; - assert (strlen (idesc->name) <= 128); + gas_assert (strlen (idesc->name) <= 128); strcpy (mnemonic, idesc->name); if (idesc->operands[2] == IA64_OPND_SOF @@ -6245,7 +6091,7 @@ parse_operands (idesc) end = strchr (input_line_pointer, '='); if (!end) { - as_bad ("Expected separator `='"); + as_bad (_("Expected separator `='")); return 0; } input_line_pointer = end + 1; @@ -6255,9 +6101,10 @@ parse_operands (idesc) for (; ; ++i) { - if (i < NELEMS (CURR_SLOT.opnd)) + if (i < NELEMS (CURR_SLOT.opnd)) { - sep = parse_operand (CURR_SLOT.opnd + i, '='); + sep = parse_operand_maybe_eval (CURR_SLOT.opnd + i, '=', + idesc->operands[i]); if (CURR_SLOT.opnd[i].X_op == O_absent) break; } @@ -6278,14 +6125,14 @@ parse_operands (idesc) 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; } @@ -6311,7 +6158,8 @@ parse_operands (idesc) /* now we can parse the first arg: */ saved_input_pointer = input_line_pointer; input_line_pointer = first_arg; - sep = parse_operand (CURR_SLOT.opnd + 0, '='); + sep = parse_operand_maybe_eval (CURR_SLOT.opnd + 0, '=', + idesc->operands[0]); if (sep != '=') --num_outputs; /* force error */ input_line_pointer = saved_input_pointer; @@ -6399,15 +6247,15 @@ parse_operands (idesc) 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; } @@ -6489,10 +6337,10 @@ parse_operands (idesc) 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; } } @@ -6516,28 +6364,26 @@ parse_operands (idesc) 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; @@ -6557,7 +6403,7 @@ build_insn (slot, insnp) else if (slot->opnd[i].X_op == O_big) { /* This must be the value 0x10000000000000000. */ - assert (idesc->operands[i] == IA64_OPND_IMM8M1U8); + gas_assert (idesc->operands[i] == IA64_OPND_IMM8M1U8); val = 0; } else @@ -6600,6 +6446,10 @@ build_insn (slot, insnp) val -= REG_CR; break; + case IA64_OPND_DAHR3: + val -= REG_DAHR; + break; + case IA64_OPND_F1: case IA64_OPND_F2: case IA64_OPND_F3: @@ -6626,6 +6476,7 @@ build_insn (slot, insnp) case IA64_OPND_PKR_R3: case IA64_OPND_PMC_R3: case IA64_OPND_PMD_R3: + case IA64_OPND_DAHR_R3: case IA64_OPND_RR_R3: val -= REG_GR; break; @@ -6638,7 +6489,7 @@ build_insn (slot, insnp) 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) @@ -6660,12 +6511,12 @@ build_insn (slot, insnp) } static void -emit_one_bundle () +emit_one_bundle (void) { int manual_bundling_off = 0, manual_bundling = 0; enum ia64_unit required_unit, insn_unit = 0; enum ia64_insn_type type[3], insn_type; - unsigned int template, orig_template; + unsigned int template_val, orig_template; bfd_vma insn[3] = { -1, -1, -1 }; struct ia64_opcode *idesc; int end_of_insn_group = 0, user_template = -1; @@ -6680,14 +6531,14 @@ emit_one_bundle () 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 otherwise: */ if (md.slot[first].user_template >= 0) - user_template = template = md.slot[first].user_template; + user_template = template_val = md.slot[first].user_template; else { /* Auto select appropriate template. */ @@ -6700,12 +6551,12 @@ emit_one_bundle () type[i] = md.slot[curr].idesc->type; curr = (curr + 1) % NUM_SLOTS; } - template = best_template[type[0]][type[1]][type[2]]; + template_val = best_template[type[0]][type[1]][type[2]]; } /* initialize instructions with appropriate nops: */ for (i = 0; i < 3; ++i) - insn[i] = nop[ia64_templ_desc[template].exec_unit[i]]; + insn[i] = nop[ia64_templ_desc[template_val].exec_unit[i]]; f = frag_more (16); @@ -6781,7 +6632,7 @@ emit_one_bundle () 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. */ } @@ -6799,7 +6650,7 @@ emit_one_bundle () MBB, BBB, MMB, and MFB. We don't handle anything other than M and B slots because these are the only kind of instructions that can have the IA64_OPCODE_LAST bit set. */ - required_template = template; + required_template = template_val; switch (idesc->type) { case IA64_TYPE_M: @@ -6813,8 +6664,8 @@ emit_one_bundle () 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; } @@ -6823,10 +6674,10 @@ emit_one_bundle () || (required_slot == 2 && !manual_bundling_off) || (user_template >= 0 /* Changing from MMI to M;MI is OK. */ - && (template ^ required_template) > 1))) + && (template_val ^ required_template) > 1))) { as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line, - "`%s' must be last in instruction group", + _("`%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. */ @@ -6836,7 +6687,7 @@ emit_one_bundle () break; i = required_slot; - if (required_template != template) + if (required_template != template_val) { /* If we switch the template, we need to reset the NOPs after slot i. The slot-types of the instructions ahead @@ -6844,15 +6695,19 @@ emit_one_bundle () 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; + template_val = required_template; } if (curr != first && md.slot[curr].label_fixups) { 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. */ @@ -6865,18 +6720,18 @@ emit_one_bundle () bundle. See if we can switch to an other template with an appropriate boundary. */ - orig_template = template; + orig_template = template_val; if (i == 1 && (user_template == 4 || (user_template < 0 - && (ia64_templ_desc[template].exec_unit[0] + && (ia64_templ_desc[template_val].exec_unit[0] == IA64_UNIT_M)))) { - template = 5; + template_val = 5; end_of_insn_group = 0; } else if (i == 2 && (user_template == 0 || (user_template < 0 - && (ia64_templ_desc[template].exec_unit[1] + && (ia64_templ_desc[template_val].exec_unit[1] == IA64_UNIT_I))) /* This test makes sure we don't switch the template if the next instruction is one that needs to be first in @@ -6889,7 +6744,7 @@ emit_one_bundle () first in the group! --davidm 99/12/16 */ && (idesc->flags & IA64_OPCODE_FIRST) == 0) { - template = 1; + template_val = 1; end_of_insn_group = 0; } else if (i == 1 @@ -6901,15 +6756,15 @@ emit_one_bundle () /* can't fit this insn */ break; - if (template != orig_template) + if (template_val != orig_template) /* if we switch the template, we need to reset the NOPs after slot i. The slot-types of the instructions ahead of i never change, so we don't need to worry about changing NOPs in front of this slot. */ for (j = i; j < 3; ++j) - insn[j] = nop[ia64_templ_desc[template].exec_unit[j]]; + insn[j] = nop[ia64_templ_desc[template_val].exec_unit[j]]; } - required_unit = ia64_templ_desc[template].exec_unit[i]; + required_unit = ia64_templ_desc[template_val].exec_unit[i]; /* resolve dynamic opcodes such as "break", "hint", and "nop": */ if (idesc->type == IA64_TYPE_DYN) @@ -6929,7 +6784,7 @@ emit_one_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 @@ -6940,7 +6795,7 @@ emit_one_bundle () 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; } } @@ -6950,13 +6805,14 @@ emit_one_bundle () { insn_unit = IA64_UNIT_M; if (required_unit == IA64_UNIT_I - || (required_unit == IA64_UNIT_F && template == 6)) + || (required_unit == IA64_UNIT_F && template_val == 6)) insn_unit = IA64_UNIT_I; } else - as_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); @@ -7036,28 +6892,29 @@ emit_one_bundle () md.slot[curr].unwind_record = NULL; } - if (required_unit == IA64_UNIT_L) - { - know (i == 1); - /* skip one slot for long/X-unit instructions */ - ++i; - } - --md.num_slots_in_use; - last_slot = i; - 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; } end_of_insn_group = md.slot[curr].end_of_insn_group; + /* This adjustment to "i" must occur after the fix, otherwise the fix + is assigned to the wrong slot, and the VMS linker complains. */ + if (required_unit == IA64_UNIT_L) + { + know (i == 1); + /* skip one slot for long/X-unit instructions */ + ++i; + } + --md.num_slots_in_use; + last_slot = i; + /* clear slot: */ ia64_free_opcode (md.slot[curr].idesc); memset (md.slot + curr, 0, sizeof (md.slot[curr])); @@ -7077,8 +6934,8 @@ emit_one_bundle () 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); + _("`%s' does not fit into %s template"), + idesc->name, ia64_templ_desc[template_val].name); /* Drop first insn so we don't livelock. */ --md.num_slots_in_use; know (curr == first); @@ -7092,30 +6949,30 @@ emit_one_bundle () { 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); + _("`%s' does not fit into bundle"), idesc->name); else { const char *where; - if (template == 2) + if (template_val == 2) where = "X slot"; else if (last_slot == 0) where = "slots 2 or 3"; 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", - idesc->name, where, ia64_templ_desc[template].name); + _("`%s' can't go in %s of %s template"), + idesc->name, where, ia64_templ_desc[template_val].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); + t0 = end_of_insn_group | (template_val << 1) | (insn[0] << 5) | (insn[1] << 46); t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23); number_to_chars_littleendian (f + 0, t0, 8); @@ -7123,9 +6980,7 @@ emit_one_bundle () } int -md_parse_option (c, arg) - int c; - char *arg; +md_parse_option (int c, const char *arg) { switch (c) @@ -7284,8 +7139,7 @@ md_parse_option (c, arg) } void -md_show_usage (stream) - FILE *stream; +md_show_usage (FILE *stream) { fputs (_("\ IA-64 options:\n\ @@ -7302,7 +7156,9 @@ IA-64 options:\n\ unwind directive check (default -munwind-check=warning)\n\ -mhint.b=[ok|warning|error]\n\ hint.b check (default -mhint.b=error)\n\ - -x | -xexplicit turn on dependency violation checking\n\ + -x | -xexplicit turn on dependency violation checking\n"), stream); + /* Note for translators: "automagically" can be translated as "automatically" here. */ + fputs (_("\ -xauto automagically remove dependency violations (default)\n\ -xnone turn off dependency violation checking\n\ -xdebug debug dependency violation checker\n\ @@ -7314,7 +7170,7 @@ 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")); @@ -7382,7 +7238,7 @@ 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, goodness, best, ok; const char *err; @@ -7391,7 +7247,7 @@ md_begin () md.auto_align = 1; md.explicit_mode = md.default_explicit_mode; - bfd_set_section_alignment (stdoutput, text_section, 4); + bfd_set_section_alignment (text_section, 4); /* Make sure function pointers get initialized. */ target_big_endian = -1; @@ -7470,6 +7326,12 @@ md_begin () symbol_new (".", undefined_section, FUNC_IPLT_RELOC, &zero_address_frag); +#ifdef TE_VMS + pseudo_func[FUNC_SLOTCOUNT_RELOC].u.sym = + symbol_new (".", undefined_section, FUNC_SLOTCOUNT_RELOC, + &zero_address_frag); +#endif + if (md.tune != itanium1) { /* Convert MFI NOPs bundles into MMI NOPs bundles. */ @@ -7549,7 +7411,7 @@ md_begin () 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); } @@ -7589,6 +7451,9 @@ md_begin () for (i = 0; i < NELEMS (cr); ++i) declare_register (cr[i].name, REG_CR + cr[i].regnum); + /* dahr registers: */ + declare_register_set ("dahr", 8, REG_DAHR); + declare_register ("ip", REG_IP); declare_register ("cfm", REG_CFM); declare_register ("psr", REG_PSR); @@ -7608,9 +7473,9 @@ md_begin () 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); } @@ -7648,12 +7513,13 @@ md_begin () options in md based on command line options. */ void -ia64_init (argc, argv) - int argc ATTRIBUTE_UNUSED; - char **argv ATTRIBUTE_UNUSED; +ia64_init (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { md.flags = MD_FLAGS_DEFAULT; +#ifndef TE_VMS + /* Don't turn on dependency checking for VMS, doesn't work. */ md.detect_dv = 1; +#endif /* FIXME: We should change it to unwind_check_error someday. */ md.unwind_check = unwind_check_warning; md.hint_b = hint_b_error; @@ -7663,7 +7529,7 @@ ia64_init (argc, argv) /* 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) { @@ -7689,8 +7555,13 @@ ia64_target_format () else { if (md.flags & EF_IA_64_ABI64) -#ifdef TE_AIX50 +#if defined (TE_AIX50) return "elf64-ia64-aix-little"; +#elif defined (TE_VMS) + { + md.flags |= EF_IA_64_ARCHVER_1; + return "elf64-ia64-vms"; + } #else return "elf64-ia64-little"; #endif @@ -7707,7 +7578,7 @@ ia64_target_format () } void -ia64_end_of_source () +ia64_end_of_source (void) { /* terminate insn group upon reaching end of file: */ insn_group_break (1, 0, 0); @@ -7721,7 +7592,7 @@ ia64_end_of_source () } void -ia64_start_line () +ia64_start_line (void) { static int first; @@ -7733,7 +7604,7 @@ ia64_start_line () } 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 ()) @@ -7757,7 +7628,7 @@ ia64_start_line () else if (input_line_pointer[-1] == '{') { 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; @@ -7776,7 +7647,7 @@ ia64_start_line () 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; @@ -7795,8 +7666,7 @@ ia64_start_line () static int defining_tag = 0; int -ia64_unrecognized_line (ch) - int ch; +ia64_unrecognized_line (int ch) { switch (ch) { @@ -7804,17 +7674,17 @@ ia64_unrecognized_line (ch) expression_and_evaluate (&md.qp); if (*input_line_pointer++ != ')') { - as_bad ("Expected ')'"); + as_bad (_("Expected ')'")); return 0; } if (md.qp.X_op != O_register) { - as_bad ("Qualifying predicate expected"); + 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"); + as_bad (_("Predicate register expected")); return 0; } return 1; @@ -7828,7 +7698,7 @@ ia64_unrecognized_line (ch) 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; } @@ -7836,8 +7706,7 @@ ia64_unrecognized_line (ch) recognize labels. */ if (is_name_beginner (*input_line_pointer)) { - s = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (&s); } else if (LOCAL_LABELS_FB && ISDIGIT (*input_line_pointer)) @@ -7858,7 +7727,7 @@ ia64_unrecognized_line (ch) { /* Put ':' back for error messages' sake. */ *input_line_pointer++ = ':'; - as_bad ("Expected ':'"); + as_bad (_("Expected ':'")); return 0; } @@ -7869,12 +7738,12 @@ ia64_unrecognized_line (ch) *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; @@ -7889,8 +7758,7 @@ ia64_unrecognized_line (ch) } void -ia64_frob_label (sym) - struct symbol *sym; +ia64_frob_label (struct symbol *sym) { struct label_fix *fix; @@ -7898,7 +7766,7 @@ ia64_frob_label (sym) labels. */ if (defining_tag) { - fix = obstack_alloc (¬es, sizeof (*fix)); + fix = XOBNEW (¬es, struct label_fix); fix->sym = sym; fix->next = CURR_SLOT.tag_fixups; fix->dw2_mark_labels = FALSE; @@ -7907,10 +7775,10 @@ ia64_frob_label (sym) return; } - if (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) + if (bfd_section_flags (now_seg) & SEC_CODE) { md.last_text_seg = now_seg; - fix = obstack_alloc (¬es, sizeof (*fix)); + fix = XOBNEW (¬es, struct label_fix); fix->sym = sym; fix->next = CURR_SLOT.label_fixups; fix->dw2_mark_labels = dwarf2_loc_mark_labels; @@ -7920,9 +7788,8 @@ ia64_frob_label (sym) if (md.path == md.maxpaths) { md.maxpaths += 20; - md.entry_labels = (const char **) - xrealloc ((void *) md.entry_labels, - md.maxpaths * sizeof (char *)); + md.entry_labels = XRESIZEVEC (const char *, md.entry_labels, + md.maxpaths); } md.entry_labels[md.path++] = S_GET_NAME (sym); } @@ -7933,12 +7800,11 @@ ia64_frob_label (sym) 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) && + if ((S_GET_SEGMENT (sym) == bfd_und_section_ptr && ! symbol_used_p (sym) && ELF_ST_VISIBILITY (S_GET_OTHER (sym)) == STV_DEFAULT) - || (S_GET_SEGMENT (sym) == &bfd_abs_section + || (S_GET_SEGMENT (sym) == bfd_abs_section_ptr && ! S_IS_EXTERNAL (sym))) return 1; return 0; @@ -7946,10 +7812,10 @@ ia64_frob_symbol (sym) #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) + && bfd_section_flags (now_seg) & SEC_CODE) { /* ??? This causes many unnecessary stop bits to be emitted. Unfortunately, it isn't clear if it is safe to remove this. */ @@ -7963,10 +7829,7 @@ ia64_flush_pending_output () of rotating registers or due to the indexing of indirect register sets. */ int -ia64_optimize_expr (l, op, r) - expressionS *l; - operatorT op; - expressionS *r; +ia64_optimize_expr (expressionS *l, operatorT op, expressionS *r) { if (op != O_index) return 0; @@ -7981,12 +7844,12 @@ ia64_optimize_expr (l, op, r) /* Left side is a .rotX-allocated register. */ if (r->X_op != O_constant) { - as_bad ("Rotating register index must be a non-negative constant"); + 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); + 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; @@ -7998,7 +7861,7 @@ ia64_optimize_expr (l, op, r) || r->X_add_number < REG_GR || r->X_add_number > REG_GR + 127) { - as_bad ("Indirect register index must be a general register"); + as_bad (_("Indirect register index must be a general register")); r->X_add_number = REG_GR; } l->X_op = O_index; @@ -8007,7 +7870,7 @@ ia64_optimize_expr (l, op, r) return 1; } } - as_bad ("Index can only be applied to rotating or indirect registers"); + 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; @@ -8016,10 +7879,7 @@ ia64_optimize_expr (l, op, r) } 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; @@ -8046,7 +7906,7 @@ ia64_parse_name (name, e, nextcharP) end = input_line_pointer; if (*nextcharP != '(') { - as_bad ("Expected '('"); + as_bad (_("Expected '('")); break; } /* Skip '('. */ @@ -8054,21 +7914,30 @@ ia64_parse_name (name, e, nextcharP) expression (e); if (*input_line_pointer != ')') { - as_bad ("Missing ')'"); + as_bad (_("Missing ')'")); goto done; } /* Skip ')'. */ ++input_line_pointer; +#ifdef TE_VMS + if (idx == FUNC_SLOTCOUNT_RELOC) + { + /* @slotcount can accept any expression. Canonicalize. */ + e->X_add_symbol = make_expr_symbol (e); + e->X_op = O_symbol; + e->X_add_number = 0; + } +#endif if (e->X_op != O_symbol) { 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)) @@ -8082,7 +7951,7 @@ ia64_parse_name (name, e, nextcharP) 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; } } @@ -8171,9 +8040,9 @@ ia64_parse_name (name, e, nextcharP) 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; } @@ -8183,8 +8052,7 @@ ia64_parse_name (name, e, nextcharP) } } - end = alloca (strlen (name) + 1); - strcpy (end, name); + end = xstrdup (name); name = ia64_canonicalize_symbol_name (end); if ((dr = hash_find (md.dynreg_hash, name))) { @@ -8194,16 +8062,17 @@ ia64_parse_name (name, e, nextcharP) bits. */ e->X_op = O_register; e->X_add_number = dr->base | (dr->num_regs << 16); + free (end); return 1; } + free (end); return 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; @@ -8212,10 +8081,10 @@ ia64_canonicalize_symbol_name (name) 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; } @@ -8228,8 +8097,7 @@ ia64_canonicalize_symbol_name (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. @@ -8249,8 +8117,7 @@ is_conditional_branch (idesc) 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); @@ -8260,8 +8127,7 @@ is_taken_branch (idesc) 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; @@ -8272,9 +8138,7 @@ is_interruption_or_rfi (idesc) -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; @@ -8318,7 +8182,7 @@ depends_on (depind, idesc) 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 @@ -8327,6 +8191,8 @@ depends_on (depind, idesc) 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. @@ -8337,13 +8203,16 @@ depends_on (depind, idesc) #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; @@ -8677,9 +8546,9 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) || (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3)) { - int index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write) - ? 1 : !rsrc_write); - int regno = CURR_SLOT.opnd[index].X_add_number - REG_GR; + int reg_index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write) + ? 1 : !rsrc_write); + int regno = CURR_SLOT.opnd[reg_index].X_add_number - REG_GR; if (regno >= 0 && regno < NELEMS (gr_values) && KNOWN (regno)) { @@ -8787,6 +8656,23 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) } 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) { @@ -8820,6 +8706,22 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) } break; + case IA64_RS_DAHR: + if (note == 0) + { + if (idesc->operands[!rsrc_write] == IA64_OPND_DAHR3) + { + specs[count] = tmpl; + specs[count++].index = + CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_DAHR; + } + } + else + { + UNHANDLED; + } + break; + case IA64_RS_FR: case IA64_RS_FRb: if (note != 1) @@ -8894,6 +8796,7 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) || idesc->operands[i] == IA64_OPND_PKR_R3 || idesc->operands[i] == IA64_OPND_PMC_R3 || idesc->operands[i] == IA64_OPND_PMD_R3 + || idesc->operands[i] == IA64_OPND_DAHR_R3 || idesc->operands[i] == IA64_OPND_RR_R3 || ((i >= idesc->num_outputs) && (idesc->operands[i] == IA64_OPND_R1 @@ -9200,11 +9103,11 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) if (idesc->operands[0] == IA64_OPND_CR3 || idesc->operands[1] == IA64_OPND_CR3) { - int index = + int reg_index = ((idesc->operands[0] == IA64_OPND_CR3) ? 0 : 1); int regno = - CURR_SLOT.opnd[index].X_add_number - REG_CR; + CURR_SLOT.opnd[reg_index].X_add_number - REG_CR; switch (regno) { @@ -9218,6 +9121,8 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) case CR_ISR: case CR_IFA: case CR_IHA: + case CR_IIB0: + case CR_IIB1: case CR_IIPA: specs[count++] = tmpl; break; @@ -9236,16 +9141,16 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) if (idesc->operands[0] == IA64_OPND_AR3 || idesc->operands[1] == IA64_OPND_AR3) { - int index = + int reg_index = ((idesc->operands[0] == IA64_OPND_AR3) ? 0 : 1); int regno = - CURR_SLOT.opnd[index].X_add_number - REG_AR; + CURR_SLOT.opnd[reg_index].X_add_number - REG_AR; if (regno == AR_ITC - || (index == 0 - && (regno == AR_ITC - || regno == AR_RSC + || regno == AR_RUC + || (reg_index == 0 + && (regno == AR_RSC || (regno >= AR_K0 && regno <= AR_K7)))) { @@ -9377,6 +9282,7 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) { specs[count++] = tmpl; } + /* Fall through. */ case AR_RSC: if (!rsrc_write && (regno == AR_BSPSTORE @@ -9415,8 +9321,9 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) 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) { @@ -9659,8 +9566,7 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note) 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++) @@ -9705,7 +9611,7 @@ update_qp_mutex (valueT mask) print_prmask (qp_mutexes[i].prmask); fprintf (stderr, "\n"); } - + /* Deal with the old mutex with more than 3+ PRs only if the new mutex on the same execution path with it. @@ -9718,7 +9624,7 @@ update_qp_mutex (valueT mask) if (add == 0 && (qp_mutexes[i].prmask & mask) == mask) add = 1; - + qp_mutexes[i].prmask &= ~mask; if (qp_mutexes[i].prmask & (qp_mutexes[i].prmask - 1)) { @@ -9728,7 +9634,7 @@ update_qp_mutex (valueT mask) i++; } } - + if (keep == 0) /* Remove the mutex. */ qp_mutexes[i] = qp_mutexes[--qp_mutexeslen]; @@ -9749,8 +9655,7 @@ update_qp_mutex (valueT mask) 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; @@ -9777,9 +9682,7 @@ clear_qp_mutex (mask) 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; @@ -9802,8 +9705,7 @@ clear_qp_implies (p1_mask, p2_mask) /* 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; @@ -9829,9 +9731,7 @@ add_qp_imply (p1, p2) if (qp_implieslen == qp_impliestotlen) { qp_impliestotlen += 20; - qp_implies = (struct qp_imply *) - xrealloc ((void *) qp_implies, - qp_impliestotlen * sizeof (struct qp_imply)); + qp_implies = XRESIZEVEC (struct qp_imply, qp_implies, qp_impliestotlen); } if (md.debug_dv) fprintf (stderr, " Registering PR%d implies PR%d\n", p1, p2); @@ -9866,8 +9766,7 @@ add_qp_imply (p1, p2) the mask. */ static void -add_qp_mutex (mask) - valueT mask; +add_qp_mutex (valueT mask) { if (mask & 0x1) abort (); @@ -9875,9 +9774,7 @@ add_qp_mutex (mask) if (qp_mutexeslen == qp_mutexestotlen) { qp_mutexestotlen += 20; - qp_mutexes = (struct qpmutex *) - xrealloc ((void *) qp_mutexes, - qp_mutexestotlen * sizeof (struct qpmutex)); + qp_mutexes = XRESIZEVEC (struct qpmutex, qp_mutexes, qp_mutexestotlen); } if (md.debug_dv) { @@ -9890,9 +9787,7 @@ add_qp_mutex (mask) } 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); @@ -9903,7 +9798,7 @@ has_suffix_p (name, suffix) } static void -clear_register_values () +clear_register_values (void) { int i; if (md.debug_dv) @@ -9918,8 +9813,7 @@ clear_register_values () 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; @@ -10118,10 +10012,7 @@ note_register_values (idesc) /* 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; @@ -10144,12 +10035,11 @@ qp_mutex (p1, p2, path) 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; @@ -10225,10 +10115,7 @@ resources_match (rs, idesc, note, qp_regno, path) 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; @@ -10292,19 +10179,16 @@ insn_group_break (insert_stop, qp_regno, save_current) /* 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) { regdepstotlen += 20; - regdeps = (struct rsrc *) - xrealloc ((void *) regdeps, - regdepstotlen * sizeof (struct rsrc)); + regdeps = XRESIZEVEC (struct rsrc, regdeps, regdepstotlen); } regdeps[regdepslen] = *spec; @@ -10319,9 +10203,7 @@ mark_resource (idesc, dep, spec, depind, path) } static void -print_dependency (action, depind) - const char *action; - int depind; +print_dependency (const char *action, int depind) { if (md.debug_dv) { @@ -10342,7 +10224,7 @@ print_dependency (action, depind) } static void -instruction_serialization () +instruction_serialization (void) { int i; if (md.debug_dv) @@ -10353,7 +10235,7 @@ instruction_serialization () } static void -data_serialization () +data_serialization (void) { int i = 0; if (md.debug_dv) @@ -10376,15 +10258,14 @@ data_serialization () /* 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) { case IA64_DVS_SPECIFIC: if (md.debug_dv) fprintf (stderr, "Implementation-specific, assume worst case...\n"); - /* ...fall through... */ + /* Fall through. */ case IA64_DVS_INSTR: if (md.debug_dv) fprintf (stderr, "Inserting instr serialization\n"); @@ -10452,8 +10333,7 @@ remove_marked_resource (rs) */ 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; @@ -10526,12 +10406,15 @@ check_dependencies (idesc) 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, @@ -10542,11 +10425,9 @@ check_dependencies (idesc) { 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; @@ -10576,8 +10457,7 @@ check_dependencies (idesc) /* 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; @@ -10650,8 +10530,7 @@ mark_resources (idesc) /* Remove dependencies when they no longer apply. */ static void -update_dependencies (idesc) - struct ia64_opcode *idesc; +update_dependencies (struct ia64_opcode *idesc) { int i; @@ -10731,8 +10610,7 @@ update_dependencies (idesc) /* 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) { @@ -10780,10 +10658,10 @@ check_dv (idesc) /* 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; + char *saved_input_line_pointer, *temp; + const char *mnemonic; const struct pseudo_opcode *pdesc; struct ia64_opcode *idesc; unsigned char qp_regno; @@ -10795,12 +10673,12 @@ md_assemble (str) /* extract the opcode (mnemonic): */ - mnemonic = input_line_pointer; - ch = get_symbol_end (); + ch = get_symbol_name (&temp); + mnemonic = temp; pdesc = (struct pseudo_opcode *) hash_find (md.pseudo_hash, mnemonic); if (pdesc) { - *input_line_pointer = ch; + (void) restore_line_pointer (ch); (*pdesc->handler) (pdesc->arg); goto done; } @@ -10808,10 +10686,10 @@ md_assemble (str) /* Find the instruction descriptor matching the arguments. */ idesc = ia64_find_opcode (mnemonic); - *input_line_pointer = ch; + (void) restore_line_pointer (ch); if (!idesc) { - as_bad ("Unknown opcode `%s'", mnemonic); + as_bad (_("Unknown opcode `%s'"), mnemonic); goto done; } @@ -10872,7 +10750,7 @@ md_assemble (str) { enum ia64_opnd opnd1, opnd2; int rop; - + opnd1 = idesc->operands[0]; opnd2 = idesc->operands[1]; if (opnd1 == IA64_OPND_AR3) @@ -10889,7 +10767,7 @@ md_assemble (str) 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)); } @@ -10901,10 +10779,10 @@ md_assemble (str) 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; } } @@ -10943,15 +10821,16 @@ md_assemble (str) 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; } /* Build the instruction. */ CURR_SLOT.qp_regno = qp_regno; CURR_SLOT.idesc = idesc; - as_where (&CURR_SLOT.src_file, &CURR_SLOT.src_line); + CURR_SLOT.src_file = as_where (&CURR_SLOT.src_line); dwarf2_where (&CURR_SLOT.debug_line); + dwarf2_consume_line_info (); /* Add unwind entries, if there are any. */ if (unwind.current_entry) @@ -10995,8 +10874,7 @@ md_assemble (str) 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; } @@ -11006,8 +10884,7 @@ md_undefined_symbol (name) the expression. */ void -md_operand (e) - expressionS *e; +md_operand (expressionS *e) { switch (*input_line_pointer) { @@ -11016,7 +10893,7 @@ md_operand (e) expression_and_evaluate (e); if (*input_line_pointer != ']') { - as_bad ("Closing bracket missing"); + as_bad (_("Closing bracket missing")); goto err; } else @@ -11025,7 +10902,7 @@ md_operand (e) || e->X_add_number < REG_GR || e->X_add_number > REG_GR + 127) { - as_bad ("Index must be a general register"); + as_bad (_("Index must be a general register")); e->X_add_number = REG_GR; } @@ -11048,8 +10925,7 @@ md_operand (e) 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)) @@ -11073,8 +10949,7 @@ ia64_fix_adjustable (fix) } int -ia64_force_relocation (fix) - fixS *fix; +ia64_force_relocation (fixS *fix) { switch (fix->fx_r_type) { @@ -11107,13 +10982,11 @@ ia64_force_relocation (fix) /* 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; - if (bfd_get_section_flags (stdoutput, sec) & SEC_CODE) + if (bfd_section_flags (sec) & SEC_CODE) off &= ~0xfUL; return off; @@ -11124,26 +10997,22 @@ ia64_pcrel_from_section (fix, sec) void ia64_dwarf2_emit_offset (symbolS *symbol, unsigned int size) { - expressionS expr; + expressionS exp; - expr.X_op = O_pseudo_fixup; - expr.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym; - expr.X_add_number = 0; - expr.X_add_symbol = symbol; - emit_expr (&expr, size); + exp.X_op = O_pseudo_fixup; + exp.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym; + exp.X_add_number = 0; + exp.X_add_symbol = symbol; + emit_expr (&exp, size); } /* This is called whenever some data item (not an instruction) needs a fixup. We pick the right reloc code depending on the byteorder currently in effect. */ void -ia64_cons_fix_new (f, where, nbytes, exp) - fragS *f; - int where; - int nbytes; - expressionS *exp; +ia64_cons_fix_new (fragS *f, int where, int nbytes, expressionS *exp, + bfd_reloc_code_real_type code) { - bfd_reloc_code_real_type code; fixS *fix; switch (nbytes) @@ -11198,7 +11067,7 @@ ia64_cons_fix_new (f, where, nbytes, exp) /* FALLTHRU */ default: - as_bad ("Unsupported fixup size %d", nbytes); + as_bad (_("Unsupported fixup size %d"), nbytes); ignore_rest_of_line (); return; } @@ -11222,11 +11091,9 @@ ia64_cons_fix_new (f, where, nbytes, exp) symbols in the pseudo_func array, or NULL. */ static bfd_reloc_code_real_type -ia64_gen_real_reloc_type (sym, r_type) - struct symbol *sym; - bfd_reloc_code_real_type r_type; +ia64_gen_real_reloc_type (struct symbol *sym, bfd_reloc_code_real_type r_type) { - bfd_reloc_code_real_type new = 0; + bfd_reloc_code_real_type newr = 0; const char *type = NULL, *suffix = ""; if (sym == NULL) @@ -11239,11 +11106,11 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_FPTR_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_FPTR64I; break; - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_FPTR32MSB; break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_FPTR32LSB; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_FPTR64MSB; break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_FPTR64LSB; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_FPTR64I; break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_FPTR32MSB; break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_FPTR32LSB; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_FPTR64MSB; break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_FPTR64LSB; break; default: type = "FPTR"; break; } break; @@ -11251,12 +11118,12 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_GP_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_GPREL22; break; - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_GPREL64I; break; - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_GPREL32MSB; break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_GPREL32LSB; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_GPREL64MSB; break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_GPREL64LSB; break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_GPREL22; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_GPREL64I; break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_GPREL32MSB; break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_GPREL32LSB; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_GPREL64MSB; break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_GPREL64LSB; break; default: type = "GPREL"; break; } break; @@ -11264,8 +11131,8 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_LT_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22; break; - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_LTOFF64I; break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_LTOFF64I; break; default: type = "LTOFF"; break; } break; @@ -11273,7 +11140,7 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_LT_RELATIVE_X: switch (r_type) { - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22X; break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22X; break; default: type = "LTOFF"; suffix = "X"; break; } break; @@ -11281,12 +11148,12 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_PC_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PCREL22; break; - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PCREL64I; break; - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_PCREL32MSB; break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_PCREL32LSB; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PCREL64MSB; break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PCREL64LSB; break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PCREL22; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PCREL64I; break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_PCREL32MSB; break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_PCREL32LSB; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PCREL64MSB; break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PCREL64LSB; break; default: type = "PCREL"; break; } break; @@ -11294,10 +11161,10 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_PLT_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PLTOFF22; break; - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PLTOFF64I; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PLTOFF64MSB;break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PLTOFF64LSB;break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PLTOFF22; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PLTOFF64I; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PLTOFF64MSB;break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PLTOFF64LSB;break; default: type = "PLTOFF"; break; } break; @@ -11305,10 +11172,10 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_SEC_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SECREL32MSB;break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SECREL32LSB;break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SECREL64MSB;break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SECREL64LSB;break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SECREL32MSB;break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SECREL32LSB;break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SECREL64MSB;break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SECREL64LSB;break; default: type = "SECREL"; break; } break; @@ -11316,10 +11183,10 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_SEG_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SEGREL32MSB;break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SEGREL32LSB;break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SEGREL64MSB;break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SEGREL64LSB;break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SEGREL32MSB;break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SEGREL32LSB;break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SEGREL64MSB;break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SEGREL64LSB;break; default: type = "SEGREL"; break; } break; @@ -11327,10 +11194,10 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_LTV_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_LTV32MSB; break; - case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_LTV32LSB; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_LTV64MSB; break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_LTV64LSB; break; + case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_LTV32MSB; break; + case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_LTV32LSB; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_LTV64MSB; break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_LTV64LSB; break; default: type = "LTV"; break; } break; @@ -11339,17 +11206,17 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_IMM22: - new = BFD_RELOC_IA64_LTOFF_FPTR22; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR22; break; case BFD_RELOC_IA64_IMM64: - new = BFD_RELOC_IA64_LTOFF_FPTR64I; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR64I; break; case BFD_RELOC_IA64_DIR32MSB: - new = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break; case BFD_RELOC_IA64_DIR32LSB: - new = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break; case BFD_RELOC_IA64_DIR64MSB: - new = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break; case BFD_RELOC_IA64_DIR64LSB: - new = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break; + newr = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break; default: type = "LTOFF_FPTR"; break; } @@ -11358,11 +11225,11 @@ ia64_gen_real_reloc_type (sym, r_type) case FUNC_TP_RELATIVE: switch (r_type) { - case BFD_RELOC_IA64_IMM14: new = BFD_RELOC_IA64_TPREL14; break; - case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_TPREL22; break; - case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_TPREL64I; break; - case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_TPREL64MSB; break; - case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_TPREL64LSB; break; + case BFD_RELOC_IA64_IMM14: newr = BFD_RELOC_IA64_TPREL14; break; + case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_TPREL22; break; + case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_TPREL64I; break; + case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_TPREL64MSB; break; + case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_TPREL64LSB; break; default: type = "TPREL"; break; } break; @@ -11371,7 +11238,7 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_IMM22: - new = BFD_RELOC_IA64_LTOFF_TPREL22; break; + newr = BFD_RELOC_IA64_LTOFF_TPREL22; break; default: type = "LTOFF_TPREL"; break; } @@ -11381,9 +11248,9 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_DIR64MSB: - new = BFD_RELOC_IA64_DTPMOD64MSB; break; + newr = BFD_RELOC_IA64_DTPMOD64MSB; break; case BFD_RELOC_IA64_DIR64LSB: - new = BFD_RELOC_IA64_DTPMOD64LSB; break; + newr = BFD_RELOC_IA64_DTPMOD64LSB; break; default: type = "DTPMOD"; break; } @@ -11393,7 +11260,7 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_IMM22: - new = BFD_RELOC_IA64_LTOFF_DTPMOD22; break; + newr = BFD_RELOC_IA64_LTOFF_DTPMOD22; break; default: type = "LTOFF_DTPMOD"; break; } @@ -11403,19 +11270,19 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_DIR32MSB: - new = BFD_RELOC_IA64_DTPREL32MSB; break; + newr = BFD_RELOC_IA64_DTPREL32MSB; break; case BFD_RELOC_IA64_DIR32LSB: - new = BFD_RELOC_IA64_DTPREL32LSB; break; + newr = BFD_RELOC_IA64_DTPREL32LSB; break; case BFD_RELOC_IA64_DIR64MSB: - new = BFD_RELOC_IA64_DTPREL64MSB; break; + newr = BFD_RELOC_IA64_DTPREL64MSB; break; case BFD_RELOC_IA64_DIR64LSB: - new = BFD_RELOC_IA64_DTPREL64LSB; break; + newr = BFD_RELOC_IA64_DTPREL64LSB; break; case BFD_RELOC_IA64_IMM14: - new = BFD_RELOC_IA64_DTPREL14; break; + newr = BFD_RELOC_IA64_DTPREL14; break; case BFD_RELOC_IA64_IMM22: - new = BFD_RELOC_IA64_DTPREL22; break; + newr = BFD_RELOC_IA64_DTPREL22; break; case BFD_RELOC_IA64_IMM64: - new = BFD_RELOC_IA64_DTPREL64I; break; + newr = BFD_RELOC_IA64_DTPREL64I; break; default: type = "DTPREL"; break; } @@ -11425,7 +11292,7 @@ ia64_gen_real_reloc_type (sym, r_type) switch (r_type) { case BFD_RELOC_IA64_IMM22: - new = BFD_RELOC_IA64_LTOFF_DTPREL22; break; + newr = BFD_RELOC_IA64_LTOFF_DTPREL22; break; default: type = "LTOFF_DTPREL"; break; } @@ -11440,12 +11307,17 @@ ia64_gen_real_reloc_type (sym, r_type) } break; +#ifdef TE_VMS + case FUNC_SLOTCOUNT_RELOC: + return DUMMY_RELOC_IA64_SLOTCOUNT; +#endif + default: abort (); } - if (new) - return new; + if (newr) + return newr; else { int width; @@ -11466,8 +11338,8 @@ ia64_gen_real_reloc_type (sym, r_type) } /* 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; } } @@ -11475,8 +11347,7 @@ ia64_gen_real_reloc_type (sym, 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) { @@ -11487,7 +11358,7 @@ ia64_validate_fix (fix) 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; @@ -11495,10 +11366,7 @@ ia64_validate_fix (fix) } 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; @@ -11529,7 +11397,7 @@ fix_insn (fix, odesc, value) else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62) { if (value & ~0x3fffffffffffffffULL) - err = "integer operand out of range"; + err = _("integer operand out of range"); insn[1] = (value >> 21) & 0x1ffffffffffLL; insn[2] |= (((value & 0xfffff) << 6) | (((value >> 20) & 0x1) << 36)); } @@ -11544,7 +11412,7 @@ fix_insn (fix, odesc, value) err = (*odesc->insert) (odesc, value, insn + slot); if (err) - as_bad_where (fix->fx_file, fix->fx_line, err); + as_bad_where (fix->fx_file, fix->fx_line, "%s", err); t0 = control_bits | (insn[0] << 5) | (insn[1] << 46); t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23); @@ -11560,10 +11428,7 @@ fix_insn (fix, odesc, value) (if possible). */ void -md_apply_fix (fix, valP, seg) - fixS *fix; - valueT *valP; - segT seg ATTRIBUTE_UNUSED; +md_apply_fix (fixS *fix, valueT *valP, segT seg ATTRIBUTE_UNUSED) { char *fixpos; valueT value = *valP; @@ -11593,13 +11458,13 @@ md_apply_fix (fix, valP, seg) } if (fix->fx_addsy) { - switch (fix->fx_r_type) + switch ((unsigned) fix->fx_r_type) { case BFD_RELOC_UNUSED: /* 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; @@ -11616,12 +11481,48 @@ md_apply_fix (fix, valP, seg) S_SET_THREAD_LOCAL (fix->fx_addsy); break; +#ifdef TE_VMS + case DUMMY_RELOC_IA64_SLOTCOUNT: + as_bad_where (fix->fx_file, fix->fx_line, + _("cannot resolve @slotcount parameter")); + fix->fx_done = 1; + return; +#endif + default: break; } } else if (fix->tc_fix_data.opnd == IA64_OPND_NIL) { +#ifdef TE_VMS + if (fix->fx_r_type == DUMMY_RELOC_IA64_SLOTCOUNT) + { + /* For @slotcount, convert an addresses difference to a slots + difference. */ + valueT v; + + v = (value >> 4) * 3; + switch (value & 0x0f) + { + case 0: + case 1: + case 2: + v += value & 0x0f; + break; + case 0x0f: + v += 2; + break; + case 0x0e: + v += 1; + break; + default: + as_bad (_("invalid @slotcount value")); + } + value = v; + } +#endif + if (fix->tc_fix_data.bigendian) number_to_chars_bigendian (fixpos, value, fix->fx_size); else @@ -11639,14 +11540,12 @@ md_apply_fix (fix, valP, seg) 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; - reloc = xmalloc (sizeof (*reloc)); - reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); + reloc = XNEW (arelent); + reloc->sym_ptr_ptr = XNEW (asymbol *); *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; reloc->addend = fixp->fx_offset; @@ -11655,8 +11554,10 @@ tc_gen_reloc (sec, fixp) 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; } @@ -11666,13 +11567,8 @@ tc_gen_reloc (sec, fixp) of LITTLENUMS emitted is stored in *SIZE. An error message is returned, or NULL on OK. */ -#define MAX_LITTLENUMS 5 - -char * -md_atof (type, lit, size) - int type; - char *lit; - int *size; +const char * +md_atof (int type, char *lit, int *size) { LITTLENUM_TYPE words[MAX_LITTLENUMS]; char *t; @@ -11704,7 +11600,7 @@ md_atof (type, lit, size) 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) @@ -11721,17 +11617,16 @@ md_atof (type, lit, size) 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 (); @@ -11741,23 +11636,22 @@ ia64_md_do_align (n, fill, len, max) of an rs_align_code fragment. */ void -ia64_handle_align (fragp) - fragS *fragp; +ia64_handle_align (fragS *fragp) { int bytes; char *p; - const unsigned char *nop; + const unsigned char *nop_type; if (fragp->fr_type != rs_align_code) return; /* Check if this frag has to end with a stop bit. */ - nop = fragp->tc_frag_data ? le_nop_stop : le_nop; + nop_type = fragp->tc_frag_data ? le_nop_stop : le_nop; bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix; p = fragp->fr_literal + fragp->fr_fix; - /* If no paddings are needed, we check if we need a stop bit. */ + /* If no paddings are needed, we check if we need a stop bit. */ if (!bytes && fragp->tc_frag_data) { if (fragp->fr_fix < 16) @@ -11789,7 +11683,7 @@ ia64_handle_align (fragp) } /* Instruction bundles are always little-endian. */ - memcpy (p, nop, 16); + memcpy (p, nop_type, 16); fragp->fr_var = 16; } @@ -11818,7 +11712,7 @@ ia64_float_to_chars_littleendian (char *lit, LITTLENUM_TYPE *words, } 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) @@ -11842,9 +11736,9 @@ ia64_check_label (symbolS *label) the relocatable file. */ struct alias { - char *file; /* The file where the directive is seen. */ + const 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 @@ -11862,8 +11756,7 @@ dot_alias (int section) struct hash_control *ahash, *nhash; const char *kind; - name = input_line_pointer; - delim = get_symbol_end (); + delim = get_symbol_name (&name); end_name = input_line_pointer; *end_name = delim; @@ -11874,7 +11767,7 @@ dot_alias (int section) return; } - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer != ',') { @@ -11935,11 +11828,11 @@ dot_alias (int section) goto out; } - h = (struct alias *) xmalloc (sizeof (struct alias)); - as_where (&h->file, &h->line); + h = XNEW (struct alias); + h->file = as_where (&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"), @@ -11947,7 +11840,7 @@ dot_alias (int section) 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"), @@ -11962,15 +11855,23 @@ out: /* It renames the original symbol name to its alias. */ static void -do_alias (const char *alias, PTR value) +do_alias (const char *alias, void *value) { struct alias *h = (struct alias *) value; symbolS *sym = symbol_find (h->name); if (sym == NULL) - as_warn_where (h->file, h->line, - _("symbol `%s' aliased to `%s' is not used"), - h->name, alias); + { +#ifdef TE_VMS + /* Uses .alias extensively to alias CRTL functions to same with + decc$ prefix. Sometimes function gets optimized away and a + warning results, which should be suppressed. */ + if (strncmp (alias, "decc$", 5) != 0) +#endif + as_warn_where (h->file, h->line, + _("symbol `%s' aliased to `%s' is not used"), + h->name, alias); + } else S_SET_NAME (sym, (char *) alias); } @@ -11984,7 +11885,7 @@ ia64_adjust_symtab (void) /* 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); @@ -12003,3 +11904,113 @@ ia64_frob_file (void) { hash_traverse (secalias_hash, do_secalias); } + +#ifdef TE_VMS +#define NT_VMS_MHD 1 +#define NT_VMS_LNM 2 + +/* Integrity VMS 8.x identifies it's ELF modules with a standard ELF + .note section. */ + +/* Manufacture a VMS-like time string. */ +static void +get_vms_time (char *Now) +{ + char *pnt; + time_t timeb; + + time (&timeb); + pnt = ctime (&timeb); + pnt[3] = 0; + pnt[7] = 0; + pnt[10] = 0; + pnt[16] = 0; + pnt[24] = 0; + sprintf (Now, "%2s-%3s-%s %s", pnt + 8, pnt + 4, pnt + 20, pnt + 11); +} + +void +ia64_vms_note (void) +{ + char *p; + asection *seg = now_seg; + subsegT subseg = now_subseg; + asection *secp = NULL; + char *bname; + char buf [256]; + symbolS *sym; + + /* Create the .note section. */ + + secp = subseg_new (".note", 0); + bfd_set_section_flags (secp, SEC_HAS_CONTENTS | SEC_READONLY); + + /* Module header note (MHD). */ + bname = xstrdup (lbasename (out_file_name)); + if ((p = strrchr (bname, '.'))) + *p = '\0'; + + /* VMS note header is 24 bytes long. */ + p = frag_more (8 + 8 + 8); + number_to_chars_littleendian (p + 0, 8, 8); + number_to_chars_littleendian (p + 8, 40 + strlen (bname), 8); + number_to_chars_littleendian (p + 16, NT_VMS_MHD, 8); + + p = frag_more (8); + strcpy (p, "IPF/VMS"); + + p = frag_more (17 + 17 + strlen (bname) + 1 + 5); + get_vms_time (p); + strcpy (p + 17, "24-FEB-2005 15:00"); + p += 17 + 17; + strcpy (p, bname); + p += strlen (bname) + 1; + free (bname); + strcpy (p, "V1.0"); + + frag_align (3, 0, 0); + + /* Language processor name note. */ + sprintf (buf, "GNU assembler version %s (%s) using BFD version %s", + VERSION, TARGET_ALIAS, BFD_VERSION_STRING); + + p = frag_more (8 + 8 + 8); + number_to_chars_littleendian (p + 0, 8, 8); + number_to_chars_littleendian (p + 8, strlen (buf) + 1, 8); + number_to_chars_littleendian (p + 16, NT_VMS_LNM, 8); + + p = frag_more (8); + strcpy (p, "IPF/VMS"); + + p = frag_more (strlen (buf) + 1); + strcpy (p, buf); + + frag_align (3, 0, 0); + + secp = subseg_new (".vms_display_name_info", 0); + bfd_set_section_flags (secp, SEC_HAS_CONTENTS | SEC_READONLY); + + /* This symbol should be passed on the command line and be variable + according to language. */ + sym = symbol_new ("__gnat_vms_display_name@gnat_demangler_rtl", + absolute_section, 0, &zero_address_frag); + symbol_table_insert (sym); + symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING | BSF_DYNAMIC; + + p = frag_more (4); + /* Format 3 of VMS demangler Spec. */ + number_to_chars_littleendian (p, 3, 4); + + p = frag_more (4); + /* Place holder for symbol table index of above symbol. */ + number_to_chars_littleendian (p, -1, 4); + + frag_align (3, 0, 0); + + /* We probably can't restore the current segment, for there likely + isn't one yet... */ + if (seg && subseg) + subseg_set (seg, subseg); +} + +#endif /* TE_VMS */