keyword in c++.
* bfd/aoutx.h (NAME (aout, make_empty_symbol)): Rename variable
new to new_symbol.
* bfd/coffgen.c (coff_make_empty_symbol)
(coff_bfd_make_debug_symbol): Rename variable new to new_symbol.
* bfd/cpu-ia64-opc.c (ext_reg, ins_imms_scaled): Rename variable
new to new_insn.
* bfd/doc/chew.c (newentry, add_intrinsic): Rename variable new to
new_d.
* bfd/ecoff.c (_bfd_ecoff_make_empty_symbol): Rename variable new
to new_symbol.
* bfd/elf32-m68k.c (elf_m68k_get_got_entry_type): Rename argument
new to new_reloc.
* bfd/hash.c (bfd_hash_lookup): Rename variable new to new_string.
* bfd/ieee.c (ieee_make_empty_symbol): Rename variable new to
new_symbol.
* bfd/linker.c (bfd_new_link_order): Rename variable new to
new_lo.
* bfd/mach-o.c (bfd_mach_o_sizeof_headers): Rename variable new to
symbol.
* bfd/oasys.c (oasys_make_empty_symbol): Rename variable new to
new_symbol_type.
* bfd/pdp11.c (NAME (aout, make_empty_symbol)): Rename variable
new to new_symbol_type.
* bfd/plugin.c (bfd_plugin_make_empty_symbol): Rename variable new
to new_symbol.
* bfd/rs6000-core.c (CoreHdr, VmInfo): Rename union member new to
new_dump.
(read_hdr, rs6000coff_core_p)
(rs6000coff_core_file_matches_executable_p)
(rs6000coff_core_file_failing_command)
(rs6000coff_core_file_failing_signal): Updated function to use new
union member name.
* bfd/som.c (som_make_empty_symbol): Rename variable new to
new_symbol_type.
* bfd/syms.c (_bfd_generic_make_empty_symbol): Rename variable new
to new_symbol.
* bfd/tekhex.c (first_phase, tekhex_make_empty_symbol): Rename
variable new to new_symbol.
* binutils/nlmconv.c (main): Rename variable new to new_name.
* gas/config/tc-arm.c (insert_reg_alias): Rename variable new to
new_reg.
* gas/config/tc-dlx.c (parse_operand): Rename variable new to
new_pos.
* gas/config/tc-ia64.c (ia64_gen_real_reloc_type): Rename variable
new to newr.
* gas/config/tc-mcore.c (parse_exp, parse_imm): Rename variable
new to new_pointer.
* gas/config/tc-microblaze.c (parse_exp, parse_imm, check_got):
Change name from new to new_pointer.
* gas/config/tc-or32.c (parse_operand): Rename variable new to
new_pointer.
* gas/config/tc-pdp11.c (md_assemble): Rename variable new to
new_pointer.
* gas/config/tc-pj.c (alias): Change argument new to new_name.
* gas/config/tc-score.c (s3_build_score_ops_hsh): Rename variable
new to new_opcode. (s3_build_dependency_insn_hsh) Rename variable
new to new_i2n. (s3_convert): Rename variables old and new to
r_old and r_new.
* gas/config/tc-score7.c (s7_build_score_ops_hsh): Rename variable
new to new_opcode. (s7_build_dependency_insn_hsh): Rename variable
new to new_i2d. (s7_b32_relax_to_b16, s7_convert_frag): Rename
variables old and new to r_old and r_new.
* gas/config/tc-sh.c (parse_exp): Rename variable new to
new_pointer.
* gas/config/tc-sh64.c (shmedia_parse_exp): Rename variable new to
new_pointer.
* gas/config/tc-tic4x.c (tic4x_operand_parse): Rename variable new
to new_pointer.
* gas/config/tc-z8k.c (parse_exp): Rename variable new to
new_pointer.
* gas/listing.c (listing_newline): Rename variable new to new_i.
* ld/ldexp.c (exp_intop, exp_bigintop, exp_relop, exp_binop)
(exp_trinop, exp_unop, exp_nameop, exp_assop): Rename variable new
to new_e.
* ld/ldfile.c (ldfile_add_library_path): Rename variable new to
new_dirs. (ldfile_add_arch): Rename variable new to new_arch.
* ld/ldlang.c (new_statement, lang_final, lang_add_wild)
(lang_target, lang_add_fill, lang_add_data, lang_add_assignment)
(lang_add_insert): Rename variable new to new_stmt. (new_afile):
Added missing cast. (lang_memory_region_lookup): Rename variable
new to new_region. (init_os): Rename variable new to
new_userdata. (lang_add_section): Rename variable new to
new_section. (ldlang_add_undef): Rename variable new to
new_undef. (realsymbol): Rename variable new to new_name.
* opcodes/z8kgen.c (internal, gas): Rename variable new to new_op.
Updated sources to avoid using the identifier name "template",
which is a keyword in c++.
* bfd/elf32-arm.c (struct stub_def): Rename member template to
template_sequence. (arm_build_one_stub,
find_stub_size_and_template, arm_size_one_stub, arm_map_one_stub):
Rename variable template to template_sequence.
* bfd/elfxx-ia64.c (elfNN_ia64_relax_br, elfNN_ia64_relax_brl):
Rename variable template to template_val.
* gas/config/tc-arm.c (struct asm_cond, struct asm_psr, struct
asm_barrier_opt): Change member template to
template_name. (md_begin): Update code to reflect new member
names.
* gas/config/tc-i386.c (struct templates, struct _i386_insn)
(match_template, cpu_flags_match, match_reg_size, match_mem_size)
(operand_size_match, md_begin, i386_print_statistics, pi)
(build_vex_prefix, md_assemble, parse_insn, optimize_imm)
(optimize_disp): Updated code to use new names. (parse_insn):
Added casts.
* gas/config/tc-ia64.c (dot_template, emit_one_bundle): Updated
code to use new names.
* gas/config/tc-score.c (struct s3_asm_opcode): Renamed member
template to template_name. (s3_parse_16_32_inst, s3_parse_48_inst,
s3_do_macro_ldst_label, s3_build_score_ops_hsh): Update code to
use new names.
* gas/config/tc-score7.c (struct s7_asm_opcode): Renamed member
template to template_name. (s7_parse_16_32_inst,
s7_do_macro_ldst_label, s7_build_score_ops_hsh): Update code to
use new names.
* gas/config/tc-tic30.c (md_begin, struct tic30_insn)
(md_assemble): Update code to use new names.
* gas/config/tc-tic54x.c (struct _tic54x_insn, md_begin)
(optimize_insn, tic54x_parse_insn, next_line_shows_parallel):
Update code to use new names.
* include/opcode/tic30.h (template): Rename type template to
insn_template. Updated code to use new name.
* include/opcode/tic54x.h (template): Rename type template to
insn_template.
* opcodes/cris-dis.c (bytes_to_skip): Update code to use new name.
* opcodes/i386-dis.c (putop): Update code to use new name.
* opcodes/i386-gen.c (process_i386_opcodes): Update code to use
new name.
* opcodes/i386-opc.h (struct template): Rename struct template to
insn_template. Update code accordingly.
* opcodes/i386-tbl.h (i386_optab): Update type to use new name.
* opcodes/ia64-dis.c (print_insn_ia64): Rename variable template
to template_val.
* opcodes/tic30-dis.c (struct instruction, get_tic30_instruction):
Update code to use new name.
* opcodes/tic54x-dis.c (has_lkaddr, get_insn_size)
(print_parallel_instruction, print_insn_tic54x, tic54x_get_insn):
Update code to use new name.
* opcodes/tic54x-opc.c (tic54x_unknown_opcode, tic54x_optab):
Update type to new name.
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * elf32-arm.c (struct stub_def): Rename member template to
+ template_sequence. (arm_build_one_stub,
+ find_stub_size_and_template, arm_size_one_stub, arm_map_one_stub):
+ Rename variable template to template_sequence.
+ * elfxx-ia64.c (elfNN_ia64_relax_br, elfNN_ia64_relax_brl):
+ Rename variable template to template_val.
+ * aoutx.h (NAME (aout, make_empty_symbol)): Rename variable
+ new to new_symbol.
+ * coffgen.c (coff_make_empty_symbol)
+ (coff_bfd_make_debug_symbol): Rename variable new to new_symbol.
+ * cpu-ia64-opc.c (ext_reg, ins_imms_scaled): Rename variable
+ new to new_insn.
+ * ecoff.c (_bfd_ecoff_make_empty_symbol): Rename variable new
+ to new_symbol.
+ * elf32-m68k.c (elf_m68k_get_got_entry_type): Rename argument
+ new to new_reloc.
+ * hash.c (bfd_hash_lookup): Rename variable new to new_string.
+ * ieee.c (ieee_make_empty_symbol): Rename variable new to
+ new_symbol.
+ * linker.c (bfd_new_link_order): Rename variable new to
+ new_lo.
+ * mach-o.c (bfd_mach_o_sizeof_headers): Rename variable new to
+ symbol.
+ * oasys.c (oasys_make_empty_symbol): Rename variable new to
+ new_symbol_type.
+ * pdp11.c (NAME (aout, make_empty_symbol)): Rename variable
+ new to new_symbol_type.
+ * plugin.c (bfd_plugin_make_empty_symbol): Rename variable new
+ to new_symbol.
+ * rs6000-core.c (CoreHdr, VmInfo): Rename union member new to
+ new_dump.
+ (read_hdr, rs6000coff_core_p)
+ (rs6000coff_core_file_matches_executable_p)
+ (rs6000coff_core_file_failing_command)
+ (rs6000coff_core_file_failing_signal): Updated function to use new
+ union member name.
+ * som.c (som_make_empty_symbol): Rename variable new to
+ new_symbol_type.
+ * syms.c (_bfd_generic_make_empty_symbol): Rename variable new
+ to new_symbol.
+ * tekhex.c (first_phase, tekhex_make_empty_symbol): Rename
+ variable new to new_symbol.
+
2009-08-27 Ralf Wildenhues <Ralf.Wildenhues@gmx.de>
* acinclude.m4 (AM_INSTALL_LIBBFD): Call AM_SUBST_NOTMAKE for
{
bfd_size_type amt = sizeof (aout_symbol_type);
- aout_symbol_type *new = bfd_zalloc (abfd, amt);
- if (!new)
+ aout_symbol_type *new_symbol = (aout_symbol_type *) bfd_zalloc (abfd, amt);
+ if (!new_symbol)
return NULL;
- new->symbol.the_bfd = abfd;
+ new_symbol->symbol.the_bfd = abfd;
- return &new->symbol;
+ return &new_symbol->symbol;
}
/* Translate a set of internal symbols into external symbols. */
coff_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (coff_symbol_type);
- coff_symbol_type *new = bfd_zalloc (abfd, amt);
+ coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
- if (new == NULL)
+ if (new_symbol == NULL)
return NULL;
- new->symbol.section = 0;
- new->native = 0;
- new->lineno = NULL;
- new->done_lineno = FALSE;
- new->symbol.the_bfd = abfd;
+ new_symbol->symbol.section = 0;
+ new_symbol->native = 0;
+ new_symbol->lineno = NULL;
+ new_symbol->done_lineno = FALSE;
+ new_symbol->symbol.the_bfd = abfd;
- return & new->symbol;
+ return & new_symbol->symbol;
}
/* Make a debugging symbol. */
unsigned long sz ATTRIBUTE_UNUSED)
{
bfd_size_type amt = sizeof (coff_symbol_type);
- coff_symbol_type *new = bfd_alloc (abfd, amt);
+ coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
- if (new == NULL)
+ if (new_symbol == NULL)
return NULL;
/* @@ The 10 is a guess at a plausible maximum number of aux entries
(but shouldn't be a constant). */
amt = sizeof (combined_entry_type) * 10;
- new->native = bfd_zalloc (abfd, amt);
- if (!new->native)
+ new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
+ if (!new_symbol->native)
return NULL;
- new->symbol.section = bfd_abs_section_ptr;
- new->symbol.flags = BSF_DEBUGGING;
- new->lineno = NULL;
- new->done_lineno = FALSE;
- new->symbol.the_bfd = abfd;
+ new_symbol->symbol.section = bfd_abs_section_ptr;
+ new_symbol->symbol.flags = BSF_DEBUGGING;
+ new_symbol->lineno = NULL;
+ new_symbol->done_lineno = FALSE;
+ new_symbol->symbol.the_bfd = abfd;
- return & new->symbol;
+ return & new_symbol->symbol;
}
void
static const char*
ins_immu (const struct ia64_operand *self, ia64_insn value, ia64_insn *code)
{
- ia64_insn new = 0;
+ ia64_insn new_insn = 0;
int i;
for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i)
{
- new |= ((value & ((((ia64_insn) 1) << self->field[i].bits) - 1))
- << self->field[i].shift);
+ new_insn |= ((value & ((((ia64_insn) 1) << self->field[i].bits) - 1))
+ << self->field[i].shift);
value >>= self->field[i].bits;
}
if (value)
return "integer operand out of range";
- *code |= new;
+ *code |= new_insn;
return 0;
}
ia64_insn *code, int scale)
{
BFD_HOST_64_BIT svalue = value, sign_bit = 0;
- ia64_insn new = 0;
+ ia64_insn new_insn = 0;
int i;
svalue >>= scale;
for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i)
{
- new |= ((svalue & ((((ia64_insn) 1) << self->field[i].bits) - 1))
- << self->field[i].shift);
+ new_insn |= ((svalue & ((((ia64_insn) 1) << self->field[i].bits) - 1))
+ << self->field[i].shift);
sign_bit = (svalue >> (self->field[i].bits - 1)) & 1;
svalue >>= self->field[i].bits;
}
if ((!sign_bit && svalue != 0) || (sign_bit && svalue != -1))
return "integer operand out of range";
- *code |= new;
+ *code |= new_insn;
return 0;
}
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * chew.c (newentry, add_intrinsic): Rename variable new to
+ new_d.
+
2009-08-27 Ralf Wildenhues <Ralf.Wildenhues@gmx.de>
* Makefile.in: Regenerate.
newentry (word)
char *word;
{
- dict_type *new = (dict_type *) malloc (sizeof (dict_type));
- new->word = word;
- new->next = root;
- root = new;
- new->code = (stinst_type *) malloc (sizeof (stinst_type));
- new->code_length = 1;
- new->code_end = 0;
- return new;
+ dict_type *new_d = (dict_type *) malloc (sizeof (dict_type));
+ new_d->word = word;
+ new_d->next = root;
+ root = new_d;
+ new_d->code = (stinst_type *) malloc (sizeof (stinst_type));
+ new_d->code_length = 1;
+ new_d->code_end = 0;
+ return new_d;
}
unsigned int
char *name;
void (*func) ();
{
- dict_type *new = newentry (name);
- add_to_definition (new, func);
- add_to_definition (new, 0);
+ dict_type *new_d = newentry (name);
+ add_to_definition (new_d, func);
+ add_to_definition (new_d, 0);
}
void
add_var (name)
char *name;
{
- dict_type *new = newentry (name);
- add_to_definition (new, push_number);
- add_to_definition (new, (stinst_type) (&(new->var)));
- add_to_definition (new, 0);
+ dict_type *new_d = newentry (name);
+ add_to_definition (new_d, push_number);
+ add_to_definition (new_d, (stinst_type) (&(new_d->var)));
+ add_to_definition (new_d, 0);
}
void
asymbol *
_bfd_ecoff_make_empty_symbol (bfd *abfd)
{
- ecoff_symbol_type *new;
+ ecoff_symbol_type *new_symbol;
bfd_size_type amt = sizeof (ecoff_symbol_type);
- new = bfd_zalloc (abfd, amt);
- if (new == NULL)
+ new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt);
+ if (new_symbol == NULL)
return NULL;
- new->symbol.section = NULL;
- new->fdr = NULL;
- new->local = FALSE;
- new->native = NULL;
- new->symbol.the_bfd = abfd;
- return &new->symbol;
+ new_symbol->symbol.section = NULL;
+ new_symbol->fdr = NULL;
+ new_symbol->local = FALSE;
+ new_symbol->native = NULL;
+ new_symbol->symbol.the_bfd = abfd;
+ return &new_symbol->symbol;
}
/* Set the BFD flags and section for an ECOFF symbol. */
typedef struct
{
- const insn_sequence* template;
+ const insn_sequence* template_sequence;
int template_size;
} stub_def;
bfd_vma sym_value;
int template_size;
int size;
- const insn_sequence *template;
+ const insn_sequence *template_sequence;
int i;
struct elf32_arm_link_hash_table * globals;
int stub_reloc_idx[MAXRELOCS] = {-1, -1};
+ stub_entry->target_section->output_offset
+ stub_entry->target_section->output_section->vma);
- template = stub_entry->stub_template;
+ template_sequence = stub_entry->stub_template;
template_size = stub_entry->stub_template_size;
size = 0;
for (i = 0; i < template_size; i++)
{
- switch (template[i].type)
+ switch (template_sequence[i].type)
{
case THUMB16_TYPE:
{
- bfd_vma data = template[i].data;
- if (template[i].reloc_addend != 0)
+ bfd_vma data = (bfd_vma) template_sequence[i].data;
+ if (template_sequence[i].reloc_addend != 0)
{
/* We've borrowed the reloc_addend field to mean we should
insert a condition code into this (Thumb-1 branch)
break;
case THUMB32_TYPE:
- put_thumb_insn (globals, stub_bfd, (template[i].data >> 16) & 0xffff,
+ put_thumb_insn (globals, stub_bfd,
+ (template_sequence[i].data >> 16) & 0xffff,
loc + size);
- put_thumb_insn (globals, stub_bfd, template[i].data & 0xffff,
+ put_thumb_insn (globals, stub_bfd, template_sequence[i].data & 0xffff,
loc + size + 2);
- if (template[i].r_type != R_ARM_NONE)
+ if (template_sequence[i].r_type != R_ARM_NONE)
{
stub_reloc_idx[nrelocs] = i;
stub_reloc_offset[nrelocs++] = size;
break;
case ARM_TYPE:
- put_arm_insn (globals, stub_bfd, template[i].data, loc + size);
+ put_arm_insn (globals, stub_bfd, template_sequence[i].data,
+ loc + size);
/* Handle cases where the target is encoded within the
instruction. */
- if (template[i].r_type == R_ARM_JUMP24)
+ if (template_sequence[i].r_type == R_ARM_JUMP24)
{
stub_reloc_idx[nrelocs] = i;
stub_reloc_offset[nrelocs++] = size;
break;
case DATA_TYPE:
- bfd_put_32 (stub_bfd, template[i].data, loc + size);
+ bfd_put_32 (stub_bfd, template_sequence[i].data, loc + size);
stub_reloc_idx[nrelocs] = i;
stub_reloc_offset[nrelocs++] = size;
size += 4;
BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
for (i = 0; i < nrelocs; i++)
- if (template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
- || template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
- || template[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
- || template[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
+ if (template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
+ || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
+ || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
+ || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
{
Elf_Internal_Rela rel;
bfd_boolean unresolved_reloc;
char *error_message;
int sym_flags
- = (template[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
+ = (template_sequence[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
? STT_ARM_TFUNC : 0;
bfd_vma points_to = sym_value + stub_entry->target_addend;
rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
- rel.r_info = ELF32_R_INFO (0, template[stub_reloc_idx[i]].r_type);
- rel.r_addend = template[stub_reloc_idx[i]].reloc_addend;
+ rel.r_info = ELF32_R_INFO (0,
+ template_sequence[stub_reloc_idx[i]].r_type);
+ rel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
/* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
rather than only for certain relocations listed in the enclosing
conditional, for the sake of consistency. */
elf32_arm_final_link_relocate (elf32_arm_howto_from_type
- (template[stub_reloc_idx[i]].r_type),
+ (template_sequence[stub_reloc_idx[i]].r_type),
stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
points_to, info, stub_entry->target_section, "", sym_flags,
(struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
else
{
_bfd_final_link_relocate (elf32_arm_howto_from_type
- (template[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
+ (template_sequence[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
stub_sec->contents, stub_entry->stub_offset + stub_reloc_offset[i],
sym_value + stub_entry->target_addend,
- template[stub_reloc_idx[i]].reloc_addend);
+ template_sequence[stub_reloc_idx[i]].reloc_addend);
}
return TRUE;
const insn_sequence **stub_template,
int *stub_template_size)
{
- const insn_sequence *template = NULL;
+ const insn_sequence *template_sequence = NULL;
int template_size = 0, i;
unsigned int size;
- template = stub_definitions[stub_type].template;
+ template_sequence = stub_definitions[stub_type].template_sequence;
template_size = stub_definitions[stub_type].template_size;
size = 0;
for (i = 0; i < template_size; i++)
{
- switch (template[i].type)
+ switch (template_sequence[i].type)
{
case THUMB16_TYPE:
size += 2;
}
if (stub_template)
- *stub_template = template;
+ *stub_template = template_sequence;
if (stub_template_size)
*stub_template_size = template_size;
{
struct elf32_arm_stub_hash_entry *stub_entry;
struct elf32_arm_link_hash_table *htab;
- const insn_sequence *template;
+ const insn_sequence *template_sequence;
int template_size, size;
/* Massage our args to the form they really have. */
BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
&& stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
- size = find_stub_size_and_template (stub_entry->stub_type, &template,
+ size = find_stub_size_and_template (stub_entry->stub_type, &template_sequence,
&template_size);
stub_entry->stub_size = size;
- stub_entry->stub_template = template;
+ stub_entry->stub_template = template_sequence;
stub_entry->stub_template_size = template_size;
size = (size + 7) & ~7;
unsigned int section_id = a8_fixes[i].section->id;
asection *link_sec = htab->stub_group[section_id].link_sec;
asection *stub_sec = htab->stub_group[section_id].stub_sec;
- const insn_sequence *template;
+ const insn_sequence *template_sequence;
int template_size, size = 0;
stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
stub_entry->orig_insn = a8_fixes[i].orig_insn;
stub_entry->st_type = STT_ARM_TFUNC;
- size = find_stub_size_and_template (a8_fixes[i].stub_type, &template,
+ size = find_stub_size_and_template (a8_fixes[i].stub_type,
+ &template_sequence,
&template_size);
stub_entry->stub_size = size;
- stub_entry->stub_template = template;
+ stub_entry->stub_template = template_sequence;
stub_entry->stub_template_size = template_size;
}
bfd_vma addr;
char *stub_name;
output_arch_syminfo *osi;
- const insn_sequence *template;
+ const insn_sequence *template_sequence;
enum stub_insn_type prev_type;
int size;
int i;
addr = (bfd_vma) stub_entry->stub_offset;
stub_name = stub_entry->output_name;
- template = stub_entry->stub_template;
- switch (template[0].type)
+ template_sequence = stub_entry->stub_template;
+ switch (template_sequence[0].type)
{
case ARM_TYPE:
if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
size = 0;
for (i = 0; i < stub_entry->stub_template_size; i++)
{
- switch (template[i].type)
+ switch (template_sequence[i].type)
{
case ARM_TYPE:
sym_type = ARM_MAP_ARM;
return FALSE;
}
- if (template[i].type != prev_type)
+ if (template_sequence[i].type != prev_type)
{
- prev_type = template[i].type;
+ prev_type = template_sequence[i].type;
if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
return FALSE;
}
- switch (template[i].type)
+ switch (template_sequence[i].type)
{
case ARM_TYPE:
case THUMB32_TYPE:
{
struct elf_i386_link_hash_table *htab;
+ /* PR 10433: STT_GNU_IFUNC symbols must go through the PLT
+ only when they are referenced, not when they are defined. */
+ if (h->type == STT_GNU_IFUNC
+ && h->def_regular
+ && ! h->ref_regular
+ && ! info->relocatable)
+ {
+ if (! ((h->dynindx != -1
+ || h->forced_local)
+ && ((info->shared
+ && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ || h->root.type != bfd_link_hash_undefweak))
+ || ! h->forced_local)
+ && elf_hash_table (info)->dynamic_sections_created))
+ return TRUE;
+ }
+
htab = elf_i386_hash_table (info);
if (h->plt.offset != (bfd_vma) -1)
static enum elf_m68k_reloc_type
elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
enum elf_m68k_reloc_type was,
- enum elf_m68k_reloc_type new)
+ enum elf_m68k_reloc_type new_reloc)
{
enum elf_m68k_got_offset_size was_size;
enum elf_m68k_got_offset_size new_size;
/* Update all got->n_slots counters, including n_slots[R_32]. */
was_size = R_LAST;
- was = new;
+ was = new_reloc;
}
else
{
/* !!! We, probably, should emit an error rather then fail on assert
in such a case. */
BFD_ASSERT (elf_m68k_reloc_got_type (was)
- == elf_m68k_reloc_got_type (new));
+ == elf_m68k_reloc_got_type (new_reloc));
was_size = elf_m68k_reloc_got_offset_size (was);
}
- new_size = elf_m68k_reloc_got_offset_size (new);
- n_slots = elf_m68k_reloc_got_n_slots (new);
+ new_size = elf_m68k_reloc_got_offset_size (new_reloc);
+ n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
while (was_size > new_size)
{
got->n_slots[was_size] += n_slots;
}
- if (new > was)
+ if (new_reloc > was)
/* Relocations are ordered from bigger got offset size to lesser,
so choose the relocation type with lesser offset size. */
- was = new;
+ was = new_reloc;
return was;
}
{
struct elf64_x86_64_link_hash_table *htab;
+ /* PR 10433: STT_GNU_IFUNC symbols must go through the PLT
+ only when they are referenced, not when they are defined. */
+ if (h->type == STT_GNU_IFUNC
+ && h->def_regular
+ && ! h->ref_regular
+ && ! info->relocatable)
+ {
+ if (! ((h->dynindx != -1
+ || h->forced_local)
+ && ((info->shared
+ && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ || h->root.type != bfd_link_hash_undefweak))
+ || ! h->forced_local)
+ && elf_hash_table (info)->dynamic_sections_created))
+ return TRUE;
+ }
+
htab = elf64_x86_64_hash_table (info);
if (h->plt.offset != (bfd_vma) -1)
static bfd_boolean
elfNN_ia64_relax_br (bfd_byte *contents, bfd_vma off)
{
- unsigned int template, mlx;
+ unsigned int template_val, mlx;
bfd_vma t0, t1, s0, s1, s2, br_code;
long br_slot;
bfd_byte *hit_addr;
/* Check if we can turn br into brl. A label is always at the start
of the bundle. Even if there are predicates on NOPs, we still
perform this optimization. */
- template = t0 & 0x1e;
+ template_val = t0 & 0x1e;
s0 = (t0 >> 5) & 0x1ffffffffffLL;
s1 = ((t0 >> 46) | (t1 << 18)) & 0x1ffffffffffLL;
s2 = (t1 >> 23) & 0x1ffffffffffLL;
case 1:
/* Check if slot 2 is NOP. Possible templates are MBB and BBB.
For BBB, slot 0 also has to be nop.b. */
- if (!((template == 0x12 /* MBB */
+ if (!((template_val == 0x12 /* MBB */
&& IS_NOP_B (s2))
- || (template == 0x16 /* BBB */
+ || (template_val == 0x16 /* BBB */
&& IS_NOP_B (s0)
&& IS_NOP_B (s2))))
return FALSE;
case 2:
/* Check if slot 1 is NOP. Possible templates are MIB, MBB, BBB,
MMB and MFB. For BBB, slot 0 also has to be nop.b. */
- if (!((template == 0x10 /* MIB */
+ if (!((template_val == 0x10 /* MIB */
&& IS_NOP_I (s1))
- || (template == 0x12 /* MBB */
+ || (template_val == 0x12 /* MBB */
&& IS_NOP_B (s1))
- || (template == 0x16 /* BBB */
+ || (template_val == 0x16 /* BBB */
&& IS_NOP_B (s0)
&& IS_NOP_B (s1))
- || (template == 0x18 /* MMB */
+ || (template_val == 0x18 /* MMB */
&& IS_NOP_M (s1))
- || (template == 0x1c /* MFB */
+ || (template_val == 0x1c /* MFB */
&& IS_NOP_F (s1))))
return FALSE;
br_code = s2;
else
mlx = 0x4;
- if (template == 0x16)
+ if (template_val == 0x16)
{
/* For BBB, we need to put nop.m in slot 0. We keep the original
predicate only if slot 0 isn't br. */
static void
elfNN_ia64_relax_brl (bfd_byte *contents, bfd_vma off)
{
- int template;
+ int template_val;
bfd_byte *hit_addr;
bfd_vma t0, t1, i0, i1, i2;
/* Turn a MLX bundle into a MBB bundle with the same stop-bit
variety. */
if (t0 & 0x1)
- template = 0x13;
+ template_val = 0x13;
else
- template = 0x12;
- t0 = (i1 << 46) | (i0 << 5) | template;
+ template_val = 0x12;
+ t0 = (i1 << 46) | (i0 << 5) | template_val;
t1 = (i2 << 23) | (i1 >> 18);
bfd_putl64 (t0, hit_addr);
if (copy)
{
- char *new;
+ char *new_string;
- new = objalloc_alloc ((struct objalloc *) table->memory, len + 1);
- if (!new)
+ new_string = (char *) objalloc_alloc ((struct objalloc *) table->memory,
+ len + 1);
+ if (!new_string)
{
bfd_set_error (bfd_error_no_memory);
return NULL;
}
- memcpy (new, string, len + 1);
- string = new;
+ memcpy (new_string, string, len + 1);
+ string = new_string;
}
return bfd_hash_insert (table, string, hash);
ieee_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (ieee_symbol_type);
- ieee_symbol_type *new = bfd_zalloc (abfd, amt);
+ ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
- if (!new)
+ if (!new_symbol)
return NULL;
- new->symbol.the_bfd = abfd;
- return &new->symbol;
+ new_symbol->symbol.the_bfd = abfd;
+ return &new_symbol->symbol;
}
static bfd *
bfd_new_link_order (bfd *abfd, asection *section)
{
bfd_size_type amt = sizeof (struct bfd_link_order);
- struct bfd_link_order *new;
+ struct bfd_link_order *new_lo;
- new = bfd_zalloc (abfd, amt);
- if (!new)
+ new_lo = (struct bfd_link_order *) bfd_zalloc (abfd, amt);
+ if (!new_lo)
return NULL;
- new->type = bfd_undefined_link_order;
+ new_lo->type = bfd_undefined_link_order;
if (section->map_tail.link_order != NULL)
- section->map_tail.link_order->next = new;
+ section->map_tail.link_order->next = new_lo;
else
- section->map_head.link_order = new;
- section->map_tail.link_order = new;
+ section->map_head.link_order = new_lo;
+ section->map_tail.link_order = new_lo;
- return new;
+ return new_lo;
}
/* Default link order processing routine. Note that we can not handle
asymbol *
bfd_mach_o_make_empty_symbol (bfd *abfd)
{
- asymbol *new;
-
- new = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
- if (new == NULL)
- return new;
- new->the_bfd = abfd;
- new->udata.i = 0;
- return new;
+ asymbol *new_symbol;
+
+ new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
+ if (new_symbol == NULL)
+ return new_symbol;
+ new_symbol->the_bfd = abfd;
+ new_symbol->udata.i = 0;
+ return new_symbol;
}
static bfd_boolean
oasys_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (oasys_symbol_type);
- oasys_symbol_type *new = bfd_zalloc (abfd, amt);
+ oasys_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
- if (!new)
+ if (!new_symbol_type)
return NULL;
- new->symbol.the_bfd = abfd;
- return &new->symbol;
+ new_symbol_type->symbol.the_bfd = abfd;
+ return &new_symbol_type->symbol;
}
/* User should have checked the file flags; perhaps we should return
NAME (aout, make_empty_symbol) (bfd *abfd)
{
bfd_size_type amt = sizeof (aout_symbol_type);
- aout_symbol_type *new = bfd_zalloc (abfd, amt);
+ aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
- if (!new)
+ if (!new_symbol_type)
return NULL;
- new->symbol.the_bfd = abfd;
+ new_symbol_type->symbol.the_bfd = abfd;
- return &new->symbol;
+ return &new_symbol_type->symbol;
}
/* Translate a set of internal symbols into external symbols. */
static asymbol *
bfd_plugin_make_empty_symbol (bfd *abfd)
{
- asymbol *new = bfd_zalloc (abfd, sizeof (asymbol));
- if (new == NULL)
- return new;
- new->the_bfd = abfd;
- return new;
+ asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
+ if (new_symbol == NULL)
+ return new_symbol;
+ new_symbol->the_bfd = abfd;
+ return new_symbol;
}
static int
typedef union {
#ifdef AIX_CORE_DUMPX_CORE
- struct core_dumpx new; /* new AIX 4.3+ core dump */
+ struct core_dumpx new_dump; /* new AIX 4.3+ core dump */
#else
- struct core_dump new; /* for simpler coding */
+ struct core_dump new_dump; /* for simpler coding */
#endif
struct core_dump old; /* old AIX 4.2- core dump, still used on
4.3+ with appropriate SMIT config */
#ifdef CORE_VERSION_1
typedef union {
#ifdef AIX_CORE_DUMPX_CORE
- struct vm_infox new;
+ struct vm_infox new_dump;
#else
- struct vm_info new;
+ struct vm_info new_dump;
#endif
struct vm_info old;
} VmInfo;
#ifdef AIX_5_CORE
# define CORE_DUMPXX_VERSION 267312562
-# define CNEW_IS_CORE_DUMPXX(c) ((c).new.c_version == CORE_DUMPXX_VERSION)
+# define CNEW_IS_CORE_DUMPXX(c) ((c).new_dump.c_version == CORE_DUMPXX_VERSION)
#else
# define CNEW_IS_CORE_DUMPXX(c) 0
#endif
/* Read the trailing portion of the structure. */
if (CORE_NEW (*core))
- size = sizeof (core->new);
+ size = sizeof (core->new_core);
else
size = sizeof (core->old);
size -= CORE_COMMONSZ;
/* Copy fields from new or old core structure. */
if (CORE_NEW (core))
{
- c_flag = core.new.c_flag;
- c_stack = (file_ptr) core.new.c_stack;
- c_size = core.new.c_size;
- c_stackend = CNEW_STACKORG (core.new) + c_size;
- c_lsize = CNEW_LSIZE (core.new);
- c_loader = CNEW_LOADER (core.new);
- proc64 = CNEW_PROC64 (core.new);
+ c_flag = core.new_dump.c_flag;
+ c_stack = (file_ptr) core.new_dump.c_stack;
+ c_size = core.new_dump.c_size;
+ c_stackend = CNEW_STACKORG (core.new_dump) + c_size;
+ c_lsize = CNEW_LSIZE (core.new_dump);
+ c_loader = CNEW_LOADER (core.new_dump);
+ proc64 = CNEW_PROC64 (core.new_dump);
}
else
{
if (proc64)
{
- c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
- c_regptr = &CNEW_CONTEXT64 (core.new);
+ c_regsize = sizeof (CNEW_CONTEXT64 (core.new_dump));
+ c_regptr = &CNEW_CONTEXT64 (core.new_dump);
}
else if (CORE_NEW (core))
{
- c_regsize = sizeof (CNEW_MSTSAVE (core.new));
- c_regptr = &CNEW_MSTSAVE (core.new);
+ c_regsize = sizeof (CNEW_MSTSAVE (core.new_dump));
+ c_regptr = &CNEW_MSTSAVE (core.new_dump);
}
else
{
bfd_get_filename (abfd));
/* Allocate core file header. */
- size = CORE_NEW (core) ? sizeof (core.new) : sizeof (core.old);
+ size = CORE_NEW (core) ? sizeof (core.new_dump) : sizeof (core.old);
tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
if (!tmpptr)
return NULL;
enum bfd_architecture arch;
unsigned long mach;
- switch (CNEW_IMPL (core.new))
+ switch (CNEW_IMPL (core.new_dump))
{
case POWER_RS1:
case POWER_RSC:
if (CORE_NEW (core))
{
- c_datasize = CNEW_DATASIZE (core.new);
- c_data = (file_ptr) core.new.c_data;
- c_vmregions = core.new.c_vmregions;
- c_vmm = (file_ptr) core.new.c_vmm;
+ c_datasize = CNEW_DATASIZE (core.new_dump);
+ c_data = (file_ptr) core.new_dump.c_data;
+ c_vmregions = core.new_dump.c_vmregions;
+ c_vmm = (file_ptr) core.new_dump.c_vmm;
}
else
{
file_ptr vminfo_offset;
bfd_vma vminfo_addr;
- size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
+ size = CORE_NEW (core) ? sizeof (vminfo.new_dump) : sizeof (vminfo.old);
if (bfd_bread (&vminfo, size, abfd) != size)
goto fail;
if (CORE_NEW (core))
{
- vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
- vminfo_size = vminfo.new.vminfo_size;
- vminfo_offset = vminfo.new.vminfo_offset;
+ vminfo_addr = (bfd_vma) vminfo.new_dump.vminfo_addr;
+ vminfo_size = vminfo.new_dump.vminfo_size;
+ vminfo_offset = vminfo.new_dump.vminfo_offset;
}
else
{
return FALSE;
if (CORE_NEW (core))
- c_loader = CNEW_LOADER (core.new);
+ c_loader = CNEW_LOADER (core.new_dump);
else
c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
- if (CORE_NEW (core) && CNEW_PROC64 (core.new))
+ if (CORE_NEW (core) && CNEW_PROC64 (core.new_dump))
size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
else
size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
{
CoreHdr *core = core_hdr (abfd);
char *com = CORE_NEW (*core) ?
- CNEW_COMM (core->new) : COLD_COMM (core->old);
+ CNEW_COMM (core->new_dump) : COLD_COMM (core->old);
if (*com)
return com;
rs6000coff_core_file_failing_signal (bfd *abfd)
{
CoreHdr *core = core_hdr (abfd);
- return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
+ return CORE_NEW (*core) ? core->new_dump.c_signo : core->old.c_signo;
}
#endif /* AIX_CORE */
som_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (som_symbol_type);
- som_symbol_type *new = bfd_zalloc (abfd, amt);
+ som_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
- if (new == NULL)
+ if (new_symbol_type == NULL)
return NULL;
- new->symbol.the_bfd = abfd;
+ new_symbol_type->symbol.the_bfd = abfd;
- return &new->symbol;
+ return &new_symbol_type->symbol;
}
/* Print symbol information. */
_bfd_generic_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (asymbol);
- asymbol *new = bfd_zalloc (abfd, amt);
- if (new)
- new->the_bfd = abfd;
- return new;
+ asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
+ if (new_symbol)
+ new_symbol->the_bfd = abfd;
+ return new_symbol;
}
/*
/* Symbols, add to section. */
{
bfd_size_type amt = sizeof (tekhex_symbol_type);
- tekhex_symbol_type *new = bfd_alloc (abfd, amt);
+ tekhex_symbol_type *new_symbol = (tekhex_symbol_type *)
+ bfd_alloc (abfd, amt);
char stype = (*src);
- if (!new)
+ if (!new_symbol)
return FALSE;
- new->symbol.the_bfd = abfd;
+ new_symbol->symbol.the_bfd = abfd;
src++;
abfd->symcount++;
abfd->flags |= HAS_SYMS;
- new->prev = abfd->tdata.tekhex_data->symbols;
- abfd->tdata.tekhex_data->symbols = new;
+ new_symbol->prev = abfd->tdata.tekhex_data->symbols;
+ abfd->tdata.tekhex_data->symbols = new_symbol;
if (!getsym (sym, &src, &len))
return FALSE;
- new->symbol.name = bfd_alloc (abfd, (bfd_size_type) len + 1);
- if (!new->symbol.name)
+ new_symbol->symbol.name = (const char *)
+ bfd_alloc (abfd, (bfd_size_type) len + 1);
+ if (!new_symbol->symbol.name)
return FALSE;
- memcpy ((char *) (new->symbol.name), sym, len + 1);
- new->symbol.section = section;
+ memcpy ((char *) (new_symbol->symbol.name), sym, len + 1);
+ new_symbol->symbol.section = section;
if (stype <= '4')
- new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
+ new_symbol->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
else
- new->symbol.flags = BSF_LOCAL;
+ new_symbol->symbol.flags = BSF_LOCAL;
if (!getvalue (&src, &val))
return FALSE;
- new->symbol.value = val - section->vma;
+ new_symbol->symbol.value = val - section->vma;
break;
}
default:
tekhex_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
- tekhex_symbol_type *new = bfd_zalloc (abfd, amt);
+ tekhex_symbol_type *new_symbol = (tekhex_symbol_type *) bfd_zalloc (abfd,
+ amt);
- if (!new)
+ if (!new_symbol)
return NULL;
- new->symbol.the_bfd = abfd;
- new->prev = NULL;
- return &(new->symbol);
+ new_symbol->symbol.the_bfd = abfd;
+ new_symbol->prev = NULL;
+ return &(new_symbol->symbol);
}
static void
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * nlmconv.c (main): Rename variable new to new_name.
+
2009-08-28 H.J. Lu <hongjiu.lu@intel.com>
* Makefile.am (sysinfo$(EXEEXT_FOR_BUILD)): Replace
++sym->name;
else
{
- char *new;
+ char *new_name;
- new = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);
- new[0] = outlead;
- strcpy (new + 1, bfd_asymbol_name (sym) + 1);
- sym->name = new;
+ new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);
+ new_name[0] = outlead;
+ strcpy (new_name + 1, bfd_asymbol_name (sym) + 1);
+ sym->name = new_name;
}
}
}
else
{
- char *new;
+ char *new_name;
- new = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);
- new[0] = outlead;
- strcpy (new + 1, bfd_asymbol_name (sym));
- sym->name = new;
+ new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);
+ new_name[0] = outlead;
+ strcpy (new_name + 1, bfd_asymbol_name (sym));
+ sym->name = new_name;
}
}
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * config/tc-arm.c (struct asm_cond, struct asm_psr, struct
+ asm_barrier_opt): Change member template to
+ template_name. (md_begin): Update code to reflect new member
+ names.
+ * config/tc-i386.c (struct templates, struct _i386_insn)
+ (match_template, cpu_flags_match, match_reg_size, match_mem_size)
+ (operand_size_match, md_begin, i386_print_statistics, pi)
+ (build_vex_prefix, md_assemble, parse_insn, optimize_imm)
+ (optimize_disp): Updated code to use new names. (parse_insn):
+ Added casts.
+ * config/tc-ia64.c (dot_template, emit_one_bundle): Updated
+ code to use new names.
+ * config/tc-score.c (struct s3_asm_opcode): Renamed member
+ template to template_name. (s3_parse_16_32_inst, s3_parse_48_inst,
+ s3_do_macro_ldst_label, s3_build_score_ops_hsh): Update code to
+ use new names.
+ * config/tc-score7.c (struct s7_asm_opcode): Renamed member
+ template to template_name. (s7_parse_16_32_inst,
+ s7_do_macro_ldst_label, s7_build_score_ops_hsh): Update code to
+ use new names.
+ * config/tc-tic30.c (md_begin, struct tic30_insn)
+ (md_assemble): Update code to use new names.
+ * config/tc-tic54x.c (struct _tic54x_insn, md_begin)
+ (optimize_insn, tic54x_parse_insn, next_line_shows_parallel):
+ Update code to use new names.
+ * config/tc-arm.c (insert_reg_alias): Rename variable new to
+ new_reg.
+ * config/tc-dlx.c (parse_operand): Rename variable new to
+ new_pos.
+ * config/tc-ia64.c (ia64_gen_real_reloc_type): Rename variable
+ new to newr.
+ * config/tc-mcore.c (parse_exp, parse_imm): Rename variable
+ new to new_pointer.
+ * config/tc-microblaze.c (parse_exp, parse_imm, check_got):
+ Change name from new to new_pointer.
+ * config/tc-or32.c (parse_operand): Rename variable new to
+ new_pointer.
+ * config/tc-pdp11.c (md_assemble): Rename variable new to
+ new_pointer.
+ * config/tc-pj.c (alias): Change argument new to new_name.
+ * config/tc-score.c (s3_build_score_ops_hsh): Rename variable
+ new to new_opcode. (s3_build_dependency_insn_hsh) Rename variable
+ new to new_i2n. (s3_convert): Rename variables old and new to
+ r_old and r_new.
+ * config/tc-score7.c (s7_build_score_ops_hsh): Rename variable
+ new to new_opcode. (s7_build_dependency_insn_hsh): Rename variable
+ new to new_i2d. (s7_b32_relax_to_b16, s7_convert_frag): Rename
+ variables old and new to r_old and r_new.
+ * config/tc-sh.c (parse_exp): Rename variable new to
+ new_pointer.
+ * config/tc-sh64.c (shmedia_parse_exp): Rename variable new to
+ new_pointer.
+ * config/tc-tic4x.c (tic4x_operand_parse): Rename variable new
+ to new_pointer.
+ * config/tc-z8k.c (parse_exp): Rename variable new to
+ new_pointer.
+ * listing.c (listing_newline): Rename variable new to new_i.
+
2009-08-29 Matt Fleming <matt@console-pimps.org>
* config/tc-sh.c (md_apply_fix): Extend sign of the offset value
}
else if (strcmp (typename, "gnu_unique_object") == 0)
{
- const struct elf_backend_data *bed;
+ struct elf_backend_data *bed;
- bed = get_elf_backend_data (stdoutput);
+ bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput);
if (!(bed->elf_osabi == ELFOSABI_LINUX
/* GNU/Linux is still using the default value 0. */
|| bed->elf_osabi == ELFOSABI_NONE))
as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
typename);
type = BSF_OBJECT | BSF_GNU_UNIQUE;
+ /* PR 10549: Always set OSABI field to LINUX for objects containing unique symbols. */
+ bed->elf_osabi = ELFOSABI_LINUX;
}
#ifdef md_elf_symbol_type
else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1)
struct asm_cond
{
- const char * template;
+ const char * template_name;
unsigned long value;
};
struct asm_psr
{
- const char * template;
+ const char * template_name;
unsigned long field;
};
struct asm_barrier_opt
{
- const char * template;
+ const char * template_name;
unsigned long value;
};
struct asm_opcode
{
/* Basic string to match. */
- const char * template;
+ const char * template_name;
/* Parameters to instruction. */
unsigned char operands[8];
static struct reg_entry *
insert_reg_alias (char *str, int number, int type)
{
- struct reg_entry *new;
+ struct reg_entry *new_reg;
const char *name;
- if ((new = hash_find (arm_reg_hsh, str)) != 0)
+ if ((new_reg = (struct reg_entry *) hash_find (arm_reg_hsh, str)) != 0)
{
- if (new->builtin)
+ if (new_reg->builtin)
as_warn (_("ignoring attempt to redefine built-in register '%s'"), str);
/* Only warn about a redefinition if it's not defined as the
same register. */
- else if (new->number != number || new->type != type)
+ else if (new_reg->number != number || new_reg->type != type)
as_warn (_("ignoring redefinition of register alias '%s'"), str);
return NULL;
}
name = xstrdup (str);
- new = xmalloc (sizeof (struct reg_entry));
+ new_reg = (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
- new->name = name;
- new->number = number;
- new->type = type;
- new->builtin = FALSE;
- new->neon = NULL;
+ new_reg->name = name;
+ new_reg->number = number;
+ new_reg->type = type;
+ new_reg->builtin = FALSE;
+ new_reg->neon = NULL;
- if (hash_insert (arm_reg_hsh, name, (void *) new))
+ if (hash_insert (arm_reg_hsh, name, (void *) new_reg))
abort ();
- return new;
+ return new_reg;
}
static void
as_fatal (_("virtual memory exhausted"));
for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
- hash_insert (arm_ops_hsh, insns[i].template, (void *) (insns + i));
+ hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i));
for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
- hash_insert (arm_cond_hsh, conds[i].template, (void *) (conds + i));
+ hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i));
for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i));
for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
- hash_insert (arm_psr_hsh, psrs[i].template, (void *) (psrs + i));
+ hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i));
for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++)
- hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template, (void *) (v7m_psrs + i));
+ hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name,
+ (void *) (v7m_psrs + i));
for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++)
hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i));
for (i = 0;
i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt);
i++)
- hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template,
+ hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name,
(void *) (barrier_opt_names + i));
#ifdef OBJ_ELF
for (i = 0; i < sizeof (reloc_names) / sizeof (struct reloc_entry); i++)
parse_operand (char *s, expressionS *operandp)
{
char *save = input_line_pointer;
- char *new;
+ char *new_pos;
the_insn.HI = the_insn.LO = 0;
(void) expression (operandp);
}
- new = input_line_pointer;
+ new_pos = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pos;
}
/* Instruction parsing. Takes a string containing the opcode.
*/
typedef struct
{
- const template *start;
- const template *end;
+ const insn_template *start;
+ const insn_template *end;
}
templates;
static void swap_2_operands (int, int);
static void optimize_imm (void);
static void optimize_disp (void);
-static const template *match_template (void);
+static const insn_template *match_template (void);
static int check_string (void);
static int process_suffix (void);
static int check_byte_reg (void);
struct _i386_insn
{
/* TM holds the template for the insn were currently assembling. */
- template tm;
+ insn_template tm;
/* SUFFIX holds the instruction size suffix for byte, word, dword
or qword, if given. */
/* Return CPU flags match bits. */
static int
-cpu_flags_match (const template *t)
+cpu_flags_match (const insn_template *t)
{
i386_cpu_flags x = t->cpu_flags;
int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
operand J for instruction template T. */
static INLINE int
-match_reg_size (const template *t, unsigned int j)
+match_reg_size (const insn_template *t, unsigned int j)
{
return !((i.types[j].bitfield.byte
&& !t->operand_types[j].bitfield.byte)
instruction template T. */
static INLINE int
-match_mem_size (const template *t, unsigned int j)
+match_mem_size (const insn_template *t, unsigned int j)
{
return (match_reg_size (t, j)
&& !((i.types[j].bitfield.unspecified
instruction template T. */
static INLINE int
-operand_size_match (const template *t)
+operand_size_match (const insn_template *t)
{
unsigned int j;
int match = 1;
op_hash = hash_new ();
{
- const template *optab;
+ const insn_template *optab;
templates *core_optab;
/* Setup for loop. */
#ifdef DEBUG386
/* Debugging routines for md_assemble. */
-static void pte (template *);
+static void pte (insn_template *);
static void pt (i386_operand_type);
static void pe (expressionS *);
static void ps (symbolS *);
}
static void
-pte (template *t)
+pte (insn_template *t)
{
unsigned int i;
fprintf (stdout, " %d operands ", t->operands);
/* Build the VEX prefix. */
static void
-build_vex_prefix (const template *t)
+build_vex_prefix (const insn_template *t)
{
unsigned int register_specifier;
unsigned int implied_prefix;
{
unsigned int j;
char mnemonic[MAX_MNEM_SIZE];
- const template *t;
+ const insn_template *t;
/* Initialize globals. */
memset (&i, '\0', sizeof (i));
char *token_start = l;
char *mnem_p;
int supported;
- const template *t;
+ const insn_template *t;
char *dot_p = NULL;
/* Non-zero if we found a prefix only acceptable with string insns. */
}
/* Look up instruction (or prefix) via hash table. */
- current_templates = hash_find (op_hash, mnemonic);
+ current_templates = (const templates *) hash_find (op_hash, mnemonic);
if (*l != END_OF_INSN
&& (!is_space_char (*l) || l[1] != END_OF_INSN)
goto check_suffix;
mnem_p = dot_p;
*dot_p = '\0';
- current_templates = hash_find (op_hash, mnemonic);
+ current_templates = (const templates *) hash_find (op_hash, mnemonic);
}
if (!current_templates)
case QWORD_MNEM_SUFFIX:
i.suffix = mnem_p[-1];
mnem_p[-1] = '\0';
- current_templates = hash_find (op_hash, mnemonic);
+ current_templates = (const templates *) hash_find (op_hash,
+ mnemonic);
break;
case SHORT_MNEM_SUFFIX:
case LONG_MNEM_SUFFIX:
{
i.suffix = mnem_p[-1];
mnem_p[-1] = '\0';
- current_templates = hash_find (op_hash, mnemonic);
+ current_templates = (const templates *) hash_find (op_hash,
+ mnemonic);
}
break;
else
i.suffix = LONG_MNEM_SUFFIX;
mnem_p[-1] = '\0';
- current_templates = hash_find (op_hash, mnemonic);
+ current_templates = (const templates *) hash_find (op_hash,
+ mnemonic);
}
break;
}
than those matching the insn suffix. */
{
i386_operand_type mask, allowed;
- const template *t;
+ const insn_template *t;
operand_type_set (&mask, 0);
operand_type_set (&allowed, 0);
}
}
-static const template *
+static const insn_template *
match_template (void)
{
/* Points to template once we've found it. */
- const template *t;
+ const insn_template *t;
i386_operand_type overlap0, overlap1, overlap2, overlap3;
i386_operand_type overlap4;
unsigned int found_reverse_match;
}
static void
-dot_template (int template)
+dot_template (int template_val)
{
- CURR_SLOT.user_template = template;
+ CURR_SLOT.user_template = template_val;
}
static void
int manual_bundling_off = 0, manual_bundling = 0;
enum ia64_unit required_unit, insn_unit = 0;
enum ia64_insn_type type[3], insn_type;
- unsigned int template, orig_template;
+ unsigned int template_val, orig_template;
bfd_vma insn[3] = { -1, -1, -1 };
struct ia64_opcode *idesc;
int end_of_insn_group = 0, user_template = -1;
otherwise: */
if (md.slot[first].user_template >= 0)
- user_template = template = md.slot[first].user_template;
+ user_template = template_val = md.slot[first].user_template;
else
{
/* Auto select appropriate template. */
type[i] = md.slot[curr].idesc->type;
curr = (curr + 1) % NUM_SLOTS;
}
- template = best_template[type[0]][type[1]][type[2]];
+ template_val = best_template[type[0]][type[1]][type[2]];
}
/* initialize instructions with appropriate nops: */
for (i = 0; i < 3; ++i)
- insn[i] = nop[ia64_templ_desc[template].exec_unit[i]];
+ insn[i] = nop[ia64_templ_desc[template_val].exec_unit[i]];
f = frag_more (16);
MBB, BBB, MMB, and MFB. We don't handle anything other
than M and B slots because these are the only kind of
instructions that can have the IA64_OPCODE_LAST bit set. */
- required_template = template;
+ required_template = template_val;
switch (idesc->type)
{
case IA64_TYPE_M:
|| (required_slot == 2 && !manual_bundling_off)
|| (user_template >= 0
/* Changing from MMI to M;MI is OK. */
- && (template ^ required_template) > 1)))
+ && (template_val ^ required_template) > 1)))
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' must be last in instruction group"),
break;
i = required_slot;
- if (required_template != template)
+ if (required_template != template_val)
{
/* If we switch the template, we need to reset the NOPs
after slot i. The slot-types of the instructions ahead
middle, so we don't need another one emitted later. */
md.slot[curr].end_of_insn_group = 0;
}
- template = required_template;
+ template_val = required_template;
}
if (curr != first && md.slot[curr].label_fixups)
{
bundle. See if we can switch to an other template with
an appropriate boundary. */
- orig_template = template;
+ orig_template = template_val;
if (i == 1 && (user_template == 4
|| (user_template < 0
- && (ia64_templ_desc[template].exec_unit[0]
+ && (ia64_templ_desc[template_val].exec_unit[0]
== IA64_UNIT_M))))
{
- template = 5;
+ template_val = 5;
end_of_insn_group = 0;
}
else if (i == 2 && (user_template == 0
|| (user_template < 0
- && (ia64_templ_desc[template].exec_unit[1]
+ && (ia64_templ_desc[template_val].exec_unit[1]
== IA64_UNIT_I)))
/* This test makes sure we don't switch the template if
the next instruction is one that needs to be first in
first in the group! --davidm 99/12/16 */
&& (idesc->flags & IA64_OPCODE_FIRST) == 0)
{
- template = 1;
+ template_val = 1;
end_of_insn_group = 0;
}
else if (i == 1
/* can't fit this insn */
break;
- if (template != orig_template)
+ if (template_val != orig_template)
/* if we switch the template, we need to reset the NOPs
after slot i. The slot-types of the instructions ahead
of i never change, so we don't need to worry about
changing NOPs in front of this slot. */
for (j = i; j < 3; ++j)
- insn[j] = nop[ia64_templ_desc[template].exec_unit[j]];
+ insn[j] = nop[ia64_templ_desc[template_val].exec_unit[j]];
}
- required_unit = ia64_templ_desc[template].exec_unit[i];
+ required_unit = ia64_templ_desc[template_val].exec_unit[i];
/* resolve dynamic opcodes such as "break", "hint", and "nop": */
if (idesc->type == IA64_TYPE_DYN)
{
insn_unit = IA64_UNIT_M;
if (required_unit == IA64_UNIT_I
- || (required_unit == IA64_UNIT_F && template == 6))
+ || (required_unit == IA64_UNIT_F && template_val == 6))
insn_unit = IA64_UNIT_I;
}
else
{
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' does not fit into %s template"),
- idesc->name, ia64_templ_desc[template].name);
+ idesc->name, ia64_templ_desc[template_val].name);
/* Drop first insn so we don't livelock. */
--md.num_slots_in_use;
know (curr == first);
{
const char *where;
- if (template == 2)
+ if (template_val == 2)
where = "X slot";
else if (last_slot == 0)
where = "slots 2 or 3";
where = "slot 3";
as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
_("`%s' can't go in %s of %s template"),
- idesc->name, where, ia64_templ_desc[template].name);
+ idesc->name, where, ia64_templ_desc[template_val].name);
}
}
else
know (md.num_slots_in_use < NUM_SLOTS);
- t0 = end_of_insn_group | (template << 1) | (insn[0] << 5) | (insn[1] << 46);
+ t0 = end_of_insn_group | (template_val << 1) | (insn[0] << 5) | (insn[1] << 46);
t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
number_to_chars_littleendian (f + 0, t0, 8);
static bfd_reloc_code_real_type
ia64_gen_real_reloc_type (struct symbol *sym, bfd_reloc_code_real_type r_type)
{
- bfd_reloc_code_real_type new = 0;
+ bfd_reloc_code_real_type newr = 0;
const char *type = NULL, *suffix = "";
if (sym == NULL)
case FUNC_FPTR_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_FPTR64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_FPTR32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_FPTR32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_FPTR64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_FPTR64LSB; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_FPTR64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_FPTR32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_FPTR32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_FPTR64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_FPTR64LSB; break;
default: type = "FPTR"; break;
}
break;
case FUNC_GP_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_GPREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_GPREL64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_GPREL32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_GPREL32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_GPREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_GPREL64LSB; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_GPREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_GPREL64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_GPREL32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_GPREL32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_GPREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_GPREL64LSB; break;
default: type = "GPREL"; break;
}
break;
case FUNC_LT_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_LTOFF64I; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_LTOFF64I; break;
default: type = "LTOFF"; break;
}
break;
case FUNC_LT_RELATIVE_X:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_LTOFF22X; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_LTOFF22X; break;
default: type = "LTOFF"; suffix = "X"; break;
}
break;
case FUNC_PC_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PCREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PCREL64I; break;
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_PCREL32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_PCREL32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PCREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PCREL64LSB; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PCREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PCREL64I; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_PCREL32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_PCREL32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PCREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PCREL64LSB; break;
default: type = "PCREL"; break;
}
break;
case FUNC_PLT_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_PLTOFF22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_PLTOFF64I; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_PLTOFF64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_PLTOFF64LSB;break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_PLTOFF22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_PLTOFF64I; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_PLTOFF64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_PLTOFF64LSB;break;
default: type = "PLTOFF"; break;
}
break;
case FUNC_SEC_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SECREL32MSB;break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SECREL32LSB;break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SECREL64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SECREL64LSB;break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SECREL32MSB;break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SECREL32LSB;break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SECREL64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SECREL64LSB;break;
default: type = "SECREL"; break;
}
break;
case FUNC_SEG_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_SEGREL32MSB;break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_SEGREL32LSB;break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_SEGREL64MSB;break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_SEGREL64LSB;break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_SEGREL32MSB;break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_SEGREL32LSB;break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_SEGREL64MSB;break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_SEGREL64LSB;break;
default: type = "SEGREL"; break;
}
break;
case FUNC_LTV_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_DIR32MSB: new = BFD_RELOC_IA64_LTV32MSB; break;
- case BFD_RELOC_IA64_DIR32LSB: new = BFD_RELOC_IA64_LTV32LSB; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_LTV64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_LTV64LSB; break;
+ case BFD_RELOC_IA64_DIR32MSB: newr = BFD_RELOC_IA64_LTV32MSB; break;
+ case BFD_RELOC_IA64_DIR32LSB: newr = BFD_RELOC_IA64_LTV32LSB; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_LTV64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_LTV64LSB; break;
default: type = "LTV"; break;
}
break;
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_FPTR22; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR22; break;
case BFD_RELOC_IA64_IMM64:
- new = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
case BFD_RELOC_IA64_DIR32MSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
case BFD_RELOC_IA64_DIR32LSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
+ newr = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
default:
type = "LTOFF_FPTR"; break;
}
case FUNC_TP_RELATIVE:
switch (r_type)
{
- case BFD_RELOC_IA64_IMM14: new = BFD_RELOC_IA64_TPREL14; break;
- case BFD_RELOC_IA64_IMM22: new = BFD_RELOC_IA64_TPREL22; break;
- case BFD_RELOC_IA64_IMM64: new = BFD_RELOC_IA64_TPREL64I; break;
- case BFD_RELOC_IA64_DIR64MSB: new = BFD_RELOC_IA64_TPREL64MSB; break;
- case BFD_RELOC_IA64_DIR64LSB: new = BFD_RELOC_IA64_TPREL64LSB; break;
+ case BFD_RELOC_IA64_IMM14: newr = BFD_RELOC_IA64_TPREL14; break;
+ case BFD_RELOC_IA64_IMM22: newr = BFD_RELOC_IA64_TPREL22; break;
+ case BFD_RELOC_IA64_IMM64: newr = BFD_RELOC_IA64_TPREL64I; break;
+ case BFD_RELOC_IA64_DIR64MSB: newr = BFD_RELOC_IA64_TPREL64MSB; break;
+ case BFD_RELOC_IA64_DIR64LSB: newr = BFD_RELOC_IA64_TPREL64LSB; break;
default: type = "TPREL"; break;
}
break;
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_TPREL22; break;
+ newr = BFD_RELOC_IA64_LTOFF_TPREL22; break;
default:
type = "LTOFF_TPREL"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_DTPMOD64MSB; break;
+ newr = BFD_RELOC_IA64_DTPMOD64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_DTPMOD64LSB; break;
+ newr = BFD_RELOC_IA64_DTPMOD64LSB; break;
default:
type = "DTPMOD"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
+ newr = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
default:
type = "LTOFF_DTPMOD"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_DIR32MSB:
- new = BFD_RELOC_IA64_DTPREL32MSB; break;
+ newr = BFD_RELOC_IA64_DTPREL32MSB; break;
case BFD_RELOC_IA64_DIR32LSB:
- new = BFD_RELOC_IA64_DTPREL32LSB; break;
+ newr = BFD_RELOC_IA64_DTPREL32LSB; break;
case BFD_RELOC_IA64_DIR64MSB:
- new = BFD_RELOC_IA64_DTPREL64MSB; break;
+ newr = BFD_RELOC_IA64_DTPREL64MSB; break;
case BFD_RELOC_IA64_DIR64LSB:
- new = BFD_RELOC_IA64_DTPREL64LSB; break;
+ newr = BFD_RELOC_IA64_DTPREL64LSB; break;
case BFD_RELOC_IA64_IMM14:
- new = BFD_RELOC_IA64_DTPREL14; break;
+ newr = BFD_RELOC_IA64_DTPREL14; break;
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_DTPREL22; break;
+ newr = BFD_RELOC_IA64_DTPREL22; break;
case BFD_RELOC_IA64_IMM64:
- new = BFD_RELOC_IA64_DTPREL64I; break;
+ newr = BFD_RELOC_IA64_DTPREL64I; break;
default:
type = "DTPREL"; break;
}
switch (r_type)
{
case BFD_RELOC_IA64_IMM22:
- new = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
+ newr = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
default:
type = "LTOFF_DTPREL"; break;
}
abort ();
}
- if (new)
- return new;
+ if (newr)
+ return newr;
else
{
int width;
parse_exp (char * s, expressionS * e)
{
char * save;
- char * new;
+ char * new_pointer;
/* Skip whitespace. */
while (ISSPACE (* s))
if (e->X_op == O_absent)
as_bad (_("missing operand"));
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
static int
unsigned min,
unsigned max)
{
- char * new;
+ char * new_pointer;
expressionS e;
- new = parse_exp (s, & e);
+ new_pointer = parse_exp (s, & e);
if (e.X_op == O_absent)
; /* An error message has already been emitted. */
* val = e.X_add_number;
- return new;
+ return new_pointer;
}
static char *
parse_exp (char *s, expressionS *e)
{
char *save;
- char *new;
+ char *new_pointer;
/* Skip whitespace. */
while (ISSPACE (* s))
if (e->X_op == O_absent)
as_fatal (_("missing operand"));
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
/* Symbol modifiers (@GOT, @PLT, @GOTOFF). */
static char *
parse_imm (char * s, expressionS * e, int min, int max)
{
- char *new;
+ char *new_pointer;
char *atp;
/* Find the start of "@GOT" or "@PLT" suffix (if any) */
GOT_symbol = symbol_find_or_make (GOT_SYMBOL_NAME);
}
- new = parse_exp (s, e);
+ new_pointer = parse_exp (s, e);
if (e->X_op == O_absent)
; /* An error message has already been emitted. */
if (atp)
{
*atp = '@'; /* restore back (needed?) */
- if (new >= atp)
- new += (e->X_md == IMM_GOTOFF)?7:4;
+ if (new_pointer >= atp)
+ new_pointer += (e->X_md == IMM_GOTOFF)?7:4;
/* sizeof("@GOTOFF", "@GOT" or "@PLT") */
}
- return new;
+ return new_pointer;
}
static char *
check_got (int * got_type, int * got_len)
{
- char *new;
+ char *new_pointer;
char *atp;
char *past_got;
int first, second;
first = atp - input_line_pointer;
past_got = atp + *got_len + 1;
- for (new = past_got; !is_end_of_line[(unsigned char) *new++]; )
+ for (new_pointer = past_got; !is_end_of_line[(unsigned char) *new_pointer++];)
;
- second = new - past_got;
+ second = new_pointer - past_got;
tmpbuf = xmalloc (first + second + 2); /* One extra byte for ' ' and one for NUL. */
memcpy (tmpbuf, input_line_pointer, first);
tmpbuf[first] = ' '; /* @GOTOFF is replaced with a single space. */
parse_operand (char *s, expressionS *operandp, int opt)
{
char *save = input_line_pointer;
- char *new;
+ char *new_pointer;
#if DEBUG
printf (" PROCESS NEW OPERAND(%s) == %c (%d)\n", s, opt ? opt : '!', opt);
}
}
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
#if DEBUG
- printf (" %s=parse_operand(%s): operandp->X_op = %u\n", new, s, operandp->X_op);
+ printf (" %s=parse_operand(%s): operandp->X_op = %u\n", new_pointer, s,
+ operandp->X_op);
#endif
- return new;
+ return new_pointer;
}
/* Instruction parsing. Takes a string containing the opcode.
case PDP11_OPCODE_DISPL:
{
- char *new;
- new = parse_expression (str, &op1);
+ char *new_pointer;
+ new_pointer = parse_expression (str, &op1);
op1.code = 0;
op1.reloc.pc_rel = 1;
op1.reloc.type = BFD_RELOC_PDP11_DISP_8_PCREL;
err = _("8-bit displacement out of range");
break;
}
- str = new;
+ str = new_pointer;
insn.code |= op1.code;
insn.reloc = op1.reloc;
}
case PDP11_OPCODE_REG_DISPL:
{
- char *new;
+ char *new_pointer;
str = parse_reg (str, &op2);
if (op2.error)
break;
op1.error = _("Missing ','");
break;
}
- new = parse_expression (str, &op1);
+ new_pointer = parse_expression (str, &op1);
op1.code = 0;
op1.reloc.pc_rel = 1;
op1.reloc.type = BFD_RELOC_PDP11_DISP_6_PCREL;
err = _("6-bit displacement out of range");
break;
}
- str = new;
+ str = new_pointer;
insn.code |= op1.code;
insn.reloc = op1.reloc;
}
can have another name. */
static void
-alias (const char *new, const char *old)
+alias (const char *new_name, const char *old)
{
- hash_insert (opcode_hash_control, new,
+ hash_insert (opcode_hash_control, new_name,
(char *) hash_find (opcode_hash_control, old));
}
struct s3_asm_opcode
{
/* Instruction name. */
- const char *template;
+ const char *template_name;
/* Instruction Opcode. */
bfd_vma value;
s3_inst.size = s3_GET_INSN_SIZE (s3_inst.type);
s3_inst.relax_size = 0;
s3_inst.bwarn = 0;
- sprintf (s3_inst.name, "%s", opcode->template);
+ sprintf (s3_inst.name, "%s", opcode->template_name);
strcpy (s3_inst.reg, "");
s3_inst.error = NULL;
s3_inst.reloc.type = BFD_RELOC_NONE;
s3_inst.size = s3_GET_INSN_SIZE (s3_inst.type);
s3_inst.relax_size = 0;
s3_inst.bwarn = 0;
- sprintf (s3_inst.name, "%s", opcode->template);
+ sprintf (s3_inst.name, "%s", opcode->template_name);
strcpy (s3_inst.reg, "");
s3_inst.error = NULL;
s3_inst.reloc.type = BFD_RELOC_NONE;
{
int ldst_idx = 0;
ldst_idx = s3_inst.instruction & OPC_PSEUDOLDST_MASK;
- s3_build_lwst_pic (reg_rd, s3_inst.reloc.exp, s3_score_ldst_insns[ldst_idx * 3 + 0].template);
+ s3_build_lwst_pic (reg_rd, s3_inst.reloc.exp,
+ s3_score_ldst_insns[ldst_idx * 3 + 0].template_name);
return;
}
else
for (i = 0; i < sizeof (s3_score_insns) / sizeof (struct s3_asm_opcode); i++)
{
const struct s3_asm_opcode *insn = s3_score_insns + i;
- unsigned len = strlen (insn->template);
- struct s3_asm_opcode *new;
- char *template;
- new = obstack_alloc (&insn_obstack, sizeof (struct s3_asm_opcode));
- template = obstack_alloc (&insn_obstack, len + 1);
+ unsigned len = strlen (insn->template_name);
+ struct s3_asm_opcode *new_opcode;
+ char *template_name;
+ new_opcode = (struct s3_asm_opcode *)
+ obstack_alloc (&insn_obstack, sizeof (struct s3_asm_opcode));
+ template_name = (char *) obstack_alloc (& insn_obstack, len + 1);
- strcpy (template, insn->template);
- new->template = template;
- new->parms = insn->parms;
- new->value = insn->value;
- new->relax_value = insn->relax_value;
- new->type = insn->type;
- new->bitmask = insn->bitmask;
- hash_insert (s3_score_ops_hsh, new->template, (void *) new);
+ strcpy (template_name, insn->template_name);
+ new_opcode->template_name = template_name;
+ new_opcode->parms = insn->parms;
+ new_opcode->value = insn->value;
+ new_opcode->relax_value = insn->relax_value;
+ new_opcode->type = insn->type;
+ new_opcode->bitmask = insn->bitmask;
+ hash_insert (s3_score_ops_hsh, new_opcode->template_name,
+ (void *) new_opcode);
}
}
{
const struct s3_insn_to_dependency *tmp = s3_insn_to_dependency_table + i;
unsigned len = strlen (tmp->insn_name);
- struct s3_insn_to_dependency *new;
+ struct s3_insn_to_dependency *new_i2n;
- new = obstack_alloc (&dependency_obstack, sizeof (struct s3_insn_to_dependency));
- new->insn_name = obstack_alloc (&dependency_obstack, len + 1);
+ new_i2n = (struct s3_insn_to_dependency *)
+ obstack_alloc (&dependency_obstack,
+ sizeof (struct s3_insn_to_dependency));
+ new_i2n->insn_name = (char *) obstack_alloc (&dependency_obstack,
+ len + 1);
- strcpy (new->insn_name, tmp->insn_name);
- new->type = tmp->type;
- hash_insert (s3_dependency_insn_hsh, new->insn_name, (void *) new);
+ strcpy (new_i2n->insn_name, tmp->insn_name);
+ new_i2n->type = tmp->type;
+ hash_insert (s3_dependency_insn_hsh, new_i2n->insn_name,
+ (void *) new_i2n);
}
}
static void
s3_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, fragS * fragp)
{
- int old;
- int new;
+ int r_old;
+ int r_new;
char backup[20];
fixS *fixp;
- old = s3_RELAX_OLD (fragp->fr_subtype);
- new = s3_RELAX_NEW (fragp->fr_subtype);
+ r_old = s3_RELAX_OLD (fragp->fr_subtype);
+ r_new = s3_RELAX_NEW (fragp->fr_subtype);
/* fragp->fr_opcode indicates whether this frag should be relaxed. */
if (fragp->fr_opcode == NULL)
{
- memcpy (backup, fragp->fr_literal, old);
- fragp->fr_fix = old;
+ memcpy (backup, fragp->fr_literal, r_old);
+ fragp->fr_fix = r_old;
}
else
{
- memcpy (backup, fragp->fr_literal + old, new);
- fragp->fr_fix = new;
+ memcpy (backup, fragp->fr_literal + r_old, r_new);
+ fragp->fr_fix = r_new;
}
fixp = fragp->tc_frag_data.fixp;
- while (fixp && fixp->fx_frag == fragp && fixp->fx_where < old)
+ while (fixp && fixp->fx_frag == fragp && fixp->fx_where < r_old)
{
if (fragp->fr_opcode)
fixp->fx_done = 1;
while (fixp && fixp->fx_frag == fragp)
{
if (fragp->fr_opcode)
- fixp->fx_where -= old + fragp->insn_addr;
+ fixp->fx_where -= r_old + fragp->insn_addr;
else
fixp->fx_done = 1;
fixp = fixp->fx_next;
struct s7_asm_opcode
{
/* Instruction name. */
- const char *template;
+ const char *template_name;
/* Instruction Opcode. */
bfd_vma value;
s7_inst.size = s7_GET_INSN_SIZE (s7_inst.type);
s7_inst.relax_size = 0;
s7_inst.bwarn = 0;
- sprintf (s7_inst.name, "%s", opcode->template);
+ sprintf (s7_inst.name, "%s", opcode->template_name);
strcpy (s7_inst.reg, "");
s7_inst.error = NULL;
s7_inst.reloc.type = BFD_RELOC_NONE;
{
int ldst_idx = 0;
ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
- s7_build_lwst_pic (reg_rd, s7_inst.reloc.exp, s7_score_ldst_insns[ldst_idx * 3 + 0].template);
+ s7_build_lwst_pic (reg_rd, s7_inst.reloc.exp,
+ s7_score_ldst_insns[ldst_idx * 3 + 0].template_name);
return;
}
else
for (i = 0; i < sizeof (s7_score_insns) / sizeof (struct s7_asm_opcode); i++)
{
const struct s7_asm_opcode *insn = s7_score_insns + i;
- unsigned len = strlen (insn->template);
- struct s7_asm_opcode *new;
- char *template;
- new = obstack_alloc (&insn_obstack, sizeof (struct s7_asm_opcode));
- template = obstack_alloc (&insn_obstack, len + 1);
-
- strcpy (template, insn->template);
- new->template = template;
- new->parms = insn->parms;
- new->value = insn->value;
- new->relax_value = insn->relax_value;
- new->type = insn->type;
- new->bitmask = insn->bitmask;
- hash_insert (s7_score_ops_hsh, new->template, (void *) new);
+ unsigned len = strlen (insn->template_name);
+ struct s7_asm_opcode *new_opcode;
+ char *template_name;
+ new_opcode = (struct s7_asm_opcode *)
+ obstack_alloc (&insn_obstack, sizeof (struct s7_asm_opcode));
+ template_name = (char *) obstack_alloc (&insn_obstack, len + 1);
+
+ strcpy (template_name, insn->template_name);
+ new_opcode->template_name = template_name;
+ new_opcode->parms = insn->parms;
+ new_opcode->value = insn->value;
+ new_opcode->relax_value = insn->relax_value;
+ new_opcode->type = insn->type;
+ new_opcode->bitmask = insn->bitmask;
+ hash_insert (s7_score_ops_hsh, new_opcode->template_name,
+ (void *) new_opcode);
}
}
{
const struct s7_insn_to_dependency *tmp = s7_insn_to_dependency_table + i;
unsigned len = strlen (tmp->insn_name);
- struct s7_insn_to_dependency *new;
+ struct s7_insn_to_dependency *new_i2d;
- new = obstack_alloc (&dependency_obstack, sizeof (struct s7_insn_to_dependency));
- new->insn_name = obstack_alloc (&dependency_obstack, len + 1);
+ new_i2d = (struct s7_insn_to_dependency *)
+ obstack_alloc (&dependency_obstack,
+ sizeof (struct s7_insn_to_dependency));
+ new_i2d->insn_name = (char *) obstack_alloc (&dependency_obstack,
+ len + 1);
- strcpy (new->insn_name, tmp->insn_name);
- new->type = tmp->type;
- hash_insert (s7_dependency_insn_hsh, new->insn_name, (void *) new);
+ strcpy (new_i2d->insn_name, tmp->insn_name);
+ new_i2d->type = tmp->type;
+ hash_insert (s7_dependency_insn_hsh, new_i2d->insn_name,
+ (void *) new_i2d);
}
}
{
int grows = 0;
int relaxable_p = 0;
- int old;
- int new;
+ int r_old;
+ int r_new;
int frag_addr = fragp->fr_address + fragp->insn_addr;
addressT symbol_address = 0;
so in relax stage , it may be wrong to calculate the symbol's offset when the frag's section
is different from the symbol's. */
- old = s7_RELAX_OLD (fragp->fr_subtype);
- new = s7_RELAX_NEW (fragp->fr_subtype);
+ r_old = s7_RELAX_OLD (fragp->fr_subtype);
+ r_new = s7_RELAX_NEW (fragp->fr_subtype);
relaxable_p = s7_RELAX_OPT (fragp->fr_subtype);
s = fragp->fr_symbol;
segT sec ATTRIBUTE_UNUSED,
fragS * fragp)
{
- int old;
- int new;
+ int r_old;
+ int r_new;
char backup[20];
fixS *fixp;
- old = s7_RELAX_OLD (fragp->fr_subtype);
- new = s7_RELAX_NEW (fragp->fr_subtype);
+ r_old = s7_RELAX_OLD (fragp->fr_subtype);
+ r_new = s7_RELAX_NEW (fragp->fr_subtype);
/* fragp->fr_opcode indicates whether this frag should be relaxed. */
if (fragp->fr_opcode == NULL)
{
- memcpy (backup, fragp->fr_literal, old);
- fragp->fr_fix = old;
+ memcpy (backup, fragp->fr_literal, r_old);
+ fragp->fr_fix = r_old;
}
else
{
- memcpy (backup, fragp->fr_literal + old, new);
- fragp->fr_fix = new;
+ memcpy (backup, fragp->fr_literal + r_old, r_new);
+ fragp->fr_fix = r_new;
}
fixp = fragp->tc_frag_data.fixp;
- while (fixp && fixp->fx_frag == fragp && fixp->fx_where < old)
+ while (fixp && fixp->fx_frag == fragp && fixp->fx_where < r_old)
{
if (fragp->fr_opcode)
fixp->fx_done = 1;
while (fixp && fixp->fx_frag == fragp)
{
if (fragp->fr_opcode)
- fixp->fx_where -= old + fragp->insn_addr;
+ fixp->fx_where -= r_old + fragp->insn_addr;
else
fixp->fx_done = 1;
fixp = fixp->fx_next;
parse_exp (char *s, sh_operand_info *op)
{
char *save;
- char *new;
+ char *new_pointer;
save = input_line_pointer;
input_line_pointer = s;
|| sh_PIC_related_p (op->immediate.X_op_symbol))
as_bad (_("misplaced PIC operand"));
#endif
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
/* The many forms of operand:
shmedia_parse_exp (char *s, shmedia_operand_info *op)
{
char *save;
- char *new;
+ char *new_pointer;
save = input_line_pointer;
input_line_pointer = s;
expression (&op->immediate);
if (op->immediate.X_op == O_absent)
as_bad (_("missing operand"));
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
/* Parse an operand. Store pointer to next character in *PTR. */
op_hash = hash_new ();
{
- const template *current_optab = tic30_optab;
+ const insn_template *current_optab = tic30_optab;
for (; current_optab < tic30_optab_end; current_optab++)
{
} immediate;
} operand;
-template *opcode;
+insn_template *opcode;
struct tic30_insn
{
- template *tm; /* Template of current instruction. */
+ insn_template *tm; /* Template of current instruction. */
unsigned opcode; /* Final opcode. */
unsigned int operands; /* Number of given operands. */
/* Type of operand given in instruction. */
void
md_assemble (char *line)
{
- template *opcode;
+ insn_template *opcode;
char *current_posn;
char *token_start;
char save_char;
/* Find instruction. */
save_char = *current_posn;
*current_posn = '\0';
- opcode = (template *) hash_find (op_hash, token_start);
+ opcode = (insn_template *) hash_find (op_hash, token_start);
if (opcode)
{
debug ("Found instruction %s\n", opcode->name);
expressionS *exp = &operand->expr;
char *save = input_line_pointer;
char *str;
- char *new;
+ char *new_pointer;
struct hash_entry *entry = NULL;
input_line_pointer = s;
str = input_line_pointer;
c = get_symbol_end (); /* Get terminator. */
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
if (strlen (str) && (entry = hash_find (tic4x_asg_hash, str)) != NULL)
{
*input_line_pointer = c;
#endif
}
if (entry == NULL)
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
static int
typedef struct _tic54x_insn
{
- const template *tm; /* Opcode template. */
+ const insn_template *tm; /* Opcode template. */
char mnemonic[MAX_LINE]; /* Opcode name/mnemonic. */
char parmnemonic[MAX_LINE]; /* 2nd mnemonic of parallel insn. */
void
md_begin (void)
{
- template *tm;
+ insn_template *tm;
symbol *sym;
const subsym_proc_entry *subsym_proc;
const math_proc_entry *math_proc;
}
op_hash = hash_new ();
- for (tm = (template *) tic54x_optab; tm->name; tm++)
+ for (tm = (insn_template *) tic54x_optab; tm->name; tm++)
{
if (hash_find (op_hash, tm->name))
continue;
tm->name, hash_err);
}
parop_hash = hash_new ();
- for (tm = (template *) tic54x_paroptab; tm->name; tm++)
+ for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++)
{
if (hash_find (parop_hash, tm->name))
continue;
static int
tic54x_parse_insn (tic54x_insn *insn, char *line)
{
- insn->tm = (template *) hash_find (op_hash, insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic);
if (!insn->tm)
{
as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
/* SUCCESS! now try some optimizations. */
if (optimize_insn (insn))
{
- insn->tm = (template *) hash_find (op_hash,
- insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (op_hash,
+ insn->mnemonic);
continue;
}
static int
tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line)
{
- insn->tm = (template *) hash_find (parop_hash, insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic);
if (!insn->tm)
{
as_bad (_("Unrecognized parallel instruction \"%s\""),
parse_exp (char *s, expressionS *op)
{
char *save = input_line_pointer;
- char *new;
+ char *new_pointer;
input_line_pointer = s;
expression (op);
if (op->X_op == O_absent)
as_bad (_("missing operand"));
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
/* The many forms of operand:
unsigned int line;
static unsigned int last_line = 0xffff;
static char *last_file = NULL;
- list_info_type *new = NULL;
+ list_info_type *new_i = NULL;
if (listing == 0)
return;
&& !(last_file && file && strcmp (file, last_file)))
return;
- new = (list_info_type *) xmalloc (sizeof (list_info_type));
+ new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
/* Detect if we are reading from stdin by examining the file
name returned by as_where().
*dest = 0;
}
- new->line_contents = copy;
+ new_i->line_contents = copy;
}
else
- new->line_contents = NULL;
+ new_i->line_contents = NULL;
}
else
{
- new = xmalloc (sizeof (list_info_type));
- new->line_contents = ps;
+ new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
+ new_i->line_contents = ps;
}
last_line = line;
new_frag ();
if (listing_tail)
- listing_tail->next = new;
+ listing_tail->next = new_i;
else
- head = new;
+ head = new_i;
- listing_tail = new;
+ listing_tail = new_i;
- new->frag = frag_now;
- new->line = line;
- new->file = file_info (file);
- new->next = (list_info_type *) NULL;
- new->message = (char *) NULL;
- new->edict = EDICT_NONE;
- new->hll_file = (file_info_type *) NULL;
- new->hll_line = 0;
- new->debugging = 0;
+ new_i->frag = frag_now;
+ new_i->line = line;
+ new_i->file = file_info (file);
+ new_i->next = (list_info_type *) NULL;
+ new_i->message = (char *) NULL;
+ new_i->edict = EDICT_NONE;
+ new_i->hll_file = (file_info_type *) NULL;
+ new_i->hll_line = 0;
+ new_i->debugging = 0;
new_frag ();
segname = segment_name (now_seg);
if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
|| strncmp (segname, ".line", sizeof ".line" - 1) == 0)
- new->debugging = 1;
+ new_i->debugging = 1;
}
#endif
}
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * tic30.h (template): Rename type template to
+ insn_template. Updated code to use new name.
+ * tic54x.h (template): Rename type template to
+ insn_template.
+
2009-08-20 Nick Hudson <nick.hudson@gmx.co.uk>
* hppa.h (pa_opcodes): Add a pa10 bb without FLAG_STRICT.
#define Imm_SInt 2
#define Imm_UInt 3
}
-template;
+insn_template;
-static const template tic30_optab[] = {
+static const insn_template tic30_optab[] = {
{ "absf" ,2,0x00000000,AddressMode, { GAddr1, Rn, 0 }, Imm_Float },
{ "absi" ,2,0x00800000,AddressMode, { GAddr2, AllReg, 0 }, Imm_SInt },
{ "addc" ,2,0x01000000,AddressMode, { GAddr2, AllReg, 0 }, Imm_SInt },
{ "" ,0,0x00000000,0, { 0, 0, 0 }, 0 }
};
-static const template *const tic30_optab_end =
+static const insn_template *const tic30_optab_end =
tic30_optab + sizeof(tic30_optab)/sizeof(tic30_optab[0]);
typedef struct {
const char* parname;
enum optype paroperand_types[MAX_OPERANDS];
-} template;
+} insn_template;
-extern const template tic54x_unknown_opcode;
-extern const template tic54x_optab[];
-extern const template tic54x_paroptab[];
+extern const insn_template tic54x_unknown_opcode;
+extern const insn_template tic54x_optab[];
+extern const insn_template tic54x_paroptab[];
extern const symbol mmregs[], regs[];
extern const symbol condition_codes[], cc2_codes[], status_bits[];
extern const symbol cc3_codes[];
extern const char *misc_symbols[];
struct disassemble_info;
-extern const template* tic54x_get_insn (struct disassemble_info *,
+extern const insn_template* tic54x_get_insn (struct disassemble_info *,
bfd_vma, unsigned short, int *);
#endif /* _opcode_tic54x_h_ */
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * ldexp.c (exp_intop, exp_bigintop, exp_relop, exp_binop)
+ (exp_trinop, exp_unop, exp_nameop, exp_assop): Rename variable new
+ to new_e.
+ * ldfile.c (ldfile_add_library_path): Rename variable new to
+ new_dirs. (ldfile_add_arch): Rename variable new to new_arch.
+ * ldlang.c (new_statement, lang_final, lang_add_wild)
+ (lang_target, lang_add_fill, lang_add_data, lang_add_assignment)
+ (lang_add_insert): Rename variable new to new_stmt. (new_afile):
+ Added missing cast. (lang_memory_region_lookup): Rename variable
+ new to new_region. (init_os): Rename variable new to
+ new_userdata. (lang_add_section): Rename variable new to
+ new_section. (ldlang_add_undef): Rename variable new to
+ new_undef. (realsymbol): Rename variable new to new_name.
+
2009-08-26 Nick Clifton <nickc@redhat.com>
PR ld/10555
etree_type *
exp_intop (bfd_vma value)
{
- etree_type *new = stat_alloc (sizeof (new->value));
- new->type.node_code = INT;
- new->type.lineno = lineno;
- new->value.value = value;
- new->value.str = NULL;
- new->type.node_class = etree_value;
- return new;
+ etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
+ new_e->type.node_code = INT;
+ new_e->type.lineno = lineno;
+ new_e->value.value = value;
+ new_e->value.str = NULL;
+ new_e->type.node_class = etree_value;
+ return new_e;
}
etree_type *
exp_bigintop (bfd_vma value, char *str)
{
- etree_type *new = stat_alloc (sizeof (new->value));
- new->type.node_code = INT;
- new->type.lineno = lineno;
- new->value.value = value;
- new->value.str = str;
- new->type.node_class = etree_value;
- return new;
+ etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
+ new_e->type.node_code = INT;
+ new_e->type.lineno = lineno;
+ new_e->value.value = value;
+ new_e->value.str = str;
+ new_e->type.node_class = etree_value;
+ return new_e;
}
/* Build an expression representing an unnamed relocatable value. */
etree_type *
exp_relop (asection *section, bfd_vma value)
{
- etree_type *new = stat_alloc (sizeof (new->rel));
- new->type.node_code = REL;
- new->type.lineno = lineno;
- new->type.node_class = etree_rel;
- new->rel.section = section;
- new->rel.value = value;
- return new;
+ etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->rel));
+ new_e->type.node_code = REL;
+ new_e->type.lineno = lineno;
+ new_e->type.node_class = etree_rel;
+ new_e->rel.section = section;
+ new_e->rel.value = value;
+ return new_e;
}
static void
etree_type *
exp_binop (int code, etree_type *lhs, etree_type *rhs)
{
- etree_type value, *new;
+ etree_type value, *new_e;
value.type.node_code = code;
value.type.lineno = lhs->type.lineno;
if (expld.result.valid_p)
return exp_intop (expld.result.value);
- new = stat_alloc (sizeof (new->binary));
- memcpy (new, &value, sizeof (new->binary));
- return new;
+ new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
+ memcpy (new_e, &value, sizeof (new_e->binary));
+ return new_e;
}
etree_type *
exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
{
- etree_type value, *new;
+ etree_type value, *new_e;
value.type.node_code = code;
value.type.lineno = lhs->type.lineno;
if (expld.result.valid_p)
return exp_intop (expld.result.value);
- new = stat_alloc (sizeof (new->trinary));
- memcpy (new, &value, sizeof (new->trinary));
- return new;
+ new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
+ memcpy (new_e, &value, sizeof (new_e->trinary));
+ return new_e;
}
etree_type *
exp_unop (int code, etree_type *child)
{
- etree_type value, *new;
+ etree_type value, *new_e;
value.unary.type.node_code = code;
value.unary.type.lineno = child->type.lineno;
if (expld.result.valid_p)
return exp_intop (expld.result.value);
- new = stat_alloc (sizeof (new->unary));
- memcpy (new, &value, sizeof (new->unary));
- return new;
+ new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
+ memcpy (new_e, &value, sizeof (new_e->unary));
+ return new_e;
}
etree_type *
exp_nameop (int code, const char *name)
{
- etree_type value, *new;
+ etree_type value, *new_e;
value.name.type.node_code = code;
value.name.type.lineno = lineno;
if (expld.result.valid_p)
return exp_intop (expld.result.value);
- new = stat_alloc (sizeof (new->name));
- memcpy (new, &value, sizeof (new->name));
- return new;
+ new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
+ memcpy (new_e, &value, sizeof (new_e->name));
+ return new_e;
}
etree_type *
exp_assop (int code, const char *dst, etree_type *src)
{
- etree_type *new;
-
- new = stat_alloc (sizeof (new->assign));
- new->type.node_code = code;
- new->type.lineno = src->type.lineno;
- new->type.node_class = etree_assign;
- new->assign.src = src;
- new->assign.dst = dst;
- return new;
+ etree_type *new_e;
+
+ new_e = (etree_type *) stat_alloc (sizeof (new_e->assign));
+ new_e->type.node_code = code;
+ new_e->type.lineno = src->type.lineno;
+ new_e->type.node_class = etree_assign;
+ new_e->assign.src = src;
+ new_e->assign.dst = dst;
+ return new_e;
}
/* Handle PROVIDE. */
void
ldfile_add_library_path (const char *name, bfd_boolean cmdline)
{
- search_dirs_type *new;
+ search_dirs_type *new_dirs;
if (!cmdline && config.only_cmd_line_lib_dirs)
return;
- new = xmalloc (sizeof (search_dirs_type));
- new->next = NULL;
- new->cmdline = cmdline;
- *search_tail_ptr = new;
- search_tail_ptr = &new->next;
+ new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
+ new_dirs->next = NULL;
+ new_dirs->cmdline = cmdline;
+ *search_tail_ptr = new_dirs;
+ search_tail_ptr = &new_dirs->next;
/* If a directory is marked as honoring sysroot, prepend the sysroot path
now. */
if (name[0] == '=')
{
- new->name = concat (ld_sysroot, name + 1, (const char *) NULL);
- new->sysrooted = TRUE;
+ new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
+ new_dirs->sysrooted = TRUE;
}
else
{
- new->name = xstrdup (name);
- new->sysrooted = is_sysrooted_pathname (name, FALSE);
+ new_dirs->name = xstrdup (name);
+ new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE);
}
}
ldfile_add_arch (const char *in_name)
{
char *name = xstrdup (in_name);
- search_arch_type *new = xmalloc (sizeof (search_arch_type));
+ search_arch_type *new_arch = (search_arch_type *)
+ xmalloc (sizeof (search_arch_type));
ldfile_output_machine_name = in_name;
- new->name = name;
- new->next = NULL;
+ new_arch->name = name;
+ new_arch->next = NULL;
while (*name)
{
*name = TOLOWER (*name);
name++;
}
- *search_arch_tail_ptr = new;
- search_arch_tail_ptr = &new->next;
+ *search_arch_tail_ptr = new_arch;
+ search_arch_tail_ptr = &new_arch->next;
}
size_t size,
lang_statement_list_type *list)
{
- lang_statement_union_type *new;
+ lang_statement_union_type *new_stmt;
- new = stat_alloc (size);
- new->header.type = type;
- new->header.next = NULL;
- lang_statement_append (list, new, &new->header.next);
- return new;
+ new_stmt = (lang_statement_union_type *) stat_alloc (size);
+ new_stmt->header.type = type;
+ new_stmt->header.next = NULL;
+ lang_statement_append (list, new_stmt, &new_stmt->header.next);
+ return new_stmt;
}
/* Build a new input file node for the language. There are several
lang_input_statement_type *p;
if (add_to_list)
- p = new_stat (lang_input_statement, stat_ptr);
+ p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
else
{
- p = stat_alloc (sizeof (lang_input_statement_type));
+ p = (lang_input_statement_type *)
+ stat_alloc (sizeof (lang_input_statement_type));
p->header.type = lang_input_statement_enum;
p->header.next = NULL;
}
{
lang_memory_region_name *n;
lang_memory_region_type *r;
- lang_memory_region_type *new;
+ lang_memory_region_type *new_region;
/* NAME is NULL for LMA memspecs if no region was specified. */
if (name == NULL)
if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);
- new = stat_alloc (sizeof (lang_memory_region_type));
+ new_region = (lang_memory_region_type *)
+ stat_alloc (sizeof (lang_memory_region_type));
- new->name_list.name = xstrdup (name);
- new->name_list.next = NULL;
- new->next = NULL;
- new->origin = 0;
- new->length = ~(bfd_size_type) 0;
- new->current = 0;
- new->last_os = NULL;
- new->flags = 0;
- new->not_flags = 0;
- new->had_full_message = FALSE;
+ new_region->name_list.name = xstrdup (name);
+ new_region->name_list.next = NULL;
+ new_region->next = NULL;
+ new_region->origin = 0;
+ new_region->length = ~(bfd_size_type) 0;
+ new_region->current = 0;
+ new_region->last_os = NULL;
+ new_region->flags = 0;
+ new_region->not_flags = 0;
+ new_region->had_full_message = FALSE;
- *lang_memory_region_list_tail = new;
- lang_memory_region_list_tail = &new->next;
+ *lang_memory_region_list_tail = new_region;
+ lang_memory_region_list_tail = &new_region->next;
- return new;
+ return new_region;
}
void
if (!link_info.reduce_memory_overheads)
{
- fat_section_userdata_type *new
- = stat_alloc (sizeof (fat_section_userdata_type));
- memset (new, 0, sizeof (fat_section_userdata_type));
- get_userdata (s->bfd_section) = new;
+ fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
+ stat_alloc (sizeof (fat_section_userdata_type));
+ memset (new_userdata, 0, sizeof (fat_section_userdata_type));
+ get_userdata (s->bfd_section) = new_userdata;
}
/* If there is a base address, make sure that any sections it might
if (section->output_section == NULL)
{
bfd_boolean first;
- lang_input_section_type *new;
+ lang_input_section_type *new_section;
flagword flags;
flags = section->flags;
}
/* Add a section reference to the list. */
- new = new_stat (lang_input_section, ptr);
+ new_section = new_stat (lang_input_section, ptr);
- new->section = section;
+ new_section->section = section;
section->output_section = output->bfd_section;
/* If final link, don't copy the SEC_LINK_ONCE flags, they've
void
ldlang_add_undef (const char *const name)
{
- ldlang_undef_chain_list_type *new =
- stat_alloc (sizeof (ldlang_undef_chain_list_type));
+ ldlang_undef_chain_list_type *new_undef = (ldlang_undef_chain_list_type *)
+ stat_alloc (sizeof (ldlang_undef_chain_list_type));
- new->next = ldlang_undef_chain_list_head;
- ldlang_undef_chain_list_head = new;
+ new_undef->next = ldlang_undef_chain_list_head;
+ ldlang_undef_chain_list_head = new_undef;
- new->name = xstrdup (name);
+ new_undef->name = xstrdup (name);
if (link_info.output_bfd != NULL)
- insert_undefined (new->name);
+ insert_undefined (new_undef->name);
}
/* Insert NAME as undefined in the symbol table. */
void
lang_final (void)
{
- lang_output_statement_type *new;
+ lang_output_statement_type *new_stmt;
+
+ new_stmt = new_stat (lang_output_statement, stat_ptr);
+ new_stmt->name = output_filename;
- new = new_stat (lang_output_statement, stat_ptr);
- new->name = output_filename;
}
/* Reset the current counters in the regions. */
bfd_boolean keep_sections)
{
struct wildcard_list *curr, *next;
- lang_wild_statement_type *new;
+ lang_wild_statement_type *new_stmt;
/* Reverse the list as the parser puts it back to front. */
for (curr = section_list, section_list = NULL;
lang_has_input_file = TRUE;
}
- new = new_stat (lang_wild_statement, stat_ptr);
- new->filename = NULL;
- new->filenames_sorted = FALSE;
+ new_stmt = new_stat (lang_wild_statement, stat_ptr);
+ new_stmt->filename = NULL;
+ new_stmt->filenames_sorted = FALSE;
if (filespec != NULL)
{
- new->filename = filespec->name;
- new->filenames_sorted = filespec->sorted == by_name;
+ new_stmt->filename = filespec->name;
+ new_stmt->filenames_sorted = filespec->sorted == by_name;
}
- new->section_list = section_list;
- new->keep_sections = keep_sections;
- lang_list_init (&new->children);
- analyze_walk_wild_section_handler (new);
+ new_stmt->section_list = section_list;
+ new_stmt->keep_sections = keep_sections;
+ lang_list_init (&new_stmt->children);
+ analyze_walk_wild_section_handler (new_stmt);
}
void
void
lang_add_target (const char *name)
{
- lang_target_statement_type *new;
+ lang_target_statement_type *new_stmt;
- new = new_stat (lang_target_statement, stat_ptr);
- new->target = name;
+ new_stmt = new_stat (lang_target_statement, stat_ptr);
+ new_stmt->target = name;
}
void
void
lang_add_fill (fill_type *fill)
{
- lang_fill_statement_type *new;
+ lang_fill_statement_type *new_stmt;
- new = new_stat (lang_fill_statement, stat_ptr);
- new->fill = fill;
+ new_stmt = new_stat (lang_fill_statement, stat_ptr);
+ new_stmt->fill = fill;
}
void
lang_add_data (int type, union etree_union *exp)
{
- lang_data_statement_type *new;
+ lang_data_statement_type *new_stmt;
- new = new_stat (lang_data_statement, stat_ptr);
- new->exp = exp;
- new->type = type;
+ new_stmt = new_stat (lang_data_statement, stat_ptr);
+ new_stmt->exp = exp;
+ new_stmt->type = type;
}
/* Create a new reloc statement. RELOC is the BFD relocation type to
lang_assignment_statement_type *
lang_add_assignment (etree_type *exp)
{
- lang_assignment_statement_type *new;
+ lang_assignment_statement_type *new_stmt;
- new = new_stat (lang_assignment_statement, stat_ptr);
- new->exp = exp;
- return new;
+ new_stmt = new_stat (lang_assignment_statement, stat_ptr);
+ new_stmt->exp = exp;
+ return new_stmt;
}
void
void
lang_add_insert (const char *where, int is_before)
{
- lang_insert_statement_type *new;
+ lang_insert_statement_type *new_stmt;
- new = new_stat (lang_insert_statement, stat_ptr);
- new->where = where;
- new->is_before = is_before;
+ new_stmt = new_stat (lang_insert_statement, stat_ptr);
+ new_stmt->where = where;
+ new_stmt->is_before = is_before;
saved_script_handle = previous_script_handle;
}
}
}
-/* This is called for each variable name or match expression. NEW is
+/* This is called for each variable name or match expression. NEW_NAME is
the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
pattern to be matched against symbol names. */
struct bfd_elf_version_expr *
lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
- const char *new,
+ const char *new_name,
const char *lang,
bfd_boolean literal_p)
{
struct bfd_elf_version_expr *ret;
- ret = xmalloc (sizeof *ret);
+ ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
ret->next = orig;
ret->symver = 0;
ret->script = 0;
ret->literal = TRUE;
- ret->pattern = literal_p ? new : realsymbol (new);
+ ret->pattern = literal_p ? new_name : realsymbol (new_name);
if (ret->pattern == NULL)
{
- ret->pattern = new;
+ ret->pattern = new_name;
ret->literal = FALSE;
}
+2009-08-29 Martin Thuresson <martin@mtme.org>
+
+ * cris-dis.c (bytes_to_skip): Update code to use new name.
+ * i386-dis.c (putop): Update code to use new name.
+ * i386-gen.c (process_i386_opcodes): Update code to use
+ new name.
+ * i386-opc.h (struct template): Rename struct template to
+ insn_template. Update code accordingly.
+ * i386-tbl.h (i386_optab): Update type to use new name.
+ * ia64-dis.c (print_insn_ia64): Rename variable template
+ to template_val.
+ * tic30-dis.c (struct instruction, get_tic30_instruction):
+ Update code to use new name.
+ * tic54x-dis.c (has_lkaddr, get_insn_size)
+ (print_parallel_instruction, print_insn_tic54x, tic54x_get_insn):
+ Update code to use new name.
+ * tic54x-opc.c (tic54x_unknown_opcode, tic54x_optab):
+ Update type to new name.
+ * z8kgen.c (internal, gas): Rename variable new to new_op.
+
2009-08-28 H.J. Lu <hongjiu.lu@intel.com>
* Makefile.am (COMPILE_FOR_BUILD): Remove BUILD_CPPFLAGS.
{
/* Each insn is a word plus "immediate" operands. */
unsigned to_skip = 2;
- const char *template = matchedp->args;
+ const char *template_name = (const char *) matchedp->args;
const char *s;
- for (s = template; *s; s++)
+ for (s = template_name; *s; s++)
if ((*s == 's' || *s == 'N' || *s == 'Y')
&& (insn & 0x400) && (insn & 15) == 15
&& prefix_matchedp == NULL)
{
/* Immediate via [pc+], so we have to check the size of the
operand. */
- int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
+ int mode_size = 1 << ((insn >> 4) & (*template_name == 'z' ? 1 : 3));
if (matchedp->imm_oprnd_size == SIZE_FIX_32)
to_skip += 4;
/* Capital letters in template are macros. */
static int
-putop (const char *template, int sizeflag)
+putop (const char *in_template, int sizeflag)
{
const char *p;
int alt = 0;
else \
abort ();
- for (p = template; *p; p++)
+ for (p = in_template; *p; p++)
{
switch (*p)
{
xcalloc, free);
fprintf (table, "\n/* i386 opcode table. */\n\n");
- fprintf (table, "const template i386_optab[] =\n{\n");
+ fprintf (table, "const insn_template i386_optab[] =\n{\n");
/* Put everything on opcode array. */
while (!feof (fp))
unsigned int array[OTNumOfUints];
} i386_operand_type;
-typedef struct template
+typedef struct insn_template
{
/* instruction name sans width suffix ("mov" for movl insns) */
char *name;
either a register or an immediate operand. */
i386_operand_type operand_types[MAX_OPERANDS];
}
-template;
+insn_template;
-extern const template i386_optab[];
+extern const insn_template i386_optab[];
/* these are for register name --> number & type hash lookup */
typedef struct
/* i386 opcode table. */
-const template i386_optab[] =
+const insn_template i386_optab[] =
{
{ "mov", 2, 0xa0, None, 1,
{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
int
print_insn_ia64 (bfd_vma memaddr, struct disassemble_info *info)
{
- ia64_insn t0, t1, slot[3], template, s_bit, insn;
+ ia64_insn t0, t1, slot[3], template_val, s_bit, insn;
int slotnum, j, status, need_comma, retval, slot_multiplier;
const struct ia64_operand *odesc;
const struct ia64_opcode *idesc;
t0 = bfd_getl64 (bundle);
t1 = bfd_getl64 (bundle + 8);
s_bit = t0 & 1;
- template = (t0 >> 1) & 0xf;
+ template_val = (t0 >> 1) & 0xf;
slot[0] = (t0 >> 5) & 0x1ffffffffffLL;
slot[1] = ((t0 >> 46) & 0x3ffff) | ((t1 & 0x7fffff) << 18);
slot[2] = (t1 >> 23) & 0x1ffffffffffLL;
- tname = ia64_templ_desc[template].name;
+ tname = ia64_templ_desc[template_val].name;
if (slotnum == 0)
(*info->fprintf_func) (info->stream, "[%s] ", tname);
else
(*info->fprintf_func) (info->stream, " ");
- unit = ia64_templ_desc[template].exec_unit[slotnum];
+ unit = ia64_templ_desc[template_val].exec_unit[slotnum];
- if (template == 2 && slotnum == 1)
+ if (template_val == 2 && slotnum == 1)
{
/* skip L slot in MLI template: */
slotnum = 2;
need_comma = 0;
}
}
- if (slotnum + 1 == ia64_templ_desc[template].group_boundary
+ if (slotnum + 1 == ia64_templ_desc[template_val].group_boundary
|| ((slotnum == 2) && s_bit))
(*info->fprintf_func) (info->stream, ";;");
struct instruction
{
int type;
- template *tm;
+ insn_template *tm;
partemplate *ptm;
};
case THREE_OPERAND:
insn->type = NORMAL_INSN;
{
- template *current_optab = (template *) tic30_optab;
+ insn_template *current_optab = (insn_template *) tic30_optab;
for (; current_optab < tic30_optab_end; current_optab++)
{
case BRANCHES:
insn->type = NORMAL_INSN;
{
- template *current_optab = (template *) tic30_optab;
+ insn_template *current_optab = (insn_template *) tic30_optab;
for (; current_optab < tic30_optab_end; current_optab++)
{
#include "opcode/tic54x.h"
#include "coff/tic54x.h"
-static int has_lkaddr (unsigned short, const template *);
-static int get_insn_size (unsigned short, const template *);
+static int has_lkaddr (unsigned short, const insn_template *);
+static int get_insn_size (unsigned short, const insn_template *);
static int print_instruction (disassemble_info *, bfd_vma,
unsigned short, const char *,
const enum optype [], int, int);
static int print_parallel_instruction (disassemble_info *, bfd_vma,
- unsigned short,
- const template *, int);
+ unsigned short,
+ const insn_template *, int);
static int sprint_dual_address (disassemble_info *,char [],
unsigned short);
static int sprint_indirect_address (disassemble_info *,char [],
bfd_byte opbuf[2];
unsigned short opcode;
int status, size;
- const template* tm;
+ const insn_template* tm;
status = (*info->read_memory_func) (memaddr, opbuf, 2, info);
if (status != 0)
}
static int
-has_lkaddr (unsigned short memdata, const template *tm)
+has_lkaddr (unsigned short memdata, const insn_template *tm)
{
return (IS_LKADDR (memdata)
&& (OPTYPE (tm->operand_types[0]) == OP_Smem
/* always returns 1 (whether an insn template was found) since we provide an
"unknown instruction" template */
-const template*
-tic54x_get_insn (disassemble_info *info, bfd_vma addr,
+const insn_template*
+tic54x_get_insn (disassemble_info *info, bfd_vma addr,
unsigned short memdata, int *size)
{
- const template *tm = NULL;
+ const insn_template *tm = NULL;
for (tm = tic54x_optab; tm->name; tm++)
{
}
}
}
- for (tm = (template *) tic54x_paroptab; tm->name; tm++)
+ for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++)
{
if (tm->opcode == (memdata & tm->mask))
{
}
static int
-get_insn_size (unsigned short memdata, const template *insn)
+get_insn_size (unsigned short memdata, const insn_template *insn)
{
int size;
disassemble_info *info;
bfd_vma memaddr;
unsigned short opcode;
- const template *ptm;
+ const insn_template *ptm;
int size;
{
print_instruction (info, memaddr, opcode,
#define ZPAR 0,{OP_None}
#define REST 0,0,ZPAR
#define XREST ZPAR
-const template tic54x_unknown_opcode =
+const insn_template tic54x_unknown_opcode =
{ "???", 1,0,0,0x0000, 0x0000, {0}, 0, REST};
-const template tic54x_optab[] = {
+const insn_template tic54x_optab[] = {
/* these must precede bc/bcd, cc/ccd to avoid misinterpretation */
{ "fb", 2,1,1,0xF880, 0xFF80, {OP_xpmad}, B_BRANCH|FL_FAR|FL_NR, REST},
{ "fbd", 2,1,1,0xFA80, 0xFF80, {OP_xpmad}, B_BRANCH|FL_FAR|FL_DELAY|FL_NR, REST},
};
/* assume all parallel instructions have at least three operands */
-const template tic54x_paroptab[] = {
+const insn_template tic54x_paroptab[] = {
{ "ld",1,1,2,0xA800, 0xFE00, {OP_Xmem,OP_DST}, FL_PAR,0,0,
"mac", {OP_Ymem,OPT|OP_RND},},
{ "ld",1,1,2,0xAA00, 0xFE00, {OP_Xmem,OP_DST}, FL_PAR,0,0,
internal (void)
{
int c = count ();
- struct op *new = xmalloc (sizeof (struct op) * c);
+ struct op *new_op = xmalloc (sizeof (struct op) * c);
struct op *p = opt;
- memcpy (new, p, c * sizeof (struct op));
+ memcpy (new_op, p, c * sizeof (struct op));
/* Sort all names in table alphabetically. */
- qsort (new, c, sizeof (struct op), (int (*)(const void *, const void *))func);
+ qsort (new_op, c, sizeof (struct op), (int (*)(const void *, const void *))func);
- p = new;
+ p = new_op;
while (p->flags && p->flags[0] != '*')
{
/* If there are any @rs, sub the ssss into a ssn0, (rs), (ssn0). */
struct op *p = opt;
int idx = -1;
char *oldname = "";
- struct op *new = xmalloc (sizeof (struct op) * c);
+ struct op *new_op = xmalloc (sizeof (struct op) * c);
- memcpy (new, p, c * sizeof (struct op));
+ memcpy (new_op, p, c * sizeof (struct op));
/* Sort all names in table alphabetically. */
- qsort (new, c, sizeof (struct op), (int (*)(const void *, const void *)) func);
+ qsort (new_op, c, sizeof (struct op), (int (*)(const void *, const void *)) func);
printf ("/* DO NOT EDIT! -*- buffer-read-only: t -*-\n");
printf (" This file is automatically generated by z8kgen. */\n\n");
printf ("#ifdef DEFINE_TABLE\n");
printf ("const opcode_entry_type z8k_table[] = {\n");
- while (new->flags && new->flags[0])
+ while (new_op->flags && new_op->flags[0])
{
int nargs;
int length;
- printf ("\n/* %s *** %s */\n", new->bits, new->name);
+ printf ("\n/* %s *** %s */\n", new_op->bits, new_op->name);
printf ("{\n");
printf ("#ifdef NICENAMES\n");
- printf ("\"%s\",%d,%d,", new->name, new->type, new->cycles);
+ printf ("\"%s\",%d,%d,", new_op->name, new_op->type, new_op->cycles);
{
int answer = 0;
- char *p = new->flags;
+ char *p = new_op->flags;
while (*p)
{
printf ("#endif\n");
- nargs = chewname (&new->name);
+ nargs = chewname (&new_op->name);
printf ("\n\t");
- chewbits (new->bits, &length);
+ chewbits (new_op->bits, &length);
length /= 2;
if (length & 1)
abort();
- if (strcmp (oldname, new->name) != 0)
+ if (strcmp (oldname, new_op->name) != 0)
idx++;
printf (",%d,%d,%d", nargs, length, idx);
- oldname = new->name;
+ oldname = new_op->name;
printf ("},\n");
- new++;
+ new_op++;
}
printf ("\n/* end marker */\n");
printf ("{\n#ifdef NICENAMES\nNULL,0,0,\n0,\n#endif\n");
projects / binutils-gdb.git / commitdiff