Lines Matching refs:md
65 #define PREV_SLOT md.slot[(md.curr_slot + NUM_SLOTS - 1) % NUM_SLOTS]
66 #define CURR_SLOT md.slot[md.curr_slot]
332 md;
1090 md.in.base = REG_GR + 32;
1091 md.loc.base = md.in.base + ins;
1092 md.out.base = md.loc.base + locs;
1094 md.in.num_regs = ins;
1095 md.loc.num_regs = locs;
1096 md.out.num_regs = outs;
1097 md.rot.num_regs = rots;
1110 if (!md.last_text_seg)
1116 subseg_set (md.last_text_seg, 0);
1118 while (md.num_slots_in_use > 0)
1181 if (md.qp.X_op == O_register)
1199 if (md.auto_align)
3096 pad = len % md.pointer_size;
3098 len += md.pointer_size - pad;
3103 size += md.pointer_size;
3127 pad = len % md.pointer_size;
3129 len += md.pointer_size - pad;
3134 size += md.pointer_size;
3144 if (md.flags & EF_IA_64_ABI64)
3156 | (len / md.pointer_size)), /* Length. */
3165 md_number_to_chars (frag->fr_literal + len + 8 - md.pointer_size + pad, 0,
3166 md.pointer_size - pad);
3338 if (md.unwind_check == unwind_check_warning)
3809 pad = size % md.pointer_size;
3811 size += md.pointer_size - pad;
3816 size += md.pointer_size;
3829 frag_align (md.pointer_size_shift, 0, 0);
3830 record_alignment (now_seg, md.pointer_size_shift);
3846 if (md.flags & EF_IA_64_BE)
3848 if (md.flags & EF_IA_64_ABI64)
3855 if (md.flags & EF_IA_64_ABI64)
3861 fix_new_exp (frag_now, frag_now_fix () - md.pointer_size,
3862 md.pointer_size, &exp, 0, reloc);
4420 (md.unwind_check == unwind_check_warning
4540 if (md.unwind_check == unwind_check_error)
4580 int unwind_check = md.unwind_check;
4582 md.unwind_check = unwind_check_error;
4585 md.unwind_check = unwind_check;
4609 subseg_set (md.last_text_seg, 0);
4616 record_alignment (now_seg, md.pointer_size_shift);
4620 memset (frag_more (3 * md.pointer_size), 0, 3 * md.pointer_size);
4621 where = frag_now_fix () - (3 * md.pointer_size);
4701 (md.unwind_check == unwind_check_warning
4799 for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
4801 hash_delete (md.dynreg_hash, dr->name);
4806 drpp = &md.dynreg[type];
4840 if (num_alloced > md.rot.num_regs)
4843 md.rot.num_regs);
4883 if (hash_insert (md.dynreg_hash, name, dr))
4945 md.flags &= ~EF_IA_64_BE;
4947 md.flags |= EF_IA_64_BE;
4949 md.flags &= ~EF_IA_64_ABI64;
4951 md.flags |= EF_IA_64_ABI64;
5022 md.keep_pending_output = 1;
5028 saved_auto_align = md.auto_align;
5030 md.auto_align = 0;
5033 md.auto_align = saved_auto_align;
5035 md.keep_pending_output = 0;
5077 int saved_auto_align = md.auto_align;
5079 md.auto_align = 0;
5081 md.auto_align = saved_auto_align;
5141 gr_values[regno - REG_GR].path = md.path;
5176 if (md.manual_bundling)
5180 md.mode_explicitly_set = 0;
5182 md.mode_explicitly_set = 1;
5184 md.detect_dv = 1;
5189 if (md.explicit_mode)
5191 md.explicit_mode = 0;
5195 if (!md.explicit_mode)
5197 md.explicit_mode = 1;
5201 if (md.explicit_mode != md.default_explicit_mode)
5203 md.explicit_mode = md.default_explicit_mode;
5204 md.mode_explicitly_set = 0;
5381 if (md.debug_dv)
5412 err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (PTR) symbolP);
5440 md.mem_offset.hint = 1;
5441 md.mem_offset.offset = get_absolute_expression ();
5449 md.mem_offset.base = get_absolute_expression ();
5618 err = hash_insert (md.reg_hash, S_GET_NAME (sym), (PTR) sym);
6693 first = (md.curr_slot + NUM_SLOTS - md.num_slots_in_use) % NUM_SLOTS;
6695 n = MIN (3, md.num_slots_in_use);
6700 if (md.slot[first].user_template >= 0)
6701 user_template = template = md.slot[first].user_template;
6709 if (md.slot[curr].label_fixups && i != 0)
6711 type[i] = md.slot[curr].idesc->type;
6733 idesc = md.slot[curr].idesc;
6736 for (i = 0; i < 3 && md.num_slots_in_use > 0; ++i)
6739 unw_rec_list *ptr = md.slot[curr].unwind_record;
6753 for (j = 1; end_ptr == NULL && j < md.num_slots_in_use; ++j)
6754 end_ptr = md.slot[(curr + j) % NUM_SLOTS].unwind_record;
6764 for (ptr = md.slot[curr].unwind_record; ptr != last_ptr;
6772 md.slot[curr].unwind_record = last_ptr;
6776 manual_bundling_off = md.slot[curr].manual_bundling_off;
6777 if (md.slot[curr].manual_bundling_on)
6787 if (curr != first && md.slot[curr].user_template >= 0)
6794 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
6826 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
6839 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
6861 md.slot[curr].end_of_insn_group = 0;
6865 if (curr != first && md.slot[curr].label_fixups)
6869 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
6877 if (end_of_insn_group && md.num_slots_in_use >= 1)
6942 switch (md.hint_b)
6988 md.slot[curr].idesc = idesc;
7014 for (lfix = md.slot[curr].label_fixups; lfix; lfix = lfix->next)
7020 for (lfix = md.slot[curr].tag_fixups; lfix; lfix = lfix->next)
7027 || md.slot[curr].loc_directive_seen
7032 md.slot[curr].loc_directive_seen = 0;
7034 md.slot[curr].debug_line.flags |= DWARF2_FLAG_BASIC_BLOCK;
7036 dwarf2_gen_line_info (addr, &md.slot[curr].debug_line);
7039 build_insn (md.slot + curr, insn + i);
7041 ptr = md.slot[curr].unwind_record;
7052 md.slot[curr].unwind_record = NULL;
7061 --md.num_slots_in_use;
7064 for (j = 0; j < md.slot[curr].num_fixups; ++j)
7066 ifix = md.slot[curr].fixup + j;
7070 fix->fx_file = md.slot[curr].src_file;
7071 fix->fx_line = md.slot[curr].src_line;
7074 end_of_insn_group = md.slot[curr].end_of_insn_group;
7077 ia64_free_opcode (md.slot[curr].idesc);
7078 memset (md.slot + curr, 0, sizeof (md.slot[curr]));
7079 md.slot[curr].user_template = -1;
7087 idesc = md.slot[curr].idesc;
7092 if (md.num_slots_in_use > 0 && last_slot < 0)
7094 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
7098 --md.num_slots_in_use;
7100 ia64_free_opcode (md.slot[curr].idesc);
7101 memset (md.slot + curr, 0, sizeof (md.slot[curr]));
7102 md.slot[curr].user_template = -1;
7106 if (md.num_slots_in_use > 0)
7109 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
7121 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
7127 as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
7131 know (md.num_slots_in_use < NUM_SLOTS);
7154 md.flags |= EF_IA_64_ABI64;
7158 md.flags &= ~EF_IA_64_ABI64;
7162 md.flags &= ~EF_IA_64_BE;
7167 md.flags |= EF_IA_64_BE;
7174 md.unwind_check = unwind_check_warning;
7176 md.unwind_check = unwind_check_error;
7184 md.hint_b = hint_b_ok;
7186 md.hint_b = hint_b_warning;
7188 md.hint_b = hint_b_error;
7196 md.tune = itanium1;
7198 md.tune = itanium2;
7246 md.detect_dv = 1;
7250 md.default_explicit_mode = 1;
7255 md.default_explicit_mode = 0;
7259 md.detect_dv = 0;
7263 md.debug_dv = 1;
7267 md.default_explicit_mode = 1;
7268 md.debug_dv = 1;
7272 md.debug_dv = 1;
7273 md.detect_dv = 0;
7287 md.flags |= EF_IA_64_CONS_GP;
7291 md.flags |= EF_IA_64_NOFUNCDESC_CONS_GP;
7370 switch (md.tune)
7406 md.auto_align = 1;
7407 md.explicit_mode = md.default_explicit_mode;
7488 if (md.tune != itanium1)
7559 md.slot[i].user_template = -1;
7561 md.pseudo_hash = hash_new ();
7564 err = hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
7571 md.reg_hash = hash_new ();
7572 md.dynreg_hash = hash_new ();
7573 md.const_hash = hash_new ();
7574 md.entry_hash = hash_new ();
7617 md.indregsym[regnum - IND_CPUID] = declare_register (indirect_reg[i].name, regnum);
7625 err = hash_insert (md.const_hash, const_bits[i].name,
7634 if (md.flags & EF_IA_64_ABI64)
7642 /* Set the pointer size and pointer shift size depending on md.flags */
7644 if (md.flags & EF_IA_64_ABI64)
7646 md.pointer_size = 8; /* pointers are 8 bytes */
7647 md.pointer_size_shift = 3; /* alignment is 8 bytes = 2^2 */
7651 md.pointer_size = 4; /* pointers are 4 bytes */
7652 md.pointer_size_shift = 2; /* alignment is 4 bytes = 2^2 */
7655 md.mem_offset.hint = 0;
7656 md.path = 0;
7657 md.maxpaths = 0;
7658 md.entry_labels = NULL;
7661 /* Set the default options in md. Cannot do this in md_begin because
7663 options in md based on command line options. */
7670 md.flags = MD_FLAGS_DEFAULT;
7671 md.detect_dv = 1;
7673 md.unwind_check = unwind_check_warning;
7674 md.hint_b = hint_b_error;
7675 md.tune = itanium2;
7685 if (md.flags & EF_IA_64_BE)
7687 if (md.flags & EF_IA_64_ABI64)
7706 if (md.flags & EF_IA_64_ABI64)
7735 bfd_set_private_flags (stdoutput, md.flags);
7737 md.mem_offset.hint = 0;
7752 if (md.qp.X_op == O_register)
7754 md.qp.X_op = O_absent;
7761 if (md.detect_dv && !md.explicit_mode)
7776 if (md.manual_bundling)
7780 md.manual_bundling = 1;
7784 if (md.detect_dv && !md.explicit_mode)
7786 if (!md.mode_explicitly_set
7787 && !md.default_explicit_mode)
7795 if (!md.manual_bundling)
7799 md.manual_bundling = 0;
7802 if (md.detect_dv
7803 && md.explicit_mode
7804 && !md.mode_explicitly_set
7805 && !md.default_explicit_mode)
7821 expression_and_evaluate (&md.qp);
7827 if (md.qp.X_op != O_register)
7832 if (md.qp.X_add_number < REG_P || md.qp.X_add_number >= REG_P + 64)
7846 if (md.qp.X_op == O_register)
7929 md.last_text_seg = now_seg;
7937 if (md.path == md.maxpaths)
7939 md.maxpaths += 20;
7940 md.entry_labels = (const char **)
7941 xrealloc ((void *) md.entry_labels,
7942 md.maxpaths * sizeof (char *));
7944 md.entry_labels[md.path++] = S_GET_NAME (sym);
7968 if (!md.keep_pending_output
8022 l->X_op_symbol = md.indregsym[l->X_add_number - IND_CPUID];
8131 sym = hash_find (md.reg_hash, name);
8139 cdesc = hash_find (md.const_hash, name);
8154 dr = &md.in;
8162 dr = &md.loc;
8170 dr = &md.out;
8206 if ((dr = hash_find (md.dynreg_hash, name)))
8452 if (md.mem_offset.hint)
8454 if (md.debug_dv)
8458 specs[count].index = (md.mem_offset.offset >> 3) & 0x3F;
8460 specs[count].mem_offset.offset = md.mem_offset.offset;
8461 specs[count++].mem_offset.base = md.mem_offset.base;
9512 /* Assumes that md.rot.num_regs is always valid */
9513 if (md.rot.num_regs > 0
9515 && num < 31 + md.rot.num_regs)
9713 && qp_mutexes[i].path == md.path)
9722 if (md.debug_dv)
9734 if (qp_mutexes[i].path == md.path)
9782 if (md.debug_dv)
9812 if (md.debug_dv)
9844 && qp_implies[i].path == md.path
9856 if (md.debug_dv)
9860 qp_implies[qp_implieslen].path = md.path;
9902 if (md.debug_dv)
9908 qp_mutexes[qp_mutexeslen].path = md.path;
9929 if (md.debug_dv)
9999 for (i = 32; i < 32 + md.rot.num_regs; i++)
10037 if (md.debug_dv)
10098 gr_values[regno].path = md.path;
10099 if (md.debug_dv)
10122 gr_values[regno].path = md.path;
10123 if (md.debug_dv)
10211 if (md.debug_dv)
10218 if (md.debug_dv)
10255 if (insert_stop && md.num_slots_in_use > 0)
10258 if (md.debug_dv)
10346 if (md.debug_dv)
10368 if (md.debug_dv)
10379 if (md.debug_dv)
10405 if (md.debug_dv)
10409 if (md.debug_dv)
10421 md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
10422 if (++md.num_slots_in_use >= NUM_SLOTS)
10432 if (md.debug_dv)
10443 md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
10444 if (++md.num_slots_in_use >= NUM_SLOTS)
10451 if (md.debug_dv)
10503 for (path = 0; path <= md.path; path++)
10551 md.entry_labels[path - 1]);
10564 if (md.explicit_mode)
10567 if (path < md.path)
10579 if (md.debug_dv)
10618 if (md.debug_dv)
10639 count = specify_resource (dep, idesc, DV_REG, specs, note, md.path);
10644 DEP (opdeps->regs[i]), md.path);
10661 for (path = 0; path < md.path; path++)
10696 md.path = 0;
10760 if (md.debug_dv)
10798 md.mem_offset.hint = 0;
10823 pdesc = (struct pseudo_opcode *) hash_find (md.pseudo_hash, mnemonic);
10922 switch (md.hint_b)
10936 if (md.qp.X_op == O_register)
10938 qp_regno = md.qp.X_add_number - REG_P;
10939 md.qp.X_op = O_absent;
11001 if (md.detect_dv)
11004 md.curr_slot = (md.curr_slot + 1) % NUM_SLOTS;
11005 if (++md.num_slots_in_use >= NUM_SLOTS)
11011 md.last_text_seg = now_seg;
11191 && !(md.flags & EF_IA_64_ABI64))