- labels are wrong if automatic alignment is introduced
(e.g., checkout the second real10 definition in test-data.s)
- DV-related stuff:
- <reg>.safe_across_calls and any other DV-related directives I don't
- have documentation for.
- verify mod-sched-brs reads/writes are checked/marked (and other
- notes)
+ <reg>.safe_across_calls and any other DV-related directives I don't
+ have documentation for.
+ verify mod-sched-brs reads/writes are checked/marked (and other
+ notes)
*/
IND_PMC,
IND_PMD,
IND_RR,
- /* The following pseudo-registers are used for unwind directives only: */
+ /* The following pseudo-registers are used for unwind directives only: */
REG_PSP,
REG_PRIUNAT,
REG_NUM
track of the list of labels that appear in front of each
instruction. */
struct label_fix
- {
- struct label_fix *next;
- struct symbol *sym;
- };
+{
+ struct label_fix *next;
+ struct symbol *sym;
+};
extern int target_big_endian;
as in 0d1.0. */
const char FLT_CHARS[] = "rRsSfFdDxXpP";
-/* ia64-specific option processing: */
+/* ia64-specific option processing: */
const char *md_shortopts = "M:N:x::";
int path; /* number of alt. entry points seen */
const char **entry_labels; /* labels of all alternate paths in
- the current DV-checking block. */
+ the current DV-checking block. */
int maxpaths; /* size currently allocated for
- entry_labels */
+ entry_labels */
}
md;
-/* application registers: */
+/* application registers: */
#define AR_K0 0
#define AR_K7 7
#define CR_LRR0 80
#define CR_LRR1 81
-/* control registers: */
+/* control registers: */
static const struct
{
const char *name;
}
const_bits[] =
{
- /* PSR constant masks: */
+ /* PSR constant masks: */
/* 0: reserved */
{"psr.be", ((valueT) 1) << 1},
{"psr.bn", ((valueT) 1) << 44},
};
-/* indirect register-sets/memory: */
+/* indirect register-sets/memory: */
static const struct
{
}
pseudo_func[] =
{
- /* reloc pseudo functions (these must come first!): */
+ /* reloc pseudo functions (these must come first!): */
{ "fptr", PSEUDO_FUNC_RELOC },
{ "gprel", PSEUDO_FUNC_RELOC },
{ "ltoff", PSEUDO_FUNC_RELOC },
{ "ltv", PSEUDO_FUNC_RELOC },
{ 0, }, /* placeholder for FUNC_LT_FPTR_RELATIVE */
- /* mbtype4 constants: */
+ /* mbtype4 constants: */
{ "alt", PSEUDO_FUNC_CONST, { 0xa } },
{ "brcst", PSEUDO_FUNC_CONST, { 0x0 } },
{ "mix", PSEUDO_FUNC_CONST, { 0x8 } },
{ "rev", PSEUDO_FUNC_CONST, { 0xb } },
{ "shuf", PSEUDO_FUNC_CONST, { 0x9 } },
- /* fclass constants: */
+ /* fclass constants: */
{ "nat", PSEUDO_FUNC_CONST, { 0x100 } },
{ "qnan", PSEUDO_FUNC_CONST, { 0x080 } },
{ "snan", PSEUDO_FUNC_CONST, { 0x040 } },
{ "natval", PSEUDO_FUNC_CONST, { 0x100 } }, /* old usage */
- /* unwind-related constants: */
+ /* unwind-related constants: */
{ "svr4", PSEUDO_FUNC_CONST, { 0 } },
{ "hpux", PSEUDO_FUNC_CONST, { 1 } },
{ "nt", PSEUDO_FUNC_CONST, { 2 } },
- /* unwind-related registers: */
+ /* unwind-related registers: */
{ "priunat",PSEUDO_FUNC_REG, { REG_PRIUNAT } }
};
-/* 41-bit nop opcodes (one per unit): */
+/* 41-bit nop opcodes (one per unit): */
static const bfd_vma nop[IA64_NUM_UNITS] =
{
0x0000000000LL, /* NIL => break 0 */
static int regdepstotlen = 0;
static const char *dv_mode[] = { "RAW", "WAW", "WAR" };
static const char *dv_sem[] = { "none", "implied", "impliedf",
- "data", "instr", "specific", "other" };
+ "data", "instr", "specific", "other" };
/* Current state of PR mutexation */
static struct qpmutex {
typedef void (*vbyte_func) PARAMS ((int, char *, char *));
-/* Forward delarations: */
+/* Forward delarations: */
static int ar_is_in_integer_unit PARAMS ((int regnum));
static void set_section PARAMS ((char *name));
static unsigned int set_regstack PARAMS ((unsigned int, unsigned int,
static void dot_entry PARAMS ((int));
static void dot_mem_offset PARAMS ((int));
static void add_unwind_entry PARAMS((unw_rec_list *ptr));
-static symbolS* declare_register PARAMS ((const char *name, int regnum));
+static symbolS *declare_register PARAMS ((const char *name, int regnum));
static void declare_register_set PARAMS ((const char *, int, int));
static unsigned int operand_width PARAMS ((enum ia64_opnd));
static int operand_match PARAMS ((const struct ia64_opcode *idesc,
set_regstack (ins, locs, outs, rots)
unsigned int ins, locs, outs, rots;
{
- unsigned int sof; /* size of frame */
+ /* Size of frame. */
+ unsigned int sof;
sof = ins + locs + outs;
if (sof > 96)
emit_one_bundle (); /* force out queued instructions */
/* In case there are labels following the last instruction, resolve
- those now: */
+ those now: */
for (lfix = CURR_SLOT.label_fixups; lfix; lfix = lfix->next)
{
S_SET_VALUE (lfix->sym, frag_now_fix ());
int r = 0;
reg = (reg & 0x7f);
switch (rtype)
- {
+ {
case psp_gr:
r = 0;
break;
break;
default:
as_bad ("Invalid record type for P3 format.");
- }
+ }
bytes[0] = (UNW_P3 | (r >> 1));
bytes[1] = (((r & 1) << 7) | reg);
(*f) (2, bytes, NULL);
count += output_leb128 (bytes + 1, w1, 0);
switch (rtype)
{
- case mem_stack_f:
- r = 0;
- count += output_leb128 (bytes + count, w2 >> 4, 0);
- break;
- case mem_stack_v:
- r = 1;
- break;
- case spill_base:
- r = 2;
- break;
- case psp_sprel:
- r = 3;
- break;
- case rp_when:
- r = 4;
- break;
- case rp_psprel:
- r = 5;
- break;
- case pfs_when:
- r = 6;
- break;
- case pfs_psprel:
- r = 7;
- break;
- case preds_when:
- r = 8;
- break;
- case preds_psprel:
- r = 9;
- break;
- case lc_when:
- r = 10;
- break;
- case lc_psprel:
- r = 11;
- break;
- case unat_when:
- r = 12;
- break;
- case unat_psprel:
- r = 13;
- break;
- case fpsr_when:
- r = 14;
- break;
- case fpsr_psprel:
- r = 15;
- break;
- default:
- break;
+ case mem_stack_f:
+ r = 0;
+ count += output_leb128 (bytes + count, w2 >> 4, 0);
+ break;
+ case mem_stack_v:
+ r = 1;
+ break;
+ case spill_base:
+ r = 2;
+ break;
+ case psp_sprel:
+ r = 3;
+ break;
+ case rp_when:
+ r = 4;
+ break;
+ case rp_psprel:
+ r = 5;
+ break;
+ case pfs_when:
+ r = 6;
+ break;
+ case pfs_psprel:
+ r = 7;
+ break;
+ case preds_when:
+ r = 8;
+ break;
+ case preds_psprel:
+ r = 9;
+ break;
+ case lc_when:
+ r = 10;
+ break;
+ case lc_psprel:
+ r = 11;
+ break;
+ case unat_when:
+ r = 12;
+ break;
+ case unat_psprel:
+ r = 13;
+ break;
+ case fpsr_when:
+ r = 14;
+ break;
+ case fpsr_psprel:
+ r = 15;
+ break;
+ default:
+ break;
}
bytes[0] = (UNW_P7 | r);
(*f) (count, bytes, NULL);
bytes[0] = UNW_P8;
switch (rtype)
{
- case rp_sprel:
- r = 1;
- break;
- case pfs_sprel:
- r = 2;
- break;
- case preds_sprel:
- r = 3;
- break;
- case lc_sprel:
- r = 4;
- break;
- case unat_sprel:
- r = 5;
- break;
- case fpsr_sprel:
- r = 6;
- break;
- case bsp_when:
- r = 7;
- break;
- case bsp_psprel:
- r = 8;
- break;
- case bsp_sprel:
- r = 9;
- break;
- case bspstore_when:
- r = 10;
- break;
- case bspstore_psprel:
- r = 11;
- break;
- case bspstore_sprel:
- r = 12;
- break;
- case rnat_when:
- r = 13;
- break;
- case rnat_psprel:
- r = 14;
- break;
- case rnat_sprel:
- r = 15;
- break;
- case priunat_when_gr:
- r = 16;
- break;
- case priunat_psprel:
- r = 17;
- break;
- case priunat_sprel:
- r = 18;
- break;
- case priunat_when_mem:
- r = 19;
- break;
- default:
- break;
+ case rp_sprel:
+ r = 1;
+ break;
+ case pfs_sprel:
+ r = 2;
+ break;
+ case preds_sprel:
+ r = 3;
+ break;
+ case lc_sprel:
+ r = 4;
+ break;
+ case unat_sprel:
+ r = 5;
+ break;
+ case fpsr_sprel:
+ r = 6;
+ break;
+ case bsp_when:
+ r = 7;
+ break;
+ case bsp_psprel:
+ r = 8;
+ break;
+ case bsp_sprel:
+ r = 9;
+ break;
+ case bspstore_when:
+ r = 10;
+ break;
+ case bspstore_psprel:
+ r = 11;
+ break;
+ case bspstore_sprel:
+ r = 12;
+ break;
+ case rnat_when:
+ r = 13;
+ break;
+ case rnat_psprel:
+ r = 14;
+ break;
+ case rnat_sprel:
+ r = 15;
+ break;
+ case priunat_when_gr:
+ r = 16;
+ break;
+ case priunat_psprel:
+ r = 17;
+ break;
+ case priunat_sprel:
+ r = 18;
+ break;
+ case priunat_when_mem:
+ r = 19;
+ break;
+ default:
+ break;
}
bytes[1] = r;
count += output_leb128 (bytes + 2, t, 0);
static char
format_ab_reg (ab, reg)
- int ab;
- int reg;
+ int ab;
+ int reg;
{
int ret;
ab = (ab & 3);
}
/* This function allocates a record list structure, and initializes fields. */
+
static unw_rec_list *
alloc_record (unw_record_type t)
{
}
/* This function frees an entire list of record structures. */
+
void
free_list_records (unw_rec_list *first)
{
unw_rec_list *ptr;
- for (ptr = first; ptr != NULL; )
+ for (ptr = first; ptr != NULL;)
{
unw_rec_list *tmp = ptr;
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (psp_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (rp_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (rp_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (pfs_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (pfs_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (preds_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (preds_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (spill_base);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (unat_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (unat_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (lc_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (lc_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (fpsr_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (fpsr_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (priunat_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (priunat_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (bsp_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (bsp_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (bspstore_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (bspstore_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (rnat_psprel);
- ptr->r.record.p.pspoff = offset/4;
+ ptr->r.record.p.pspoff = offset / 4;
return ptr;
}
unsigned int offset;
{
unw_rec_list *ptr = alloc_record (rnat_sprel);
- ptr->r.record.p.spoff = offset/4;
+ ptr->r.record.p.spoff = offset / 4;
return ptr;
}
unw_rec_list *ptr = alloc_record (spill_psprel);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.pspoff = offset/4;
+ ptr->r.record.x.pspoff = offset / 4;
return ptr;
}
unw_rec_list *ptr = alloc_record (spill_sprel);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.spoff = offset/4;
+ ptr->r.record.x.spoff = offset / 4;
return ptr;
}
unw_rec_list *ptr = alloc_record (spill_psprel_p);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.pspoff = offset/4;
+ ptr->r.record.x.pspoff = offset / 4;
ptr->r.record.x.qp = predicate;
return ptr;
}
unw_rec_list *ptr = alloc_record (spill_sprel_p);
ptr->r.record.x.ab = ab;
ptr->r.record.x.reg = reg;
- ptr->r.record.x.spoff = offset/4;
+ ptr->r.record.x.spoff = offset / 4;
ptr->r.record.x.qp = predicate;
return ptr;
}
/* Given a unw_rec_list process the correct format with the
specified function. */
+
static void
process_one_record (ptr, f)
unw_rec_list *ptr;
switch (ptr->r.type)
{
- case gr_mem:
- case fr_mem:
- case br_mem:
- case frgr_mem:
- /* these are taken care of by prologue/prologue_gr */
- break;
-
- case prologue_gr:
- case prologue:
- if (ptr->r.type == prologue_gr)
- output_R2_format (f, ptr->r.record.r.grmask,
- ptr->r.record.r.grsave, ptr->r.record.r.rlen);
- else
- output_R1_format (f, ptr->r.type, ptr->r.record.r.rlen);
-
- /* output descriptor(s) for union of register spills (if any): */
- gr_mask = ptr->r.record.r.mask.gr_mem;
- fr_mask = ptr->r.record.r.mask.fr_mem;
- if (fr_mask)
- {
- if ((fr_mask & ~0xfUL) == 0)
- output_P6_format (f, fr_mem, fr_mask);
- else
- {
- output_P5_format (f, gr_mask, fr_mask);
- gr_mask = 0;
- }
- }
- if (gr_mask)
- output_P6_format (f, gr_mem, gr_mask);
- if (ptr->r.record.r.mask.br_mem)
- output_P1_format (f, ptr->r.record.r.mask.br_mem);
-
- /* output imask descriptor if necessary: */
- if (ptr->r.record.r.mask.i)
- output_P4_format (f, ptr->r.record.r.mask.i,
- ptr->r.record.r.imask_size);
- break;
+ case gr_mem:
+ case fr_mem:
+ case br_mem:
+ case frgr_mem:
+ /* These are taken care of by prologue/prologue_gr. */
+ break;
- case body:
+ case prologue_gr:
+ case prologue:
+ if (ptr->r.type == prologue_gr)
+ output_R2_format (f, ptr->r.record.r.grmask,
+ ptr->r.record.r.grsave, ptr->r.record.r.rlen);
+ else
output_R1_format (f, ptr->r.type, ptr->r.record.r.rlen);
- break;
- case mem_stack_f:
- case mem_stack_v:
- output_P7_format (f, ptr->r.type, ptr->r.record.p.t,
- ptr->r.record.p.size);
- break;
- case psp_gr:
- case rp_gr:
- case pfs_gr:
- case preds_gr:
- case unat_gr:
- case lc_gr:
- case fpsr_gr:
- case priunat_gr:
- case bsp_gr:
- case bspstore_gr:
- case rnat_gr:
- output_P3_format (f, ptr->r.type, ptr->r.record.p.gr);
- break;
- case rp_br:
- output_P3_format (f, rp_br, ptr->r.record.p.br);
- break;
- case psp_sprel:
- output_P7_format (f, psp_sprel, ptr->r.record.p.spoff, 0);
- break;
- case rp_when:
- case pfs_when:
- case preds_when:
- case unat_when:
- case lc_when:
- case fpsr_when:
- output_P7_format (f, ptr->r.type, ptr->r.record.p.t, 0);
- break;
- case rp_psprel:
- case pfs_psprel:
- case preds_psprel:
- case unat_psprel:
- case lc_psprel:
- case fpsr_psprel:
- case spill_base:
- output_P7_format (f, ptr->r.type, ptr->r.record.p.pspoff, 0);
- break;
- case rp_sprel:
- case pfs_sprel:
- case preds_sprel:
- case unat_sprel:
- case lc_sprel:
- case fpsr_sprel:
- case priunat_sprel:
- case bsp_sprel:
- case bspstore_sprel:
- case rnat_sprel:
- output_P8_format (f, ptr->r.type, ptr->r.record.p.spoff);
- break;
- case gr_gr:
- output_P9_format (f, ptr->r.record.p.grmask, ptr->r.record.p.gr);
- break;
- case br_gr:
- output_P2_format (f, ptr->r.record.p.brmask, ptr->r.record.p.gr);
- break;
- case spill_mask:
- as_bad ("spill_mask record unimplemented.");
- break;
- case priunat_when_gr:
- case priunat_when_mem:
- case bsp_when:
- case bspstore_when:
- case rnat_when:
- output_P8_format (f, ptr->r.type, ptr->r.record.p.t);
- break;
- case priunat_psprel:
- case bsp_psprel:
- case bspstore_psprel:
- case rnat_psprel:
- output_P8_format (f, ptr->r.type, ptr->r.record.p.pspoff);
- break;
- case unwabi:
- output_P10_format (f, ptr->r.record.p.abi, ptr->r.record.p.context);
- break;
- case epilogue:
- output_B3_format (f, ptr->r.record.b.ecount, ptr->r.record.b.t);
- break;
- case label_state:
- case copy_state:
- output_B4_format (f, ptr->r.type, ptr->r.record.b.label);
- break;
- case spill_psprel:
- output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
- ptr->r.record.x.reg, ptr->r.record.x.t,
- ptr->r.record.x.pspoff);
- break;
- case spill_sprel:
- output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
- ptr->r.record.x.reg, ptr->r.record.x.t,
- ptr->r.record.x.spoff);
- break;
- case spill_reg:
- output_X2_format (f, ptr->r.record.x.ab, ptr->r.record.x.reg,
- ptr->r.record.x.xy >> 1, ptr->r.record.x.xy,
- ptr->r.record.x.treg, ptr->r.record.x.t);
- break;
- case spill_psprel_p:
- output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
- ptr->r.record.x.ab, ptr->r.record.x.reg,
- ptr->r.record.x.t, ptr->r.record.x.pspoff);
- break;
- case spill_sprel_p:
- output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
- ptr->r.record.x.ab, ptr->r.record.x.reg,
- ptr->r.record.x.t, ptr->r.record.x.spoff);
- break;
- case spill_reg_p:
- output_X4_format (f, ptr->r.record.x.qp, ptr->r.record.x.ab,
- ptr->r.record.x.reg, ptr->r.record.x.xy >> 1,
- ptr->r.record.x.xy, ptr->r.record.x.treg,
- ptr->r.record.x.t);
- break;
- default:
- as_bad ("record_type_not_valid");
- break;
+
+ /* Output descriptor(s) for union of register spills (if any). */
+ gr_mask = ptr->r.record.r.mask.gr_mem;
+ fr_mask = ptr->r.record.r.mask.fr_mem;
+ if (fr_mask)
+ {
+ if ((fr_mask & ~0xfUL) == 0)
+ output_P6_format (f, fr_mem, fr_mask);
+ else
+ {
+ output_P5_format (f, gr_mask, fr_mask);
+ gr_mask = 0;
+ }
+ }
+ if (gr_mask)
+ output_P6_format (f, gr_mem, gr_mask);
+ if (ptr->r.record.r.mask.br_mem)
+ output_P1_format (f, ptr->r.record.r.mask.br_mem);
+
+ /* output imask descriptor if necessary: */
+ if (ptr->r.record.r.mask.i)
+ output_P4_format (f, ptr->r.record.r.mask.i,
+ ptr->r.record.r.imask_size);
+ break;
+
+ case body:
+ output_R1_format (f, ptr->r.type, ptr->r.record.r.rlen);
+ break;
+ case mem_stack_f:
+ case mem_stack_v:
+ output_P7_format (f, ptr->r.type, ptr->r.record.p.t,
+ ptr->r.record.p.size);
+ break;
+ case psp_gr:
+ case rp_gr:
+ case pfs_gr:
+ case preds_gr:
+ case unat_gr:
+ case lc_gr:
+ case fpsr_gr:
+ case priunat_gr:
+ case bsp_gr:
+ case bspstore_gr:
+ case rnat_gr:
+ output_P3_format (f, ptr->r.type, ptr->r.record.p.gr);
+ break;
+ case rp_br:
+ output_P3_format (f, rp_br, ptr->r.record.p.br);
+ break;
+ case psp_sprel:
+ output_P7_format (f, psp_sprel, ptr->r.record.p.spoff, 0);
+ break;
+ case rp_when:
+ case pfs_when:
+ case preds_when:
+ case unat_when:
+ case lc_when:
+ case fpsr_when:
+ output_P7_format (f, ptr->r.type, ptr->r.record.p.t, 0);
+ break;
+ case rp_psprel:
+ case pfs_psprel:
+ case preds_psprel:
+ case unat_psprel:
+ case lc_psprel:
+ case fpsr_psprel:
+ case spill_base:
+ output_P7_format (f, ptr->r.type, ptr->r.record.p.pspoff, 0);
+ break;
+ case rp_sprel:
+ case pfs_sprel:
+ case preds_sprel:
+ case unat_sprel:
+ case lc_sprel:
+ case fpsr_sprel:
+ case priunat_sprel:
+ case bsp_sprel:
+ case bspstore_sprel:
+ case rnat_sprel:
+ output_P8_format (f, ptr->r.type, ptr->r.record.p.spoff);
+ break;
+ case gr_gr:
+ output_P9_format (f, ptr->r.record.p.grmask, ptr->r.record.p.gr);
+ break;
+ case br_gr:
+ output_P2_format (f, ptr->r.record.p.brmask, ptr->r.record.p.gr);
+ break;
+ case spill_mask:
+ as_bad ("spill_mask record unimplemented.");
+ break;
+ case priunat_when_gr:
+ case priunat_when_mem:
+ case bsp_when:
+ case bspstore_when:
+ case rnat_when:
+ output_P8_format (f, ptr->r.type, ptr->r.record.p.t);
+ break;
+ case priunat_psprel:
+ case bsp_psprel:
+ case bspstore_psprel:
+ case rnat_psprel:
+ output_P8_format (f, ptr->r.type, ptr->r.record.p.pspoff);
+ break;
+ case unwabi:
+ output_P10_format (f, ptr->r.record.p.abi, ptr->r.record.p.context);
+ break;
+ case epilogue:
+ output_B3_format (f, ptr->r.record.b.ecount, ptr->r.record.b.t);
+ break;
+ case label_state:
+ case copy_state:
+ output_B4_format (f, ptr->r.type, ptr->r.record.b.label);
+ break;
+ case spill_psprel:
+ output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
+ ptr->r.record.x.reg, ptr->r.record.x.t,
+ ptr->r.record.x.pspoff);
+ break;
+ case spill_sprel:
+ output_X1_format (f, ptr->r.type, ptr->r.record.x.ab,
+ ptr->r.record.x.reg, ptr->r.record.x.t,
+ ptr->r.record.x.spoff);
+ break;
+ case spill_reg:
+ output_X2_format (f, ptr->r.record.x.ab, ptr->r.record.x.reg,
+ ptr->r.record.x.xy >> 1, ptr->r.record.x.xy,
+ ptr->r.record.x.treg, ptr->r.record.x.t);
+ break;
+ case spill_psprel_p:
+ output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
+ ptr->r.record.x.ab, ptr->r.record.x.reg,
+ ptr->r.record.x.t, ptr->r.record.x.pspoff);
+ break;
+ case spill_sprel_p:
+ output_X3_format (f, ptr->r.type, ptr->r.record.x.qp,
+ ptr->r.record.x.ab, ptr->r.record.x.reg,
+ ptr->r.record.x.t, ptr->r.record.x.spoff);
+ break;
+ case spill_reg_p:
+ output_X4_format (f, ptr->r.record.x.qp, ptr->r.record.x.ab,
+ ptr->r.record.x.reg, ptr->r.record.x.xy >> 1,
+ ptr->r.record.x.xy, ptr->r.record.x.treg,
+ ptr->r.record.x.t);
+ break;
+ default:
+ as_bad ("record_type_not_valid");
+ break;
}
}
imask_size = region->r.record.r.imask_size;
if (!imask)
{
- imask_size = (region->r.record.r.rlen*2 + 7)/8 + 1;
+ imask_size = (region->r.record.r.rlen * 2 + 7) / 8 + 1;
imask = xmalloc (imask_size);
memset (imask, 0, imask_size);
region->r.record.r.mask.i = imask;
}
- i = (t/4) + 1;
- pos = 2*(3 - t%4);
+ i = (t / 4) + 1;
+ pos = 2 * (3 - t % 4);
while (regmask)
{
if (i >= imask_size)
unsigned long
slot_index (unsigned long slot_addr, unsigned long first_addr)
{
- return (3*((slot_addr >> 4) - (first_addr >> 4))
+ return (3 * ((slot_addr >> 4) - (first_addr >> 4))
+ ((slot_addr & 0x3) - (first_addr & 0x3)));
}
unresolved fields, (ie length counts for a prologue). After
this has been run, all neccessary information should be available
within each record to generate an image. */
+
static void
fixup_unw_records (list)
unw_rec_list *list;
for (ptr = list; ptr; ptr = ptr->next)
{
if (ptr->slot_number == SLOT_NUM_NOT_SET)
- as_bad (" Insn slot not set in unwind record.");
+ as_bad (" Insn slot not set in unwind record.");
t = slot_index (ptr->slot_number, first_addr);
switch (ptr->r.type)
{
- case prologue:
- case prologue_gr:
- case body:
- {
- unw_rec_list *last;
- int size, dir_len = 0;
- unsigned long last_addr;
-
- first_addr = ptr->slot_number;
- ptr->slot_number = 0;
- /* Find either the next body/prologue start, or the end of
- the list, and determine the size of the region. */
- last_addr = unwind.next_slot_number;
- for (last = ptr->next; last != NULL; last = last->next)
- if (last->r.type == prologue || last->r.type == prologue_gr
- || last->r.type == body)
- {
- last_addr = last->slot_number;
- break;
- }
- else if (!last->next)
- {
- /* In the absence of an explicit .body directive,
- the prologue ends after the last instruction
- covered by an unwind directive. */
- if (ptr->r.type != body)
- {
- last_addr = last->slot_number;
- switch (last->r.type)
- {
- case frgr_mem:
- dir_len = (count_bits (last->r.record.p.frmask)
- + count_bits (last->r.record.p.grmask));
- break;
- case fr_mem:
- case gr_mem:
- dir_len += count_bits (last->r.record.p.rmask);
- break;
- case br_mem:
- case br_gr:
- dir_len += count_bits (last->r.record.p.brmask);
- break;
- case gr_gr:
- dir_len += count_bits (last->r.record.p.grmask);
- break;
- default:
- dir_len = 1;
- break;
- }
- }
- break;
- }
- size = slot_index (last_addr, first_addr) + dir_len;
- rlen = ptr->r.record.r.rlen = size;
- region = ptr;
- break;
- }
- case epilogue:
- ptr->r.record.b.t = rlen - 1 - t;
+ case prologue:
+ case prologue_gr:
+ case body:
+ {
+ unw_rec_list *last;
+ int size, dir_len = 0;
+ unsigned long last_addr;
+
+ first_addr = ptr->slot_number;
+ ptr->slot_number = 0;
+ /* Find either the next body/prologue start, or the end of
+ the list, and determine the size of the region. */
+ last_addr = unwind.next_slot_number;
+ for (last = ptr->next; last != NULL; last = last->next)
+ if (last->r.type == prologue || last->r.type == prologue_gr
+ || last->r.type == body)
+ {
+ last_addr = last->slot_number;
+ break;
+ }
+ else if (!last->next)
+ {
+ /* In the absence of an explicit .body directive,
+ the prologue ends after the last instruction
+ covered by an unwind directive. */
+ if (ptr->r.type != body)
+ {
+ last_addr = last->slot_number;
+ switch (last->r.type)
+ {
+ case frgr_mem:
+ dir_len = (count_bits (last->r.record.p.frmask)
+ + count_bits (last->r.record.p.grmask));
+ break;
+ case fr_mem:
+ case gr_mem:
+ dir_len += count_bits (last->r.record.p.rmask);
+ break;
+ case br_mem:
+ case br_gr:
+ dir_len += count_bits (last->r.record.p.brmask);
+ break;
+ case gr_gr:
+ dir_len += count_bits (last->r.record.p.grmask);
+ break;
+ default:
+ dir_len = 1;
+ break;
+ }
+ }
+ break;
+ }
+ size = slot_index (last_addr, first_addr) + dir_len;
+ rlen = ptr->r.record.r.rlen = size;
+ region = ptr;
break;
+ }
+ case epilogue:
+ ptr->r.record.b.t = rlen - 1 - t;
+ break;
- case mem_stack_f:
- case mem_stack_v:
- case rp_when:
- case pfs_when:
- case preds_when:
- case unat_when:
- case lc_when:
- case fpsr_when:
- case priunat_when_gr:
- case priunat_when_mem:
- case bsp_when:
- case bspstore_when:
- case rnat_when:
- ptr->r.record.p.t = t;
- break;
+ case mem_stack_f:
+ case mem_stack_v:
+ case rp_when:
+ case pfs_when:
+ case preds_when:
+ case unat_when:
+ case lc_when:
+ case fpsr_when:
+ case priunat_when_gr:
+ case priunat_when_mem:
+ case bsp_when:
+ case bspstore_when:
+ case rnat_when:
+ ptr->r.record.p.t = t;
+ break;
- case spill_reg:
- case spill_sprel:
- case spill_psprel:
- case spill_reg_p:
- case spill_sprel_p:
- case spill_psprel_p:
- ptr->r.record.x.t = t;
- break;
+ case spill_reg:
+ case spill_sprel:
+ case spill_psprel:
+ case spill_reg_p:
+ case spill_sprel_p:
+ case spill_psprel_p:
+ ptr->r.record.x.t = t;
+ break;
- case frgr_mem:
- if (!region)
- {
- as_bad ("frgr_mem record before region record!\n");
- return;
- }
- region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
- region->r.record.r.mask.gr_mem |= ptr->r.record.p.grmask;
- set_imask (region, ptr->r.record.p.frmask, t, 1);
- set_imask (region, ptr->r.record.p.grmask, t, 2);
- break;
- case fr_mem:
- if (!region)
- {
- as_bad ("fr_mem record before region record!\n");
- return;
- }
- region->r.record.r.mask.fr_mem |= ptr->r.record.p.rmask;
- set_imask (region, ptr->r.record.p.rmask, t, 1);
- break;
- case gr_mem:
- if (!region)
- {
- as_bad ("gr_mem record before region record!\n");
- return;
- }
- region->r.record.r.mask.gr_mem |= ptr->r.record.p.rmask;
- set_imask (region, ptr->r.record.p.rmask, t, 2);
- break;
- case br_mem:
- if (!region)
- {
- as_bad ("br_mem record before region record!\n");
- return;
- }
- region->r.record.r.mask.br_mem |= ptr->r.record.p.brmask;
- set_imask (region, ptr->r.record.p.brmask, t, 3);
- break;
+ case frgr_mem:
+ if (!region)
+ {
+ as_bad ("frgr_mem record before region record!\n");
+ return;
+ }
+ region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
+ region->r.record.r.mask.gr_mem |= ptr->r.record.p.grmask;
+ set_imask (region, ptr->r.record.p.frmask, t, 1);
+ set_imask (region, ptr->r.record.p.grmask, t, 2);
+ break;
+ case fr_mem:
+ if (!region)
+ {
+ as_bad ("fr_mem record before region record!\n");
+ return;
+ }
+ region->r.record.r.mask.fr_mem |= ptr->r.record.p.rmask;
+ set_imask (region, ptr->r.record.p.rmask, t, 1);
+ break;
+ case gr_mem:
+ if (!region)
+ {
+ as_bad ("gr_mem record before region record!\n");
+ return;
+ }
+ region->r.record.r.mask.gr_mem |= ptr->r.record.p.rmask;
+ set_imask (region, ptr->r.record.p.rmask, t, 2);
+ break;
+ case br_mem:
+ if (!region)
+ {
+ as_bad ("br_mem record before region record!\n");
+ return;
+ }
+ region->r.record.r.mask.br_mem |= ptr->r.record.p.brmask;
+ set_imask (region, ptr->r.record.p.brmask, t, 3);
+ break;
- case gr_gr:
- if (!region)
- {
- as_bad ("gr_gr record before region record!\n");
- return;
- }
- set_imask (region, ptr->r.record.p.grmask, t, 2);
- break;
- case br_gr:
- if (!region)
- {
- as_bad ("br_gr record before region record!\n");
- return;
- }
- set_imask (region, ptr->r.record.p.brmask, t, 3);
- break;
+ case gr_gr:
+ if (!region)
+ {
+ as_bad ("gr_gr record before region record!\n");
+ return;
+ }
+ set_imask (region, ptr->r.record.p.grmask, t, 2);
+ break;
+ case br_gr:
+ if (!region)
+ {
+ as_bad ("br_gr record before region record!\n");
+ return;
+ }
+ set_imask (region, ptr->r.record.p.brmask, t, 3);
+ break;
- default:
- break;
+ default:
+ break;
}
}
}
if (radix != 'C' && !is_end_of_line[(unsigned char) radix])
{
as_bad ("Radix `%c' unsupported", *input_line_pointer);
- ignore_rest_of_line ();
+ ignore_rest_of_line ();
return;
}
}
/* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'. */
if (e1.X_op == O_register)
{
- if (e2.X_op == O_register && reg2 >=0 && reg2 < 128)
+ if (e2.X_op == O_register && reg2 >= 0 && reg2 < 128)
{
switch (reg1)
{
- case REG_AR + AR_BSP:
- add_unwind_entry (output_bsp_when ());
- add_unwind_entry (output_bsp_gr (reg2));
- break;
- case REG_AR + AR_BSPSTORE:
- add_unwind_entry (output_bspstore_when ());
- add_unwind_entry (output_bspstore_gr (reg2));
- break;
- case REG_AR + AR_RNAT:
- add_unwind_entry (output_rnat_when ());
- add_unwind_entry (output_rnat_gr (reg2));
- break;
- case REG_AR+AR_UNAT:
- add_unwind_entry (output_unat_when ());
- add_unwind_entry (output_unat_gr (reg2));
- break;
- case REG_AR+AR_FPSR:
- add_unwind_entry (output_fpsr_when ());
- add_unwind_entry (output_fpsr_gr (reg2));
- break;
- case REG_AR+AR_PFS:
- add_unwind_entry (output_pfs_when ());
- if (! (unwind.prologue_mask & 4))
- add_unwind_entry (output_pfs_gr (reg2));
- break;
- case REG_AR+AR_LC:
- add_unwind_entry (output_lc_when ());
- add_unwind_entry (output_lc_gr (reg2));
- break;
- case REG_BR:
- add_unwind_entry (output_rp_when ());
- if (! (unwind.prologue_mask & 8))
- add_unwind_entry (output_rp_gr (reg2));
- break;
- case REG_PR:
- add_unwind_entry (output_preds_when ());
- if (! (unwind.prologue_mask & 1))
- add_unwind_entry (output_preds_gr (reg2));
- break;
- case REG_PRIUNAT:
- add_unwind_entry (output_priunat_when_gr ());
- add_unwind_entry (output_priunat_gr (reg2));
- break;
- default:
- as_bad ("First operand not a valid register");
+ case REG_AR + AR_BSP:
+ add_unwind_entry (output_bsp_when ());
+ add_unwind_entry (output_bsp_gr (reg2));
+ break;
+ case REG_AR + AR_BSPSTORE:
+ add_unwind_entry (output_bspstore_when ());
+ add_unwind_entry (output_bspstore_gr (reg2));
+ break;
+ case REG_AR + AR_RNAT:
+ add_unwind_entry (output_rnat_when ());
+ add_unwind_entry (output_rnat_gr (reg2));
+ break;
+ case REG_AR + AR_UNAT:
+ add_unwind_entry (output_unat_when ());
+ add_unwind_entry (output_unat_gr (reg2));
+ break;
+ case REG_AR + AR_FPSR:
+ add_unwind_entry (output_fpsr_when ());
+ add_unwind_entry (output_fpsr_gr (reg2));
+ break;
+ case REG_AR + AR_PFS:
+ add_unwind_entry (output_pfs_when ());
+ if (! (unwind.prologue_mask & 4))
+ add_unwind_entry (output_pfs_gr (reg2));
+ break;
+ case REG_AR + AR_LC:
+ add_unwind_entry (output_lc_when ());
+ add_unwind_entry (output_lc_gr (reg2));
+ break;
+ case REG_BR:
+ add_unwind_entry (output_rp_when ());
+ if (! (unwind.prologue_mask & 8))
+ add_unwind_entry (output_rp_gr (reg2));
+ break;
+ case REG_PR:
+ add_unwind_entry (output_preds_when ());
+ if (! (unwind.prologue_mask & 1))
+ add_unwind_entry (output_preds_gr (reg2));
+ break;
+ case REG_PRIUNAT:
+ add_unwind_entry (output_priunat_when_gr ());
+ add_unwind_entry (output_priunat_gr (reg2));
+ break;
+ default:
+ as_bad ("First operand not a valid register");
}
}
else
/* Set expression which points to start of unwind descriptor area. */
unwind.info = expr_build_dot ();
- where = (unsigned char *)frag_more (size);
+ where = (unsigned char *) frag_more (size);
/* Issue a label for this address, and keep track of it to put it
in the unwind section. */
memcpy (where, unw_rec, size);
/* Add the personality address to the image. */
if (unwind.personality_routine != 0)
- {
+ {
exp.X_op = O_symbol;
exp.X_add_symbol = unwind.personality_routine;
exp.X_add_number = 0;
fix_new_exp (frag_now, frag_now_fix () - 8, 8,
&exp, 0, BFD_RELOC_IA64_LTOFF_FPTR64LSB);
unwind.personality_routine = 0;
- }
+ }
obj_elf_previous (0);
}
}
static void
-dot_handlerdata (dummy)
+dot_handlerdata (dummy)
int dummy;
{
generate_unwind_image ();
{
switch (reg1)
{
- case REG_AR + AR_BSP:
- add_unwind_entry (output_bsp_when ());
- add_unwind_entry ((psprel
- ? output_bsp_psprel
- : output_bsp_sprel) (val));
- break;
- case REG_AR + AR_BSPSTORE:
- add_unwind_entry (output_bspstore_when ());
- add_unwind_entry ((psprel
- ? output_bspstore_psprel
- : output_bspstore_sprel) (val));
- break;
- case REG_AR + AR_RNAT:
- add_unwind_entry (output_rnat_when ());
- add_unwind_entry ((psprel
- ? output_rnat_psprel
- : output_rnat_sprel) (val));
- break;
- case REG_AR + AR_UNAT:
- add_unwind_entry (output_unat_when ());
- add_unwind_entry ((psprel
- ? output_unat_psprel
- : output_unat_sprel) (val));
- break;
- case REG_AR + AR_FPSR:
- add_unwind_entry (output_fpsr_when ());
- add_unwind_entry ((psprel
- ? output_fpsr_psprel
- : output_fpsr_sprel) (val));
- break;
- case REG_AR + AR_PFS:
- add_unwind_entry (output_pfs_when ());
- add_unwind_entry ((psprel
- ? output_pfs_psprel
- : output_pfs_sprel) (val));
- break;
- case REG_AR + AR_LC:
- add_unwind_entry (output_lc_when ());
- add_unwind_entry ((psprel
- ? output_lc_psprel
- : output_lc_sprel) (val));
- break;
- case REG_BR:
- add_unwind_entry (output_rp_when ());
- add_unwind_entry ((psprel
- ? output_rp_psprel
- : output_rp_sprel) (val));
- break;
- case REG_PR:
- add_unwind_entry (output_preds_when ());
- add_unwind_entry ((psprel
- ? output_preds_psprel
- : output_preds_sprel) (val));
- break;
- case REG_PRIUNAT:
- add_unwind_entry (output_priunat_when_mem ());
- add_unwind_entry ((psprel
- ? output_priunat_psprel
- : output_priunat_sprel) (val));
- break;
- default:
- as_bad ("First operand not a valid register");
+ case REG_AR + AR_BSP:
+ add_unwind_entry (output_bsp_when ());
+ add_unwind_entry ((psprel
+ ? output_bsp_psprel
+ : output_bsp_sprel) (val));
+ break;
+ case REG_AR + AR_BSPSTORE:
+ add_unwind_entry (output_bspstore_when ());
+ add_unwind_entry ((psprel
+ ? output_bspstore_psprel
+ : output_bspstore_sprel) (val));
+ break;
+ case REG_AR + AR_RNAT:
+ add_unwind_entry (output_rnat_when ());
+ add_unwind_entry ((psprel
+ ? output_rnat_psprel
+ : output_rnat_sprel) (val));
+ break;
+ case REG_AR + AR_UNAT:
+ add_unwind_entry (output_unat_when ());
+ add_unwind_entry ((psprel
+ ? output_unat_psprel
+ : output_unat_sprel) (val));
+ break;
+ case REG_AR + AR_FPSR:
+ add_unwind_entry (output_fpsr_when ());
+ add_unwind_entry ((psprel
+ ? output_fpsr_psprel
+ : output_fpsr_sprel) (val));
+ break;
+ case REG_AR + AR_PFS:
+ add_unwind_entry (output_pfs_when ());
+ add_unwind_entry ((psprel
+ ? output_pfs_psprel
+ : output_pfs_sprel) (val));
+ break;
+ case REG_AR + AR_LC:
+ add_unwind_entry (output_lc_when ());
+ add_unwind_entry ((psprel
+ ? output_lc_psprel
+ : output_lc_sprel) (val));
+ break;
+ case REG_BR:
+ add_unwind_entry (output_rp_when ());
+ add_unwind_entry ((psprel
+ ? output_rp_psprel
+ : output_rp_sprel) (val));
+ break;
+ case REG_PR:
+ add_unwind_entry (output_preds_when ());
+ add_unwind_entry ((psprel
+ ? output_preds_psprel
+ : output_preds_sprel) (val));
+ break;
+ case REG_PRIUNAT:
+ add_unwind_entry (output_priunat_when_mem ());
+ add_unwind_entry ((psprel
+ ? output_priunat_psprel
+ : output_priunat_sprel) (val));
+ break;
+ default:
+ as_bad ("First operand not a valid register");
}
}
else
if (sep != ',')
add_unwind_entry (output_gr_mem (grmask));
else
- {
+ {
int reg = e2.X_add_number - REG_GR;
- if (e2.X_op == O_register && reg >=0 && reg < 128)
+ if (e2.X_op == O_register && reg >= 0 && reg < 128)
add_unwind_entry (output_gr_gr (grmask, reg));
else
as_bad ("Second operand is an invalid register.");
unwind.proc_start = expr_build_dot ();
/* Parse names of main and alternate entry points and mark them as
- function symbols: */
+ function symbols: */
while (1)
{
SKIP_WHITESPACE ();
p = input_line_pointer;
sym = symbol_find_or_make (name);
if (unwind.proc_start == 0)
- {
+ {
unwind.proc_start = sym;
}
symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
as_bad ("No second operand to .prologue");
sep = parse_operand (&e2);
if (!is_end_of_line[sep] && !is_it_end_of_statement ())
- ignore_rest_of_line ();
+ ignore_rest_of_line ();
if (e1.X_op == O_constant)
- {
+ {
mask = e1.X_add_number;
if (e2.X_op == O_constant)
default: break;
}
- /* first, remove existing names from hash table: */
+ /* First, remove existing names from hash table. */
for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
{
hash_delete (md.dynreg_hash, dr->name);
demand_empty_rest_of_line ();
}
-static char*
+static char *
parse_section_name ()
{
char *name;
}
/* Why doesn't float_cons() call md_cons_align() the way cons() does? */
+
static void
stmt_float_cons (kind)
int kind;
}
/* .reg.val <regname>,value */
+
static void
dot_reg_val (dummy)
- int dummy;
+ int dummy;
{
expressionS reg;
{
valueT value = get_absolute_expression ();
int regno = reg.X_add_number;
- if (regno < REG_GR || regno > REG_GR+128)
- as_warn (_("Register value annotation ignored"));
+ if (regno < REG_GR || regno > REG_GR + 128)
+ as_warn (_("Register value annotation ignored"));
else
- {
- gr_values[regno-REG_GR].known = 1;
- gr_values[regno-REG_GR].value = value;
- gr_values[regno-REG_GR].path = md.path;
- }
+ {
+ gr_values[regno - REG_GR].known = 1;
+ gr_values[regno - REG_GR].value = value;
+ gr_values[regno - REG_GR].path = md.path;
+ }
}
demand_empty_rest_of_line ();
}
A stop is inserted when changing modes
*/
+
static void
dot_dv_mode (type)
- int type;
+ int type;
{
if (md.manual_bundling)
as_warn (_("Directive invalid within a bundle"));
case 'A':
case 'a':
if (md.explicit_mode)
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
md.explicit_mode = 0;
break;
case 'E':
case 'e':
if (!md.explicit_mode)
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
md.explicit_mode = 1;
break;
default:
case 'd':
if (md.explicit_mode != md.default_explicit_mode)
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
md.explicit_mode = md.default_explicit_mode;
md.mode_explicitly_set = 0;
break;
static void
print_prmask (mask)
- valueT mask;
+ valueT mask;
{
int regno;
char *comma = "";
- for (regno = 0;regno < 64;regno++)
+ for (regno = 0; regno < 64; regno++)
{
- if (mask & ((valueT) 1<<regno))
- {
- fprintf (stderr, "%s p%d", comma, regno);
- comma = ",";
- }
+ if (mask & ((valueT) 1 << regno))
+ {
+ fprintf (stderr, "%s p%d", comma, regno);
+ comma = ",";
+ }
}
}
.pred.rel.mutex p1, p2 [,...] (also .pred.rel "mutex")
.pred.safe_across_calls p1 [, p2 [,...]]
*/
+
static void
dot_pred_rel (type)
- int type;
+ int type;
{
valueT mask = 0;
int count = 0;
if (type == 0)
{
if (*input_line_pointer != '"')
- {
- as_bad (_("Missing predicate relation type"));
- ignore_rest_of_line ();
- return;
- }
+ {
+ as_bad (_("Missing predicate relation type"));
+ ignore_rest_of_line ();
+ return;
+ }
else
- {
- int len;
- char *form = demand_copy_C_string (&len);
- if (strcmp (form, "mutex") == 0)
- type = 'm';
- else if (strcmp (form, "clear") == 0)
- type = 'c';
- else if (strcmp (form, "imply") == 0)
- type = 'i';
- else
- {
- as_bad (_("Unrecognized predicate relation type"));
- ignore_rest_of_line ();
- return;
- }
- }
+ {
+ int len;
+ char *form = demand_copy_C_string (&len);
+ if (strcmp (form, "mutex") == 0)
+ type = 'm';
+ else if (strcmp (form, "clear") == 0)
+ type = 'c';
+ else if (strcmp (form, "imply") == 0)
+ type = 'i';
+ else
+ {
+ as_bad (_("Unrecognized predicate relation type"));
+ ignore_rest_of_line ();
+ return;
+ }
+ }
if (*input_line_pointer == ',')
- ++input_line_pointer;
+ ++input_line_pointer;
SKIP_WHITESPACE ();
}
int regno;
if (toupper (*input_line_pointer) != 'P'
- || (regno = atoi (++input_line_pointer)) < 0
- || regno > 63)
- {
- as_bad (_("Predicate register expected"));
- ignore_rest_of_line ();
- return;
- }
+ || (regno = atoi (++input_line_pointer)) < 0
+ || regno > 63)
+ {
+ as_bad (_("Predicate register expected"));
+ ignore_rest_of_line ();
+ return;
+ }
while (isdigit (*input_line_pointer))
- ++input_line_pointer;
+ ++input_line_pointer;
if (p1 == -1)
- p1 = regno;
+ p1 = regno;
else if (p2 == -1)
- p2 = regno;
+ p2 = regno;
bit <<= regno;
if (mask & bit)
- as_warn (_("Duplicate predicate register ignored"));
- mask |= bit; count++;
- /* see if it's a range */
+ as_warn (_("Duplicate predicate register ignored"));
+ mask |= bit;
+ count++;
+ /* See if it's a range. */
if (*input_line_pointer == '-')
- {
- valueT stop = 1;
- ++input_line_pointer;
-
- if (toupper (*input_line_pointer) != 'P'
- || (regno = atoi (++input_line_pointer)) < 0
- || regno > 63)
- {
- as_bad (_("Predicate register expected"));
- ignore_rest_of_line ();
- return;
- }
- while (isdigit (*input_line_pointer))
- ++input_line_pointer;
- stop <<= regno;
- if (bit >= stop)
- {
- as_bad (_("Bad register range"));
- ignore_rest_of_line ();
- return;
- }
- while (bit < stop)
- {
- bit <<= 1;
- mask |= bit; count++;
- }
- SKIP_WHITESPACE ();
- }
+ {
+ valueT stop = 1;
+ ++input_line_pointer;
+
+ if (toupper (*input_line_pointer) != 'P'
+ || (regno = atoi (++input_line_pointer)) < 0
+ || regno > 63)
+ {
+ as_bad (_("Predicate register expected"));
+ ignore_rest_of_line ();
+ return;
+ }
+ while (isdigit (*input_line_pointer))
+ ++input_line_pointer;
+ stop <<= regno;
+ if (bit >= stop)
+ {
+ as_bad (_("Bad register range"));
+ ignore_rest_of_line ();
+ return;
+ }
+ while (bit < stop)
+ {
+ bit <<= 1;
+ mask |= bit;
+ count++;
+ }
+ SKIP_WHITESPACE ();
+ }
if (*input_line_pointer != ',')
- break;
+ break;
++input_line_pointer;
SKIP_WHITESPACE ();
}
{
case 'c':
if (count == 0)
- mask = ~(valueT) 0;
+ mask = ~(valueT) 0;
clear_qp_mutex (mask);
clear_qp_implies (mask, (valueT) 0);
break;
case 'i':
if (count != 2 || p1 == -1 || p2 == -1)
- as_bad (_("Predicate source and target required"));
+ as_bad (_("Predicate source and target required"));
else if (p1 == 0 || p2 == 0)
- as_bad (_("Use of p0 is not valid in this context"));
+ as_bad (_("Use of p0 is not valid in this context"));
else
- add_qp_imply (p1, p2);
+ add_qp_imply (p1, p2);
break;
case 'm':
if (count < 2)
- {
- as_bad (_("At least two PR arguments expected"));
- break;
- }
+ {
+ as_bad (_("At least two PR arguments expected"));
+ break;
+ }
else if (mask & 1)
- {
- as_bad (_("Use of p0 is not valid in this context"));
- break;
- }
+ {
+ as_bad (_("Use of p0 is not valid in this context"));
+ break;
+ }
add_qp_mutex (mask);
break;
case 's':
/* note that we don't override any existing relations */
if (count == 0)
- {
- as_bad (_("At least one PR argument expected"));
- break;
- }
+ {
+ as_bad (_("At least one PR argument expected"));
+ break;
+ }
if (md.debug_dv)
- {
- fprintf (stderr, "Safe across calls: ");
- print_prmask (mask);
- fprintf (stderr, "\n");
- }
+ {
+ fprintf (stderr, "Safe across calls: ");
+ print_prmask (mask);
+ fprintf (stderr, "\n");
+ }
qp_safe_across_calls = mask;
break;
}
/* .entry label [, label [, ...]]
Hint to DV code that the given labels are to be considered entry points.
- Otherwise, only global labels are considered entry points.
- */
+ Otherwise, only global labels are considered entry points. */
+
static void
dot_entry (dummy)
- int dummy;
+ int dummy;
{
const char *err;
char *name;
err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (PTR) symbolP);
if (err)
- as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
- name, err);
+ as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
+ name, err);
*input_line_pointer = c;
SKIP_WHITESPACE ();
}
/* .mem.offset offset, base
- "base" is used to distinguish between offsets from a different base.
- */
+ "base" is used to distinguish between offsets from a different base. */
+
static void
dot_mem_offset (dummy)
int dummy;
demand_empty_rest_of_line ();
}
-/* ia64-specific pseudo-ops: */
+/* ia64-specific pseudo-ops: */
const pseudo_typeS md_pseudo_table[] =
{
{ "radix", dot_radix, 0 },
{ "xstring", dot_xstringer, 0 },
{ "xstringz", dot_xstringer, 1 },
- /* unaligned versions: */
+ /* unaligned versions: */
{ "xdata2.ua", dot_xdata_ua, 2 },
{ "xdata4.ua", dot_xdata_ua, 4 },
{ "xdata8.ua", dot_xdata_ua, 8 },
{ "string", stringer, 0 },
{ "stringz", stringer, 1 },
- /* unaligned versions: */
+ /* unaligned versions: */
{ "data2.ua", stmt_cons_ua, 2 },
{ "data4.ua", stmt_cons_ua, 4 },
{ "data8.ua", stmt_cons_ua, 8 },
/* Declare a register by creating a symbol for it and entering it in
the symbol table. */
-static symbolS*
+
+static symbolS *
declare_register (name, regnum)
const char *name;
int regnum;
switch (opnd)
{
- /* constants: */
+ /* constants: */
case IA64_OPND_AR_CCV:
if (e->X_op == O_register && e->X_add_number == REG_AR + 32)
return 1;
break;
- /* register operands: */
+ /* register operands: */
case IA64_OPND_AR3:
if (e->X_op == O_register && e->X_add_number >= REG_AR
return 1;
break;
- /* indirect operands: */
+ /* indirect operands: */
case IA64_OPND_CPUID_R3:
case IA64_OPND_DBR_R3:
case IA64_OPND_DTR_R3:
return 1;
break;
- /* immediate operands: */
+ /* immediate operands: */
case IA64_OPND_CNT2a:
case IA64_OPND_LEN4:
case IA64_OPND_LEN6:
case IA64_OPND_IMMU62:
if (e->X_op == O_constant)
- {
+ {
if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << 62))
- return 1;
- }
+ return 1;
+ }
else
- {
- /* FIXME -- need 62-bit relocation type */
- as_bad (_("62-bit relocation not yet implemented"));
- }
+ {
+ /* FIXME -- need 62-bit relocation type */
+ as_bad (_("62-bit relocation not yet implemented"));
+ }
break;
case IA64_OPND_IMMU64:
bits = operand_width (idesc->operands[index]);
if (e->X_op == O_constant
&& (bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
- {
- int lobits = e->X_add_number & 0x3;
- if (((bfd_vma) e->X_add_number & 0x3C) != 0 && lobits == 0)
- e->X_add_number |= (bfd_vma) 0x3;
- return 1;
- }
+ {
+ int lobits = e->X_add_number & 0x3;
+ if (((bfd_vma) e->X_add_number & 0x3C) != 0 && lobits == 0)
+ e->X_add_number |= (bfd_vma) 0x3;
+ return 1;
+ }
break;
case IA64_OPND_IMM44:
/* least 16 bits must be zero */
if ((e->X_add_number & 0xffff) != 0)
- as_warn (_("lower 16 bits of mask ignored"));
+ as_warn (_("lower 16 bits of mask ignored"));
if (e->X_op == O_constant
&& ((e->X_add_number >= 0
&& e->X_add_number < ((bfd_vma) 1 << 44))
|| (e->X_add_number < 0
&& -e->X_add_number <= ((bfd_vma) 1 << 44))))
- {
- /* sign-extend */
- if (e->X_add_number >= 0
- && (e->X_add_number & ((bfd_vma) 1 << 43)) != 0)
- {
- e->X_add_number |= ~(((bfd_vma) 1 << 44) - 1);
- }
- return 1;
- }
+ {
+ /* sign-extend */
+ if (e->X_add_number >= 0
+ && (e->X_add_number & ((bfd_vma) 1 << 43)) != 0)
+ {
+ e->X_add_number |= ~(((bfd_vma) 1 << 44) - 1);
+ }
+ return 1;
+ }
break;
case IA64_OPND_IMM17:
&& e->X_add_number < ((bfd_vma) 1 << 17))
|| (e->X_add_number < 0
&& -e->X_add_number <= ((bfd_vma) 1 << 17))))
- {
- /* sign-extend */
- if (e->X_add_number >= 0
- && (e->X_add_number & ((bfd_vma) 1 << 16)) != 0)
- {
- e->X_add_number |= ~(((bfd_vma) 1 << 17) - 1);
- }
- return 1;
- }
+ {
+ /* sign-extend */
+ if (e->X_add_number >= 0
+ && (e->X_add_number & ((bfd_vma) 1 << 16)) != 0)
+ {
+ e->X_add_number |= ~(((bfd_vma) 1 << 17) - 1);
+ }
+ return 1;
+ }
break;
case IA64_OPND_IMM14:
fix->code = BFD_RELOC_IA64_PCREL21M;
else if (opnd == IA64_OPND_TGT25c)
fix->code = BFD_RELOC_IA64_PCREL21B;
- else if (opnd == IA64_OPND_TGT64)
+ else if (opnd == IA64_OPND_TGT64)
fix->code = BFD_RELOC_IA64_PCREL60B;
else
abort ();
/* Parse the operands for the opcode and find the opcode variant that
matches the specified operands, or NULL if no match is possible. */
-static struct ia64_opcode*
+
+static struct ia64_opcode *
parse_operands (idesc)
struct ia64_opcode *idesc;
{
CURR_SLOT.opnd[4].X_add_number,
CURR_SLOT.opnd[5].X_add_number);
- /* now we can parse the first arg: */
+ /* now we can parse the first arg: */
saved_input_pointer = input_line_pointer;
input_line_pointer = first_arg;
sep = parse_operand (CURR_SLOT.opnd + 0);
continue;
case IA64_OPND_IMMU62:
- val &= 0x3fffffffffffffffULL;
- if (val != slot->opnd[i].X_add_number)
- as_warn (_("Value truncated to 62 bits"));
- *insnp++ = (val >> 21) & 0x1ffffffffffLL;
- insn |= (((val & 0xfffff) << 6) | (((val >> 20) & 0x1) << 36));
+ val &= 0x3fffffffffffffffULL;
+ if (val != slot->opnd[i].X_add_number)
+ as_warn (_("Value truncated to 62 bits"));
+ *insnp++ = (val >> 21) & 0x1ffffffffffLL;
+ insn |= (((val & 0xfffff) << 6) | (((val >> 20) & 0x1) << 36));
continue;
case IA64_OPND_TGT64:
enum ia64_unit required_unit, insn_unit = 0;
enum ia64_insn_type type[3], insn_type;
unsigned int template, orig_template;
- bfd_vma insn[3] = {-1, -1, -1};
+ bfd_vma insn[3] = { -1, -1, -1 };
struct ia64_opcode *idesc;
int end_of_insn_group = 0, user_template = -1;
int n, i, j, first, curr;
n = MIN (3, md.num_slots_in_use);
/* Determine template: user user_template if specified, best match
- otherwise: */
+ otherwise: */
if (md.slot[first].user_template >= 0)
user_template = template = md.slot[first].user_template;
template = best_template[type[0]][type[1]][type[2]];
}
- /* initialize instructions with appropriate nops: */
+ /* initialize instructions with appropriate nops: */
for (i = 0; i < 3; ++i)
insn[i] = nop[ia64_templ_desc[template].exec_unit[i]];
f = frag_more (16);
- /* now fill in slots with as many insns as possible: */
+ /* now fill in slots with as many insns as possible: */
curr = first;
idesc = md.slot[curr].idesc;
end_of_insn_group = 0;
{
/* Set the slot number for prologue/body records now as those
refer to the current point, not the point after the
- instruction has been issued: */
+ instruction has been issued: */
/* Don't try to delete prologue/body records here, as that will cause
them to also be deleted from the master list of unwind records. */
for (ptr = md.slot[curr].unwind_record; ptr; ptr = ptr->next)
}
required_unit = ia64_templ_desc[template].exec_unit[i];
- /* resolve dynamic opcodes such as "break" and "nop": */
+ /* resolve dynamic opcodes such as "break" and "nop": */
if (idesc->type == IA64_TYPE_DYN)
{
if ((strcmp (idesc->name, "nop") == 0)
if (required_unit == IA64_UNIT_I || required_unit == IA64_UNIT_M)
insn_unit = required_unit;
break;
- case IA64_TYPE_X: insn_unit = IA64_UNIT_L; break;
+ case IA64_TYPE_X: insn_unit = IA64_UNIT_L; break;
case IA64_TYPE_I: insn_unit = IA64_UNIT_I; break;
case IA64_TYPE_M: insn_unit = IA64_UNIT_M; break;
case IA64_TYPE_B: insn_unit = IA64_UNIT_B; break;
if (insn_unit != required_unit)
{
if (required_unit == IA64_UNIT_L
- && insn_unit == IA64_UNIT_I
+ && insn_unit == IA64_UNIT_I
&& !(idesc->flags & IA64_OPCODE_X_IN_MLX))
{
/* we got ourselves an MLX template but the current
md.slot[curr].src_line,
"`%s' can't go in X slot of "
"MLX template", idesc->name);
- /* drop this insn so we don't livelock: */
+ /* drop this insn so we don't livelock: */
--md.num_slots_in_use;
}
break;
{
bfd_vma addr;
- addr = frag_now->fr_address + frag_now_fix () - 16 + 1*i;
+ addr = frag_now->fr_address + frag_now_fix () - 16 + 1 * i;
dwarf2_gen_line_info (addr, &md.slot[curr].debug_line);
}
}
--md.num_slots_in_use;
- /* now is a good time to fix up the labels for this insn: */
+ /* now is a good time to fix up the labels for this insn: */
for (lfix = md.slot[curr].label_fixups; lfix; lfix = lfix->next)
{
S_SET_VALUE (lfix->sym, frag_now_fix () - 16);
end_of_insn_group = md.slot[curr].end_of_insn_group;
- /* clear slot: */
+ /* clear slot: */
ia64_free_opcode (md.slot[curr].idesc);
memset (md.slot + curr, 0, sizeof (md.slot[curr]));
md.slot[curr].user_template = -1;
case 'N':
if (strcmp (arg, "so") == 0)
{
- /* Suppress signon message. */
+ /* Suppress signon message. */
}
else if (strcmp (arg, "pi") == 0)
{
/* -X conflicts with an ignored option, use -x instead */
md.detect_dv = 1;
if (!arg || strcmp (arg, "explicit") == 0)
- {
- /* set default mode to explicit */
- md.default_explicit_mode = 1;
- break;
- }
+ {
+ /* set default mode to explicit */
+ md.default_explicit_mode = 1;
+ break;
+ }
else if (strcmp (arg, "auto") == 0)
- {
- md.default_explicit_mode = 0;
- }
+ {
+ md.default_explicit_mode = 0;
+ }
else if (strcmp (arg, "debug") == 0)
- {
- md.debug_dv = 1;
- }
+ {
+ md.debug_dv = 1;
+ }
else if (strcmp (arg, "debugx") == 0)
- {
- md.default_explicit_mode = 1;
- md.debug_dv = 1;
- }
+ {
+ md.default_explicit_mode = 1;
+ md.debug_dv = 1;
+ }
else
- {
- as_bad (_("Unrecognized option '-x%s'"), arg);
- }
+ {
+ as_bad (_("Unrecognized option '-x%s'"), arg);
+ }
break;
case 'S':
md_show_usage (stream)
FILE *stream;
{
- fputs(_("\
+ fputs (_("\
IA-64 options:\n\
-Milp32|-Milp64|-Mlp64|-Mp64 select data model (default -Mlp64)\n\
-Mle | -Mbe select little- or big-endian byte order (default -Mle)\n\
target_big_endian = 0;
pseudo_func[FUNC_FPTR_RELATIVE].u.sym =
- symbol_new (".<fptr>", undefined_section, FUNC_FPTR_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<fptr>", undefined_section, FUNC_FPTR_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_GP_RELATIVE].u.sym =
- symbol_new (".<gprel>", undefined_section, FUNC_GP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<gprel>", undefined_section, FUNC_GP_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_LT_RELATIVE].u.sym =
- symbol_new (".<ltoff>", undefined_section, FUNC_LT_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff>", undefined_section, FUNC_LT_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_PC_RELATIVE].u.sym =
-
symbol_new (".<pcrel>", undefined_section, FUNC_PC_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<pcrel>", undefined_section, FUNC_PC_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_PLT_RELATIVE].u.sym =
-
symbol_new (".<pltoff>", undefined_section, FUNC_PLT_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<pltoff>", undefined_section, FUNC_PLT_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_SEC_RELATIVE].u.sym =
- symbol_new (".<secrel>", undefined_section, FUNC_SEC_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<secrel>", undefined_section, FUNC_SEC_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_SEG_RELATIVE].u.sym =
- symbol_new (".<segrel>", undefined_section, FUNC_SEG_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<segrel>", undefined_section, FUNC_SEG_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_LTV_RELATIVE].u.sym =
- symbol_new (".<ltv>", undefined_section, FUNC_LTV_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltv>", undefined_section, FUNC_LTV_RELATIVE,
+ &zero_address_frag);
pseudo_func[FUNC_LT_FPTR_RELATIVE].u.sym =
- symbol_new (".<ltoff.fptr>", undefined_section, FUNC_LT_FPTR_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff.fptr>", undefined_section, FUNC_LT_FPTR_RELATIVE,
+ &zero_address_frag);
/* Compute the table of best templates. We compute goodness as a
base 4 value, in which each match counts for 3, each F counts
md.const_hash = hash_new ();
md.entry_hash = hash_new ();
- /* general registers: */
+ /* general registers: */
total = 128;
for (i = 0; i < total; ++i)
md.regsym[i] = declare_register (name, i);
}
- /* floating point registers: */
+ /* floating point registers: */
total += 128;
for (; i < total; ++i)
{
md.regsym[i] = declare_register (name, i);
}
- /* application registers: */
+ /* application registers: */
total += 128;
ar_base = i;
for (; i < total; ++i)
md.regsym[i] = declare_register (name, i);
}
- /* control registers: */
+ /* control registers: */
total += 128;
cr_base = i;
for (; i < total; ++i)
md.regsym[i] = declare_register (name, i);
}
- /* predicate registers: */
+ /* predicate registers: */
total += 64;
for (; i < total; ++i)
{
md.regsym[i] = declare_register (name, i);
}
- /* branch registers: */
+ /* branch registers: */
total += 8;
for (; i < total; ++i)
{
md.regsym[regnum] = declare_register (indirect_reg[i].name, regnum);
}
- /* define synonyms for application registers: */
+ /* define synonyms for application registers: */
for (i = REG_AR; i < REG_AR + NELEMS (ar); ++i)
md.regsym[i] = declare_register (ar[i - REG_AR].name,
REG_AR + ar[i - REG_AR].regnum);
- /* define synonyms for control registers: */
+ /* define synonyms for control registers: */
for (i = REG_CR; i < REG_CR + NELEMS (cr); ++i)
md.regsym[i] = declare_register (cr[i - REG_CR].name,
REG_CR + cr[i - REG_CR].regnum);
declare_register ("sp", REG_GR + 12);
declare_register ("rp", REG_BR + 0);
- /* pseudo-registers used to specify unwind info: */
+ /* pseudo-registers used to specify unwind info: */
declare_register ("psp", REG_PSP);
declare_register_set ("ret", 4, REG_GR + 8);
void
ia64_end_of_source ()
{
- /* terminate insn group upon reaching end of file: */
+ /* terminate insn group upon reaching end of file: */
insn_group_break (1, 0, 0);
- /* emits slots we haven't written yet: */
+ /* emits slots we haven't written yet: */
ia64_flush_insns ();
bfd_set_private_flags (stdoutput, md.flags);
if (input_line_pointer[0] == ';' && input_line_pointer[-1] == ';')
{
if (md.detect_dv && !md.explicit_mode)
- as_warn (_("Explicit stops are ignored in auto mode"));
+ as_warn (_("Explicit stops are ignored in auto mode"));
else
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
}
}
CURR_SLOT.manual_bundling_on = 1;
md.manual_bundling = 1;
- /* bundling is only acceptable in explicit mode
- or when in default automatic mode */
+ /* Bundling is only acceptable in explicit mode
+ or when in default automatic mode. */
if (md.detect_dv && !md.explicit_mode)
- {
- if (!md.mode_explicitly_set
- && !md.default_explicit_mode)
- dot_dv_mode ('E');
- else
- as_warn (_("Found '{' after explicit switch to automatic mode"));
- }
+ {
+ if (!md.mode_explicitly_set
+ && !md.default_explicit_mode)
+ dot_dv_mode ('E');
+ else
+ as_warn (_("Found '{' after explicit switch to automatic mode"));
+ }
return 1;
case '}':
/* switch back to automatic mode, if applicable */
if (md.detect_dv
- && md.explicit_mode
- && !md.mode_explicitly_set
- && !md.default_explicit_mode)
- dot_dv_mode ('A');
+ && md.explicit_mode
+ && !md.mode_explicitly_set
+ && !md.default_explicit_mode)
+ dot_dv_mode ('A');
/* Allow '{' to follow on the same line. We also allow ";;", but that
happens automatically because ';' is an end of line marker. */
default:
break;
}
- return 0; /* not a valid line */
+
+ /* Not a valid line. */
+ return 0;
}
void
fix->next = CURR_SLOT.label_fixups;
CURR_SLOT.label_fixups = fix;
- /* keep track of how many code entry points we've seen */
+ /* Keep track of how many code entry points we've seen. */
if (md.path == md.maxpaths)
- {
- md.maxpaths += 20;
- md.entry_labels = (const char **)
- xrealloc ((void *)md.entry_labels, md.maxpaths * sizeof (char *));
- }
+ {
+ md.maxpaths += 20;
+ md.entry_labels = (const char **)
+ xrealloc ((void *) md.entry_labels,
+ md.maxpaths * sizeof (char *));
+ }
md.entry_labels[md.path++] = S_GET_NAME (sym);
}
}
struct symbol *sym;
char *end;
- /* first see if NAME is a known register name: */
+ /* first see if NAME is a known register name: */
sym = hash_find (md.reg_hash, name);
if (sym)
{
return 1;
}
- /* check for inN, locN, or outN: */
+ /* check for inN, locN, or outN: */
switch (name[0])
{
case 'i':
if (dr)
{
- /* the name is inN, locN, or outN; parse the register number: */
+ /* The name is inN, locN, or outN; parse the register number. */
regnum = strtoul (name, &end, 10);
if (end > name && *end == '\0')
{
if (!dr->num_regs)
as_bad ("No current frame");
else
- as_bad ("Register number out of range 0..%u", dr->num_regs-1);
+ as_bad ("Register number out of range 0..%u",
+ dr->num_regs - 1);
regnum = 0;
}
e->X_op = O_register;
if ((dr = hash_find (md.dynreg_hash, name)))
{
/* We've got ourselves the name of a rotating register set.
- Store the base register number in the low 16 bits of
- X_add_number and the size of the register set in the top 16
- bits. */
+ Store the base register number in the low 16 bits of
+ X_add_number and the size of the register set in the top 16
+ bits. */
e->X_op = O_register;
e->X_add_number = dr->base | (dr->num_regs << 16);
return 1;
ia64_canonicalize_symbol_name (name)
char *name;
{
- size_t len = strlen(name);
- if (len > 1 && name[len-1] == '#')
- name[len-1] = '\0';
+ size_t len = strlen (name);
+ if (len > 1 && name[len - 1] == '#')
+ name[len - 1] = '\0';
return name;
}
static int
is_conditional_branch (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
return (strncmp (idesc->name, "br", 2) == 0
- && (strcmp (idesc->name, "br") == 0
- || strncmp (idesc->name, "br.cond", 7) == 0
- || strncmp (idesc->name, "br.call", 7) == 0
- || strncmp (idesc->name, "br.ret", 6) == 0
- || strcmp (idesc->name, "brl") == 0
- || strncmp (idesc->name, "brl.cond", 7) == 0
- || strncmp (idesc->name, "brl.call", 7) == 0
- || strncmp (idesc->name, "brl.ret", 6) == 0));
+ && (strcmp (idesc->name, "br") == 0
+ || strncmp (idesc->name, "br.cond", 7) == 0
+ || strncmp (idesc->name, "br.call", 7) == 0
+ || strncmp (idesc->name, "br.ret", 6) == 0
+ || strcmp (idesc->name, "brl") == 0
+ || strncmp (idesc->name, "brl.cond", 7) == 0
+ || strncmp (idesc->name, "brl.call", 7) == 0
+ || strncmp (idesc->name, "brl.ret", 6) == 0));
}
/* Return whether the given opcode is a taken branch. If there's any doubt,
- returns zero */
+ returns zero. */
+
static int
is_taken_branch (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
return ((is_conditional_branch (idesc) && CURR_SLOT.qp_regno == 0)
- || strncmp (idesc->name, "br.ia", 5) == 0);
+ || strncmp (idesc->name, "br.ia", 5) == 0);
}
/* Return whether the given opcode is an interruption or rfi. If there's any
- doubt, returns zero */
+ doubt, returns zero. */
+
static int
is_interruption_or_rfi (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
if (strcmp (idesc->name, "rfi") == 0)
return 1;
/* Returns the index of the given dependency in the opcode's list of chks, or
-1 if there is no dependency. */
+
static int
depends_on (depind, idesc)
- int depind;
- struct ia64_opcode *idesc;
+ int depind;
+ struct ia64_opcode *idesc;
{
int i;
const struct ia64_opcode_dependency *dep = idesc->dependencies;
- for (i = 0;i < dep->nchks; i++)
+ for (i = 0; i < dep->nchks; i++)
{
- if (depind == DEP(dep->chks[i]))
- return i;
+ if (depind == DEP (dep->chks[i]))
+ return i;
}
return -1;
}
Memory resources (i.e. locations in memory) are *not* marked or tracked by
this code; there are no dependency violations based on memory access.
-
*/
#define MAX_SPECS 256
static int
specify_resource (dep, idesc, type, specs, note, path)
- const struct ia64_dependency *dep;
- struct ia64_opcode *idesc;
- int type; /* is this a DV chk or a DV reg? */
- struct rsrc specs[MAX_SPECS]; /* returned specific resources */
- int note; /* resource note for this insn's usage */
- int path; /* which execution path to examine */
+ const struct ia64_dependency *dep;
+ struct ia64_opcode *idesc;
+ int type; /* is this a DV chk or a DV reg? */
+ struct rsrc specs[MAX_SPECS]; /* returned specific resources */
+ int note; /* resource note for this insn's usage */
+ int path; /* which execution path to examine */
{
int count = 0;
int i;
{
case IA64_RS_AR_K:
if (note == 1)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
- if (regno >= 0 && regno <= 7)
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
+ if (regno >= 0 && regno <= 7)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
+ }
else if (note == 0)
- {
- for(i=0;i < 8;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
+ {
+ for (i = 0; i < 8; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_AR_UNAT:
specs[count] = tmpl;
if (md.mem_offset.hint)
{
- if (md.debug_dv)
- fprintf (stderr, " Using hint for spill/fill\n");
- /* the index isn't actually used, just set it to something
- approximating the bit index */
+ if (md.debug_dv)
+ fprintf (stderr, " Using hint for spill/fill\n");
+ /* The index isn't actually used, just set it to something
+ approximating the bit index. */
specs[count].index = (md.mem_offset.offset >> 3) & 0x3F;
specs[count].mem_offset.hint = 1;
specs[count].mem_offset.offset = md.mem_offset.offset;
case IA64_RS_AR:
if (note == 1)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
- if ((regno >= 8 && regno <= 15)
- || (regno >= 20 && regno <= 23)
- || (regno >= 31 && regno <= 39)
- || (regno >= 41 && regno <= 47)
- || (regno >= 67 && regno <= 111))
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
+ if ((regno >= 8 && regno <= 15)
+ || (regno >= 20 && regno <= 23)
+ || (regno >= 31 && regno <= 39)
+ || (regno >= 41 && regno <= 47)
+ || (regno >= 67 && regno <= 111))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_ARb:
if (note == 1)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
- if ((regno >= 48 && regno <= 63)
- || (regno >= 112 && regno <= 127))
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
+ if ((regno >= 48 && regno <= 63)
+ || (regno >= 112 && regno <= 127))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
+ }
else if (note == 0)
- {
- for (i=48;i < 64;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- for (i=112;i < 128;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
+ {
+ for (i = 48; i < 64; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ for (i = 112; i < 128; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_BR:
if (note != 1)
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
else
- {
- if (rsrc_write)
- {
- for (i=0;i < idesc->num_outputs;i++)
- if (idesc->operands[i] == IA64_OPND_B1
- || idesc->operands[i] == IA64_OPND_B2)
- {
- specs[count] = tmpl;
- specs[count++].index =
- CURR_SLOT.opnd[i].X_add_number - REG_BR;
- }
- }
- else
- {
- for (i = idesc->num_outputs;i < NELEMS(idesc->operands);i++)
- if (idesc->operands[i] == IA64_OPND_B1
- || idesc->operands[i] == IA64_OPND_B2)
- {
- specs[count] = tmpl;
- specs[count++].index =
- CURR_SLOT.opnd[i].X_add_number - REG_BR;
- }
- }
- }
+ {
+ if (rsrc_write)
+ {
+ for (i = 0; i < idesc->num_outputs; i++)
+ if (idesc->operands[i] == IA64_OPND_B1
+ || idesc->operands[i] == IA64_OPND_B2)
+ {
+ specs[count] = tmpl;
+ specs[count++].index =
+ CURR_SLOT.opnd[i].X_add_number - REG_BR;
+ }
+ }
+ else
+ {
+ for (i = idesc->num_outputs;i < NELEMS (idesc->operands); i++)
+ if (idesc->operands[i] == IA64_OPND_B1
+ || idesc->operands[i] == IA64_OPND_B2)
+ {
+ specs[count] = tmpl;
+ specs[count++].index =
+ CURR_SLOT.opnd[i].X_add_number - REG_BR;
+ }
+ }
+ }
break;
case IA64_RS_CPUID: /* four or more registers */
if (note == 3)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_CPUID_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CPUID_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_DBR: /* four or more registers */
if (note == 3)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_DBR_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_DBR_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
else if (note == 0 && !rsrc_write)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_IBR: /* four or more registers */
if (note == 3)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_IBR_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_IBR_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_MSR:
case IA64_RS_PKR: /* 16 or more registers */
if (note == 3 || note == 4)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_PKR_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- if (note == 3)
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else for (i=0;i < NELEMS(gr_values);i++)
- {
- /* uses all registers *except* the one in R3 */
- if (i != (gr_values[regno].value & 0xFF))
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
- else if (note == 0)
- {
- /* probe et al. */
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- break;
-
- case IA64_RS_PMC: /* four or more registers */
- if (note == 3)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_PMC_R3
- || (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3))
-
- {
- int index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
- ? 1 : !rsrc_write);
- int regno = CURR_SLOT.opnd[index].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
- else
- {
- UNHANDLED;
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_PKR_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ if (note == 3)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ for (i = 0; i < NELEMS (gr_values); i++)
+ {
+ /* Uses all registers *except* the one in R3. */
+ if (i != (gr_values[regno].value & 0xFF))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
+ else if (note == 0)
+ {
+ /* probe et al. */
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ break;
+
+ case IA64_RS_PMC: /* four or more registers */
+ if (note == 3)
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_PMC_R3
+ || (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3))
+
+ {
+ int index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
+ ? 1 : !rsrc_write);
+ int regno = CURR_SLOT.opnd[index].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
+ else
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_PMD: /* four or more registers */
if (note == 3)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_PMD_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = gr_values[regno].value & 0xFF;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_PMD_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = gr_values[regno].value & 0xFF;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_RR: /* eight registers */
if (note == 6)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_RR_R3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
- if (regno >= 0 && regno < NELEMS(gr_values)
- && KNOWN(regno))
- {
- specs[count] = tmpl;
- specs[count++].index = (gr_values[regno].value >> 61) & 0x7;
- }
- else
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_RR_R3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_GR;
+ if (regno >= 0 && regno < NELEMS (gr_values)
+ && KNOWN (regno))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = (gr_values[regno].value >> 61) & 0x7;
+ }
+ else
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
else if (note == 0 && !rsrc_write)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_CR_IRR:
if (note == 0)
- {
- /* handle mov-from-CR-IVR; it's a read that writes CR[IRR] */
- int regno = CURR_SLOT.opnd[1].X_add_number - REG_CR;
- if (rsrc_write
- && idesc->operands[1] == IA64_OPND_CR3
- && regno == CR_IVR)
- {
- for(i=0;i < 4;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = CR_IRR0 + i;
- }
- }
- }
+ {
+ /* handle mov-from-CR-IVR; it's a read that writes CR[IRR] */
+ int regno = CURR_SLOT.opnd[1].X_add_number - REG_CR;
+ if (rsrc_write
+ && idesc->operands[1] == IA64_OPND_CR3
+ && regno == CR_IVR)
+ {
+ for (i = 0; i < 4; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = CR_IRR0 + i;
+ }
+ }
+ }
else if (note == 1)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
- if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
- && regno >= CR_IRR0
- && regno <= CR_IRR3)
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
+ && regno >= CR_IRR0
+ && regno <= CR_IRR3)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_CR_LRR:
if (note != 1)
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
else
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
- if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
- && (regno == CR_LRR0 || regno == CR_LRR1))
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
+ && (regno == CR_LRR0 || regno == CR_LRR1))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
break;
case IA64_RS_CR:
if (note == 1)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
- {
- specs[count] = tmpl;
- specs[count++].index =
- CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
+ {
+ specs[count] = tmpl;
+ specs[count++].index =
+ CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_FR:
case IA64_RS_FRb:
if (note != 1)
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
else if (rsrc_write)
- {
- if (dep->specifier == IA64_RS_FRb
- && idesc->operands[0] == IA64_OPND_F1)
- {
- specs[count] = tmpl;
- specs[count++].index = CURR_SLOT.opnd[0].X_add_number - REG_FR;
- }
- }
+ {
+ if (dep->specifier == IA64_RS_FRb
+ && idesc->operands[0] == IA64_OPND_F1)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = CURR_SLOT.opnd[0].X_add_number - REG_FR;
+ }
+ }
else
- {
- for (i=idesc->num_outputs;i < NELEMS(idesc->operands);i++)
- {
- if (idesc->operands[i] == IA64_OPND_F2
- || idesc->operands[i] == IA64_OPND_F3
- || idesc->operands[i] == IA64_OPND_F4)
- {
- specs[count] = tmpl;
- specs[count++].index =
- CURR_SLOT.opnd[i].X_add_number - REG_FR;
- }
- }
- }
+ {
+ for (i = idesc->num_outputs; i < NELEMS (idesc->operands); i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_F2
+ || idesc->operands[i] == IA64_OPND_F3
+ || idesc->operands[i] == IA64_OPND_F4)
+ {
+ specs[count] = tmpl;
+ specs[count++].index =
+ CURR_SLOT.opnd[i].X_add_number - REG_FR;
+ }
+ }
+ }
break;
case IA64_RS_GR:
if (note == 13)
- {
- /* This reference applies only to the GR whose value is loaded with
- data returned from memory */
- specs[count] = tmpl;
- specs[count++].index = CURR_SLOT.opnd[0].X_add_number - REG_GR;
- }
+ {
+ /* This reference applies only to the GR whose value is loaded with
+ data returned from memory. */
+ specs[count] = tmpl;
+ specs[count++].index = CURR_SLOT.opnd[0].X_add_number - REG_GR;
+ }
else if (note == 1)
- {
- if (rsrc_write)
- {
- for (i= 0; i < idesc->num_outputs; i++)
+ {
+ if (rsrc_write)
+ {
+ for (i = 0; i < idesc->num_outputs; i++)
if (idesc->operands[i] == IA64_OPND_R1
|| idesc->operands[i] == IA64_OPND_R2
|| idesc->operands[i] == IA64_OPND_R3)
specs[count++].index =
CURR_SLOT.opnd[i].X_add_number - REG_GR;
}
- }
- else
- {
- /* Look for anything that reads a GR */
- for (i=0;i < NELEMS(idesc->operands);i++)
- {
- if (idesc->operands[i] == IA64_OPND_MR3
- || idesc->operands[i] == IA64_OPND_CPUID_R3
- || idesc->operands[i] == IA64_OPND_DBR_R3
- || idesc->operands[i] == IA64_OPND_IBR_R3
+ }
+ else
+ {
+ /* Look for anything that reads a GR. */
+ for (i = 0; i < NELEMS (idesc->operands); i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_MR3
+ || idesc->operands[i] == IA64_OPND_CPUID_R3
+ || idesc->operands[i] == IA64_OPND_DBR_R3
+ || idesc->operands[i] == IA64_OPND_IBR_R3
|| idesc->operands[i] == IA64_OPND_MSR_R3
- || idesc->operands[i] == IA64_OPND_PKR_R3
- || idesc->operands[i] == IA64_OPND_PMC_R3
- || idesc->operands[i] == IA64_OPND_PMD_R3
- || idesc->operands[i] == IA64_OPND_RR_R3
- || ((i >= idesc->num_outputs)
- && (idesc->operands[i] == IA64_OPND_R1
- || idesc->operands[i] == IA64_OPND_R2
- || idesc->operands[i] == IA64_OPND_R3
+ || idesc->operands[i] == IA64_OPND_PKR_R3
+ || idesc->operands[i] == IA64_OPND_PMC_R3
+ || idesc->operands[i] == IA64_OPND_PMD_R3
+ || idesc->operands[i] == IA64_OPND_RR_R3
+ || ((i >= idesc->num_outputs)
+ && (idesc->operands[i] == IA64_OPND_R1
+ || idesc->operands[i] == IA64_OPND_R2
+ || idesc->operands[i] == IA64_OPND_R3
/* addl source register. */
|| idesc->operands[i] == IA64_OPND_R3_2)))
- {
- specs[count] = tmpl;
- specs[count++].index =
- CURR_SLOT.opnd[i].X_add_number - REG_GR;
- }
- }
- }
- }
+ {
+ specs[count] = tmpl;
+ specs[count++].index =
+ CURR_SLOT.opnd[i].X_add_number - REG_GR;
+ }
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_PR:
if (note == 0)
- {
- if (idesc->operands[0] == IA64_OPND_PR_ROT)
- {
- for (i=16;i < 63;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- else
- {
- for (i=1;i < 63;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- }
+ {
+ if (idesc->operands[0] == IA64_OPND_PR_ROT)
+ {
+ for (i = 16; i < 63; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ else
+ {
+ for (i = 1; i < 63; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ }
else if (note == 7)
- {
- valueT mask = 0;
- /* mark only those registers indicated by the mask */
- if (rsrc_write
- && idesc->operands[0] == IA64_OPND_PR)
- {
- mask = CURR_SLOT.opnd[2].X_add_number;
- if (mask & ((valueT) 1<<16))
- mask |= ~(valueT) 0xffff;
- for (i=1;i < 63;i++)
- {
- if (mask & ((valueT) 1<<i))
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- }
- else if (rsrc_write
- && idesc->operands[0] == IA64_OPND_PR_ROT)
- {
- for (i=16;i < 63;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- else
- {
- UNHANDLED;
- }
- }
+ {
+ valueT mask = 0;
+ /* Mark only those registers indicated by the mask. */
+ if (rsrc_write
+ && idesc->operands[0] == IA64_OPND_PR)
+ {
+ mask = CURR_SLOT.opnd[2].X_add_number;
+ if (mask & ((valueT) 1 << 16))
+ mask |= ~(valueT) 0xffff;
+ for (i = 1; i < 63; i++)
+ {
+ if (mask & ((valueT) 1 << i))
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ }
+ else if (rsrc_write
+ && idesc->operands[0] == IA64_OPND_PR_ROT)
+ {
+ for (i = 16; i < 63; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ else
+ {
+ UNHANDLED;
+ }
+ }
else if (note == 11) /* note 11 implies note 1 as well */
- {
- if (rsrc_write)
- {
- for (i=0;i < idesc->num_outputs;i++)
- {
- if (idesc->operands[i] == IA64_OPND_P1
- || idesc->operands[i] == IA64_OPND_P2)
- {
- int regno = CURR_SLOT.opnd[i].X_add_number - REG_P;
- if (regno != 0)
- {
- specs[count] = tmpl;
- specs[count++].index = regno;
- }
- }
- }
- }
- else
- {
- UNHANDLED;
- }
- }
+ {
+ if (rsrc_write)
+ {
+ for (i = 0; i < idesc->num_outputs; i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_P1
+ || idesc->operands[i] == IA64_OPND_P2)
+ {
+ int regno = CURR_SLOT.opnd[i].X_add_number - REG_P;
+ if (regno != 0)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = regno;
+ }
+ }
+ }
+ }
+ else
+ {
+ UNHANDLED;
+ }
+ }
else if (note == 12)
- {
- if (CURR_SLOT.qp_regno != 0)
- {
- specs[count] = tmpl;
- specs[count++].index = CURR_SLOT.qp_regno;
- }
- }
+ {
+ if (CURR_SLOT.qp_regno != 0)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = CURR_SLOT.qp_regno;
+ }
+ }
else if (note == 1)
- {
- if (rsrc_write)
- {
- int p1 = CURR_SLOT.opnd[0].X_add_number - REG_P;
- int p2 = CURR_SLOT.opnd[1].X_add_number - REG_P;
- if ((idesc->operands[0] == IA64_OPND_P1
- || idesc->operands[0] == IA64_OPND_P2)
- && p1 != 0 && p1 != 63)
- {
- specs[count] = tmpl;
- specs[count++].index = p1;
- }
- if ((idesc->operands[1] == IA64_OPND_P1
- || idesc->operands[1] == IA64_OPND_P2)
- && p2 != 0 && p2 != 63)
- {
- specs[count] = tmpl;
- specs[count++].index = p2;
- }
- }
- else
- {
- if (CURR_SLOT.qp_regno != 0)
- {
- specs[count] = tmpl;
- specs[count++].index = CURR_SLOT.qp_regno;
- }
- if (idesc->operands[1] == IA64_OPND_PR)
- {
- for (i=1;i < 63;i++)
- {
- specs[count] = tmpl;
- specs[count++].index = i;
- }
- }
- }
- }
+ {
+ if (rsrc_write)
+ {
+ int p1 = CURR_SLOT.opnd[0].X_add_number - REG_P;
+ int p2 = CURR_SLOT.opnd[1].X_add_number - REG_P;
+ if ((idesc->operands[0] == IA64_OPND_P1
+ || idesc->operands[0] == IA64_OPND_P2)
+ && p1 != 0 && p1 != 63)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = p1;
+ }
+ if ((idesc->operands[1] == IA64_OPND_P1
+ || idesc->operands[1] == IA64_OPND_P2)
+ && p2 != 0 && p2 != 63)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = p2;
+ }
+ }
+ else
+ {
+ if (CURR_SLOT.qp_regno != 0)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = CURR_SLOT.qp_regno;
+ }
+ if (idesc->operands[1] == IA64_OPND_PR)
+ {
+ for (i = 1; i < 63; i++)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = i;
+ }
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_PSR:
/* Verify that the instruction is using the PSR bit indicated in
- dep->regindex */
+ dep->regindex. */
if (note == 0)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_PSR_UM)
- {
- if (dep->regindex < 6)
- {
- specs[count++] = tmpl;
- }
- }
- else if (idesc->operands[!rsrc_write] == IA64_OPND_PSR)
- {
- if (dep->regindex < 32
- || dep->regindex == 35
- || dep->regindex == 36
- || (!rsrc_write && dep->regindex == PSR_CPL))
- {
- specs[count++] = tmpl;
- }
- }
- else if (idesc->operands[!rsrc_write] == IA64_OPND_PSR_L)
- {
- if (dep->regindex < 32
- || dep->regindex == 35
- || dep->regindex == 36
- || (rsrc_write && dep->regindex == PSR_CPL))
- {
- specs[count++] = tmpl;
- }
- }
- else
- {
- /* Several PSR bits have very specific dependencies. */
- switch (dep->regindex)
- {
- default:
- specs[count++] = tmpl;
- break;
- case PSR_IC:
- if (rsrc_write)
- {
- specs[count++] = tmpl;
- }
- else
- {
- /* Only certain CR accesses use PSR.ic */
- if (idesc->operands[0] == IA64_OPND_CR3
- || idesc->operands[1] == IA64_OPND_CR3)
- {
- int index =
- ((idesc->operands[0] == IA64_OPND_CR3)
- ? 0 : 1);
- int regno =
- CURR_SLOT.opnd[index].X_add_number - REG_CR;
-
- switch (regno)
- {
- default:
- break;
- case CR_ITIR:
- case CR_IFS:
- case CR_IIM:
- case CR_IIP:
- case CR_IPSR:
- case CR_ISR:
- case CR_IFA:
- case CR_IHA:
- case CR_IIPA:
- specs[count++] = tmpl;
- break;
- }
- }
- }
- break;
- case PSR_CPL:
- if (rsrc_write)
- {
- specs[count++] = tmpl;
- }
- else
- {
- /* Only some AR accesses use cpl */
- if (idesc->operands[0] == IA64_OPND_AR3
- || idesc->operands[1] == IA64_OPND_AR3)
- {
- int index =
- ((idesc->operands[0] == IA64_OPND_AR3)
- ? 0 : 1);
- int regno =
- CURR_SLOT.opnd[index].X_add_number - REG_AR;
-
- if (regno == AR_ITC
- || (index == 0
- && (regno == AR_ITC
- || regno == AR_RSC
- || (regno >= AR_K0
- && regno <= AR_K7))))
- {
- specs[count++] = tmpl;
- }
- }
- else
- {
- specs[count++] = tmpl;
- }
- break;
- }
- }
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_PSR_UM)
+ {
+ if (dep->regindex < 6)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else if (idesc->operands[!rsrc_write] == IA64_OPND_PSR)
+ {
+ if (dep->regindex < 32
+ || dep->regindex == 35
+ || dep->regindex == 36
+ || (!rsrc_write && dep->regindex == PSR_CPL))
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else if (idesc->operands[!rsrc_write] == IA64_OPND_PSR_L)
+ {
+ if (dep->regindex < 32
+ || dep->regindex == 35
+ || dep->regindex == 36
+ || (rsrc_write && dep->regindex == PSR_CPL))
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else
+ {
+ /* Several PSR bits have very specific dependencies. */
+ switch (dep->regindex)
+ {
+ default:
+ specs[count++] = tmpl;
+ break;
+ case PSR_IC:
+ if (rsrc_write)
+ {
+ specs[count++] = tmpl;
+ }
+ else
+ {
+ /* Only certain CR accesses use PSR.ic */
+ if (idesc->operands[0] == IA64_OPND_CR3
+ || idesc->operands[1] == IA64_OPND_CR3)
+ {
+ int index =
+ ((idesc->operands[0] == IA64_OPND_CR3)
+ ? 0 : 1);
+ int regno =
+ CURR_SLOT.opnd[index].X_add_number - REG_CR;
+
+ switch (regno)
+ {
+ default:
+ break;
+ case CR_ITIR:
+ case CR_IFS:
+ case CR_IIM:
+ case CR_IIP:
+ case CR_IPSR:
+ case CR_ISR:
+ case CR_IFA:
+ case CR_IHA:
+ case CR_IIPA:
+ specs[count++] = tmpl;
+ break;
+ }
+ }
+ }
+ break;
+ case PSR_CPL:
+ if (rsrc_write)
+ {
+ specs[count++] = tmpl;
+ }
+ else
+ {
+ /* Only some AR accesses use cpl */
+ if (idesc->operands[0] == IA64_OPND_AR3
+ || idesc->operands[1] == IA64_OPND_AR3)
+ {
+ int index =
+ ((idesc->operands[0] == IA64_OPND_AR3)
+ ? 0 : 1);
+ int regno =
+ CURR_SLOT.opnd[index].X_add_number - REG_AR;
+
+ if (regno == AR_ITC
+ || (index == 0
+ && (regno == AR_ITC
+ || regno == AR_RSC
+ || (regno >= AR_K0
+ && regno <= AR_K7))))
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else
+ {
+ specs[count++] = tmpl;
+ }
+ break;
+ }
+ }
+ }
+ }
else if (note == 7)
- {
- valueT mask = 0;
- if (idesc->operands[0] == IA64_OPND_IMMU24)
- {
- mask = CURR_SLOT.opnd[0].X_add_number;
- }
- else
- {
- UNHANDLED;
- }
- if (mask & ((valueT) 1<<dep->regindex))
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ valueT mask = 0;
+ if (idesc->operands[0] == IA64_OPND_IMMU24)
+ {
+ mask = CURR_SLOT.opnd[0].X_add_number;
+ }
+ else
+ {
+ UNHANDLED;
+ }
+ if (mask & ((valueT) 1 << dep->regindex))
+ {
+ specs[count++] = tmpl;
+ }
+ }
else if (note == 8)
- {
- int min = dep->regindex == PSR_DFL ? 2 : 32;
- int max = dep->regindex == PSR_DFL ? 31 : 127;
- /* dfh is read on FR32-127; dfl is read on FR2-31 */
- for (i=0;i < NELEMS(idesc->operands);i++)
- {
- if (idesc->operands[i] == IA64_OPND_F1
- || idesc->operands[i] == IA64_OPND_F2
- || idesc->operands[i] == IA64_OPND_F3
- || idesc->operands[i] == IA64_OPND_F4)
- {
- int reg = CURR_SLOT.opnd[i].X_add_number - REG_FR;
- if (reg >= min && reg <= max)
- {
- specs[count++] = tmpl;
- }
- }
- }
- }
+ {
+ int min = dep->regindex == PSR_DFL ? 2 : 32;
+ int max = dep->regindex == PSR_DFL ? 31 : 127;
+ /* dfh is read on FR32-127; dfl is read on FR2-31 */
+ for (i = 0; i < NELEMS (idesc->operands); i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_F1
+ || idesc->operands[i] == IA64_OPND_F2
+ || idesc->operands[i] == IA64_OPND_F3
+ || idesc->operands[i] == IA64_OPND_F4)
+ {
+ int reg = CURR_SLOT.opnd[i].X_add_number - REG_FR;
+ if (reg >= min && reg <= max)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
+ }
else if (note == 9)
- {
- int min = dep->regindex == PSR_MFL ? 2 : 32;
- int max = dep->regindex == PSR_MFL ? 31 : 127;
- /* mfh is read on writes to FR32-127; mfl is read on writes to
- FR2-31 */
- for (i=0;i < idesc->num_outputs;i++)
- {
- if (idesc->operands[i] == IA64_OPND_F1)
- {
- int reg = CURR_SLOT.opnd[i].X_add_number - REG_FR;
- if (reg >= min && reg <= max)
- {
- specs[count++] = tmpl;
- }
- }
- }
- }
+ {
+ int min = dep->regindex == PSR_MFL ? 2 : 32;
+ int max = dep->regindex == PSR_MFL ? 31 : 127;
+ /* mfh is read on writes to FR32-127; mfl is read on writes to
+ FR2-31 */
+ for (i = 0; i < idesc->num_outputs; i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_F1)
+ {
+ int reg = CURR_SLOT.opnd[i].X_add_number - REG_FR;
+ if (reg >= min && reg <= max)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
+ }
else if (note == 10)
- {
- for (i=0;i < NELEMS(idesc->operands);i++)
- {
- if (idesc->operands[i] == IA64_OPND_R1
- || idesc->operands[i] == IA64_OPND_R2
- || idesc->operands[i] == IA64_OPND_R3)
- {
- int regno = CURR_SLOT.opnd[i].X_add_number - REG_GR;
- if (regno >= 16 && regno <= 31)
- {
- specs[count++] = tmpl;
- }
- }
- }
- }
+ {
+ for (i = 0; i < NELEMS (idesc->operands); i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_R1
+ || idesc->operands[i] == IA64_OPND_R2
+ || idesc->operands[i] == IA64_OPND_R3)
+ {
+ int regno = CURR_SLOT.opnd[i].X_add_number - REG_GR;
+ if (regno >= 16 && regno <= 31)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_AR_FPSR:
if (idesc->operands[!rsrc_write] == IA64_OPND_AR3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
- if (regno == AR_FPSR)
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
+ if (regno == AR_FPSR)
+ {
+ specs[count++] = tmpl;
+ }
+ }
else
- {
- specs[count++] = tmpl;
- }
+ {
+ specs[count++] = tmpl;
+ }
break;
case IA64_RS_ARX:
/* Handle all AR[REG] resources */
if (note == 0 || note == 1)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
- if (idesc->operands[!rsrc_write] == IA64_OPND_AR3
- && regno == dep->regindex)
- {
- specs[count++] = tmpl;
- }
- /* other AR[REG] resources may be affected by AR accesses */
- else if (idesc->operands[0] == IA64_OPND_AR3)
- {
- /* AR[] writes */
- regno = CURR_SLOT.opnd[0].X_add_number - REG_AR;
- switch (dep->regindex)
- {
- default:
- break;
- case AR_BSP:
- case AR_RNAT:
- if (regno == AR_BSPSTORE)
- {
- specs[count++] = tmpl;
- }
- case AR_RSC:
- if (!rsrc_write &&
- (regno == AR_BSPSTORE
- || regno == AR_RNAT))
- {
- specs[count++] = tmpl;
- }
- break;
- }
- }
- else if (idesc->operands[1] == IA64_OPND_AR3)
- {
- /* AR[] reads */
- regno = CURR_SLOT.opnd[1].X_add_number - REG_AR;
- switch (dep->regindex)
- {
- default:
- break;
- case AR_RSC:
- if (regno == AR_BSPSTORE || regno == AR_RNAT)
- {
- specs[count++] = tmpl;
- }
- break;
- }
- }
- else
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_AR;
+ if (idesc->operands[!rsrc_write] == IA64_OPND_AR3
+ && regno == dep->regindex)
+ {
+ specs[count++] = tmpl;
+ }
+ /* other AR[REG] resources may be affected by AR accesses */
+ else if (idesc->operands[0] == IA64_OPND_AR3)
+ {
+ /* AR[] writes */
+ regno = CURR_SLOT.opnd[0].X_add_number - REG_AR;
+ switch (dep->regindex)
+ {
+ default:
+ break;
+ case AR_BSP:
+ case AR_RNAT:
+ if (regno == AR_BSPSTORE)
+ {
+ specs[count++] = tmpl;
+ }
+ case AR_RSC:
+ if (!rsrc_write &&
+ (regno == AR_BSPSTORE
+ || regno == AR_RNAT))
+ {
+ specs[count++] = tmpl;
+ }
+ break;
+ }
+ }
+ else if (idesc->operands[1] == IA64_OPND_AR3)
+ {
+ /* AR[] reads */
+ regno = CURR_SLOT.opnd[1].X_add_number - REG_AR;
+ switch (dep->regindex)
+ {
+ default:
+ break;
+ case AR_RSC:
+ if (regno == AR_BSPSTORE || regno == AR_RNAT)
+ {
+ specs[count++] = tmpl;
+ }
+ break;
+ }
+ }
+ else
+ {
+ specs[count++] = tmpl;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_CRX:
/* Handle all CR[REG] resources */
if (note == 0 || note == 1)
- {
- if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
- {
- int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
- if (regno == dep->regindex)
- {
- specs[count++] = tmpl;
- }
- else if (!rsrc_write)
- {
- /* Reads from CR[IVR] affect other resources. */
- if (regno == CR_IVR)
- {
- if ((dep->regindex >= CR_IRR0
- && dep->regindex <= CR_IRR3)
- || dep->regindex == CR_TPR)
- {
- specs[count++] = tmpl;
- }
- }
- }
- }
- else
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
+ {
+ int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+ if (regno == dep->regindex)
+ {
+ specs[count++] = tmpl;
+ }
+ else if (!rsrc_write)
+ {
+ /* Reads from CR[IVR] affect other resources. */
+ if (regno == CR_IVR)
+ {
+ if ((dep->regindex >= CR_IRR0
+ && dep->regindex <= CR_IRR3)
+ || dep->regindex == CR_TPR)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
+ }
+ else
+ {
+ specs[count++] = tmpl;
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_INSERVICE:
/* look for write of EOI (67) or read of IVR (65) */
if ((idesc->operands[0] == IA64_OPND_CR3
- && CURR_SLOT.opnd[0].X_add_number - REG_CR == CR_EOI)
- || (idesc->operands[1] == IA64_OPND_CR3
- && CURR_SLOT.opnd[1].X_add_number - REG_CR == CR_IVR))
- {
- specs[count++] = tmpl;
- }
+ && CURR_SLOT.opnd[0].X_add_number - REG_CR == CR_EOI)
+ || (idesc->operands[1] == IA64_OPND_CR3
+ && CURR_SLOT.opnd[1].X_add_number - REG_CR == CR_IVR))
+ {
+ specs[count++] = tmpl;
+ }
break;
case IA64_RS_GR0:
if (note == 1)
- {
- specs[count++] = tmpl;
- }
+ {
+ specs[count++] = tmpl;
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_CFM:
if (note != 2)
- {
- specs[count++] = tmpl;
- }
+ {
+ specs[count++] = tmpl;
+ }
else
- {
- /* Check if any of the registers accessed are in the rotating region.
- mov to/from pr accesses CFM only when qp_regno is in the rotating
- region */
- for (i=0;i < NELEMS(idesc->operands);i++)
- {
- if (idesc->operands[i] == IA64_OPND_R1
- || idesc->operands[i] == IA64_OPND_R2
- || idesc->operands[i] == IA64_OPND_R3)
- {
- int num = CURR_SLOT.opnd[i].X_add_number - REG_GR;
- /* Assumes that md.rot.num_regs is always valid */
- if (md.rot.num_regs > 0
- && num > 31
- && num < 31 + md.rot.num_regs)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- else if (idesc->operands[i] == IA64_OPND_F1
- || idesc->operands[i] == IA64_OPND_F2
- || idesc->operands[i] == IA64_OPND_F3
- || idesc->operands[i] == IA64_OPND_F4)
- {
- int num = CURR_SLOT.opnd[i].X_add_number - REG_FR;
- if (num > 31)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- else if (idesc->operands[i] == IA64_OPND_P1
- || idesc->operands[i] == IA64_OPND_P2)
- {
- int num = CURR_SLOT.opnd[i].X_add_number - REG_P;
- if (num > 15)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
- }
- if (CURR_SLOT.qp_regno > 15)
- {
- specs[count] = tmpl;
- specs[count++].specific = 0;
- }
- }
+ {
+ /* Check if any of the registers accessed are in the rotating region.
+ mov to/from pr accesses CFM only when qp_regno is in the rotating
+ region */
+ for (i = 0; i < NELEMS (idesc->operands); i++)
+ {
+ if (idesc->operands[i] == IA64_OPND_R1
+ || idesc->operands[i] == IA64_OPND_R2
+ || idesc->operands[i] == IA64_OPND_R3)
+ {
+ int num = CURR_SLOT.opnd[i].X_add_number - REG_GR;
+ /* Assumes that md.rot.num_regs is always valid */
+ if (md.rot.num_regs > 0
+ && num > 31
+ && num < 31 + md.rot.num_regs)
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ else if (idesc->operands[i] == IA64_OPND_F1
+ || idesc->operands[i] == IA64_OPND_F2
+ || idesc->operands[i] == IA64_OPND_F3
+ || idesc->operands[i] == IA64_OPND_F4)
+ {
+ int num = CURR_SLOT.opnd[i].X_add_number - REG_FR;
+ if (num > 31)
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ else if (idesc->operands[i] == IA64_OPND_P1
+ || idesc->operands[i] == IA64_OPND_P2)
+ {
+ int num = CURR_SLOT.opnd[i].X_add_number - REG_P;
+ if (num > 15)
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
+ }
+ if (CURR_SLOT.qp_regno > 15)
+ {
+ specs[count] = tmpl;
+ specs[count++].specific = 0;
+ }
+ }
break;
case IA64_RS_PR63:
if (note == 0)
- {
- specs[count++] = tmpl;
- }
+ {
+ specs[count++] = tmpl;
+ }
else if (note == 11)
- {
- if ((idesc->operands[0] == IA64_OPND_P1
- && CURR_SLOT.opnd[0].X_add_number - REG_P == 63)
- || (idesc->operands[1] == IA64_OPND_P2
- && CURR_SLOT.opnd[1].X_add_number - REG_P == 63))
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ if ((idesc->operands[0] == IA64_OPND_P1
+ && CURR_SLOT.opnd[0].X_add_number - REG_P == 63)
+ || (idesc->operands[1] == IA64_OPND_P2
+ && CURR_SLOT.opnd[1].X_add_number - REG_P == 63))
+ {
+ specs[count++] = tmpl;
+ }
+ }
else if (note == 12)
- {
- if (CURR_SLOT.qp_regno == 63)
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ if (CURR_SLOT.qp_regno == 63)
+ {
+ specs[count++] = tmpl;
+ }
+ }
else if (note == 7)
- {
- valueT mask = 0;
- if (idesc->operands[2] == IA64_OPND_IMM17)
- mask = CURR_SLOT.opnd[2].X_add_number;
- if (mask & ((valueT) 1<<63))
- {
- specs[count++] = tmpl;
- }
- }
+ {
+ valueT mask = 0;
+ if (idesc->operands[2] == IA64_OPND_IMM17)
+ mask = CURR_SLOT.opnd[2].X_add_number;
+ if (mask & ((valueT) 1 << 63))
+ {
+ specs[count++] = tmpl;
+ }
+ }
else if (note == 1)
- {
- if (rsrc_write)
- {
- for (i=0;i < idesc->num_outputs;i++)
- if ((idesc->operands[i] == IA64_OPND_P1
- || idesc->operands[i] == IA64_OPND_P2)
- && CURR_SLOT.opnd[i].X_add_number - REG_P == 63)
- {
- specs[count++] = tmpl;
- }
- }
- else
- {
- if (CURR_SLOT.qp_regno == 63)
- {
- specs[count++] = tmpl;
- }
- }
- }
+ {
+ if (rsrc_write)
+ {
+ for (i = 0; i < idesc->num_outputs; i++)
+ if ((idesc->operands[i] == IA64_OPND_P1
+ || idesc->operands[i] == IA64_OPND_P2)
+ && CURR_SLOT.opnd[i].X_add_number - REG_P == 63)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else
+ {
+ if (CURR_SLOT.qp_regno == 63)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
else
- {
- UNHANDLED;
- }
+ {
+ UNHANDLED;
+ }
break;
case IA64_RS_RSE:
/* FIXME we can identify some individual RSE written resources, but RSE
- read resources have not yet been completely identified, so for now
- treat RSE as a single resource */
+ read resources have not yet been completely identified, so for now
+ treat RSE as a single resource */
if (strncmp (idesc->name, "mov", 3) == 0)
- {
- if (rsrc_write)
- {
- if (idesc->operands[0] == IA64_OPND_AR3
- && CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_BSPSTORE)
- {
- specs[count] = tmpl;
- specs[count++].index = 0; /* IA64_RSE_BSPLOAD/RNATBITINDEX */
- }
- }
- else
- {
- if (idesc->operands[0] == IA64_OPND_AR3)
- {
- if (CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_BSPSTORE
- || CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_RNAT)
- {
- specs[count++] = tmpl;
- }
- }
- else if (idesc->operands[1] == IA64_OPND_AR3)
- {
- if (CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_BSP
- || CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_BSPSTORE
- || CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_RNAT)
- {
- specs[count++] = tmpl;
- }
- }
- }
- }
+ {
+ if (rsrc_write)
+ {
+ if (idesc->operands[0] == IA64_OPND_AR3
+ && CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_BSPSTORE)
+ {
+ specs[count] = tmpl;
+ specs[count++].index = 0; /* IA64_RSE_BSPLOAD/RNATBITINDEX */
+ }
+ }
+ else
+ {
+ if (idesc->operands[0] == IA64_OPND_AR3)
+ {
+ if (CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_BSPSTORE
+ || CURR_SLOT.opnd[0].X_add_number - REG_AR == AR_RNAT)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ else if (idesc->operands[1] == IA64_OPND_AR3)
+ {
+ if (CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_BSP
+ || CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_BSPSTORE
+ || CURR_SLOT.opnd[1].X_add_number - REG_AR == AR_RNAT)
+ {
+ specs[count++] = tmpl;
+ }
+ }
+ }
+ }
else
- {
- specs[count++] = tmpl;
- }
+ {
+ specs[count++] = tmpl;
+ }
break;
case IA64_RS_ANY:
}
/* Clear branch flags on marked resources. This breaks the link between the
- QP of the marking instruction and a subsequent branch on the same QP.
-*/
+ QP of the marking instruction and a subsequent branch on the same QP. */
+
static void
clear_qp_branch_flag (mask)
- valueT mask;
+ valueT mask;
{
int i;
- for (i = 0;i < regdepslen;i++)
+ for (i = 0; i < regdepslen; i++)
{
valueT bit = ((valueT) 1 << regdeps[i].qp_regno);
if ((bit & mask) != 0)
- {
- regdeps[i].link_to_qp_branch = 0;
- }
+ {
+ regdeps[i].link_to_qp_branch = 0;
+ }
}
}
/* Remove any mutexes which contain any of the PRs indicated in the mask.
- Any changes to a PR clears the mutex relations which include that PR.
-*/
+ Any changes to a PR clears the mutex relations which include that PR. */
+
static void
clear_qp_mutex (mask)
- valueT mask;
+ valueT mask;
{
int i;
while (i < qp_mutexeslen)
{
if ((qp_mutexes[i].prmask & mask) != 0)
- {
- if (md.debug_dv)
- {
- fprintf (stderr, " Clearing mutex relation");
- print_prmask (qp_mutexes[i].prmask);
- fprintf (stderr, "\n");
- }
- qp_mutexes[i] = qp_mutexes[--qp_mutexeslen];
- }
+ {
+ if (md.debug_dv)
+ {
+ fprintf (stderr, " Clearing mutex relation");
+ print_prmask (qp_mutexes[i].prmask);
+ fprintf (stderr, "\n");
+ }
+ qp_mutexes[i] = qp_mutexes[--qp_mutexeslen];
+ }
else
- ++i;
+ ++i;
}
}
/* Clear implies relations which contain PRs in the given masks.
P1_MASK indicates the source of the implies relation, while P2_MASK
- indicates the implied PR.
-*/
+ indicates the implied PR. */
+
static void
clear_qp_implies (p1_mask, p2_mask)
- valueT p1_mask;
- valueT p2_mask;
+ valueT p1_mask;
+ valueT p2_mask;
{
int i;
while (i < qp_implieslen)
{
if ((((valueT) 1 << qp_implies[i].p1) & p1_mask) != 0
- || (((valueT) 1 << qp_implies[i].p2) & p2_mask) != 0)
- {
- if (md.debug_dv)
- fprintf (stderr, "Clearing implied relation PR%d->PR%d\n",
- qp_implies[i].p1, qp_implies[i].p2);
- qp_implies[i] = qp_implies[--qp_implieslen];
- }
+ || (((valueT) 1 << qp_implies[i].p2) & p2_mask) != 0)
+ {
+ if (md.debug_dv)
+ fprintf (stderr, "Clearing implied relation PR%d->PR%d\n",
+ qp_implies[i].p1, qp_implies[i].p2);
+ qp_implies[i] = qp_implies[--qp_implieslen];
+ }
else
- ++i;
+ ++i;
}
}
-/* add the PRs specified to the list of implied relations */
+/* Add the PRs specified to the list of implied relations. */
+
static void
add_qp_imply (p1, p2)
- int p1, p2;
+ int p1, p2;
{
valueT mask;
valueT bit;
int i;
- /* p0 is not meaningful here */
+ /* p0 is not meaningful here. */
if (p1 == 0 || p2 == 0)
abort ();
if (p1 == p2)
return;
- /* if it exists already, ignore it */
- for (i=0;i < qp_implieslen;i++)
+ /* If it exists already, ignore it. */
+ for (i = 0; i < qp_implieslen; i++)
{
if (qp_implies[i].p1 == p1
- && qp_implies[i].p2 == p2
- && qp_implies[i].path == md.path
- && !qp_implies[i].p2_branched)
- return;
+ && qp_implies[i].p2 == p2
+ && qp_implies[i].path == md.path
+ && !qp_implies[i].p2_branched)
+ return;
}
if (qp_implieslen == qp_impliestotlen)
{
qp_impliestotlen += 20;
qp_implies = (struct qp_imply *)
- xrealloc ((void *)qp_implies,
- qp_impliestotlen * sizeof (struct qp_imply));
+ xrealloc ((void *) qp_implies,
+ qp_impliestotlen * sizeof (struct qp_imply));
}
if (md.debug_dv)
fprintf (stderr, " Registering PR%d implies PR%d\n", p1, p2);
/* Add in the implied transitive relations; for everything that p2 implies,
make p1 imply that, too; for everything that implies p1, make it imply p2
as well. */
- for (i=0;i < qp_implieslen;i++)
+ for (i = 0; i < qp_implieslen; i++)
{
if (qp_implies[i].p1 == p2)
- add_qp_imply (p1, qp_implies[i].p2);
+ add_qp_imply (p1, qp_implies[i].p2);
if (qp_implies[i].p2 == p1)
- add_qp_imply (qp_implies[i].p1, p2);
+ add_qp_imply (qp_implies[i].p1, p2);
}
/* Add in mutex relations implied by this implies relation; for each mutex
relation containing p2, duplicate it and replace p2 with p1. */
bit = (valueT) 1 << p1;
mask = (valueT) 1 << p2;
- for (i=0;i < qp_mutexeslen;i++)
+ for (i = 0; i < qp_mutexeslen; i++)
{
if (qp_mutexes[i].prmask & mask)
- add_qp_mutex ((qp_mutexes[i].prmask & ~mask) | bit);
+ add_qp_mutex ((qp_mutexes[i].prmask & ~mask) | bit);
}
}
/* Add the PRs specified in the mask to the mutex list; this means that only
one of the PRs can be true at any time. PR0 should never be included in
the mask. */
+
static void
add_qp_mutex (mask)
- valueT mask;
+ valueT mask;
{
if (mask & 0x1)
abort ();
{
qp_mutexestotlen += 20;
qp_mutexes = (struct qpmutex *)
- xrealloc ((void *)qp_mutexes,
- qp_mutexestotlen * sizeof (struct qpmutex));
+ xrealloc ((void *) qp_mutexes,
+ qp_mutexestotlen * sizeof (struct qpmutex));
}
if (md.debug_dv)
{
int i;
if (md.debug_dv)
fprintf (stderr, " Clearing register values\n");
- for (i=1;i < NELEMS(gr_values);i++)
+ for (i = 1; i < NELEMS (gr_values); i++)
gr_values[i].known = 0;
}
/* Keep track of register values/changes which affect DV tracking.
optimization note: should add a flag to classes of insns where otherwise we
- have to examine a group of strings to identify them.
+ have to examine a group of strings to identify them. */
- */
static void
note_register_values (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
valueT qp_changemask = 0;
int i;
- /* invalidate values for registers being written to */
- for (i=0;i < idesc->num_outputs;i++)
+ /* Invalidate values for registers being written to. */
+ for (i = 0; i < idesc->num_outputs; i++)
{
if (idesc->operands[i] == IA64_OPND_R1
- || idesc->operands[i] == IA64_OPND_R2
- || idesc->operands[i] == IA64_OPND_R3)
- {
- int regno = CURR_SLOT.opnd[i].X_add_number - REG_GR;
- if (regno > 0 && regno < NELEMS(gr_values))
- gr_values[regno].known = 0;
- }
+ || idesc->operands[i] == IA64_OPND_R2
+ || idesc->operands[i] == IA64_OPND_R3)
+ {
+ int regno = CURR_SLOT.opnd[i].X_add_number - REG_GR;
+ if (regno > 0 && regno < NELEMS (gr_values))
+ gr_values[regno].known = 0;
+ }
else if (idesc->operands[i] == IA64_OPND_R3_2)
{
int regno = CURR_SLOT.opnd[i].X_add_number - REG_GR;
gr_values[regno].known = 0;
}
else if (idesc->operands[i] == IA64_OPND_P1
- || idesc->operands[i] == IA64_OPND_P2)
- {
- int regno = CURR_SLOT.opnd[i].X_add_number - REG_P;
- qp_changemask |= (valueT) 1 << regno;
- }
+ || idesc->operands[i] == IA64_OPND_P2)
+ {
+ int regno = CURR_SLOT.opnd[i].X_add_number - REG_P;
+ qp_changemask |= (valueT) 1 << regno;
+ }
else if (idesc->operands[i] == IA64_OPND_PR)
- {
- if (idesc->operands[2] & (valueT) 0x10000)
- qp_changemask = ~(valueT) 0x1FFFF | idesc->operands[2];
- else
- qp_changemask = idesc->operands[2];
- break;
- }
+ {
+ if (idesc->operands[2] & (valueT) 0x10000)
+ qp_changemask = ~(valueT) 0x1FFFF | idesc->operands[2];
+ else
+ qp_changemask = idesc->operands[2];
+ break;
+ }
else if (idesc->operands[i] == IA64_OPND_PR_ROT)
- {
- if (idesc->operands[1] & ((valueT) 1 << 43))
- qp_changemask = ~(valueT) 0xFFFFFFFFFFF | idesc->operands[1];
- else
- qp_changemask = idesc->operands[1];
- qp_changemask &= ~(valueT) 0xFFFF;
- break;
- }
- }
-
- /* Always clear qp branch flags on any PR change */
- /* FIXME there may be exceptions for certain compares */
+ {
+ if (idesc->operands[1] & ((valueT) 1 << 43))
+ qp_changemask = ~(valueT) 0xFFFFFFFFFFF | idesc->operands[1];
+ else
+ qp_changemask = idesc->operands[1];
+ qp_changemask &= ~(valueT) 0xFFFF;
+ break;
+ }
+ }
+
+ /* Always clear qp branch flags on any PR change. */
+ /* FIXME there may be exceptions for certain compares. */
clear_qp_branch_flag (qp_changemask);
- /* invalidate rotating registers on insns which affect RRBs in CFM */
+ /* Invalidate rotating registers on insns which affect RRBs in CFM. */
if (idesc->flags & IA64_OPCODE_MOD_RRBS)
{
qp_changemask |= ~(valueT) 0xFFFF;
if (strcmp (idesc->name, "clrrrb.pr") != 0)
- {
- for (i=32;i < 32+md.rot.num_regs;i++)
- gr_values[i].known = 0;
- }
+ {
+ for (i = 32; i < 32 + md.rot.num_regs; i++)
+ gr_values[i].known = 0;
+ }
clear_qp_mutex (qp_changemask);
clear_qp_implies (qp_changemask, qp_changemask);
}
- /* after a call, all register values are undefined, except those marked
- as "safe" */
+ /* After a call, all register values are undefined, except those marked
+ as "safe". */
else if (strncmp (idesc->name, "br.call", 6) == 0
- || strncmp (idesc->name, "brl.call", 7) == 0)
+ || strncmp (idesc->name, "brl.call", 7) == 0)
{
// FIXME keep GR values which are marked as "safe_across_calls"
clear_register_values ();
clear_qp_branch_flag (~qp_safe_across_calls);
}
else if (is_interruption_or_rfi (idesc)
- || is_taken_branch (idesc))
+ || is_taken_branch (idesc))
{
clear_register_values ();
clear_qp_mutex (~(valueT) 0);
clear_qp_implies (~(valueT) 0, ~(valueT) 0);
}
- /* Look for mutex and implies relations */
+ /* Look for mutex and implies relations. */
else if ((idesc->operands[0] == IA64_OPND_P1
- || idesc->operands[0] == IA64_OPND_P2)
- && (idesc->operands[1] == IA64_OPND_P1
- || idesc->operands[1] == IA64_OPND_P2))
+ || idesc->operands[0] == IA64_OPND_P2)
+ && (idesc->operands[1] == IA64_OPND_P1
+ || idesc->operands[1] == IA64_OPND_P2))
{
int p1 = CURR_SLOT.opnd[0].X_add_number - REG_P;
int p2 = CURR_SLOT.opnd[1].X_add_number - REG_P;
valueT p1mask = (valueT) 1 << p1;
valueT p2mask = (valueT) 1 << p2;
- /* if one of the PRs is PR0, we can't really do anything */
+ /* If one of the PRs is PR0, we can't really do anything. */
if (p1 == 0 || p2 == 0)
- {
- if (md.debug_dv)
- fprintf (stderr, " Ignoring PRs due to inclusion of p0\n");
- }
+ {
+ if (md.debug_dv)
+ fprintf (stderr, " Ignoring PRs due to inclusion of p0\n");
+ }
/* In general, clear mutexes and implies which include P1 or P2,
- with the following exceptions */
+ with the following exceptions. */
else if (strstr (idesc->name, ".or.andcm") != NULL)
- {
- add_qp_mutex (p1mask | p2mask);
- clear_qp_implies (p2mask, p1mask);
- }
+ {
+ add_qp_mutex (p1mask | p2mask);
+ clear_qp_implies (p2mask, p1mask);
+ }
else if (strstr (idesc->name, ".and.orcm") != NULL)
- {
- add_qp_mutex (p1mask | p2mask);
- clear_qp_implies (p1mask, p2mask);
- }
+ {
+ add_qp_mutex (p1mask | p2mask);
+ clear_qp_implies (p1mask, p2mask);
+ }
else if (strstr (idesc->name, ".and") != NULL)
- {
- clear_qp_implies (0, p1mask | p2mask);
- }
+ {
+ clear_qp_implies (0, p1mask | p2mask);
+ }
else if (strstr (idesc->name, ".or") != NULL)
- {
- clear_qp_mutex (p1mask | p2mask);
- clear_qp_implies (p1mask | p2mask, 0);
- }
+ {
+ clear_qp_mutex (p1mask | p2mask);
+ clear_qp_implies (p1mask | p2mask, 0);
+ }
else
- {
- clear_qp_implies (p1mask | p2mask, p1mask | p2mask);
- if (strstr (idesc->name, ".unc") != NULL)
- {
- add_qp_mutex (p1mask | p2mask);
- if (CURR_SLOT.qp_regno != 0)
- {
- add_qp_imply (CURR_SLOT.opnd[0].X_add_number - REG_P,
- CURR_SLOT.qp_regno);
- add_qp_imply (CURR_SLOT.opnd[1].X_add_number - REG_P,
- CURR_SLOT.qp_regno);
- }
- }
- else if (CURR_SLOT.qp_regno == 0)
- {
- add_qp_mutex (p1mask | p2mask);
- }
- else
- {
- clear_qp_mutex (p1mask | p2mask);
- }
- }
- }
- /* Look for mov imm insns into GRs */
+ {
+ clear_qp_implies (p1mask | p2mask, p1mask | p2mask);
+ if (strstr (idesc->name, ".unc") != NULL)
+ {
+ add_qp_mutex (p1mask | p2mask);
+ if (CURR_SLOT.qp_regno != 0)
+ {
+ add_qp_imply (CURR_SLOT.opnd[0].X_add_number - REG_P,
+ CURR_SLOT.qp_regno);
+ add_qp_imply (CURR_SLOT.opnd[1].X_add_number - REG_P,
+ CURR_SLOT.qp_regno);
+ }
+ }
+ else if (CURR_SLOT.qp_regno == 0)
+ {
+ add_qp_mutex (p1mask | p2mask);
+ }
+ else
+ {
+ clear_qp_mutex (p1mask | p2mask);
+ }
+ }
+ }
+ /* Look for mov imm insns into GRs. */
else if (idesc->operands[0] == IA64_OPND_R1
- && (idesc->operands[1] == IA64_OPND_IMM22
- || idesc->operands[1] == IA64_OPND_IMMU64)
- && (strcmp(idesc->name, "mov") == 0
- || strcmp(idesc->name, "movl") == 0))
+ && (idesc->operands[1] == IA64_OPND_IMM22
+ || idesc->operands[1] == IA64_OPND_IMMU64)
+ && (strcmp (idesc->name, "mov") == 0
+ || strcmp (idesc->name, "movl") == 0))
{
int regno = CURR_SLOT.opnd[0].X_add_number - REG_GR;
- if (regno > 0 && regno < NELEMS(gr_values))
- {
- gr_values[regno].known = 1;
- gr_values[regno].value = CURR_SLOT.opnd[1].X_add_number;
- gr_values[regno].path = md.path;
- if (md.debug_dv)
- fprintf (stderr, " Know gr%d = 0x%llx\n",
- regno, gr_values[regno].value);
- }
+ if (regno > 0 && regno < NELEMS (gr_values))
+ {
+ gr_values[regno].known = 1;
+ gr_values[regno].value = CURR_SLOT.opnd[1].X_add_number;
+ gr_values[regno].path = md.path;
+ if (md.debug_dv)
+ fprintf (stderr, " Know gr%d = 0x%llx\n",
+ regno, gr_values[regno].value);
+ }
}
else
{
}
}
-/* Return whether the given predicate registers are currently mutex */
+/* Return whether the given predicate registers are currently mutex. */
+
static int
qp_mutex (p1, p2, path)
- int p1;
- int p2;
- int path;
+ int p1;
+ int p2;
+ int path;
{
int i;
valueT mask;
if (p1 != p2)
{
- mask = ((valueT) 1<<p1) | (valueT) 1<<p2;
- for (i=0;i < qp_mutexeslen;i++)
- {
- if (qp_mutexes[i].path >= path
- && (qp_mutexes[i].prmask & mask) == mask)
- return 1;
- }
+ mask = ((valueT) 1 << p1) | (valueT) 1 << p2;
+ for (i = 0; i < qp_mutexeslen; i++)
+ {
+ if (qp_mutexes[i].path >= path
+ && (qp_mutexes[i].prmask & mask) == mask)
+ return 1;
+ }
}
return 0;
}
/* Return whether the given resource is in the given insn's list of chks
Return 1 if the conflict is absolutely determined, 2 if it's a potential
- conflict.
- */
+ conflict. */
+
static int
resources_match (rs, idesc, note, qp_regno, path)
- struct rsrc *rs;
- struct ia64_opcode *idesc;
- int note;
- int qp_regno;
- int path;
+ struct rsrc *rs;
+ struct ia64_opcode *idesc;
+ int note;
+ int qp_regno;
+ int path;
{
struct rsrc specs[MAX_SPECS];
int count;
{
/* UNAT checking is a bit more specific than other resources */
if (rs->dependency->specifier == IA64_RS_AR_UNAT
- && specs[count].mem_offset.hint
- && rs->mem_offset.hint)
- {
- if (rs->mem_offset.base == specs[count].mem_offset.base)
- {
- if (((rs->mem_offset.offset >> 3) & 0x3F) ==
- ((specs[count].mem_offset.offset >> 3) & 0x3F))
- return 1;
- else
- continue;
- }
- }
+ && specs[count].mem_offset.hint
+ && rs->mem_offset.hint)
+ {
+ if (rs->mem_offset.base == specs[count].mem_offset.base)
+ {
+ if (((rs->mem_offset.offset >> 3) & 0x3F) ==
+ ((specs[count].mem_offset.offset >> 3) & 0x3F))
+ return 1;
+ else
+ continue;
+ }
+ }
/* If either resource is not specific, conservatively assume a conflict
*/
if (!specs[count].specific || !rs->specific)
- return 2;
+ return 2;
else if (specs[count].index == rs->index)
- return 1;
+ return 1;
}
#if 0
if (md.debug_dv)
appropriately. If QP_REGNO is non-zero, only apply the break to resources
which use the same QP_REGNO and have the link_to_qp_branch flag set.
If SAVE_CURRENT is non-zero, don't affect resources marked by the current
- instruction.
-*/
+ instruction. */
static void
insn_group_break (insert_stop, qp_regno, save_current)
- int insert_stop;
- int qp_regno;
- int save_current;
+ int insert_stop;
+ int qp_regno;
+ int save_current;
{
int i;
if (md.debug_dv)
{
fprintf (stderr, " Insn group break%s",
- (insert_stop ? " (w/stop)" : ""));
+ (insert_stop ? " (w/stop)" : ""));
if (qp_regno != 0)
- fprintf (stderr, " effective for QP=%d", qp_regno);
+ fprintf (stderr, " effective for QP=%d", qp_regno);
fprintf (stderr, "\n");
}
const struct ia64_dependency *dep = regdeps[i].dependency;
if (qp_regno != 0
- && regdeps[i].qp_regno != qp_regno)
- {
- ++i;
- continue;
- }
+ && regdeps[i].qp_regno != qp_regno)
+ {
+ ++i;
+ continue;
+ }
if (save_current
- && CURR_SLOT.src_file == regdeps[i].file
- && CURR_SLOT.src_line == regdeps[i].line)
- {
- ++i;
- continue;
- }
+ && CURR_SLOT.src_file == regdeps[i].file
+ && CURR_SLOT.src_line == regdeps[i].line)
+ {
+ ++i;
+ continue;
+ }
/* clear dependencies which are automatically cleared by a stop, or
- those that have reached the appropriate state of insn serialization */
+ those that have reached the appropriate state of insn serialization */
if (dep->semantics == IA64_DVS_IMPLIED
- || dep->semantics == IA64_DVS_IMPLIEDF
- || regdeps[i].insn_srlz == STATE_SRLZ)
- {
- print_dependency ("Removing", i);
- regdeps[i] = regdeps[--regdepslen];
- }
+ || dep->semantics == IA64_DVS_IMPLIEDF
+ || regdeps[i].insn_srlz == STATE_SRLZ)
+ {
+ print_dependency ("Removing", i);
+ regdeps[i] = regdeps[--regdepslen];
+ }
else
- {
- if (dep->semantics == IA64_DVS_DATA
- || dep->semantics == IA64_DVS_INSTR
+ {
+ if (dep->semantics == IA64_DVS_DATA
+ || dep->semantics == IA64_DVS_INSTR
|| dep->semantics == IA64_DVS_SPECIFIC)
- {
- if (regdeps[i].insn_srlz == STATE_NONE)
- regdeps[i].insn_srlz = STATE_STOP;
- if (regdeps[i].data_srlz == STATE_NONE)
- regdeps[i].data_srlz = STATE_STOP;
- }
- ++i;
- }
+ {
+ if (regdeps[i].insn_srlz == STATE_NONE)
+ regdeps[i].insn_srlz = STATE_STOP;
+ if (regdeps[i].data_srlz == STATE_NONE)
+ regdeps[i].data_srlz = STATE_STOP;
+ }
+ ++i;
+ }
}
}
-/* Add the given resource usage spec to the list of active dependencies */
+/* Add the given resource usage spec to the list of active dependencies. */
+
static void
mark_resource (idesc, dep, spec, depind, path)
- struct ia64_opcode *idesc;
- const struct ia64_dependency *dep;
- struct rsrc *spec;
- int depind;
- int path;
+ struct ia64_opcode *idesc;
+ const struct ia64_dependency *dep;
+ struct rsrc *spec;
+ int depind;
+ int path;
{
if (regdepslen == regdepstotlen)
{
regdepstotlen += 20;
regdeps = (struct rsrc *)
- xrealloc ((void *)regdeps,
- regdepstotlen * sizeof(struct rsrc));
+ xrealloc ((void *) regdeps,
+ regdepstotlen * sizeof(struct rsrc));
}
regdeps[regdepslen] = *spec;
static void
print_dependency (action, depind)
- const char *action;
- int depind;
+ const char *action;
+ int depind;
{
if (md.debug_dv)
{
fprintf (stderr, " %s %s '%s'",
- action, dv_mode[(regdeps[depind].dependency)->mode],
- (regdeps[depind].dependency)->name);
+ action, dv_mode[(regdeps[depind].dependency)->mode],
+ (regdeps[depind].dependency)->name);
if (regdeps[depind].specific && regdeps[depind].index != 0)
- fprintf (stderr, " (%d)", regdeps[depind].index);
+ fprintf (stderr, " (%d)", regdeps[depind].index);
if (regdeps[depind].mem_offset.hint)
- fprintf (stderr, " 0x%llx+0x%llx",
- regdeps[depind].mem_offset.base,
- regdeps[depind].mem_offset.offset);
+ fprintf (stderr, " 0x%llx+0x%llx",
+ regdeps[depind].mem_offset.base,
+ regdeps[depind].mem_offset.offset);
fprintf (stderr, "\n");
}
}
int i;
if (md.debug_dv)
fprintf (stderr, " Instruction serialization\n");
- for (i=0;i < regdepslen;i++)
+ for (i = 0; i < regdepslen; i++)
if (regdeps[i].insn_srlz == STATE_STOP)
regdeps[i].insn_srlz = STATE_SRLZ;
}
while (i < regdepslen)
{
if (regdeps[i].data_srlz == STATE_STOP
- /* Note: as of 991210, all "other" dependencies are cleared by a
- data serialization. This might change with new tables */
- || (regdeps[i].dependency)->semantics == IA64_DVS_OTHER)
- {
- print_dependency ("Removing", i);
- regdeps[i] = regdeps[--regdepslen];
- }
+ /* Note: as of 991210, all "other" dependencies are cleared by a
+ data serialization. This might change with new tables */
+ || (regdeps[i].dependency)->semantics == IA64_DVS_OTHER)
+ {
+ print_dependency ("Removing", i);
+ regdeps[i] = regdeps[--regdepslen];
+ }
else
- ++i;
+ ++i;
}
}
-/* Insert stops and serializations as needed to avoid DVs */
+/* Insert stops and serializations as needed to avoid DVs. */
+
static void
remove_marked_resource (rs)
- struct rsrc *rs;
+ struct rsrc *rs;
{
switch (rs->dependency->semantics)
{
/* ...fall through... */
case IA64_DVS_INSTR:
if (md.debug_dv)
- fprintf (stderr, "Inserting instr serialization\n");
+ fprintf (stderr, "Inserting instr serialization\n");
if (rs->insn_srlz < STATE_STOP)
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
if (rs->insn_srlz < STATE_SRLZ)
- {
- int oldqp = CURR_SLOT.qp_regno;
- struct ia64_opcode *oldidesc = CURR_SLOT.idesc;
- /* Manually jam a srlz.i insn into the stream */
- CURR_SLOT.qp_regno = 0;
- CURR_SLOT.idesc = ia64_find_opcode ("srlz.i");
- instruction_serialization ();
- md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
- if (++md.num_slots_in_use >= NUM_SLOTS)
- emit_one_bundle ();
- CURR_SLOT.qp_regno = oldqp;
- CURR_SLOT.idesc = oldidesc;
- }
+ {
+ int oldqp = CURR_SLOT.qp_regno;
+ struct ia64_opcode *oldidesc = CURR_SLOT.idesc;
+ /* Manually jam a srlz.i insn into the stream */
+ CURR_SLOT.qp_regno = 0;
+ CURR_SLOT.idesc = ia64_find_opcode ("srlz.i");
+ instruction_serialization ();
+ md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
+ if (++md.num_slots_in_use >= NUM_SLOTS)
+ emit_one_bundle ();
+ CURR_SLOT.qp_regno = oldqp;
+ CURR_SLOT.idesc = oldidesc;
+ }
insn_group_break (1, 0, 0);
break;
case IA64_DVS_OTHER: /* as of rev2 (991220) of the DV tables, all
- "other" types of DV are eliminated
- by a data serialization */
+ "other" types of DV are eliminated
+ by a data serialization */
case IA64_DVS_DATA:
if (md.debug_dv)
- fprintf (stderr, "Inserting data serialization\n");
+ fprintf (stderr, "Inserting data serialization\n");
if (rs->data_srlz < STATE_STOP)
- insn_group_break (1, 0, 0);
+ insn_group_break (1, 0, 0);
{
- int oldqp = CURR_SLOT.qp_regno;
- struct ia64_opcode *oldidesc = CURR_SLOT.idesc;
- /* Manually jam a srlz.d insn into the stream */
- CURR_SLOT.qp_regno = 0;
- CURR_SLOT.idesc = ia64_find_opcode ("srlz.d");
- data_serialization ();
- md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
- if (++md.num_slots_in_use >= NUM_SLOTS)
- emit_one_bundle ();
- CURR_SLOT.qp_regno = oldqp;
- CURR_SLOT.idesc = oldidesc;
+ int oldqp = CURR_SLOT.qp_regno;
+ struct ia64_opcode *oldidesc = CURR_SLOT.idesc;
+ /* Manually jam a srlz.d insn into the stream */
+ CURR_SLOT.qp_regno = 0;
+ CURR_SLOT.idesc = ia64_find_opcode ("srlz.d");
+ data_serialization ();
+ md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
+ if (++md.num_slots_in_use >= NUM_SLOTS)
+ emit_one_bundle ();
+ CURR_SLOT.qp_regno = oldqp;
+ CURR_SLOT.idesc = oldidesc;
}
break;
case IA64_DVS_IMPLIED:
case IA64_DVS_IMPLIEDF:
if (md.debug_dv)
- fprintf (stderr, "Inserting stop\n");
+ fprintf (stderr, "Inserting stop\n");
insn_group_break (1, 0, 0);
break;
default:
L2: add
br.ret
*/
+
static void
check_dependencies (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
int path;
int start_over = 0;
if (dep->semantics == IA64_DVS_NONE
- || (chkind = depends_on (rs->depind, idesc)) == -1)
- {
- ++i; continue;
- }
-
- note = NOTE(opdeps->chks[chkind]);
-
- /* Check this resource against each execution path seen thus far */
- for (path=0;path <= md.path;path++)
- {
- int matchtype;
-
- /* If the dependency wasn't on the path being checked, ignore it */
- if (rs->path < path)
- continue;
-
- /* If the QP for this insn implies a QP which has branched, don't
- bother checking. Ed. NOTE: I don't think this check is terribly
- useful; what's the point of generating code which will only be
- reached if its QP is zero?
- This code was specifically inserted to handle the following code,
- based on notes from Intel's DV checking code, where p1 implies p2.
-
- mov r4 = 2
- (p2) br.cond L
- (p1) mov r4 = 7
-
- */
- if (CURR_SLOT.qp_regno != 0)
- {
- int skip = 0;
- int implies;
- for (implies=0;implies < qp_implieslen;implies++)
- {
- if (qp_implies[implies].path >= path
- && qp_implies[implies].p1 == CURR_SLOT.qp_regno
- && qp_implies[implies].p2_branched)
- {
- skip = 1;
- break;
- }
- }
- if (skip)
- continue;
- }
-
- if ((matchtype = resources_match (rs, idesc, note,
- CURR_SLOT.qp_regno, path)) != 0)
- {
- char msg[1024];
- char pathmsg[256] = "";
- char indexmsg[256] = "";
- int certain = (matchtype == 1 && CURR_SLOT.qp_regno == 0);
-
- if (path != 0)
- sprintf (pathmsg, " when entry is at label '%s'",
- md.entry_labels[path-1]);
- if (rs->specific && rs->index != 0)
- sprintf (indexmsg, ", specific resource number is %d",
- rs->index);
- sprintf (msg, "Use of '%s' %s %s dependency '%s' (%s)%s%s",
- idesc->name,
- (certain ? "violates" : "may violate"),
- dv_mode[dep->mode], dep->name,
- dv_sem[dep->semantics],
- pathmsg, indexmsg);
-
- if (md.explicit_mode)
- {
- as_warn ("%s", msg);
- if (path < md.path)
- as_warn (_("Only the first path encountering the conflict "
- "is reported"));
- as_warn_where (rs->file, rs->line,
- _("This is the location of the "
- "conflicting usage"));
- /* Don't bother checking other paths, to avoid duplicating
- the same warning */
- break;
- }
- else
- {
- if (md.debug_dv)
- fprintf(stderr, "%s @ %s:%d\n", msg, rs->file, rs->line);
-
- remove_marked_resource (rs);
-
- /* since the set of dependencies has changed, start over */
- /* FIXME -- since we're removing dvs as we go, we
- probably don't really need to start over... */
- start_over = 1;
- break;
- }
- }
- }
+ || (chkind = depends_on (rs->depind, idesc)) == -1)
+ {
+ ++i;
+ continue;
+ }
+
+ note = NOTE (opdeps->chks[chkind]);
+
+ /* Check this resource against each execution path seen thus far. */
+ for (path = 0; path <= md.path; path++)
+ {
+ int matchtype;
+
+ /* If the dependency wasn't on the path being checked, ignore it. */
+ if (rs->path < path)
+ continue;
+
+ /* If the QP for this insn implies a QP which has branched, don't
+ bother checking. Ed. NOTE: I don't think this check is terribly
+ useful; what's the point of generating code which will only be
+ reached if its QP is zero?
+ This code was specifically inserted to handle the following code,
+ based on notes from Intel's DV checking code, where p1 implies p2.
+
+ mov r4 = 2
+ (p2) br.cond L
+ (p1) mov r4 = 7
+ */
+ if (CURR_SLOT.qp_regno != 0)
+ {
+ int skip = 0;
+ int implies;
+ for (implies = 0; implies < qp_implieslen; implies++)
+ {
+ if (qp_implies[implies].path >= path
+ && qp_implies[implies].p1 == CURR_SLOT.qp_regno
+ && qp_implies[implies].p2_branched)
+ {
+ skip = 1;
+ break;
+ }
+ }
+ if (skip)
+ continue;
+ }
+
+ if ((matchtype = resources_match (rs, idesc, note,
+ CURR_SLOT.qp_regno, path)) != 0)
+ {
+ char msg[1024];
+ char pathmsg[256] = "";
+ char indexmsg[256] = "";
+ int certain = (matchtype == 1 && CURR_SLOT.qp_regno == 0);
+
+ if (path != 0)
+ sprintf (pathmsg, " when entry is at label '%s'",
+ md.entry_labels[path - 1]);
+ if (rs->specific && rs->index != 0)
+ sprintf (indexmsg, ", specific resource number is %d",
+ rs->index);
+ sprintf (msg, "Use of '%s' %s %s dependency '%s' (%s)%s%s",
+ idesc->name,
+ (certain ? "violates" : "may violate"),
+ dv_mode[dep->mode], dep->name,
+ dv_sem[dep->semantics],
+ pathmsg, indexmsg);
+
+ if (md.explicit_mode)
+ {
+ as_warn ("%s", msg);
+ if (path < md.path)
+ as_warn (_("Only the first path encountering the conflict "
+ "is reported"));
+ as_warn_where (rs->file, rs->line,
+ _("This is the location of the "
+ "conflicting usage"));
+ /* Don't bother checking other paths, to avoid duplicating
+ the same warning */
+ break;
+ }
+ else
+ {
+ if (md.debug_dv)
+ fprintf (stderr, "%s @ %s:%d\n", msg, rs->file, rs->line);
+
+ remove_marked_resource (rs);
+
+ /* since the set of dependencies has changed, start over */
+ /* FIXME -- since we're removing dvs as we go, we
+ probably don't really need to start over... */
+ start_over = 1;
+ break;
+ }
+ }
+ }
if (start_over)
- i = 0;
+ i = 0;
else
- ++i;
+ ++i;
}
}
-/* register new dependencies based on the given opcode */
+/* Register new dependencies based on the given opcode. */
+
static void
mark_resources (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
int i;
const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
if (md.debug_dv)
fprintf (stderr, "Registering '%s' resource usage\n", idesc->name);
- for (i=0;i < opdeps->nregs;i++)
+ for (i = 0; i < opdeps->nregs; i++)
{
const struct ia64_dependency *dep;
struct rsrc specs[MAX_SPECS];
int count;
dep = ia64_find_dependency (opdeps->regs[i]);
- note = NOTE(opdeps->regs[i]);
+ note = NOTE (opdeps->regs[i]);
if (add_only_qp_reads
- && !(dep->mode == IA64_DV_WAR
- && (dep->specifier == IA64_RS_PR
- || dep->specifier == IA64_RS_PR63)))
- continue;
+ && !(dep->mode == IA64_DV_WAR
+ && (dep->specifier == IA64_RS_PR
+ || dep->specifier == IA64_RS_PR63)))
+ continue;
count = specify_resource (dep, idesc, DV_REG, specs, note, md.path);
#if 0
if (md.debug_dv && !count)
- fprintf (stderr, " No %s %s usage found (path %d)\n",
- dv_mode[dep->mode], dep->name, md.path);
+ fprintf (stderr, " No %s %s usage found (path %d)\n",
+ dv_mode[dep->mode], dep->name, md.path);
#endif
while (count-- > 0)
- {
- mark_resource (idesc, dep, &specs[count],
- DEP(opdeps->regs[i]), md.path);
- }
+ {
+ mark_resource (idesc, dep, &specs[count],
+ DEP (opdeps->regs[i]), md.path);
+ }
/* The execution path may affect register values, which may in turn
- affect which indirect-access resources are accessed. */
+ affect which indirect-access resources are accessed. */
switch (dep->specifier)
- {
- default:
- break;
- case IA64_RS_CPUID:
- case IA64_RS_DBR:
- case IA64_RS_IBR:
+ {
+ default:
+ break;
+ case IA64_RS_CPUID:
+ case IA64_RS_DBR:
+ case IA64_RS_IBR:
case IA64_RS_MSR:
- case IA64_RS_PKR:
- case IA64_RS_PMC:
- case IA64_RS_PMD:
- case IA64_RS_RR:
- for (path=0;path < md.path;path++)
- {
- count = specify_resource (dep, idesc, DV_REG, specs, note, path);
- while (count-- > 0)
- mark_resource (idesc, dep, &specs[count],
- DEP(opdeps->regs[i]), path);
- }
- break;
- }
- }
-}
-
-/* remove dependencies when they no longer apply */
+ case IA64_RS_PKR:
+ case IA64_RS_PMC:
+ case IA64_RS_PMD:
+ case IA64_RS_RR:
+ for (path = 0; path < md.path; path++)
+ {
+ count = specify_resource (dep, idesc, DV_REG, specs, note, path);
+ while (count-- > 0)
+ mark_resource (idesc, dep, &specs[count],
+ DEP (opdeps->regs[i]), path);
+ }
+ break;
+ }
+ }
+}
+
+/* Remove dependencies when they no longer apply. */
+
static void
update_dependencies (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
int i;
data_serialization ();
}
else if (is_interruption_or_rfi (idesc)
- || is_taken_branch (idesc))
+ || is_taken_branch (idesc))
{
- /* although technically the taken branch doesn't clear dependencies
- which require a srlz.[id], we don't follow the branch; the next
- instruction is assumed to start with a clean slate */
+ /* Although technically the taken branch doesn't clear dependencies
+ which require a srlz.[id], we don't follow the branch; the next
+ instruction is assumed to start with a clean slate. */
regdepslen = 0;
md.path = 0;
}
else if (is_conditional_branch (idesc)
- && CURR_SLOT.qp_regno != 0)
+ && CURR_SLOT.qp_regno != 0)
{
int is_call = strstr (idesc->name, ".call") != NULL;
- for (i=0;i < qp_implieslen;i++)
- {
- /* if the conditional branch's predicate is implied by the predicate
- in an existing dependency, remove that dependency */
- if (qp_implies[i].p2 == CURR_SLOT.qp_regno)
- {
- int depind = 0;
- /* note that this implied predicate takes a branch so that if
- a later insn generates a DV but its predicate implies this
- one, we can avoid the false DV warning */
- qp_implies[i].p2_branched = 1;
- while (depind < regdepslen)
- {
- if (regdeps[depind].qp_regno == qp_implies[i].p1)
- {
- print_dependency ("Removing", depind);
- regdeps[depind] = regdeps[--regdepslen];
- }
- else
- ++depind;
- }
- }
- }
+ for (i = 0; i < qp_implieslen; i++)
+ {
+ /* If the conditional branch's predicate is implied by the predicate
+ in an existing dependency, remove that dependency. */
+ if (qp_implies[i].p2 == CURR_SLOT.qp_regno)
+ {
+ int depind = 0;
+ /* Note that this implied predicate takes a branch so that if
+ a later insn generates a DV but its predicate implies this
+ one, we can avoid the false DV warning. */
+ qp_implies[i].p2_branched = 1;
+ while (depind < regdepslen)
+ {
+ if (regdeps[depind].qp_regno == qp_implies[i].p1)
+ {
+ print_dependency ("Removing", depind);
+ regdeps[depind] = regdeps[--regdepslen];
+ }
+ else
+ ++depind;
+ }
+ }
+ }
/* Any marked resources which have this same predicate should be
- cleared, provided that the QP hasn't been modified between the
- marking instruction and the branch.
- */
+ cleared, provided that the QP hasn't been modified between the
+ marking instruction and the branch. */
if (is_call)
- {
- insn_group_break (0, CURR_SLOT.qp_regno, 1);
- }
+ {
+ insn_group_break (0, CURR_SLOT.qp_regno, 1);
+ }
else
- {
- i = 0;
- while (i < regdepslen)
- {
- if (regdeps[i].qp_regno == CURR_SLOT.qp_regno
- && regdeps[i].link_to_qp_branch
- && (regdeps[i].file != CURR_SLOT.src_file
- || regdeps[i].line != CURR_SLOT.src_line))
- {
- /* Treat like a taken branch */
- print_dependency ("Removing", i);
- regdeps[i] = regdeps[--regdepslen];
- }
- else
- ++i;
- }
- }
+ {
+ i = 0;
+ while (i < regdepslen)
+ {
+ if (regdeps[i].qp_regno == CURR_SLOT.qp_regno
+ && regdeps[i].link_to_qp_branch
+ && (regdeps[i].file != CURR_SLOT.src_file
+ || regdeps[i].line != CURR_SLOT.src_line))
+ {
+ /* Treat like a taken branch */
+ print_dependency ("Removing", i);
+ regdeps[i] = regdeps[--regdepslen];
+ }
+ else
+ ++i;
+ }
+ }
}
}
/* Examine the current instruction for dependency violations. */
+
static int
check_dv (idesc)
- struct ia64_opcode *idesc;
+ struct ia64_opcode *idesc;
{
if (md.debug_dv)
{
fprintf (stderr, "Checking %s for violations (line %d, %d/%d)\n",
- idesc->name, CURR_SLOT.src_line,
- idesc->dependencies->nchks,
- idesc->dependencies->nregs);
+ idesc->name, CURR_SLOT.src_line,
+ idesc->dependencies->nchks,
+ idesc->dependencies->nregs);
}
/* Look through the list of currently marked resources; if the current
instruction has the dependency in its chks list which uses that resource,
- check against the specific resources used.
- */
+ check against the specific resources used. */
check_dependencies (idesc);
- /*
- Look up the instruction's regdeps (RAW writes, WAW writes, and WAR reads),
- then add them to the list of marked resources.
- */
+ /* Look up the instruction's regdeps (RAW writes, WAW writes, and WAR reads),
+ then add them to the list of marked resources. */
mark_resources (idesc);
/* There are several types of dependency semantics, and each has its own
saved_input_line_pointer = input_line_pointer;
input_line_pointer = str;
- /* extract the opcode (mnemonic): */
+ /* extract the opcode (mnemonic): */
mnemonic = input_line_pointer;
ch = get_symbol_end ();
goto done;
}
- /* find the instruction descriptor matching the arguments: */
+ /* Find the instruction descriptor matching the arguments. */
idesc = ia64_find_opcode (mnemonic);
*input_line_pointer = ch;
if (!idesc)
goto done;
- /* Handle the dynamic ops we can handle now: */
+ /* Handle the dynamic ops we can handle now: */
if (idesc->type == IA64_TYPE_DYN)
{
if (strcmp (idesc->name, "add") == 0)
goto done;
}
- /* build the instruction: */
+ /* Build the instruction. */
CURR_SLOT.qp_regno = qp_regno;
CURR_SLOT.idesc = idesc;
as_where (&CURR_SLOT.src_file, &CURR_SLOT.src_line);
unwind.current_entry = NULL;
}
- /* check for dependency violations */
+ /* Check for dependency violations. */
if (md.detect_dv)
- check_dv(idesc);
+ check_dv (idesc);
md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
if (++md.num_slots_in_use >= NUM_SLOTS)
/* Called when symbol NAME cannot be found in the symbol table.
Should be used for dynamic valued symbols only. */
-symbolS*
+
+symbolS *
md_undefined_symbol (name)
char *name;
{
/* Called for any expression that can not be recognized. When the
function is called, `input_line_pointer' will point to the start of
the expression. */
+
void
md_operand (e)
expressionS *e;
switch (*input_line_pointer)
{
case '@':
- /* find what relocation pseudo-function we're dealing with: */
+ /* Find what relocation pseudo-function we're dealing with. */
pseudo_type = 0;
ch = *++input_line_pointer;
for (i = 0; i < NELEMS (pseudo_func); ++i)
as_bad ("Expected '('");
goto err;
}
- ++input_line_pointer; /* skip '(' */
+ /* Skip '('. */
+ ++input_line_pointer;
expression (e);
if (*input_line_pointer++ != ')')
{
goto err;
}
}
- /* make sure gas doesn't get rid of local symbols that are used
- in relocs: */
+ /* Make sure gas doesn't get rid of local symbols that are used
+ in relocs. */
e->X_op = O_pseudo_fixup;
e->X_op_symbol = pseudo_func[i].u.sym;
break;
}
/* ??? This is a hack copied from tc-i386.c to make PCREL relocs
- work. There should be a better way to handle this. */
+ work. There should be a better way to handle this. */
if (adjust)
fix->fx_offset += fix->fx_where + fix->fx_frag->fr_address;
}
/* Generate the BFD reloc to be stuck in the object file from the
fixup used internally in the assembler. */
-arelent*
+
+arelent *
tc_gen_reloc (sec, fixp)
asection *sec;
fixS *fixp;
#define MAX_LITTLENUMS 5
-char*
+char *
md_atof (type, lit, size)
int type;
char *lit;
projects / external / binutils.git / commitdiff