1 /* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
35 - labels are wrong if automatic alignment is introduced
36 (e.g., checkout the second real10 definition in test-data.s)
38 <reg>.safe_across_calls and any other DV-related directives I don't
39 have documentation for.
40 verify mod-sched-brs reads/writes are checked/marked (and other
46 #include "safe-ctype.h"
47 #include "dwarf2dbg.h"
50 #include "opcode/ia64.h"
58 #define NELEMS(a) ((int) (sizeof (a)/sizeof ((a)[0])))
59 #define MIN(a,b) ((a) < (b) ? (a) : (b))
62 #define PREV_SLOT md.slot[(md.curr_slot + NUM_SLOTS - 1) % NUM_SLOTS]
63 #define CURR_SLOT md.slot[md.curr_slot]
65 #define O_pseudo_fixup (O_max + 1)
69 /* IA-64 ABI section pseudo-ops. */
70 SPECIAL_SECTION_BSS
= 0,
72 SPECIAL_SECTION_SDATA
,
73 SPECIAL_SECTION_RODATA
,
74 SPECIAL_SECTION_COMMENT
,
75 SPECIAL_SECTION_UNWIND
,
76 SPECIAL_SECTION_UNWIND_INFO
,
77 /* HPUX specific section pseudo-ops. */
78 SPECIAL_SECTION_INIT_ARRAY
,
79 SPECIAL_SECTION_FINI_ARRAY
,
96 FUNC_LT_FPTR_RELATIVE
,
106 REG_FR
= (REG_GR
+ 128),
107 REG_AR
= (REG_FR
+ 128),
108 REG_CR
= (REG_AR
+ 128),
109 REG_P
= (REG_CR
+ 128),
110 REG_BR
= (REG_P
+ 64),
111 REG_IP
= (REG_BR
+ 8),
118 /* The following are pseudo-registers for use by gas only. */
130 /* The following pseudo-registers are used for unwind directives only: */
138 DYNREG_GR
= 0, /* dynamic general purpose register */
139 DYNREG_FR
, /* dynamic floating point register */
140 DYNREG_PR
, /* dynamic predicate register */
144 enum operand_match_result
147 OPERAND_OUT_OF_RANGE
,
151 /* On the ia64, we can't know the address of a text label until the
152 instructions are packed into a bundle. To handle this, we keep
153 track of the list of labels that appear in front of each
157 struct label_fix
*next
;
161 /* This is the endianness of the current section. */
162 extern int target_big_endian
;
164 /* This is the default endianness. */
165 static int default_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
167 void (*ia64_number_to_chars
) PARAMS ((char *, valueT
, int));
169 static void ia64_float_to_chars_bigendian
170 PARAMS ((char *, LITTLENUM_TYPE
*, int));
171 static void ia64_float_to_chars_littleendian
172 PARAMS ((char *, LITTLENUM_TYPE
*, int));
173 static void (*ia64_float_to_chars
)
174 PARAMS ((char *, LITTLENUM_TYPE
*, int));
176 static struct hash_control
*alias_hash
;
177 static struct hash_control
*alias_name_hash
;
178 static struct hash_control
*secalias_hash
;
179 static struct hash_control
*secalias_name_hash
;
181 /* List of chars besides those in app.c:symbol_chars that can start an
182 operand. Used to prevent the scrubber eating vital white-space. */
183 const char ia64_symbol_chars
[] = "@?";
185 /* Characters which always start a comment. */
186 const char comment_chars
[] = "";
188 /* Characters which start a comment at the beginning of a line. */
189 const char line_comment_chars
[] = "#";
191 /* Characters which may be used to separate multiple commands on a
193 const char line_separator_chars
[] = ";";
195 /* Characters which are used to indicate an exponent in a floating
197 const char EXP_CHARS
[] = "eE";
199 /* Characters which mean that a number is a floating point constant,
201 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
203 /* ia64-specific option processing: */
205 const char *md_shortopts
= "m:N:x::";
207 struct option md_longopts
[] =
209 #define OPTION_MCONSTANT_GP (OPTION_MD_BASE + 1)
210 {"mconstant-gp", no_argument
, NULL
, OPTION_MCONSTANT_GP
},
211 #define OPTION_MAUTO_PIC (OPTION_MD_BASE + 2)
212 {"mauto-pic", no_argument
, NULL
, OPTION_MAUTO_PIC
}
215 size_t md_longopts_size
= sizeof (md_longopts
);
219 struct hash_control
*pseudo_hash
; /* pseudo opcode hash table */
220 struct hash_control
*reg_hash
; /* register name hash table */
221 struct hash_control
*dynreg_hash
; /* dynamic register hash table */
222 struct hash_control
*const_hash
; /* constant hash table */
223 struct hash_control
*entry_hash
; /* code entry hint hash table */
225 symbolS
*regsym
[REG_NUM
];
227 /* If X_op is != O_absent, the registername for the instruction's
228 qualifying predicate. If NULL, p0 is assumed for instructions
229 that are predicatable. */
232 /* What to do when hint.b is used. */
244 explicit_mode
: 1, /* which mode we're in */
245 default_explicit_mode
: 1, /* which mode is the default */
246 mode_explicitly_set
: 1, /* was the current mode explicitly set? */
248 keep_pending_output
: 1;
250 /* What to do when something is wrong with unwind directives. */
253 unwind_check_warning
,
257 /* Each bundle consists of up to three instructions. We keep
258 track of four most recent instructions so we can correctly set
259 the end_of_insn_group for the last instruction in a bundle. */
261 int num_slots_in_use
;
265 end_of_insn_group
: 1,
266 manual_bundling_on
: 1,
267 manual_bundling_off
: 1,
268 loc_directive_seen
: 1;
269 signed char user_template
; /* user-selected template, if any */
270 unsigned char qp_regno
; /* qualifying predicate */
271 /* This duplicates a good fraction of "struct fix" but we
272 can't use a "struct fix" instead since we can't call
273 fix_new_exp() until we know the address of the instruction. */
277 bfd_reloc_code_real_type code
;
278 enum ia64_opnd opnd
; /* type of operand in need of fix */
279 unsigned int is_pcrel
: 1; /* is operand pc-relative? */
280 expressionS expr
; /* the value to be inserted */
282 fixup
[2]; /* at most two fixups per insn */
283 struct ia64_opcode
*idesc
;
284 struct label_fix
*label_fixups
;
285 struct label_fix
*tag_fixups
;
286 struct unw_rec_list
*unwind_record
; /* Unwind directive. */
289 unsigned int src_line
;
290 struct dwarf2_line_info debug_line
;
298 struct dynreg
*next
; /* next dynamic register */
300 unsigned short base
; /* the base register number */
301 unsigned short num_regs
; /* # of registers in this set */
303 *dynreg
[DYNREG_NUM_TYPES
], in
, loc
, out
, rot
;
305 flagword flags
; /* ELF-header flags */
308 unsigned hint
:1; /* is this hint currently valid? */
309 bfd_vma offset
; /* mem.offset offset */
310 bfd_vma base
; /* mem.offset base */
313 int path
; /* number of alt. entry points seen */
314 const char **entry_labels
; /* labels of all alternate paths in
315 the current DV-checking block. */
316 int maxpaths
; /* size currently allocated for
319 int pointer_size
; /* size in bytes of a pointer */
320 int pointer_size_shift
; /* shift size of a pointer for alignment */
324 /* application registers: */
330 #define AR_BSPSTORE 18
345 {"ar.k0", 0}, {"ar.k1", 1}, {"ar.k2", 2}, {"ar.k3", 3},
346 {"ar.k4", 4}, {"ar.k5", 5}, {"ar.k6", 6}, {"ar.k7", 7},
347 {"ar.rsc", 16}, {"ar.bsp", 17},
348 {"ar.bspstore", 18}, {"ar.rnat", 19},
349 {"ar.fcr", 21}, {"ar.eflag", 24},
350 {"ar.csd", 25}, {"ar.ssd", 26},
351 {"ar.cflg", 27}, {"ar.fsr", 28},
352 {"ar.fir", 29}, {"ar.fdr", 30},
353 {"ar.ccv", 32}, {"ar.unat", 36},
354 {"ar.fpsr", 40}, {"ar.itc", 44},
355 {"ar.pfs", 64}, {"ar.lc", 65},
376 /* control registers: */
418 static const struct const_desc
425 /* PSR constant masks: */
428 {"psr.be", ((valueT
) 1) << 1},
429 {"psr.up", ((valueT
) 1) << 2},
430 {"psr.ac", ((valueT
) 1) << 3},
431 {"psr.mfl", ((valueT
) 1) << 4},
432 {"psr.mfh", ((valueT
) 1) << 5},
434 {"psr.ic", ((valueT
) 1) << 13},
435 {"psr.i", ((valueT
) 1) << 14},
436 {"psr.pk", ((valueT
) 1) << 15},
438 {"psr.dt", ((valueT
) 1) << 17},
439 {"psr.dfl", ((valueT
) 1) << 18},
440 {"psr.dfh", ((valueT
) 1) << 19},
441 {"psr.sp", ((valueT
) 1) << 20},
442 {"psr.pp", ((valueT
) 1) << 21},
443 {"psr.di", ((valueT
) 1) << 22},
444 {"psr.si", ((valueT
) 1) << 23},
445 {"psr.db", ((valueT
) 1) << 24},
446 {"psr.lp", ((valueT
) 1) << 25},
447 {"psr.tb", ((valueT
) 1) << 26},
448 {"psr.rt", ((valueT
) 1) << 27},
449 /* 28-31: reserved */
450 /* 32-33: cpl (current privilege level) */
451 {"psr.is", ((valueT
) 1) << 34},
452 {"psr.mc", ((valueT
) 1) << 35},
453 {"psr.it", ((valueT
) 1) << 36},
454 {"psr.id", ((valueT
) 1) << 37},
455 {"psr.da", ((valueT
) 1) << 38},
456 {"psr.dd", ((valueT
) 1) << 39},
457 {"psr.ss", ((valueT
) 1) << 40},
458 /* 41-42: ri (restart instruction) */
459 {"psr.ed", ((valueT
) 1) << 43},
460 {"psr.bn", ((valueT
) 1) << 44},
463 /* indirect register-sets/memory: */
472 { "CPUID", IND_CPUID
},
473 { "cpuid", IND_CPUID
},
485 /* Pseudo functions used to indicate relocation types (these functions
486 start with an at sign (@). */
508 /* reloc pseudo functions (these must come first!): */
509 { "dtpmod", PSEUDO_FUNC_RELOC
, { 0 } },
510 { "dtprel", PSEUDO_FUNC_RELOC
, { 0 } },
511 { "fptr", PSEUDO_FUNC_RELOC
, { 0 } },
512 { "gprel", PSEUDO_FUNC_RELOC
, { 0 } },
513 { "ltoff", PSEUDO_FUNC_RELOC
, { 0 } },
514 { "ltoffx", PSEUDO_FUNC_RELOC
, { 0 } },
515 { "pcrel", PSEUDO_FUNC_RELOC
, { 0 } },
516 { "pltoff", PSEUDO_FUNC_RELOC
, { 0 } },
517 { "secrel", PSEUDO_FUNC_RELOC
, { 0 } },
518 { "segrel", PSEUDO_FUNC_RELOC
, { 0 } },
519 { "tprel", PSEUDO_FUNC_RELOC
, { 0 } },
520 { "ltv", PSEUDO_FUNC_RELOC
, { 0 } },
521 { NULL
, 0, { 0 } }, /* placeholder for FUNC_LT_FPTR_RELATIVE */
522 { NULL
, 0, { 0 } }, /* placeholder for FUNC_LT_DTP_MODULE */
523 { NULL
, 0, { 0 } }, /* placeholder for FUNC_LT_DTP_RELATIVE */
524 { NULL
, 0, { 0 } }, /* placeholder for FUNC_LT_TP_RELATIVE */
525 { "iplt", PSEUDO_FUNC_RELOC
, { 0 } },
527 /* mbtype4 constants: */
528 { "alt", PSEUDO_FUNC_CONST
, { 0xa } },
529 { "brcst", PSEUDO_FUNC_CONST
, { 0x0 } },
530 { "mix", PSEUDO_FUNC_CONST
, { 0x8 } },
531 { "rev", PSEUDO_FUNC_CONST
, { 0xb } },
532 { "shuf", PSEUDO_FUNC_CONST
, { 0x9 } },
534 /* fclass constants: */
535 { "nat", PSEUDO_FUNC_CONST
, { 0x100 } },
536 { "qnan", PSEUDO_FUNC_CONST
, { 0x080 } },
537 { "snan", PSEUDO_FUNC_CONST
, { 0x040 } },
538 { "pos", PSEUDO_FUNC_CONST
, { 0x001 } },
539 { "neg", PSEUDO_FUNC_CONST
, { 0x002 } },
540 { "zero", PSEUDO_FUNC_CONST
, { 0x004 } },
541 { "unorm", PSEUDO_FUNC_CONST
, { 0x008 } },
542 { "norm", PSEUDO_FUNC_CONST
, { 0x010 } },
543 { "inf", PSEUDO_FUNC_CONST
, { 0x020 } },
545 { "natval", PSEUDO_FUNC_CONST
, { 0x100 } }, /* old usage */
547 /* hint constants: */
548 { "pause", PSEUDO_FUNC_CONST
, { 0x0 } },
550 /* unwind-related constants: */
551 { "svr4", PSEUDO_FUNC_CONST
, { ELFOSABI_NONE
} },
552 { "hpux", PSEUDO_FUNC_CONST
, { ELFOSABI_HPUX
} },
553 { "nt", PSEUDO_FUNC_CONST
, { 2 } }, /* conflicts w/ELFOSABI_NETBSD */
554 { "linux", PSEUDO_FUNC_CONST
, { ELFOSABI_LINUX
} },
555 { "freebsd", PSEUDO_FUNC_CONST
, { ELFOSABI_FREEBSD
} },
556 { "openvms", PSEUDO_FUNC_CONST
, { ELFOSABI_OPENVMS
} },
557 { "nsk", PSEUDO_FUNC_CONST
, { ELFOSABI_NSK
} },
559 /* unwind-related registers: */
560 { "priunat",PSEUDO_FUNC_REG
, { REG_PRIUNAT
} }
563 /* 41-bit nop opcodes (one per unit): */
564 static const bfd_vma nop
[IA64_NUM_UNITS
] =
566 0x0000000000LL
, /* NIL => break 0 */
567 0x0008000000LL
, /* I-unit nop */
568 0x0008000000LL
, /* M-unit nop */
569 0x4000000000LL
, /* B-unit nop */
570 0x0008000000LL
, /* F-unit nop */
571 0x0008000000LL
, /* L-"unit" nop */
572 0x0008000000LL
, /* X-unit nop */
575 /* Can't be `const' as it's passed to input routines (which have the
576 habit of setting temporary sentinels. */
577 static char special_section_name
[][20] =
579 {".bss"}, {".sbss"}, {".sdata"}, {".rodata"}, {".comment"},
580 {".IA_64.unwind"}, {".IA_64.unwind_info"},
581 {".init_array"}, {".fini_array"}
584 /* The best template for a particular sequence of up to three
586 #define N IA64_NUM_TYPES
587 static unsigned char best_template
[N
][N
][N
];
590 /* Resource dependencies currently in effect */
592 int depind
; /* dependency index */
593 const struct ia64_dependency
*dependency
; /* actual dependency */
594 unsigned specific
:1, /* is this a specific bit/regno? */
595 link_to_qp_branch
:1; /* will a branch on the same QP clear it?*/
596 int index
; /* specific regno/bit within dependency */
597 int note
; /* optional qualifying note (0 if none) */
601 int insn_srlz
; /* current insn serialization state */
602 int data_srlz
; /* current data serialization state */
603 int qp_regno
; /* qualifying predicate for this usage */
604 char *file
; /* what file marked this dependency */
605 unsigned int line
; /* what line marked this dependency */
606 struct mem_offset mem_offset
; /* optional memory offset hint */
607 enum { CMP_NONE
, CMP_OR
, CMP_AND
} cmp_type
; /* OR or AND compare? */
608 int path
; /* corresponding code entry index */
610 static int regdepslen
= 0;
611 static int regdepstotlen
= 0;
612 static const char *dv_mode
[] = { "RAW", "WAW", "WAR" };
613 static const char *dv_sem
[] = { "none", "implied", "impliedf",
614 "data", "instr", "specific", "stop", "other" };
615 static const char *dv_cmp_type
[] = { "none", "OR", "AND" };
617 /* Current state of PR mutexation */
618 static struct qpmutex
{
621 } *qp_mutexes
= NULL
; /* QP mutex bitmasks */
622 static int qp_mutexeslen
= 0;
623 static int qp_mutexestotlen
= 0;
624 static valueT qp_safe_across_calls
= 0;
626 /* Current state of PR implications */
627 static struct qp_imply
{
630 unsigned p2_branched
:1;
632 } *qp_implies
= NULL
;
633 static int qp_implieslen
= 0;
634 static int qp_impliestotlen
= 0;
636 /* Keep track of static GR values so that indirect register usage can
637 sometimes be tracked. */
648 (((1 << (8 * sizeof(gr_values
->path
) - 2)) - 1) << 1) + 1,
654 /* Remember the alignment frag. */
655 static fragS
*align_frag
;
657 /* These are the routines required to output the various types of
660 /* A slot_number is a frag address plus the slot index (0-2). We use the
661 frag address here so that if there is a section switch in the middle of
662 a function, then instructions emitted to a different section are not
663 counted. Since there may be more than one frag for a function, this
664 means we also need to keep track of which frag this address belongs to
665 so we can compute inter-frag distances. This also nicely solves the
666 problem with nops emitted for align directives, which can't easily be
667 counted, but can easily be derived from frag sizes. */
669 typedef struct unw_rec_list
{
671 unsigned long slot_number
;
673 unsigned long next_slot_number
;
674 fragS
*next_slot_frag
;
675 struct unw_rec_list
*next
;
678 #define SLOT_NUM_NOT_SET (unsigned)-1
680 /* Linked list of saved prologue counts. A very poor
681 implementation of a map from label numbers to prologue counts. */
682 typedef struct label_prologue_count
684 struct label_prologue_count
*next
;
685 unsigned long label_number
;
686 unsigned int prologue_count
;
687 } label_prologue_count
;
691 /* Maintain a list of unwind entries for the current function. */
695 /* Any unwind entires that should be attached to the current slot
696 that an insn is being constructed for. */
697 unw_rec_list
*current_entry
;
699 /* These are used to create the unwind table entry for this function. */
701 symbolS
*info
; /* pointer to unwind info */
702 symbolS
*personality_routine
;
704 subsegT saved_text_subseg
;
705 unsigned int force_unwind_entry
: 1; /* force generation of unwind entry? */
707 /* TRUE if processing unwind directives in a prologue region. */
708 unsigned int prologue
: 1;
709 unsigned int prologue_mask
: 4;
710 unsigned int body
: 1;
711 unsigned int insn
: 1;
712 unsigned int prologue_count
; /* number of .prologues seen so far */
713 /* Prologue counts at previous .label_state directives. */
714 struct label_prologue_count
* saved_prologue_counts
;
717 /* The input value is a negated offset from psp, and specifies an address
718 psp - offset. The encoded value is psp + 16 - (4 * offset). Thus we
719 must add 16 and divide by 4 to get the encoded value. */
721 #define ENCODED_PSP_OFFSET(OFFSET) (((OFFSET) + 16) / 4)
723 typedef void (*vbyte_func
) PARAMS ((int, char *, char *));
725 /* Forward declarations: */
726 static void set_section
PARAMS ((char *name
));
727 static unsigned int set_regstack
PARAMS ((unsigned int, unsigned int,
728 unsigned int, unsigned int));
729 static void dot_align (int);
730 static void dot_radix
PARAMS ((int));
731 static void dot_special_section
PARAMS ((int));
732 static void dot_proc
PARAMS ((int));
733 static void dot_fframe
PARAMS ((int));
734 static void dot_vframe
PARAMS ((int));
735 static void dot_vframesp
PARAMS ((int));
736 static void dot_vframepsp
PARAMS ((int));
737 static void dot_save
PARAMS ((int));
738 static void dot_restore
PARAMS ((int));
739 static void dot_restorereg
PARAMS ((int));
740 static void dot_restorereg_p
PARAMS ((int));
741 static void dot_handlerdata
PARAMS ((int));
742 static void dot_unwentry
PARAMS ((int));
743 static void dot_altrp
PARAMS ((int));
744 static void dot_savemem
PARAMS ((int));
745 static void dot_saveg
PARAMS ((int));
746 static void dot_savef
PARAMS ((int));
747 static void dot_saveb
PARAMS ((int));
748 static void dot_savegf
PARAMS ((int));
749 static void dot_spill
PARAMS ((int));
750 static void dot_spillreg
PARAMS ((int));
751 static void dot_spillmem
PARAMS ((int));
752 static void dot_spillreg_p
PARAMS ((int));
753 static void dot_spillmem_p
PARAMS ((int));
754 static void dot_label_state
PARAMS ((int));
755 static void dot_copy_state
PARAMS ((int));
756 static void dot_unwabi
PARAMS ((int));
757 static void dot_personality
PARAMS ((int));
758 static void dot_body
PARAMS ((int));
759 static void dot_prologue
PARAMS ((int));
760 static void dot_endp
PARAMS ((int));
761 static void dot_template
PARAMS ((int));
762 static void dot_regstk
PARAMS ((int));
763 static void dot_rot
PARAMS ((int));
764 static void dot_byteorder
PARAMS ((int));
765 static void dot_psr
PARAMS ((int));
766 static void dot_alias
PARAMS ((int));
767 static void dot_ln
PARAMS ((int));
768 static void cross_section
PARAMS ((int ref
, void (*cons
) PARAMS((int)), int ua
));
769 static void dot_xdata
PARAMS ((int));
770 static void stmt_float_cons
PARAMS ((int));
771 static void stmt_cons_ua
PARAMS ((int));
772 static void dot_xfloat_cons
PARAMS ((int));
773 static void dot_xstringer
PARAMS ((int));
774 static void dot_xdata_ua
PARAMS ((int));
775 static void dot_xfloat_cons_ua
PARAMS ((int));
776 static void print_prmask
PARAMS ((valueT mask
));
777 static void dot_pred_rel
PARAMS ((int));
778 static void dot_reg_val
PARAMS ((int));
779 static void dot_serialize
PARAMS ((int));
780 static void dot_dv_mode
PARAMS ((int));
781 static void dot_entry
PARAMS ((int));
782 static void dot_mem_offset
PARAMS ((int));
783 static void add_unwind_entry
PARAMS((unw_rec_list
*ptr
));
784 static symbolS
*declare_register
PARAMS ((const char *name
, int regnum
));
785 static void declare_register_set
PARAMS ((const char *, int, int));
786 static unsigned int operand_width
PARAMS ((enum ia64_opnd
));
787 static enum operand_match_result operand_match
PARAMS ((const struct ia64_opcode
*idesc
,
790 static int parse_operand
PARAMS ((expressionS
*e
));
791 static struct ia64_opcode
* parse_operands
PARAMS ((struct ia64_opcode
*));
792 static void build_insn
PARAMS ((struct slot
*, bfd_vma
*));
793 static void emit_one_bundle
PARAMS ((void));
794 static void fix_insn
PARAMS ((fixS
*, const struct ia64_operand
*, valueT
));
795 static bfd_reloc_code_real_type ia64_gen_real_reloc_type
PARAMS ((struct symbol
*sym
,
796 bfd_reloc_code_real_type r_type
));
797 static void insn_group_break
PARAMS ((int, int, int));
798 static void mark_resource
PARAMS ((struct ia64_opcode
*, const struct ia64_dependency
*,
799 struct rsrc
*, int depind
, int path
));
800 static void add_qp_mutex
PARAMS((valueT mask
));
801 static void add_qp_imply
PARAMS((int p1
, int p2
));
802 static void clear_qp_branch_flag
PARAMS((valueT mask
));
803 static void clear_qp_mutex
PARAMS((valueT mask
));
804 static void clear_qp_implies
PARAMS((valueT p1_mask
, valueT p2_mask
));
805 static int has_suffix_p
PARAMS((const char *, const char *));
806 static void clear_register_values
PARAMS ((void));
807 static void print_dependency
PARAMS ((const char *action
, int depind
));
808 static void instruction_serialization
PARAMS ((void));
809 static void data_serialization
PARAMS ((void));
810 static void remove_marked_resource
PARAMS ((struct rsrc
*));
811 static int is_conditional_branch
PARAMS ((struct ia64_opcode
*));
812 static int is_taken_branch
PARAMS ((struct ia64_opcode
*));
813 static int is_interruption_or_rfi
PARAMS ((struct ia64_opcode
*));
814 static int depends_on
PARAMS ((int, struct ia64_opcode
*));
815 static int specify_resource
PARAMS ((const struct ia64_dependency
*,
816 struct ia64_opcode
*, int, struct rsrc
[], int, int));
817 static int check_dv
PARAMS((struct ia64_opcode
*idesc
));
818 static void check_dependencies
PARAMS((struct ia64_opcode
*));
819 static void mark_resources
PARAMS((struct ia64_opcode
*));
820 static void update_dependencies
PARAMS((struct ia64_opcode
*));
821 static void note_register_values
PARAMS((struct ia64_opcode
*));
822 static int qp_mutex
PARAMS ((int, int, int));
823 static int resources_match
PARAMS ((struct rsrc
*, struct ia64_opcode
*, int, int, int));
824 static void output_vbyte_mem
PARAMS ((int, char *, char *));
825 static void count_output
PARAMS ((int, char *, char *));
826 static void output_R1_format
PARAMS ((vbyte_func
, unw_record_type
, int));
827 static void output_R2_format
PARAMS ((vbyte_func
, int, int, unsigned long));
828 static void output_R3_format
PARAMS ((vbyte_func
, unw_record_type
, unsigned long));
829 static void output_P1_format
PARAMS ((vbyte_func
, int));
830 static void output_P2_format
PARAMS ((vbyte_func
, int, int));
831 static void output_P3_format
PARAMS ((vbyte_func
, unw_record_type
, int));
832 static void output_P4_format
PARAMS ((vbyte_func
, unsigned char *, unsigned long));
833 static void output_P5_format
PARAMS ((vbyte_func
, int, unsigned long));
834 static void output_P6_format
PARAMS ((vbyte_func
, unw_record_type
, int));
835 static void output_P7_format
PARAMS ((vbyte_func
, unw_record_type
, unsigned long, unsigned long));
836 static void output_P8_format
PARAMS ((vbyte_func
, unw_record_type
, unsigned long));
837 static void output_P9_format
PARAMS ((vbyte_func
, int, int));
838 static void output_P10_format
PARAMS ((vbyte_func
, int, int));
839 static void output_B1_format
PARAMS ((vbyte_func
, unw_record_type
, unsigned long));
840 static void output_B2_format
PARAMS ((vbyte_func
, unsigned long, unsigned long));
841 static void output_B3_format
PARAMS ((vbyte_func
, unsigned long, unsigned long));
842 static void output_B4_format
PARAMS ((vbyte_func
, unw_record_type
, unsigned long));
843 static char format_ab_reg
PARAMS ((int, int));
844 static void output_X1_format
PARAMS ((vbyte_func
, unw_record_type
, int, int, unsigned long,
846 static void output_X2_format
PARAMS ((vbyte_func
, int, int, int, int, int, unsigned long));
847 static void output_X3_format
PARAMS ((vbyte_func
, unw_record_type
, int, int, int, unsigned long,
849 static void output_X4_format
PARAMS ((vbyte_func
, int, int, int, int, int, int, unsigned long));
850 static unw_rec_list
*output_endp
PARAMS ((void));
851 static unw_rec_list
*output_prologue
PARAMS ((void));
852 static unw_rec_list
*output_prologue_gr
PARAMS ((unsigned int, unsigned int));
853 static unw_rec_list
*output_body
PARAMS ((void));
854 static unw_rec_list
*output_mem_stack_f
PARAMS ((unsigned int));
855 static unw_rec_list
*output_mem_stack_v
PARAMS ((void));
856 static unw_rec_list
*output_psp_gr
PARAMS ((unsigned int));
857 static unw_rec_list
*output_psp_sprel
PARAMS ((unsigned int));
858 static unw_rec_list
*output_rp_when
PARAMS ((void));
859 static unw_rec_list
*output_rp_gr
PARAMS ((unsigned int));
860 static unw_rec_list
*output_rp_br
PARAMS ((unsigned int));
861 static unw_rec_list
*output_rp_psprel
PARAMS ((unsigned int));
862 static unw_rec_list
*output_rp_sprel
PARAMS ((unsigned int));
863 static unw_rec_list
*output_pfs_when
PARAMS ((void));
864 static unw_rec_list
*output_pfs_gr
PARAMS ((unsigned int));
865 static unw_rec_list
*output_pfs_psprel
PARAMS ((unsigned int));
866 static unw_rec_list
*output_pfs_sprel
PARAMS ((unsigned int));
867 static unw_rec_list
*output_preds_when
PARAMS ((void));
868 static unw_rec_list
*output_preds_gr
PARAMS ((unsigned int));
869 static unw_rec_list
*output_preds_psprel
PARAMS ((unsigned int));
870 static unw_rec_list
*output_preds_sprel
PARAMS ((unsigned int));
871 static unw_rec_list
*output_fr_mem
PARAMS ((unsigned int));
872 static unw_rec_list
*output_frgr_mem
PARAMS ((unsigned int, unsigned int));
873 static unw_rec_list
*output_gr_gr
PARAMS ((unsigned int, unsigned int));
874 static unw_rec_list
*output_gr_mem
PARAMS ((unsigned int));
875 static unw_rec_list
*output_br_mem
PARAMS ((unsigned int));
876 static unw_rec_list
*output_br_gr
PARAMS ((unsigned int, unsigned int));
877 static unw_rec_list
*output_spill_base
PARAMS ((unsigned int));
878 static unw_rec_list
*output_unat_when
PARAMS ((void));
879 static unw_rec_list
*output_unat_gr
PARAMS ((unsigned int));
880 static unw_rec_list
*output_unat_psprel
PARAMS ((unsigned int));
881 static unw_rec_list
*output_unat_sprel
PARAMS ((unsigned int));
882 static unw_rec_list
*output_lc_when
PARAMS ((void));
883 static unw_rec_list
*output_lc_gr
PARAMS ((unsigned int));
884 static unw_rec_list
*output_lc_psprel
PARAMS ((unsigned int));
885 static unw_rec_list
*output_lc_sprel
PARAMS ((unsigned int));
886 static unw_rec_list
*output_fpsr_when
PARAMS ((void));
887 static unw_rec_list
*output_fpsr_gr
PARAMS ((unsigned int));
888 static unw_rec_list
*output_fpsr_psprel
PARAMS ((unsigned int));
889 static unw_rec_list
*output_fpsr_sprel
PARAMS ((unsigned int));
890 static unw_rec_list
*output_priunat_when_gr
PARAMS ((void));
891 static unw_rec_list
*output_priunat_when_mem
PARAMS ((void));
892 static unw_rec_list
*output_priunat_gr
PARAMS ((unsigned int));
893 static unw_rec_list
*output_priunat_psprel
PARAMS ((unsigned int));
894 static unw_rec_list
*output_priunat_sprel
PARAMS ((unsigned int));
895 static unw_rec_list
*output_bsp_when
PARAMS ((void));
896 static unw_rec_list
*output_bsp_gr
PARAMS ((unsigned int));
897 static unw_rec_list
*output_bsp_psprel
PARAMS ((unsigned int));
898 static unw_rec_list
*output_bsp_sprel
PARAMS ((unsigned int));
899 static unw_rec_list
*output_bspstore_when
PARAMS ((void));
900 static unw_rec_list
*output_bspstore_gr
PARAMS ((unsigned int));
901 static unw_rec_list
*output_bspstore_psprel
PARAMS ((unsigned int));
902 static unw_rec_list
*output_bspstore_sprel
PARAMS ((unsigned int));
903 static unw_rec_list
*output_rnat_when
PARAMS ((void));
904 static unw_rec_list
*output_rnat_gr
PARAMS ((unsigned int));
905 static unw_rec_list
*output_rnat_psprel
PARAMS ((unsigned int));
906 static unw_rec_list
*output_rnat_sprel
PARAMS ((unsigned int));
907 static unw_rec_list
*output_unwabi
PARAMS ((unsigned long, unsigned long));
908 static unw_rec_list
*output_epilogue
PARAMS ((unsigned long));
909 static unw_rec_list
*output_label_state
PARAMS ((unsigned long));
910 static unw_rec_list
*output_copy_state
PARAMS ((unsigned long));
911 static unw_rec_list
*output_spill_psprel
PARAMS ((unsigned int, unsigned int, unsigned int));
912 static unw_rec_list
*output_spill_sprel
PARAMS ((unsigned int, unsigned int, unsigned int));
913 static unw_rec_list
*output_spill_psprel_p
PARAMS ((unsigned int, unsigned int, unsigned int,
915 static unw_rec_list
*output_spill_sprel_p
PARAMS ((unsigned int, unsigned int, unsigned int,
917 static unw_rec_list
*output_spill_reg
PARAMS ((unsigned int, unsigned int, unsigned int,
919 static unw_rec_list
*output_spill_reg_p
PARAMS ((unsigned int, unsigned int, unsigned int,
920 unsigned int, unsigned int));
921 static void process_one_record
PARAMS ((unw_rec_list
*, vbyte_func
));
922 static void process_unw_records
PARAMS ((unw_rec_list
*, vbyte_func
));
923 static int calc_record_size
PARAMS ((unw_rec_list
*));
924 static void set_imask
PARAMS ((unw_rec_list
*, unsigned long, unsigned long, unsigned int));
925 static unsigned long slot_index
PARAMS ((unsigned long, fragS
*,
926 unsigned long, fragS
*,
928 static unw_rec_list
*optimize_unw_records
PARAMS ((unw_rec_list
*));
929 static void fixup_unw_records
PARAMS ((unw_rec_list
*, int));
930 static int convert_expr_to_ab_reg
PARAMS ((expressionS
*, unsigned int *, unsigned int *));
931 static int convert_expr_to_xy_reg
PARAMS ((expressionS
*, unsigned int *, unsigned int *));
932 static unsigned int get_saved_prologue_count
PARAMS ((unsigned long));
933 static void save_prologue_count
PARAMS ((unsigned long, unsigned int));
934 static void free_saved_prologue_counts
PARAMS ((void));
936 /* Determine if application register REGNUM resides only in the integer
937 unit (as opposed to the memory unit). */
939 ar_is_only_in_integer_unit (int reg
)
942 return reg
>= 64 && reg
<= 111;
945 /* Determine if application register REGNUM resides only in the memory
946 unit (as opposed to the integer unit). */
948 ar_is_only_in_memory_unit (int reg
)
951 return reg
>= 0 && reg
<= 47;
954 /* Switch to section NAME and create section if necessary. It's
955 rather ugly that we have to manipulate input_line_pointer but I
956 don't see any other way to accomplish the same thing without
957 changing obj-elf.c (which may be the Right Thing, in the end). */
962 char *saved_input_line_pointer
;
964 saved_input_line_pointer
= input_line_pointer
;
965 input_line_pointer
= name
;
967 input_line_pointer
= saved_input_line_pointer
;
970 /* Map 's' to SHF_IA_64_SHORT. */
973 ia64_elf_section_letter (letter
, ptr_msg
)
978 return SHF_IA_64_SHORT
;
979 else if (letter
== 'o')
980 return SHF_LINK_ORDER
;
982 *ptr_msg
= _("Bad .section directive: want a,o,s,w,x,M,S,G,T in string");
986 /* Map SHF_IA_64_SHORT to SEC_SMALL_DATA. */
989 ia64_elf_section_flags (flags
, attr
, type
)
991 int attr
, type ATTRIBUTE_UNUSED
;
993 if (attr
& SHF_IA_64_SHORT
)
994 flags
|= SEC_SMALL_DATA
;
999 ia64_elf_section_type (str
, len
)
1003 #define STREQ(s) ((len == sizeof (s) - 1) && (strncmp (str, s, sizeof (s) - 1) == 0))
1005 if (STREQ (ELF_STRING_ia64_unwind_info
))
1006 return SHT_PROGBITS
;
1008 if (STREQ (ELF_STRING_ia64_unwind_info_once
))
1009 return SHT_PROGBITS
;
1011 if (STREQ (ELF_STRING_ia64_unwind
))
1012 return SHT_IA_64_UNWIND
;
1014 if (STREQ (ELF_STRING_ia64_unwind_once
))
1015 return SHT_IA_64_UNWIND
;
1017 if (STREQ ("unwind"))
1018 return SHT_IA_64_UNWIND
;
1025 set_regstack (ins
, locs
, outs
, rots
)
1026 unsigned int ins
, locs
, outs
, rots
;
1028 /* Size of frame. */
1031 sof
= ins
+ locs
+ outs
;
1034 as_bad ("Size of frame exceeds maximum of 96 registers");
1039 as_warn ("Size of rotating registers exceeds frame size");
1042 md
.in
.base
= REG_GR
+ 32;
1043 md
.loc
.base
= md
.in
.base
+ ins
;
1044 md
.out
.base
= md
.loc
.base
+ locs
;
1046 md
.in
.num_regs
= ins
;
1047 md
.loc
.num_regs
= locs
;
1048 md
.out
.num_regs
= outs
;
1049 md
.rot
.num_regs
= rots
;
1056 struct label_fix
*lfix
;
1058 subsegT saved_subseg
;
1061 if (!md
.last_text_seg
)
1064 saved_seg
= now_seg
;
1065 saved_subseg
= now_subseg
;
1067 subseg_set (md
.last_text_seg
, 0);
1069 while (md
.num_slots_in_use
> 0)
1070 emit_one_bundle (); /* force out queued instructions */
1072 /* In case there are labels following the last instruction, resolve
1074 for (lfix
= CURR_SLOT
.label_fixups
; lfix
; lfix
= lfix
->next
)
1076 S_SET_VALUE (lfix
->sym
, frag_now_fix ());
1077 symbol_set_frag (lfix
->sym
, frag_now
);
1079 CURR_SLOT
.label_fixups
= 0;
1080 for (lfix
= CURR_SLOT
.tag_fixups
; lfix
; lfix
= lfix
->next
)
1082 S_SET_VALUE (lfix
->sym
, frag_now_fix ());
1083 symbol_set_frag (lfix
->sym
, frag_now
);
1085 CURR_SLOT
.tag_fixups
= 0;
1087 /* In case there are unwind directives following the last instruction,
1088 resolve those now. We only handle prologue, body, and endp directives
1089 here. Give an error for others. */
1090 for (ptr
= unwind
.current_entry
; ptr
; ptr
= ptr
->next
)
1092 switch (ptr
->r
.type
)
1098 ptr
->slot_number
= (unsigned long) frag_more (0);
1099 ptr
->slot_frag
= frag_now
;
1102 /* Allow any record which doesn't have a "t" field (i.e.,
1103 doesn't relate to a particular instruction). */
1119 as_bad (_("Unwind directive not followed by an instruction."));
1123 unwind
.current_entry
= NULL
;
1125 subseg_set (saved_seg
, saved_subseg
);
1127 if (md
.qp
.X_op
== O_register
)
1128 as_bad ("qualifying predicate not followed by instruction");
1132 ia64_do_align (int nbytes
)
1134 char *saved_input_line_pointer
= input_line_pointer
;
1136 input_line_pointer
= "";
1137 s_align_bytes (nbytes
);
1138 input_line_pointer
= saved_input_line_pointer
;
1142 ia64_cons_align (nbytes
)
1147 char *saved_input_line_pointer
= input_line_pointer
;
1148 input_line_pointer
= "";
1149 s_align_bytes (nbytes
);
1150 input_line_pointer
= saved_input_line_pointer
;
1154 /* Output COUNT bytes to a memory location. */
1155 static char *vbyte_mem_ptr
= NULL
;
1158 output_vbyte_mem (count
, ptr
, comment
)
1161 char *comment ATTRIBUTE_UNUSED
;
1164 if (vbyte_mem_ptr
== NULL
)
1169 for (x
= 0; x
< count
; x
++)
1170 *(vbyte_mem_ptr
++) = ptr
[x
];
1173 /* Count the number of bytes required for records. */
1174 static int vbyte_count
= 0;
1176 count_output (count
, ptr
, comment
)
1178 char *ptr ATTRIBUTE_UNUSED
;
1179 char *comment ATTRIBUTE_UNUSED
;
1181 vbyte_count
+= count
;
1185 output_R1_format (f
, rtype
, rlen
)
1187 unw_record_type rtype
;
1194 output_R3_format (f
, rtype
, rlen
);
1200 else if (rtype
!= prologue
)
1201 as_bad ("record type is not valid");
1203 byte
= UNW_R1
| (r
<< 5) | (rlen
& 0x1f);
1204 (*f
) (1, &byte
, NULL
);
1208 output_R2_format (f
, mask
, grsave
, rlen
)
1215 mask
= (mask
& 0x0f);
1216 grsave
= (grsave
& 0x7f);
1218 bytes
[0] = (UNW_R2
| (mask
>> 1));
1219 bytes
[1] = (((mask
& 0x01) << 7) | grsave
);
1220 count
+= output_leb128 (bytes
+ 2, rlen
, 0);
1221 (*f
) (count
, bytes
, NULL
);
1225 output_R3_format (f
, rtype
, rlen
)
1227 unw_record_type rtype
;
1234 output_R1_format (f
, rtype
, rlen
);
1240 else if (rtype
!= prologue
)
1241 as_bad ("record type is not valid");
1242 bytes
[0] = (UNW_R3
| r
);
1243 count
= output_leb128 (bytes
+ 1, rlen
, 0);
1244 (*f
) (count
+ 1, bytes
, NULL
);
1248 output_P1_format (f
, brmask
)
1253 byte
= UNW_P1
| (brmask
& 0x1f);
1254 (*f
) (1, &byte
, NULL
);
1258 output_P2_format (f
, brmask
, gr
)
1264 brmask
= (brmask
& 0x1f);
1265 bytes
[0] = UNW_P2
| (brmask
>> 1);
1266 bytes
[1] = (((brmask
& 1) << 7) | gr
);
1267 (*f
) (2, bytes
, NULL
);
1271 output_P3_format (f
, rtype
, reg
)
1273 unw_record_type rtype
;
1318 as_bad ("Invalid record type for P3 format.");
1320 bytes
[0] = (UNW_P3
| (r
>> 1));
1321 bytes
[1] = (((r
& 1) << 7) | reg
);
1322 (*f
) (2, bytes
, NULL
);
1326 output_P4_format (f
, imask
, imask_size
)
1328 unsigned char *imask
;
1329 unsigned long imask_size
;
1332 (*f
) (imask_size
, (char *) imask
, NULL
);
1336 output_P5_format (f
, grmask
, frmask
)
1339 unsigned long frmask
;
1342 grmask
= (grmask
& 0x0f);
1345 bytes
[1] = ((grmask
<< 4) | ((frmask
& 0x000f0000) >> 16));
1346 bytes
[2] = ((frmask
& 0x0000ff00) >> 8);
1347 bytes
[3] = (frmask
& 0x000000ff);
1348 (*f
) (4, bytes
, NULL
);
1352 output_P6_format (f
, rtype
, rmask
)
1354 unw_record_type rtype
;
1360 if (rtype
== gr_mem
)
1362 else if (rtype
!= fr_mem
)
1363 as_bad ("Invalid record type for format P6");
1364 byte
= (UNW_P6
| (r
<< 4) | (rmask
& 0x0f));
1365 (*f
) (1, &byte
, NULL
);
1369 output_P7_format (f
, rtype
, w1
, w2
)
1371 unw_record_type rtype
;
1378 count
+= output_leb128 (bytes
+ 1, w1
, 0);
1383 count
+= output_leb128 (bytes
+ count
, w2
>> 4, 0);
1433 bytes
[0] = (UNW_P7
| r
);
1434 (*f
) (count
, bytes
, NULL
);
1438 output_P8_format (f
, rtype
, t
)
1440 unw_record_type rtype
;
1479 case bspstore_psprel
:
1482 case bspstore_sprel
:
1494 case priunat_when_gr
:
1497 case priunat_psprel
:
1503 case priunat_when_mem
:
1510 count
+= output_leb128 (bytes
+ 2, t
, 0);
1511 (*f
) (count
, bytes
, NULL
);
1515 output_P9_format (f
, grmask
, gr
)
1522 bytes
[1] = (grmask
& 0x0f);
1523 bytes
[2] = (gr
& 0x7f);
1524 (*f
) (3, bytes
, NULL
);
1528 output_P10_format (f
, abi
, context
)
1535 bytes
[1] = (abi
& 0xff);
1536 bytes
[2] = (context
& 0xff);
1537 (*f
) (3, bytes
, NULL
);
1541 output_B1_format (f
, rtype
, label
)
1543 unw_record_type rtype
;
1544 unsigned long label
;
1550 output_B4_format (f
, rtype
, label
);
1553 if (rtype
== copy_state
)
1555 else if (rtype
!= label_state
)
1556 as_bad ("Invalid record type for format B1");
1558 byte
= (UNW_B1
| (r
<< 5) | (label
& 0x1f));
1559 (*f
) (1, &byte
, NULL
);
1563 output_B2_format (f
, ecount
, t
)
1565 unsigned long ecount
;
1572 output_B3_format (f
, ecount
, t
);
1575 bytes
[0] = (UNW_B2
| (ecount
& 0x1f));
1576 count
+= output_leb128 (bytes
+ 1, t
, 0);
1577 (*f
) (count
, bytes
, NULL
);
1581 output_B3_format (f
, ecount
, t
)
1583 unsigned long ecount
;
1590 output_B2_format (f
, ecount
, t
);
1594 count
+= output_leb128 (bytes
+ 1, t
, 0);
1595 count
+= output_leb128 (bytes
+ count
, ecount
, 0);
1596 (*f
) (count
, bytes
, NULL
);
1600 output_B4_format (f
, rtype
, label
)
1602 unw_record_type rtype
;
1603 unsigned long label
;
1610 output_B1_format (f
, rtype
, label
);
1614 if (rtype
== copy_state
)
1616 else if (rtype
!= label_state
)
1617 as_bad ("Invalid record type for format B1");
1619 bytes
[0] = (UNW_B4
| (r
<< 3));
1620 count
+= output_leb128 (bytes
+ 1, label
, 0);
1621 (*f
) (count
, bytes
, NULL
);
1625 format_ab_reg (ab
, reg
)
1632 ret
= (ab
<< 5) | reg
;
1637 output_X1_format (f
, rtype
, ab
, reg
, t
, w1
)
1639 unw_record_type rtype
;
1649 if (rtype
== spill_sprel
)
1651 else if (rtype
!= spill_psprel
)
1652 as_bad ("Invalid record type for format X1");
1653 bytes
[1] = ((r
<< 7) | format_ab_reg (ab
, reg
));
1654 count
+= output_leb128 (bytes
+ 2, t
, 0);
1655 count
+= output_leb128 (bytes
+ count
, w1
, 0);
1656 (*f
) (count
, bytes
, NULL
);
1660 output_X2_format (f
, ab
, reg
, x
, y
, treg
, t
)
1669 bytes
[1] = (((x
& 1) << 7) | format_ab_reg (ab
, reg
));
1670 bytes
[2] = (((y
& 1) << 7) | (treg
& 0x7f));
1671 count
+= output_leb128 (bytes
+ 3, t
, 0);
1672 (*f
) (count
, bytes
, NULL
);
1676 output_X3_format (f
, rtype
, qp
, ab
, reg
, t
, w1
)
1678 unw_record_type rtype
;
1689 if (rtype
== spill_sprel_p
)
1691 else if (rtype
!= spill_psprel_p
)
1692 as_bad ("Invalid record type for format X3");
1693 bytes
[1] = ((r
<< 7) | (qp
& 0x3f));
1694 bytes
[2] = format_ab_reg (ab
, reg
);
1695 count
+= output_leb128 (bytes
+ 3, t
, 0);
1696 count
+= output_leb128 (bytes
+ count
, w1
, 0);
1697 (*f
) (count
, bytes
, NULL
);
1701 output_X4_format (f
, qp
, ab
, reg
, x
, y
, treg
, t
)
1711 bytes
[1] = (qp
& 0x3f);
1712 bytes
[2] = (((x
& 1) << 7) | format_ab_reg (ab
, reg
));
1713 bytes
[3] = (((y
& 1) << 7) | (treg
& 0x7f));
1714 count
+= output_leb128 (bytes
+ 4, t
, 0);
1715 (*f
) (count
, bytes
, NULL
);
1718 /* This function allocates a record list structure, and initializes fields. */
1720 static unw_rec_list
*
1721 alloc_record (unw_record_type t
)
1724 ptr
= xmalloc (sizeof (*ptr
));
1726 ptr
->slot_number
= SLOT_NUM_NOT_SET
;
1728 ptr
->next_slot_number
= 0;
1729 ptr
->next_slot_frag
= 0;
1733 /* Dummy unwind record used for calculating the length of the last prologue or
1736 static unw_rec_list
*
1739 unw_rec_list
*ptr
= alloc_record (endp
);
1743 static unw_rec_list
*
1746 unw_rec_list
*ptr
= alloc_record (prologue
);
1747 memset (&ptr
->r
.record
.r
.mask
, 0, sizeof (ptr
->r
.record
.r
.mask
));
1751 static unw_rec_list
*
1752 output_prologue_gr (saved_mask
, reg
)
1753 unsigned int saved_mask
;
1756 unw_rec_list
*ptr
= alloc_record (prologue_gr
);
1757 memset (&ptr
->r
.record
.r
.mask
, 0, sizeof (ptr
->r
.record
.r
.mask
));
1758 ptr
->r
.record
.r
.grmask
= saved_mask
;
1759 ptr
->r
.record
.r
.grsave
= reg
;
1763 static unw_rec_list
*
1766 unw_rec_list
*ptr
= alloc_record (body
);
1770 static unw_rec_list
*
1771 output_mem_stack_f (size
)
1774 unw_rec_list
*ptr
= alloc_record (mem_stack_f
);
1775 ptr
->r
.record
.p
.size
= size
;
1779 static unw_rec_list
*
1780 output_mem_stack_v ()
1782 unw_rec_list
*ptr
= alloc_record (mem_stack_v
);
1786 static unw_rec_list
*
1790 unw_rec_list
*ptr
= alloc_record (psp_gr
);
1791 ptr
->r
.record
.p
.gr
= gr
;
1795 static unw_rec_list
*
1796 output_psp_sprel (offset
)
1797 unsigned int offset
;
1799 unw_rec_list
*ptr
= alloc_record (psp_sprel
);
1800 ptr
->r
.record
.p
.spoff
= offset
/ 4;
1804 static unw_rec_list
*
1807 unw_rec_list
*ptr
= alloc_record (rp_when
);
1811 static unw_rec_list
*
1815 unw_rec_list
*ptr
= alloc_record (rp_gr
);
1816 ptr
->r
.record
.p
.gr
= gr
;
1820 static unw_rec_list
*
1824 unw_rec_list
*ptr
= alloc_record (rp_br
);
1825 ptr
->r
.record
.p
.br
= br
;
1829 static unw_rec_list
*
1830 output_rp_psprel (offset
)
1831 unsigned int offset
;
1833 unw_rec_list
*ptr
= alloc_record (rp_psprel
);
1834 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
1838 static unw_rec_list
*
1839 output_rp_sprel (offset
)
1840 unsigned int offset
;
1842 unw_rec_list
*ptr
= alloc_record (rp_sprel
);
1843 ptr
->r
.record
.p
.spoff
= offset
/ 4;
1847 static unw_rec_list
*
1850 unw_rec_list
*ptr
= alloc_record (pfs_when
);
1854 static unw_rec_list
*
1858 unw_rec_list
*ptr
= alloc_record (pfs_gr
);
1859 ptr
->r
.record
.p
.gr
= gr
;
1863 static unw_rec_list
*
1864 output_pfs_psprel (offset
)
1865 unsigned int offset
;
1867 unw_rec_list
*ptr
= alloc_record (pfs_psprel
);
1868 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
1872 static unw_rec_list
*
1873 output_pfs_sprel (offset
)
1874 unsigned int offset
;
1876 unw_rec_list
*ptr
= alloc_record (pfs_sprel
);
1877 ptr
->r
.record
.p
.spoff
= offset
/ 4;
1881 static unw_rec_list
*
1882 output_preds_when ()
1884 unw_rec_list
*ptr
= alloc_record (preds_when
);
1888 static unw_rec_list
*
1889 output_preds_gr (gr
)
1892 unw_rec_list
*ptr
= alloc_record (preds_gr
);
1893 ptr
->r
.record
.p
.gr
= gr
;
1897 static unw_rec_list
*
1898 output_preds_psprel (offset
)
1899 unsigned int offset
;
1901 unw_rec_list
*ptr
= alloc_record (preds_psprel
);
1902 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
1906 static unw_rec_list
*
1907 output_preds_sprel (offset
)
1908 unsigned int offset
;
1910 unw_rec_list
*ptr
= alloc_record (preds_sprel
);
1911 ptr
->r
.record
.p
.spoff
= offset
/ 4;
1915 static unw_rec_list
*
1916 output_fr_mem (mask
)
1919 unw_rec_list
*ptr
= alloc_record (fr_mem
);
1920 ptr
->r
.record
.p
.rmask
= mask
;
1924 static unw_rec_list
*
1925 output_frgr_mem (gr_mask
, fr_mask
)
1926 unsigned int gr_mask
;
1927 unsigned int fr_mask
;
1929 unw_rec_list
*ptr
= alloc_record (frgr_mem
);
1930 ptr
->r
.record
.p
.grmask
= gr_mask
;
1931 ptr
->r
.record
.p
.frmask
= fr_mask
;
1935 static unw_rec_list
*
1936 output_gr_gr (mask
, reg
)
1940 unw_rec_list
*ptr
= alloc_record (gr_gr
);
1941 ptr
->r
.record
.p
.grmask
= mask
;
1942 ptr
->r
.record
.p
.gr
= reg
;
1946 static unw_rec_list
*
1947 output_gr_mem (mask
)
1950 unw_rec_list
*ptr
= alloc_record (gr_mem
);
1951 ptr
->r
.record
.p
.rmask
= mask
;
1955 static unw_rec_list
*
1956 output_br_mem (unsigned int mask
)
1958 unw_rec_list
*ptr
= alloc_record (br_mem
);
1959 ptr
->r
.record
.p
.brmask
= mask
;
1963 static unw_rec_list
*
1964 output_br_gr (save_mask
, reg
)
1965 unsigned int save_mask
;
1968 unw_rec_list
*ptr
= alloc_record (br_gr
);
1969 ptr
->r
.record
.p
.brmask
= save_mask
;
1970 ptr
->r
.record
.p
.gr
= reg
;
1974 static unw_rec_list
*
1975 output_spill_base (offset
)
1976 unsigned int offset
;
1978 unw_rec_list
*ptr
= alloc_record (spill_base
);
1979 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
1983 static unw_rec_list
*
1986 unw_rec_list
*ptr
= alloc_record (unat_when
);
1990 static unw_rec_list
*
1994 unw_rec_list
*ptr
= alloc_record (unat_gr
);
1995 ptr
->r
.record
.p
.gr
= gr
;
1999 static unw_rec_list
*
2000 output_unat_psprel (offset
)
2001 unsigned int offset
;
2003 unw_rec_list
*ptr
= alloc_record (unat_psprel
);
2004 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2008 static unw_rec_list
*
2009 output_unat_sprel (offset
)
2010 unsigned int offset
;
2012 unw_rec_list
*ptr
= alloc_record (unat_sprel
);
2013 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2017 static unw_rec_list
*
2020 unw_rec_list
*ptr
= alloc_record (lc_when
);
2024 static unw_rec_list
*
2028 unw_rec_list
*ptr
= alloc_record (lc_gr
);
2029 ptr
->r
.record
.p
.gr
= gr
;
2033 static unw_rec_list
*
2034 output_lc_psprel (offset
)
2035 unsigned int offset
;
2037 unw_rec_list
*ptr
= alloc_record (lc_psprel
);
2038 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2042 static unw_rec_list
*
2043 output_lc_sprel (offset
)
2044 unsigned int offset
;
2046 unw_rec_list
*ptr
= alloc_record (lc_sprel
);
2047 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2051 static unw_rec_list
*
2054 unw_rec_list
*ptr
= alloc_record (fpsr_when
);
2058 static unw_rec_list
*
2062 unw_rec_list
*ptr
= alloc_record (fpsr_gr
);
2063 ptr
->r
.record
.p
.gr
= gr
;
2067 static unw_rec_list
*
2068 output_fpsr_psprel (offset
)
2069 unsigned int offset
;
2071 unw_rec_list
*ptr
= alloc_record (fpsr_psprel
);
2072 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2076 static unw_rec_list
*
2077 output_fpsr_sprel (offset
)
2078 unsigned int offset
;
2080 unw_rec_list
*ptr
= alloc_record (fpsr_sprel
);
2081 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2085 static unw_rec_list
*
2086 output_priunat_when_gr ()
2088 unw_rec_list
*ptr
= alloc_record (priunat_when_gr
);
2092 static unw_rec_list
*
2093 output_priunat_when_mem ()
2095 unw_rec_list
*ptr
= alloc_record (priunat_when_mem
);
2099 static unw_rec_list
*
2100 output_priunat_gr (gr
)
2103 unw_rec_list
*ptr
= alloc_record (priunat_gr
);
2104 ptr
->r
.record
.p
.gr
= gr
;
2108 static unw_rec_list
*
2109 output_priunat_psprel (offset
)
2110 unsigned int offset
;
2112 unw_rec_list
*ptr
= alloc_record (priunat_psprel
);
2113 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2117 static unw_rec_list
*
2118 output_priunat_sprel (offset
)
2119 unsigned int offset
;
2121 unw_rec_list
*ptr
= alloc_record (priunat_sprel
);
2122 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2126 static unw_rec_list
*
2129 unw_rec_list
*ptr
= alloc_record (bsp_when
);
2133 static unw_rec_list
*
2137 unw_rec_list
*ptr
= alloc_record (bsp_gr
);
2138 ptr
->r
.record
.p
.gr
= gr
;
2142 static unw_rec_list
*
2143 output_bsp_psprel (offset
)
2144 unsigned int offset
;
2146 unw_rec_list
*ptr
= alloc_record (bsp_psprel
);
2147 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2151 static unw_rec_list
*
2152 output_bsp_sprel (offset
)
2153 unsigned int offset
;
2155 unw_rec_list
*ptr
= alloc_record (bsp_sprel
);
2156 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2160 static unw_rec_list
*
2161 output_bspstore_when ()
2163 unw_rec_list
*ptr
= alloc_record (bspstore_when
);
2167 static unw_rec_list
*
2168 output_bspstore_gr (gr
)
2171 unw_rec_list
*ptr
= alloc_record (bspstore_gr
);
2172 ptr
->r
.record
.p
.gr
= gr
;
2176 static unw_rec_list
*
2177 output_bspstore_psprel (offset
)
2178 unsigned int offset
;
2180 unw_rec_list
*ptr
= alloc_record (bspstore_psprel
);
2181 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2185 static unw_rec_list
*
2186 output_bspstore_sprel (offset
)
2187 unsigned int offset
;
2189 unw_rec_list
*ptr
= alloc_record (bspstore_sprel
);
2190 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2194 static unw_rec_list
*
2197 unw_rec_list
*ptr
= alloc_record (rnat_when
);
2201 static unw_rec_list
*
2205 unw_rec_list
*ptr
= alloc_record (rnat_gr
);
2206 ptr
->r
.record
.p
.gr
= gr
;
2210 static unw_rec_list
*
2211 output_rnat_psprel (offset
)
2212 unsigned int offset
;
2214 unw_rec_list
*ptr
= alloc_record (rnat_psprel
);
2215 ptr
->r
.record
.p
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2219 static unw_rec_list
*
2220 output_rnat_sprel (offset
)
2221 unsigned int offset
;
2223 unw_rec_list
*ptr
= alloc_record (rnat_sprel
);
2224 ptr
->r
.record
.p
.spoff
= offset
/ 4;
2228 static unw_rec_list
*
2229 output_unwabi (abi
, context
)
2231 unsigned long context
;
2233 unw_rec_list
*ptr
= alloc_record (unwabi
);
2234 ptr
->r
.record
.p
.abi
= abi
;
2235 ptr
->r
.record
.p
.context
= context
;
2239 static unw_rec_list
*
2240 output_epilogue (unsigned long ecount
)
2242 unw_rec_list
*ptr
= alloc_record (epilogue
);
2243 ptr
->r
.record
.b
.ecount
= ecount
;
2247 static unw_rec_list
*
2248 output_label_state (unsigned long label
)
2250 unw_rec_list
*ptr
= alloc_record (label_state
);
2251 ptr
->r
.record
.b
.label
= label
;
2255 static unw_rec_list
*
2256 output_copy_state (unsigned long label
)
2258 unw_rec_list
*ptr
= alloc_record (copy_state
);
2259 ptr
->r
.record
.b
.label
= label
;
2263 static unw_rec_list
*
2264 output_spill_psprel (ab
, reg
, offset
)
2267 unsigned int offset
;
2269 unw_rec_list
*ptr
= alloc_record (spill_psprel
);
2270 ptr
->r
.record
.x
.ab
= ab
;
2271 ptr
->r
.record
.x
.reg
= reg
;
2272 ptr
->r
.record
.x
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2276 static unw_rec_list
*
2277 output_spill_sprel (ab
, reg
, offset
)
2280 unsigned int offset
;
2282 unw_rec_list
*ptr
= alloc_record (spill_sprel
);
2283 ptr
->r
.record
.x
.ab
= ab
;
2284 ptr
->r
.record
.x
.reg
= reg
;
2285 ptr
->r
.record
.x
.spoff
= offset
/ 4;
2289 static unw_rec_list
*
2290 output_spill_psprel_p (ab
, reg
, offset
, predicate
)
2293 unsigned int offset
;
2294 unsigned int predicate
;
2296 unw_rec_list
*ptr
= alloc_record (spill_psprel_p
);
2297 ptr
->r
.record
.x
.ab
= ab
;
2298 ptr
->r
.record
.x
.reg
= reg
;
2299 ptr
->r
.record
.x
.pspoff
= ENCODED_PSP_OFFSET (offset
);
2300 ptr
->r
.record
.x
.qp
= predicate
;
2304 static unw_rec_list
*
2305 output_spill_sprel_p (ab
, reg
, offset
, predicate
)
2308 unsigned int offset
;
2309 unsigned int predicate
;
2311 unw_rec_list
*ptr
= alloc_record (spill_sprel_p
);
2312 ptr
->r
.record
.x
.ab
= ab
;
2313 ptr
->r
.record
.x
.reg
= reg
;
2314 ptr
->r
.record
.x
.spoff
= offset
/ 4;
2315 ptr
->r
.record
.x
.qp
= predicate
;
2319 static unw_rec_list
*
2320 output_spill_reg (ab
, reg
, targ_reg
, xy
)
2323 unsigned int targ_reg
;
2326 unw_rec_list
*ptr
= alloc_record (spill_reg
);
2327 ptr
->r
.record
.x
.ab
= ab
;
2328 ptr
->r
.record
.x
.reg
= reg
;
2329 ptr
->r
.record
.x
.treg
= targ_reg
;
2330 ptr
->r
.record
.x
.xy
= xy
;
2334 static unw_rec_list
*
2335 output_spill_reg_p (ab
, reg
, targ_reg
, xy
, predicate
)
2338 unsigned int targ_reg
;
2340 unsigned int predicate
;
2342 unw_rec_list
*ptr
= alloc_record (spill_reg_p
);
2343 ptr
->r
.record
.x
.ab
= ab
;
2344 ptr
->r
.record
.x
.reg
= reg
;
2345 ptr
->r
.record
.x
.treg
= targ_reg
;
2346 ptr
->r
.record
.x
.xy
= xy
;
2347 ptr
->r
.record
.x
.qp
= predicate
;
2351 /* Given a unw_rec_list process the correct format with the
2352 specified function. */
2355 process_one_record (ptr
, f
)
2359 unsigned long fr_mask
, gr_mask
;
2361 switch (ptr
->r
.type
)
2363 /* This is a dummy record that takes up no space in the output. */
2371 /* These are taken care of by prologue/prologue_gr. */
2376 if (ptr
->r
.type
== prologue_gr
)
2377 output_R2_format (f
, ptr
->r
.record
.r
.grmask
,
2378 ptr
->r
.record
.r
.grsave
, ptr
->r
.record
.r
.rlen
);
2380 output_R1_format (f
, ptr
->r
.type
, ptr
->r
.record
.r
.rlen
);
2382 /* Output descriptor(s) for union of register spills (if any). */
2383 gr_mask
= ptr
->r
.record
.r
.mask
.gr_mem
;
2384 fr_mask
= ptr
->r
.record
.r
.mask
.fr_mem
;
2387 if ((fr_mask
& ~0xfUL
) == 0)
2388 output_P6_format (f
, fr_mem
, fr_mask
);
2391 output_P5_format (f
, gr_mask
, fr_mask
);
2396 output_P6_format (f
, gr_mem
, gr_mask
);
2397 if (ptr
->r
.record
.r
.mask
.br_mem
)
2398 output_P1_format (f
, ptr
->r
.record
.r
.mask
.br_mem
);
2400 /* output imask descriptor if necessary: */
2401 if (ptr
->r
.record
.r
.mask
.i
)
2402 output_P4_format (f
, ptr
->r
.record
.r
.mask
.i
,
2403 ptr
->r
.record
.r
.imask_size
);
2407 output_R1_format (f
, ptr
->r
.type
, ptr
->r
.record
.r
.rlen
);
2411 output_P7_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.t
,
2412 ptr
->r
.record
.p
.size
);
2425 output_P3_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.gr
);
2428 output_P3_format (f
, rp_br
, ptr
->r
.record
.p
.br
);
2431 output_P7_format (f
, psp_sprel
, ptr
->r
.record
.p
.spoff
, 0);
2439 output_P7_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.t
, 0);
2448 output_P7_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.pspoff
, 0);
2458 case bspstore_sprel
:
2460 output_P8_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.spoff
);
2463 output_P9_format (f
, ptr
->r
.record
.p
.grmask
, ptr
->r
.record
.p
.gr
);
2466 output_P2_format (f
, ptr
->r
.record
.p
.brmask
, ptr
->r
.record
.p
.gr
);
2469 as_bad ("spill_mask record unimplemented.");
2471 case priunat_when_gr
:
2472 case priunat_when_mem
:
2476 output_P8_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.t
);
2478 case priunat_psprel
:
2480 case bspstore_psprel
:
2482 output_P8_format (f
, ptr
->r
.type
, ptr
->r
.record
.p
.pspoff
);
2485 output_P10_format (f
, ptr
->r
.record
.p
.abi
, ptr
->r
.record
.p
.context
);
2488 output_B3_format (f
, ptr
->r
.record
.b
.ecount
, ptr
->r
.record
.b
.t
);
2492 output_B4_format (f
, ptr
->r
.type
, ptr
->r
.record
.b
.label
);
2495 output_X1_format (f
, ptr
->r
.type
, ptr
->r
.record
.x
.ab
,
2496 ptr
->r
.record
.x
.reg
, ptr
->r
.record
.x
.t
,
2497 ptr
->r
.record
.x
.pspoff
);
2500 output_X1_format (f
, ptr
->r
.type
, ptr
->r
.record
.x
.ab
,
2501 ptr
->r
.record
.x
.reg
, ptr
->r
.record
.x
.t
,
2502 ptr
->r
.record
.x
.spoff
);
2505 output_X2_format (f
, ptr
->r
.record
.x
.ab
, ptr
->r
.record
.x
.reg
,
2506 ptr
->r
.record
.x
.xy
>> 1, ptr
->r
.record
.x
.xy
,
2507 ptr
->r
.record
.x
.treg
, ptr
->r
.record
.x
.t
);
2509 case spill_psprel_p
:
2510 output_X3_format (f
, ptr
->r
.type
, ptr
->r
.record
.x
.qp
,
2511 ptr
->r
.record
.x
.ab
, ptr
->r
.record
.x
.reg
,
2512 ptr
->r
.record
.x
.t
, ptr
->r
.record
.x
.pspoff
);
2515 output_X3_format (f
, ptr
->r
.type
, ptr
->r
.record
.x
.qp
,
2516 ptr
->r
.record
.x
.ab
, ptr
->r
.record
.x
.reg
,
2517 ptr
->r
.record
.x
.t
, ptr
->r
.record
.x
.spoff
);
2520 output_X4_format (f
, ptr
->r
.record
.x
.qp
, ptr
->r
.record
.x
.ab
,
2521 ptr
->r
.record
.x
.reg
, ptr
->r
.record
.x
.xy
>> 1,
2522 ptr
->r
.record
.x
.xy
, ptr
->r
.record
.x
.treg
,
2526 as_bad ("record_type_not_valid");
2531 /* Given a unw_rec_list list, process all the records with
2532 the specified function. */
2534 process_unw_records (list
, f
)
2539 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
2540 process_one_record (ptr
, f
);
2543 /* Determine the size of a record list in bytes. */
2545 calc_record_size (list
)
2549 process_unw_records (list
, count_output
);
2553 /* Update IMASK bitmask to reflect the fact that one or more registers
2554 of type TYPE are saved starting at instruction with index T. If N
2555 bits are set in REGMASK, it is assumed that instructions T through
2556 T+N-1 save these registers.
2560 1: instruction saves next fp reg
2561 2: instruction saves next general reg
2562 3: instruction saves next branch reg */
2564 set_imask (region
, regmask
, t
, type
)
2565 unw_rec_list
*region
;
2566 unsigned long regmask
;
2570 unsigned char *imask
;
2571 unsigned long imask_size
;
2575 imask
= region
->r
.record
.r
.mask
.i
;
2576 imask_size
= region
->r
.record
.r
.imask_size
;
2579 imask_size
= (region
->r
.record
.r
.rlen
* 2 + 7) / 8 + 1;
2580 imask
= xmalloc (imask_size
);
2581 memset (imask
, 0, imask_size
);
2583 region
->r
.record
.r
.imask_size
= imask_size
;
2584 region
->r
.record
.r
.mask
.i
= imask
;
2588 pos
= 2 * (3 - t
% 4);
2591 if (i
>= imask_size
)
2593 as_bad ("Ignoring attempt to spill beyond end of region");
2597 imask
[i
] |= (type
& 0x3) << pos
;
2599 regmask
&= (regmask
- 1);
2609 /* Return the number of instruction slots from FIRST_ADDR to SLOT_ADDR.
2610 SLOT_FRAG is the frag containing SLOT_ADDR, and FIRST_FRAG is the frag
2611 containing FIRST_ADDR. If BEFORE_RELAX, then we use worst-case estimates
2615 slot_index (slot_addr
, slot_frag
, first_addr
, first_frag
, before_relax
)
2616 unsigned long slot_addr
;
2618 unsigned long first_addr
;
2622 unsigned long index
= 0;
2624 /* First time we are called, the initial address and frag are invalid. */
2625 if (first_addr
== 0)
2628 /* If the two addresses are in different frags, then we need to add in
2629 the remaining size of this frag, and then the entire size of intermediate
2631 while (slot_frag
!= first_frag
)
2633 unsigned long start_addr
= (unsigned long) &first_frag
->fr_literal
;
2637 /* We can get the final addresses only during and after
2639 if (first_frag
->fr_next
&& first_frag
->fr_next
->fr_address
)
2640 index
+= 3 * ((first_frag
->fr_next
->fr_address
2641 - first_frag
->fr_address
2642 - first_frag
->fr_fix
) >> 4);
2645 /* We don't know what the final addresses will be. We try our
2646 best to estimate. */
2647 switch (first_frag
->fr_type
)
2653 as_fatal ("only constant space allocation is supported");
2659 /* Take alignment into account. Assume the worst case
2660 before relaxation. */
2661 index
+= 3 * ((1 << first_frag
->fr_offset
) >> 4);
2665 if (first_frag
->fr_symbol
)
2667 as_fatal ("only constant offsets are supported");
2671 index
+= 3 * (first_frag
->fr_offset
>> 4);
2675 /* Add in the full size of the frag converted to instruction slots. */
2676 index
+= 3 * (first_frag
->fr_fix
>> 4);
2677 /* Subtract away the initial part before first_addr. */
2678 index
-= (3 * ((first_addr
>> 4) - (start_addr
>> 4))
2679 + ((first_addr
& 0x3) - (start_addr
& 0x3)));
2681 /* Move to the beginning of the next frag. */
2682 first_frag
= first_frag
->fr_next
;
2683 first_addr
= (unsigned long) &first_frag
->fr_literal
;
2686 /* Add in the used part of the last frag. */
2687 index
+= (3 * ((slot_addr
>> 4) - (first_addr
>> 4))
2688 + ((slot_addr
& 0x3) - (first_addr
& 0x3)));
2692 /* Optimize unwind record directives. */
2694 static unw_rec_list
*
2695 optimize_unw_records (list
)
2701 /* If the only unwind record is ".prologue" or ".prologue" followed
2702 by ".body", then we can optimize the unwind directives away. */
2703 if (list
->r
.type
== prologue
2704 && (list
->next
->r
.type
== endp
2705 || (list
->next
->r
.type
== body
&& list
->next
->next
->r
.type
== endp
)))
2711 /* Given a complete record list, process any records which have
2712 unresolved fields, (ie length counts for a prologue). After
2713 this has been run, all necessary information should be available
2714 within each record to generate an image. */
2717 fixup_unw_records (list
, before_relax
)
2721 unw_rec_list
*ptr
, *region
= 0;
2722 unsigned long first_addr
= 0, rlen
= 0, t
;
2723 fragS
*first_frag
= 0;
2725 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
2727 if (ptr
->slot_number
== SLOT_NUM_NOT_SET
)
2728 as_bad (" Insn slot not set in unwind record.");
2729 t
= slot_index (ptr
->slot_number
, ptr
->slot_frag
,
2730 first_addr
, first_frag
, before_relax
);
2731 switch (ptr
->r
.type
)
2739 unsigned long last_addr
= 0;
2740 fragS
*last_frag
= NULL
;
2742 first_addr
= ptr
->slot_number
;
2743 first_frag
= ptr
->slot_frag
;
2744 /* Find either the next body/prologue start, or the end of
2745 the function, and determine the size of the region. */
2746 for (last
= ptr
->next
; last
!= NULL
; last
= last
->next
)
2747 if (last
->r
.type
== prologue
|| last
->r
.type
== prologue_gr
2748 || last
->r
.type
== body
|| last
->r
.type
== endp
)
2750 last_addr
= last
->slot_number
;
2751 last_frag
= last
->slot_frag
;
2754 size
= slot_index (last_addr
, last_frag
, first_addr
, first_frag
,
2756 rlen
= ptr
->r
.record
.r
.rlen
= size
;
2757 if (ptr
->r
.type
== body
)
2758 /* End of region. */
2766 ptr
->r
.record
.b
.t
= rlen
- 1 - t
;
2768 /* This happens when a memory-stack-less procedure uses a
2769 ".restore sp" directive at the end of a region to pop
2771 ptr
->r
.record
.b
.t
= 0;
2782 case priunat_when_gr
:
2783 case priunat_when_mem
:
2787 ptr
->r
.record
.p
.t
= t
;
2795 case spill_psprel_p
:
2796 ptr
->r
.record
.x
.t
= t
;
2802 as_bad ("frgr_mem record before region record!");
2805 region
->r
.record
.r
.mask
.fr_mem
|= ptr
->r
.record
.p
.frmask
;
2806 region
->r
.record
.r
.mask
.gr_mem
|= ptr
->r
.record
.p
.grmask
;
2807 set_imask (region
, ptr
->r
.record
.p
.frmask
, t
, 1);
2808 set_imask (region
, ptr
->r
.record
.p
.grmask
, t
, 2);
2813 as_bad ("fr_mem record before region record!");
2816 region
->r
.record
.r
.mask
.fr_mem
|= ptr
->r
.record
.p
.rmask
;
2817 set_imask (region
, ptr
->r
.record
.p
.rmask
, t
, 1);
2822 as_bad ("gr_mem record before region record!");
2825 region
->r
.record
.r
.mask
.gr_mem
|= ptr
->r
.record
.p
.rmask
;
2826 set_imask (region
, ptr
->r
.record
.p
.rmask
, t
, 2);
2831 as_bad ("br_mem record before region record!");
2834 region
->r
.record
.r
.mask
.br_mem
|= ptr
->r
.record
.p
.brmask
;
2835 set_imask (region
, ptr
->r
.record
.p
.brmask
, t
, 3);
2841 as_bad ("gr_gr record before region record!");
2844 set_imask (region
, ptr
->r
.record
.p
.grmask
, t
, 2);
2849 as_bad ("br_gr record before region record!");
2852 set_imask (region
, ptr
->r
.record
.p
.brmask
, t
, 3);
2861 /* Estimate the size of a frag before relaxing. We only have one type of frag
2862 to handle here, which is the unwind info frag. */
2865 ia64_estimate_size_before_relax (fragS
*frag
,
2866 asection
*segtype ATTRIBUTE_UNUSED
)
2871 /* ??? This code is identical to the first part of ia64_convert_frag. */
2872 list
= (unw_rec_list
*) frag
->fr_opcode
;
2873 fixup_unw_records (list
, 0);
2875 len
= calc_record_size (list
);
2876 /* pad to pointer-size boundary. */
2877 pad
= len
% md
.pointer_size
;
2879 len
+= md
.pointer_size
- pad
;
2880 /* Add 8 for the header. */
2882 /* Add a pointer for the personality offset. */
2883 if (frag
->fr_offset
)
2884 size
+= md
.pointer_size
;
2886 /* fr_var carries the max_chars that we created the fragment with.
2887 We must, of course, have allocated enough memory earlier. */
2888 assert (frag
->fr_var
>= size
);
2890 return frag
->fr_fix
+ size
;
2893 /* This function converts a rs_machine_dependent variant frag into a
2894 normal fill frag with the unwind image from the the record list. */
2896 ia64_convert_frag (fragS
*frag
)
2902 /* ??? This code is identical to ia64_estimate_size_before_relax. */
2903 list
= (unw_rec_list
*) frag
->fr_opcode
;
2904 fixup_unw_records (list
, 0);
2906 len
= calc_record_size (list
);
2907 /* pad to pointer-size boundary. */
2908 pad
= len
% md
.pointer_size
;
2910 len
+= md
.pointer_size
- pad
;
2911 /* Add 8 for the header. */
2913 /* Add a pointer for the personality offset. */
2914 if (frag
->fr_offset
)
2915 size
+= md
.pointer_size
;
2917 /* fr_var carries the max_chars that we created the fragment with.
2918 We must, of course, have allocated enough memory earlier. */
2919 assert (frag
->fr_var
>= size
);
2921 /* Initialize the header area. fr_offset is initialized with
2922 unwind.personality_routine. */
2923 if (frag
->fr_offset
)
2925 if (md
.flags
& EF_IA_64_ABI64
)
2926 flag_value
= (bfd_vma
) 3 << 32;
2928 /* 32-bit unwind info block. */
2929 flag_value
= (bfd_vma
) 0x1003 << 32;
2934 md_number_to_chars (frag
->fr_literal
,
2935 (((bfd_vma
) 1 << 48) /* Version. */
2936 | flag_value
/* U & E handler flags. */
2937 | (len
/ md
.pointer_size
)), /* Length. */
2940 /* Skip the header. */
2941 vbyte_mem_ptr
= frag
->fr_literal
+ 8;
2942 process_unw_records (list
, output_vbyte_mem
);
2944 /* Fill the padding bytes with zeros. */
2946 md_number_to_chars (frag
->fr_literal
+ len
+ 8 - md
.pointer_size
+ pad
, 0,
2947 md
.pointer_size
- pad
);
2949 frag
->fr_fix
+= size
;
2950 frag
->fr_type
= rs_fill
;
2952 frag
->fr_offset
= 0;
2956 convert_expr_to_ab_reg (e
, ab
, regp
)
2963 if (e
->X_op
!= O_register
)
2966 reg
= e
->X_add_number
;
2967 if (reg
>= (REG_GR
+ 4) && reg
<= (REG_GR
+ 7))
2970 *regp
= reg
- REG_GR
;
2972 else if ((reg
>= (REG_FR
+ 2) && reg
<= (REG_FR
+ 5))
2973 || (reg
>= (REG_FR
+ 16) && reg
<= (REG_FR
+ 31)))
2976 *regp
= reg
- REG_FR
;
2978 else if (reg
>= (REG_BR
+ 1) && reg
<= (REG_BR
+ 5))
2981 *regp
= reg
- REG_BR
;
2988 case REG_PR
: *regp
= 0; break;
2989 case REG_PSP
: *regp
= 1; break;
2990 case REG_PRIUNAT
: *regp
= 2; break;
2991 case REG_BR
+ 0: *regp
= 3; break;
2992 case REG_AR
+ AR_BSP
: *regp
= 4; break;
2993 case REG_AR
+ AR_BSPSTORE
: *regp
= 5; break;
2994 case REG_AR
+ AR_RNAT
: *regp
= 6; break;
2995 case REG_AR
+ AR_UNAT
: *regp
= 7; break;
2996 case REG_AR
+ AR_FPSR
: *regp
= 8; break;
2997 case REG_AR
+ AR_PFS
: *regp
= 9; break;
2998 case REG_AR
+ AR_LC
: *regp
= 10; break;
3008 convert_expr_to_xy_reg (e
, xy
, regp
)
3015 if (e
->X_op
!= O_register
)
3018 reg
= e
->X_add_number
;
3020 if (/* reg >= REG_GR && */ reg
<= (REG_GR
+ 127))
3023 *regp
= reg
- REG_GR
;
3025 else if (reg
>= REG_FR
&& reg
<= (REG_FR
+ 127))
3028 *regp
= reg
- REG_FR
;
3030 else if (reg
>= REG_BR
&& reg
<= (REG_BR
+ 7))
3033 *regp
= reg
- REG_BR
;
3043 /* The current frag is an alignment frag. */
3044 align_frag
= frag_now
;
3045 s_align_bytes (arg
);
3050 int dummy ATTRIBUTE_UNUSED
;
3055 radix
= *input_line_pointer
++;
3057 if (radix
!= 'C' && !is_end_of_line
[(unsigned char) radix
])
3059 as_bad ("Radix `%c' unsupported", *input_line_pointer
);
3060 ignore_rest_of_line ();
3065 /* Helper function for .loc directives. If the assembler is not generating
3066 line number info, then we need to remember which instructions have a .loc
3067 directive, and only call dwarf2_gen_line_info for those instructions. */
3072 CURR_SLOT
.loc_directive_seen
= 1;
3073 dwarf2_directive_loc (x
);
3076 /* .sbss, .bss etc. are macros that expand into ".section SECNAME". */
3078 dot_special_section (which
)
3081 set_section ((char *) special_section_name
[which
]);
3084 /* Return -1 for warning and 0 for error. */
3087 unwind_diagnostic (const char * region
, const char *directive
)
3089 if (md
.unwind_check
== unwind_check_warning
)
3091 as_warn (".%s outside of %s", directive
, region
);
3096 as_bad (".%s outside of %s", directive
, region
);
3097 ignore_rest_of_line ();
3102 /* Return 1 if a directive is in a procedure, -1 if a directive isn't in
3103 a procedure but the unwind directive check is set to warning, 0 if
3104 a directive isn't in a procedure and the unwind directive check is set
3108 in_procedure (const char *directive
)
3110 if (unwind
.proc_start
3111 && (!unwind
.saved_text_seg
|| strcmp (directive
, "endp") == 0))
3113 return unwind_diagnostic ("procedure", directive
);
3116 /* Return 1 if a directive is in a prologue, -1 if a directive isn't in
3117 a prologue but the unwind directive check is set to warning, 0 if
3118 a directive isn't in a prologue and the unwind directive check is set
3122 in_prologue (const char *directive
)
3124 int in
= in_procedure (directive
);
3127 /* We are in a procedure. Check if we are in a prologue. */
3128 if (unwind
.prologue
)
3130 /* We only want to issue one message. */
3132 return unwind_diagnostic ("prologue", directive
);
3139 /* Return 1 if a directive is in a body, -1 if a directive isn't in
3140 a body but the unwind directive check is set to warning, 0 if
3141 a directive isn't in a body and the unwind directive check is set
3145 in_body (const char *directive
)
3147 int in
= in_procedure (directive
);
3150 /* We are in a procedure. Check if we are in a body. */
3153 /* We only want to issue one message. */
3155 return unwind_diagnostic ("body region", directive
);
3163 add_unwind_entry (ptr
)
3167 unwind
.tail
->next
= ptr
;
3172 /* The current entry can in fact be a chain of unwind entries. */
3173 if (unwind
.current_entry
== NULL
)
3174 unwind
.current_entry
= ptr
;
3179 int dummy ATTRIBUTE_UNUSED
;
3183 if (!in_prologue ("fframe"))
3188 if (e
.X_op
!= O_constant
)
3189 as_bad ("Operand to .fframe must be a constant");
3191 add_unwind_entry (output_mem_stack_f (e
.X_add_number
));
3196 int dummy ATTRIBUTE_UNUSED
;
3201 if (!in_prologue ("vframe"))
3205 reg
= e
.X_add_number
- REG_GR
;
3206 if (e
.X_op
== O_register
&& reg
< 128)
3208 add_unwind_entry (output_mem_stack_v ());
3209 if (! (unwind
.prologue_mask
& 2))
3210 add_unwind_entry (output_psp_gr (reg
));
3213 as_bad ("First operand to .vframe must be a general register");
3217 dot_vframesp (dummy
)
3218 int dummy ATTRIBUTE_UNUSED
;
3222 if (!in_prologue ("vframesp"))
3226 if (e
.X_op
== O_constant
)
3228 add_unwind_entry (output_mem_stack_v ());
3229 add_unwind_entry (output_psp_sprel (e
.X_add_number
));
3232 as_bad ("Operand to .vframesp must be a constant (sp-relative offset)");
3236 dot_vframepsp (dummy
)
3237 int dummy ATTRIBUTE_UNUSED
;
3241 if (!in_prologue ("vframepsp"))
3245 if (e
.X_op
== O_constant
)
3247 add_unwind_entry (output_mem_stack_v ());
3248 add_unwind_entry (output_psp_sprel (e
.X_add_number
));
3251 as_bad ("Operand to .vframepsp must be a constant (psp-relative offset)");
3256 int dummy ATTRIBUTE_UNUSED
;
3262 if (!in_prologue ("save"))
3265 sep
= parse_operand (&e1
);
3267 as_bad ("No second operand to .save");
3268 sep
= parse_operand (&e2
);
3270 reg1
= e1
.X_add_number
;
3271 reg2
= e2
.X_add_number
- REG_GR
;
3273 /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
3274 if (e1
.X_op
== O_register
)
3276 if (e2
.X_op
== O_register
&& reg2
>= 0 && reg2
< 128)
3280 case REG_AR
+ AR_BSP
:
3281 add_unwind_entry (output_bsp_when ());
3282 add_unwind_entry (output_bsp_gr (reg2
));
3284 case REG_AR
+ AR_BSPSTORE
:
3285 add_unwind_entry (output_bspstore_when ());
3286 add_unwind_entry (output_bspstore_gr (reg2
));
3288 case REG_AR
+ AR_RNAT
:
3289 add_unwind_entry (output_rnat_when ());
3290 add_unwind_entry (output_rnat_gr (reg2
));
3292 case REG_AR
+ AR_UNAT
:
3293 add_unwind_entry (output_unat_when ());
3294 add_unwind_entry (output_unat_gr (reg2
));
3296 case REG_AR
+ AR_FPSR
:
3297 add_unwind_entry (output_fpsr_when ());
3298 add_unwind_entry (output_fpsr_gr (reg2
));
3300 case REG_AR
+ AR_PFS
:
3301 add_unwind_entry (output_pfs_when ());
3302 if (! (unwind
.prologue_mask
& 4))
3303 add_unwind_entry (output_pfs_gr (reg2
));
3305 case REG_AR
+ AR_LC
:
3306 add_unwind_entry (output_lc_when ());
3307 add_unwind_entry (output_lc_gr (reg2
));
3310 add_unwind_entry (output_rp_when ());
3311 if (! (unwind
.prologue_mask
& 8))
3312 add_unwind_entry (output_rp_gr (reg2
));
3315 add_unwind_entry (output_preds_when ());
3316 if (! (unwind
.prologue_mask
& 1))
3317 add_unwind_entry (output_preds_gr (reg2
));
3320 add_unwind_entry (output_priunat_when_gr ());
3321 add_unwind_entry (output_priunat_gr (reg2
));
3324 as_bad ("First operand not a valid register");
3328 as_bad (" Second operand not a valid register");
3331 as_bad ("First operand not a register");
3336 int dummy ATTRIBUTE_UNUSED
;
3339 unsigned long ecount
; /* # of _additional_ regions to pop */
3342 if (!in_body ("restore"))
3345 sep
= parse_operand (&e1
);
3346 if (e1
.X_op
!= O_register
|| e1
.X_add_number
!= REG_GR
+ 12)
3348 as_bad ("First operand to .restore must be stack pointer (sp)");
3354 parse_operand (&e2
);
3355 if (e2
.X_op
!= O_constant
|| e2
.X_add_number
< 0)
3357 as_bad ("Second operand to .restore must be a constant >= 0");
3360 ecount
= e2
.X_add_number
;
3363 ecount
= unwind
.prologue_count
- 1;
3365 if (ecount
>= unwind
.prologue_count
)
3367 as_bad ("Epilogue count of %lu exceeds number of nested prologues (%u)",
3368 ecount
+ 1, unwind
.prologue_count
);
3372 add_unwind_entry (output_epilogue (ecount
));
3374 if (ecount
< unwind
.prologue_count
)
3375 unwind
.prologue_count
-= ecount
+ 1;
3377 unwind
.prologue_count
= 0;
3381 dot_restorereg (dummy
)
3382 int dummy ATTRIBUTE_UNUSED
;
3384 unsigned int ab
, reg
;
3387 if (!in_procedure ("restorereg"))
3392 if (!convert_expr_to_ab_reg (&e
, &ab
, ®
))
3394 as_bad ("First operand to .restorereg must be a preserved register");
3397 add_unwind_entry (output_spill_reg (ab
, reg
, 0, 0));
3401 dot_restorereg_p (dummy
)
3402 int dummy ATTRIBUTE_UNUSED
;
3404 unsigned int qp
, ab
, reg
;
3408 if (!in_procedure ("restorereg.p"))
3411 sep
= parse_operand (&e1
);
3414 as_bad ("No second operand to .restorereg.p");
3418 parse_operand (&e2
);
3420 qp
= e1
.X_add_number
- REG_P
;
3421 if (e1
.X_op
!= O_register
|| qp
> 63)
3423 as_bad ("First operand to .restorereg.p must be a predicate");
3427 if (!convert_expr_to_ab_reg (&e2
, &ab
, ®
))
3429 as_bad ("Second operand to .restorereg.p must be a preserved register");
3432 add_unwind_entry (output_spill_reg_p (ab
, reg
, 0, 0, qp
));
3435 static char *special_linkonce_name
[] =
3437 ".gnu.linkonce.ia64unw.", ".gnu.linkonce.ia64unwi."
3441 start_unwind_section (const segT text_seg
, int sec_index
, int linkonce_empty
)
3444 Use a slightly ugly scheme to derive the unwind section names from
3445 the text section name:
3447 text sect. unwind table sect.
3448 name: name: comments:
3449 ---------- ----------------- --------------------------------
3451 .text.foo .IA_64.unwind.text.foo
3452 .foo .IA_64.unwind.foo
3454 .gnu.linkonce.ia64unw.foo
3455 _info .IA_64.unwind_info gas issues error message (ditto)
3456 _infoFOO .IA_64.unwind_infoFOO gas issues error message (ditto)
3458 This mapping is done so that:
3460 (a) An object file with unwind info only in .text will use
3461 unwind section names .IA_64.unwind and .IA_64.unwind_info.
3462 This follows the letter of the ABI and also ensures backwards
3463 compatibility with older toolchains.
3465 (b) An object file with unwind info in multiple text sections
3466 will use separate unwind sections for each text section.
3467 This allows us to properly set the "sh_info" and "sh_link"
3468 fields in SHT_IA_64_UNWIND as required by the ABI and also
3469 lets GNU ld support programs with multiple segments
3470 containing unwind info (as might be the case for certain
3471 embedded applications).
3473 (c) An error is issued if there would be a name clash.
3476 const char *text_name
, *sec_text_name
;
3478 const char *prefix
= special_section_name
[sec_index
];
3480 size_t prefix_len
, suffix_len
, sec_name_len
;
3482 sec_text_name
= segment_name (text_seg
);
3483 text_name
= sec_text_name
;
3484 if (strncmp (text_name
, "_info", 5) == 0)
3486 as_bad ("Illegal section name `%s' (causes unwind section name clash)",
3488 ignore_rest_of_line ();
3491 if (strcmp (text_name
, ".text") == 0)
3494 /* Build the unwind section name by appending the (possibly stripped)
3495 text section name to the unwind prefix. */
3497 if (strncmp (text_name
, ".gnu.linkonce.t.",
3498 sizeof (".gnu.linkonce.t.") - 1) == 0)
3500 prefix
= special_linkonce_name
[sec_index
- SPECIAL_SECTION_UNWIND
];
3501 suffix
+= sizeof (".gnu.linkonce.t.") - 1;
3503 else if (linkonce_empty
)
3506 prefix_len
= strlen (prefix
);
3507 suffix_len
= strlen (suffix
);
3508 sec_name_len
= prefix_len
+ suffix_len
;
3509 sec_name
= alloca (sec_name_len
+ 1);
3510 memcpy (sec_name
, prefix
, prefix_len
);
3511 memcpy (sec_name
+ prefix_len
, suffix
, suffix_len
);
3512 sec_name
[sec_name_len
] = '\0';
3514 /* Handle COMDAT group. */
3515 if (suffix
== text_name
&& (text_seg
->flags
& SEC_LINK_ONCE
) != 0)
3518 size_t len
, group_name_len
;
3519 const char *group_name
= elf_group_name (text_seg
);
3521 if (group_name
== NULL
)
3523 as_bad ("Group section `%s' has no group signature",
3525 ignore_rest_of_line ();
3528 /* We have to construct a fake section directive. */
3529 group_name_len
= strlen (group_name
);
3531 + 16 /* ,"aG",@progbits, */
3532 + group_name_len
/* ,group_name */
3535 section
= alloca (len
+ 1);
3536 memcpy (section
, sec_name
, sec_name_len
);
3537 memcpy (section
+ sec_name_len
, ",\"aG\",@progbits,", 16);
3538 memcpy (section
+ sec_name_len
+ 16, group_name
, group_name_len
);
3539 memcpy (section
+ len
- 7, ",comdat", 7);
3540 section
[len
] = '\0';
3541 set_section (section
);
3545 set_section (sec_name
);
3546 bfd_set_section_flags (stdoutput
, now_seg
,
3547 SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
3550 elf_linked_to_section (now_seg
) = text_seg
;
3554 generate_unwind_image (const segT text_seg
)
3559 /* Mark the end of the unwind info, so that we can compute the size of the
3560 last unwind region. */
3561 add_unwind_entry (output_endp ());
3563 /* Force out pending instructions, to make sure all unwind records have
3564 a valid slot_number field. */
3565 ia64_flush_insns ();
3567 /* Generate the unwind record. */
3568 list
= optimize_unw_records (unwind
.list
);
3569 fixup_unw_records (list
, 1);
3570 size
= calc_record_size (list
);
3572 if (size
> 0 || unwind
.force_unwind_entry
)
3574 unwind
.force_unwind_entry
= 0;
3575 /* pad to pointer-size boundary. */
3576 pad
= size
% md
.pointer_size
;
3578 size
+= md
.pointer_size
- pad
;
3579 /* Add 8 for the header. */
3581 /* Add a pointer for the personality offset. */
3582 if (unwind
.personality_routine
)
3583 size
+= md
.pointer_size
;
3586 /* If there are unwind records, switch sections, and output the info. */
3590 bfd_reloc_code_real_type reloc
;
3592 start_unwind_section (text_seg
, SPECIAL_SECTION_UNWIND_INFO
, 0);
3594 /* Make sure the section has 4 byte alignment for ILP32 and
3595 8 byte alignment for LP64. */
3596 frag_align (md
.pointer_size_shift
, 0, 0);
3597 record_alignment (now_seg
, md
.pointer_size_shift
);
3599 /* Set expression which points to start of unwind descriptor area. */
3600 unwind
.info
= expr_build_dot ();
3602 frag_var (rs_machine_dependent
, size
, size
, 0, 0,
3603 (offsetT
) (long) unwind
.personality_routine
,
3606 /* Add the personality address to the image. */
3607 if (unwind
.personality_routine
!= 0)
3609 exp
.X_op
= O_symbol
;
3610 exp
.X_add_symbol
= unwind
.personality_routine
;
3611 exp
.X_add_number
= 0;
3613 if (md
.flags
& EF_IA_64_BE
)
3615 if (md
.flags
& EF_IA_64_ABI64
)
3616 reloc
= BFD_RELOC_IA64_LTOFF_FPTR64MSB
;
3618 reloc
= BFD_RELOC_IA64_LTOFF_FPTR32MSB
;
3622 if (md
.flags
& EF_IA_64_ABI64
)
3623 reloc
= BFD_RELOC_IA64_LTOFF_FPTR64LSB
;
3625 reloc
= BFD_RELOC_IA64_LTOFF_FPTR32LSB
;
3628 fix_new_exp (frag_now
, frag_now_fix () - md
.pointer_size
,
3629 md
.pointer_size
, &exp
, 0, reloc
);
3630 unwind
.personality_routine
= 0;
3634 start_unwind_section (text_seg
, SPECIAL_SECTION_UNWIND_INFO
, 1);
3636 free_saved_prologue_counts ();
3637 unwind
.list
= unwind
.tail
= unwind
.current_entry
= NULL
;
3641 dot_handlerdata (dummy
)
3642 int dummy ATTRIBUTE_UNUSED
;
3644 if (!in_procedure ("handlerdata"))
3646 unwind
.force_unwind_entry
= 1;
3648 /* Remember which segment we're in so we can switch back after .endp */
3649 unwind
.saved_text_seg
= now_seg
;
3650 unwind
.saved_text_subseg
= now_subseg
;
3652 /* Generate unwind info into unwind-info section and then leave that
3653 section as the currently active one so dataXX directives go into
3654 the language specific data area of the unwind info block. */
3655 generate_unwind_image (now_seg
);
3656 demand_empty_rest_of_line ();
3660 dot_unwentry (dummy
)
3661 int dummy ATTRIBUTE_UNUSED
;
3663 if (!in_procedure ("unwentry"))
3665 unwind
.force_unwind_entry
= 1;
3666 demand_empty_rest_of_line ();
3671 int dummy ATTRIBUTE_UNUSED
;
3676 if (!in_prologue ("altrp"))
3680 reg
= e
.X_add_number
- REG_BR
;
3681 if (e
.X_op
== O_register
&& reg
< 8)
3682 add_unwind_entry (output_rp_br (reg
));
3684 as_bad ("First operand not a valid branch register");
3688 dot_savemem (psprel
)
3695 if (!in_prologue (psprel
? "savepsp" : "savesp"))
3698 sep
= parse_operand (&e1
);
3700 as_bad ("No second operand to .save%ssp", psprel
? "p" : "");
3701 sep
= parse_operand (&e2
);
3703 reg1
= e1
.X_add_number
;
3704 val
= e2
.X_add_number
;
3706 /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
3707 if (e1
.X_op
== O_register
)
3709 if (e2
.X_op
== O_constant
)
3713 case REG_AR
+ AR_BSP
:
3714 add_unwind_entry (output_bsp_when ());
3715 add_unwind_entry ((psprel
3717 : output_bsp_sprel
) (val
));
3719 case REG_AR
+ AR_BSPSTORE
:
3720 add_unwind_entry (output_bspstore_when ());
3721 add_unwind_entry ((psprel
3722 ? output_bspstore_psprel
3723 : output_bspstore_sprel
) (val
));
3725 case REG_AR
+ AR_RNAT
:
3726 add_unwind_entry (output_rnat_when ());
3727 add_unwind_entry ((psprel
3728 ? output_rnat_psprel
3729 : output_rnat_sprel
) (val
));
3731 case REG_AR
+ AR_UNAT
:
3732 add_unwind_entry (output_unat_when ());
3733 add_unwind_entry ((psprel
3734 ? output_unat_psprel
3735 : output_unat_sprel
) (val
));
3737 case REG_AR
+ AR_FPSR
:
3738 add_unwind_entry (output_fpsr_when ());
3739 add_unwind_entry ((psprel
3740 ? output_fpsr_psprel
3741 : output_fpsr_sprel
) (val
));
3743 case REG_AR
+ AR_PFS
:
3744 add_unwind_entry (output_pfs_when ());
3745 add_unwind_entry ((psprel
3747 : output_pfs_sprel
) (val
));
3749 case REG_AR
+ AR_LC
:
3750 add_unwind_entry (output_lc_when ());
3751 add_unwind_entry ((psprel
3753 : output_lc_sprel
) (val
));
3756 add_unwind_entry (output_rp_when ());
3757 add_unwind_entry ((psprel
3759 : output_rp_sprel
) (val
));
3762 add_unwind_entry (output_preds_when ());
3763 add_unwind_entry ((psprel
3764 ? output_preds_psprel
3765 : output_preds_sprel
) (val
));
3768 add_unwind_entry (output_priunat_when_mem ());
3769 add_unwind_entry ((psprel
3770 ? output_priunat_psprel
3771 : output_priunat_sprel
) (val
));
3774 as_bad ("First operand not a valid register");
3778 as_bad (" Second operand not a valid constant");
3781 as_bad ("First operand not a register");
3786 int dummy ATTRIBUTE_UNUSED
;
3791 if (!in_prologue ("save.g"))
3794 sep
= parse_operand (&e1
);
3796 parse_operand (&e2
);
3798 if (e1
.X_op
!= O_constant
)
3799 as_bad ("First operand to .save.g must be a constant.");
3802 int grmask
= e1
.X_add_number
;
3804 add_unwind_entry (output_gr_mem (grmask
));
3807 int reg
= e2
.X_add_number
- REG_GR
;
3808 if (e2
.X_op
== O_register
&& reg
>= 0 && reg
< 128)
3809 add_unwind_entry (output_gr_gr (grmask
, reg
));
3811 as_bad ("Second operand is an invalid register.");
3818 int dummy ATTRIBUTE_UNUSED
;
3823 if (!in_prologue ("save.f"))
3826 sep
= parse_operand (&e1
);
3828 if (e1
.X_op
!= O_constant
)
3829 as_bad ("Operand to .save.f must be a constant.");
3831 add_unwind_entry (output_fr_mem (e1
.X_add_number
));
3836 int dummy ATTRIBUTE_UNUSED
;
3843 if (!in_prologue ("save.b"))
3846 sep
= parse_operand (&e1
);
3847 if (e1
.X_op
!= O_constant
)
3849 as_bad ("First operand to .save.b must be a constant.");
3852 brmask
= e1
.X_add_number
;
3856 sep
= parse_operand (&e2
);
3857 reg
= e2
.X_add_number
- REG_GR
;
3858 if (e2
.X_op
!= O_register
|| reg
> 127)
3860 as_bad ("Second operand to .save.b must be a general register.");
3863 add_unwind_entry (output_br_gr (brmask
, e2
.X_add_number
));
3866 add_unwind_entry (output_br_mem (brmask
));
3868 if (!is_end_of_line
[sep
] && !is_it_end_of_statement ())
3869 demand_empty_rest_of_line ();
3874 int dummy ATTRIBUTE_UNUSED
;
3879 if (!in_prologue ("save.gf"))
3882 sep
= parse_operand (&e1
);
3884 parse_operand (&e2
);
3886 if (e1
.X_op
!= O_constant
|| sep
!= ',' || e2
.X_op
!= O_constant
)
3887 as_bad ("Both operands of .save.gf must be constants.");
3890 int grmask
= e1
.X_add_number
;
3891 int frmask
= e2
.X_add_number
;
3892 add_unwind_entry (output_frgr_mem (grmask
, frmask
));
3898 int dummy ATTRIBUTE_UNUSED
;
3903 if (!in_prologue ("spill"))
3906 sep
= parse_operand (&e
);
3907 if (!is_end_of_line
[sep
] && !is_it_end_of_statement ())
3908 demand_empty_rest_of_line ();
3910 if (e
.X_op
!= O_constant
)
3911 as_bad ("Operand to .spill must be a constant");
3913 add_unwind_entry (output_spill_base (e
.X_add_number
));
3917 dot_spillreg (dummy
)
3918 int dummy ATTRIBUTE_UNUSED
;
3921 unsigned int ab
, xy
, reg
, treg
;
3924 if (!in_procedure ("spillreg"))
3927 sep
= parse_operand (&e1
);
3930 as_bad ("No second operand to .spillreg");
3934 parse_operand (&e2
);
3936 if (!convert_expr_to_ab_reg (&e1
, &ab
, ®
))
3938 as_bad ("First operand to .spillreg must be a preserved register");
3942 if (!convert_expr_to_xy_reg (&e2
, &xy
, &treg
))
3944 as_bad ("Second operand to .spillreg must be a register");
3948 add_unwind_entry (output_spill_reg (ab
, reg
, treg
, xy
));
3952 dot_spillmem (psprel
)
3957 unsigned int ab
, reg
;
3959 if (!in_procedure ("spillmem"))
3962 sep
= parse_operand (&e1
);
3965 as_bad ("Second operand missing");
3969 parse_operand (&e2
);
3971 if (!convert_expr_to_ab_reg (&e1
, &ab
, ®
))
3973 as_bad ("First operand to .spill%s must be a preserved register",
3974 psprel
? "psp" : "sp");
3978 if (e2
.X_op
!= O_constant
)
3980 as_bad ("Second operand to .spill%s must be a constant",
3981 psprel
? "psp" : "sp");
3986 add_unwind_entry (output_spill_psprel (ab
, reg
, e2
.X_add_number
));
3988 add_unwind_entry (output_spill_sprel (ab
, reg
, e2
.X_add_number
));
3992 dot_spillreg_p (dummy
)
3993 int dummy ATTRIBUTE_UNUSED
;
3996 unsigned int ab
, xy
, reg
, treg
;
3997 expressionS e1
, e2
, e3
;
4000 if (!in_procedure ("spillreg.p"))
4003 sep
= parse_operand (&e1
);
4006 as_bad ("No second and third operand to .spillreg.p");
4010 sep
= parse_operand (&e2
);
4013 as_bad ("No third operand to .spillreg.p");
4017 parse_operand (&e3
);
4019 qp
= e1
.X_add_number
- REG_P
;
4021 if (e1
.X_op
!= O_register
|| qp
> 63)
4023 as_bad ("First operand to .spillreg.p must be a predicate");
4027 if (!convert_expr_to_ab_reg (&e2
, &ab
, ®
))
4029 as_bad ("Second operand to .spillreg.p must be a preserved register");
4033 if (!convert_expr_to_xy_reg (&e3
, &xy
, &treg
))
4035 as_bad ("Third operand to .spillreg.p must be a register");
4039 add_unwind_entry (output_spill_reg_p (ab
, reg
, treg
, xy
, qp
));
4043 dot_spillmem_p (psprel
)
4046 expressionS e1
, e2
, e3
;
4048 unsigned int ab
, reg
;
4051 if (!in_procedure ("spillmem.p"))
4054 sep
= parse_operand (&e1
);
4057 as_bad ("Second operand missing");
4061 parse_operand (&e2
);
4064 as_bad ("Second operand missing");
4068 parse_operand (&e3
);
4070 qp
= e1
.X_add_number
- REG_P
;
4071 if (e1
.X_op
!= O_register
|| qp
> 63)
4073 as_bad ("First operand to .spill%s_p must be a predicate",
4074 psprel
? "psp" : "sp");
4078 if (!convert_expr_to_ab_reg (&e2
, &ab
, ®
))
4080 as_bad ("Second operand to .spill%s_p must be a preserved register",
4081 psprel
? "psp" : "sp");
4085 if (e3
.X_op
!= O_constant
)
4087 as_bad ("Third operand to .spill%s_p must be a constant",
4088 psprel
? "psp" : "sp");
4093 add_unwind_entry (output_spill_psprel_p (ab
, reg
, e3
.X_add_number
, qp
));
4095 add_unwind_entry (output_spill_sprel_p (ab
, reg
, e3
.X_add_number
, qp
));
4099 get_saved_prologue_count (lbl
)
4102 label_prologue_count
*lpc
= unwind
.saved_prologue_counts
;
4104 while (lpc
!= NULL
&& lpc
->label_number
!= lbl
)
4108 return lpc
->prologue_count
;
4110 as_bad ("Missing .label_state %ld", lbl
);
4115 save_prologue_count (lbl
, count
)
4119 label_prologue_count
*lpc
= unwind
.saved_prologue_counts
;
4121 while (lpc
!= NULL
&& lpc
->label_number
!= lbl
)
4125 lpc
->prologue_count
= count
;
4128 label_prologue_count
*new_lpc
= xmalloc (sizeof (* new_lpc
));
4130 new_lpc
->next
= unwind
.saved_prologue_counts
;
4131 new_lpc
->label_number
= lbl
;
4132 new_lpc
->prologue_count
= count
;
4133 unwind
.saved_prologue_counts
= new_lpc
;
4138 free_saved_prologue_counts ()
4140 label_prologue_count
*lpc
= unwind
.saved_prologue_counts
;
4141 label_prologue_count
*next
;
4150 unwind
.saved_prologue_counts
= NULL
;
4154 dot_label_state (dummy
)
4155 int dummy ATTRIBUTE_UNUSED
;
4159 if (!in_body ("label_state"))
4163 if (e
.X_op
!= O_constant
)
4165 as_bad ("Operand to .label_state must be a constant");
4168 add_unwind_entry (output_label_state (e
.X_add_number
));
4169 save_prologue_count (e
.X_add_number
, unwind
.prologue_count
);
4173 dot_copy_state (dummy
)
4174 int dummy ATTRIBUTE_UNUSED
;
4178 if (!in_body ("copy_state"))
4182 if (e
.X_op
!= O_constant
)
4184 as_bad ("Operand to .copy_state must be a constant");
4187 add_unwind_entry (output_copy_state (e
.X_add_number
));
4188 unwind
.prologue_count
= get_saved_prologue_count (e
.X_add_number
);
4193 int dummy ATTRIBUTE_UNUSED
;
4198 if (!in_procedure ("unwabi"))
4201 sep
= parse_operand (&e1
);
4204 as_bad ("Second operand to .unwabi missing");
4207 sep
= parse_operand (&e2
);
4208 if (!is_end_of_line
[sep
] && !is_it_end_of_statement ())
4209 demand_empty_rest_of_line ();
4211 if (e1
.X_op
!= O_constant
)
4213 as_bad ("First operand to .unwabi must be a constant");
4217 if (e2
.X_op
!= O_constant
)
4219 as_bad ("Second operand to .unwabi must be a constant");
4223 add_unwind_entry (output_unwabi (e1
.X_add_number
, e2
.X_add_number
));
4227 dot_personality (dummy
)
4228 int dummy ATTRIBUTE_UNUSED
;
4231 if (!in_procedure ("personality"))
4234 name
= input_line_pointer
;
4235 c
= get_symbol_end ();
4236 p
= input_line_pointer
;
4237 unwind
.personality_routine
= symbol_find_or_make (name
);
4238 unwind
.force_unwind_entry
= 1;
4241 demand_empty_rest_of_line ();
4246 int dummy ATTRIBUTE_UNUSED
;
4251 unwind
.proc_start
= 0;
4252 /* Parse names of main and alternate entry points and mark them as
4253 function symbols: */
4257 name
= input_line_pointer
;
4258 c
= get_symbol_end ();
4259 p
= input_line_pointer
;
4261 as_bad ("Empty argument of .proc");
4264 sym
= symbol_find_or_make (name
);
4265 if (S_IS_DEFINED (sym
))
4266 as_bad ("`%s' was already defined", name
);
4267 else if (unwind
.proc_start
== 0)
4269 unwind
.proc_start
= sym
;
4271 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
4275 if (*input_line_pointer
!= ',')
4277 ++input_line_pointer
;
4279 if (unwind
.proc_start
== 0)
4280 unwind
.proc_start
= expr_build_dot ();
4281 demand_empty_rest_of_line ();
4284 unwind
.prologue
= 0;
4285 unwind
.prologue_count
= 0;
4288 unwind
.list
= unwind
.tail
= unwind
.current_entry
= NULL
;
4289 unwind
.personality_routine
= 0;
4294 int dummy ATTRIBUTE_UNUSED
;
4296 if (!in_procedure ("body"))
4298 if (!unwind
.prologue
&& !unwind
.body
&& unwind
.insn
)
4299 as_warn ("Initial .body should precede any instructions");
4301 unwind
.prologue
= 0;
4302 unwind
.prologue_mask
= 0;
4305 add_unwind_entry (output_body ());
4306 demand_empty_rest_of_line ();
4310 dot_prologue (dummy
)
4311 int dummy ATTRIBUTE_UNUSED
;
4314 int mask
= 0, grsave
= 0;
4316 if (!in_procedure ("prologue"))
4318 if (unwind
.prologue
)
4320 as_bad (".prologue within prologue");
4321 ignore_rest_of_line ();
4324 if (!unwind
.body
&& unwind
.insn
)
4325 as_warn ("Initial .prologue should precede any instructions");
4327 if (!is_it_end_of_statement ())
4330 sep
= parse_operand (&e1
);
4332 as_bad ("No second operand to .prologue");
4333 sep
= parse_operand (&e2
);
4334 if (!is_end_of_line
[sep
] && !is_it_end_of_statement ())
4335 demand_empty_rest_of_line ();
4337 if (e1
.X_op
== O_constant
)
4339 mask
= e1
.X_add_number
;
4341 if (e2
.X_op
== O_constant
)
4342 grsave
= e2
.X_add_number
;
4343 else if (e2
.X_op
== O_register
4344 && (grsave
= e2
.X_add_number
- REG_GR
) < 128)
4347 as_bad ("Second operand not a constant or general register");
4349 add_unwind_entry (output_prologue_gr (mask
, grsave
));
4352 as_bad ("First operand not a constant");
4355 add_unwind_entry (output_prologue ());
4357 unwind
.prologue
= 1;
4358 unwind
.prologue_mask
= mask
;
4360 ++unwind
.prologue_count
;
4365 int dummy ATTRIBUTE_UNUSED
;
4369 int bytes_per_address
;
4372 subsegT saved_subseg
;
4373 char *name
, *default_name
, *p
, c
;
4375 int unwind_check
= md
.unwind_check
;
4377 md
.unwind_check
= unwind_check_error
;
4378 if (!in_procedure ("endp"))
4380 md
.unwind_check
= unwind_check
;
4382 if (unwind
.saved_text_seg
)
4384 saved_seg
= unwind
.saved_text_seg
;
4385 saved_subseg
= unwind
.saved_text_subseg
;
4386 unwind
.saved_text_seg
= NULL
;
4390 saved_seg
= now_seg
;
4391 saved_subseg
= now_subseg
;
4394 insn_group_break (1, 0, 0);
4396 /* If there wasn't a .handlerdata, we haven't generated an image yet. */
4398 generate_unwind_image (saved_seg
);
4400 if (unwind
.info
|| unwind
.force_unwind_entry
)
4404 subseg_set (md
.last_text_seg
, 0);
4405 proc_end
= expr_build_dot ();
4407 start_unwind_section (saved_seg
, SPECIAL_SECTION_UNWIND
, 0);
4409 /* Make sure that section has 4 byte alignment for ILP32 and
4410 8 byte alignment for LP64. */
4411 record_alignment (now_seg
, md
.pointer_size_shift
);
4413 /* Need space for 3 pointers for procedure start, procedure end,
4415 ptr
= frag_more (3 * md
.pointer_size
);
4416 where
= frag_now_fix () - (3 * md
.pointer_size
);
4417 bytes_per_address
= bfd_arch_bits_per_address (stdoutput
) / 8;
4419 /* Issue the values of a) Proc Begin, b) Proc End, c) Unwind Record. */
4420 e
.X_op
= O_pseudo_fixup
;
4421 e
.X_op_symbol
= pseudo_func
[FUNC_SEG_RELATIVE
].u
.sym
;
4423 e
.X_add_symbol
= unwind
.proc_start
;
4424 ia64_cons_fix_new (frag_now
, where
, bytes_per_address
, &e
);
4426 e
.X_op
= O_pseudo_fixup
;
4427 e
.X_op_symbol
= pseudo_func
[FUNC_SEG_RELATIVE
].u
.sym
;
4429 e
.X_add_symbol
= proc_end
;
4430 ia64_cons_fix_new (frag_now
, where
+ bytes_per_address
,
4431 bytes_per_address
, &e
);
4435 e
.X_op
= O_pseudo_fixup
;
4436 e
.X_op_symbol
= pseudo_func
[FUNC_SEG_RELATIVE
].u
.sym
;
4438 e
.X_add_symbol
= unwind
.info
;
4439 ia64_cons_fix_new (frag_now
, where
+ (bytes_per_address
* 2),
4440 bytes_per_address
, &e
);
4443 md_number_to_chars (ptr
+ (bytes_per_address
* 2), 0,
4448 start_unwind_section (saved_seg
, SPECIAL_SECTION_UNWIND
, 1);
4450 subseg_set (saved_seg
, saved_subseg
);
4452 if (unwind
.proc_start
)
4453 default_name
= (char *) S_GET_NAME (unwind
.proc_start
);
4455 default_name
= NULL
;
4457 /* Parse names of main and alternate entry points and set symbol sizes. */
4461 name
= input_line_pointer
;
4462 c
= get_symbol_end ();
4463 p
= input_line_pointer
;
4466 if (md
.unwind_check
== unwind_check_warning
)
4470 as_warn ("Empty argument of .endp. Use the default name `%s'",
4472 name
= default_name
;
4475 as_warn ("Empty argument of .endp");
4478 as_bad ("Empty argument of .endp");
4482 sym
= symbol_find (name
);
4484 && md
.unwind_check
== unwind_check_warning
4486 && default_name
!= name
)
4488 /* We have a bad name. Try the default one if needed. */
4489 as_warn ("`%s' was not defined within procedure. Use the default name `%s'",
4490 name
, default_name
);
4491 name
= default_name
;
4492 sym
= symbol_find (name
);
4494 if (!sym
|| !S_IS_DEFINED (sym
))
4495 as_bad ("`%s' was not defined within procedure", name
);
4496 else if (unwind
.proc_start
4497 && (symbol_get_bfdsym (sym
)->flags
& BSF_FUNCTION
)
4498 && S_GET_SIZE (sym
) == 0 && symbol_get_obj (sym
)->size
== NULL
)
4500 fragS
*fr
= symbol_get_frag (unwind
.proc_start
);
4501 fragS
*frag
= symbol_get_frag (sym
);
4503 /* Check whether the function label is at or beyond last
4505 while (fr
&& fr
!= frag
)
4509 if (frag
== frag_now
&& SEG_NORMAL (now_seg
))
4510 S_SET_SIZE (sym
, frag_now_fix () - S_GET_VALUE (sym
));
4513 symbol_get_obj (sym
)->size
=
4514 (expressionS
*) xmalloc (sizeof (expressionS
));
4515 symbol_get_obj (sym
)->size
->X_op
= O_subtract
;
4516 symbol_get_obj (sym
)->size
->X_add_symbol
4517 = symbol_new (FAKE_LABEL_NAME
, now_seg
,
4518 frag_now_fix (), frag_now
);
4519 symbol_get_obj (sym
)->size
->X_op_symbol
= sym
;
4520 symbol_get_obj (sym
)->size
->X_add_number
= 0;
4527 if (*input_line_pointer
!= ',')
4529 ++input_line_pointer
;
4531 demand_empty_rest_of_line ();
4532 unwind
.proc_start
= unwind
.info
= 0;
4536 dot_template (template)
4539 CURR_SLOT
.user_template
= template;
4544 int dummy ATTRIBUTE_UNUSED
;
4546 int ins
, locs
, outs
, rots
;
4548 if (is_it_end_of_statement ())
4549 ins
= locs
= outs
= rots
= 0;
4552 ins
= get_absolute_expression ();
4553 if (*input_line_pointer
++ != ',')
4555 locs
= get_absolute_expression ();
4556 if (*input_line_pointer
++ != ',')
4558 outs
= get_absolute_expression ();
4559 if (*input_line_pointer
++ != ',')
4561 rots
= get_absolute_expression ();
4563 set_regstack (ins
, locs
, outs
, rots
);
4567 as_bad ("Comma expected");
4568 ignore_rest_of_line ();
4575 unsigned num_regs
, num_alloced
= 0;
4576 struct dynreg
**drpp
, *dr
;
4577 int ch
, base_reg
= 0;
4583 case DYNREG_GR
: base_reg
= REG_GR
+ 32; break;
4584 case DYNREG_FR
: base_reg
= REG_FR
+ 32; break;
4585 case DYNREG_PR
: base_reg
= REG_P
+ 16; break;
4589 /* First, remove existing names from hash table. */
4590 for (dr
= md
.dynreg
[type
]; dr
&& dr
->num_regs
; dr
= dr
->next
)
4592 hash_delete (md
.dynreg_hash
, dr
->name
);
4593 /* FIXME: Free dr->name. */
4597 drpp
= &md
.dynreg
[type
];
4600 start
= input_line_pointer
;
4601 ch
= get_symbol_end ();
4602 len
= strlen (ia64_canonicalize_symbol_name (start
));
4603 *input_line_pointer
= ch
;
4606 if (*input_line_pointer
!= '[')
4608 as_bad ("Expected '['");
4611 ++input_line_pointer
; /* skip '[' */
4613 num_regs
= get_absolute_expression ();
4615 if (*input_line_pointer
++ != ']')
4617 as_bad ("Expected ']'");
4622 num_alloced
+= num_regs
;
4626 if (num_alloced
> md
.rot
.num_regs
)
4628 as_bad ("Used more than the declared %d rotating registers",
4634 if (num_alloced
> 96)
4636 as_bad ("Used more than the available 96 rotating registers");
4641 if (num_alloced
> 48)
4643 as_bad ("Used more than the available 48 rotating registers");
4654 *drpp
= obstack_alloc (¬es
, sizeof (*dr
));
4655 memset (*drpp
, 0, sizeof (*dr
));
4658 name
= obstack_alloc (¬es
, len
+ 1);
4659 memcpy (name
, start
, len
);
4664 dr
->num_regs
= num_regs
;
4665 dr
->base
= base_reg
;
4667 base_reg
+= num_regs
;
4669 if (hash_insert (md
.dynreg_hash
, name
, dr
))
4671 as_bad ("Attempt to redefine register set `%s'", name
);
4672 obstack_free (¬es
, name
);
4676 if (*input_line_pointer
!= ',')
4678 ++input_line_pointer
; /* skip comma */
4681 demand_empty_rest_of_line ();
4685 ignore_rest_of_line ();
4689 dot_byteorder (byteorder
)
4692 segment_info_type
*seginfo
= seg_info (now_seg
);
4694 if (byteorder
== -1)
4696 if (seginfo
->tc_segment_info_data
.endian
== 0)
4697 seginfo
->tc_segment_info_data
.endian
= default_big_endian
? 1 : 2;
4698 byteorder
= seginfo
->tc_segment_info_data
.endian
== 1;
4701 seginfo
->tc_segment_info_data
.endian
= byteorder
? 1 : 2;
4703 if (target_big_endian
!= byteorder
)
4705 target_big_endian
= byteorder
;
4706 if (target_big_endian
)
4708 ia64_number_to_chars
= number_to_chars_bigendian
;
4709 ia64_float_to_chars
= ia64_float_to_chars_bigendian
;
4713 ia64_number_to_chars
= number_to_chars_littleendian
;
4714 ia64_float_to_chars
= ia64_float_to_chars_littleendian
;
4721 int dummy ATTRIBUTE_UNUSED
;
4728 option
= input_line_pointer
;
4729 ch
= get_symbol_end ();
4730 if (strcmp (option
, "lsb") == 0)
4731 md
.flags
&= ~EF_IA_64_BE
;
4732 else if (strcmp (option
, "msb") == 0)
4733 md
.flags
|= EF_IA_64_BE
;
4734 else if (strcmp (option
, "abi32") == 0)
4735 md
.flags
&= ~EF_IA_64_ABI64
;
4736 else if (strcmp (option
, "abi64") == 0)
4737 md
.flags
|= EF_IA_64_ABI64
;
4739 as_bad ("Unknown psr option `%s'", option
);
4740 *input_line_pointer
= ch
;
4743 if (*input_line_pointer
!= ',')
4746 ++input_line_pointer
;
4749 demand_empty_rest_of_line ();
4754 int dummy ATTRIBUTE_UNUSED
;
4756 new_logical_line (0, get_absolute_expression ());
4757 demand_empty_rest_of_line ();
4761 cross_section (ref
, cons
, ua
)
4763 void (*cons
) PARAMS((int));
4767 int saved_auto_align
;
4768 unsigned int section_count
;
4771 start
= input_line_pointer
;
4777 name
= demand_copy_C_string (&len
);
4778 obstack_free(¬es
, name
);
4781 ignore_rest_of_line ();
4787 char c
= get_symbol_end ();
4789 if (input_line_pointer
== start
)
4791 as_bad ("Missing section name");
4792 ignore_rest_of_line ();
4795 *input_line_pointer
= c
;
4797 end
= input_line_pointer
;
4799 if (*input_line_pointer
!= ',')
4801 as_bad ("Comma expected after section name");
4802 ignore_rest_of_line ();
4806 end
= input_line_pointer
+ 1; /* skip comma */
4807 input_line_pointer
= start
;
4808 md
.keep_pending_output
= 1;
4809 section_count
= bfd_count_sections(stdoutput
);
4810 obj_elf_section (0);
4811 if (section_count
!= bfd_count_sections(stdoutput
))
4812 as_warn ("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated.");
4813 input_line_pointer
= end
;
4814 saved_auto_align
= md
.auto_align
;
4819 md
.auto_align
= saved_auto_align
;
4820 obj_elf_previous (0);
4821 md
.keep_pending_output
= 0;
4828 cross_section (size
, cons
, 0);
4831 /* Why doesn't float_cons() call md_cons_align() the way cons() does? */
4834 stmt_float_cons (kind
)
4855 ia64_do_align (alignment
);
4863 int saved_auto_align
= md
.auto_align
;
4867 md
.auto_align
= saved_auto_align
;
4871 dot_xfloat_cons (kind
)
4874 cross_section (kind
, stmt_float_cons
, 0);
4878 dot_xstringer (zero
)
4881 cross_section (zero
, stringer
, 0);
4888 cross_section (size
, cons
, 1);
4892 dot_xfloat_cons_ua (kind
)
4895 cross_section (kind
, float_cons
, 1);
4898 /* .reg.val <regname>,value */
4902 int dummy ATTRIBUTE_UNUSED
;
4907 if (reg
.X_op
!= O_register
)
4909 as_bad (_("Register name expected"));
4910 ignore_rest_of_line ();
4912 else if (*input_line_pointer
++ != ',')
4914 as_bad (_("Comma expected"));
4915 ignore_rest_of_line ();
4919 valueT value
= get_absolute_expression ();
4920 int regno
= reg
.X_add_number
;
4921 if (regno
<= REG_GR
|| regno
> REG_GR
+ 127)
4922 as_warn (_("Register value annotation ignored"));
4925 gr_values
[regno
- REG_GR
].known
= 1;
4926 gr_values
[regno
- REG_GR
].value
= value
;
4927 gr_values
[regno
- REG_GR
].path
= md
.path
;
4930 demand_empty_rest_of_line ();
4935 .serialize.instruction
4938 dot_serialize (type
)
4941 insn_group_break (0, 0, 0);
4943 instruction_serialization ();
4945 data_serialization ();
4946 insn_group_break (0, 0, 0);
4947 demand_empty_rest_of_line ();
4950 /* select dv checking mode
4955 A stop is inserted when changing modes
4962 if (md
.manual_bundling
)
4963 as_warn (_("Directive invalid within a bundle"));
4965 if (type
== 'E' || type
== 'A')
4966 md
.mode_explicitly_set
= 0;
4968 md
.mode_explicitly_set
= 1;
4975 if (md
.explicit_mode
)
4976 insn_group_break (1, 0, 0);
4977 md
.explicit_mode
= 0;
4981 if (!md
.explicit_mode
)
4982 insn_group_break (1, 0, 0);
4983 md
.explicit_mode
= 1;
4987 if (md
.explicit_mode
!= md
.default_explicit_mode
)
4988 insn_group_break (1, 0, 0);
4989 md
.explicit_mode
= md
.default_explicit_mode
;
4990 md
.mode_explicitly_set
= 0;
5001 for (regno
= 0; regno
< 64; regno
++)
5003 if (mask
& ((valueT
) 1 << regno
))
5005 fprintf (stderr
, "%s p%d", comma
, regno
);
5012 .pred.rel.clear [p1 [,p2 [,...]]] (also .pred.rel "clear" or @clear)
5013 .pred.rel.imply p1, p2 (also .pred.rel "imply" or @imply)
5014 .pred.rel.mutex p1, p2 [,...] (also .pred.rel "mutex" or @mutex)
5015 .pred.safe_across_calls p1 [, p2 [,...]]
5024 int p1
= -1, p2
= -1;
5028 if (*input_line_pointer
== '"')
5031 char *form
= demand_copy_C_string (&len
);
5033 if (strcmp (form
, "mutex") == 0)
5035 else if (strcmp (form
, "clear") == 0)
5037 else if (strcmp (form
, "imply") == 0)
5039 obstack_free (¬es
, form
);
5041 else if (*input_line_pointer
== '@')
5043 char *form
= ++input_line_pointer
;
5044 char c
= get_symbol_end();
5046 if (strcmp (form
, "mutex") == 0)
5048 else if (strcmp (form
, "clear") == 0)
5050 else if (strcmp (form
, "imply") == 0)
5052 *input_line_pointer
= c
;
5056 as_bad (_("Missing predicate relation type"));
5057 ignore_rest_of_line ();
5062 as_bad (_("Unrecognized predicate relation type"));
5063 ignore_rest_of_line ();
5066 if (*input_line_pointer
== ',')
5067 ++input_line_pointer
;
5076 expressionS pr
, *pr1
, *pr2
;
5079 if (pr
.X_op
== O_register
5080 && pr
.X_add_number
>= REG_P
5081 && pr
.X_add_number
<= REG_P
+ 63)
5083 regno
= pr
.X_add_number
- REG_P
;
5091 else if (type
!= 'i'
5092 && pr
.X_op
== O_subtract
5093 && (pr1
= symbol_get_value_expression (pr
.X_add_symbol
))
5094 && pr1
->X_op
== O_register
5095 && pr1
->X_add_number
>= REG_P
5096 && pr1
->X_add_number
<= REG_P
+ 63
5097 && (pr2
= symbol_get_value_expression (pr
.X_op_symbol
))
5098 && pr2
->X_op
== O_register
5099 && pr2
->X_add_number
>= REG_P
5100 && pr2
->X_add_number
<= REG_P
+ 63)
5105 regno
= pr1
->X_add_number
- REG_P
;
5106 stop
= pr2
->X_add_number
- REG_P
;
5109 as_bad (_("Bad register range"));
5110 ignore_rest_of_line ();
5113 bits
= ((bits
<< stop
) << 1) - (bits
<< regno
);
5114 count
+= stop
- regno
+ 1;
5118 as_bad (_("Predicate register expected"));
5119 ignore_rest_of_line ();
5123 as_warn (_("Duplicate predicate register ignored"));
5125 if (*input_line_pointer
!= ',')
5127 ++input_line_pointer
;
5136 clear_qp_mutex (mask
);
5137 clear_qp_implies (mask
, (valueT
) 0);
5140 if (count
!= 2 || p1
== -1 || p2
== -1)
5141 as_bad (_("Predicate source and target required"));
5142 else if (p1
== 0 || p2
== 0)
5143 as_bad (_("Use of p0 is not valid in this context"));
5145 add_qp_imply (p1
, p2
);
5150 as_bad (_("At least two PR arguments expected"));
5155 as_bad (_("Use of p0 is not valid in this context"));
5158 add_qp_mutex (mask
);
5161 /* note that we don't override any existing relations */
5164 as_bad (_("At least one PR argument expected"));
5169 fprintf (stderr
, "Safe across calls: ");
5170 print_prmask (mask
);
5171 fprintf (stderr
, "\n");
5173 qp_safe_across_calls
= mask
;
5176 demand_empty_rest_of_line ();
5179 /* .entry label [, label [, ...]]
5180 Hint to DV code that the given labels are to be considered entry points.
5181 Otherwise, only global labels are considered entry points. */
5185 int dummy ATTRIBUTE_UNUSED
;
5194 name
= input_line_pointer
;
5195 c
= get_symbol_end ();
5196 symbolP
= symbol_find_or_make (name
);
5198 err
= hash_insert (md
.entry_hash
, S_GET_NAME (symbolP
), (PTR
) symbolP
);
5200 as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
5203 *input_line_pointer
= c
;
5205 c
= *input_line_pointer
;
5208 input_line_pointer
++;
5210 if (*input_line_pointer
== '\n')
5216 demand_empty_rest_of_line ();
5219 /* .mem.offset offset, base
5220 "base" is used to distinguish between offsets from a different base. */
5223 dot_mem_offset (dummy
)
5224 int dummy ATTRIBUTE_UNUSED
;
5226 md
.mem_offset
.hint
= 1;
5227 md
.mem_offset
.offset
= get_absolute_expression ();
5228 if (*input_line_pointer
!= ',')
5230 as_bad (_("Comma expected"));
5231 ignore_rest_of_line ();
5234 ++input_line_pointer
;
5235 md
.mem_offset
.base
= get_absolute_expression ();
5236 demand_empty_rest_of_line ();
5239 /* ia64-specific pseudo-ops: */
5240 const pseudo_typeS md_pseudo_table
[] =
5242 { "radix", dot_radix
, 0 },
5243 { "lcomm", s_lcomm_bytes
, 1 },
5244 { "loc", dot_loc
, 0 },
5245 { "bss", dot_special_section
, SPECIAL_SECTION_BSS
},
5246 { "sbss", dot_special_section
, SPECIAL_SECTION_SBSS
},
5247 { "sdata", dot_special_section
, SPECIAL_SECTION_SDATA
},
5248 { "rodata", dot_special_section
, SPECIAL_SECTION_RODATA
},
5249 { "comment", dot_special_section
, SPECIAL_SECTION_COMMENT
},
5250 { "ia_64.unwind", dot_special_section
, SPECIAL_SECTION_UNWIND
},
5251 { "ia_64.unwind_info", dot_special_section
, SPECIAL_SECTION_UNWIND_INFO
},
5252 { "init_array", dot_special_section
, SPECIAL_SECTION_INIT_ARRAY
},
5253 { "fini_array", dot_special_section
, SPECIAL_SECTION_FINI_ARRAY
},
5254 { "proc", dot_proc
, 0 },
5255 { "body", dot_body
, 0 },
5256 { "prologue", dot_prologue
, 0 },
5257 { "endp", dot_endp
, 0 },
5259 { "fframe", dot_fframe
, 0 },
5260 { "vframe", dot_vframe
, 0 },
5261 { "vframesp", dot_vframesp
, 0 },
5262 { "vframepsp", dot_vframepsp
, 0 },
5263 { "save", dot_save
, 0 },
5264 { "restore", dot_restore
, 0 },
5265 { "restorereg", dot_restorereg
, 0 },
5266 { "restorereg.p", dot_restorereg_p
, 0 },
5267 { "handlerdata", dot_handlerdata
, 0 },
5268 { "unwentry", dot_unwentry
, 0 },
5269 { "altrp", dot_altrp
, 0 },
5270 { "savesp", dot_savemem
, 0 },
5271 { "savepsp", dot_savemem
, 1 },
5272 { "save.g", dot_saveg
, 0 },
5273 { "save.f", dot_savef
, 0 },
5274 { "save.b", dot_saveb
, 0 },
5275 { "save.gf", dot_savegf
, 0 },
5276 { "spill", dot_spill
, 0 },
5277 { "spillreg", dot_spillreg
, 0 },
5278 { "spillsp", dot_spillmem
, 0 },
5279 { "spillpsp", dot_spillmem
, 1 },
5280 { "spillreg.p", dot_spillreg_p
, 0 },
5281 { "spillsp.p", dot_spillmem_p
, 0 },
5282 { "spillpsp.p", dot_spillmem_p
, 1 },
5283 { "label_state", dot_label_state
, 0 },
5284 { "copy_state", dot_copy_state
, 0 },
5285 { "unwabi", dot_unwabi
, 0 },
5286 { "personality", dot_personality
, 0 },
5287 { "mii", dot_template
, 0x0 },
5288 { "mli", dot_template
, 0x2 }, /* old format, for compatibility */
5289 { "mlx", dot_template
, 0x2 },
5290 { "mmi", dot_template
, 0x4 },
5291 { "mfi", dot_template
, 0x6 },
5292 { "mmf", dot_template
, 0x7 },
5293 { "mib", dot_template
, 0x8 },
5294 { "mbb", dot_template
, 0x9 },
5295 { "bbb", dot_template
, 0xb },
5296 { "mmb", dot_template
, 0xc },
5297 { "mfb", dot_template
, 0xe },
5298 { "align", dot_align
, 0 },
5299 { "regstk", dot_regstk
, 0 },
5300 { "rotr", dot_rot
, DYNREG_GR
},
5301 { "rotf", dot_rot
, DYNREG_FR
},
5302 { "rotp", dot_rot
, DYNREG_PR
},
5303 { "lsb", dot_byteorder
, 0 },
5304 { "msb", dot_byteorder
, 1 },
5305 { "psr", dot_psr
, 0 },
5306 { "alias", dot_alias
, 0 },
5307 { "secalias", dot_alias
, 1 },
5308 { "ln", dot_ln
, 0 }, /* source line info (for debugging) */
5310 { "xdata1", dot_xdata
, 1 },
5311 { "xdata2", dot_xdata
, 2 },
5312 { "xdata4", dot_xdata
, 4 },
5313 { "xdata8", dot_xdata
, 8 },
5314 { "xdata16", dot_xdata
, 16 },
5315 { "xreal4", dot_xfloat_cons
, 'f' },
5316 { "xreal8", dot_xfloat_cons
, 'd' },
5317 { "xreal10", dot_xfloat_cons
, 'x' },
5318 { "xreal16", dot_xfloat_cons
, 'X' },
5319 { "xstring", dot_xstringer
, 0 },
5320 { "xstringz", dot_xstringer
, 1 },
5322 /* unaligned versions: */
5323 { "xdata2.ua", dot_xdata_ua
, 2 },
5324 { "xdata4.ua", dot_xdata_ua
, 4 },
5325 { "xdata8.ua", dot_xdata_ua
, 8 },
5326 { "xdata16.ua", dot_xdata_ua
, 16 },
5327 { "xreal4.ua", dot_xfloat_cons_ua
, 'f' },
5328 { "xreal8.ua", dot_xfloat_cons_ua
, 'd' },
5329 { "xreal10.ua", dot_xfloat_cons_ua
, 'x' },
5330 { "xreal16.ua", dot_xfloat_cons_ua
, 'X' },
5332 /* annotations/DV checking support */
5333 { "entry", dot_entry
, 0 },
5334 { "mem.offset", dot_mem_offset
, 0 },
5335 { "pred.rel", dot_pred_rel
, 0 },
5336 { "pred.rel.clear", dot_pred_rel
, 'c' },
5337 { "pred.rel.imply", dot_pred_rel
, 'i' },
5338 { "pred.rel.mutex", dot_pred_rel
, 'm' },
5339 { "pred.safe_across_calls", dot_pred_rel
, 's' },
5340 { "reg.val", dot_reg_val
, 0 },
5341 { "serialize.data", dot_serialize
, 0 },
5342 { "serialize.instruction", dot_serialize
, 1 },
5343 { "auto", dot_dv_mode
, 'a' },
5344 { "explicit", dot_dv_mode
, 'e' },
5345 { "default", dot_dv_mode
, 'd' },
5347 /* ??? These are needed to make gas/testsuite/gas/elf/ehopt.s work.
5348 IA-64 aligns data allocation pseudo-ops by default, so we have to
5349 tell it that these ones are supposed to be unaligned. Long term,
5350 should rewrite so that only IA-64 specific data allocation pseudo-ops
5351 are aligned by default. */
5352 {"2byte", stmt_cons_ua
, 2},
5353 {"4byte", stmt_cons_ua
, 4},
5354 {"8byte", stmt_cons_ua
, 8},
5359 static const struct pseudo_opcode
5362 void (*handler
) (int);
5367 /* these are more like pseudo-ops, but don't start with a dot */
5368 { "data1", cons
, 1 },
5369 { "data2", cons
, 2 },
5370 { "data4", cons
, 4 },
5371 { "data8", cons
, 8 },
5372 { "data16", cons
, 16 },
5373 { "real4", stmt_float_cons
, 'f' },
5374 { "real8", stmt_float_cons
, 'd' },
5375 { "real10", stmt_float_cons
, 'x' },
5376 { "real16", stmt_float_cons
, 'X' },
5377 { "string", stringer
, 0 },
5378 { "stringz", stringer
, 1 },
5380 /* unaligned versions: */
5381 { "data2.ua", stmt_cons_ua
, 2 },
5382 { "data4.ua", stmt_cons_ua
, 4 },
5383 { "data8.ua", stmt_cons_ua
, 8 },
5384 { "data16.ua", stmt_cons_ua
, 16 },
5385 { "real4.ua", float_cons
, 'f' },
5386 { "real8.ua", float_cons
, 'd' },
5387 { "real10.ua", float_cons
, 'x' },
5388 { "real16.ua", float_cons
, 'X' },
5391 /* Declare a register by creating a symbol for it and entering it in
5392 the symbol table. */
5395 declare_register (name
, regnum
)
5402 sym
= symbol_new (name
, reg_section
, regnum
, &zero_address_frag
);
5404 err
= hash_insert (md
.reg_hash
, S_GET_NAME (sym
), (PTR
) sym
);
5406 as_fatal ("Inserting \"%s\" into register table failed: %s",
5413 declare_register_set (prefix
, num_regs
, base_regnum
)
5421 for (i
= 0; i
< num_regs
; ++i
)
5423 sprintf (name
, "%s%u", prefix
, i
);
5424 declare_register (name
, base_regnum
+ i
);
5429 operand_width (opnd
)
5430 enum ia64_opnd opnd
;
5432 const struct ia64_operand
*odesc
= &elf64_ia64_operands
[opnd
];
5433 unsigned int bits
= 0;
5437 for (i
= 0; i
< NELEMS (odesc
->field
) && odesc
->field
[i
].bits
; ++i
)
5438 bits
+= odesc
->field
[i
].bits
;
5443 static enum operand_match_result
5444 operand_match (idesc
, index
, e
)
5445 const struct ia64_opcode
*idesc
;
5449 enum ia64_opnd opnd
= idesc
->operands
[index
];
5450 int bits
, relocatable
= 0;
5451 struct insn_fix
*fix
;
5458 case IA64_OPND_AR_CCV
:
5459 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_AR
+ 32)
5460 return OPERAND_MATCH
;
5463 case IA64_OPND_AR_CSD
:
5464 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_AR
+ 25)
5465 return OPERAND_MATCH
;
5468 case IA64_OPND_AR_PFS
:
5469 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_AR
+ 64)
5470 return OPERAND_MATCH
;
5474 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_GR
+ 0)
5475 return OPERAND_MATCH
;
5479 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_IP
)
5480 return OPERAND_MATCH
;
5484 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_PR
)
5485 return OPERAND_MATCH
;
5488 case IA64_OPND_PR_ROT
:
5489 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_PR_ROT
)
5490 return OPERAND_MATCH
;
5494 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_PSR
)
5495 return OPERAND_MATCH
;
5498 case IA64_OPND_PSR_L
:
5499 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_PSR_L
)
5500 return OPERAND_MATCH
;
5503 case IA64_OPND_PSR_UM
:
5504 if (e
->X_op
== O_register
&& e
->X_add_number
== REG_PSR_UM
)
5505 return OPERAND_MATCH
;
5509 if (e
->X_op
== O_constant
)
5511 if (e
->X_add_number
== 1)
5512 return OPERAND_MATCH
;
5514 return OPERAND_OUT_OF_RANGE
;
5519 if (e
->X_op
== O_constant
)
5521 if (e
->X_add_number
== 8)
5522 return OPERAND_MATCH
;
5524 return OPERAND_OUT_OF_RANGE
;
5529 if (e
->X_op
== O_constant
)
5531 if (e
->X_add_number
== 16)
5532 return OPERAND_MATCH
;
5534 return OPERAND_OUT_OF_RANGE
;
5538 /* register operands: */
5541 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_AR
5542 && e
->X_add_number
< REG_AR
+ 128)
5543 return OPERAND_MATCH
;
5548 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_BR
5549 && e
->X_add_number
< REG_BR
+ 8)
5550 return OPERAND_MATCH
;
5554 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_CR
5555 && e
->X_add_number
< REG_CR
+ 128)
5556 return OPERAND_MATCH
;
5563 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_FR
5564 && e
->X_add_number
< REG_FR
+ 128)
5565 return OPERAND_MATCH
;
5570 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_P
5571 && e
->X_add_number
< REG_P
+ 64)
5572 return OPERAND_MATCH
;
5578 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_GR
5579 && e
->X_add_number
< REG_GR
+ 128)
5580 return OPERAND_MATCH
;
5583 case IA64_OPND_R3_2
:
5584 if (e
->X_op
== O_register
&& e
->X_add_number
>= REG_GR
)
5586 if (e
->X_add_number
< REG_GR
+ 4)
5587 return OPERAND_MATCH
;
5588 else if (e
->X_add_number
< REG_GR
+ 128)
5589 return OPERAND_OUT_OF_RANGE
;
5593 /* indirect operands: */
5594 case IA64_OPND_CPUID_R3
:
5595 case IA64_OPND_DBR_R3
:
5596 case IA64_OPND_DTR_R3
:
5597 case IA64_OPND_ITR_R3
:
5598 case IA64_OPND_IBR_R3
:
5599 case IA64_OPND_MSR_R3
:
5600 case IA64_OPND_PKR_R3
:
5601 case IA64_OPND_PMC_R3
:
5602 case IA64_OPND_PMD_R3
:
5603 case IA64_OPND_RR_R3
:
5604 if (e
->X_op
== O_index
&& e
->X_op_symbol
5605 && (S_GET_VALUE (e
->X_op_symbol
) - IND_CPUID
5606 == opnd
- IA64_OPND_CPUID_R3
))
5607 return OPERAND_MATCH
;
5611 if (e
->X_op
== O_index
&& !e
->X_op_symbol
)
5612 return OPERAND_MATCH
;
5615 /* immediate operands: */
5616 case IA64_OPND_CNT2a
:
5617 case IA64_OPND_LEN4
:
5618 case IA64_OPND_LEN6
:
5619 bits
= operand_width (idesc
->operands
[index
]);
5620 if (e
->X_op
== O_constant
)
5622 if ((bfd_vma
) (e
->X_add_number
- 1) < ((bfd_vma
) 1 << bits
))
5623 return OPERAND_MATCH
;
5625 return OPERAND_OUT_OF_RANGE
;
5629 case IA64_OPND_CNT2b
:
5630 if (e
->X_op
== O_constant
)
5632 if ((bfd_vma
) (e
->X_add_number
- 1) < 3)
5633 return OPERAND_MATCH
;
5635 return OPERAND_OUT_OF_RANGE
;
5639 case IA64_OPND_CNT2c
:
5640 val
= e
->X_add_number
;
5641 if (e
->X_op
== O_constant
)
5643 if ((val
== 0 || val
== 7 || val
== 15 || val
== 16))
5644 return OPERAND_MATCH
;
5646 return OPERAND_OUT_OF_RANGE
;
5651 /* SOR must be an integer multiple of 8 */
5652 if (e
->X_op
== O_constant
&& e
->X_add_number
& 0x7)
5653 return OPERAND_OUT_OF_RANGE
;
5656 if (e
->X_op
== O_constant
)
5658 if ((bfd_vma
) e
->X_add_number
<= 96)
5659 return OPERAND_MATCH
;
5661 return OPERAND_OUT_OF_RANGE
;
5665 case IA64_OPND_IMMU62
:
5666 if (e
->X_op
== O_constant
)
5668 if ((bfd_vma
) e
->X_add_number
< ((bfd_vma
) 1 << 62))
5669 return OPERAND_MATCH
;
5671 return OPERAND_OUT_OF_RANGE
;
5675 /* FIXME -- need 62-bit relocation type */
5676 as_bad (_("62-bit relocation not yet implemented"));
5680 case IA64_OPND_IMMU64
:
5681 if (e
->X_op
== O_symbol
|| e
->X_op
== O_pseudo_fixup
5682 || e
->X_op
== O_subtract
)
5684 fix
= CURR_SLOT
.fixup
+ CURR_SLOT
.num_fixups
;
5685 fix
->code
= BFD_RELOC_IA64_IMM64
;
5686 if (e
->X_op
!= O_subtract
)
5688 fix
->code
= ia64_gen_real_reloc_type (e
->X_op_symbol
, fix
->code
);
5689 if (e
->X_op
== O_pseudo_fixup
)
5693 fix
->opnd
= idesc
->operands
[index
];
5696 ++CURR_SLOT
.num_fixups
;
5697 return OPERAND_MATCH
;
5699 else if (e
->X_op
== O_constant
)
5700 return OPERAND_MATCH
;
5703 case IA64_OPND_CCNT5
:
5704 case IA64_OPND_CNT5
:
5705 case IA64_OPND_CNT6
:
5706 case IA64_OPND_CPOS6a
:
5707 case IA64_OPND_CPOS6b
:
5708 case IA64_OPND_CPOS6c
:
5709 case IA64_OPND_IMMU2
:
5710 case IA64_OPND_IMMU7a
:
5711 case IA64_OPND_IMMU7b
:
5712 case IA64_OPND_IMMU21
:
5713 case IA64_OPND_IMMU24
:
5714 case IA64_OPND_MBTYPE4
:
5715 case IA64_OPND_MHTYPE8
:
5716 case IA64_OPND_POS6
:
5717 bits
= operand_width (idesc
->operands
[index
]);
5718 if (e
->X_op
== O_constant
)
5720 if ((bfd_vma
) e
->X_add_number
< ((bfd_vma
) 1 << bits
))
5721 return OPERAND_MATCH
;
5723 return OPERAND_OUT_OF_RANGE
;
5727 case IA64_OPND_IMMU9
:
5728 bits
= operand_width (idesc
->operands
[index
]);
5729 if (e
->X_op
== O_constant
)
5731 if ((bfd_vma
) e
->X_add_number
< ((bfd_vma
) 1 << bits
))
5733 int lobits
= e
->X_add_number
& 0x3;
5734 if (((bfd_vma
) e
->X_add_number
& 0x3C) != 0 && lobits
== 0)
5735 e
->X_add_number
|= (bfd_vma
) 0x3;
5736 return OPERAND_MATCH
;
5739 return OPERAND_OUT_OF_RANGE
;
5743 case IA64_OPND_IMM44
:
5744 /* least 16 bits must be zero */
5745 if ((e
->X_add_number
& 0xffff) != 0)
5746 /* XXX technically, this is wrong: we should not be issuing warning
5747 messages until we're sure this instruction pattern is going to
5749 as_warn (_("lower 16 bits of mask ignored"));
5751 if (e
->X_op
== O_constant
)
5753 if (((e
->X_add_number
>= 0
5754 && (bfd_vma
) e
->X_add_number
< ((bfd_vma
) 1 << 44))
5755 || (e
->X_add_number
< 0
5756 && (bfd_vma
) -e
->X_add_number
<= ((bfd_vma
) 1 << 44))))
5759 if (e
->X_add_number
>= 0
5760 && (e
->X_add_number
& ((bfd_vma
) 1 << 43)) != 0)
5762 e
->X_add_number
|= ~(((bfd_vma
) 1 << 44) - 1);
5764 return OPERAND_MATCH
;
5767 return OPERAND_OUT_OF_RANGE
;
5771 case IA64_OPND_IMM17
:
5772 /* bit 0 is a don't care (pr0 is hardwired to 1) */
5773 if (e
->X_op
== O_constant
)
5775 if (((e
->X_add_number
>= 0
5776 && (bfd_vma
) e
->X_add_number
< ((bfd_vma
) 1 << 17))
5777 || (e
->X_add_number
< 0
5778 && (bfd_vma
) -e
->X_add_number
<= ((bfd_vma
) 1 << 17))))
5781 if (e
->X_add_number
>= 0
5782 && (e
->X_add_number
& ((bfd_vma
) 1 << 16)) != 0)
5784 e
->X_add_number
|= ~(((bfd_vma
) 1 << 17) - 1);
5786 return OPERAND_MATCH
;
5789 return OPERAND_OUT_OF_RANGE
;
5793 case IA64_OPND_IMM14
:
5794 case IA64_OPND_IMM22
:
5796 case IA64_OPND_IMM1
:
5797 case IA64_OPND_IMM8
:
5798 case IA64_OPND_IMM8U4
:
5799 case IA64_OPND_IMM8M1
:
5800 case IA64_OPND_IMM8M1U4
:
5801 case IA64_OPND_IMM8M1U8
:
5802 case IA64_OPND_IMM9a
:
5803 case IA64_OPND_IMM9b
:
5804 bits
= operand_width (idesc
->operands
[index
]);
5805 if (relocatable
&& (e
->X_op
== O_symbol
5806 || e
->X_op
== O_subtract
5807 || e
->X_op
== O_pseudo_fixup
))
5809 fix
= CURR_SLOT
.fixup
+ CURR_SLOT
.num_fixups
;
5811 if (idesc
->operands
[index
] == IA64_OPND_IMM14
)
5812 fix
->code
= BFD_RELOC_IA64_IMM14
;
5814 fix
->code
= BFD_RELOC_IA64_IMM22
;
5816 if (e
->X_op
!= O_subtract
)
5818 fix
->code
= ia64_gen_real_reloc_type (e
->X_op_symbol
, fix
->code
);
5819 if (e
->X_op
== O_pseudo_fixup
)
5823 fix
->opnd
= idesc
->operands
[index
];
5826 ++CURR_SLOT
.num_fixups
;
5827 return OPERAND_MATCH
;
5829 else if (e
->X_op
!= O_constant
5830 && ! (e
->X_op
== O_big
&& opnd
== IA64_OPND_IMM8M1U8
))
5831 return OPERAND_MISMATCH
;
5833 if (opnd
== IA64_OPND_IMM8M1U4
)
5835 /* Zero is not valid for unsigned compares that take an adjusted
5836 constant immediate range. */
5837 if (e
->X_add_number
== 0)
5838 return OPERAND_OUT_OF_RANGE
;
5840 /* Sign-extend 32-bit unsigned numbers, so that the following range
5841 checks will work. */
5842 val
= e
->X_add_number
;
5843 if (((val
& (~(bfd_vma
) 0 << 32)) == 0)
5844 && ((val
& ((bfd_vma
) 1 << 31)) != 0))
5845 val
= ((val
<< 32) >> 32);
5847 /* Check for 0x100000000. This is valid because
5848 0x100000000-1 is the same as ((uint32_t) -1). */
5849 if (val
== ((bfd_signed_vma
) 1 << 32))
5850 return OPERAND_MATCH
;
5854 else if (opnd
== IA64_OPND_IMM8M1U8
)
5856 /* Zero is not valid for unsigned compares that take an adjusted
5857 constant immediate range. */
5858 if (e
->X_add_number
== 0)
5859 return OPERAND_OUT_OF_RANGE
;
5861 /* Check for 0x10000000000000000. */
5862 if (e
->X_op
== O_big
)
5864 if (generic_bignum
[0] == 0
5865 && generic_bignum
[1] == 0
5866 && generic_bignum
[2] == 0
5867 && generic_bignum
[3] == 0
5868 && generic_bignum
[4] == 1)
5869 return OPERAND_MATCH
;
5871 return OPERAND_OUT_OF_RANGE
;
5874 val
= e
->X_add_number
- 1;
5876 else if (opnd
== IA64_OPND_IMM8M1
)
5877 val
= e
->X_add_number
- 1;
5878 else if (opnd
== IA64_OPND_IMM8U4
)
5880 /* Sign-extend 32-bit unsigned numbers, so that the following range
5881 checks will work. */
5882 val
= e
->X_add_number
;
5883 if (((val
& (~(bfd_vma
) 0 << 32)) == 0)
5884 && ((val
& ((bfd_vma
) 1 << 31)) != 0))
5885 val
= ((val
<< 32) >> 32);
5888 val
= e
->X_add_number
;
5890 if ((val
>= 0 && (bfd_vma
) val
< ((bfd_vma
) 1 << (bits
- 1)))
5891 || (val
< 0 && (bfd_vma
) -val
<= ((bfd_vma
) 1 << (bits
- 1))))
5892 return OPERAND_MATCH
;
5894 return OPERAND_OUT_OF_RANGE
;
5896 case IA64_OPND_INC3
:
5897 /* +/- 1, 4, 8, 16 */
5898 val
= e
->X_add_number
;
5901 if (e
->X_op
== O_constant
)
5903 if ((val
== 1 || val
== 4 || val
== 8 || val
== 16))
5904 return OPERAND_MATCH
;
5906 return OPERAND_OUT_OF_RANGE
;
5910 case IA64_OPND_TGT25
:
5911 case IA64_OPND_TGT25b
:
5912 case IA64_OPND_TGT25c
:
5913 case IA64_OPND_TGT64
:
5914 if (e
->X_op
== O_symbol
)
5916 fix
= CURR_SLOT
.fixup
+ CURR_SLOT
.num_fixups
;
5917 if (opnd
== IA64_OPND_TGT25
)
5918 fix
->code
= BFD_RELOC_IA64_PCREL21F
;
5919 else if (opnd
== IA64_OPND_TGT25b
)
5920 fix
->code
= BFD_RELOC_IA64_PCREL21M
;
5921 else if (opnd
== IA64_OPND_TGT25c
)
5922 fix
->code
= BFD_RELOC_IA64_PCREL21B
;
5923 else if (opnd
== IA64_OPND_TGT64
)
5924 fix
->code
= BFD_RELOC_IA64_PCREL60B
;
5928 fix
->code
= ia64_gen_real_reloc_type (e
->X_op_symbol
, fix
->code
);
5929 fix
->opnd
= idesc
->operands
[index
];
5932 ++CURR_SLOT
.num_fixups
;
5933 return OPERAND_MATCH
;
5935 case IA64_OPND_TAG13
:
5936 case IA64_OPND_TAG13b
:
5940 return OPERAND_MATCH
;
5943 fix
= CURR_SLOT
.fixup
+ CURR_SLOT
.num_fixups
;
5944 /* There are no external relocs for TAG13/TAG13b fields, so we
5945 create a dummy reloc. This will not live past md_apply_fix3. */
5946 fix
->code
= BFD_RELOC_UNUSED
;
5947 fix
->code
= ia64_gen_real_reloc_type (e
->X_op_symbol
, fix
->code
);
5948 fix
->opnd
= idesc
->operands
[index
];
5951 ++CURR_SLOT
.num_fixups
;
5952 return OPERAND_MATCH
;
5959 case IA64_OPND_LDXMOV
:
5960 fix
= CURR_SLOT
.fixup
+ CURR_SLOT
.num_fixups
;
5961 fix
->code
= BFD_RELOC_IA64_LDXMOV
;
5962 fix
->opnd
= idesc
->operands
[index
];
5965 ++CURR_SLOT
.num_fixups
;
5966 return OPERAND_MATCH
;
5971 return OPERAND_MISMATCH
;
5980 memset (e
, 0, sizeof (*e
));
5983 if (*input_line_pointer
!= '}')
5985 sep
= *input_line_pointer
++;
5989 if (!md
.manual_bundling
)
5990 as_warn ("Found '}' when manual bundling is off");
5992 CURR_SLOT
.manual_bundling_off
= 1;
5993 md
.manual_bundling
= 0;
5999 /* Returns the next entry in the opcode table that matches the one in
6000 IDESC, and frees the entry in IDESC. If no matching entry is
6001 found, NULL is returned instead. */
6003 static struct ia64_opcode
*
6004 get_next_opcode (struct ia64_opcode
*idesc
)
6006 struct ia64_opcode
*next
= ia64_find_next_opcode (idesc
);
6007 ia64_free_opcode (idesc
);
6011 /* Parse the operands for the opcode and find the opcode variant that
6012 matches the specified operands, or NULL if no match is possible. */
6014 static struct ia64_opcode
*
6015 parse_operands (idesc
)
6016 struct ia64_opcode
*idesc
;
6018 int i
= 0, highest_unmatched_operand
, num_operands
= 0, num_outputs
= 0;
6019 int error_pos
, out_of_range_pos
, curr_out_of_range_pos
, sep
= 0;
6022 enum ia64_opnd expected_operand
= IA64_OPND_NIL
;
6023 enum operand_match_result result
;
6025 char *first_arg
= 0, *end
, *saved_input_pointer
;
6028 assert (strlen (idesc
->name
) <= 128);
6030 strcpy (mnemonic
, idesc
->name
);
6031 if (idesc
->operands
[2] == IA64_OPND_SOF
6032 || idesc
->operands
[1] == IA64_OPND_SOF
)
6034 /* To make the common idiom "alloc loc?=ar.pfs,0,1,0,0" work, we
6035 can't parse the first operand until we have parsed the
6036 remaining operands of the "alloc" instruction. */
6038 first_arg
= input_line_pointer
;
6039 end
= strchr (input_line_pointer
, '=');
6042 as_bad ("Expected separator `='");
6045 input_line_pointer
= end
+ 1;
6052 if (i
< NELEMS (CURR_SLOT
.opnd
))
6054 sep
= parse_operand (CURR_SLOT
.opnd
+ i
);
6055 if (CURR_SLOT
.opnd
[i
].X_op
== O_absent
)
6062 sep
= parse_operand (&dummy
);
6063 if (dummy
.X_op
== O_absent
)
6069 if (sep
!= '=' && sep
!= ',')
6074 if (num_outputs
> 0)
6075 as_bad ("Duplicate equal sign (=) in instruction");
6077 num_outputs
= i
+ 1;
6082 as_bad ("Illegal operand separator `%c'", sep
);
6086 if (idesc
->operands
[2] == IA64_OPND_SOF
6087 || idesc
->operands
[1] == IA64_OPND_SOF
)
6089 /* map alloc r1=ar.pfs,i,l,o,r to alloc r1=ar.pfs,(i+l+o),(i+l),r */
6090 know (strcmp (idesc
->name
, "alloc") == 0);
6091 i
= (CURR_SLOT
.opnd
[1].X_op
== O_register
6092 && CURR_SLOT
.opnd
[1].X_add_number
== REG_AR
+ AR_PFS
) ? 2 : 1;
6093 if (num_operands
== i
+ 3 /* first_arg not included in this count! */
6094 && CURR_SLOT
.opnd
[i
].X_op
== O_constant
6095 && CURR_SLOT
.opnd
[i
+ 1].X_op
== O_constant
6096 && CURR_SLOT
.opnd
[i
+ 2].X_op
== O_constant
6097 && CURR_SLOT
.opnd
[i
+ 3].X_op
== O_constant
)
6099 sof
= set_regstack (CURR_SLOT
.opnd
[i
].X_add_number
,
6100 CURR_SLOT
.opnd
[i
+ 1].X_add_number
,
6101 CURR_SLOT
.opnd
[i
+ 2].X_add_number
,
6102 CURR_SLOT
.opnd
[i
+ 3].X_add_number
);
6104 /* now we can parse the first arg: */
6105 saved_input_pointer
= input_line_pointer
;
6106 input_line_pointer
= first_arg
;
6107 sep
= parse_operand (CURR_SLOT
.opnd
+ 0);
6109 --num_outputs
; /* force error */
6110 input_line_pointer
= saved_input_pointer
;
6112 CURR_SLOT
.opnd
[i
].X_add_number
= sof
;
6113 CURR_SLOT
.opnd
[i
+ 1].X_add_number
6114 = sof
- CURR_SLOT
.opnd
[i
+ 2].X_add_number
;
6115 CURR_SLOT
.opnd
[i
+ 2] = CURR_SLOT
.opnd
[i
+ 3];
6119 highest_unmatched_operand
= -4;
6120 curr_out_of_range_pos
= -1;
6122 for (; idesc
; idesc
= get_next_opcode (idesc
))
6124 if (num_outputs
!= idesc
->num_outputs
)
6125 continue; /* mismatch in # of outputs */
6126 if (highest_unmatched_operand
< 0)
6127 highest_unmatched_operand
|= 1;
6128 if (num_operands
> NELEMS (idesc
->operands
)
6129 || (num_operands
< NELEMS (idesc
->operands
)
6130 && idesc
->operands
[num_operands
])
6131 || (num_operands
> 0 && !idesc
->operands
[num_operands
- 1]))
6132 continue; /* mismatch in number of arguments */
6133 if (highest_unmatched_operand
< 0)
6134 highest_unmatched_operand
|= 2;
6136 CURR_SLOT
.num_fixups
= 0;
6138 /* Try to match all operands. If we see an out-of-range operand,
6139 then continue trying to match the rest of the operands, since if
6140 the rest match, then this idesc will give the best error message. */
6142 out_of_range_pos
= -1;
6143 for (i
= 0; i
< num_operands
&& idesc
->operands
[i
]; ++i
)
6145 result
= operand_match (idesc
, i
, CURR_SLOT
.opnd
+ i
);
6146 if (result
!= OPERAND_MATCH
)
6148 if (result
!= OPERAND_OUT_OF_RANGE
)
6150 if (out_of_range_pos
< 0)
6151 /* remember position of the first out-of-range operand: */
6152 out_of_range_pos
= i
;
6156 /* If we did not match all operands, or if at least one operand was
6157 out-of-range, then this idesc does not match. Keep track of which
6158 idesc matched the most operands before failing. If we have two
6159 idescs that failed at the same position, and one had an out-of-range
6160 operand, then prefer the out-of-range operand. Thus if we have
6161 "add r0=0x1000000,r1" we get an error saying the constant is out
6162 of range instead of an error saying that the constant should have been
6165 if (i
!= num_operands
|| out_of_range_pos
>= 0)
6167 if (i
> highest_unmatched_operand
6168 || (i
== highest_unmatched_operand
6169 && out_of_range_pos
> curr_out_of_range_pos
))
6171 highest_unmatched_operand
= i
;
6172 if (out_of_range_pos
>= 0)
6174 expected_operand
= idesc
->operands
[out_of_range_pos
];
6175 error_pos
= out_of_range_pos
;
6179 expected_operand
= idesc
->operands
[i
];
6182 curr_out_of_range_pos
= out_of_range_pos
;
6191 if (expected_operand
)
6192 as_bad ("Operand %u of `%s' should be %s",
6193 error_pos
+ 1, mnemonic
,
6194 elf64_ia64_operands
[expected_operand
].desc
);
6195 else if (highest_unmatched_operand
< 0 && !(highest_unmatched_operand
& 1))
6196 as_bad ("Wrong number of output operands");
6197 else if (highest_unmatched_operand
< 0 && !(highest_unmatched_operand
& 2))
6198 as_bad ("Wrong number of input operands");
6200 as_bad ("Operand mismatch");
6204 /* Check that the instruction doesn't use
6205 - r0, f0, or f1 as output operands
6206 - the same predicate twice as output operands
6207 - r0 as address of a base update load or store
6208 - the same GR as output and address of a base update load
6209 - two even- or two odd-numbered FRs as output operands of a floating
6210 point parallel load.
6211 At most two (conflicting) output (or output-like) operands can exist,
6212 (floating point parallel loads have three outputs, but the base register,
6213 if updated, cannot conflict with the actual outputs). */
6215 for (i
= 0; i
< num_operands
; ++i
)
6220 switch (idesc
->operands
[i
])
6225 if (i
< num_outputs
)
6227 if (CURR_SLOT
.opnd
[i
].X_add_number
== REG_GR
)
6230 reg1
= CURR_SLOT
.opnd
[i
].X_add_number
;
6232 reg2
= CURR_SLOT
.opnd
[i
].X_add_number
;
6237 if (i
< num_outputs
)
6240 reg1
= CURR_SLOT
.opnd
[i
].X_add_number
;
6242 reg2
= CURR_SLOT
.opnd
[i
].X_add_number
;
6249 if (i
< num_outputs
)
6251 if (CURR_SLOT
.opnd
[i
].X_add_number
>= REG_FR
6252 && CURR_SLOT
.opnd
[i
].X_add_number
<= REG_FR
+ 1)
6255 regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_FR
;
6258 reg1
= CURR_SLOT
.opnd
[i
].X_add_number
;
6260 reg2
= CURR_SLOT
.opnd
[i
].X_add_number
;
6264 if (idesc
->flags
& IA64_OPCODE_POSTINC
)
6266 if (CURR_SLOT
.opnd
[i
].X_add_number
== REG_GR
)
6269 reg1
= CURR_SLOT
.opnd
[i
].X_add_number
;
6271 reg2
= CURR_SLOT
.opnd
[i
].X_add_number
;
6282 as_warn ("Invalid use of `%c%d' as output operand", reg_class
, regno
);
6285 as_warn ("Invalid use of `r%d' as base update address operand", regno
);
6291 if (reg1
>= REG_GR
&& reg1
<= REG_GR
+ 127)
6296 else if (reg1
>= REG_P
&& reg1
<= REG_P
+ 63)
6301 else if (reg1
>= REG_FR
&& reg1
<= REG_FR
+ 127)
6309 as_warn ("Invalid duplicate use of `%c%d'", reg_class
, reg1
);
6311 else if (((reg1
>= REG_FR
&& reg1
<= REG_FR
+ 31
6312 && reg2
>= REG_FR
&& reg2
<= REG_FR
+ 31)
6313 || (reg1
>= REG_FR
+ 32 && reg1
<= REG_FR
+ 127
6314 && reg2
>= REG_FR
+ 32 && reg2
<= REG_FR
+ 127))
6315 && ! ((reg1
^ reg2
) & 1))
6316 as_warn ("Invalid simultaneous use of `f%d' and `f%d'",
6317 reg1
- REG_FR
, reg2
- REG_FR
);
6318 else if ((reg1
>= REG_FR
&& reg1
<= REG_FR
+ 31
6319 && reg2
>= REG_FR
+ 32 && reg2
<= REG_FR
+ 127)
6320 || (reg1
>= REG_FR
+ 32 && reg1
<= REG_FR
+ 127
6321 && reg2
>= REG_FR
&& reg2
<= REG_FR
+ 31))
6322 as_warn ("Dangerous simultaneous use of `f%d' and `f%d'",
6323 reg1
- REG_FR
, reg2
- REG_FR
);
6328 build_insn (slot
, insnp
)
6332 const struct ia64_operand
*odesc
, *o2desc
;
6333 struct ia64_opcode
*idesc
= slot
->idesc
;
6339 insn
= idesc
->opcode
| slot
->qp_regno
;
6341 for (i
= 0; i
< NELEMS (idesc
->operands
) && idesc
->operands
[i
]; ++i
)
6343 if (slot
->opnd
[i
].X_op
== O_register
6344 || slot
->opnd
[i
].X_op
== O_constant
6345 || slot
->opnd
[i
].X_op
== O_index
)
6346 val
= slot
->opnd
[i
].X_add_number
;
6347 else if (slot
->opnd
[i
].X_op
== O_big
)
6349 /* This must be the value 0x10000000000000000. */
6350 assert (idesc
->operands
[i
] == IA64_OPND_IMM8M1U8
);
6356 switch (idesc
->operands
[i
])
6358 case IA64_OPND_IMMU64
:
6359 *insnp
++ = (val
>> 22) & 0x1ffffffffffLL
;
6360 insn
|= (((val
& 0x7f) << 13) | (((val
>> 7) & 0x1ff) << 27)
6361 | (((val
>> 16) & 0x1f) << 22) | (((val
>> 21) & 0x1) << 21)
6362 | (((val
>> 63) & 0x1) << 36));
6365 case IA64_OPND_IMMU62
:
6366 val
&= 0x3fffffffffffffffULL
;
6367 if (val
!= slot
->opnd
[i
].X_add_number
)
6368 as_warn (_("Value truncated to 62 bits"));
6369 *insnp
++ = (val
>> 21) & 0x1ffffffffffLL
;
6370 insn
|= (((val
& 0xfffff) << 6) | (((val
>> 20) & 0x1) << 36));
6373 case IA64_OPND_TGT64
:
6375 *insnp
++ = ((val
>> 20) & 0x7fffffffffLL
) << 2;
6376 insn
|= ((((val
>> 59) & 0x1) << 36)
6377 | (((val
>> 0) & 0xfffff) << 13));
6408 case IA64_OPND_R3_2
:
6409 case IA64_OPND_CPUID_R3
:
6410 case IA64_OPND_DBR_R3
:
6411 case IA64_OPND_DTR_R3
:
6412 case IA64_OPND_ITR_R3
:
6413 case IA64_OPND_IBR_R3
:
6415 case IA64_OPND_MSR_R3
:
6416 case IA64_OPND_PKR_R3
:
6417 case IA64_OPND_PMC_R3
:
6418 case IA64_OPND_PMD_R3
:
6419 case IA64_OPND_RR_R3
:
6427 odesc
= elf64_ia64_operands
+ idesc
->operands
[i
];
6428 err
= (*odesc
->insert
) (odesc
, val
, &insn
);
6430 as_bad_where (slot
->src_file
, slot
->src_line
,
6431 "Bad operand value: %s", err
);
6432 if (idesc
->flags
& IA64_OPCODE_PSEUDO
)
6434 if ((idesc
->flags
& IA64_OPCODE_F2_EQ_F3
)
6435 && odesc
== elf64_ia64_operands
+ IA64_OPND_F3
)
6437 o2desc
= elf64_ia64_operands
+ IA64_OPND_F2
;
6438 (*o2desc
->insert
) (o2desc
, val
, &insn
);
6440 if ((idesc
->flags
& IA64_OPCODE_LEN_EQ_64MCNT
)
6441 && (odesc
== elf64_ia64_operands
+ IA64_OPND_CPOS6a
6442 || odesc
== elf64_ia64_operands
+ IA64_OPND_POS6
))
6444 o2desc
= elf64_ia64_operands
+ IA64_OPND_LEN6
;
6445 (*o2desc
->insert
) (o2desc
, 64 - val
, &insn
);
6455 int manual_bundling_off
= 0, manual_bundling
= 0;
6456 enum ia64_unit required_unit
, insn_unit
= 0;
6457 enum ia64_insn_type type
[3], insn_type
;
6458 unsigned int template, orig_template
;
6459 bfd_vma insn
[3] = { -1, -1, -1 };
6460 struct ia64_opcode
*idesc
;
6461 int end_of_insn_group
= 0, user_template
= -1;
6462 int n
, i
, j
, first
, curr
;
6463 unw_rec_list
*ptr
, *last_ptr
, *end_ptr
;
6464 bfd_vma t0
= 0, t1
= 0;
6465 struct label_fix
*lfix
;
6466 struct insn_fix
*ifix
;
6472 first
= (md
.curr_slot
+ NUM_SLOTS
- md
.num_slots_in_use
) % NUM_SLOTS
;
6473 know (first
>= 0 & first
< NUM_SLOTS
);
6474 n
= MIN (3, md
.num_slots_in_use
);
6476 /* Determine template: user user_template if specified, best match
6479 if (md
.slot
[first
].user_template
>= 0)
6480 user_template
= template = md
.slot
[first
].user_template
;
6483 /* Auto select appropriate template. */
6484 memset (type
, 0, sizeof (type
));
6486 for (i
= 0; i
< n
; ++i
)
6488 if (md
.slot
[curr
].label_fixups
&& i
!= 0)
6490 type
[i
] = md
.slot
[curr
].idesc
->type
;
6491 curr
= (curr
+ 1) % NUM_SLOTS
;
6493 template = best_template
[type
[0]][type
[1]][type
[2]];
6496 /* initialize instructions with appropriate nops: */
6497 for (i
= 0; i
< 3; ++i
)
6498 insn
[i
] = nop
[ia64_templ_desc
[template].exec_unit
[i
]];
6502 /* Check to see if this bundle is at an offset that is a multiple of 16-bytes
6503 from the start of the frag. */
6504 addr_mod
= frag_now_fix () & 15;
6505 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
6506 as_bad (_("instruction address is not a multiple of 16"));
6507 frag_now
->insn_addr
= addr_mod
;
6508 frag_now
->has_code
= 1;
6510 /* now fill in slots with as many insns as possible: */
6512 idesc
= md
.slot
[curr
].idesc
;
6513 end_of_insn_group
= 0;
6514 for (i
= 0; i
< 3 && md
.num_slots_in_use
> 0; ++i
)
6516 /* If we have unwind records, we may need to update some now. */
6517 ptr
= md
.slot
[curr
].unwind_record
;
6520 /* Find the last prologue/body record in the list for the current
6521 insn, and set the slot number for all records up to that point.
6522 This needs to be done now, because prologue/body records refer to
6523 the current point, not the point after the instruction has been
6524 issued. This matters because there may have been nops emitted
6525 meanwhile. Any non-prologue non-body record followed by a
6526 prologue/body record must also refer to the current point. */
6528 end_ptr
= md
.slot
[(curr
+ 1) % NUM_SLOTS
].unwind_record
;
6529 for (; ptr
!= end_ptr
; ptr
= ptr
->next
)
6530 if (ptr
->r
.type
== prologue
|| ptr
->r
.type
== prologue_gr
6531 || ptr
->r
.type
== body
)
6535 /* Make last_ptr point one after the last prologue/body
6537 last_ptr
= last_ptr
->next
;
6538 for (ptr
= md
.slot
[curr
].unwind_record
; ptr
!= last_ptr
;
6541 ptr
->slot_number
= (unsigned long) f
+ i
;
6542 ptr
->slot_frag
= frag_now
;
6544 /* Remove the initialized records, so that we won't accidentally
6545 update them again if we insert a nop and continue. */
6546 md
.slot
[curr
].unwind_record
= last_ptr
;
6550 manual_bundling_off
= md
.slot
[curr
].manual_bundling_off
;
6551 if (md
.slot
[curr
].manual_bundling_on
)
6554 manual_bundling
= 1;
6556 break; /* Need to start a new bundle. */
6559 /* If this instruction specifies a template, then it must be the first
6560 instruction of a bundle. */
6561 if (curr
!= first
&& md
.slot
[curr
].user_template
>= 0)
6564 if (idesc
->flags
& IA64_OPCODE_SLOT2
)
6566 if (manual_bundling
&& !manual_bundling_off
)
6568 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6569 "`%s' must be last in bundle", idesc
->name
);
6571 manual_bundling
= -1; /* Suppress meaningless post-loop errors. */
6575 if (idesc
->flags
& IA64_OPCODE_LAST
)
6578 unsigned int required_template
;
6580 /* If we need a stop bit after an M slot, our only choice is
6581 template 5 (M;;MI). If we need a stop bit after a B
6582 slot, our only choice is to place it at the end of the
6583 bundle, because the only available templates are MIB,
6584 MBB, BBB, MMB, and MFB. We don't handle anything other
6585 than M and B slots because these are the only kind of
6586 instructions that can have the IA64_OPCODE_LAST bit set. */
6587 required_template
= template;
6588 switch (idesc
->type
)
6592 required_template
= 5;
6600 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6601 "Internal error: don't know how to force %s to end"
6602 "of instruction group", idesc
->name
);
6607 && (i
> required_slot
6608 || (required_slot
== 2 && !manual_bundling_off
)
6609 || (user_template
>= 0
6610 /* Changing from MMI to M;MI is OK. */
6611 && (template ^ required_template
) > 1)))
6613 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6614 "`%s' must be last in instruction group",
6616 if (i
< 2 && required_slot
== 2 && !manual_bundling_off
)
6617 manual_bundling
= -1; /* Suppress meaningless post-loop errors. */
6619 if (required_slot
< i
)
6620 /* Can't fit this instruction. */
6624 if (required_template
!= template)
6626 /* If we switch the template, we need to reset the NOPs
6627 after slot i. The slot-types of the instructions ahead
6628 of i never change, so we don't need to worry about
6629 changing NOPs in front of this slot. */
6630 for (j
= i
; j
< 3; ++j
)
6631 insn
[j
] = nop
[ia64_templ_desc
[required_template
].exec_unit
[j
]];
6633 template = required_template
;
6635 if (curr
!= first
&& md
.slot
[curr
].label_fixups
)
6637 if (manual_bundling
)
6639 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6640 "Label must be first in a bundle");
6641 manual_bundling
= -1; /* Suppress meaningless post-loop errors. */
6643 /* This insn must go into the first slot of a bundle. */
6647 if (end_of_insn_group
&& md
.num_slots_in_use
>= 1)
6649 /* We need an instruction group boundary in the middle of a
6650 bundle. See if we can switch to an other template with
6651 an appropriate boundary. */
6653 orig_template
= template;
6654 if (i
== 1 && (user_template
== 4
6655 || (user_template
< 0
6656 && (ia64_templ_desc
[template].exec_unit
[0]
6660 end_of_insn_group
= 0;
6662 else if (i
== 2 && (user_template
== 0
6663 || (user_template
< 0
6664 && (ia64_templ_desc
[template].exec_unit
[1]
6666 /* This test makes sure we don't switch the template if
6667 the next instruction is one that needs to be first in
6668 an instruction group. Since all those instructions are
6669 in the M group, there is no way such an instruction can
6670 fit in this bundle even if we switch the template. The
6671 reason we have to check for this is that otherwise we
6672 may end up generating "MI;;I M.." which has the deadly
6673 effect that the second M instruction is no longer the
6674 first in the group! --davidm 99/12/16 */
6675 && (idesc
->flags
& IA64_OPCODE_FIRST
) == 0)
6678 end_of_insn_group
= 0;
6681 && user_template
== 0
6682 && !(idesc
->flags
& IA64_OPCODE_FIRST
))
6683 /* Use the next slot. */
6685 else if (curr
!= first
)
6686 /* can't fit this insn */
6689 if (template != orig_template
)
6690 /* if we switch the template, we need to reset the NOPs
6691 after slot i. The slot-types of the instructions ahead
6692 of i never change, so we don't need to worry about
6693 changing NOPs in front of this slot. */
6694 for (j
= i
; j
< 3; ++j
)
6695 insn
[j
] = nop
[ia64_templ_desc
[template].exec_unit
[j
]];
6697 required_unit
= ia64_templ_desc
[template].exec_unit
[i
];
6699 /* resolve dynamic opcodes such as "break", "hint", and "nop": */
6700 if (idesc
->type
== IA64_TYPE_DYN
)
6702 enum ia64_opnd opnd1
, opnd2
;
6704 if ((strcmp (idesc
->name
, "nop") == 0)
6705 || (strcmp (idesc
->name
, "break") == 0))
6706 insn_unit
= required_unit
;
6707 else if (strcmp (idesc
->name
, "hint") == 0)
6709 insn_unit
= required_unit
;
6710 if (required_unit
== IA64_UNIT_B
)
6716 case hint_b_warning
:
6717 as_warn ("hint in B unit may be treated as nop");
6720 /* When manual bundling is off and there is no
6721 user template, we choose a different unit so
6722 that hint won't go into the current slot. We
6723 will fill the current bundle with nops and
6724 try to put hint into the next bundle. */
6725 if (!manual_bundling
&& user_template
< 0)
6726 insn_unit
= IA64_UNIT_I
;
6728 as_bad ("hint in B unit can't be used");
6733 else if (strcmp (idesc
->name
, "chk.s") == 0
6734 || strcmp (idesc
->name
, "mov") == 0)
6736 insn_unit
= IA64_UNIT_M
;
6737 if (required_unit
== IA64_UNIT_I
6738 || (required_unit
== IA64_UNIT_F
&& template == 6))
6739 insn_unit
= IA64_UNIT_I
;
6742 as_fatal ("emit_one_bundle: unexpected dynamic op");
6744 sprintf (mnemonic
, "%s.%c", idesc
->name
, "?imbfxx"[insn_unit
]);
6745 opnd1
= idesc
->operands
[0];
6746 opnd2
= idesc
->operands
[1];
6747 ia64_free_opcode (idesc
);
6748 idesc
= ia64_find_opcode (mnemonic
);
6749 /* moves to/from ARs have collisions */
6750 if (opnd1
== IA64_OPND_AR3
|| opnd2
== IA64_OPND_AR3
)
6752 while (idesc
!= NULL
6753 && (idesc
->operands
[0] != opnd1
6754 || idesc
->operands
[1] != opnd2
))
6755 idesc
= get_next_opcode (idesc
);
6757 md
.slot
[curr
].idesc
= idesc
;
6761 insn_type
= idesc
->type
;
6762 insn_unit
= IA64_UNIT_NIL
;
6766 if (required_unit
== IA64_UNIT_I
|| required_unit
== IA64_UNIT_M
)
6767 insn_unit
= required_unit
;
6769 case IA64_TYPE_X
: insn_unit
= IA64_UNIT_L
; break;
6770 case IA64_TYPE_I
: insn_unit
= IA64_UNIT_I
; break;
6771 case IA64_TYPE_M
: insn_unit
= IA64_UNIT_M
; break;
6772 case IA64_TYPE_B
: insn_unit
= IA64_UNIT_B
; break;
6773 case IA64_TYPE_F
: insn_unit
= IA64_UNIT_F
; break;
6778 if (insn_unit
!= required_unit
)
6780 if (required_unit
== IA64_UNIT_L
6781 && insn_unit
== IA64_UNIT_I
6782 && !(idesc
->flags
& IA64_OPCODE_X_IN_MLX
))
6784 /* we got ourselves an MLX template but the current
6785 instruction isn't an X-unit, or an I-unit instruction
6786 that can go into the X slot of an MLX template. Duh. */
6787 if (md
.num_slots_in_use
>= NUM_SLOTS
)
6789 as_bad_where (md
.slot
[curr
].src_file
,
6790 md
.slot
[curr
].src_line
,
6791 "`%s' can't go in X slot of "
6792 "MLX template", idesc
->name
);
6793 /* drop this insn so we don't livelock: */
6794 --md
.num_slots_in_use
;
6798 continue; /* try next slot */
6801 if (debug_type
== DEBUG_DWARF2
|| md
.slot
[curr
].loc_directive_seen
)
6803 bfd_vma addr
= frag_now
->fr_address
+ frag_now_fix () - 16 + i
;
6805 md
.slot
[curr
].loc_directive_seen
= 0;
6806 dwarf2_gen_line_info (addr
, &md
.slot
[curr
].debug_line
);
6809 build_insn (md
.slot
+ curr
, insn
+ i
);
6811 ptr
= md
.slot
[curr
].unwind_record
;
6814 /* Set slot numbers for all remaining unwind records belonging to the
6815 current insn. There can not be any prologue/body unwind records
6817 end_ptr
= md
.slot
[(curr
+ 1) % NUM_SLOTS
].unwind_record
;
6818 for (; ptr
!= end_ptr
; ptr
= ptr
->next
)
6820 ptr
->slot_number
= (unsigned long) f
+ i
;
6821 ptr
->slot_frag
= frag_now
;
6823 md
.slot
[curr
].unwind_record
= NULL
;
6826 if (required_unit
== IA64_UNIT_L
)
6829 /* skip one slot for long/X-unit instructions */
6832 --md
.num_slots_in_use
;
6834 /* now is a good time to fix up the labels for this insn: */
6835 for (lfix
= md
.slot
[curr
].label_fixups
; lfix
; lfix
= lfix
->next
)
6837 S_SET_VALUE (lfix
->sym
, frag_now_fix () - 16);
6838 symbol_set_frag (lfix
->sym
, frag_now
);
6840 /* and fix up the tags also. */
6841 for (lfix
= md
.slot
[curr
].tag_fixups
; lfix
; lfix
= lfix
->next
)
6843 S_SET_VALUE (lfix
->sym
, frag_now_fix () - 16 + i
);
6844 symbol_set_frag (lfix
->sym
, frag_now
);
6847 for (j
= 0; j
< md
.slot
[curr
].num_fixups
; ++j
)
6849 ifix
= md
.slot
[curr
].fixup
+ j
;
6850 fix
= fix_new_exp (frag_now
, frag_now_fix () - 16 + i
, 8,
6851 &ifix
->expr
, ifix
->is_pcrel
, ifix
->code
);
6852 fix
->tc_fix_data
.opnd
= ifix
->opnd
;
6853 fix
->fx_plt
= (fix
->fx_r_type
== BFD_RELOC_IA64_PLTOFF22
);
6854 fix
->fx_file
= md
.slot
[curr
].src_file
;
6855 fix
->fx_line
= md
.slot
[curr
].src_line
;
6858 end_of_insn_group
= md
.slot
[curr
].end_of_insn_group
;
6861 ia64_free_opcode (md
.slot
[curr
].idesc
);
6862 memset (md
.slot
+ curr
, 0, sizeof (md
.slot
[curr
]));
6863 md
.slot
[curr
].user_template
= -1;
6865 if (manual_bundling_off
)
6867 manual_bundling
= 0;
6870 curr
= (curr
+ 1) % NUM_SLOTS
;
6871 idesc
= md
.slot
[curr
].idesc
;
6873 if (manual_bundling
> 0)
6875 if (md
.num_slots_in_use
> 0)
6877 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6878 "`%s' does not fit into %s template",
6879 idesc
->name
, ia64_templ_desc
[template].name
);
6880 --md
.num_slots_in_use
;
6883 as_bad_where (md
.slot
[curr
].src_file
, md
.slot
[curr
].src_line
,
6884 "Missing '}' at end of file");
6886 know (md
.num_slots_in_use
< NUM_SLOTS
);
6888 t0
= end_of_insn_group
| (template << 1) | (insn
[0] << 5) | (insn
[1] << 46);
6889 t1
= ((insn
[1] >> 18) & 0x7fffff) | (insn
[2] << 23);
6891 number_to_chars_littleendian (f
+ 0, t0
, 8);
6892 number_to_chars_littleendian (f
+ 8, t1
, 8);
6896 unwind
.list
->next_slot_number
= (unsigned long) f
+ 16;
6897 unwind
.list
->next_slot_frag
= frag_now
;
6902 md_parse_option (c
, arg
)
6909 /* Switches from the Intel assembler. */
6911 if (strcmp (arg
, "ilp64") == 0
6912 || strcmp (arg
, "lp64") == 0
6913 || strcmp (arg
, "p64") == 0)
6915 md
.flags
|= EF_IA_64_ABI64
;
6917 else if (strcmp (arg
, "ilp32") == 0)
6919 md
.flags
&= ~EF_IA_64_ABI64
;
6921 else if (strcmp (arg
, "le") == 0)
6923 md
.flags
&= ~EF_IA_64_BE
;
6924 default_big_endian
= 0;
6926 else if (strcmp (arg
, "be") == 0)
6928 md
.flags
|= EF_IA_64_BE
;
6929 default_big_endian
= 1;
6931 else if (strncmp (arg
, "unwind-check=", 13) == 0)
6934 if (strcmp (arg
, "warning") == 0)
6935 md
.unwind_check
= unwind_check_warning
;
6936 else if (strcmp (arg
, "error") == 0)
6937 md
.unwind_check
= unwind_check_error
;
6941 else if (strncmp (arg
, "hint.b=", 7) == 0)
6944 if (strcmp (arg
, "ok") == 0)
6945 md
.hint_b
= hint_b_ok
;
6946 else if (strcmp (arg
, "warning") == 0)
6947 md
.hint_b
= hint_b_warning
;
6948 else if (strcmp (arg
, "error") == 0)
6949 md
.hint_b
= hint_b_error
;
6958 if (strcmp (arg
, "so") == 0)
6960 /* Suppress signon message. */
6962 else if (strcmp (arg
, "pi") == 0)
6964 /* Reject privileged instructions. FIXME */
6966 else if (strcmp (arg
, "us") == 0)
6968 /* Allow union of signed and unsigned range. FIXME */
6970 else if (strcmp (arg
, "close_fcalls") == 0)
6972 /* Do not resolve global function calls. */
6979 /* temp[="prefix"] Insert temporary labels into the object file
6980 symbol table prefixed by "prefix".
6981 Default prefix is ":temp:".
6986 /* indirect=<tgt> Assume unannotated indirect branches behavior
6987 according to <tgt> --
6988 exit: branch out from the current context (default)
6989 labels: all labels in context may be branch targets
6991 if (strncmp (arg
, "indirect=", 9) != 0)
6996 /* -X conflicts with an ignored option, use -x instead */
6998 if (!arg
|| strcmp (arg
, "explicit") == 0)
7000 /* set default mode to explicit */
7001 md
.default_explicit_mode
= 1;
7004 else if (strcmp (arg
, "auto") == 0)
7006 md
.default_explicit_mode
= 0;
7008 else if (strcmp (arg
, "none") == 0)
7012 else if (strcmp (arg
, "debug") == 0)
7016 else if (strcmp (arg
, "debugx") == 0)
7018 md
.default_explicit_mode
= 1;
7021 else if (strcmp (arg
, "debugn") == 0)
7028 as_bad (_("Unrecognized option '-x%s'"), arg
);
7033 /* nops Print nops statistics. */
7036 /* GNU specific switches for gcc. */
7037 case OPTION_MCONSTANT_GP
:
7038 md
.flags
|= EF_IA_64_CONS_GP
;
7041 case OPTION_MAUTO_PIC
:
7042 md
.flags
|= EF_IA_64_NOFUNCDESC_CONS_GP
;
7053 md_show_usage (stream
)
7058 --mconstant-gp mark output file as using the constant-GP model\n\
7059 (sets ELF header flag EF_IA_64_CONS_GP)\n\
7060 --mauto-pic mark output file as using the constant-GP model\n\
7061 without function descriptors (sets ELF header flag\n\
7062 EF_IA_64_NOFUNCDESC_CONS_GP)\n\
7063 -milp32|-milp64|-mlp64|-mp64 select data model (default -mlp64)\n\
7064 -mle | -mbe select little- or big-endian byte order (default -mle)\n\
7065 -munwind-check=[warning|error]\n\
7066 unwind directive check (default -munwind-check=warning)\n\
7067 -mhint.b=[ok|warning|error]\n\
7068 hint.b check (default -mhint.b=error)\n\
7069 -x | -xexplicit turn on dependency violation checking\n\
7070 -xauto automagically remove dependency violations (default)\n\
7071 -xnone turn off dependency violation checking\n\
7072 -xdebug debug dependency violation checker\n\
7073 -xdebugn debug dependency violation checker but turn off\n\
7074 dependency violation checking\n\
7075 -xdebugx debug dependency violation checker and turn on\n\
7076 dependency violation checking\n"),
7081 ia64_after_parse_args ()
7083 if (debug_type
== DEBUG_STABS
)
7084 as_fatal (_("--gstabs is not supported for ia64"));
7087 /* Return true if TYPE fits in TEMPL at SLOT. */
7090 match (int templ
, int type
, int slot
)
7092 enum ia64_unit unit
;
7095 unit
= ia64_templ_desc
[templ
].exec_unit
[slot
];
7098 case IA64_TYPE_DYN
: result
= 1; break; /* for nop and break */
7100 result
= (unit
== IA64_UNIT_I
|| unit
== IA64_UNIT_M
);
7102 case IA64_TYPE_X
: result
= (unit
== IA64_UNIT_L
); break;
7103 case IA64_TYPE_I
: result
= (unit
== IA64_UNIT_I
); break;
7104 case IA64_TYPE_M
: result
= (unit
== IA64_UNIT_M
); break;
7105 case IA64_TYPE_B
: result
= (unit
== IA64_UNIT_B
); break;
7106 case IA64_TYPE_F
: result
= (unit
== IA64_UNIT_F
); break;
7107 default: result
= 0; break;
7112 /* Add a bit of extra goodness if a nop of type F or B would fit
7113 in TEMPL at SLOT. */
7116 extra_goodness (int templ
, int slot
)
7118 if (slot
== 1 && match (templ
, IA64_TYPE_F
, slot
))
7120 if (slot
== 2 && match (templ
, IA64_TYPE_B
, slot
))
7125 /* This function is called once, at assembler startup time. It sets
7126 up all the tables, etc. that the MD part of the assembler will need
7127 that can be determined before arguments are parsed. */
7131 int i
, j
, k
, t
, total
, ar_base
, cr_base
, goodness
, best
, regnum
, ok
;
7136 md
.explicit_mode
= md
.default_explicit_mode
;
7138 bfd_set_section_alignment (stdoutput
, text_section
, 4);
7140 /* Make sure function pointers get initialized. */
7141 target_big_endian
= -1;
7142 dot_byteorder (default_big_endian
);
7144 alias_hash
= hash_new ();
7145 alias_name_hash
= hash_new ();
7146 secalias_hash
= hash_new ();
7147 secalias_name_hash
= hash_new ();
7149 pseudo_func
[FUNC_DTP_MODULE
].u
.sym
=
7150 symbol_new (".<dtpmod>", undefined_section
, FUNC_DTP_MODULE
,
7151 &zero_address_frag
);
7153 pseudo_func
[FUNC_DTP_RELATIVE
].u
.sym
=
7154 symbol_new (".<dtprel>", undefined_section
, FUNC_DTP_RELATIVE
,
7155 &zero_address_frag
);
7157 pseudo_func
[FUNC_FPTR_RELATIVE
].u
.sym
=
7158 symbol_new (".<fptr>", undefined_section
, FUNC_FPTR_RELATIVE
,
7159 &zero_address_frag
);
7161 pseudo_func
[FUNC_GP_RELATIVE
].u
.sym
=
7162 symbol_new (".<gprel>", undefined_section
, FUNC_GP_RELATIVE
,
7163 &zero_address_frag
);
7165 pseudo_func
[FUNC_LT_RELATIVE
].u
.sym
=
7166 symbol_new (".<ltoff>", undefined_section
, FUNC_LT_RELATIVE
,
7167 &zero_address_frag
);
7169 pseudo_func
[FUNC_LT_RELATIVE_X
].u
.sym
=
7170 symbol_new (".<ltoffx>", undefined_section
, FUNC_LT_RELATIVE_X
,
7171 &zero_address_frag
);
7173 pseudo_func
[FUNC_PC_RELATIVE
].u
.sym
=
7174 symbol_new (".<pcrel>", undefined_section
, FUNC_PC_RELATIVE
,
7175 &zero_address_frag
);
7177 pseudo_func
[FUNC_PLT_RELATIVE
].u
.sym
=
7178 symbol_new (".<pltoff>", undefined_section
, FUNC_PLT_RELATIVE
,
7179 &zero_address_frag
);
7181 pseudo_func
[FUNC_SEC_RELATIVE
].u
.sym
=
7182 symbol_new (".<secrel>", undefined_section
, FUNC_SEC_RELATIVE
,
7183 &zero_address_frag
);
7185 pseudo_func
[FUNC_SEG_RELATIVE
].u
.sym
=
7186 symbol_new (".<segrel>", undefined_section
, FUNC_SEG_RELATIVE
,
7187 &zero_address_frag
);
7189 pseudo_func
[FUNC_TP_RELATIVE
].u
.sym
=
7190 symbol_new (".<tprel>", undefined_section
, FUNC_TP_RELATIVE
,
7191 &zero_address_frag
);
7193 pseudo_func
[FUNC_LTV_RELATIVE
].u
.sym
=
7194 symbol_new (".<ltv>", undefined_section
, FUNC_LTV_RELATIVE
,
7195 &zero_address_frag
);
7197 pseudo_func
[FUNC_LT_FPTR_RELATIVE
].u
.sym
=
7198 symbol_new (".<ltoff.fptr>", undefined_section
, FUNC_LT_FPTR_RELATIVE
,
7199 &zero_address_frag
);
7201 pseudo_func
[FUNC_LT_DTP_MODULE
].u
.sym
=
7202 symbol_new (".<ltoff.dtpmod>", undefined_section
, FUNC_LT_DTP_MODULE
,
7203 &zero_address_frag
);
7205 pseudo_func
[FUNC_LT_DTP_RELATIVE
].u
.sym
=
7206 symbol_new (".<ltoff.dptrel>", undefined_section
, FUNC_LT_DTP_RELATIVE
,
7207 &zero_address_frag
);
7209 pseudo_func
[FUNC_LT_TP_RELATIVE
].u
.sym
=
7210 symbol_new (".<ltoff.tprel>", undefined_section
, FUNC_LT_TP_RELATIVE
,
7211 &zero_address_frag
);
7213 pseudo_func
[FUNC_IPLT_RELOC
].u
.sym
=
7214 symbol_new (".<iplt>", undefined_section
, FUNC_IPLT_RELOC
,
7215 &zero_address_frag
);
7217 /* Compute the table of best templates. We compute goodness as a
7218 base 4 value, in which each match counts for 3, each F counts
7219 for 2, each B counts for 1. This should maximize the number of
7220 F and B nops in the chosen bundles, which is good because these
7221 pipelines are least likely to be overcommitted. */
7222 for (i
= 0; i
< IA64_NUM_TYPES
; ++i
)
7223 for (j
= 0; j
< IA64_NUM_TYPES
; ++j
)
7224 for (k
= 0; k
< IA64_NUM_TYPES
; ++k
)
7227 for (t
= 0; t
< NELEMS (ia64_templ_desc
); ++t
)
7230 if (match (t
, i
, 0))
7232 if (match (t
, j
, 1))
7234 if (match (t
, k
, 2))
7235 goodness
= 3 + 3 + 3;
7237 goodness
= 3 + 3 + extra_goodness (t
, 2);
7239 else if (match (t
, j
, 2))
7240 goodness
= 3 + 3 + extra_goodness (t
, 1);
7244 goodness
+= extra_goodness (t
, 1);
7245 goodness
+= extra_goodness (t
, 2);
7248 else if (match (t
, i
, 1))
7250 if (match (t
, j
, 2))
7253 goodness
= 3 + extra_goodness (t
, 2);
7255 else if (match (t
, i
, 2))
7256 goodness
= 3 + extra_goodness (t
, 1);
7258 if (goodness
> best
)
7261 best_template
[i
][j
][k
] = t
;
7266 for (i
= 0; i
< NUM_SLOTS
; ++i
)
7267 md
.slot
[i
].user_template
= -1;
7269 md
.pseudo_hash
= hash_new ();
7270 for (i
= 0; i
< NELEMS (pseudo_opcode
); ++i
)
7272 err
= hash_insert (md
.pseudo_hash
, pseudo_opcode
[i
].name
,
7273 (void *) (pseudo_opcode
+ i
));
7275 as_fatal ("ia64.md_begin: can't hash `%s': %s",
7276 pseudo_opcode
[i
].name
, err
);
7279 md
.reg_hash
= hash_new ();
7280 md
.dynreg_hash
= hash_new ();
7281 md
.const_hash
= hash_new ();
7282 md
.entry_hash
= hash_new ();
7284 /* general registers: */
7287 for (i
= 0; i
< total
; ++i
)
7289 sprintf (name
, "r%d", i
- REG_GR
);
7290 md
.regsym
[i
] = declare_register (name
, i
);
7293 /* floating point registers: */
7295 for (; i
< total
; ++i
)
7297 sprintf (name
, "f%d", i
- REG_FR
);
7298 md
.regsym
[i
] = declare_register (name
, i
);
7301 /* application registers: */
7304 for (; i
< total
; ++i
)
7306 sprintf (name
, "ar%d", i
- REG_AR
);
7307 md
.regsym
[i
] = declare_register (name
, i
);
7310 /* control registers: */
7313 for (; i
< total
; ++i
)
7315 sprintf (name
, "cr%d", i
- REG_CR
);
7316 md
.regsym
[i
] = declare_register (name
, i
);
7319 /* predicate registers: */
7321 for (; i
< total
; ++i
)
7323 sprintf (name
, "p%d", i
- REG_P
);
7324 md
.regsym
[i
] = declare_register (name
, i
);
7327 /* branch registers: */
7329 for (; i
< total
; ++i
)
7331 sprintf (name
, "b%d", i
- REG_BR
);
7332 md
.regsym
[i
] = declare_register (name
, i
);
7335 md
.regsym
[REG_IP
] = declare_register ("ip", REG_IP
);
7336 md
.regsym
[REG_CFM
] = declare_register ("cfm", REG_CFM
);
7337 md
.regsym
[REG_PR
] = declare_register ("pr", REG_PR
);
7338 md
.regsym
[REG_PR_ROT
] = declare_register ("pr.rot", REG_PR_ROT
);
7339 md
.regsym
[REG_PSR
] = declare_register ("psr", REG_PSR
);
7340 md
.regsym
[REG_PSR_L
] = declare_register ("psr.l", REG_PSR_L
);
7341 md
.regsym
[REG_PSR_UM
] = declare_register ("psr.um", REG_PSR_UM
);
7343 for (i
= 0; i
< NELEMS (indirect_reg
); ++i
)
7345 regnum
= indirect_reg
[i
].regnum
;
7346 md
.regsym
[regnum
] = declare_register (indirect_reg
[i
].name
, regnum
);
7349 /* define synonyms for application registers: */
7350 for (i
= REG_AR
; i
< REG_AR
+ NELEMS (ar
); ++i
)
7351 md
.regsym
[i
] = declare_register (ar
[i
- REG_AR
].name
,
7352 REG_AR
+ ar
[i
- REG_AR
].regnum
);
7354 /* define synonyms for control registers: */
7355 for (i
= REG_CR
; i
< REG_CR
+ NELEMS (cr
); ++i
)
7356 md
.regsym
[i
] = declare_register (cr
[i
- REG_CR
].name
,
7357 REG_CR
+ cr
[i
- REG_CR
].regnum
);
7359 declare_register ("gp", REG_GR
+ 1);
7360 declare_register ("sp", REG_GR
+ 12);
7361 declare_register ("rp", REG_BR
+ 0);
7363 /* pseudo-registers used to specify unwind info: */
7364 declare_register ("psp", REG_PSP
);
7366 declare_register_set ("ret", 4, REG_GR
+ 8);
7367 declare_register_set ("farg", 8, REG_FR
+ 8);
7368 declare_register_set ("fret", 8, REG_FR
+ 8);
7370 for (i
= 0; i
< NELEMS (const_bits
); ++i
)
7372 err
= hash_insert (md
.const_hash
, const_bits
[i
].name
,
7373 (PTR
) (const_bits
+ i
));
7375 as_fatal ("Inserting \"%s\" into constant hash table failed: %s",
7379 /* Set the architecture and machine depending on defaults and command line
7381 if (md
.flags
& EF_IA_64_ABI64
)
7382 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_ia64
, bfd_mach_ia64_elf64
);
7384 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_ia64
, bfd_mach_ia64_elf32
);
7387 as_warn (_("Could not set architecture and machine"));
7389 /* Set the pointer size and pointer shift size depending on md.flags */
7391 if (md
.flags
& EF_IA_64_ABI64
)
7393 md
.pointer_size
= 8; /* pointers are 8 bytes */
7394 md
.pointer_size_shift
= 3; /* alignment is 8 bytes = 2^2 */
7398 md
.pointer_size
= 4; /* pointers are 4 bytes */
7399 md
.pointer_size_shift
= 2; /* alignment is 4 bytes = 2^2 */
7402 md
.mem_offset
.hint
= 0;
7405 md
.entry_labels
= NULL
;
7408 /* Set the default options in md. Cannot do this in md_begin because
7409 that is called after md_parse_option which is where we set the
7410 options in md based on command line options. */
7413 ia64_init (argc
, argv
)
7414 int argc ATTRIBUTE_UNUSED
;
7415 char **argv ATTRIBUTE_UNUSED
;
7417 md
.flags
= MD_FLAGS_DEFAULT
;
7419 /* FIXME: We should change it to unwind_check_error someday. */
7420 md
.unwind_check
= unwind_check_warning
;
7421 md
.hint_b
= hint_b_error
;
7424 /* Return a string for the target object file format. */
7427 ia64_target_format ()
7429 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
7431 if (md
.flags
& EF_IA_64_BE
)
7433 if (md
.flags
& EF_IA_64_ABI64
)
7434 #if defined(TE_AIX50)
7435 return "elf64-ia64-aix-big";
7436 #elif defined(TE_HPUX)
7437 return "elf64-ia64-hpux-big";
7439 return "elf64-ia64-big";
7442 #if defined(TE_AIX50)
7443 return "elf32-ia64-aix-big";
7444 #elif defined(TE_HPUX)
7445 return "elf32-ia64-hpux-big";
7447 return "elf32-ia64-big";
7452 if (md
.flags
& EF_IA_64_ABI64
)
7454 return "elf64-ia64-aix-little";
7456 return "elf64-ia64-little";
7460 return "elf32-ia64-aix-little";
7462 return "elf32-ia64-little";
7467 return "unknown-format";
7471 ia64_end_of_source ()
7473 /* terminate insn group upon reaching end of file: */
7474 insn_group_break (1, 0, 0);
7476 /* emits slots we haven't written yet: */
7477 ia64_flush_insns ();
7479 bfd_set_private_flags (stdoutput
, md
.flags
);
7481 md
.mem_offset
.hint
= 0;
7487 if (md
.qp
.X_op
== O_register
)
7488 as_bad ("qualifying predicate not followed by instruction");
7489 md
.qp
.X_op
= O_absent
;
7491 if (ignore_input ())
7494 if (input_line_pointer
[0] == ';' && input_line_pointer
[-1] == ';')
7496 if (md
.detect_dv
&& !md
.explicit_mode
)
7503 as_warn (_("Explicit stops are ignored in auto mode"));
7507 insn_group_break (1, 0, 0);
7511 /* This is a hook for ia64_frob_label, so that it can distinguish tags from
7513 static int defining_tag
= 0;
7516 ia64_unrecognized_line (ch
)
7522 expression (&md
.qp
);
7523 if (*input_line_pointer
++ != ')')
7525 as_bad ("Expected ')'");
7528 if (md
.qp
.X_op
!= O_register
)
7530 as_bad ("Qualifying predicate expected");
7533 if (md
.qp
.X_add_number
< REG_P
|| md
.qp
.X_add_number
>= REG_P
+ 64)
7535 as_bad ("Predicate register expected");
7541 if (md
.manual_bundling
)
7542 as_warn ("Found '{' when manual bundling is already turned on");
7544 CURR_SLOT
.manual_bundling_on
= 1;
7545 md
.manual_bundling
= 1;
7547 /* Bundling is only acceptable in explicit mode
7548 or when in default automatic mode. */
7549 if (md
.detect_dv
&& !md
.explicit_mode
)
7551 if (!md
.mode_explicitly_set
7552 && !md
.default_explicit_mode
)
7555 as_warn (_("Found '{' after explicit switch to automatic mode"));
7560 if (!md
.manual_bundling
)
7561 as_warn ("Found '}' when manual bundling is off");
7563 PREV_SLOT
.manual_bundling_off
= 1;
7564 md
.manual_bundling
= 0;
7566 /* switch back to automatic mode, if applicable */
7569 && !md
.mode_explicitly_set
7570 && !md
.default_explicit_mode
)
7573 /* Allow '{' to follow on the same line. We also allow ";;", but that
7574 happens automatically because ';' is an end of line marker. */
7576 if (input_line_pointer
[0] == '{')
7578 input_line_pointer
++;
7579 return ia64_unrecognized_line ('{');
7582 demand_empty_rest_of_line ();
7592 if (md
.qp
.X_op
== O_register
)
7594 as_bad ("Tag must come before qualifying predicate.");
7598 /* This implements just enough of read_a_source_file in read.c to
7599 recognize labels. */
7600 if (is_name_beginner (*input_line_pointer
))
7602 s
= input_line_pointer
;
7603 c
= get_symbol_end ();
7605 else if (LOCAL_LABELS_FB
7606 && ISDIGIT (*input_line_pointer
))
7609 while (ISDIGIT (*input_line_pointer
))
7610 temp
= (temp
* 10) + *input_line_pointer
++ - '0';
7611 fb_label_instance_inc (temp
);
7612 s
= fb_label_name (temp
, 0);
7613 c
= *input_line_pointer
;
7622 /* Put ':' back for error messages' sake. */
7623 *input_line_pointer
++ = ':';
7624 as_bad ("Expected ':'");
7631 /* Put ':' back for error messages' sake. */
7632 *input_line_pointer
++ = ':';
7633 if (*input_line_pointer
++ != ']')
7635 as_bad ("Expected ']'");
7640 as_bad ("Tag name expected");
7650 /* Not a valid line. */
7655 ia64_frob_label (sym
)
7658 struct label_fix
*fix
;
7660 /* Tags need special handling since they are not bundle breaks like
7664 fix
= obstack_alloc (¬es
, sizeof (*fix
));
7666 fix
->next
= CURR_SLOT
.tag_fixups
;
7667 CURR_SLOT
.tag_fixups
= fix
;
7672 if (bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
)
7674 md
.last_text_seg
= now_seg
;
7675 fix
= obstack_alloc (¬es
, sizeof (*fix
));
7677 fix
->next
= CURR_SLOT
.label_fixups
;
7678 CURR_SLOT
.label_fixups
= fix
;
7680 /* Keep track of how many code entry points we've seen. */
7681 if (md
.path
== md
.maxpaths
)
7684 md
.entry_labels
= (const char **)
7685 xrealloc ((void *) md
.entry_labels
,
7686 md
.maxpaths
* sizeof (char *));
7688 md
.entry_labels
[md
.path
++] = S_GET_NAME (sym
);
7693 /* The HP-UX linker will give unresolved symbol errors for symbols
7694 that are declared but unused. This routine removes declared,
7695 unused symbols from an object. */
7697 ia64_frob_symbol (sym
)
7700 if ((S_GET_SEGMENT (sym
) == &bfd_und_section
&& ! symbol_used_p (sym
) &&
7701 ELF_ST_VISIBILITY (S_GET_OTHER (sym
)) == STV_DEFAULT
)
7702 || (S_GET_SEGMENT (sym
) == &bfd_abs_section
7703 && ! S_IS_EXTERNAL (sym
)))
7710 ia64_flush_pending_output ()
7712 if (!md
.keep_pending_output
7713 && bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
)
7715 /* ??? This causes many unnecessary stop bits to be emitted.
7716 Unfortunately, it isn't clear if it is safe to remove this. */
7717 insn_group_break (1, 0, 0);
7718 ia64_flush_insns ();
7722 /* Do ia64-specific expression optimization. All that's done here is
7723 to transform index expressions that are either due to the indexing
7724 of rotating registers or due to the indexing of indirect register
7727 ia64_optimize_expr (l
, op
, r
)
7736 if (l
->X_op
== O_register
&& r
->X_op
== O_constant
)
7738 num_regs
= (l
->X_add_number
>> 16);
7739 if ((unsigned) r
->X_add_number
>= num_regs
)
7742 as_bad ("No current frame");
7744 as_bad ("Index out of range 0..%u", num_regs
- 1);
7745 r
->X_add_number
= 0;
7747 l
->X_add_number
= (l
->X_add_number
& 0xffff) + r
->X_add_number
;
7750 else if (l
->X_op
== O_register
&& r
->X_op
== O_register
)
7752 if (l
->X_add_number
< IND_CPUID
|| l
->X_add_number
> IND_RR
7753 || l
->X_add_number
== IND_MEM
)
7755 as_bad ("Indirect register set name expected");
7756 l
->X_add_number
= IND_CPUID
;
7759 l
->X_op_symbol
= md
.regsym
[l
->X_add_number
];
7760 l
->X_add_number
= r
->X_add_number
;
7768 ia64_parse_name (name
, e
, nextcharP
)
7773 struct const_desc
*cdesc
;
7774 struct dynreg
*dr
= 0;
7781 enum pseudo_type pseudo_type
= PSEUDO_FUNC_NONE
;
7783 /* Find what relocation pseudo-function we're dealing with. */
7784 for (idx
= 0; idx
< NELEMS (pseudo_func
); ++idx
)
7785 if (pseudo_func
[idx
].name
7786 && pseudo_func
[idx
].name
[0] == name
[1]
7787 && strcmp (pseudo_func
[idx
].name
+ 1, name
+ 2) == 0)
7789 pseudo_type
= pseudo_func
[idx
].type
;
7792 switch (pseudo_type
)
7794 case PSEUDO_FUNC_RELOC
:
7795 end
= input_line_pointer
;
7796 if (*nextcharP
!= '(')
7798 as_bad ("Expected '('");
7802 ++input_line_pointer
;
7804 if (*input_line_pointer
!= ')')
7806 as_bad ("Missing ')'");
7810 ++input_line_pointer
;
7811 if (e
->X_op
!= O_symbol
)
7813 if (e
->X_op
!= O_pseudo_fixup
)
7815 as_bad ("Not a symbolic expression");
7818 if (idx
!= FUNC_LT_RELATIVE
)
7820 as_bad ("Illegal combination of relocation functions");
7823 switch (S_GET_VALUE (e
->X_op_symbol
))
7825 case FUNC_FPTR_RELATIVE
:
7826 idx
= FUNC_LT_FPTR_RELATIVE
; break;
7827 case FUNC_DTP_MODULE
:
7828 idx
= FUNC_LT_DTP_MODULE
; break;
7829 case FUNC_DTP_RELATIVE
:
7830 idx
= FUNC_LT_DTP_RELATIVE
; break;
7831 case FUNC_TP_RELATIVE
:
7832 idx
= FUNC_LT_TP_RELATIVE
; break;
7834 as_bad ("Illegal combination of relocation functions");
7838 /* Make sure gas doesn't get rid of local symbols that are used
7840 e
->X_op
= O_pseudo_fixup
;
7841 e
->X_op_symbol
= pseudo_func
[idx
].u
.sym
;
7843 *nextcharP
= *input_line_pointer
;
7846 case PSEUDO_FUNC_CONST
:
7847 e
->X_op
= O_constant
;
7848 e
->X_add_number
= pseudo_func
[idx
].u
.ival
;
7851 case PSEUDO_FUNC_REG
:
7852 e
->X_op
= O_register
;
7853 e
->X_add_number
= pseudo_func
[idx
].u
.ival
;
7862 /* first see if NAME is a known register name: */
7863 sym
= hash_find (md
.reg_hash
, name
);
7866 e
->X_op
= O_register
;
7867 e
->X_add_number
= S_GET_VALUE (sym
);
7871 cdesc
= hash_find (md
.const_hash
, name
);
7874 e
->X_op
= O_constant
;
7875 e
->X_add_number
= cdesc
->value
;
7879 /* check for inN, locN, or outN: */
7884 if (name
[1] == 'n' && ISDIGIT (name
[2]))
7892 if (name
[1] == 'o' && name
[2] == 'c' && ISDIGIT (name
[3]))
7900 if (name
[1] == 'u' && name
[2] == 't' && ISDIGIT (name
[3]))
7911 /* Ignore register numbers with leading zeroes, except zero itself. */
7912 if (dr
&& (name
[idx
] != '0' || name
[idx
+ 1] == '\0'))
7914 unsigned long regnum
;
7916 /* The name is inN, locN, or outN; parse the register number. */
7917 regnum
= strtoul (name
+ idx
, &end
, 10);
7918 if (end
> name
+ idx
&& *end
== '\0' && regnum
< 96)
7920 if (regnum
>= dr
->num_regs
)
7923 as_bad ("No current frame");
7925 as_bad ("Register number out of range 0..%u",
7929 e
->X_op
= O_register
;
7930 e
->X_add_number
= dr
->base
+ regnum
;
7935 end
= alloca (strlen (name
) + 1);
7937 name
= ia64_canonicalize_symbol_name (end
);
7938 if ((dr
= hash_find (md
.dynreg_hash
, name
)))
7940 /* We've got ourselves the name of a rotating register set.
7941 Store the base register number in the low 16 bits of
7942 X_add_number and the size of the register set in the top 16
7944 e
->X_op
= O_register
;
7945 e
->X_add_number
= dr
->base
| (dr
->num_regs
<< 16);
7951 /* Remove the '#' suffix that indicates a symbol as opposed to a register. */
7954 ia64_canonicalize_symbol_name (name
)
7957 size_t len
= strlen (name
), full
= len
;
7959 while (len
> 0 && name
[len
- 1] == '#')
7964 as_bad ("Standalone `#' is illegal");
7966 as_bad ("Zero-length symbol is illegal");
7968 else if (len
< full
- 1)
7969 as_warn ("Redundant `#' suffix operators");
7974 /* Return true if idesc is a conditional branch instruction. This excludes
7975 the modulo scheduled branches, and br.ia. Mod-sched branches are excluded
7976 because they always read/write resources regardless of the value of the
7977 qualifying predicate. br.ia must always use p0, and hence is always
7978 taken. Thus this function returns true for branches which can fall
7979 through, and which use no resources if they do fall through. */
7982 is_conditional_branch (idesc
)
7983 struct ia64_opcode
*idesc
;
7985 /* br is a conditional branch. Everything that starts with br. except
7986 br.ia, br.c{loop,top,exit}, and br.w{top,exit} is a conditional branch.
7987 Everything that starts with brl is a conditional branch. */
7988 return (idesc
->name
[0] == 'b' && idesc
->name
[1] == 'r'
7989 && (idesc
->name
[2] == '\0'
7990 || (idesc
->name
[2] == '.' && idesc
->name
[3] != 'i'
7991 && idesc
->name
[3] != 'c' && idesc
->name
[3] != 'w')
7992 || idesc
->name
[2] == 'l'
7993 /* br.cond, br.call, br.clr */
7994 || (idesc
->name
[2] == '.' && idesc
->name
[3] == 'c'
7995 && (idesc
->name
[4] == 'a' || idesc
->name
[4] == 'o'
7996 || (idesc
->name
[4] == 'l' && idesc
->name
[5] == 'r')))));
7999 /* Return whether the given opcode is a taken branch. If there's any doubt,
8003 is_taken_branch (idesc
)
8004 struct ia64_opcode
*idesc
;
8006 return ((is_conditional_branch (idesc
) && CURR_SLOT
.qp_regno
== 0)
8007 || strncmp (idesc
->name
, "br.ia", 5) == 0);
8010 /* Return whether the given opcode is an interruption or rfi. If there's any
8011 doubt, returns zero. */
8014 is_interruption_or_rfi (idesc
)
8015 struct ia64_opcode
*idesc
;
8017 if (strcmp (idesc
->name
, "rfi") == 0)
8022 /* Returns the index of the given dependency in the opcode's list of chks, or
8023 -1 if there is no dependency. */
8026 depends_on (depind
, idesc
)
8028 struct ia64_opcode
*idesc
;
8031 const struct ia64_opcode_dependency
*dep
= idesc
->dependencies
;
8032 for (i
= 0; i
< dep
->nchks
; i
++)
8034 if (depind
== DEP (dep
->chks
[i
]))
8040 /* Determine a set of specific resources used for a particular resource
8041 class. Returns the number of specific resources identified For those
8042 cases which are not determinable statically, the resource returned is
8045 Meanings of value in 'NOTE':
8046 1) only read/write when the register number is explicitly encoded in the
8048 2) only read CFM when accessing a rotating GR, FR, or PR. mov pr only
8049 accesses CFM when qualifying predicate is in the rotating region.
8050 3) general register value is used to specify an indirect register; not
8051 determinable statically.
8052 4) only read the given resource when bits 7:0 of the indirect index
8053 register value does not match the register number of the resource; not
8054 determinable statically.
8055 5) all rules are implementation specific.
8056 6) only when both the index specified by the reader and the index specified
8057 by the writer have the same value in bits 63:61; not determinable
8059 7) only access the specified resource when the corresponding mask bit is
8061 8) PSR.dfh is only read when these insns reference FR32-127. PSR.dfl is
8062 only read when these insns reference FR2-31
8063 9) PSR.mfl is only written when these insns write FR2-31. PSR.mfh is only
8064 written when these insns write FR32-127
8065 10) The PSR.bn bit is only accessed when one of GR16-31 is specified in the
8067 11) The target predicates are written independently of PR[qp], but source
8068 registers are only read if PR[qp] is true. Since the state of PR[qp]
8069 cannot statically be determined, all source registers are marked used.
8070 12) This insn only reads the specified predicate register when that
8071 register is the PR[qp].
8072 13) This reference to ld-c only applies to teh GR whose value is loaded
8073 with data returned from memory, not the post-incremented address register.
8074 14) The RSE resource includes the implementation-specific RSE internal
8075 state resources. At least one (and possibly more) of these resources are
8076 read by each instruction listed in IC:rse-readers. At least one (and
8077 possibly more) of these resources are written by each insn listed in
8079 15+16) Represents reserved instructions, which the assembler does not
8082 Memory resources (i.e. locations in memory) are *not* marked or tracked by
8083 this code; there are no dependency violations based on memory access.
8086 #define MAX_SPECS 256
8091 specify_resource (dep
, idesc
, type
, specs
, note
, path
)
8092 const struct ia64_dependency
*dep
;
8093 struct ia64_opcode
*idesc
;
8094 int type
; /* is this a DV chk or a DV reg? */
8095 struct rsrc specs
[MAX_SPECS
]; /* returned specific resources */
8096 int note
; /* resource note for this insn's usage */
8097 int path
; /* which execution path to examine */
8104 if (dep
->mode
== IA64_DV_WAW
8105 || (dep
->mode
== IA64_DV_RAW
&& type
== DV_REG
)
8106 || (dep
->mode
== IA64_DV_WAR
&& type
== DV_CHK
))
8109 /* template for any resources we identify */
8110 tmpl
.dependency
= dep
;
8112 tmpl
.insn_srlz
= tmpl
.data_srlz
= 0;
8113 tmpl
.qp_regno
= CURR_SLOT
.qp_regno
;
8114 tmpl
.link_to_qp_branch
= 1;
8115 tmpl
.mem_offset
.hint
= 0;
8118 tmpl
.cmp_type
= CMP_NONE
;
8121 as_warn (_("Unhandled dependency %s for %s (%s), note %d"), \
8122 dep->name, idesc->name, (rsrc_write?"write":"read"), note)
8123 #define KNOWN(REG) (gr_values[REG].known && gr_values[REG].path >= path)
8125 /* we don't need to track these */
8126 if (dep
->semantics
== IA64_DVS_NONE
)
8129 switch (dep
->specifier
)
8134 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
)
8136 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
8137 if (regno
>= 0 && regno
<= 7)
8139 specs
[count
] = tmpl
;
8140 specs
[count
++].index
= regno
;
8146 for (i
= 0; i
< 8; i
++)
8148 specs
[count
] = tmpl
;
8149 specs
[count
++].index
= i
;
8158 case IA64_RS_AR_UNAT
:
8159 /* This is a mov =AR or mov AR= instruction. */
8160 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
)
8162 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
8163 if (regno
== AR_UNAT
)
8165 specs
[count
++] = tmpl
;
8170 /* This is a spill/fill, or other instruction that modifies the
8173 /* Unless we can determine the specific bits used, mark the whole
8174 thing; bits 8:3 of the memory address indicate the bit used in
8175 UNAT. The .mem.offset hint may be used to eliminate a small
8176 subset of conflicts. */
8177 specs
[count
] = tmpl
;
8178 if (md
.mem_offset
.hint
)
8181 fprintf (stderr
, " Using hint for spill/fill\n");
8182 /* The index isn't actually used, just set it to something
8183 approximating the bit index. */
8184 specs
[count
].index
= (md
.mem_offset
.offset
>> 3) & 0x3F;
8185 specs
[count
].mem_offset
.hint
= 1;
8186 specs
[count
].mem_offset
.offset
= md
.mem_offset
.offset
;
8187 specs
[count
++].mem_offset
.base
= md
.mem_offset
.base
;
8191 specs
[count
++].specific
= 0;
8199 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
)
8201 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
8202 if ((regno
>= 8 && regno
<= 15)
8203 || (regno
>= 20 && regno
<= 23)
8204 || (regno
>= 31 && regno
<= 39)
8205 || (regno
>= 41 && regno
<= 47)
8206 || (regno
>= 67 && regno
<= 111))
8208 specs
[count
] = tmpl
;
8209 specs
[count
++].index
= regno
;
8222 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
)
8224 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
8225 if ((regno
>= 48 && regno
<= 63)
8226 || (regno
>= 112 && regno
<= 127))
8228 specs
[count
] = tmpl
;
8229 specs
[count
++].index
= regno
;
8235 for (i
= 48; i
< 64; i
++)
8237 specs
[count
] = tmpl
;
8238 specs
[count
++].index
= i
;
8240 for (i
= 112; i
< 128; i
++)
8242 specs
[count
] = tmpl
;
8243 specs
[count
++].index
= i
;
8261 for (i
= 0; i
< idesc
->num_outputs
; i
++)
8262 if (idesc
->operands
[i
] == IA64_OPND_B1
8263 || idesc
->operands
[i
] == IA64_OPND_B2
)
8265 specs
[count
] = tmpl
;
8266 specs
[count
++].index
=
8267 CURR_SLOT
.opnd
[i
].X_add_number
- REG_BR
;
8272 for (i
= idesc
->num_outputs
; i
< NELEMS (idesc
->operands
); i
++)
8273 if (idesc
->operands
[i
] == IA64_OPND_B1
8274 || idesc
->operands
[i
] == IA64_OPND_B2
)
8276 specs
[count
] = tmpl
;
8277 specs
[count
++].index
=
8278 CURR_SLOT
.opnd
[i
].X_add_number
- REG_BR
;
8284 case IA64_RS_CPUID
: /* four or more registers */
8287 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_CPUID_R3
)
8289 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8290 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8293 specs
[count
] = tmpl
;
8294 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8298 specs
[count
] = tmpl
;
8299 specs
[count
++].specific
= 0;
8309 case IA64_RS_DBR
: /* four or more registers */
8312 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_DBR_R3
)
8314 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8315 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8318 specs
[count
] = tmpl
;
8319 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8323 specs
[count
] = tmpl
;
8324 specs
[count
++].specific
= 0;
8328 else if (note
== 0 && !rsrc_write
)
8330 specs
[count
] = tmpl
;
8331 specs
[count
++].specific
= 0;
8339 case IA64_RS_IBR
: /* four or more registers */
8342 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_IBR_R3
)
8344 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8345 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8348 specs
[count
] = tmpl
;
8349 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8353 specs
[count
] = tmpl
;
8354 specs
[count
++].specific
= 0;
8367 /* These are implementation specific. Force all references to
8368 conflict with all other references. */
8369 specs
[count
] = tmpl
;
8370 specs
[count
++].specific
= 0;
8378 case IA64_RS_PKR
: /* 16 or more registers */
8379 if (note
== 3 || note
== 4)
8381 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PKR_R3
)
8383 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8384 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8389 specs
[count
] = tmpl
;
8390 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8393 for (i
= 0; i
< NELEMS (gr_values
); i
++)
8395 /* Uses all registers *except* the one in R3. */
8396 if ((unsigned)i
!= (gr_values
[regno
].value
& 0xFF))
8398 specs
[count
] = tmpl
;
8399 specs
[count
++].index
= i
;
8405 specs
[count
] = tmpl
;
8406 specs
[count
++].specific
= 0;
8413 specs
[count
] = tmpl
;
8414 specs
[count
++].specific
= 0;
8418 case IA64_RS_PMC
: /* four or more registers */
8421 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PMC_R3
8422 || (!rsrc_write
&& idesc
->operands
[1] == IA64_OPND_PMD_R3
))
8425 int index
= ((idesc
->operands
[1] == IA64_OPND_R3
&& !rsrc_write
)
8427 int regno
= CURR_SLOT
.opnd
[index
].X_add_number
- REG_GR
;
8428 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8431 specs
[count
] = tmpl
;
8432 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8436 specs
[count
] = tmpl
;
8437 specs
[count
++].specific
= 0;
8447 case IA64_RS_PMD
: /* four or more registers */
8450 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PMD_R3
)
8452 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8453 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8456 specs
[count
] = tmpl
;
8457 specs
[count
++].index
= gr_values
[regno
].value
& 0xFF;
8461 specs
[count
] = tmpl
;
8462 specs
[count
++].specific
= 0;
8472 case IA64_RS_RR
: /* eight registers */
8475 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_RR_R3
)
8477 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_GR
;
8478 if (regno
>= 0 && regno
< NELEMS (gr_values
)
8481 specs
[count
] = tmpl
;
8482 specs
[count
++].index
= (gr_values
[regno
].value
>> 61) & 0x7;
8486 specs
[count
] = tmpl
;
8487 specs
[count
++].specific
= 0;
8491 else if (note
== 0 && !rsrc_write
)
8493 specs
[count
] = tmpl
;
8494 specs
[count
++].specific
= 0;
8502 case IA64_RS_CR_IRR
:
8505 /* handle mov-from-CR-IVR; it's a read that writes CR[IRR] */
8506 int regno
= CURR_SLOT
.opnd
[1].X_add_number
- REG_CR
;
8508 && idesc
->operands
[1] == IA64_OPND_CR3
8511 for (i
= 0; i
< 4; i
++)
8513 specs
[count
] = tmpl
;
8514 specs
[count
++].index
= CR_IRR0
+ i
;
8520 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_CR
;
8521 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_CR3
8523 && regno
<= CR_IRR3
)
8525 specs
[count
] = tmpl
;
8526 specs
[count
++].index
= regno
;
8535 case IA64_RS_CR_LRR
:
8542 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_CR
;
8543 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_CR3
8544 && (regno
== CR_LRR0
|| regno
== CR_LRR1
))
8546 specs
[count
] = tmpl
;
8547 specs
[count
++].index
= regno
;
8555 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_CR3
)
8557 specs
[count
] = tmpl
;
8558 specs
[count
++].index
=
8559 CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_CR
;
8574 else if (rsrc_write
)
8576 if (dep
->specifier
== IA64_RS_FRb
8577 && idesc
->operands
[0] == IA64_OPND_F1
)
8579 specs
[count
] = tmpl
;
8580 specs
[count
++].index
= CURR_SLOT
.opnd
[0].X_add_number
- REG_FR
;
8585 for (i
= idesc
->num_outputs
; i
< NELEMS (idesc
->operands
); i
++)
8587 if (idesc
->operands
[i
] == IA64_OPND_F2
8588 || idesc
->operands
[i
] == IA64_OPND_F3
8589 || idesc
->operands
[i
] == IA64_OPND_F4
)
8591 specs
[count
] = tmpl
;
8592 specs
[count
++].index
=
8593 CURR_SLOT
.opnd
[i
].X_add_number
- REG_FR
;
8602 /* This reference applies only to the GR whose value is loaded with
8603 data returned from memory. */
8604 specs
[count
] = tmpl
;
8605 specs
[count
++].index
= CURR_SLOT
.opnd
[0].X_add_number
- REG_GR
;
8611 for (i
= 0; i
< idesc
->num_outputs
; i
++)
8612 if (idesc
->operands
[i
] == IA64_OPND_R1
8613 || idesc
->operands
[i
] == IA64_OPND_R2
8614 || idesc
->operands
[i
] == IA64_OPND_R3
)
8616 specs
[count
] = tmpl
;
8617 specs
[count
++].index
=
8618 CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
8620 if (idesc
->flags
& IA64_OPCODE_POSTINC
)
8621 for (i
= 0; i
< NELEMS (idesc
->operands
); i
++)
8622 if (idesc
->operands
[i
] == IA64_OPND_MR3
)
8624 specs
[count
] = tmpl
;
8625 specs
[count
++].index
=
8626 CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
8631 /* Look for anything that reads a GR. */
8632 for (i
= 0; i
< NELEMS (idesc
->operands
); i
++)
8634 if (idesc
->operands
[i
] == IA64_OPND_MR3
8635 || idesc
->operands
[i
] == IA64_OPND_CPUID_R3
8636 || idesc
->operands
[i
] == IA64_OPND_DBR_R3
8637 || idesc
->operands
[i
] == IA64_OPND_IBR_R3
8638 || idesc
->operands
[i
] == IA64_OPND_MSR_R3
8639 || idesc
->operands
[i
] == IA64_OPND_PKR_R3
8640 || idesc
->operands
[i
] == IA64_OPND_PMC_R3
8641 || idesc
->operands
[i
] == IA64_OPND_PMD_R3
8642 || idesc
->operands
[i
] == IA64_OPND_RR_R3
8643 || ((i
>= idesc
->num_outputs
)
8644 && (idesc
->operands
[i
] == IA64_OPND_R1
8645 || idesc
->operands
[i
] == IA64_OPND_R2
8646 || idesc
->operands
[i
] == IA64_OPND_R3
8647 /* addl source register. */
8648 || idesc
->operands
[i
] == IA64_OPND_R3_2
)))
8650 specs
[count
] = tmpl
;
8651 specs
[count
++].index
=
8652 CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
8663 /* This is the same as IA64_RS_PRr, except that the register range is
8664 from 1 - 15, and there are no rotating register reads/writes here. */
8668 for (i
= 1; i
< 16; i
++)
8670 specs
[count
] = tmpl
;
8671 specs
[count
++].index
= i
;
8677 /* Mark only those registers indicated by the mask. */
8680 mask
= CURR_SLOT
.opnd
[2].X_add_number
;
8681 for (i
= 1; i
< 16; i
++)
8682 if (mask
& ((valueT
) 1 << i
))
8684 specs
[count
] = tmpl
;
8685 specs
[count
++].index
= i
;
8693 else if (note
== 11) /* note 11 implies note 1 as well */
8697 for (i
= 0; i
< idesc
->num_outputs
; i
++)
8699 if (idesc
->operands
[i
] == IA64_OPND_P1
8700 || idesc
->operands
[i
] == IA64_OPND_P2
)
8702 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_P
;
8703 if (regno
>= 1 && regno
< 16)
8705 specs
[count
] = tmpl
;
8706 specs
[count
++].index
= regno
;
8716 else if (note
== 12)
8718 if (CURR_SLOT
.qp_regno
>= 1 && CURR_SLOT
.qp_regno
< 16)
8720 specs
[count
] = tmpl
;
8721 specs
[count
++].index
= CURR_SLOT
.qp_regno
;
8728 int p1
= CURR_SLOT
.opnd
[0].X_add_number
- REG_P
;
8729 int p2
= CURR_SLOT
.opnd
[1].X_add_number
- REG_P
;
8730 int or_andcm
= strstr (idesc
->name
, "or.andcm") != NULL
;
8731 int and_orcm
= strstr (idesc
->name
, "and.orcm") != NULL
;
8733 if ((idesc
->operands
[0] == IA64_OPND_P1
8734 || idesc
->operands
[0] == IA64_OPND_P2
)
8735 && p1
>= 1 && p1
< 16)
8737 specs
[count
] = tmpl
;
8738 specs
[count
].cmp_type
=
8739 (or_andcm
? CMP_OR
: (and_orcm
? CMP_AND
: CMP_NONE
));
8740 specs
[count
++].index
= p1
;
8742 if ((idesc
->operands
[1] == IA64_OPND_P1
8743 || idesc
->operands
[1] == IA64_OPND_P2
)
8744 && p2
>= 1 && p2
< 16)
8746 specs
[count
] = tmpl
;
8747 specs
[count
].cmp_type
=
8748 (or_andcm
? CMP_AND
: (and_orcm
? CMP_OR
: CMP_NONE
));
8749 specs
[count
++].index
= p2
;
8754 if (CURR_SLOT
.qp_regno
>= 1 && CURR_SLOT
.qp_regno
< 16)
8756 specs
[count
] = tmpl
;
8757 specs
[count
++].index
= CURR_SLOT
.qp_regno
;
8759 if (idesc
->operands
[1] == IA64_OPND_PR
)
8761 for (i
= 1; i
< 16; i
++)
8763 specs
[count
] = tmpl
;
8764 specs
[count
++].index
= i
;
8775 /* This is the general case for PRs. IA64_RS_PR and IA64_RS_PR63 are
8776 simplified cases of this. */
8780 for (i
= 16; i
< 63; i
++)
8782 specs
[count
] = tmpl
;
8783 specs
[count
++].index
= i
;
8789 /* Mark only those registers indicated by the mask. */
8791 && idesc
->operands
[0] == IA64_OPND_PR
)
8793 mask
= CURR_SLOT
.opnd
[2].X_add_number
;
8794 if (mask
& ((valueT
) 1 << 16))
8795 for (i
= 16; i
< 63; i
++)
8797 specs
[count
] = tmpl
;
8798 specs
[count
++].index
= i
;
8802 && idesc
->operands
[0] == IA64_OPND_PR_ROT
)
8804 for (i
= 16; i
< 63; i
++)
8806 specs
[count
] = tmpl
;
8807 specs
[count
++].index
= i
;
8815 else if (note
== 11) /* note 11 implies note 1 as well */
8819 for (i
= 0; i
< idesc
->num_outputs
; i
++)
8821 if (idesc
->operands
[i
] == IA64_OPND_P1
8822 || idesc
->operands
[i
] == IA64_OPND_P2
)
8824 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_P
;
8825 if (regno
>= 16 && regno
< 63)
8827 specs
[count
] = tmpl
;
8828 specs
[count
++].index
= regno
;
8838 else if (note
== 12)
8840 if (CURR_SLOT
.qp_regno
>= 16 && CURR_SLOT
.qp_regno
< 63)
8842 specs
[count
] = tmpl
;
8843 specs
[count
++].index
= CURR_SLOT
.qp_regno
;
8850 int p1
= CURR_SLOT
.opnd
[0].X_add_number
- REG_P
;
8851 int p2
= CURR_SLOT
.opnd
[1].X_add_number
- REG_P
;
8852 int or_andcm
= strstr (idesc
->name
, "or.andcm") != NULL
;
8853 int and_orcm
= strstr (idesc
->name
, "and.orcm") != NULL
;
8855 if ((idesc
->operands
[0] == IA64_OPND_P1
8856 || idesc
->operands
[0] == IA64_OPND_P2
)
8857 && p1
>= 16 && p1
< 63)
8859 specs
[count
] = tmpl
;
8860 specs
[count
].cmp_type
=
8861 (or_andcm
? CMP_OR
: (and_orcm
? CMP_AND
: CMP_NONE
));
8862 specs
[count
++].index
= p1
;
8864 if ((idesc
->operands
[1] == IA64_OPND_P1
8865 || idesc
->operands
[1] == IA64_OPND_P2
)
8866 && p2
>= 16 && p2
< 63)
8868 specs
[count
] = tmpl
;
8869 specs
[count
].cmp_type
=
8870 (or_andcm
? CMP_AND
: (and_orcm
? CMP_OR
: CMP_NONE
));
8871 specs
[count
++].index
= p2
;
8876 if (CURR_SLOT
.qp_regno
>= 16 && CURR_SLOT
.qp_regno
< 63)
8878 specs
[count
] = tmpl
;
8879 specs
[count
++].index
= CURR_SLOT
.qp_regno
;
8881 if (idesc
->operands
[1] == IA64_OPND_PR
)
8883 for (i
= 16; i
< 63; i
++)
8885 specs
[count
] = tmpl
;
8886 specs
[count
++].index
= i
;
8898 /* Verify that the instruction is using the PSR bit indicated in
8902 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PSR_UM
)
8904 if (dep
->regindex
< 6)
8906 specs
[count
++] = tmpl
;
8909 else if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PSR
)
8911 if (dep
->regindex
< 32
8912 || dep
->regindex
== 35
8913 || dep
->regindex
== 36
8914 || (!rsrc_write
&& dep
->regindex
== PSR_CPL
))
8916 specs
[count
++] = tmpl
;
8919 else if (idesc
->operands
[!rsrc_write
] == IA64_OPND_PSR_L
)
8921 if (dep
->regindex
< 32
8922 || dep
->regindex
== 35
8923 || dep
->regindex
== 36
8924 || (rsrc_write
&& dep
->regindex
== PSR_CPL
))
8926 specs
[count
++] = tmpl
;
8931 /* Several PSR bits have very specific dependencies. */
8932 switch (dep
->regindex
)
8935 specs
[count
++] = tmpl
;
8940 specs
[count
++] = tmpl
;
8944 /* Only certain CR accesses use PSR.ic */
8945 if (idesc
->operands
[0] == IA64_OPND_CR3
8946 || idesc
->operands
[1] == IA64_OPND_CR3
)
8949 ((idesc
->operands
[0] == IA64_OPND_CR3
)
8952 CURR_SLOT
.opnd
[index
].X_add_number
- REG_CR
;
8967 specs
[count
++] = tmpl
;
8976 specs
[count
++] = tmpl
;
8980 /* Only some AR accesses use cpl */
8981 if (idesc
->operands
[0] == IA64_OPND_AR3
8982 || idesc
->operands
[1] == IA64_OPND_AR3
)
8985 ((idesc
->operands
[0] == IA64_OPND_AR3
)
8988 CURR_SLOT
.opnd
[index
].X_add_number
- REG_AR
;
8995 && regno
<= AR_K7
))))
8997 specs
[count
++] = tmpl
;
9002 specs
[count
++] = tmpl
;
9012 if (idesc
->operands
[0] == IA64_OPND_IMMU24
)
9014 mask
= CURR_SLOT
.opnd
[0].X_add_number
;
9020 if (mask
& ((valueT
) 1 << dep
->regindex
))
9022 specs
[count
++] = tmpl
;
9027 int min
= dep
->regindex
== PSR_DFL
? 2 : 32;
9028 int max
= dep
->regindex
== PSR_DFL
? 31 : 127;
9029 /* dfh is read on FR32-127; dfl is read on FR2-31 */
9030 for (i
= 0; i
< NELEMS (idesc
->operands
); i
++)
9032 if (idesc
->operands
[i
] == IA64_OPND_F1
9033 || idesc
->operands
[i
] == IA64_OPND_F2
9034 || idesc
->operands
[i
] == IA64_OPND_F3
9035 || idesc
->operands
[i
] == IA64_OPND_F4
)
9037 int reg
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_FR
;
9038 if (reg
>= min
&& reg
<= max
)
9040 specs
[count
++] = tmpl
;
9047 int min
= dep
->regindex
== PSR_MFL
? 2 : 32;
9048 int max
= dep
->regindex
== PSR_MFL
? 31 : 127;
9049 /* mfh is read on writes to FR32-127; mfl is read on writes to
9051 for (i
= 0; i
< idesc
->num_outputs
; i
++)
9053 if (idesc
->operands
[i
] == IA64_OPND_F1
)
9055 int reg
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_FR
;
9056 if (reg
>= min
&& reg
<= max
)
9058 specs
[count
++] = tmpl
;
9063 else if (note
== 10)
9065 for (i
= 0; i
< NELEMS (idesc
->operands
); i
++)
9067 if (idesc
->operands
[i
] == IA64_OPND_R1
9068 || idesc
->operands
[i
] == IA64_OPND_R2
9069 || idesc
->operands
[i
] == IA64_OPND_R3
)
9071 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
9072 if (regno
>= 16 && regno
<= 31)
9074 specs
[count
++] = tmpl
;
9085 case IA64_RS_AR_FPSR
:
9086 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
)
9088 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
9089 if (regno
== AR_FPSR
)
9091 specs
[count
++] = tmpl
;
9096 specs
[count
++] = tmpl
;
9101 /* Handle all AR[REG] resources */
9102 if (note
== 0 || note
== 1)
9104 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_AR
;
9105 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_AR3
9106 && regno
== dep
->regindex
)
9108 specs
[count
++] = tmpl
;
9110 /* other AR[REG] resources may be affected by AR accesses */
9111 else if (idesc
->operands
[0] == IA64_OPND_AR3
)
9114 regno
= CURR_SLOT
.opnd
[0].X_add_number
- REG_AR
;
9115 switch (dep
->regindex
)
9121 if (regno
== AR_BSPSTORE
)
9123 specs
[count
++] = tmpl
;
9127 (regno
== AR_BSPSTORE
9128 || regno
== AR_RNAT
))
9130 specs
[count
++] = tmpl
;
9135 else if (idesc
->operands
[1] == IA64_OPND_AR3
)
9138 regno
= CURR_SLOT
.opnd
[1].X_add_number
- REG_AR
;
9139 switch (dep
->regindex
)
9144 if (regno
== AR_BSPSTORE
|| regno
== AR_RNAT
)
9146 specs
[count
++] = tmpl
;
9153 specs
[count
++] = tmpl
;
9163 /* Handle all CR[REG] resources */
9164 if (note
== 0 || note
== 1)
9166 if (idesc
->operands
[!rsrc_write
] == IA64_OPND_CR3
)
9168 int regno
= CURR_SLOT
.opnd
[!rsrc_write
].X_add_number
- REG_CR
;
9169 if (regno
== dep
->regindex
)
9171 specs
[count
++] = tmpl
;
9173 else if (!rsrc_write
)
9175 /* Reads from CR[IVR] affect other resources. */
9176 if (regno
== CR_IVR
)
9178 if ((dep
->regindex
>= CR_IRR0
9179 && dep
->regindex
<= CR_IRR3
)
9180 || dep
->regindex
== CR_TPR
)
9182 specs
[count
++] = tmpl
;
9189 specs
[count
++] = tmpl
;
9198 case IA64_RS_INSERVICE
:
9199 /* look for write of EOI (67) or read of IVR (65) */
9200 if ((idesc
->operands
[0] == IA64_OPND_CR3
9201 && CURR_SLOT
.opnd
[0].X_add_number
- REG_CR
== CR_EOI
)
9202 || (idesc
->operands
[1] == IA64_OPND_CR3
9203 && CURR_SLOT
.opnd
[1].X_add_number
- REG_CR
== CR_IVR
))
9205 specs
[count
++] = tmpl
;
9212 specs
[count
++] = tmpl
;
9223 specs
[count
++] = tmpl
;
9227 /* Check if any of the registers accessed are in the rotating region.
9228 mov to/from pr accesses CFM only when qp_regno is in the rotating
9230 for (i
= 0; i
< NELEMS (idesc
->operands
); i
++)
9232 if (idesc
->operands
[i
] == IA64_OPND_R1
9233 || idesc
->operands
[i
] == IA64_OPND_R2
9234 || idesc
->operands
[i
] == IA64_OPND_R3
)
9236 int num
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
9237 /* Assumes that md.rot.num_regs is always valid */
9238 if (md
.rot
.num_regs
> 0
9240 && num
< 31 + md
.rot
.num_regs
)
9242 specs
[count
] = tmpl
;
9243 specs
[count
++].specific
= 0;
9246 else if (idesc
->operands
[i
] == IA64_OPND_F1
9247 || idesc
->operands
[i
] == IA64_OPND_F2
9248 || idesc
->operands
[i
] == IA64_OPND_F3
9249 || idesc
->operands
[i
] == IA64_OPND_F4
)
9251 int num
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_FR
;
9254 specs
[count
] = tmpl
;
9255 specs
[count
++].specific
= 0;
9258 else if (idesc
->operands
[i
] == IA64_OPND_P1
9259 || idesc
->operands
[i
] == IA64_OPND_P2
)
9261 int num
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_P
;
9264 specs
[count
] = tmpl
;
9265 specs
[count
++].specific
= 0;
9269 if (CURR_SLOT
.qp_regno
> 15)
9271 specs
[count
] = tmpl
;
9272 specs
[count
++].specific
= 0;
9277 /* This is the same as IA64_RS_PRr, except simplified to account for
9278 the fact that there is only one register. */
9282 specs
[count
++] = tmpl
;
9287 if (idesc
->operands
[2] == IA64_OPND_IMM17
)
9288 mask
= CURR_SLOT
.opnd
[2].X_add_number
;
9289 if (mask
& ((valueT
) 1 << 63))
9290 specs
[count
++] = tmpl
;
9292 else if (note
== 11)
9294 if ((idesc
->operands
[0] == IA64_OPND_P1
9295 && CURR_SLOT
.opnd
[0].X_add_number
- REG_P
== 63)
9296 || (idesc
->operands
[1] == IA64_OPND_P2
9297 && CURR_SLOT
.opnd
[1].X_add_number
- REG_P
== 63))
9299 specs
[count
++] = tmpl
;
9302 else if (note
== 12)
9304 if (CURR_SLOT
.qp_regno
== 63)
9306 specs
[count
++] = tmpl
;
9313 int p1
= CURR_SLOT
.opnd
[0].X_add_number
- REG_P
;
9314 int p2
= CURR_SLOT
.opnd
[1].X_add_number
- REG_P
;
9315 int or_andcm
= strstr (idesc
->name
, "or.andcm") != NULL
;
9316 int and_orcm
= strstr (idesc
->name
, "and.orcm") != NULL
;
9319 && (idesc
->operands
[0] == IA64_OPND_P1
9320 || idesc
->operands
[0] == IA64_OPND_P2
))
9322 specs
[count
] = tmpl
;
9323 specs
[count
++].cmp_type
=
9324 (or_andcm
? CMP_OR
: (and_orcm
? CMP_AND
: CMP_NONE
));
9327 && (idesc
->operands
[1] == IA64_OPND_P1
9328 || idesc
->operands
[1] == IA64_OPND_P2
))
9330 specs
[count
] = tmpl
;
9331 specs
[count
++].cmp_type
=
9332 (or_andcm
? CMP_AND
: (and_orcm
? CMP_OR
: CMP_NONE
));
9337 if (CURR_SLOT
.qp_regno
== 63)
9339 specs
[count
++] = tmpl
;
9350 /* FIXME we can identify some individual RSE written resources, but RSE
9351 read resources have not yet been completely identified, so for now
9352 treat RSE as a single resource */
9353 if (strncmp (idesc
->name
, "mov", 3) == 0)
9357 if (idesc
->operands
[0] == IA64_OPND_AR3
9358 && CURR_SLOT
.opnd
[0].X_add_number
- REG_AR
== AR_BSPSTORE
)
9360 specs
[count
++] = tmpl
;
9365 if (idesc
->operands
[0] == IA64_OPND_AR3
)
9367 if (CURR_SLOT
.opnd
[0].X_add_number
- REG_AR
== AR_BSPSTORE
9368 || CURR_SLOT
.opnd
[0].X_add_number
- REG_AR
== AR_RNAT
)
9370 specs
[count
++] = tmpl
;
9373 else if (idesc
->operands
[1] == IA64_OPND_AR3
)
9375 if (CURR_SLOT
.opnd
[1].X_add_number
- REG_AR
== AR_BSP
9376 || CURR_SLOT
.opnd
[1].X_add_number
- REG_AR
== AR_BSPSTORE
9377 || CURR_SLOT
.opnd
[1].X_add_number
- REG_AR
== AR_RNAT
)
9379 specs
[count
++] = tmpl
;
9386 specs
[count
++] = tmpl
;
9391 /* FIXME -- do any of these need to be non-specific? */
9392 specs
[count
++] = tmpl
;
9396 as_bad (_("Unrecognized dependency specifier %d\n"), dep
->specifier
);
9403 /* Clear branch flags on marked resources. This breaks the link between the
9404 QP of the marking instruction and a subsequent branch on the same QP. */
9407 clear_qp_branch_flag (mask
)
9411 for (i
= 0; i
< regdepslen
; i
++)
9413 valueT bit
= ((valueT
) 1 << regdeps
[i
].qp_regno
);
9414 if ((bit
& mask
) != 0)
9416 regdeps
[i
].link_to_qp_branch
= 0;
9421 /* MASK contains 2 and only 2 PRs which are mutually exclusive. Remove
9422 any mutexes which contain one of the PRs and create new ones when
9426 update_qp_mutex (valueT mask
)
9432 while (i
< qp_mutexeslen
)
9434 if ((qp_mutexes
[i
].prmask
& mask
) != 0)
9436 /* If it destroys and creates the same mutex, do nothing. */
9437 if (qp_mutexes
[i
].prmask
== mask
9438 && qp_mutexes
[i
].path
== md
.path
)
9449 fprintf (stderr
, " Clearing mutex relation");
9450 print_prmask (qp_mutexes
[i
].prmask
);
9451 fprintf (stderr
, "\n");
9454 /* Deal with the old mutex with more than 3+ PRs only if
9455 the new mutex on the same execution path with it.
9457 FIXME: The 3+ mutex support is incomplete.
9458 dot_pred_rel () may be a better place to fix it. */
9459 if (qp_mutexes
[i
].path
== md
.path
)
9461 /* If it is a proper subset of the mutex, create a
9464 && (qp_mutexes
[i
].prmask
& mask
) == mask
)
9467 qp_mutexes
[i
].prmask
&= ~mask
;
9468 if (qp_mutexes
[i
].prmask
& (qp_mutexes
[i
].prmask
- 1))
9470 /* Modify the mutex if there are more than one
9478 /* Remove the mutex. */
9479 qp_mutexes
[i
] = qp_mutexes
[--qp_mutexeslen
];
9487 add_qp_mutex (mask
);
9492 /* Remove any mutexes which contain any of the PRs indicated in the mask.
9494 Any changes to a PR clears the mutex relations which include that PR. */
9497 clear_qp_mutex (mask
)
9503 while (i
< qp_mutexeslen
)
9505 if ((qp_mutexes
[i
].prmask
& mask
) != 0)
9509 fprintf (stderr
, " Clearing mutex relation");
9510 print_prmask (qp_mutexes
[i
].prmask
);
9511 fprintf (stderr
, "\n");
9513 qp_mutexes
[i
] = qp_mutexes
[--qp_mutexeslen
];
9520 /* Clear implies relations which contain PRs in the given masks.
9521 P1_MASK indicates the source of the implies relation, while P2_MASK
9522 indicates the implied PR. */
9525 clear_qp_implies (p1_mask
, p2_mask
)
9532 while (i
< qp_implieslen
)
9534 if ((((valueT
) 1 << qp_implies
[i
].p1
) & p1_mask
) != 0
9535 || (((valueT
) 1 << qp_implies
[i
].p2
) & p2_mask
) != 0)
9538 fprintf (stderr
, "Clearing implied relation PR%d->PR%d\n",
9539 qp_implies
[i
].p1
, qp_implies
[i
].p2
);
9540 qp_implies
[i
] = qp_implies
[--qp_implieslen
];
9547 /* Add the PRs specified to the list of implied relations. */
9550 add_qp_imply (p1
, p2
)
9557 /* p0 is not meaningful here. */
9558 if (p1
== 0 || p2
== 0)
9564 /* If it exists already, ignore it. */
9565 for (i
= 0; i
< qp_implieslen
; i
++)
9567 if (qp_implies
[i
].p1
== p1
9568 && qp_implies
[i
].p2
== p2
9569 && qp_implies
[i
].path
== md
.path
9570 && !qp_implies
[i
].p2_branched
)
9574 if (qp_implieslen
== qp_impliestotlen
)
9576 qp_impliestotlen
+= 20;
9577 qp_implies
= (struct qp_imply
*)
9578 xrealloc ((void *) qp_implies
,
9579 qp_impliestotlen
* sizeof (struct qp_imply
));
9582 fprintf (stderr
, " Registering PR%d implies PR%d\n", p1
, p2
);
9583 qp_implies
[qp_implieslen
].p1
= p1
;
9584 qp_implies
[qp_implieslen
].p2
= p2
;
9585 qp_implies
[qp_implieslen
].path
= md
.path
;
9586 qp_implies
[qp_implieslen
++].p2_branched
= 0;
9588 /* Add in the implied transitive relations; for everything that p2 implies,
9589 make p1 imply that, too; for everything that implies p1, make it imply p2
9591 for (i
= 0; i
< qp_implieslen
; i
++)
9593 if (qp_implies
[i
].p1
== p2
)
9594 add_qp_imply (p1
, qp_implies
[i
].p2
);
9595 if (qp_implies
[i
].p2
== p1
)
9596 add_qp_imply (qp_implies
[i
].p1
, p2
);
9598 /* Add in mutex relations implied by this implies relation; for each mutex
9599 relation containing p2, duplicate it and replace p2 with p1. */
9600 bit
= (valueT
) 1 << p1
;
9601 mask
= (valueT
) 1 << p2
;
9602 for (i
= 0; i
< qp_mutexeslen
; i
++)
9604 if (qp_mutexes
[i
].prmask
& mask
)
9605 add_qp_mutex ((qp_mutexes
[i
].prmask
& ~mask
) | bit
);
9609 /* Add the PRs specified in the mask to the mutex list; this means that only
9610 one of the PRs can be true at any time. PR0 should never be included in
9620 if (qp_mutexeslen
== qp_mutexestotlen
)
9622 qp_mutexestotlen
+= 20;
9623 qp_mutexes
= (struct qpmutex
*)
9624 xrealloc ((void *) qp_mutexes
,
9625 qp_mutexestotlen
* sizeof (struct qpmutex
));
9629 fprintf (stderr
, " Registering mutex on");
9630 print_prmask (mask
);
9631 fprintf (stderr
, "\n");
9633 qp_mutexes
[qp_mutexeslen
].path
= md
.path
;
9634 qp_mutexes
[qp_mutexeslen
++].prmask
= mask
;
9638 has_suffix_p (name
, suffix
)
9642 size_t namelen
= strlen (name
);
9643 size_t sufflen
= strlen (suffix
);
9645 if (namelen
<= sufflen
)
9647 return strcmp (name
+ namelen
- sufflen
, suffix
) == 0;
9651 clear_register_values ()
9655 fprintf (stderr
, " Clearing register values\n");
9656 for (i
= 1; i
< NELEMS (gr_values
); i
++)
9657 gr_values
[i
].known
= 0;
9660 /* Keep track of register values/changes which affect DV tracking.
9662 optimization note: should add a flag to classes of insns where otherwise we
9663 have to examine a group of strings to identify them. */
9666 note_register_values (idesc
)
9667 struct ia64_opcode
*idesc
;
9669 valueT qp_changemask
= 0;
9672 /* Invalidate values for registers being written to. */
9673 for (i
= 0; i
< idesc
->num_outputs
; i
++)
9675 if (idesc
->operands
[i
] == IA64_OPND_R1
9676 || idesc
->operands
[i
] == IA64_OPND_R2
9677 || idesc
->operands
[i
] == IA64_OPND_R3
)
9679 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
9680 if (regno
> 0 && regno
< NELEMS (gr_values
))
9681 gr_values
[regno
].known
= 0;
9683 else if (idesc
->operands
[i
] == IA64_OPND_R3_2
)
9685 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_GR
;
9686 if (regno
> 0 && regno
< 4)
9687 gr_values
[regno
].known
= 0;
9689 else if (idesc
->operands
[i
] == IA64_OPND_P1
9690 || idesc
->operands
[i
] == IA64_OPND_P2
)
9692 int regno
= CURR_SLOT
.opnd
[i
].X_add_number
- REG_P
;
9693 qp_changemask
|= (valueT
) 1 << regno
;
9695 else if (idesc
->operands
[i
] == IA64_OPND_PR
)
9697 if (idesc
->operands
[2] & (valueT
) 0x10000)
9698 qp_changemask
= ~(valueT
) 0x1FFFF | idesc
->operands
[2];
9700 qp_changemask
= idesc
->operands
[2];
9703 else if (idesc
->operands
[i
] == IA64_OPND_PR_ROT
)
9705 if (idesc
->operands
[1] & ((valueT
) 1 << 43))
9706 qp_changemask
= -((valueT
) 1 << 44) | idesc
->operands
[1];
9708 qp_changemask
= idesc
->operands
[1];
9709 qp_changemask
&= ~(valueT
) 0xFFFF;
9714 /* Always clear qp branch flags on any PR change. */
9715 /* FIXME there may be exceptions for certain compares. */
9716 clear_qp_branch_flag (qp_changemask
);
9718 /* Invalidate rotating registers on insns which affect RRBs in CFM. */
9719 if (idesc
->flags
& IA64_OPCODE_MOD_RRBS
)
9721 qp_changemask
|= ~(valueT
) 0xFFFF;
9722 if (strcmp (idesc
->name
, "clrrrb.pr") != 0)
9724 for (i
= 32; i
< 32 + md
.rot
.num_regs
; i
++)
9725 gr_values
[i
].known
= 0;
9727 clear_qp_mutex (qp_changemask
);
9728 clear_qp_implies (qp_changemask
, qp_changemask
);
9730 /* After a call, all register values are undefined, except those marked
9732 else if (strncmp (idesc
->name
, "br.call", 6) == 0
9733 || strncmp (idesc
->name
, "brl.call", 7) == 0)
9735 /* FIXME keep GR values which are marked as "safe_across_calls" */
9736 clear_register_values ();
9737 clear_qp_mutex (~qp_safe_across_calls
);
9738 clear_qp_implies (~qp_safe_across_calls
, ~qp_safe_across_calls
);
9739 clear_qp_branch_flag (~qp_safe_across_calls
);
9741 else if (is_interruption_or_rfi (idesc
)
9742 || is_taken_branch (idesc
))
9744 clear_register_values ();
9745 clear_qp_mutex (~(valueT
) 0);
9746 clear_qp_implies (~(valueT
) 0, ~(valueT
) 0);
9748 /* Look for mutex and implies relations. */
9749 else if ((idesc
->operands
[0] == IA64_OPND_P1
9750 || idesc
->operands
[0] == IA64_OPND_P2
)
9751 && (idesc
->operands
[1] == IA64_OPND_P1
9752 || idesc
->operands
[1] == IA64_OPND_P2
))
9754 int p1
= CURR_SLOT
.opnd
[0].X_add_number
- REG_P
;
9755 int p2
= CURR_SLOT
.opnd
[1].X_add_number
- REG_P
;
9756 valueT p1mask
= (p1
!= 0) ? (valueT
) 1 << p1
: 0;
9757 valueT p2mask
= (p2
!= 0) ? (valueT
) 1 << p2
: 0;
9759 /* If both PRs are PR0, we can't really do anything. */
9760 if (p1
== 0 && p2
== 0)
9763 fprintf (stderr
, " Ignoring PRs due to inclusion of p0\n");
9765 /* In general, clear mutexes and implies which include P1 or P2,
9766 with the following exceptions. */
9767 else if (has_suffix_p (idesc
->name
, ".or.andcm")
9768 || has_suffix_p (idesc
->name
, ".and.orcm"))
9770 clear_qp_implies (p2mask
, p1mask
);
9772 else if (has_suffix_p (idesc
->name
, ".andcm")
9773 || has_suffix_p (idesc
->name
, ".and"))
9775 clear_qp_implies (0, p1mask
| p2mask
);
9777 else if (has_suffix_p (idesc
->name
, ".orcm")
9778 || has_suffix_p (idesc
->name
, ".or"))
9780 clear_qp_mutex (p1mask
| p2mask
);
9781 clear_qp_implies (p1mask
| p2mask
, 0);
9787 clear_qp_implies (p1mask
| p2mask
, p1mask
| p2mask
);
9789 /* If one of the PRs is PR0, we call clear_qp_mutex. */
9790 if (p1
== 0 || p2
== 0)
9791 clear_qp_mutex (p1mask
| p2mask
);
9793 added
= update_qp_mutex (p1mask
| p2mask
);
9795 if (CURR_SLOT
.qp_regno
== 0
9796 || has_suffix_p (idesc
->name
, ".unc"))
9798 if (added
== 0 && p1
&& p2
)
9799 add_qp_mutex (p1mask
| p2mask
);
9800 if (CURR_SLOT
.qp_regno
!= 0)
9803 add_qp_imply (p1
, CURR_SLOT
.qp_regno
);
9805 add_qp_imply (p2
, CURR_SLOT
.qp_regno
);
9810 /* Look for mov imm insns into GRs. */
9811 else if (idesc
->operands
[0] == IA64_OPND_R1
9812 && (idesc
->operands
[1] == IA64_OPND_IMM22
9813 || idesc
->operands
[1] == IA64_OPND_IMMU64
)
9814 && CURR_SLOT
.opnd
[1].X_op
== O_constant
9815 && (strcmp (idesc
->name
, "mov") == 0
9816 || strcmp (idesc
->name
, "movl") == 0))
9818 int regno
= CURR_SLOT
.opnd
[0].X_add_number
- REG_GR
;
9819 if (regno
> 0 && regno
< NELEMS (gr_values
))
9821 gr_values
[regno
].known
= 1;
9822 gr_values
[regno
].value
= CURR_SLOT
.opnd
[1].X_add_number
;
9823 gr_values
[regno
].path
= md
.path
;
9826 fprintf (stderr
, " Know gr%d = ", regno
);
9827 fprintf_vma (stderr
, gr_values
[regno
].value
);
9828 fputs ("\n", stderr
);
9832 /* Look for dep.z imm insns. */
9833 else if (idesc
->operands
[0] == IA64_OPND_R1
9834 && idesc
->operands
[1] == IA64_OPND_IMM8
9835 && strcmp (idesc
->name
, "dep.z") == 0)
9837 int regno
= CURR_SLOT
.opnd
[0].X_add_number
- REG_GR
;
9838 if (regno
> 0 && regno
< NELEMS (gr_values
))
9840 valueT value
= CURR_SLOT
.opnd
[1].X_add_number
;
9842 if (CURR_SLOT
.opnd
[3].X_add_number
< 64)
9843 value
&= ((valueT
)1 << CURR_SLOT
.opnd
[3].X_add_number
) - 1;
9844 value
<<= CURR_SLOT
.opnd
[2].X_add_number
;
9845 gr_values
[regno
].known
= 1;
9846 gr_values
[regno
].value
= value
;
9847 gr_values
[regno
].path
= md
.path
;
9850 fprintf (stderr
, " Know gr%d = ", regno
);
9851 fprintf_vma (stderr
, gr_values
[regno
].value
);
9852 fputs ("\n", stderr
);
9858 clear_qp_mutex (qp_changemask
);
9859 clear_qp_implies (qp_changemask
, qp_changemask
);
9863 /* Return whether the given predicate registers are currently mutex. */
9866 qp_mutex (p1
, p2
, path
)
9876 mask
= ((valueT
) 1 << p1
) | (valueT
) 1 << p2
;
9877 for (i
= 0; i
< qp_mutexeslen
; i
++)
9879 if (qp_mutexes
[i
].path
>= path
9880 && (qp_mutexes
[i
].prmask
& mask
) == mask
)
9887 /* Return whether the given resource is in the given insn's list of chks
9888 Return 1 if the conflict is absolutely determined, 2 if it's a potential
9892 resources_match (rs
, idesc
, note
, qp_regno
, path
)
9894 struct ia64_opcode
*idesc
;
9899 struct rsrc specs
[MAX_SPECS
];
9902 /* If the marked resource's qp_regno and the given qp_regno are mutex,
9903 we don't need to check. One exception is note 11, which indicates that
9904 target predicates are written regardless of PR[qp]. */
9905 if (qp_mutex (rs
->qp_regno
, qp_regno
, path
)
9909 count
= specify_resource (rs
->dependency
, idesc
, DV_CHK
, specs
, note
, path
);
9912 /* UNAT checking is a bit more specific than other resources */
9913 if (rs
->dependency
->specifier
== IA64_RS_AR_UNAT
9914 && specs
[count
].mem_offset
.hint
9915 && rs
->mem_offset
.hint
)
9917 if (rs
->mem_offset
.base
== specs
[count
].mem_offset
.base
)
9919 if (((rs
->mem_offset
.offset
>> 3) & 0x3F) ==
9920 ((specs
[count
].mem_offset
.offset
>> 3) & 0x3F))
9927 /* Skip apparent PR write conflicts where both writes are an AND or both
9928 writes are an OR. */
9929 if (rs
->dependency
->specifier
== IA64_RS_PR
9930 || rs
->dependency
->specifier
== IA64_RS_PRr
9931 || rs
->dependency
->specifier
== IA64_RS_PR63
)
9933 if (specs
[count
].cmp_type
!= CMP_NONE
9934 && specs
[count
].cmp_type
== rs
->cmp_type
)
9937 fprintf (stderr
, " %s on parallel compare allowed (PR%d)\n",
9938 dv_mode
[rs
->dependency
->mode
],
9939 rs
->dependency
->specifier
!= IA64_RS_PR63
?
9940 specs
[count
].index
: 63);
9945 " %s on parallel compare conflict %s vs %s on PR%d\n",
9946 dv_mode
[rs
->dependency
->mode
],
9947 dv_cmp_type
[rs
->cmp_type
],
9948 dv_cmp_type
[specs
[count
].cmp_type
],
9949 rs
->dependency
->specifier
!= IA64_RS_PR63
?
9950 specs
[count
].index
: 63);
9954 /* If either resource is not specific, conservatively assume a conflict
9956 if (!specs
[count
].specific
|| !rs
->specific
)
9958 else if (specs
[count
].index
== rs
->index
)
9965 /* Indicate an instruction group break; if INSERT_STOP is non-zero, then
9966 insert a stop to create the break. Update all resource dependencies
9967 appropriately. If QP_REGNO is non-zero, only apply the break to resources
9968 which use the same QP_REGNO and have the link_to_qp_branch flag set.
9969 If SAVE_CURRENT is non-zero, don't affect resources marked by the current
9973 insn_group_break (insert_stop
, qp_regno
, save_current
)
9980 if (insert_stop
&& md
.num_slots_in_use
> 0)
9981 PREV_SLOT
.end_of_insn_group
= 1;
9985 fprintf (stderr
, " Insn group break%s",
9986 (insert_stop
? " (w/stop)" : ""));
9988 fprintf (stderr
, " effective for QP=%d", qp_regno
);
9989 fprintf (stderr
, "\n");
9993 while (i
< regdepslen
)
9995 const struct ia64_dependency
*dep
= regdeps
[i
].dependency
;
9998 && regdeps
[i
].qp_regno
!= qp_regno
)
10005 && CURR_SLOT
.src_file
== regdeps
[i
].file
10006 && CURR_SLOT
.src_line
== regdeps
[i
].line
)
10012 /* clear dependencies which are automatically cleared by a stop, or
10013 those that have reached the appropriate state of insn serialization */
10014 if (dep
->semantics
== IA64_DVS_IMPLIED
10015 || dep
->semantics
== IA64_DVS_IMPLIEDF
10016 || regdeps
[i
].insn_srlz
== STATE_SRLZ
)
10018 print_dependency ("Removing", i
);
10019 regdeps
[i
] = regdeps
[--regdepslen
];
10023 if (dep
->semantics
== IA64_DVS_DATA
10024 || dep
->semantics
== IA64_DVS_INSTR
10025 || dep
->semantics
== IA64_DVS_SPECIFIC
)
10027 if (regdeps
[i
].insn_srlz
== STATE_NONE
)
10028 regdeps
[i
].insn_srlz
= STATE_STOP
;
10029 if (regdeps
[i
].data_srlz
== STATE_NONE
)
10030 regdeps
[i
].data_srlz
= STATE_STOP
;
10037 /* Add the given resource usage spec to the list of active dependencies. */
10040 mark_resource (idesc
, dep
, spec
, depind
, path
)
10041 struct ia64_opcode
*idesc ATTRIBUTE_UNUSED
;
10042 const struct ia64_dependency
*dep ATTRIBUTE_UNUSED
;
10047 if (regdepslen
== regdepstotlen
)
10049 regdepstotlen
+= 20;
10050 regdeps
= (struct rsrc
*)
10051 xrealloc ((void *) regdeps
,
10052 regdepstotlen
* sizeof (struct rsrc
));
10055 regdeps
[regdepslen
] = *spec
;
10056 regdeps
[regdepslen
].depind
= depind
;
10057 regdeps
[regdepslen
].path
= path
;
10058 regdeps
[regdepslen
].file
= CURR_SLOT
.src_file
;
10059 regdeps
[regdepslen
].line
= CURR_SLOT
.src_line
;
10061 print_dependency ("Adding", regdepslen
);
10067 print_dependency (action
, depind
)
10068 const char *action
;
10073 fprintf (stderr
, " %s %s '%s'",
10074 action
, dv_mode
[(regdeps
[depind
].dependency
)->mode
],
10075 (regdeps
[depind
].dependency
)->name
);
10076 if (regdeps
[depind
].specific
&& regdeps
[depind
].index
>= 0)
10077 fprintf (stderr
, " (%d)", regdeps
[depind
].index
);
10078 if (regdeps
[depind
].mem_offset
.hint
)
10080 fputs (" ", stderr
);
10081 fprintf_vma (stderr
, regdeps
[depind
].mem_offset
.base
);
10082 fputs ("+", stderr
);
10083 fprintf_vma (stderr
, regdeps
[depind
].mem_offset
.offset
);
10085 fprintf (stderr
, "\n");
10090 instruction_serialization ()
10094 fprintf (stderr
, " Instruction serialization\n");
10095 for (i
= 0; i
< regdepslen
; i
++)
10096 if (regdeps
[i
].insn_srlz
== STATE_STOP
)
10097 regdeps
[i
].insn_srlz
= STATE_SRLZ
;
10101 data_serialization ()
10105 fprintf (stderr
, " Data serialization\n");
10106 while (i
< regdepslen
)
10108 if (regdeps
[i
].data_srlz
== STATE_STOP
10109 /* Note: as of 991210, all "other" dependencies are cleared by a
10110 data serialization. This might change with new tables */
10111 || (regdeps
[i
].dependency
)->semantics
== IA64_DVS_OTHER
)
10113 print_dependency ("Removing", i
);
10114 regdeps
[i
] = regdeps
[--regdepslen
];
10121 /* Insert stops and serializations as needed to avoid DVs. */
10124 remove_marked_resource (rs
)
10127 switch (rs
->dependency
->semantics
)
10129 case IA64_DVS_SPECIFIC
:
10131 fprintf (stderr
, "Implementation-specific, assume worst case...\n");
10132 /* ...fall through... */
10133 case IA64_DVS_INSTR
:
10135 fprintf (stderr
, "Inserting instr serialization\n");
10136 if (rs
->insn_srlz
< STATE_STOP
)
10137 insn_group_break (1, 0, 0);
10138 if (rs
->insn_srlz
< STATE_SRLZ
)
10140 struct slot oldslot
= CURR_SLOT
;
10141 /* Manually jam a srlz.i insn into the stream */
10142 memset (&CURR_SLOT
, 0, sizeof (CURR_SLOT
));
10143 CURR_SLOT
.user_template
= -1;
10144 CURR_SLOT
.idesc
= ia64_find_opcode ("srlz.i");
10145 instruction_serialization ();
10146 md
.curr_slot
= (md
.curr_slot
+ 1) % NUM_SLOTS
;
10147 if (++md
.num_slots_in_use
>= NUM_SLOTS
)
10148 emit_one_bundle ();
10149 CURR_SLOT
= oldslot
;
10151 insn_group_break (1, 0, 0);
10153 case IA64_DVS_OTHER
: /* as of rev2 (991220) of the DV tables, all
10154 "other" types of DV are eliminated
10155 by a data serialization */
10156 case IA64_DVS_DATA
:
10158 fprintf (stderr
, "Inserting data serialization\n");
10159 if (rs
->data_srlz
< STATE_STOP
)
10160 insn_group_break (1, 0, 0);
10162 struct slot oldslot
= CURR_SLOT
;
10163 /* Manually jam a srlz.d insn into the stream */
10164 memset (&CURR_SLOT
, 0, sizeof (CURR_SLOT
));
10165 CURR_SLOT
.user_template
= -1;
10166 CURR_SLOT
.idesc
= ia64_find_opcode ("srlz.d");
10167 data_serialization ();
10168 md
.curr_slot
= (md
.curr_slot
+ 1) % NUM_SLOTS
;
10169 if (++md
.num_slots_in_use
>= NUM_SLOTS
)
10170 emit_one_bundle ();
10171 CURR_SLOT
= oldslot
;
10174 case IA64_DVS_IMPLIED
:
10175 case IA64_DVS_IMPLIEDF
:
10177 fprintf (stderr
, "Inserting stop\n");
10178 insn_group_break (1, 0, 0);
10185 /* Check the resources used by the given opcode against the current dependency
10188 The check is run once for each execution path encountered. In this case,
10189 a unique execution path is the sequence of instructions following a code
10190 entry point, e.g. the following has three execution paths, one starting
10191 at L0, one at L1, and one at L2.
10200 check_dependencies (idesc
)
10201 struct ia64_opcode
*idesc
;
10203 const struct ia64_opcode_dependency
*opdeps
= idesc
->dependencies
;
10207 /* Note that the number of marked resources may change within the
10208 loop if in auto mode. */
10210 while (i
< regdepslen
)
10212 struct rsrc
*rs
= ®deps
[i
];
10213 const struct ia64_dependency
*dep
= rs
->dependency
;
10216 int start_over
= 0;
10218 if (dep
->semantics
== IA64_DVS_NONE
10219 || (chkind
= depends_on (rs
->depind
, idesc
)) == -1)
10225 note
= NOTE (opdeps
->chks
[chkind
]);
10227 /* Check this resource against each execution path seen thus far. */
10228 for (path
= 0; path
<= md
.path
; path
++)
10232 /* If the dependency wasn't on the path being checked, ignore it. */
10233 if (rs
->path
< path
)
10236 /* If the QP for this insn implies a QP which has branched, don't
10237 bother checking. Ed. NOTE: I don't think this check is terribly
10238 useful; what's the point of generating code which will only be
10239 reached if its QP is zero?
10240 This code was specifically inserted to handle the following code,
10241 based on notes from Intel's DV checking code, where p1 implies p2.
10247 if (CURR_SLOT
.qp_regno
!= 0)
10251 for (implies
= 0; implies
< qp_implieslen
; implies
++)
10253 if (qp_implies
[implies
].path
>= path
10254 && qp_implies
[implies
].p1
== CURR_SLOT
.qp_regno
10255 && qp_implies
[implies
].p2_branched
)
10265 if ((matchtype
= resources_match (rs
, idesc
, note
,
10266 CURR_SLOT
.qp_regno
, path
)) != 0)
10269 char pathmsg
[256] = "";
10270 char indexmsg
[256] = "";
10271 int certain
= (matchtype
== 1 && CURR_SLOT
.qp_regno
== 0);
10274 sprintf (pathmsg
, " when entry is at label '%s'",
10275 md
.entry_labels
[path
- 1]);
10276 if (matchtype
== 1 && rs
->index
>= 0)
10277 sprintf (indexmsg
, ", specific resource number is %d",
10279 sprintf (msg
, "Use of '%s' %s %s dependency '%s' (%s)%s%s",
10281 (certain
? "violates" : "may violate"),
10282 dv_mode
[dep
->mode
], dep
->name
,
10283 dv_sem
[dep
->semantics
],
10284 pathmsg
, indexmsg
);
10286 if (md
.explicit_mode
)
10288 as_warn ("%s", msg
);
10289 if (path
< md
.path
)
10290 as_warn (_("Only the first path encountering the conflict "
10292 as_warn_where (rs
->file
, rs
->line
,
10293 _("This is the location of the "
10294 "conflicting usage"));
10295 /* Don't bother checking other paths, to avoid duplicating
10296 the same warning */
10302 fprintf (stderr
, "%s @ %s:%d\n", msg
, rs
->file
, rs
->line
);
10304 remove_marked_resource (rs
);
10306 /* since the set of dependencies has changed, start over */
10307 /* FIXME -- since we're removing dvs as we go, we
10308 probably don't really need to start over... */
10321 /* Register new dependencies based on the given opcode. */
10324 mark_resources (idesc
)
10325 struct ia64_opcode
*idesc
;
10328 const struct ia64_opcode_dependency
*opdeps
= idesc
->dependencies
;
10329 int add_only_qp_reads
= 0;
10331 /* A conditional branch only uses its resources if it is taken; if it is
10332 taken, we stop following that path. The other branch types effectively
10333 *always* write their resources. If it's not taken, register only QP
10335 if (is_conditional_branch (idesc
) || is_interruption_or_rfi (idesc
))
10337 add_only_qp_reads
= 1;
10341 fprintf (stderr
, "Registering '%s' resource usage\n", idesc
->name
);
10343 for (i
= 0; i
< opdeps
->nregs
; i
++)
10345 const struct ia64_dependency
*dep
;
10346 struct rsrc specs
[MAX_SPECS
];
10351 dep
= ia64_find_dependency (opdeps
->regs
[i
]);
10352 note
= NOTE (opdeps
->regs
[i
]);
10354 if (add_only_qp_reads
10355 && !(dep
->mode
== IA64_DV_WAR
10356 && (dep
->specifier
== IA64_RS_PR
10357 || dep
->specifier
== IA64_RS_PRr
10358 || dep
->specifier
== IA64_RS_PR63
)))
10361 count
= specify_resource (dep
, idesc
, DV_REG
, specs
, note
, md
.path
);
10363 while (count
-- > 0)
10365 mark_resource (idesc
, dep
, &specs
[count
],
10366 DEP (opdeps
->regs
[i
]), md
.path
);
10369 /* The execution path may affect register values, which may in turn
10370 affect which indirect-access resources are accessed. */
10371 switch (dep
->specifier
)
10375 case IA64_RS_CPUID
:
10383 for (path
= 0; path
< md
.path
; path
++)
10385 count
= specify_resource (dep
, idesc
, DV_REG
, specs
, note
, path
);
10386 while (count
-- > 0)
10387 mark_resource (idesc
, dep
, &specs
[count
],
10388 DEP (opdeps
->regs
[i
]), path
);
10395 /* Remove dependencies when they no longer apply. */
10398 update_dependencies (idesc
)
10399 struct ia64_opcode
*idesc
;
10403 if (strcmp (idesc
->name
, "srlz.i") == 0)
10405 instruction_serialization ();
10407 else if (strcmp (idesc
->name
, "srlz.d") == 0)
10409 data_serialization ();
10411 else if (is_interruption_or_rfi (idesc
)
10412 || is_taken_branch (idesc
))
10414 /* Although technically the taken branch doesn't clear dependencies
10415 which require a srlz.[id], we don't follow the branch; the next
10416 instruction is assumed to start with a clean slate. */
10420 else if (is_conditional_branch (idesc
)
10421 && CURR_SLOT
.qp_regno
!= 0)
10423 int is_call
= strstr (idesc
->name
, ".call") != NULL
;
10425 for (i
= 0; i
< qp_implieslen
; i
++)
10427 /* If the conditional branch's predicate is implied by the predicate
10428 in an existing dependency, remove that dependency. */
10429 if (qp_implies
[i
].p2
== CURR_SLOT
.qp_regno
)
10432 /* Note that this implied predicate takes a branch so that if
10433 a later insn generates a DV but its predicate implies this
10434 one, we can avoid the false DV warning. */
10435 qp_implies
[i
].p2_branched
= 1;
10436 while (depind
< regdepslen
)
10438 if (regdeps
[depind
].qp_regno
== qp_implies
[i
].p1
)
10440 print_dependency ("Removing", depind
);
10441 regdeps
[depind
] = regdeps
[--regdepslen
];
10448 /* Any marked resources which have this same predicate should be
10449 cleared, provided that the QP hasn't been modified between the
10450 marking instruction and the branch. */
10453 insn_group_break (0, CURR_SLOT
.qp_regno
, 1);
10458 while (i
< regdepslen
)
10460 if (regdeps
[i
].qp_regno
== CURR_SLOT
.qp_regno
10461 && regdeps
[i
].link_to_qp_branch
10462 && (regdeps
[i
].file
!= CURR_SLOT
.src_file
10463 || regdeps
[i
].line
!= CURR_SLOT
.src_line
))
10465 /* Treat like a taken branch */
10466 print_dependency ("Removing", i
);
10467 regdeps
[i
] = regdeps
[--regdepslen
];
10476 /* Examine the current instruction for dependency violations. */
10480 struct ia64_opcode
*idesc
;
10484 fprintf (stderr
, "Checking %s for violations (line %d, %d/%d)\n",
10485 idesc
->name
, CURR_SLOT
.src_line
,
10486 idesc
->dependencies
->nchks
,
10487 idesc
->dependencies
->nregs
);
10490 /* Look through the list of currently marked resources; if the current
10491 instruction has the dependency in its chks list which uses that resource,
10492 check against the specific resources used. */
10493 check_dependencies (idesc
);
10495 /* Look up the instruction's regdeps (RAW writes, WAW writes, and WAR reads),
10496 then add them to the list of marked resources. */
10497 mark_resources (idesc
);
10499 /* There are several types of dependency semantics, and each has its own
10500 requirements for being cleared
10502 Instruction serialization (insns separated by interruption, rfi, or
10503 writer + srlz.i + reader, all in separate groups) clears DVS_INSTR.
10505 Data serialization (instruction serialization, or writer + srlz.d +
10506 reader, where writer and srlz.d are in separate groups) clears
10507 DVS_DATA. (This also clears DVS_OTHER, but that is not guaranteed to
10508 always be the case).
10510 Instruction group break (groups separated by stop, taken branch,
10511 interruption or rfi) clears DVS_IMPLIED and DVS_IMPLIEDF.
10513 update_dependencies (idesc
);
10515 /* Sometimes, knowing a register value allows us to avoid giving a false DV
10516 warning. Keep track of as many as possible that are useful. */
10517 note_register_values (idesc
);
10519 /* We don't need or want this anymore. */
10520 md
.mem_offset
.hint
= 0;
10525 /* Translate one line of assembly. Pseudo ops and labels do not show
10531 char *saved_input_line_pointer
, *mnemonic
;
10532 const struct pseudo_opcode
*pdesc
;
10533 struct ia64_opcode
*idesc
;
10534 unsigned char qp_regno
;
10535 unsigned int flags
;
10538 saved_input_line_pointer
= input_line_pointer
;
10539 input_line_pointer
= str
;
10541 /* extract the opcode (mnemonic): */
10543 mnemonic
= input_line_pointer
;
10544 ch
= get_symbol_end ();
10545 pdesc
= (struct pseudo_opcode
*) hash_find (md
.pseudo_hash
, mnemonic
);
10548 *input_line_pointer
= ch
;
10549 (*pdesc
->handler
) (pdesc
->arg
);
10553 /* Find the instruction descriptor matching the arguments. */
10555 idesc
= ia64_find_opcode (mnemonic
);
10556 *input_line_pointer
= ch
;
10559 as_bad ("Unknown opcode `%s'", mnemonic
);
10563 idesc
= parse_operands (idesc
);
10567 /* Handle the dynamic ops we can handle now: */
10568 if (idesc
->type
== IA64_TYPE_DYN
)
10570 if (strcmp (idesc
->name
, "add") == 0)
10572 if (CURR_SLOT
.opnd
[2].X_op
== O_register
10573 && CURR_SLOT
.opnd
[2].X_add_number
< 4)
10577 ia64_free_opcode (idesc
);
10578 idesc
= ia64_find_opcode (mnemonic
);
10580 else if (strcmp (idesc
->name
, "mov") == 0)
10582 enum ia64_opnd opnd1
, opnd2
;
10585 opnd1
= idesc
->operands
[0];
10586 opnd2
= idesc
->operands
[1];
10587 if (opnd1
== IA64_OPND_AR3
)
10589 else if (opnd2
== IA64_OPND_AR3
)
10593 if (CURR_SLOT
.opnd
[rop
].X_op
== O_register
)
10595 if (ar_is_only_in_integer_unit (CURR_SLOT
.opnd
[rop
].X_add_number
))
10596 mnemonic
= "mov.i";
10597 else if (ar_is_only_in_memory_unit (CURR_SLOT
.opnd
[rop
].X_add_number
))
10598 mnemonic
= "mov.m";
10606 ia64_free_opcode (idesc
);
10607 idesc
= ia64_find_opcode (mnemonic
);
10608 while (idesc
!= NULL
10609 && (idesc
->operands
[0] != opnd1
10610 || idesc
->operands
[1] != opnd2
))
10611 idesc
= get_next_opcode (idesc
);
10615 else if (strcmp (idesc
->name
, "mov.i") == 0
10616 || strcmp (idesc
->name
, "mov.m") == 0)
10618 enum ia64_opnd opnd1
, opnd2
;
10621 opnd1
= idesc
->operands
[0];
10622 opnd2
= idesc
->operands
[1];
10623 if (opnd1
== IA64_OPND_AR3
)
10625 else if (opnd2
== IA64_OPND_AR3
)
10629 if (CURR_SLOT
.opnd
[rop
].X_op
== O_register
)
10632 if (ar_is_only_in_integer_unit (CURR_SLOT
.opnd
[rop
].X_add_number
))
10634 else if (ar_is_only_in_memory_unit (CURR_SLOT
.opnd
[rop
].X_add_number
))
10636 if (unit
!= 'a' && unit
!= idesc
->name
[4])
10637 as_bad ("AR %d cannot be accessed by %c-unit",
10638 (int) (CURR_SLOT
.opnd
[rop
].X_add_number
- REG_AR
),
10642 else if (strcmp (idesc
->name
, "hint.b") == 0)
10648 case hint_b_warning
:
10649 as_warn ("hint.b may be treated as nop");
10652 as_bad ("hint.b shouldn't be used");
10658 if (md
.qp
.X_op
== O_register
)
10660 qp_regno
= md
.qp
.X_add_number
- REG_P
;
10661 md
.qp
.X_op
= O_absent
;
10664 flags
= idesc
->flags
;
10666 if ((flags
& IA64_OPCODE_FIRST
) != 0)
10668 /* The alignment frag has to end with a stop bit only if the
10669 next instruction after the alignment directive has to be
10670 the first instruction in an instruction group. */
10673 while (align_frag
->fr_type
!= rs_align_code
)
10675 align_frag
= align_frag
->fr_next
;
10679 /* align_frag can be NULL if there are directives in
10681 if (align_frag
&& align_frag
->fr_next
== frag_now
)
10682 align_frag
->tc_frag_data
= 1;
10685 insn_group_break (1, 0, 0);
10689 if ((flags
& IA64_OPCODE_NO_PRED
) != 0 && qp_regno
!= 0)
10691 as_bad ("`%s' cannot be predicated", idesc
->name
);
10695 /* Build the instruction. */
10696 CURR_SLOT
.qp_regno
= qp_regno
;
10697 CURR_SLOT
.idesc
= idesc
;
10698 as_where (&CURR_SLOT
.src_file
, &CURR_SLOT
.src_line
);
10699 dwarf2_where (&CURR_SLOT
.debug_line
);
10701 /* Add unwind entry, if there is one. */
10702 if (unwind
.current_entry
)
10704 CURR_SLOT
.unwind_record
= unwind
.current_entry
;
10705 unwind
.current_entry
= NULL
;
10707 if (unwind
.proc_start
&& S_IS_DEFINED (unwind
.proc_start
))
10710 /* Check for dependency violations. */
10714 md
.curr_slot
= (md
.curr_slot
+ 1) % NUM_SLOTS
;
10715 if (++md
.num_slots_in_use
>= NUM_SLOTS
)
10716 emit_one_bundle ();
10718 if ((flags
& IA64_OPCODE_LAST
) != 0)
10719 insn_group_break (1, 0, 0);
10721 md
.last_text_seg
= now_seg
;
10724 input_line_pointer
= saved_input_line_pointer
;
10727 /* Called when symbol NAME cannot be found in the symbol table.
10728 Should be used for dynamic valued symbols only. */
10731 md_undefined_symbol (name
)
10732 char *name ATTRIBUTE_UNUSED
;
10737 /* Called for any expression that can not be recognized. When the
10738 function is called, `input_line_pointer' will point to the start of
10745 switch (*input_line_pointer
)
10748 ++input_line_pointer
;
10750 if (*input_line_pointer
!= ']')
10752 as_bad ("Closing bracket missing");
10757 if (e
->X_op
!= O_register
)
10758 as_bad ("Register expected as index");
10760 ++input_line_pointer
;
10771 ignore_rest_of_line ();
10774 /* Return 1 if it's OK to adjust a reloc by replacing the symbol with
10775 a section symbol plus some offset. For relocs involving @fptr(),
10776 directives we don't want such adjustments since we need to have the
10777 original symbol's name in the reloc. */
10779 ia64_fix_adjustable (fix
)
10782 /* Prevent all adjustments to global symbols */
10783 if (S_IS_EXTERN (fix
->fx_addsy
) || S_IS_WEAK (fix
->fx_addsy
))
10786 switch (fix
->fx_r_type
)
10788 case BFD_RELOC_IA64_FPTR64I
:
10789 case BFD_RELOC_IA64_FPTR32MSB
:
10790 case BFD_RELOC_IA64_FPTR32LSB
:
10791 case BFD_RELOC_IA64_FPTR64MSB
:
10792 case BFD_RELOC_IA64_FPTR64LSB
:
10793 case BFD_RELOC_IA64_LTOFF_FPTR22
:
10794 case BFD_RELOC_IA64_LTOFF_FPTR64I
:
10804 ia64_force_relocation (fix
)
10807 switch (fix
->fx_r_type
)
10809 case BFD_RELOC_IA64_FPTR64I
:
10810 case BFD_RELOC_IA64_FPTR32MSB
:
10811 case BFD_RELOC_IA64_FPTR32LSB
:
10812 case BFD_RELOC_IA64_FPTR64MSB
:
10813 case BFD_RELOC_IA64_FPTR64LSB
:
10815 case BFD_RELOC_IA64_LTOFF22
:
10816 case BFD_RELOC_IA64_LTOFF64I
:
10817 case BFD_RELOC_IA64_LTOFF_FPTR22
:
10818 case BFD_RELOC_IA64_LTOFF_FPTR64I
:
10819 case BFD_RELOC_IA64_PLTOFF22
:
10820 case BFD_RELOC_IA64_PLTOFF64I
:
10821 case BFD_RELOC_IA64_PLTOFF64MSB
:
10822 case BFD_RELOC_IA64_PLTOFF64LSB
:
10824 case BFD_RELOC_IA64_LTOFF22X
:
10825 case BFD_RELOC_IA64_LDXMOV
:
10832 return generic_force_reloc (fix
);
10835 /* Decide from what point a pc-relative relocation is relative to,
10836 relative to the pc-relative fixup. Er, relatively speaking. */
10838 ia64_pcrel_from_section (fix
, sec
)
10842 unsigned long off
= fix
->fx_frag
->fr_address
+ fix
->fx_where
;
10844 if (bfd_get_section_flags (stdoutput
, sec
) & SEC_CODE
)
10851 /* Used to emit section-relative relocs for the dwarf2 debug data. */
10853 ia64_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
10857 expr
.X_op
= O_pseudo_fixup
;
10858 expr
.X_op_symbol
= pseudo_func
[FUNC_SEC_RELATIVE
].u
.sym
;
10859 expr
.X_add_number
= 0;
10860 expr
.X_add_symbol
= symbol
;
10861 emit_expr (&expr
, size
);
10864 /* This is called whenever some data item (not an instruction) needs a
10865 fixup. We pick the right reloc code depending on the byteorder
10866 currently in effect. */
10868 ia64_cons_fix_new (f
, where
, nbytes
, exp
)
10874 bfd_reloc_code_real_type code
;
10879 /* There are no reloc for 8 and 16 bit quantities, but we allow
10880 them here since they will work fine as long as the expression
10881 is fully defined at the end of the pass over the source file. */
10882 case 1: code
= BFD_RELOC_8
; break;
10883 case 2: code
= BFD_RELOC_16
; break;
10885 if (target_big_endian
)
10886 code
= BFD_RELOC_IA64_DIR32MSB
;
10888 code
= BFD_RELOC_IA64_DIR32LSB
;
10892 /* In 32-bit mode, data8 could mean function descriptors too. */
10893 if (exp
->X_op
== O_pseudo_fixup
10894 && exp
->X_op_symbol
10895 && S_GET_VALUE (exp
->X_op_symbol
) == FUNC_IPLT_RELOC
10896 && !(md
.flags
& EF_IA_64_ABI64
))
10898 if (target_big_endian
)
10899 code
= BFD_RELOC_IA64_IPLTMSB
;
10901 code
= BFD_RELOC_IA64_IPLTLSB
;
10902 exp
->X_op
= O_symbol
;
10907 if (target_big_endian
)
10908 code
= BFD_RELOC_IA64_DIR64MSB
;
10910 code
= BFD_RELOC_IA64_DIR64LSB
;
10915 if (exp
->X_op
== O_pseudo_fixup
10916 && exp
->X_op_symbol
10917 && S_GET_VALUE (exp
->X_op_symbol
) == FUNC_IPLT_RELOC
)
10919 if (target_big_endian
)
10920 code
= BFD_RELOC_IA64_IPLTMSB
;
10922 code
= BFD_RELOC_IA64_IPLTLSB
;
10923 exp
->X_op
= O_symbol
;
10929 as_bad ("Unsupported fixup size %d", nbytes
);
10930 ignore_rest_of_line ();
10934 if (exp
->X_op
== O_pseudo_fixup
)
10936 exp
->X_op
= O_symbol
;
10937 code
= ia64_gen_real_reloc_type (exp
->X_op_symbol
, code
);
10938 /* ??? If code unchanged, unsupported. */
10941 fix
= fix_new_exp (f
, where
, nbytes
, exp
, 0, code
);
10942 /* We need to store the byte order in effect in case we're going
10943 to fix an 8 or 16 bit relocation (for which there no real
10944 relocs available). See md_apply_fix3(). */
10945 fix
->tc_fix_data
.bigendian
= target_big_endian
;
10948 /* Return the actual relocation we wish to associate with the pseudo
10949 reloc described by SYM and R_TYPE. SYM should be one of the
10950 symbols in the pseudo_func array, or NULL. */
10952 static bfd_reloc_code_real_type
10953 ia64_gen_real_reloc_type (sym
, r_type
)
10954 struct symbol
*sym
;
10955 bfd_reloc_code_real_type r_type
;
10957 bfd_reloc_code_real_type
new = 0;
10958 const char *type
= NULL
, *suffix
= "";
10965 switch (S_GET_VALUE (sym
))
10967 case FUNC_FPTR_RELATIVE
:
10970 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_FPTR64I
; break;
10971 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_FPTR32MSB
; break;
10972 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_FPTR32LSB
; break;
10973 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_FPTR64MSB
; break;
10974 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_FPTR64LSB
; break;
10975 default: type
= "FPTR"; break;
10979 case FUNC_GP_RELATIVE
:
10982 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_GPREL22
; break;
10983 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_GPREL64I
; break;
10984 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_GPREL32MSB
; break;
10985 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_GPREL32LSB
; break;
10986 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_GPREL64MSB
; break;
10987 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_GPREL64LSB
; break;
10988 default: type
= "GPREL"; break;
10992 case FUNC_LT_RELATIVE
:
10995 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_LTOFF22
; break;
10996 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_LTOFF64I
; break;
10997 default: type
= "LTOFF"; break;
11001 case FUNC_LT_RELATIVE_X
:
11004 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_LTOFF22X
; break;
11005 default: type
= "LTOFF"; suffix
= "X"; break;
11009 case FUNC_PC_RELATIVE
:
11012 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_PCREL22
; break;
11013 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_PCREL64I
; break;
11014 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_PCREL32MSB
; break;
11015 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_PCREL32LSB
; break;
11016 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_PCREL64MSB
; break;
11017 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_PCREL64LSB
; break;
11018 default: type
= "PCREL"; break;
11022 case FUNC_PLT_RELATIVE
:
11025 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_PLTOFF22
; break;
11026 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_PLTOFF64I
; break;
11027 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_PLTOFF64MSB
;break;
11028 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_PLTOFF64LSB
;break;
11029 default: type
= "PLTOFF"; break;
11033 case FUNC_SEC_RELATIVE
:
11036 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_SECREL32MSB
;break;
11037 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_SECREL32LSB
;break;
11038 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_SECREL64MSB
;break;
11039 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_SECREL64LSB
;break;
11040 default: type
= "SECREL"; break;
11044 case FUNC_SEG_RELATIVE
:
11047 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_SEGREL32MSB
;break;
11048 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_SEGREL32LSB
;break;
11049 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_SEGREL64MSB
;break;
11050 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_SEGREL64LSB
;break;
11051 default: type
= "SEGREL"; break;
11055 case FUNC_LTV_RELATIVE
:
11058 case BFD_RELOC_IA64_DIR32MSB
: new = BFD_RELOC_IA64_LTV32MSB
; break;
11059 case BFD_RELOC_IA64_DIR32LSB
: new = BFD_RELOC_IA64_LTV32LSB
; break;
11060 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_LTV64MSB
; break;
11061 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_LTV64LSB
; break;
11062 default: type
= "LTV"; break;
11066 case FUNC_LT_FPTR_RELATIVE
:
11069 case BFD_RELOC_IA64_IMM22
:
11070 new = BFD_RELOC_IA64_LTOFF_FPTR22
; break;
11071 case BFD_RELOC_IA64_IMM64
:
11072 new = BFD_RELOC_IA64_LTOFF_FPTR64I
; break;
11073 case BFD_RELOC_IA64_DIR32MSB
:
11074 new = BFD_RELOC_IA64_LTOFF_FPTR32MSB
; break;
11075 case BFD_RELOC_IA64_DIR32LSB
:
11076 new = BFD_RELOC_IA64_LTOFF_FPTR32LSB
; break;
11077 case BFD_RELOC_IA64_DIR64MSB
:
11078 new = BFD_RELOC_IA64_LTOFF_FPTR64MSB
; break;
11079 case BFD_RELOC_IA64_DIR64LSB
:
11080 new = BFD_RELOC_IA64_LTOFF_FPTR64LSB
; break;
11082 type
= "LTOFF_FPTR"; break;
11086 case FUNC_TP_RELATIVE
:
11089 case BFD_RELOC_IA64_IMM14
: new = BFD_RELOC_IA64_TPREL14
; break;
11090 case BFD_RELOC_IA64_IMM22
: new = BFD_RELOC_IA64_TPREL22
; break;
11091 case BFD_RELOC_IA64_IMM64
: new = BFD_RELOC_IA64_TPREL64I
; break;
11092 case BFD_RELOC_IA64_DIR64MSB
: new = BFD_RELOC_IA64_TPREL64MSB
; break;
11093 case BFD_RELOC_IA64_DIR64LSB
: new = BFD_RELOC_IA64_TPREL64LSB
; break;
11094 default: type
= "TPREL"; break;
11098 case FUNC_LT_TP_RELATIVE
:
11101 case BFD_RELOC_IA64_IMM22
:
11102 new = BFD_RELOC_IA64_LTOFF_TPREL22
; break;
11104 type
= "LTOFF_TPREL"; break;
11108 case FUNC_DTP_MODULE
:
11111 case BFD_RELOC_IA64_DIR64MSB
:
11112 new = BFD_RELOC_IA64_DTPMOD64MSB
; break;
11113 case BFD_RELOC_IA64_DIR64LSB
:
11114 new = BFD_RELOC_IA64_DTPMOD64LSB
; break;
11116 type
= "DTPMOD"; break;
11120 case FUNC_LT_DTP_MODULE
:
11123 case BFD_RELOC_IA64_IMM22
:
11124 new = BFD_RELOC_IA64_LTOFF_DTPMOD22
; break;
11126 type
= "LTOFF_DTPMOD"; break;
11130 case FUNC_DTP_RELATIVE
:
11133 case BFD_RELOC_IA64_DIR32MSB
:
11134 new = BFD_RELOC_IA64_DTPREL32MSB
; break;
11135 case BFD_RELOC_IA64_DIR32LSB
:
11136 new = BFD_RELOC_IA64_DTPREL32LSB
; break;
11137 case BFD_RELOC_IA64_DIR64MSB
:
11138 new = BFD_RELOC_IA64_DTPREL64MSB
; break;
11139 case BFD_RELOC_IA64_DIR64LSB
:
11140 new = BFD_RELOC_IA64_DTPREL64LSB
; break;
11141 case BFD_RELOC_IA64_IMM14
:
11142 new = BFD_RELOC_IA64_DTPREL14
; break;
11143 case BFD_RELOC_IA64_IMM22
:
11144 new = BFD_RELOC_IA64_DTPREL22
; break;
11145 case BFD_RELOC_IA64_IMM64
:
11146 new = BFD_RELOC_IA64_DTPREL64I
; break;
11148 type
= "DTPREL"; break;
11152 case FUNC_LT_DTP_RELATIVE
:
11155 case BFD_RELOC_IA64_IMM22
:
11156 new = BFD_RELOC_IA64_LTOFF_DTPREL22
; break;
11158 type
= "LTOFF_DTPREL"; break;
11162 case FUNC_IPLT_RELOC
:
11165 case BFD_RELOC_IA64_IPLTMSB
: return r_type
;
11166 case BFD_RELOC_IA64_IPLTLSB
: return r_type
;
11167 default: type
= "IPLT"; break;
11185 case BFD_RELOC_IA64_DIR32MSB
: width
= 32; suffix
= "MSB"; break;
11186 case BFD_RELOC_IA64_DIR32LSB
: width
= 32; suffix
= "LSB"; break;
11187 case BFD_RELOC_IA64_DIR64MSB
: width
= 64; suffix
= "MSB"; break;
11188 case BFD_RELOC_IA64_DIR64LSB
: width
= 64; suffix
= "LSB"; break;
11189 case BFD_RELOC_IA64_IMM14
: width
= 14; break;
11190 case BFD_RELOC_IA64_IMM22
: width
= 22; break;
11191 case BFD_RELOC_IA64_IMM64
: width
= 64; suffix
= "I"; break;
11195 /* This should be an error, but since previously there wasn't any
11196 diagnostic here, dont't make it fail because of this for now. */
11197 as_warn ("Cannot express %s%d%s relocation", type
, width
, suffix
);
11202 /* Here is where generate the appropriate reloc for pseudo relocation
11205 ia64_validate_fix (fix
)
11208 switch (fix
->fx_r_type
)
11210 case BFD_RELOC_IA64_FPTR64I
:
11211 case BFD_RELOC_IA64_FPTR32MSB
:
11212 case BFD_RELOC_IA64_FPTR64LSB
:
11213 case BFD_RELOC_IA64_LTOFF_FPTR22
:
11214 case BFD_RELOC_IA64_LTOFF_FPTR64I
:
11215 if (fix
->fx_offset
!= 0)
11216 as_bad_where (fix
->fx_file
, fix
->fx_line
,
11217 "No addend allowed in @fptr() relocation");
11225 fix_insn (fix
, odesc
, value
)
11227 const struct ia64_operand
*odesc
;
11230 bfd_vma insn
[3], t0
, t1
, control_bits
;
11235 slot
= fix
->fx_where
& 0x3;
11236 fixpos
= fix
->fx_frag
->fr_literal
+ (fix
->fx_where
- slot
);
11238 /* Bundles are always in little-endian byte order */
11239 t0
= bfd_getl64 (fixpos
);
11240 t1
= bfd_getl64 (fixpos
+ 8);
11241 control_bits
= t0
& 0x1f;
11242 insn
[0] = (t0
>> 5) & 0x1ffffffffffLL
;
11243 insn
[1] = ((t0
>> 46) & 0x3ffff) | ((t1
& 0x7fffff) << 18);
11244 insn
[2] = (t1
>> 23) & 0x1ffffffffffLL
;
11247 if (odesc
- elf64_ia64_operands
== IA64_OPND_IMMU64
)
11249 insn
[1] = (value
>> 22) & 0x1ffffffffffLL
;
11250 insn
[2] |= (((value
& 0x7f) << 13)
11251 | (((value
>> 7) & 0x1ff) << 27)
11252 | (((value
>> 16) & 0x1f) << 22)
11253 | (((value
>> 21) & 0x1) << 21)
11254 | (((value
>> 63) & 0x1) << 36));
11256 else if (odesc
- elf64_ia64_operands
== IA64_OPND_IMMU62
)
11258 if (value
& ~0x3fffffffffffffffULL
)
11259 err
= "integer operand out of range";
11260 insn
[1] = (value
>> 21) & 0x1ffffffffffLL
;
11261 insn
[2] |= (((value
& 0xfffff) << 6) | (((value
>> 20) & 0x1) << 36));
11263 else if (odesc
- elf64_ia64_operands
== IA64_OPND_TGT64
)
11266 insn
[1] = ((value
>> 20) & 0x7fffffffffLL
) << 2;
11267 insn
[2] |= ((((value
>> 59) & 0x1) << 36)
11268 | (((value
>> 0) & 0xfffff) << 13));
11271 err
= (*odesc
->insert
) (odesc
, value
, insn
+ slot
);
11274 as_bad_where (fix
->fx_file
, fix
->fx_line
, err
);
11276 t0
= control_bits
| (insn
[0] << 5) | (insn
[1] << 46);
11277 t1
= ((insn
[1] >> 18) & 0x7fffff) | (insn
[2] << 23);
11278 number_to_chars_littleendian (fixpos
+ 0, t0
, 8);
11279 number_to_chars_littleendian (fixpos
+ 8, t1
, 8);
11282 /* Attempt to simplify or even eliminate a fixup. The return value is
11283 ignored; perhaps it was once meaningful, but now it is historical.
11284 To indicate that a fixup has been eliminated, set FIXP->FX_DONE.
11286 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry
11290 md_apply_fix3 (fix
, valP
, seg
)
11293 segT seg ATTRIBUTE_UNUSED
;
11296 valueT value
= *valP
;
11298 fixpos
= fix
->fx_frag
->fr_literal
+ fix
->fx_where
;
11302 switch (fix
->fx_r_type
)
11304 case BFD_RELOC_IA64_PCREL21B
: break;
11305 case BFD_RELOC_IA64_PCREL21BI
: break;
11306 case BFD_RELOC_IA64_PCREL21F
: break;
11307 case BFD_RELOC_IA64_PCREL21M
: break;
11308 case BFD_RELOC_IA64_PCREL60B
: break;
11309 case BFD_RELOC_IA64_PCREL22
: break;
11310 case BFD_RELOC_IA64_PCREL64I
: break;
11311 case BFD_RELOC_IA64_PCREL32MSB
: break;
11312 case BFD_RELOC_IA64_PCREL32LSB
: break;
11313 case BFD_RELOC_IA64_PCREL64MSB
: break;
11314 case BFD_RELOC_IA64_PCREL64LSB
: break;
11316 fix
->fx_r_type
= ia64_gen_real_reloc_type (pseudo_func
[FUNC_PC_RELATIVE
].u
.sym
,
11323 switch (fix
->fx_r_type
)
11325 case BFD_RELOC_UNUSED
:
11326 /* This must be a TAG13 or TAG13b operand. There are no external
11327 relocs defined for them, so we must give an error. */
11328 as_bad_where (fix
->fx_file
, fix
->fx_line
,
11329 "%s must have a constant value",
11330 elf64_ia64_operands
[fix
->tc_fix_data
.opnd
].desc
);
11334 case BFD_RELOC_IA64_TPREL14
:
11335 case BFD_RELOC_IA64_TPREL22
:
11336 case BFD_RELOC_IA64_TPREL64I
:
11337 case BFD_RELOC_IA64_LTOFF_TPREL22
:
11338 case BFD_RELOC_IA64_LTOFF_DTPMOD22
:
11339 case BFD_RELOC_IA64_DTPREL14
:
11340 case BFD_RELOC_IA64_DTPREL22
:
11341 case BFD_RELOC_IA64_DTPREL64I
:
11342 case BFD_RELOC_IA64_LTOFF_DTPREL22
:
11343 S_SET_THREAD_LOCAL (fix
->fx_addsy
);
11350 else if (fix
->tc_fix_data
.opnd
== IA64_OPND_NIL
)
11352 if (fix
->tc_fix_data
.bigendian
)
11353 number_to_chars_bigendian (fixpos
, value
, fix
->fx_size
);
11355 number_to_chars_littleendian (fixpos
, value
, fix
->fx_size
);
11360 fix_insn (fix
, elf64_ia64_operands
+ fix
->tc_fix_data
.opnd
, value
);
11365 /* Generate the BFD reloc to be stuck in the object file from the
11366 fixup used internally in the assembler. */
11369 tc_gen_reloc (sec
, fixp
)
11370 asection
*sec ATTRIBUTE_UNUSED
;
11375 reloc
= xmalloc (sizeof (*reloc
));
11376 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
11377 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
11378 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
11379 reloc
->addend
= fixp
->fx_offset
;
11380 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
11384 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11385 "Cannot represent %s relocation in object file",
11386 bfd_get_reloc_code_name (fixp
->fx_r_type
));
11391 /* Turn a string in input_line_pointer into a floating point constant
11392 of type TYPE, and store the appropriate bytes in *LIT. The number
11393 of LITTLENUMS emitted is stored in *SIZE. An error message is
11394 returned, or NULL on OK. */
11396 #define MAX_LITTLENUMS 5
11399 md_atof (type
, lit
, size
)
11404 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
11434 return "Bad call to MD_ATOF()";
11436 t
= atof_ieee (input_line_pointer
, type
, words
);
11438 input_line_pointer
= t
;
11440 (*ia64_float_to_chars
) (lit
, words
, prec
);
11444 /* It is 10 byte floating point with 6 byte padding. */
11445 memset (&lit
[10], 0, 6);
11446 *size
= 8 * sizeof (LITTLENUM_TYPE
);
11449 *size
= prec
* sizeof (LITTLENUM_TYPE
);
11454 /* Handle ia64 specific semantics of the align directive. */
11457 ia64_md_do_align (n
, fill
, len
, max
)
11458 int n ATTRIBUTE_UNUSED
;
11459 const char *fill ATTRIBUTE_UNUSED
;
11460 int len ATTRIBUTE_UNUSED
;
11461 int max ATTRIBUTE_UNUSED
;
11463 if (subseg_text_p (now_seg
))
11464 ia64_flush_insns ();
11467 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
11468 of an rs_align_code fragment. */
11471 ia64_handle_align (fragp
)
11474 /* Use mfi bundle of nops with no stop bits. */
11475 static const unsigned char le_nop
[]
11476 = { 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
11477 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00};
11478 static const unsigned char le_nop_stop
[]
11479 = { 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
11480 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00};
11484 const unsigned char *nop
;
11486 if (fragp
->fr_type
!= rs_align_code
)
11489 /* Check if this frag has to end with a stop bit. */
11490 nop
= fragp
->tc_frag_data
? le_nop_stop
: le_nop
;
11492 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
11493 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
11495 /* If no paddings are needed, we check if we need a stop bit. */
11496 if (!bytes
&& fragp
->tc_frag_data
)
11498 if (fragp
->fr_fix
< 16)
11500 /* FIXME: It won't work with
11502 alloc r32=ar.pfs,1,2,4,0
11506 as_bad_where (fragp
->fr_file
, fragp
->fr_line
,
11507 _("Can't add stop bit to mark end of instruction group"));
11510 /* Bundles are always in little-endian byte order. Make sure
11511 the previous bundle has the stop bit. */
11515 /* Make sure we are on a 16-byte boundary, in case someone has been
11516 putting data into a text section. */
11519 int fix
= bytes
& 15;
11520 memset (p
, 0, fix
);
11523 fragp
->fr_fix
+= fix
;
11526 /* Instruction bundles are always little-endian. */
11527 memcpy (p
, nop
, 16);
11528 fragp
->fr_var
= 16;
11532 ia64_float_to_chars_bigendian (char *lit
, LITTLENUM_TYPE
*words
,
11537 number_to_chars_bigendian (lit
, (long) (*words
++),
11538 sizeof (LITTLENUM_TYPE
));
11539 lit
+= sizeof (LITTLENUM_TYPE
);
11544 ia64_float_to_chars_littleendian (char *lit
, LITTLENUM_TYPE
*words
,
11549 number_to_chars_littleendian (lit
, (long) (words
[prec
]),
11550 sizeof (LITTLENUM_TYPE
));
11551 lit
+= sizeof (LITTLENUM_TYPE
);
11556 ia64_elf_section_change_hook (void)
11558 if (elf_section_type (now_seg
) == SHT_IA_64_UNWIND
11559 && elf_linked_to_section (now_seg
) == NULL
)
11560 elf_linked_to_section (now_seg
) = text_section
;
11561 dot_byteorder (-1);
11564 /* Check if a label should be made global. */
11566 ia64_check_label (symbolS
*label
)
11568 if (*input_line_pointer
== ':')
11570 S_SET_EXTERNAL (label
);
11571 input_line_pointer
++;
11575 /* Used to remember where .alias and .secalias directives are seen. We
11576 will rename symbol and section names when we are about to output
11577 the relocatable file. */
11580 char *file
; /* The file where the directive is seen. */
11581 unsigned int line
; /* The line number the directive is at. */
11582 const char *name
; /* The orignale name of the symbol. */
11585 /* Called for .alias and .secalias directives. If SECTION is 1, it is
11586 .secalias. Otherwise, it is .alias. */
11588 dot_alias (int section
)
11590 char *name
, *alias
;
11594 const char *error_string
;
11597 struct hash_control
*ahash
, *nhash
;
11600 name
= input_line_pointer
;
11601 delim
= get_symbol_end ();
11602 end_name
= input_line_pointer
;
11605 if (name
== end_name
)
11607 as_bad (_("expected symbol name"));
11608 discard_rest_of_line ();
11612 SKIP_WHITESPACE ();
11614 if (*input_line_pointer
!= ',')
11617 as_bad (_("expected comma after \"%s\""), name
);
11619 ignore_rest_of_line ();
11623 input_line_pointer
++;
11625 ia64_canonicalize_symbol_name (name
);
11627 /* We call demand_copy_C_string to check if alias string is valid.
11628 There should be a closing `"' and no `\0' in the string. */
11629 alias
= demand_copy_C_string (&len
);
11632 ignore_rest_of_line ();
11636 /* Make a copy of name string. */
11637 len
= strlen (name
) + 1;
11638 obstack_grow (¬es
, name
, len
);
11639 name
= obstack_finish (¬es
);
11644 ahash
= secalias_hash
;
11645 nhash
= secalias_name_hash
;
11650 ahash
= alias_hash
;
11651 nhash
= alias_name_hash
;
11654 /* Check if alias has been used before. */
11655 h
= (struct alias
*) hash_find (ahash
, alias
);
11658 if (strcmp (h
->name
, name
))
11659 as_bad (_("`%s' is already the alias of %s `%s'"),
11660 alias
, kind
, h
->name
);
11664 /* Check if name already has an alias. */
11665 a
= (const char *) hash_find (nhash
, name
);
11668 if (strcmp (a
, alias
))
11669 as_bad (_("%s `%s' already has an alias `%s'"), kind
, name
, a
);
11673 h
= (struct alias
*) xmalloc (sizeof (struct alias
));
11674 as_where (&h
->file
, &h
->line
);
11677 error_string
= hash_jam (ahash
, alias
, (PTR
) h
);
11680 as_fatal (_("inserting \"%s\" into %s alias hash table failed: %s"),
11681 alias
, kind
, error_string
);
11685 error_string
= hash_jam (nhash
, name
, (PTR
) alias
);
11688 as_fatal (_("inserting \"%s\" into %s name hash table failed: %s"),
11689 alias
, kind
, error_string
);
11691 obstack_free (¬es
, name
);
11692 obstack_free (¬es
, alias
);
11695 demand_empty_rest_of_line ();
11698 /* It renames the original symbol name to its alias. */
11700 do_alias (const char *alias
, PTR value
)
11702 struct alias
*h
= (struct alias
*) value
;
11703 symbolS
*sym
= symbol_find (h
->name
);
11706 as_warn_where (h
->file
, h
->line
,
11707 _("symbol `%s' aliased to `%s' is not used"),
11710 S_SET_NAME (sym
, (char *) alias
);
11713 /* Called from write_object_file. */
11715 ia64_adjust_symtab (void)
11717 hash_traverse (alias_hash
, do_alias
);
11720 /* It renames the original section name to its alias. */
11722 do_secalias (const char *alias
, PTR value
)
11724 struct alias
*h
= (struct alias
*) value
;
11725 segT sec
= bfd_get_section_by_name (stdoutput
, h
->name
);
11728 as_warn_where (h
->file
, h
->line
,
11729 _("section `%s' aliased to `%s' is not used"),
11735 /* Called from write_object_file. */
11737 ia64_frob_file (void)
11739 hash_traverse (secalias_hash
, do_secalias
);