+2012-05-18 Sergio Durigan Junior <sergiodj@redhat.com>
+
+ * ada-lang.c:
+ * ada-tasks.c:
+ * ada-varobj.c:
+ * amd64-darwin-tdep.c:
+ * arm-symbian-tdep.c:
+ * arm-tdep.c:
+ * avr-tdep.c:
+ * ax-gdb.c:
+ * bfin-linux-tdep.c:
+ * breakpoint.c:
+ * c-valprint.c:
+ * cli/cli-cmds.c:
+ * coffread.c:
+ * cp-support.c:
+ * cris-tdep.c:
+ * dwarf2-frame-tailcall.c:
+ * dwarf2-frame.c:
+ * dwarf2expr.c:
+ * dwarf2loc.c:
+ * dwarf2read.c:
+ * elfread.c:
+ * eval.c:
+ * expprint.c:
+ * f-valprint.c:
+ * frv-tdep.c:
+ * h8300-tdep.c:
+ * hppa-hpux-tdep.c:
+ * hppa-tdep.c:
+ * hppanbsd-tdep.c:
+ * i386-nto-tdep.c:
+ * i386-tdep.c:
+ * i387-tdep.c:
+ * ia64-tdep.c:
+ * jit.c:
+ * linespec.c:
+ * linux-tdep.c:
+ * lm32-tdep.c:
+ * m2-valprint.c:
+ * m32c-tdep.c:
+ * m32r-rom.c:
+ * m32r-tdep.c:
+ * m68k-tdep.c:
+ * m68klinux-tdep.c:
+ * mi/mi-main.c:
+ * microblaze-tdep.c:
+ * mips-linux-tdep.c:
+ * mips-tdep.c:
+ * mn10300-tdep.c:
+ * p-valprint.c:
+ * parse.c:
+ * ppc-linux-tdep.c:
+ * ppc-sysv-tdep.c:
+ * printcmd.c:
+ * python/py-finishbreakpoint.c:
+ * python/py-inferior.c:
+ * python/py-infthread.c:
+ * python/py-type.c:
+ * python/python.c:
+ * remote-fileio.c:
+ * remote-m32r-sdi.c:
+ * remote-mips.c:
+ * reverse.c:
+ * rl78-tdep.c:
+ * rs6000-aix-tdep.c:
+ * rs6000-tdep.c:
+ * s390-tdep.c:
+ * score-tdep.c:
+ * sh64-tdep.c:
+ * skip.c:
+ * solib-darwin.c:
+ * solib-dsbt.c:
+ * solib-frv.c:
+ * sparc-tdep.c:
+ * spu-multiarch.c:
+ * spu-tdep.c:
+ * stack.c:
+ * symfile.c:
+ * symtab.c:
+ * tic6x-tdep.c:
+ * tracepoint.c:
+ * v850-tdep.c:
+ * valarith.c:
+ * valprint.c:
+ * value.c:
+ * xcoffread.c:
+ * xtensa-tdep.c:
+ * ada-lang.c:
+ * ada-tasks.c:
+ * ada-varobj.c:
+ * amd64-darwin-tdep.c:
+ * arm-symbian-tdep.c:
+ * arm-tdep.c: Delete unused variables.
+
2012-05-18 Jan Kratochvil <jan.kratochvil@redhat.com>
Rename $ddir to $datadir.
static int
wild_match (const char *name, const char *patn)
{
- const char *p, *n;
+ const char *p;
const char *name0 = name;
while (1)
ada_exception_support_info_sniffer (void)
{
struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
- struct symbol *sym;
/* If the exception info is already known, then no need to recompute it. */
if (data->exception_info != NULL)
static void
ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
{
- const char *name;
struct minimal_symbol *msym;
struct symbol *sym;
struct type *parent_type)
{
LONGEST lo, hi;
- int len;
if (!get_array_bounds (parent_type, &lo, &hi))
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR rbx;
- CORE_ADDR si;
gdb_byte buf[8];
/* A pointer to the ucontext is passed as the fourth argument
static enum gdb_osabi
arm_symbian_osabi_sniffer (bfd *abfd)
{
- Elf_Internal_Phdr *phdrs, **segments;
+ Elf_Internal_Phdr *phdrs;
long phdrs_size;
int num_phdrs, i;
int
arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
{
- struct obj_section *sec;
struct minimal_symbol *sym;
char type;
struct displaced_step_closure* dsc
arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
{
enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
- unsigned int address, basereg;
+ unsigned int basereg;
struct minimal_symbol *stack_chk_guard;
int offset;
int is_thumb = arm_pc_is_thumb (gdbarch, pc);
unsigned long inst;
CORE_ADDR skip_pc;
CORE_ADDR func_addr, limit_pc;
- struct symtab_and_line sal;
/* See if we can determine the end of the prologue via the symbol table.
If so, then return either PC, or the PC after the prologue, whichever
{
CORE_ADDR prologue_start;
CORE_ADDR prologue_end;
- CORE_ADDR current_pc;
if (find_pc_partial_function (block_addr, NULL, &prologue_start,
&prologue_end))
extend_buffer_earlier (gdb_byte *buf, CORE_ADDR endaddr,
int old_len, int new_len)
{
- gdb_byte *new_buf, *middle;
+ gdb_byte *new_buf;
int bytes_to_read = new_len - old_len;
new_buf = xmalloc (new_len);
gdb_byte *buf;
char map_type;
CORE_ADDR boundary, func_start;
- int buf_len, buf2_len;
+ int buf_len;
enum bfd_endian order = gdbarch_byte_order_for_code (gdbarch);
int i, any, last_it, last_it_count;
struct displaced_step_closure *dsc)
{
uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
- int load_executed = condition_true (dsc->u.block.cond, status), i;
+ int load_executed = condition_true (dsc->u.block.cond, status);
unsigned int mask = dsc->u.block.regmask, write_reg = ARM_PC_REGNUM;
unsigned int regs_loaded = bitcount (mask);
unsigned int num_to_shuffle = regs_loaded, clobbered;
arm_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
int *kindptr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-
arm_breakpoint_from_pc (gdbarch, pcptr, kindptr);
if (arm_pc_is_thumb (gdbarch, *pcptr) && *kindptr == 4)
arm_show_fallback_mode (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
-
fprintf_filtered (file,
_("The current execution mode assumed "
"(when symbols are unavailable) is \"%s\".\n"),
int regnum, const gdb_byte *buf)
{
char name_buf[4];
- gdb_byte reg_buf[8];
int offset, double_regnum;
sprintf (name_buf, "d%d", regnum << 1);
0xcd, 0xb7, /* in r28,__SP_L__ */
0xde, 0xb7 /* in r29,__SP_H__ */
};
- unsigned short insn1;
if (vpc + sizeof (img) < len
&& memcmp (prologue + vpc, img, sizeof (img)) == 0)
case OP_THIS:
{
- char *this_name;
struct symbol *sym, *func;
struct block *b;
const struct language_defn *lang;
CORE_ADDR sp = get_frame_sp (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
CORE_ADDR sigcontext = sp + SIGCONTEXT_OFFSET;
- struct frame_id this_id;
const int *reg_offset = bfin_linux_sigcontext_reg_offset;
int i;
set_condition_evaluation_mode (char *args, int from_tty,
struct cmd_list_element *c)
{
- struct breakpoint *b;
const char *old_mode, *new_mode;
if ((condition_evaluation_mode_1 == condition_evaluation_target)
struct solib_catchpoint *c;
struct gdbarch *gdbarch = get_current_arch ();
int tempflag;
- regex_t compiled;
struct cleanup *cleanup;
tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
ptid_t ptid;
struct target_waitstatus last;
struct syscall s;
- char *syscall_id;
get_last_target_status (&ptid, &last);
{
VEC(static_tracepoint_marker_p) *markers = NULL;
struct symtabs_and_lines sals;
- struct symtab_and_line sal;
- struct symbol *sym;
struct cleanup *old_chain;
char *p = &(*arg_p)[3];
char *endp;
struct linespec_result canonical;
struct cleanup *old_chain;
struct cleanup *bkpt_chain = NULL;
- int i;
int pending = 0;
int task = 0;
int prev_bkpt_count = breakpoint_count;
struct tracepoint *tp = (struct tracepoint *) b;
struct static_tracepoint_marker marker;
CORE_ADDR pc;
- int i;
pc = sal.pc;
if (sal.line)
if (parsed_float)
{
- const char *suffix;
- int suffix_len;
-
/* If it ends at "df", "dd" or "dl", take it as type of decimal floating
point. Return DECFLOAT. */
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
unsigned eltlen;
- LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
}
else
{
- int i;
dyn_string_t alias_prefix_dyn_string, command_prefix_dyn_string;
char *alias_prefix, *command_prefix;
struct cmd_list_element *c_alias, *c_command;
coff_getfilename (union internal_auxent *aux_entry)
{
static char buffer[BUFSIZ];
- char *temp;
const char *result;
if (aux_entry->x_file.x_n.x_zeroes == 0)
static void
make_symbol_overload_list_qualified (const char *func_name)
{
- struct symbol *sym;
struct symtab *s;
struct objfile *objfile;
const struct block *b, *surrounding_static_block = 0;
- struct dict_iterator iter;
- const struct dictionary *dict;
/* Look through the partial symtabs for all symbols which begin by
matching FUNC_NAME. Make sure we read that symbol table in. */
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct cris_unwind_cache *info;
- CORE_ADDR pc;
- CORE_ADDR sp;
CORE_ADDR addr;
char buf[4];
int i;
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- CORE_ADDR pc;
struct cris_unwind_cache *info;
- int i;
if ((*this_prologue_cache))
return (*this_prologue_cache);
int struct_return, CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int stack_alloc;
int stack_offset;
int argreg;
int argnum;
- CORE_ADDR regval;
-
/* The function's arguments and memory allocated by gdb for the arguments to
point at reside in separate areas on the stack.
Both frame pointers grow toward higher addresses. */
static void
bdap_prefix (unsigned short inst, inst_env_type *inst_env)
{
-
- long offset;
-
/* It's invalid to be in a delay slot. */
if (inst_env->slot_needed || inst_env->prefix_found)
{
{
int next_levels = existing_next_levels (this_frame, cache);
struct call_site_chain *chain = cache->chain;
- int caller_no;
gdb_assert (chain != NULL);
{
CORE_ADDR prev_pc = 0, prev_sp = 0; /* GCC warning. */
int prev_sp_p = 0;
- CORE_ADDR this_pc, pc;
+ CORE_ADDR this_pc;
struct gdbarch *prev_gdbarch;
struct call_site_chain *chain = NULL;
- struct frame_info *fi;
struct tailcall_cache *cache;
volatile struct gdb_exception except;
const int num_regs = gdbarch_num_regs (gdbarch)
+ gdbarch_num_pseudo_regs (gdbarch);
struct dwarf2_fde *fde;
- CORE_ADDR text_offset, cfa;
+ CORE_ADDR text_offset;
struct dwarf2_frame_state fs;
int addr_size;
case DW_OP_GNU_implicit_pointer:
{
- ULONGEST die;
LONGEST len;
if (ctx->ref_addr_size == -1)
call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
CORE_ADDR callee_pc)
{
- struct func_type *func_specific;
struct obstack addr_obstack;
struct cleanup *back_to_retval, *back_to_workdata;
struct call_site_chain *retval = NULL;
struct frame_info *caller_frame = get_prev_frame (frame);
struct call_site *call_site;
int iparams;
- struct value *val;
- struct dwarf2_locexpr_baton *dwarf_block;
/* Initialize it just to avoid a GCC false warning. */
struct call_site_parameter *parameter = NULL;
CORE_ADDR target_addr;
{
const gdb_byte *datastart;
size_t datalen;
- unsigned int before_stack_len;
struct block *b;
struct symbol *framefunc;
LONGEST base_offset = 0;
struct line_header *lh;
struct attribute *attr;
int i;
- unsigned int bytes_read;
char *name, *comp_dir;
void **slot;
struct quick_file_names *qfn;
struct dwarf2_cu *cu = reader->cu;
struct objfile *objfile = cu->objfile;
struct dwarf2_per_cu_data *per_cu = cu->per_cu;
- bfd *abfd = objfile->obfd;
struct attribute *attr;
CORE_ADDR baseaddr;
CORE_ADDR best_lowpc = 0, best_highpc = 0;
psymtab_to_symtab_1 (struct partial_symtab *pst)
{
struct dwarf2_per_cu_data *per_cu;
- struct cleanup *back_to;
int i;
if (pst->readin)
void *data)
{
struct dwarf2_cu *cu = reader->cu;
- struct attribute *attr;
enum language *language_ptr = data;
gdb_assert (cu->die_hash == NULL);
bfd *sym_bfd;
int desc;
char *absolute_name;
- char *name;
desc = openp (debug_file_directory, OPF_TRY_CWD_FIRST, file_name,
O_RDONLY | O_BINARY, &absolute_name);
open_dwo_file (const char *dwo_name, const char *comp_dir)
{
bfd *abfd;
- char *path_to_try, *debug_dir;
if (IS_ABSOLUTE_PATH (dwo_name))
return try_open_dwo_file (dwo_name);
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwo_file *dwo_file;
- struct dwo_unit find_dwo_tu, *dwo_tu;
dwo_file = lookup_dwo_file (dwo_name, comp_dir);
if (dwo_file == NULL)
child_die && child_die->tag;
child_die = sibling_die (child_die))
{
- struct dwarf2_locexpr_baton *dlbaton;
struct call_site_parameter *parameter;
if (child_die->tag != DW_TAG_GNU_call_site_parameter)
void *data)
{
struct dwarf2_cu *cu = reader->cu;
- struct attribute *attr;
gdb_assert (cu->die_hash == NULL);
cu->die_hash =
{
struct addrmap_index_data *data = datap;
struct partial_symtab *pst = obj;
- offset_type cu_index;
- void **slot;
if (data->previous_valid)
add_address_entry (data->objfile, data->addr_obstack,
struct mapped_symtab *symtab;
offset_type val, size_of_contents, total_len;
struct stat st;
- char buf[8];
htab_t psyms_seen;
htab_t cu_index_htab;
struct psymtab_cu_index_map *psymtab_cu_index_map;
bfd *obfd = objfile->obfd;
const struct elf_backend_data *bed = get_elf_backend_data (obfd);
asection *plt, *relplt, *got_plt;
- unsigned u;
int plt_elf_idx;
bfd_size_type reloc_count, reloc;
char *string_buffer = NULL;
reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
for (reloc = 0; reloc < reloc_count; reloc++)
{
- const char *name, *name_got_plt;
+ const char *name;
struct minimal_symbol *msym;
CORE_ADDR address;
const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
struct type *type;
int nargs;
struct value **argvec;
- int upper, lower;
+ int lower;
int code;
int ix;
long mem_offset;
case OP_VAR_ENTRY_VALUE:
{
- struct block *b;
-
(*pos) += 2;
fprintf_filtered (stream, "%s@entry",
SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
break;
case TYPE_INSTANCE:
{
- char *elem_name;
LONGEST len;
len = exp->elts[elt++].longconst;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int i = 0; /* Number of characters printed. */
struct type *elttype;
- LONGEST val;
CORE_ADDR addr;
int index;
{
struct gdbarch_tdep *var;
int r;
- char buf[20];
var = xmalloc (sizeof (*var));
memset (var, 0, sizeof (*var));
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- CORE_ADDR pc;
- ULONGEST this_base;
struct frv_unwind_cache *info;
if ((*this_prologue_cache))
if (name2.token == NAME)
{
/* Ok, we have "name1 . name2". */
- int token;
char *copy;
copy = copy_name (current.value.sval);
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct h8300_frame_cache *cache;
- char buf[4];
int i;
CORE_ADDR current_pc;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
- ULONGEST c, addr;
+ ULONGEST c;
switch (len)
{
struct minimal_symbol *minsym;
asection *sec;
CORE_ADDR addr;
- int insn, i;
+ int insn;
minsym = lookup_minimal_symbol_by_pc (pc);
if (! minsym)
unsigned long status;
unsigned int inst;
char buf[4];
- int off;
status = target_read_memory (pc, buf, 4);
if (status != 0)
{
struct symtab_and_line sal;
CORE_ADDR func_addr, func_end;
- struct symbol *f;
/* If we can not find the symbol in the partial symbol table, then
there is no hope we can determine the function's start address
static CORE_ADDR
hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- unsigned long inst;
- int offset;
CORE_ADDR post_prologue_pc;
- char buf[4];
/* See if we can determine the end of the prologue via the symbol table.
If so, then return either PC, or the PC after the prologue, whichever
struct hppa_frame_cache *cache;
long saved_gr_mask;
long saved_fr_mask;
- CORE_ADDR this_sp;
long frame_size;
struct unwind_table_entry *u;
CORE_ADDR prologue_end;
int regnum, const void *gregs, size_t len)
{
const gdb_byte *regs = gregs;
- size_t offset;
int i;
gdb_assert (len >= HPPANBSD_SIZEOF_GREGS);
int regno, int regset, unsigned *off)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- int len;
*off = 0;
if (regset == NTO_REG_GENERAL)
{
CORE_ADDR current_pc;
int ix, i;
- gdb_byte op;
struct i386_insn *insn;
insn = i386_match_insn (pc, insn_patterns);
ULONGEST fop;
int fop_p;
int fpreg;
- int fpreg_p;
int top;
- int top_p;
gdb_assert (gdbarch == get_frame_arch (frame));
int i;
unsigned int clear_bv;
static const gdb_byte zero[MAX_REGISTER_SIZE] = { 0 };
- const gdb_byte *p;
enum
{
none = 0x0,
It can be calculated as the bsp - sof (sizeof frame). */
ULONGEST bsp, vbsp;
ULONGEST cfm;
- CORE_ADDR reg;
status = regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
if (status != REG_VALID)
return status;
ULONGEST pr;
ULONGEST cfm;
ULONGEST prN_val;
- CORE_ADDR reg;
status = regcache_cooked_read_unsigned (regcache, IA64_PR_REGNUM, &pr);
if (status != REG_VALID)
return status;
{
ULONGEST bsp;
ULONGEST cfm;
- CORE_ADDR reg;
regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct ia64_frame_cache *cache;
char buf[8];
- CORE_ADDR cfm, sof, sol, bsp, psr;
- int i;
+ CORE_ADDR cfm, psr;
if (*this_cache)
return *this_cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct ia64_frame_cache *cache;
- CORE_ADDR addr;
char buf[8];
- int i;
if (*this_cache)
return *this_cache;
jit_reader_load_command (char *args, int from_tty)
{
char *so_name;
- int len;
struct cleanup *prev_cleanup;
if (args == NULL)
static void
add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
{
- CORE_ADDR *entry_addr_ptr;
struct jit_objfile_data *objf_data;
objf_data = get_jit_objfile_data (objfile);
{
void *gdb_mem;
int status;
- struct jit_dbg_reader *i;
jit_dbg_reader_data priv_data;
struct gdb_reader_funcs *funcs;
volatile struct gdb_exception e;
jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
{
struct objfile *objf;
- CORE_ADDR *objf_entry_addr;
ALL_OBJFILES (objf)
{
{
struct jit_inferior_data *inf_data;
struct jit_unwind_private *priv_data;
- struct jit_dbg_reader *iter;
struct gdb_unwind_callbacks callbacks;
struct gdb_reader_funcs *funcs;
struct jit_code_entry cur_entry;
struct jit_inferior_data *inf_data;
CORE_ADDR cur_entry_addr;
- struct jit_objfile_data *objf_data;
if (jit_debug)
fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
VEC (typep) *superclass_vec;
VEC (const_char_ptr) *result_names;
struct collect_info info;
- char *name_iter;
/* Sort symbols so that symbols with the same program space are next
to each other. */
for (ix = 0; VEC_iterate (symtab_p, info->file_symtabs, ix, elt); ++ix)
{
- struct symbol *sym;
-
if (elt == NULL)
{
iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
{
struct cleanup *cleanup = make_cleanup (xfree, data);
const char *p = data;
- ULONGEST val;
printf_filtered (_("Process: %s\n"),
pulongest (strtoulst (p, &p, 10)));
lm32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
CORE_ADDR func_addr, limit_pc;
- struct symtab_and_line sal;
struct lm32_frame_cache frame_info;
struct trad_frame_saved_reg saved_regs[SIM_LM32_NUM_REGS];
struct type *arg_type = check_typedef (value_type (arg));
gdb_byte *contents;
int len;
- int j;
- int reg;
ULONGEST val;
/* Promote small integer types to int. */
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int offset;
ULONGEST l;
CORE_ADDR return_buffer;
static struct lm32_frame_cache *
lm32_frame_cache (struct frame_info *this_frame, void **this_prologue_cache)
{
- CORE_ADDR prologue_pc;
CORE_ADDR current_pc;
ULONGEST prev_sp;
ULONGEST this_base;
struct lm32_frame_cache *info;
- int prefixed;
- unsigned long instruction;
- int op;
- int offsets[32];
int i;
- long immediate;
if ((*this_prologue_cache))
return (*this_prologue_cache);
unsigned len;
struct type *elttype;
unsigned eltlen;
- LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
LONGEST *frame_offset)
{
const char *name;
- CORE_ADDR func_addr, func_end, sal_end;
+ CORE_ADDR func_addr, func_end;
struct m32c_prologue p;
struct regcache *regcache = get_current_regcache ();
m32r_load (char *filename, int from_tty)
{
bfd *abfd;
- asection *s;
- unsigned int i, data_count = 0;
+ unsigned int data_count = 0;
struct timeval start_time, end_time;
if (filename == NULL || filename[0] == 0)
monitor_supply_register (regcache, regno, val);
if (regno == PSW_REGNUM)
{
+#if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
+ || defined BIE_REGNUM || defined COND_REGNUM || defined CBR_REGNUM \
+ || defined BPC_REGNUM || defined BCARRY_REGNUM)
unsigned long psw = strtoul (val, NULL, 16);
char *zero = "00000000", *one = "00000001";
+#endif
#ifdef SM_REGNUM
/* Stack mode bit */
{
bfd_size_type section_size = bfd_section_size (abfd, s);
bfd_vma section_base = bfd_section_lma (abfd, s);
- unsigned int buffer;
data_count += section_size;
CORE_ADDR pc, scan_limit;
ULONGEST prev_sp;
ULONGEST this_base;
- unsigned long op, op2;
+ unsigned long op;
int i;
struct m32r_unwind_cache *info;
gdb_byte *val;
gdb_byte valbuf[MAX_REGISTER_SIZE];
int len;
- int odd_sized_struct;
/* First force sp to a 4-byte alignment. */
sp = sp & ~3;
{
struct m68k_frame_cache cache;
CORE_ADDR pc;
- int op;
cache.locals = -1;
pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- CORE_ADDR sp;
gdb_byte buf[12];
unsigned long insn0, insn1, insn2;
CORE_ADDR pc = get_frame_pc (this_frame);
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct ui_out *uiout = current_uiout;
- CORE_ADDR addr;
- enum lval_type lval;
struct value *val;
if (format == 'N')
microblaze_alloc_frame_cache (void)
{
struct microblaze_frame_cache *cache;
- int i;
cache = FRAME_OBSTACK_ZALLOC (struct microblaze_frame_cache);
const char *name;
CORE_ADDR func_addr, func_end, addr, stop, prologue_end_addr = 0;
unsigned long insn;
- int rn, rd, ra, rb, imm;
+ int rd, ra, rb, imm;
enum microblaze_instr op;
int flags = 0;
int save_hidden_pointer_found = 0;
{
struct microblaze_frame_cache *cache;
struct gdbarch *gdbarch = get_frame_arch (next_frame);
- CORE_ADDR func, pc, fp;
+ CORE_ADDR func;
int rn;
if (*this_cache)
mips_elf_fpregset_t *fpregsetp, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- char *from, *to;
+ char *to;
if ((regno >= gdbarch_fp0_regnum (gdbarch))
&& (regno < gdbarch_fp0_regnum (gdbarch) + 32))
CORE_ADDR func)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- int ireg, reg_position;
+ int ireg;
CORE_ADDR frame_sp = get_frame_sp (this_frame);
CORE_ADDR sigcontext_base;
const struct mips_regnum *regs = mips_regnum (gdbarch);
CORE_ADDR func)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- int ireg, reg_position;
+ int ireg;
CORE_ADDR frame_sp = get_frame_sp (this_frame);
CORE_ADDR sigcontext_base;
const struct mips_regnum *regs = mips_regnum (gdbarch);
{
case 2: /* Branch */
{
- CORE_ADDR offset;
struct upk_mips16 upk;
unpack_mips16 (gdbarch, pc, extension, insn, itype, &upk);
pc += (upk.offset << 1) + 2;
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- int offset;
struct value_print_options opts;
struct value *val;
static CORE_ADDR
mips_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
{
- CORE_ADDR prev_addr, next_addr;
+ CORE_ADDR prev_addr;
CORE_ADDR boundary;
CORE_ADDR func_addr;
}
else
{
- struct minimal_symbol *sym;
CORE_ADDR addr, jmpaddr;
int i;
struct mn10300_prologue *result)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- CORE_ADDR pc, next_pc;
+ CORE_ADDR pc;
int rn;
pv_t regs[MN10300_MAX_NUM_REGS];
struct pv_area *stack;
unsigned eltlen;
int length_pos, length_size, string_pos;
struct type *char_type;
- LONGEST val;
CORE_ADDR addr;
int want_space = 0;
parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
{
char *copy;
- char *s;
int n, num;
copy = xmalloc (len + 1);
static int
powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc)
{
- struct objfile *objfile;
struct minimal_symbol *sym;
/* Check whether PC is in the dynamic linker. This also checks
struct obj_section *dot_fn_section;
struct minimal_symbol *dot_fn;
struct minimal_symbol *fn;
- CORE_ADDR toc;
/* Find the minimal symbol that corresponds to CODE_ADDR (should
have a name of the form ".FN"). */
dot_fn = lookup_minimal_symbol_by_pc (code_addr);
void *data)
{
struct get_number_or_range_state state;
- struct display *b, *tmp;
int num;
if (args == NULL)
static void
undisplay_command (char *args, int from_tty)
{
- int num;
- struct get_number_or_range_state state;
-
if (args == NULL)
{
if (query (_("Delete all auto-display expressions? ")))
static void
bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
{
- volatile struct gdb_exception except;
breakpoint_object *bp_obj = (breakpoint_object *) bpfinish_obj;
PyObject *py_obj = (PyObject *) bp_obj;
PyObject *
find_inferior_object (int pid)
{
- struct inflist_entry *p;
struct inferior *inf = find_inferior_pid (pid);
if (inf)
{
struct cleanup *cleanup;
inferior_object *inf_obj;
- thread_object *thread_obj;
struct threadlist_entry **entry, *tmp;
cleanup = ensure_python_env (python_gdbarch, python_language);
thpy_switch (PyObject *self, PyObject *args)
{
thread_object *thread_obj = (thread_object *) self;
- struct cleanup *cleanup;
volatile struct gdb_exception except;
THPY_REQUIRE_VALID (thread_obj);
if (TYPE_TARGET_TYPE (type1) != NULL)
{
struct type_equality_entry entry;
- int added;
if (TYPE_TARGET_TYPE (type2) == NULL)
return Py_NE;
struct type *type = ((type_object *) self)->type;
char *field;
int i;
- volatile struct gdb_exception except;
field = python_string_to_host_string (key);
if (field == NULL)
struct type *type = ((type_object *) self)->type;
const char *field;
int i;
- volatile struct gdb_exception except;
if (!PyArg_ParseTuple (args, "s", &field))
return NULL;
{
typy_iterator_object *iter_obj = (typy_iterator_object *) self;
struct type *type = iter_obj->source->type;
- int i;
PyObject *result;
if (iter_obj->field < TYPE_NFIELDS (type))
for (i = 0; i < sals.nelts; ++i)
{
PyObject *obj;
- char *str;
obj = symtab_and_line_to_sal_object (sals.sals[i]);
if (! obj)
gdbpy_run_events (struct serial *scb, void *context)
{
struct cleanup *cleanup;
- int r;
cleanup = ensure_python_env (get_current_arch (), current_language);
long target_fd, num;
LONGEST lnum;
CORE_ADDR ptrval;
- int fd, ret, retlength;
+ int fd, ret;
gdb_byte *buffer;
size_t length;
off_t old_offset, new_offset;
remote_fileio_func_fstat (char *buf)
{
CORE_ADDR ptrval;
- int fd, ret, retlength;
+ int fd, ret;
long target_fd;
LONGEST lnum;
struct stat st;
{
LONGEST lnum;
CORE_ADDR ptrval;
- int ret, retlength;
+ int ret;
struct timeval tv;
struct fio_timeval ftv;
remote_fileio_func_system (char *buf)
{
CORE_ADDR ptrval;
- int ret, length, retlength;
+ int ret, length;
char *cmdline = NULL;
/* Parameter: Ptr to commandline / length incl. trailing zero */
static int
send_data (void *buf, int len)
{
- int ret;
-
if (!sdi_desc)
return -1;
int ib_breakpoints;
long i;
unsigned char buf[13];
- unsigned long val;
int ret, c;
if (remote_debug)
int nostart;
struct timeval start_time, end_time;
unsigned long data_count; /* Number of bytes transferred to memory. */
- int ret;
static RETSIGTYPE (*prev_sigint) ();
/* for direct tcp connections, we can do a fast binary download. */
enum mips_monitor_type new_monitor,
const char *new_monitor_prompt)
{
- char *ptype;
char *serial_port_name;
char *remote_name = 0;
char *local_name = 0;
ULONGEST rpc, rfp, rsp;
char pc_string[17], fp_string[17], sp_string[17], flags[20];
int nfields;
- int i;
interrupt_count = 0;
hit_watchpoint = 0;
static void
delete_bookmark_command (char *args, int from_tty)
{
- struct bookmark *b;
int num;
struct get_number_or_range_state state;
struct type *value_type = value_enclosing_type (args[i]);
int len = TYPE_LENGTH (value_type);
int container_len = (len + 1) & ~1;
- int offset;
sp -= container_len;
write_memory (rl78_make_data_address (sp),
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- gdb_byte buf[8];
/* The calling convention this function implements assumes the
processor has floating-point registers. We shouldn't be using it
enum bfd_architecture arch;
unsigned long mach;
bfd abfd;
- asection *sect;
enum auto_boolean soft_float_flag = powerpc_soft_float_global;
int soft_float;
enum powerpc_vector_abi vector_abi = powerpc_vector_abi_global;
{
pv_t addr = s390_addr (data, d2, x2, b2);
- pv_t offset;
/* If it's a load from an in-line constant pool, then we can
simulate that, under the assumption that the code isn't
#define EXTRACT_LEN 2
CORE_ADDR adjust_pc = *pcptr & ~0x1;
- int inst_len;
gdb_byte buf[5][EXTRACT_LEN] =
{
{'\0', '\0'},
CORE_ADDR func_pc,
CORE_ADDR current_pc)
{
- int reg_nr;
int pc;
int opc;
int insn;
CORE_ADDR regval;
char *val;
char valbuf[8];
- char valbuf_tmp[8];
int len;
int argreg_size;
int fp_args[12];
/* Decode arg. We set funfirstline=1 so decode_line_1 will give us the
first line of the function specified, if it can, and so that we'll
reject variable names and the like. */
-
- int i;
- int pending = 0;
char *orig_arg = arg; /* decode_line_1 modifies the arg pointer. */
volatile struct gdb_exception decode_exception;
struct symtabs_and_lines sals = { 0 };
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int ptr_len = TYPE_LENGTH (ptr_type);
unsigned int image_info_size;
- CORE_ADDR lm;
struct so_list *head = NULL;
struct so_list *tail = NULL;
int i;
struct int_elf32_dsbt_loadmap *int_ldmbuf;
int version, seg, nsegs;
- int ext_ldmbuf_size, int_ldmbuf_size;
+ int int_ldmbuf_size;
ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf;
unsigned int interp_sect_size;
gdb_byte *buf;
bfd *tmp_bfd = NULL;
- int status;
- CORE_ADDR addr, interp_loadmap_addr;
+ CORE_ADDR addr;
gdb_byte addr_buf[TIC6X_PTR_SIZE];
struct int_elf32_dsbt_loadmap *ldm;
volatile struct gdb_exception ex;
static void
dsbt_relocate_main_executable (void)
{
- int status;
- CORE_ADDR exec_addr, interp_addr;
struct int_elf32_dsbt_loadmap *ldm;
struct cleanup *old_chain;
struct section_offsets *new_offsets;
CORE_ADDR got_value;
struct int_elf32_fdpic_loadmap *ldm = 0;
struct symbol *sym;
- int status;
- CORE_ADDR exec_loadmap_addr;
/* Fetch the corresponding global pointer for the entry point. */
got_value = frv_fdpic_find_global_pointer (entry_point);
sparc_alloc_frame_cache (void)
{
struct sparc_frame_cache *cache;
- int i;
cache = FRAME_OBSTACK_ZALLOC (struct sparc_frame_cache);
struct gdbarch_tdep *tdep;
struct regcache *regcache;
char buf[4];
- CORE_ADDR pc;
ULONGEST regval;
/* If we're not on PPU, there's nothing to detect. */
CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
bfd_byte buf[4];
unsigned int insn;
- int rt, ra, rb, rc, immed;
+ int rt, ra, rb, immed;
/* Find the search limits based on function boundaries and hard limit.
We assume the epilogue can be up to 64 instructions long. */
gdb_byte buf[100];
char annex[32];
LONGEST len;
- int rc, id;
+ int id;
if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
char annex[32];
gdb_byte buf[100];
LONGEST len;
- int rc, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
ULONGEST mfc_cq_dw1;
ULONGEST mfc_cq_dw2;
int mfc_cmd_opcode, mfc_cmd_tag, rclass_id, tclass_id;
- int lsa, size, list_lsa, list_size, mfc_lsa, mfc_size;
+ int list_lsa, list_size, mfc_lsa, mfc_size;
ULONGEST mfc_ea;
int list_valid_p, noop_valid_p, qw_valid_p, ea_valid_p, cmd_error_p;
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
long highest_offset = -1;
/* Number of ints of arguments that we have printed so far. */
int args_printed = 0;
- struct cleanup *old_chain, *list_chain;
+ struct cleanup *old_chain;
struct ui_file *stb;
/* True if we should print arguments, false otherwise. */
int print_args = strcmp (print_frame_arguments, "none");
{
const struct other_sections *a = *((struct other_sections **) ap);
const struct other_sections *b = *((struct other_sections **) bp);
- int retval, a_idx, b_idx;
+ int retval;
retval = strcmp (addr_section_name (a->name), addr_section_name (b->name));
if (retval)
int search_len)
{
int len = strlen (filename);
- int offset;
if (len < search_len)
return 0;
struct symtab *after_last)
{
struct symtab *s = NULL;
- struct cleanup *cleanup;
const char* base_name = lbasename (name);
int name_len = strlen (name);
int is_abs = IS_ABSOLUTE_PATH (name);
struct symbol *sym;
struct objfile *objfile;
struct minimal_symbol *msymbol;
- char *val;
int found_misc = 0;
static const enum minimal_symbol_type types[]
= {mst_data, mst_text, mst_abs};
static CORE_ADDR
tic6x_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
{
- CORE_ADDR limit_pc;
CORE_ADDR func_addr;
struct tic6x_unwind_cache cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR current_pc;
struct tic6x_unwind_cache *cache;
- int i;
if (*this_prologue_cache)
return *this_prologue_cache;
{
struct gdbarch *gdbarch = get_frame_arch (frame);
unsigned long inst;
- int offset;
int register_number;
int last = 0;
struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- char block_type;
- int pos, offset, regn, regsize, pc_regno;
- unsigned short mlen;
+ int offset, regn, regsize, pc_regno;
char *regs;
/* An uninitialized reg size says we're not going to be
CORE_ADDR prologue_end, current_pc;
struct pifsr pifsrs[E_NUM_REGS + 1];
struct pifsr *pifsr, *pifsr_tmp;
- int fp_used;
int ep_used;
int reg;
CORE_ADDR save_pc, save_end;
v850_alloc_frame_cache (struct frame_info *this_frame)
{
struct v850_frame_cache *cache;
- int i;
cache = FRAME_OBSTACK_ZALLOC (struct v850_frame_cache);
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
{
struct value *val, *tmp, *mark;
- struct type *type1, *type2, *eltype1, *eltype2, *result_type;
+ struct type *type1, *type2, *eltype1, *eltype2;
int t1_is_vec, t2_is_vec, elsize, i;
LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
unsigned len;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
- unsigned eltlen;
LONGEST val;
CORE_ADDR addr;
int *real_type_found)
{
struct value_print_options opts;
- struct value *target;
struct type *result;
get_user_print_options (&opts);
int n_scnum,
struct objfile *objfile)
{
- struct find_targ_sec_arg args;
int secnum;
asection *bfd_sect;
&& (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15))
{
gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
- unsigned int wb;
regcache_raw_read (regcache,
gdbarch_tdep (gdbarch)->wb_regnum, buf);
void (*func) (struct gdbarch *, int, int, int, CORE_ADDR);
int at, as, offset;
- int num_operands;
/* WindowUnderflow12 = true, when inside _WindowUnderflow12. */
int WindowUnderflow12 = (current_pc & 0x1ff) >= 0x140;
projects / binutils-gdb.git / commitdiff