gdb, gdbserver, gdbsupport: fix whitespace issues
Replace spaces with tabs in a bunch of places. Change-Id: If0f87180f1d13028dc178e5a8af7882a067868b0
This commit is contained in:
+7
-7
@@ -304,10 +304,10 @@ ptrace_check (int req, int id, int ret)
|
||||
break;
|
||||
case PTT_READ_VEC:
|
||||
case PTT_READ_VSX:
|
||||
if (debug_aix_thread)
|
||||
gdb_printf (gdb_stdlog,
|
||||
"ptrace (%d, %d) = %d (errno = %d)\n",
|
||||
req, id, ret, errno);
|
||||
if (debug_aix_thread)
|
||||
gdb_printf (gdb_stdlog,
|
||||
"ptrace (%d, %d) = %d (errno = %d)\n",
|
||||
req, id, ret, errno);
|
||||
if (ret == -1)
|
||||
return -1;
|
||||
break;
|
||||
@@ -1505,9 +1505,9 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
|
||||
else
|
||||
ret = ptrace32 (PTT_READ_VSX, tid, (long long) &vsx, 0, 0);
|
||||
if (ret < 0)
|
||||
memset(&vsx, 0, sizeof(__vsx_context_t));
|
||||
memset(&vsx, 0, sizeof(__vsx_context_t));
|
||||
for (i = 0; i < ppc_num_vshrs; i++)
|
||||
regcache->raw_supply (tdep->ppc_vsr0_upper_regnum + i, &(vsx.__vsr_dw1[i]));
|
||||
regcache->raw_supply (tdep->ppc_vsr0_upper_regnum + i, &(vsx.__vsr_dw1[i]));
|
||||
}
|
||||
|
||||
/* Floating-point registers. */
|
||||
@@ -1609,7 +1609,7 @@ fill_vsx (const struct regcache *regcache, __vsx_context_t *vsx)
|
||||
for (regno = 0; regno < ppc_num_vshrs; regno++)
|
||||
if (REG_VALID == regcache->get_register_status ( tdep->ppc_vsr0_upper_regnum + regno))
|
||||
regcache->raw_collect (tdep->ppc_vsr0_upper_regnum + regno,
|
||||
&(vsx->__vsr_dw1[0]) + regno);
|
||||
&(vsx->__vsr_dw1[0]) + regno);
|
||||
}
|
||||
|
||||
/* Store the gp registers into an array of uint32_t or uint64_t. */
|
||||
|
||||
@@ -146,7 +146,7 @@ const struct regset amd64_fbsd_segbases_regset =
|
||||
__sighandler_t *sf_handler;
|
||||
} sf_ahu;
|
||||
ucontext_t sf_uc;
|
||||
...
|
||||
...
|
||||
}
|
||||
|
||||
ucontext_t is defined as:
|
||||
|
||||
+1
-1
@@ -2549,7 +2549,7 @@ amd64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
|
||||
&& cust->producer () != nullptr
|
||||
&& (producer_is_llvm (cust->producer ())
|
||||
|| producer_is_icc_ge_19 (cust->producer ()))))
|
||||
return std::max (start_pc, post_prologue_pc);
|
||||
return std::max (start_pc, post_prologue_pc);
|
||||
}
|
||||
|
||||
amd64_init_frame_cache (&cache);
|
||||
|
||||
@@ -377,23 +377,23 @@ handle_atomic_sequence (arc_instruction insn, disassemble_info *di)
|
||||
di, arc_delayed_print_insn, &insn);
|
||||
|
||||
if (insn.insn_class == BRCC)
|
||||
{
|
||||
/* If more than one conditional branch is found, this is not
|
||||
the pattern we are interested in. */
|
||||
if (found_bc)
|
||||
{
|
||||
/* If more than one conditional branch is found, this is not
|
||||
the pattern we are interested in. */
|
||||
if (found_bc)
|
||||
break;
|
||||
found_bc = true;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* This is almost a happy ending. */
|
||||
if (insn.insn_class == SCOND)
|
||||
{
|
||||
{
|
||||
/* SCOND should match the LLOCK's data size. */
|
||||
if (insn.data_size_mode == llock_data_size_mode)
|
||||
is_pattern_valid = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (is_pattern_valid)
|
||||
|
||||
+1
-1
@@ -3876,7 +3876,7 @@ arm_m_exception_prev_register (frame_info_ptr this_frame,
|
||||
prev_regnum);
|
||||
CORE_ADDR pc = value_as_address (value);
|
||||
return frame_unwind_got_constant (this_frame, prev_regnum,
|
||||
UNMAKE_THUMB_ADDR (pc));
|
||||
UNMAKE_THUMB_ADDR (pc));
|
||||
}
|
||||
|
||||
/* The value might be one of the alternative SP, if so, use the
|
||||
|
||||
+2
-2
@@ -1537,8 +1537,8 @@ _initialize_auto_load ()
|
||||
const char *suffix;
|
||||
|
||||
gdb::observers::new_objfile.attach (auto_load_new_objfile,
|
||||
auto_load_new_objfile_observer_token,
|
||||
"auto-load");
|
||||
auto_load_new_objfile_observer_token,
|
||||
"auto-load");
|
||||
add_setshow_boolean_cmd ("gdb-scripts", class_support,
|
||||
&auto_load_gdb_scripts, _("\
|
||||
Enable or disable auto-loading of canned sequences of commands scripts."), _("\
|
||||
|
||||
+2
-2
@@ -6376,7 +6376,7 @@ print_one_breakpoint_location (struct breakpoint *b,
|
||||
without a footnote. On the CLI, for enabled locations whose
|
||||
breakpoint is disabled, display "y-". */
|
||||
auto get_enable_state = [uiout, loc] () -> const char *
|
||||
{
|
||||
{
|
||||
if (uiout->is_mi_like_p ())
|
||||
{
|
||||
if (loc->disabled_by_cond)
|
||||
@@ -6613,7 +6613,7 @@ print_one_breakpoint_location (struct breakpoint *b,
|
||||
|
||||
bool use_fixed_output =
|
||||
(uiout->test_flags (fix_breakpoint_script_output)
|
||||
|| fix_breakpoint_script_output_globally);
|
||||
|| fix_breakpoint_script_output_globally);
|
||||
|
||||
gdb::optional<ui_out_emit_tuple> tuple_emitter;
|
||||
gdb::optional<ui_out_emit_list> list_emitter;
|
||||
|
||||
@@ -52,7 +52,7 @@ static void do_define_command (const char *comname, int from_tty,
|
||||
const counted_command_line *commands);
|
||||
|
||||
static void do_document_command (const char *comname, int from_tty,
|
||||
const counted_command_line *commands);
|
||||
const counted_command_line *commands);
|
||||
|
||||
static const char *read_next_line (std::string &buffer);
|
||||
|
||||
@@ -1509,7 +1509,7 @@ define_command (const char *comname, int from_tty)
|
||||
command and the commands are provided. */
|
||||
static void
|
||||
do_document_command (const char *comname, int from_tty,
|
||||
const counted_command_line *commands)
|
||||
const counted_command_line *commands)
|
||||
{
|
||||
struct cmd_list_element *alias, *prefix_cmd, *c;
|
||||
const char *comfull;
|
||||
@@ -1540,7 +1540,7 @@ do_document_command (const char *comname, int from_tty,
|
||||
if (commands == nullptr)
|
||||
{
|
||||
std::string prompt
|
||||
= string_printf ("Type documentation for \"%s\".", comfull);
|
||||
= string_printf ("Type documentation for \"%s\".", comfull);
|
||||
doclines = read_command_lines (prompt.c_str (), from_tty, 0, 0);
|
||||
}
|
||||
else
|
||||
@@ -1696,7 +1696,7 @@ _initialize_cli_script ()
|
||||
as this helps the user to either type the command name and/or
|
||||
its prefixes. */
|
||||
document_cmd_element = add_com ("document", class_support, document_command,
|
||||
_("\
|
||||
_("\
|
||||
Document a user-defined command or user-defined alias.\n\
|
||||
Give command or alias name as argument. Give documentation on following lines.\n\
|
||||
End with a line of just \"end\"."));
|
||||
|
||||
+164
-164
@@ -430,23 +430,23 @@ csky_get_supported_register_by_index (int index)
|
||||
switch (multi)
|
||||
{
|
||||
case 0: /* Bank1. */
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp1cr%d", remain);
|
||||
tdesc_reg.num = 189 + remain;
|
||||
}
|
||||
break;
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp1cr%d", remain);
|
||||
tdesc_reg.num = 189 + remain;
|
||||
}
|
||||
break;
|
||||
case 1: /* Bank2. */
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp2cr%d", remain);
|
||||
tdesc_reg.num = 276 + remain;
|
||||
}
|
||||
break;
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp2cr%d", remain);
|
||||
tdesc_reg.num = 276 + remain;
|
||||
}
|
||||
break;
|
||||
case 2: /* Bank3. */
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp3cr%d", remain);
|
||||
tdesc_reg.num = 221 + remain;
|
||||
}
|
||||
break;
|
||||
{
|
||||
sprintf (tdesc_reg.name, "cp3cr%d", remain);
|
||||
tdesc_reg.num = 221 + remain;
|
||||
}
|
||||
break;
|
||||
case 3: /* Bank4. */
|
||||
case 4: /* Bank5. */
|
||||
case 5: /* Bank6. */
|
||||
@@ -458,12 +458,12 @@ csky_get_supported_register_by_index (int index)
|
||||
case 11: /* Bank12. */
|
||||
case 12: /* Bank13. */
|
||||
case 13: /* Bank14. */
|
||||
{
|
||||
/* Regitsers in Bank4~14 have continuous regno with start 308. */
|
||||
sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 1), remain);
|
||||
tdesc_reg.num = 308 + ((multi - 3) * 32) + remain;
|
||||
}
|
||||
break;
|
||||
{
|
||||
/* Regitsers in Bank4~14 have continuous regno with start 308. */
|
||||
sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 1), remain);
|
||||
tdesc_reg.num = 308 + ((multi - 3) * 32) + remain;
|
||||
}
|
||||
break;
|
||||
case 14: /* Bank16. */
|
||||
case 15: /* Bank17. */
|
||||
case 16: /* Bank18. */
|
||||
@@ -480,14 +480,14 @@ csky_get_supported_register_by_index (int index)
|
||||
case 27: /* Bank29. */
|
||||
case 28: /* Bank30. */
|
||||
case 29: /* Bank31. */
|
||||
{
|
||||
/* Regitsers in Bank16~31 have continuous regno with start 660. */
|
||||
sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 2), remain);
|
||||
tdesc_reg.num = 660 + ((multi - 14) * 32) + remain;
|
||||
}
|
||||
break;
|
||||
{
|
||||
/* Regitsers in Bank16~31 have continuous regno with start 660. */
|
||||
sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 2), remain);
|
||||
tdesc_reg.num = 660 + ((multi - 14) * 32) + remain;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
return &tdesc_reg;
|
||||
}
|
||||
@@ -723,7 +723,7 @@ csky_register_type (struct gdbarch *gdbarch, int reg_nr)
|
||||
{
|
||||
struct type *tdesc_t = tdesc_register_type (gdbarch, reg_nr);
|
||||
if (tdesc_t)
|
||||
return tdesc_t;
|
||||
return tdesc_t;
|
||||
}
|
||||
|
||||
/* PC, EPC, FPC is a text pointer. */
|
||||
@@ -2414,7 +2414,7 @@ csky_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
|
||||
if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
|
||||
{
|
||||
if (tdesc_register_in_reggroup_p (gdbarch, regnum, reggroup) > 0)
|
||||
return 7;
|
||||
return 7;
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -2440,9 +2440,9 @@ csky_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dw_reg)
|
||||
char name_buf[4];
|
||||
|
||||
xsnprintf (name_buf, sizeof (name_buf), "s%d",
|
||||
dw_reg - FV_PSEUDO_REGNO_FIRST);
|
||||
dw_reg - FV_PSEUDO_REGNO_FIRST);
|
||||
return user_reg_map_name_to_regnum (gdbarch, name_buf,
|
||||
strlen (name_buf));
|
||||
strlen (name_buf));
|
||||
}
|
||||
|
||||
/* Others, unknown. */
|
||||
@@ -2475,8 +2475,8 @@ csky_fr0_fr15_reg_check (const struct csky_supported_tdesc_register *reg) {
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
if ((strcmp (reg->name, csky_supported_fpu_regs[i].name) == 0)
|
||||
&& (csky_supported_fpu_regs[i].num == reg->num))
|
||||
return (1 << i);
|
||||
&& (csky_supported_fpu_regs[i].num == reg->num))
|
||||
return (1 << i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -2490,8 +2490,8 @@ csky_fr16_fr31_reg_check (const struct csky_supported_tdesc_register *reg) {
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
if ((strcmp (reg->name, csky_supported_fpu_regs[i + 16].name) == 0)
|
||||
&& (csky_supported_fpu_regs[i + 16].num == reg->num))
|
||||
return (1 << i);
|
||||
&& (csky_supported_fpu_regs[i + 16].num == reg->num))
|
||||
return (1 << i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -2505,8 +2505,8 @@ csky_vr0_vr15_reg_check (const struct csky_supported_tdesc_register *reg) {
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
if ((strcmp (reg->name, csky_supported_fpu_regs[i + 32].name) == 0)
|
||||
&& (csky_supported_fpu_regs[i + 32].num == reg->num))
|
||||
return (1 << i);
|
||||
&& (csky_supported_fpu_regs[i + 32].num == reg->num))
|
||||
return (1 << i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -2526,33 +2526,33 @@ csky_pseudo_register_name (struct gdbarch *gdbarch, int regno)
|
||||
if (tdep->fv_pseudo_registers_count)
|
||||
{
|
||||
static const char *const fv_pseudo_names[] = {
|
||||
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
|
||||
"s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
|
||||
"s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
|
||||
"s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
|
||||
"s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
|
||||
"s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
|
||||
"s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
|
||||
"s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
|
||||
"s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
|
||||
"s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
|
||||
"s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
|
||||
"s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
|
||||
"s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
|
||||
"s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
|
||||
"s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
|
||||
"s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
|
||||
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
|
||||
"s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
|
||||
"s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
|
||||
"s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
|
||||
"s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
|
||||
"s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
|
||||
"s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
|
||||
"s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
|
||||
"s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
|
||||
"s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
|
||||
"s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
|
||||
"s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
|
||||
"s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
|
||||
"s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
|
||||
"s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
|
||||
"s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
|
||||
};
|
||||
|
||||
if (regno < tdep->fv_pseudo_registers_count)
|
||||
{
|
||||
if ((regno < 64) && ((regno % 4) >= 2) && !tdep->has_vr0)
|
||||
return "";
|
||||
else if ((regno >= 64) && ((regno % 4) >= 2))
|
||||
return "";
|
||||
else
|
||||
return fv_pseudo_names[regno];
|
||||
}
|
||||
{
|
||||
if ((regno < 64) && ((regno % 4) >= 2) && !tdep->has_vr0)
|
||||
return "";
|
||||
else if ((regno >= 64) && ((regno % 4) >= 2))
|
||||
return "";
|
||||
else
|
||||
return fv_pseudo_names[regno];
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
@@ -2562,8 +2562,8 @@ csky_pseudo_register_name (struct gdbarch *gdbarch, int regno)
|
||||
|
||||
static enum register_status
|
||||
csky_pseudo_register_read (struct gdbarch *gdbarch,
|
||||
struct readable_regcache *regcache,
|
||||
int regnum, gdb_byte *buf)
|
||||
struct readable_regcache *regcache,
|
||||
int regnum, gdb_byte *buf)
|
||||
{
|
||||
int num_regs = gdbarch_num_regs (gdbarch);
|
||||
csky_gdbarch_tdep *tdep
|
||||
@@ -2580,31 +2580,31 @@ csky_pseudo_register_read (struct gdbarch *gdbarch,
|
||||
|
||||
/* Ensure getting s0~s63 from vrx if tdep->has_vr0 is ture. */
|
||||
if (tdep->has_vr0)
|
||||
{
|
||||
if (regnum < 64)
|
||||
{
|
||||
gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
|
||||
offset = (regnum % 4) * 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return REG_UNAVAILABLE;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
}
|
||||
{
|
||||
if (regnum < 64)
|
||||
{
|
||||
gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
|
||||
offset = (regnum % 4) * 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return REG_UNAVAILABLE;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return REG_UNAVAILABLE;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
{
|
||||
gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return REG_UNAVAILABLE;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
|
||||
status = regcache->raw_read (gdb_regnum, reg_buf);
|
||||
if (status == REG_VALID)
|
||||
memcpy (buf, reg_buf + offset, 4);
|
||||
memcpy (buf, reg_buf + offset, 4);
|
||||
return status;
|
||||
}
|
||||
|
||||
@@ -2615,7 +2615,7 @@ csky_pseudo_register_read (struct gdbarch *gdbarch,
|
||||
|
||||
static void
|
||||
csky_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
|
||||
int regnum, const gdb_byte *buf)
|
||||
int regnum, const gdb_byte *buf)
|
||||
{
|
||||
int num_regs = gdbarch_num_regs (gdbarch);
|
||||
csky_gdbarch_tdep *tdep
|
||||
@@ -2630,27 +2630,27 @@ csky_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
|
||||
int offset = 0;
|
||||
|
||||
if (tdep->has_vr0)
|
||||
{
|
||||
if (regnum < 64)
|
||||
{
|
||||
gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
|
||||
offset = (regnum % 4) * 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
}
|
||||
{
|
||||
if (regnum < 64)
|
||||
{
|
||||
gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
|
||||
offset = (regnum % 4) * 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
{
|
||||
gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
|
||||
if ((regnum % 4) >= 2)
|
||||
return;
|
||||
offset = (regnum % 2) * 4;
|
||||
}
|
||||
|
||||
regcache->raw_read (gdb_regnum, reg_buf);
|
||||
memcpy (reg_buf + offset, buf, 4);
|
||||
@@ -2690,38 +2690,38 @@ csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
int i = 0;
|
||||
int feature_names_count = ARRAY_SIZE (csky_supported_tdesc_feature_names);
|
||||
int support_tdesc_regs_count
|
||||
= csky_get_supported_tdesc_registers_count();
|
||||
= csky_get_supported_tdesc_registers_count();
|
||||
const struct csky_supported_tdesc_register *tdesc_reg;
|
||||
const struct tdesc_feature *feature;
|
||||
|
||||
tdesc_data = tdesc_data_alloc ();
|
||||
for (index = 0; index < feature_names_count; index ++)
|
||||
{
|
||||
feature = tdesc_find_feature (info.target_desc,
|
||||
csky_supported_tdesc_feature_names[index]);
|
||||
if (feature != NULL)
|
||||
{
|
||||
for (i = 0; i < support_tdesc_regs_count; i++)
|
||||
{
|
||||
tdesc_reg = csky_get_supported_register_by_index (i);
|
||||
if (!tdesc_reg)
|
||||
break;
|
||||
numbered = tdesc_numbered_register (feature, tdesc_data.get(),
|
||||
tdesc_reg->num,
|
||||
tdesc_reg->name);
|
||||
if (numbered) {
|
||||
valid_p |= csky_essential_reg_check (tdesc_reg);
|
||||
has_fr0 |= csky_fr0_fr15_reg_check (tdesc_reg);
|
||||
has_fr16 |= csky_fr16_fr31_reg_check (tdesc_reg);
|
||||
has_vr0 |= csky_vr0_vr15_reg_check (tdesc_reg);
|
||||
if (num_regs < tdesc_reg->num)
|
||||
num_regs = tdesc_reg->num;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
feature = tdesc_find_feature (info.target_desc,
|
||||
csky_supported_tdesc_feature_names[index]);
|
||||
if (feature != NULL)
|
||||
{
|
||||
for (i = 0; i < support_tdesc_regs_count; i++)
|
||||
{
|
||||
tdesc_reg = csky_get_supported_register_by_index (i);
|
||||
if (!tdesc_reg)
|
||||
break;
|
||||
numbered = tdesc_numbered_register (feature, tdesc_data.get(),
|
||||
tdesc_reg->num,
|
||||
tdesc_reg->name);
|
||||
if (numbered) {
|
||||
valid_p |= csky_essential_reg_check (tdesc_reg);
|
||||
has_fr0 |= csky_fr0_fr15_reg_check (tdesc_reg);
|
||||
has_fr16 |= csky_fr16_fr31_reg_check (tdesc_reg);
|
||||
has_vr0 |= csky_vr0_vr15_reg_check (tdesc_reg);
|
||||
if (num_regs < tdesc_reg->num)
|
||||
num_regs = tdesc_reg->num;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (valid_p != CSKY_TDESC_REGS_ESSENTIAL_VALUE)
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* When the type of bfd file is srec(or any files are not elf),
|
||||
@@ -2730,14 +2730,14 @@ csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
{
|
||||
/* Get FPU, VDSP build options. */
|
||||
fpu_abi = bfd_elf_get_obj_attr_int (info.abfd,
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_FPU_ABI);
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_FPU_ABI);
|
||||
vdsp_version = bfd_elf_get_obj_attr_int (info.abfd,
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_VDSP_VERSION);
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_VDSP_VERSION);
|
||||
fpu_hardfp = bfd_elf_get_obj_attr_int (info.abfd,
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_FPU_HARDFP);
|
||||
OBJ_ATTR_PROC,
|
||||
Tag_CSKY_FPU_HARDFP);
|
||||
}
|
||||
|
||||
/* Find a candidate among the list of pre-declared architectures. */
|
||||
@@ -2748,11 +2748,11 @@ csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
csky_gdbarch_tdep *tdep
|
||||
= gdbarch_tdep<csky_gdbarch_tdep> (arches->gdbarch);
|
||||
if (fpu_abi != tdep->fpu_abi)
|
||||
continue;
|
||||
continue;
|
||||
if (vdsp_version != tdep->vdsp_version)
|
||||
continue;
|
||||
continue;
|
||||
if (fpu_hardfp != tdep->fpu_hardfp)
|
||||
continue;
|
||||
continue;
|
||||
|
||||
/* Found a match. */
|
||||
return arches->gdbarch;
|
||||
@@ -2771,28 +2771,28 @@ csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
if (tdesc_data != NULL)
|
||||
{
|
||||
if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
|
||||
&& (has_fr16 == CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 1;
|
||||
tdep->fv_pseudo_registers_count = 128;
|
||||
}
|
||||
&& (has_fr16 == CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 1;
|
||||
tdep->fv_pseudo_registers_count = 128;
|
||||
}
|
||||
else if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
|
||||
&& (has_fr16 != CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 1;
|
||||
tdep->fv_pseudo_registers_count = 64;
|
||||
}
|
||||
&& (has_fr16 != CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 1;
|
||||
tdep->fv_pseudo_registers_count = 64;
|
||||
}
|
||||
else if ((has_fr0 == CSKY_FULL16_ONEHOT_VALUE)
|
||||
&& (has_vr0 != CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 0;
|
||||
tdep->fv_pseudo_registers_count = 64;
|
||||
}
|
||||
&& (has_vr0 != CSKY_FULL16_ONEHOT_VALUE))
|
||||
{
|
||||
tdep->has_vr0 = 0;
|
||||
tdep->fv_pseudo_registers_count = 64;
|
||||
}
|
||||
else
|
||||
{
|
||||
tdep->has_vr0 = 0;
|
||||
tdep->fv_pseudo_registers_count = 0;
|
||||
}
|
||||
{
|
||||
tdep->has_vr0 = 0;
|
||||
tdep->fv_pseudo_registers_count = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2860,17 +2860,17 @@ csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
tdesc_use_registers (gdbarch, info.target_desc, std::move (tdesc_data));
|
||||
set_gdbarch_register_type (gdbarch, csky_register_type);
|
||||
set_gdbarch_register_reggroup_p (gdbarch,
|
||||
csky_register_reggroup_p);
|
||||
csky_register_reggroup_p);
|
||||
}
|
||||
|
||||
if (tdep->fv_pseudo_registers_count)
|
||||
{
|
||||
set_gdbarch_num_pseudo_regs (gdbarch,
|
||||
tdep->fv_pseudo_registers_count);
|
||||
tdep->fv_pseudo_registers_count);
|
||||
set_gdbarch_pseudo_register_read (gdbarch,
|
||||
csky_pseudo_register_read);
|
||||
csky_pseudo_register_read);
|
||||
set_gdbarch_pseudo_register_write (gdbarch,
|
||||
csky_pseudo_register_write);
|
||||
csky_pseudo_register_write);
|
||||
set_tdesc_pseudo_register_name (gdbarch, csky_pseudo_register_name);
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -1105,7 +1105,7 @@ darwin_nat_target::decode_message (mach_msg_header_t *hdr,
|
||||
if (WIFEXITED (wstatus))
|
||||
{
|
||||
status->set_exited (WEXITSTATUS (wstatus));
|
||||
inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
|
||||
inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
|
||||
res_pid, wstatus);
|
||||
}
|
||||
else if (WIFSTOPPED (wstatus))
|
||||
@@ -1128,7 +1128,7 @@ darwin_nat_target::decode_message (mach_msg_header_t *hdr,
|
||||
{
|
||||
status->set_ignore ();
|
||||
warning (_("Unexpected wait status after MACH_NOTIFY_DEAD_NAME "
|
||||
"notification: 0x%x"), wstatus);
|
||||
"notification: 0x%x"), wstatus);
|
||||
return minus_one_ptid;
|
||||
}
|
||||
|
||||
|
||||
+14
-14
@@ -3958,15 +3958,15 @@ read_cutu_die_from_dwo (dwarf2_cu *cu,
|
||||
cu->addr_base = stub_comp_unit_die->addr_base ();
|
||||
|
||||
/* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
|
||||
We need the value before we can process DW_AT_ranges values from the
|
||||
DWO. */
|
||||
We need the value before we can process DW_AT_ranges values from the
|
||||
DWO. */
|
||||
cu->gnu_ranges_base = stub_comp_unit_die->gnu_ranges_base ();
|
||||
|
||||
/* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
|
||||
there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
|
||||
need the rnglists base. Attributes of form DW_FORM_rnglistx in the
|
||||
split unit don't use it, as the DWO has its own .debug_rnglists.dwo
|
||||
section. */
|
||||
there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
|
||||
need the rnglists base. Attributes of form DW_FORM_rnglistx in the
|
||||
split unit don't use it, as the DWO has its own .debug_rnglists.dwo
|
||||
section. */
|
||||
cu->rnglists_base = stub_comp_unit_die->rnglists_base ();
|
||||
}
|
||||
else if (stub_comp_dir != NULL)
|
||||
@@ -11576,17 +11576,17 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die,
|
||||
&& !die_is_declaration (die, cu))
|
||||
{
|
||||
if (die->tag == DW_TAG_namelist_item)
|
||||
{
|
||||
{
|
||||
/* Typically, DW_TAG_namelist_item are references to namelist items.
|
||||
If so, follow that reference. */
|
||||
struct attribute *attr1 = dwarf2_attr (die, DW_AT_namelist_item, cu);
|
||||
struct die_info *item_die = nullptr;
|
||||
struct dwarf2_cu *item_cu = cu;
|
||||
if (attr1->form_is_ref ())
|
||||
if (attr1->form_is_ref ())
|
||||
item_die = follow_die_ref (die, attr1, &item_cu);
|
||||
if (item_die != nullptr)
|
||||
die = item_die;
|
||||
}
|
||||
}
|
||||
/* Data member other than a C++ static data member. */
|
||||
|
||||
/* Get type of field. */
|
||||
@@ -16452,8 +16452,8 @@ cooked_indexer::index_dies (cutu_reader *reader,
|
||||
have linkage name present but name is absent. */
|
||||
if (name != nullptr
|
||||
|| (abbrev->tag != DW_TAG_subprogram
|
||||
&& abbrev->tag != DW_TAG_inlined_subroutine
|
||||
&& abbrev->tag != DW_TAG_entry_point))
|
||||
&& abbrev->tag != DW_TAG_inlined_subroutine
|
||||
&& abbrev->tag != DW_TAG_entry_point))
|
||||
flags = flags | IS_LINKAGE;
|
||||
m_index_storage->add (this_die, abbrev->tag, flags,
|
||||
linkage_name, nullptr, m_per_cu);
|
||||
@@ -17555,7 +17555,7 @@ read_dwo_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
|
||||
if (reader->cu->header.version >= 5)
|
||||
{
|
||||
/* We have a DWARF5 CU with a reference to a .debug_str_offsets section,
|
||||
so assume the .debug_str_offsets section is DWARF5 as well, and
|
||||
so assume the .debug_str_offsets section is DWARF5 as well, and
|
||||
parse the header. FIXME: Parse the header only once. */
|
||||
unsigned int bytes_read = 0;
|
||||
bfd *abfd = reader->dwo_file->sections.str_offsets.get_bfd_owner ();
|
||||
@@ -18786,8 +18786,8 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
|
||||
|
||||
name = dwarf2_name (die, cu);
|
||||
if (name == nullptr && (die->tag == DW_TAG_subprogram
|
||||
|| die->tag == DW_TAG_inlined_subroutine
|
||||
|| die->tag == DW_TAG_entry_point))
|
||||
|| die->tag == DW_TAG_inlined_subroutine
|
||||
|| die->tag == DW_TAG_entry_point))
|
||||
name = dw2_linkage_name (die, cu);
|
||||
|
||||
if (name)
|
||||
|
||||
+1
-1
@@ -824,7 +824,7 @@ enum dwarf2_section_enum {
|
||||
};
|
||||
|
||||
extern void dwarf2_get_section_info (struct objfile *,
|
||||
enum dwarf2_section_enum,
|
||||
enum dwarf2_section_enum,
|
||||
asection **, const gdb_byte **,
|
||||
bfd_size_type *);
|
||||
|
||||
|
||||
@@ -160,16 +160,16 @@ struct fortran_array_walker_base_impl
|
||||
|
||||
start_dimension (INDEX_TYPE, 3, false);
|
||||
start_dimension (INDEX_TYPE, 2, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
finish_dimension (true, false);
|
||||
start_dimension (INDEX_TYPE, 2, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
finish_dimension (true, true);
|
||||
start_dimension (INDEX_TYPE, 2, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
process_element (TYPE, OFFSET, false);
|
||||
process_element (TYPE, OFFSET, true);
|
||||
finish_dimension (true, true);
|
||||
finish_dimension (false, true); */
|
||||
void process_element (struct type *elt_type, LONGEST elt_off,
|
||||
|
||||
+1
-1
@@ -321,7 +321,7 @@ f_language::f_type_print_base (struct type *type, struct ui_file *stream,
|
||||
if (type->code () == TYPE_CODE_UNION)
|
||||
prefix = "Type, C_Union :: ";
|
||||
else if (type->code () == TYPE_CODE_STRUCT
|
||||
|| type->code () == TYPE_CODE_NAMELIST)
|
||||
|| type->code () == TYPE_CODE_NAMELIST)
|
||||
prefix = "Type ";
|
||||
gdb_printf (stream, "%*s%s%s", level, "", prefix, type->name ());
|
||||
return;
|
||||
|
||||
+4
-4
@@ -3384,7 +3384,7 @@ set_type_code (struct type *type, enum type_code code)
|
||||
break;
|
||||
case TYPE_CODE_FUNC:
|
||||
INIT_FUNC_SPECIFIC (type);
|
||||
break;
|
||||
break;
|
||||
case TYPE_CODE_FIXED_POINT:
|
||||
INIT_FIXED_POINT_SPECIFIC (type);
|
||||
break;
|
||||
@@ -5702,10 +5702,10 @@ copy_type_recursive (struct type *type, htab_t copied_types)
|
||||
new_type->field (i).set_loc_physname
|
||||
(xstrdup (type->field (i).loc_physname ()));
|
||||
break;
|
||||
case FIELD_LOC_KIND_DWARF_BLOCK:
|
||||
new_type->field (i).set_loc_dwarf_block
|
||||
case FIELD_LOC_KIND_DWARF_BLOCK:
|
||||
new_type->field (i).set_loc_dwarf_block
|
||||
(type->field (i).loc_dwarf_block ());
|
||||
break;
|
||||
break;
|
||||
default:
|
||||
internal_error (_("Unexpected type field location kind: %d"),
|
||||
type->field (i).loc_kind ());
|
||||
|
||||
+1
-1
@@ -131,7 +131,7 @@ private:
|
||||
The API is inspired from GMP's mpz_export, hence the naming and types
|
||||
of the following parameter:
|
||||
- ENDIAN should be:
|
||||
. 1 for most significant byte first; or
|
||||
. 1 for most significant byte first; or
|
||||
. -1 for least significant byte first; or
|
||||
. 0 for native endianness.
|
||||
|
||||
|
||||
@@ -562,7 +562,7 @@ vlscm_convert_typed_number (const char *func_name, int obj_arg_pos, SCM obj,
|
||||
{
|
||||
*except_scmp
|
||||
= gdbscm_make_out_of_range_error
|
||||
(func_name, obj_arg_pos, obj,
|
||||
(func_name, obj_arg_pos, obj,
|
||||
_("value out of range for type"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -133,7 +133,7 @@ const struct regset i386_fbsd_segbases_regset =
|
||||
__sighandler_t *sf_handler;
|
||||
} sf_ahu;
|
||||
ucontext_t sf_uc;
|
||||
...
|
||||
...
|
||||
}
|
||||
|
||||
ucontext_t is defined as:
|
||||
|
||||
+1
-1
@@ -1856,7 +1856,7 @@ i386_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
|
||||
&& cust->producer () != NULL
|
||||
&& (producer_is_llvm (cust->producer ())
|
||||
|| producer_is_icc_ge_19 (cust->producer ()))))
|
||||
return std::max (start_pc, post_prologue_pc);
|
||||
return std::max (start_pc, post_prologue_pc);
|
||||
}
|
||||
|
||||
cache.locals = -1;
|
||||
|
||||
+1
-1
@@ -405,7 +405,7 @@ inf_child_target::follow_exec (inferior *follow_inf, ptid_t ptid,
|
||||
if (orig_inf != follow_inf)
|
||||
{
|
||||
/* If the target was implicitly push in the original inferior, unpush
|
||||
it. */
|
||||
it. */
|
||||
scoped_restore_current_thread restore_thread;
|
||||
switch_to_inferior_no_thread (orig_inf);
|
||||
maybe_unpush_target ();
|
||||
|
||||
+4
-4
@@ -693,7 +693,7 @@ holding the child stopped. Try \"set detach-on-fork\" or \
|
||||
if (child_inf != nullptr)
|
||||
{
|
||||
/* If FOLLOW_CHILD, we leave CHILD_INF as the current inferior
|
||||
(do not restore the parent as the current inferior). */
|
||||
(do not restore the parent as the current inferior). */
|
||||
gdb::optional<scoped_restore_current_thread> maybe_restore;
|
||||
|
||||
if (!follow_child)
|
||||
@@ -3089,7 +3089,7 @@ scoped_disable_commit_resumed::reset ()
|
||||
if (m_prev_enable_commit_resumed)
|
||||
{
|
||||
/* This is the outermost instance, re-enable
|
||||
COMMIT_RESUMED_STATE on the targets where it's possible. */
|
||||
COMMIT_RESUMED_STATE on the targets where it's possible. */
|
||||
maybe_set_commit_resumed_all_targets ();
|
||||
}
|
||||
else
|
||||
@@ -5878,7 +5878,7 @@ handle_inferior_event (struct execution_control_state *ecs)
|
||||
if (should_resume)
|
||||
{
|
||||
/* Never call switch_back_to_stepped_thread if we are waiting for
|
||||
vfork-done (waiting for an external vfork child to exec or
|
||||
vfork-done (waiting for an external vfork child to exec or
|
||||
exit). We will resume only the vforking thread for the purpose
|
||||
of collecting the vfork-done event, and we will restart any
|
||||
step once the critical shared address space window is done. */
|
||||
@@ -7518,7 +7518,7 @@ process_event_stop_test (struct execution_control_state *ecs)
|
||||
return;
|
||||
}
|
||||
else if (get_frame_id (get_current_frame ())
|
||||
== ecs->event_thread->control.step_frame_id)
|
||||
== ecs->event_thread->control.step_frame_id)
|
||||
{
|
||||
/* We are not at the start of a statement, and we have not changed
|
||||
frame.
|
||||
|
||||
+1
-1
@@ -1226,7 +1226,7 @@ get_detach_signal (struct lwp_info *lp)
|
||||
if (tp->has_pending_waitstatus ())
|
||||
{
|
||||
/* If the thread has a pending event, and it was stopped with a
|
||||
signal, use that signal to resume it. If it has a pending
|
||||
signal, use that signal to resume it. If it has a pending
|
||||
event of another kind, it was not stopped with a signal, so
|
||||
resume it without a signal. */
|
||||
if (tp->pending_waitstatus ().kind () == TARGET_WAITKIND_STOPPED)
|
||||
|
||||
@@ -809,8 +809,8 @@ static bool
|
||||
libpthread_objfile_p (objfile *obj)
|
||||
{
|
||||
return (libpthread_name_p (objfile_name (obj))
|
||||
&& lookup_minimal_symbol ("pthread_create",
|
||||
NULL,
|
||||
&& lookup_minimal_symbol ("pthread_create",
|
||||
NULL,
|
||||
obj).minsym != NULL);
|
||||
}
|
||||
|
||||
|
||||
@@ -336,7 +336,7 @@ void
|
||||
_initialize_loongarch_linux_tdep ()
|
||||
{
|
||||
gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch32,
|
||||
GDB_OSABI_LINUX, loongarch_linux_init_abi);
|
||||
GDB_OSABI_LINUX, loongarch_linux_init_abi);
|
||||
gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch64,
|
||||
GDB_OSABI_LINUX, loongarch_linux_init_abi);
|
||||
GDB_OSABI_LINUX, loongarch_linux_init_abi);
|
||||
}
|
||||
|
||||
@@ -602,12 +602,12 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
|
||||
and the signed integer scalars are sign-extended. */
|
||||
if (type->is_unsigned ())
|
||||
{
|
||||
ULONGEST data = extract_unsigned_integer (val, len, BFD_ENDIAN_LITTLE);
|
||||
ULONGEST data = extract_unsigned_integer (val, len, BFD_ENDIAN_LITTLE);
|
||||
if (gar > 0)
|
||||
pass_in_gar (regcache, gar--, (gdb_byte *) &data);
|
||||
else
|
||||
pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LONGEST data = extract_signed_integer (val, len, BFD_ENDIAN_LITTLE);
|
||||
@@ -615,7 +615,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
|
||||
pass_in_gar (regcache, gar--, (gdb_byte *) &data);
|
||||
else
|
||||
pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TYPE_CODE_FLT:
|
||||
@@ -975,7 +975,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
|
||||
}
|
||||
else if (len > 2 * regsize)
|
||||
{
|
||||
/* It's passed by reference and are replaced in the argument list with the address.
|
||||
/* It's passed by reference and are replaced in the argument list with the address.
|
||||
If there is an available GAR, the reference is passed in the GAR,
|
||||
and passed on the stack if no GAR is available. */
|
||||
sp = align_down (sp - len, 16);
|
||||
|
||||
+1
-1
@@ -571,7 +571,7 @@ get_token (shared_macro_buffer *tok, shared_macro_buffer *src)
|
||||
yield "< <", not "<<", etc. */
|
||||
static void
|
||||
append_tokens_without_splicing (growable_macro_buffer *dest,
|
||||
shared_macro_buffer *src)
|
||||
shared_macro_buffer *src)
|
||||
{
|
||||
int original_dest_len = dest->len;
|
||||
shared_macro_buffer dest_tail, new_token;
|
||||
|
||||
+1
-1
@@ -1239,7 +1239,7 @@ Usage: maintenance info sections [-all-objects] [FILTERS]\n\
|
||||
FILTERS is a list of words, each word is either:\n\
|
||||
+ A section name - any section with this name will be printed, or\n\
|
||||
+ A section flag - any section with this flag will be printed. The\n\
|
||||
known flags are:\n\
|
||||
known flags are:\n\
|
||||
ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
|
||||
HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
|
||||
\n\
|
||||
|
||||
+1
-3
@@ -637,9 +637,7 @@ mi_cmd_var_update (const char *command, char **argv, int argc)
|
||||
only the root VAROBJs. */
|
||||
|
||||
all_root_varobjs ([=] (varobj *var)
|
||||
{
|
||||
mi_cmd_var_update_iter (var, *name == '0', print_values);
|
||||
});
|
||||
{ mi_cmd_var_update_iter (var, *name == '0', print_values); });
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
+7
-7
@@ -38,7 +38,7 @@ struct mi_command_mi : public mi_command
|
||||
constructor, FUNC is the function called from do_invoke, which
|
||||
implements this MI command. */
|
||||
mi_command_mi (const char *name, mi_cmd_argv_ftype func,
|
||||
int *suppress_notification)
|
||||
int *suppress_notification)
|
||||
: mi_command (name, suppress_notification),
|
||||
m_argv_function (func)
|
||||
{
|
||||
@@ -75,7 +75,7 @@ struct mi_command_cli : public mi_command
|
||||
forwarded to CLI_NAME as its argument string, otherwise, if ARGS_P is
|
||||
false, nullptr is send to CLI_NAME as its argument string. */
|
||||
mi_command_cli (const char *name, const char *cli_name, bool args_p,
|
||||
int *suppress_notification)
|
||||
int *suppress_notification)
|
||||
: mi_command (name, suppress_notification),
|
||||
m_cli_name (cli_name),
|
||||
m_args_p (args_p)
|
||||
@@ -232,11 +232,11 @@ add_builtin_mi_commands ()
|
||||
add_mi_cmd_mi ("catch-unload", mi_cmd_catch_unload,
|
||||
&mi_suppress_notification.breakpoint);
|
||||
add_mi_cmd_mi ("catch-throw", mi_cmd_catch_throw,
|
||||
&mi_suppress_notification.breakpoint),
|
||||
&mi_suppress_notification.breakpoint),
|
||||
add_mi_cmd_mi ("catch-rethrow", mi_cmd_catch_rethrow,
|
||||
&mi_suppress_notification.breakpoint),
|
||||
&mi_suppress_notification.breakpoint),
|
||||
add_mi_cmd_mi ("catch-catch", mi_cmd_catch_catch,
|
||||
&mi_suppress_notification.breakpoint),
|
||||
&mi_suppress_notification.breakpoint),
|
||||
add_mi_cmd_mi ("complete", mi_cmd_complete);
|
||||
add_mi_cmd_mi ("data-disassemble", mi_cmd_disassemble);
|
||||
add_mi_cmd_mi ("data-evaluate-expression", mi_cmd_data_evaluate_expression);
|
||||
@@ -315,9 +315,9 @@ add_builtin_mi_commands ()
|
||||
add_mi_cmd_mi ("symbol-info-types", mi_cmd_symbol_info_types);
|
||||
add_mi_cmd_mi ("symbol-info-modules", mi_cmd_symbol_info_modules);
|
||||
add_mi_cmd_mi ("symbol-info-module-functions",
|
||||
mi_cmd_symbol_info_module_functions);
|
||||
mi_cmd_symbol_info_module_functions);
|
||||
add_mi_cmd_mi ("symbol-info-module-variables",
|
||||
mi_cmd_symbol_info_module_variables);
|
||||
mi_cmd_symbol_info_module_variables);
|
||||
add_mi_cmd_cli ("target-attach", "attach", 1);
|
||||
add_mi_cmd_mi ("target-detach", mi_cmd_target_detach);
|
||||
add_mi_cmd_cli ("target-disconnect", "disconnect", 0);
|
||||
|
||||
+3
-3
@@ -5219,13 +5219,13 @@ mips_n32n64_return_value (struct gdbarch *gdbarch, struct value *function,
|
||||
From MIPSpro Assembly Language Programmer's Guide, Document Number:
|
||||
007-2418-004
|
||||
|
||||
Software
|
||||
Software
|
||||
Register Name(from
|
||||
Name fgregdef.h) Use and Linkage
|
||||
-----------------------------------------------------------------
|
||||
$f0, $f2 fv0, fv1 Hold results of floating-point type function
|
||||
($f0) and complex type function ($f0 has the
|
||||
real part, $f2 has the imaginary part.) */
|
||||
($f0) and complex type function ($f0 has the
|
||||
real part, $f2 has the imaginary part.) */
|
||||
|
||||
if (type->length () > 2 * MIPS64_REGSIZE)
|
||||
return RETURN_VALUE_STRUCT_CONVENTION;
|
||||
|
||||
+1
-1
@@ -127,7 +127,7 @@ obsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
|
||||
}
|
||||
|
||||
/* Ensure the ptid is updated with an LWP id on the first stop
|
||||
of a process. */
|
||||
of a process. */
|
||||
if (!in_thread_list (this, wptid))
|
||||
{
|
||||
if (in_thread_list (this, ptid_t (pid)))
|
||||
|
||||
+2
-2
@@ -1563,13 +1563,13 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch,
|
||||
&& eltype->length () == 16
|
||||
&& (gdbarch_long_double_format (gdbarch)
|
||||
== floatformats_ieee_quad))
|
||||
/* IEEE FLOAT128, args in vector registers. */
|
||||
/* IEEE FLOAT128, args in vector registers. */
|
||||
{
|
||||
ppc64_sysv_abi_push_vreg (gdbarch, elval, argpos);
|
||||
align = 16;
|
||||
}
|
||||
else if (eltype->code () == TYPE_CODE_FLT
|
||||
|| eltype->code () == TYPE_CODE_DECFLOAT)
|
||||
|| eltype->code () == TYPE_CODE_DECFLOAT)
|
||||
/* IBM long double and all other floats and decfloats, args
|
||||
are in a pair of floating point registers. */
|
||||
ppc64_sysv_abi_push_freg (gdbarch, eltype, elval, argpos);
|
||||
|
||||
+2
-2
@@ -622,9 +622,9 @@ ppc64_skip_trampoline_code_1 (frame_info_ptr frame, CORE_ADDR pc)
|
||||
ARRAY_SIZE (ppc64_standard_linkage6)),
|
||||
MAX (ARRAY_SIZE (ppc64_standard_linkage7),
|
||||
ARRAY_SIZE (ppc64_standard_linkage8))),
|
||||
MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage9),
|
||||
MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage9),
|
||||
ARRAY_SIZE (ppc64_standard_linkage10)),
|
||||
MAX (ARRAY_SIZE (ppc64_standard_linkage11),
|
||||
MAX (ARRAY_SIZE (ppc64_standard_linkage11),
|
||||
ARRAY_SIZE (ppc64_standard_linkage12)))))
|
||||
|
||||
- 1];
|
||||
|
||||
@@ -95,7 +95,7 @@ process_stratum_target::follow_exec (inferior *follow_inf, ptid_t ptid,
|
||||
if (orig_inf != follow_inf)
|
||||
{
|
||||
/* Execution continues in a new inferior, push the original inferior's
|
||||
process target on the new inferior's target stack. The process target
|
||||
process target on the new inferior's target stack. The process target
|
||||
may decide to unpush itself from the original inferior's target stack
|
||||
after that, at its discretion. */
|
||||
follow_inf->push_target (orig_inf->process_target ());
|
||||
|
||||
+1
-1
@@ -521,7 +521,7 @@ cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
|
||||
docstring.release (), cmd_list);
|
||||
|
||||
/* If successful, the above takes ownership of the name, since we set
|
||||
name_allocated, so release it. */
|
||||
name_allocated, so release it. */
|
||||
cmd_name.release ();
|
||||
|
||||
/* There appears to be no API to set this. */
|
||||
|
||||
@@ -269,7 +269,7 @@ serialize_mi_result_1 (PyObject *result, const char *field_name)
|
||||
gdbpy_handle_exception ();
|
||||
for (Py_ssize_t i = 0; i < len; ++i)
|
||||
{
|
||||
gdbpy_ref<> item (PySequence_ITEM (result, i));
|
||||
gdbpy_ref<> item (PySequence_ITEM (result, i));
|
||||
if (item == nullptr)
|
||||
gdbpy_handle_exception ();
|
||||
serialize_mi_result_1 (item.get (), nullptr);
|
||||
@@ -452,7 +452,7 @@ micmdpy_install_command (micmdpy_object *obj)
|
||||
if (cmd != nullptr && cmd_py == nullptr)
|
||||
{
|
||||
/* There is already an MI command registered with that name, and it's not
|
||||
a Python one. Forbid replacing a non-Python MI command. */
|
||||
a Python one. Forbid replacing a non-Python MI command. */
|
||||
PyErr_SetString (PyExc_RuntimeError,
|
||||
_("unable to add command, name is already in use"));
|
||||
return -1;
|
||||
@@ -461,7 +461,7 @@ micmdpy_install_command (micmdpy_object *obj)
|
||||
if (cmd_py != nullptr)
|
||||
{
|
||||
/* There is already a Python MI command registered with that name, swap
|
||||
in the new gdb.MICommand implementation. */
|
||||
in the new gdb.MICommand implementation. */
|
||||
cmd_py->swap_python_object (obj);
|
||||
}
|
||||
else
|
||||
|
||||
+1
-1
@@ -2078,7 +2078,7 @@ do_start_initialization ()
|
||||
|
||||
PyConfig_InitPythonConfig (&config);
|
||||
PyStatus status = PyConfig_SetString (&config, &config.program_name,
|
||||
progname_copy);
|
||||
progname_copy);
|
||||
if (PyStatus_Exception (status))
|
||||
goto init_done;
|
||||
|
||||
|
||||
+5
-5
@@ -5214,7 +5214,7 @@ remote_target::start_remote_1 (int from_tty, int extended_p)
|
||||
continue;
|
||||
|
||||
/* Need to switch to a specific thread, because remote_check_symbols
|
||||
uses INFERIOR_PTID to set the general thread. */
|
||||
uses INFERIOR_PTID to set the general thread. */
|
||||
scoped_restore_current_thread restore_thread;
|
||||
thread_info *thread = any_thread_of_inferior (inf);
|
||||
switch_to_thread (thread);
|
||||
@@ -6733,7 +6733,7 @@ remote_target::resume (ptid_t scope_ptid, int step, enum gdb_signal siggnal)
|
||||
= get_remote_thread_info (inferior_thread ());
|
||||
|
||||
/* We don't expect the core to ask to resume an already resumed (from
|
||||
its point of view) thread. */
|
||||
its point of view) thread. */
|
||||
gdb_assert (remote_thr->get_resume_state () == resume_state::NOT_RESUMED);
|
||||
|
||||
remote_thr->set_resumed_pending_vcont (step, siggnal);
|
||||
@@ -7025,7 +7025,7 @@ remote_target::commit_resumed ()
|
||||
gdb_assert (!thread_is_in_step_over_chain (tp));
|
||||
|
||||
/* We should never be commit-resuming a thread that has a stop reply.
|
||||
Otherwise, we would end up reporting a stop event for a thread while
|
||||
Otherwise, we would end up reporting a stop event for a thread while
|
||||
it is running on the remote target. */
|
||||
remote_state *rs = get_remote_state ();
|
||||
for (const auto &stop_reply : rs->stop_reply_queue)
|
||||
@@ -7035,7 +7035,7 @@ remote_target::commit_resumed ()
|
||||
= remote_thr->resumed_pending_vcont_info ();
|
||||
|
||||
/* Check if we need to send a specific action for this thread. If not,
|
||||
it will be included in a wildcard resume instead. */
|
||||
it will be included in a wildcard resume instead. */
|
||||
if (info.step || info.sig != GDB_SIGNAL_0
|
||||
|| !get_remote_inferior (tp->inf)->may_wildcard_vcont)
|
||||
vcont_builder.push_action (tp->ptid, info.step, info.sig);
|
||||
@@ -14732,7 +14732,7 @@ remote_new_objfile (struct objfile *objfile)
|
||||
continue;
|
||||
|
||||
/* Need to switch to a specific thread, because remote_check_symbols will
|
||||
set the general thread using INFERIOR_PTID.
|
||||
set the general thread using INFERIOR_PTID.
|
||||
|
||||
It's possible to have inferiors with no thread here, because we are
|
||||
called very early in the connection process, while the inferior is
|
||||
|
||||
@@ -134,7 +134,7 @@ riscv_iterate_over_regset_sections (struct gdbarch *gdbarch,
|
||||
if (tdesc != nullptr)
|
||||
{
|
||||
const struct tdesc_feature *feature_csr
|
||||
= tdesc_find_feature (tdesc, riscv_feature_name_csr);
|
||||
= tdesc_find_feature (tdesc, riscv_feature_name_csr);
|
||||
if (feature_csr != nullptr && feature_csr->registers.size () > 0)
|
||||
{
|
||||
riscv_update_csrmap (gdbarch, feature_csr);
|
||||
|
||||
@@ -296,7 +296,7 @@ store_vsx_register_aix (struct regcache *regcache, int regno)
|
||||
tid64_t thrd_i = 0;
|
||||
|
||||
if (getthrds64(pid, &thrdentry, sizeof(struct thrdentry64),
|
||||
&thrd_i, 1) == 1)
|
||||
&thrd_i, 1) == 1)
|
||||
thrd_i = thrdentry.ti_tid;
|
||||
|
||||
memset(&vsx, 0, sizeof(__vsx_context_t));
|
||||
@@ -336,7 +336,7 @@ store_altivec_register_aix (struct regcache *regcache, int regno)
|
||||
tid64_t thrd_i = 0;
|
||||
|
||||
if (getthrds64(pid, &thrdentry, sizeof(struct thrdentry64),
|
||||
&thrd_i, 1) == 1)
|
||||
&thrd_i, 1) == 1)
|
||||
thrd_i = thrdentry.ti_tid;
|
||||
|
||||
memset(&vmx, 0, sizeof(__vmx_context_t));
|
||||
@@ -373,7 +373,7 @@ supply_vrregset_aix (struct regcache *regcache, __vmx_context_t *vmx)
|
||||
|
||||
for (i = 0; i < num_of_vrregs; i++)
|
||||
regcache->raw_supply (tdep->ppc_vr0_regnum + i,
|
||||
&(vmx->__vr[i]));
|
||||
&(vmx->__vr[i]));
|
||||
regcache->raw_supply (tdep->ppc_vrsave_regnum, &(vmx->__vrsave));
|
||||
regcache->raw_supply (tdep->ppc_vrsave_regnum - 1, &(vmx->__vscr));
|
||||
}
|
||||
@@ -389,7 +389,7 @@ fetch_altivec_registers_aix (struct regcache *regcache)
|
||||
tid64_t thrd_i = 0;
|
||||
|
||||
if (getthrds64(pid, &thrdentry, sizeof(struct thrdentry64),
|
||||
&thrd_i, 1) == 1)
|
||||
&thrd_i, 1) == 1)
|
||||
thrd_i = thrdentry.ti_tid;
|
||||
|
||||
memset(&vmx, 0, sizeof(__vmx_context_t));
|
||||
@@ -414,7 +414,7 @@ supply_vsxregset_aix (struct regcache *regcache, __vsx_context_t *vsx)
|
||||
|
||||
for (i = 0; i < ppc_num_vshrs; i++)
|
||||
regcache->raw_supply (tdep->ppc_vsr0_upper_regnum + i,
|
||||
&(vsx->__vsr_dw1[i]));
|
||||
&(vsx->__vsr_dw1[i]));
|
||||
}
|
||||
|
||||
/* Fetch vsx registers. */
|
||||
@@ -427,7 +427,7 @@ fetch_vsx_registers_aix (struct regcache *regcache)
|
||||
tid64_t thrd_i = 0;
|
||||
|
||||
if (getthrds64(pid, &thrdentry, sizeof(struct thrdentry64),
|
||||
&thrd_i, 1) == 1)
|
||||
&thrd_i, 1) == 1)
|
||||
thrd_i = thrdentry.ti_tid;
|
||||
|
||||
memset(&vsx, 0, sizeof(__vsx_context_t));
|
||||
@@ -654,10 +654,10 @@ rs6000_nat_target::fetch_registers (struct regcache *regcache, int regno)
|
||||
fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
|
||||
|
||||
if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
|
||||
fetch_altivec_registers_aix (regcache);
|
||||
fetch_altivec_registers_aix (regcache);
|
||||
|
||||
if (tdep->ppc_vsr0_upper_regnum != -1)
|
||||
fetch_vsx_registers_aix (regcache);
|
||||
fetch_vsx_registers_aix (regcache);
|
||||
|
||||
/* Read special registers. */
|
||||
fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
|
||||
|
||||
+9
-10
@@ -86,7 +86,7 @@ static struct rs6000_aix_reg_vrreg_offset rs6000_aix_vrreg_offset =
|
||||
static int
|
||||
rs6000_aix_get_vrreg_offset (ppc_gdbarch_tdep *tdep,
|
||||
const struct rs6000_aix_reg_vrreg_offset *offsets,
|
||||
int regnum)
|
||||
int regnum)
|
||||
{
|
||||
if (regnum >= tdep->ppc_vr0_regnum &&
|
||||
regnum < tdep->ppc_vr0_regnum + ppc_num_vrs)
|
||||
@@ -103,7 +103,7 @@ rs6000_aix_get_vrreg_offset (ppc_gdbarch_tdep *tdep,
|
||||
|
||||
static void
|
||||
rs6000_aix_supply_vrregset (const struct regset *regset, struct regcache *regcache,
|
||||
int regnum, const void *vrregs, size_t len)
|
||||
int regnum, const void *vrregs, size_t len)
|
||||
{
|
||||
struct gdbarch *gdbarch = regcache->arch ();
|
||||
const struct rs6000_aix_reg_vrreg_offset *offsets;
|
||||
@@ -142,7 +142,7 @@ rs6000_aix_supply_vrregset (const struct regset *regset, struct regcache *regcac
|
||||
|
||||
static void
|
||||
rs6000_aix_supply_vsxregset (const struct regset *regset, struct regcache *regcache,
|
||||
int regnum, const void *vsxregs, size_t len)
|
||||
int regnum, const void *vsxregs, size_t len)
|
||||
{
|
||||
struct gdbarch *gdbarch = regcache->arch ();
|
||||
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
|
||||
@@ -165,8 +165,8 @@ rs6000_aix_supply_vsxregset (const struct regset *regset, struct regcache *regca
|
||||
|
||||
static void
|
||||
rs6000_aix_collect_vsxregset (const struct regset *regset,
|
||||
const struct regcache *regcache,
|
||||
int regnum, void *vsxregs, size_t len)
|
||||
const struct regcache *regcache,
|
||||
int regnum, void *vsxregs, size_t len)
|
||||
{
|
||||
struct gdbarch *gdbarch = regcache->arch ();
|
||||
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
|
||||
@@ -183,15 +183,14 @@ rs6000_aix_collect_vsxregset (const struct regset *regset,
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
else
|
||||
else
|
||||
ppc_collect_reg (regcache, regnum, (gdb_byte *) vsxregs, 0, 8);
|
||||
}
|
||||
|
||||
static void
|
||||
rs6000_aix_collect_vrregset (const struct regset *regset,
|
||||
const struct regcache *regcache,
|
||||
int regnum, void *vrregs, size_t len)
|
||||
const struct regcache *regcache,
|
||||
int regnum, void *vrregs, size_t len)
|
||||
{
|
||||
struct gdbarch *gdbarch = regcache->arch ();
|
||||
const struct rs6000_aix_reg_vrreg_offset *offsets;
|
||||
@@ -225,7 +224,7 @@ rs6000_aix_collect_vrregset (const struct regset *regset,
|
||||
ppc_collect_reg (regcache, regnum, (gdb_byte *) vrregs, offset, 16);
|
||||
else
|
||||
ppc_collect_reg (regcache, regnum,
|
||||
(gdb_byte *) vrregs, offset, 4);
|
||||
(gdb_byte *) vrregs, offset, 4);
|
||||
}
|
||||
|
||||
static const struct regset rs6000_aix_vrregset = {
|
||||
|
||||
+16
-16
@@ -1058,7 +1058,7 @@ ppc_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
else
|
||||
{
|
||||
/* Handle any other instructions that do not fit in the categories
|
||||
above. */
|
||||
above. */
|
||||
regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
|
||||
from + offset);
|
||||
}
|
||||
@@ -4181,15 +4181,15 @@ ppc_record_ACC_fpscr (struct regcache *regcache, ppc_gdbarch_tdep *tdep,
|
||||
entry consist of four 128-bit rows.
|
||||
|
||||
The ACC rows map to specific VSR registers.
|
||||
ACC[0][0] -> VSR[0]
|
||||
ACC[0][1] -> VSR[1]
|
||||
ACC[0][2] -> VSR[2]
|
||||
ACC[0][3] -> VSR[3]
|
||||
...
|
||||
ACC[7][0] -> VSR[28]
|
||||
ACC[7][1] -> VSR[29]
|
||||
ACC[7][2] -> VSR[30]
|
||||
ACC[7][3] -> VSR[31]
|
||||
ACC[0][0] -> VSR[0]
|
||||
ACC[0][1] -> VSR[1]
|
||||
ACC[0][2] -> VSR[2]
|
||||
ACC[0][3] -> VSR[3]
|
||||
...
|
||||
ACC[7][0] -> VSR[28]
|
||||
ACC[7][1] -> VSR[29]
|
||||
ACC[7][2] -> VSR[30]
|
||||
ACC[7][3] -> VSR[31]
|
||||
|
||||
NOTE:
|
||||
In ISA 3.1 the ACC is mapped on top of VSR[0] thru VSR[31].
|
||||
@@ -7446,14 +7446,14 @@ rs6000_program_breakpoint_here_p (gdbarch *gdbarch, CORE_ADDR address)
|
||||
if (target_read_memory (address, target_mem, PPC_INSN_SIZE) == 0)
|
||||
{
|
||||
uint32_t insn = (uint32_t) extract_unsigned_integer
|
||||
(target_mem, PPC_INSN_SIZE, gdbarch_byte_order_for_code (gdbarch));
|
||||
(target_mem, PPC_INSN_SIZE, gdbarch_byte_order_for_code (gdbarch));
|
||||
|
||||
/* Check if INSN is a TW, TWI, TD or TDI instruction. There
|
||||
are multiple choices of such instructions with different registers
|
||||
and / or immediate values but they all cause a break. */
|
||||
are multiple choices of such instructions with different registers
|
||||
and / or immediate values but they all cause a break. */
|
||||
if (is_tw_insn (insn) || is_twi_insn (insn) || is_td_insn (insn)
|
||||
|| is_tdi_insn (insn))
|
||||
return true;
|
||||
|| is_tdi_insn (insn))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -8326,7 +8326,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
set_gdbarch_sw_breakpoint_from_kind (gdbarch,
|
||||
rs6000_breakpoint::bp_from_kind);
|
||||
set_gdbarch_program_breakpoint_here_p (gdbarch,
|
||||
rs6000_program_breakpoint_here_p);
|
||||
rs6000_program_breakpoint_here_p);
|
||||
|
||||
/* The value of symbols of type N_SO and N_FUN maybe null when
|
||||
it shouldn't be. */
|
||||
|
||||
+1
-1
@@ -1400,7 +1400,7 @@ rust_parser::parse_binop (bool required)
|
||||
/* Arrange to pop the entire stack. */
|
||||
precedence = -2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure that assignments are right-associative while other
|
||||
operations are left-associative. */
|
||||
|
||||
+1
-3
@@ -99,9 +99,7 @@ register_test_foreach_arch (const std::string &name,
|
||||
self_test_foreach_arch_function *function)
|
||||
{
|
||||
add_lazy_generator ([=] ()
|
||||
{
|
||||
return foreach_arch_test_generator (name, function);
|
||||
});
|
||||
{ return foreach_arch_test_generator (name, function); });
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
+2
-2
@@ -1908,8 +1908,8 @@ solist_update_incremental (svr4_info *info, CORE_ADDR debug_base,
|
||||
return 0;
|
||||
|
||||
/* Get the so list from the target. We replace the list in the
|
||||
target response so we can easily check that the response only
|
||||
covers one namespace.
|
||||
target response so we can easily check that the response only
|
||||
covers one namespace.
|
||||
|
||||
We expect gdbserver to provide updates for the namespace that
|
||||
contains LM, which whould be this namespace... */
|
||||
|
||||
+1
-1
@@ -959,7 +959,7 @@ bool
|
||||
libpthread_name_p (const char *name)
|
||||
{
|
||||
return (strstr (name, "/libpthread") != NULL
|
||||
|| strstr (name, "/libc.") != NULL );
|
||||
|| strstr (name, "/libc.") != NULL );
|
||||
}
|
||||
|
||||
/* Return non-zero if SO is the libpthread shared library. */
|
||||
|
||||
+8
-8
@@ -566,7 +566,7 @@ add_path (const char *dirname, char **which_path, int parse_separators)
|
||||
}
|
||||
|
||||
if (name[0] == '\0')
|
||||
goto skip_dup;
|
||||
goto skip_dup;
|
||||
if (name[0] == '~')
|
||||
new_name_holder
|
||||
= gdb::unique_xmalloc_ptr<char[]> (tilde_expand (name)).get ();
|
||||
@@ -2021,12 +2021,12 @@ By default, relative filenames are displayed."),
|
||||
&setlist, &showlist);
|
||||
|
||||
add_prefix_cmd ("source", no_class, set_source,
|
||||
_("Generic command for setting how sources are handled."),
|
||||
&setsourcelist, 0, &setlist);
|
||||
_("Generic command for setting how sources are handled."),
|
||||
&setsourcelist, 0, &setlist);
|
||||
|
||||
add_prefix_cmd ("source", no_class, show_source,
|
||||
_("Generic command for showing source settings."),
|
||||
&showsourcelist, 0, &showlist);
|
||||
_("Generic command for showing source settings."),
|
||||
&showsourcelist, 0, &showlist);
|
||||
|
||||
add_setshow_boolean_cmd ("open", class_files, &source_open, _("\
|
||||
Set whether GDB should open source files."), _("\
|
||||
@@ -2038,7 +2038,7 @@ When this option is off GDB will not try to open source files, instead\n\
|
||||
GDB will print the file and line number that would have been displayed.\n\
|
||||
This can be useful if access to source code files is slow, for example\n\
|
||||
due to the source being located over a slow network connection."),
|
||||
NULL,
|
||||
show_source_open,
|
||||
&setsourcelist, &showsourcelist);
|
||||
NULL,
|
||||
show_source_open,
|
||||
&setsourcelist, &showsourcelist);
|
||||
}
|
||||
|
||||
+15
-15
@@ -3771,7 +3771,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
|
||||
pc = saved_pc;
|
||||
|
||||
/* Check if the compiler explicitly indicated where a breakpoint should
|
||||
be placed to skip the prologue. */
|
||||
be placed to skip the prologue. */
|
||||
if (!ignore_prologue_end_flag && skip)
|
||||
{
|
||||
gdb::optional<CORE_ADDR> linetable_pc
|
||||
@@ -4153,7 +4153,7 @@ operator_chars (const char *p, const char **end)
|
||||
/* See class declaration. */
|
||||
|
||||
info_sources_filter::info_sources_filter (match_on match_type,
|
||||
const char *regexp)
|
||||
const char *regexp)
|
||||
: m_match_type (match_type),
|
||||
m_regexp (regexp)
|
||||
{
|
||||
@@ -4182,23 +4182,23 @@ info_sources_filter::matches (const char *fullname) const
|
||||
std::string dirname;
|
||||
|
||||
switch (m_match_type)
|
||||
{
|
||||
case match_on::DIRNAME:
|
||||
dirname = ldirname (fullname);
|
||||
to_match = dirname.c_str ();
|
||||
break;
|
||||
case match_on::BASENAME:
|
||||
to_match = lbasename (fullname);
|
||||
break;
|
||||
case match_on::FULLNAME:
|
||||
to_match = fullname;
|
||||
break;
|
||||
{
|
||||
case match_on::DIRNAME:
|
||||
dirname = ldirname (fullname);
|
||||
to_match = dirname.c_str ();
|
||||
break;
|
||||
case match_on::BASENAME:
|
||||
to_match = lbasename (fullname);
|
||||
break;
|
||||
case match_on::FULLNAME:
|
||||
to_match = fullname;
|
||||
break;
|
||||
default:
|
||||
gdb_assert_not_reached ("bad m_match_type");
|
||||
}
|
||||
}
|
||||
|
||||
if (m_c_regexp->exec (to_match, 0, NULL, 0) != 0)
|
||||
return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
+1
-1
@@ -88,7 +88,7 @@ all_matching_threads_iterator::all_matching_threads_iterator
|
||||
if (filter_ptid == minus_one_ptid)
|
||||
{
|
||||
/* Iterate on all threads of all inferiors, possibly filtering on
|
||||
FILTER_TARGET. */
|
||||
FILTER_TARGET. */
|
||||
m_mode = mode::ALL_THREADS;
|
||||
|
||||
/* Seek the first thread of the first matching inferior. */
|
||||
|
||||
+4
-4
@@ -204,11 +204,11 @@ set_thread_exited (thread_info *tp, bool silent)
|
||||
process_stratum_target *proc_target = tp->inf->process_target ();
|
||||
|
||||
/* Some targets unpush themselves from the inferior's target stack before
|
||||
clearing the inferior's thread list (which marks all threads as exited,
|
||||
and therefore leads to this function). In this case, the inferior's
|
||||
process target will be nullptr when we arrive here.
|
||||
clearing the inferior's thread list (which marks all threads as exited,
|
||||
and therefore leads to this function). In this case, the inferior's
|
||||
process target will be nullptr when we arrive here.
|
||||
|
||||
See also the comment in inferior::unpush_target. */
|
||||
See also the comment in inferior::unpush_target. */
|
||||
if (proc_target != nullptr)
|
||||
proc_target->maybe_remove_resumed_with_pending_wait_status (tp);
|
||||
|
||||
|
||||
@@ -667,7 +667,7 @@ execute_command (const char *p, int from_tty)
|
||||
subcommands. */
|
||||
{
|
||||
std::string prefixname = c->prefixname ();
|
||||
std::string prefixname_no_space
|
||||
std::string prefixname_no_space
|
||||
= prefixname.substr (0, prefixname.length () - 1);
|
||||
gdb_printf
|
||||
("\"%s\" must be followed by the name of a subcommand.\n",
|
||||
|
||||
@@ -850,7 +850,7 @@ tui_layout_split::apply (int x_, int y_, int width_, int height_,
|
||||
{
|
||||
/* Save the old cmd window information, in case we need to
|
||||
restore it later. */
|
||||
old_cmd_info.emplace (i, info[i].min_size, info[i].max_size);
|
||||
old_cmd_info.emplace (i, info[i].min_size, info[i].max_size);
|
||||
|
||||
/* If this layout has never been applied, then it means the
|
||||
user just changed the layout. In this situation, it's
|
||||
@@ -965,11 +965,11 @@ tui_layout_split::apply (int x_, int y_, int width_, int height_,
|
||||
window non-fixed-size (if possible), and hope we can
|
||||
shrink this enough to fit the rest of the sub-layouts in.
|
||||
|
||||
Alternatively, we've made it around the loop without
|
||||
adjusting any window's size. This likely means all
|
||||
windows have hit their min or max size. Again, our only
|
||||
hope is to make the cmd window non-fixed-size, and hope
|
||||
this fixes all our problems. */
|
||||
Alternatively, we've made it around the loop without
|
||||
adjusting any window's size. This likely means all
|
||||
windows have hit their min or max size. Again, our only
|
||||
hope is to make the cmd window non-fixed-size, and hope
|
||||
this fixes all our problems. */
|
||||
if (old_cmd_info.has_value ()
|
||||
&& ((available_size < used_size)
|
||||
|| !found_window_that_can_grow_p))
|
||||
|
||||
+2
-2
@@ -845,9 +845,9 @@ Available FLAGS are:\n\
|
||||
/T print typedefs defined in a class\n\
|
||||
/o print offsets and sizes of fields in a struct (like pahole)\n\
|
||||
/x use hexadecimal notation when displaying sizes and offsets\n\
|
||||
of struct members\n\
|
||||
of struct members\n\
|
||||
/d use decimal notation when displaying sizes and offsets\n\
|
||||
of struct members "));
|
||||
of struct members "));
|
||||
set_cmd_completer (c, expression_completer);
|
||||
|
||||
c = add_com ("whatis", class_vars, whatis_command,
|
||||
|
||||
@@ -45,7 +45,7 @@ do_test ()
|
||||
does not exist, gdb_tilde expand must still be able to do the tilde
|
||||
expansion. */
|
||||
SELF_CHECK (gdb_tilde_expand ("~/non/existent/directory")
|
||||
== home + "/non/existent/directory");
|
||||
== home + "/non/existent/directory");
|
||||
|
||||
/* gdb_tilde_expand only expands tilde and does not try to do any other
|
||||
substitution. */
|
||||
@@ -63,7 +63,7 @@ do_test ()
|
||||
const std::string user (c_user);
|
||||
SELF_CHECK (gdb_tilde_expand (("~" + user).c_str ()) == home);
|
||||
SELF_CHECK (gdb_tilde_expand (("~" + user + "/a/b").c_str ())
|
||||
== home + "/a/b");
|
||||
== home + "/a/b");
|
||||
}
|
||||
|
||||
/* Check that an error is thrown when trying to expand home of a unknown
|
||||
@@ -77,8 +77,8 @@ do_test ()
|
||||
{
|
||||
SELF_CHECK (e.error == GENERIC_ERROR);
|
||||
SELF_CHECK
|
||||
(*e.message
|
||||
== "Could not find a match for '~no_one_should_have_that_login'.");
|
||||
(*e.message
|
||||
== "Could not find a match for '~no_one_should_have_that_login'.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+4
-4
@@ -1634,10 +1634,10 @@ value::set_component_location (const struct value *whole)
|
||||
By changing the type of the component to lval_memory we ensure
|
||||
that value_fetch_lazy can successfully load the component.
|
||||
|
||||
This solution isn't ideal, but a real fix would require values to
|
||||
carry around both the parent value contents, and the contents of
|
||||
any dynamic fields within the parent. This is a substantial
|
||||
change to how values work in GDB. */
|
||||
This solution isn't ideal, but a real fix would require values to
|
||||
carry around both the parent value contents, and the contents of
|
||||
any dynamic fields within the parent. This is a substantial
|
||||
change to how values work in GDB. */
|
||||
if (this->lval () == lval_internalvar_component)
|
||||
{
|
||||
gdb_assert (lazy ());
|
||||
|
||||
+1
-1
@@ -928,7 +928,7 @@ z80_read_overlay_region_table ()
|
||||
byte_order = gdbarch_byte_order (gdbarch);
|
||||
|
||||
cache_novly_regions = read_memory_integer (novly_regions_msym.value_address (),
|
||||
4, byte_order);
|
||||
4, byte_order);
|
||||
cache_ovly_region_table
|
||||
= (unsigned int (*)[3]) xmalloc (cache_novly_regions *
|
||||
sizeof (*cache_ovly_region_table));
|
||||
|
||||
@@ -3540,7 +3540,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
|
||||
else
|
||||
{
|
||||
/* The LWP stopped due to a plain signal or a syscall signal. Either way,
|
||||
event_chid->waitstatus wasn't filled in with the details, so look at
|
||||
event_chid->waitstatus wasn't filled in with the details, so look at
|
||||
the wait status W. */
|
||||
if (WSTOPSIG (w) == SYSCALL_SIGTRAP)
|
||||
{
|
||||
|
||||
+1
-1
@@ -59,7 +59,7 @@
|
||||
#define FILEIO_S_IRWXO 07
|
||||
#define FILEIO_S_SUPPORTED (FILEIO_S_IFREG|FILEIO_S_IFDIR| \
|
||||
FILEIO_S_IRWXU|FILEIO_S_IRWXG| \
|
||||
FILEIO_S_IRWXO)
|
||||
FILEIO_S_IRWXO)
|
||||
|
||||
/* lseek(2) flags */
|
||||
#define FILEIO_SEEK_SET 0
|
||||
|
||||
@@ -527,7 +527,7 @@ read_text_file_to_string (const char *path)
|
||||
gdb_assert (n < chunk_size);
|
||||
|
||||
/* Less than CHUNK means EOF or error. If it's an error, return
|
||||
no value. */
|
||||
no value. */
|
||||
if (ferror (file.get ()))
|
||||
return {};
|
||||
|
||||
|
||||
@@ -90,10 +90,8 @@ gdb_tilde_expand (const char *dir)
|
||||
/* Look for the first dir separator (if any) and split d around it. */
|
||||
const auto first_sep
|
||||
= std::find_if (d.cbegin (), d.cend(),
|
||||
[] (const char c) -> bool
|
||||
{
|
||||
return IS_DIR_SEPARATOR (c);
|
||||
});
|
||||
[] (const char c) -> bool
|
||||
{ return IS_DIR_SEPARATOR (c); });
|
||||
const std::string to_expand (d.cbegin (), first_sep);
|
||||
const std::string remainder (first_sep, d.cend ());
|
||||
|
||||
|
||||
+10
-10
@@ -194,14 +194,14 @@ private:
|
||||
for (const token *dep : m_observers[index].dependencies)
|
||||
{
|
||||
/* ... find the observer that has token DEP. If found, visit it. */
|
||||
auto it_dep
|
||||
= std::find_if (m_observers.begin (), m_observers.end (),
|
||||
[&] (observer o) { return o.token == dep; });
|
||||
if (it_dep != m_observers.end ())
|
||||
{
|
||||
int i = std::distance (m_observers.begin (), it_dep);
|
||||
visit_for_sorting (sorted_observers, visit_states, i);
|
||||
}
|
||||
auto it_dep
|
||||
= std::find_if (m_observers.begin (), m_observers.end (),
|
||||
[&] (observer o) { return o.token == dep; });
|
||||
if (it_dep != m_observers.end ())
|
||||
{
|
||||
int i = std::distance (m_observers.begin (), it_dep);
|
||||
visit_for_sorting (sorted_observers, visit_states, i);
|
||||
}
|
||||
}
|
||||
|
||||
visit_states[index] = detail::visit_state::VISITED;
|
||||
@@ -226,11 +226,11 @@ private:
|
||||
}
|
||||
|
||||
void attach (const func_type &f, const token *t, const char *name,
|
||||
const std::vector<const struct token *> &dependencies)
|
||||
const std::vector<const struct token *> &dependencies)
|
||||
{
|
||||
|
||||
observer_debug_printf ("Attaching observable %s to observer %s",
|
||||
name, m_name);
|
||||
name, m_name);
|
||||
|
||||
m_observers.emplace_back (t, f, name, dependencies);
|
||||
|
||||
|
||||
@@ -271,9 +271,7 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last,
|
||||
debug_printf (_("\n"));
|
||||
}
|
||||
results.post (i, [=] ()
|
||||
{
|
||||
return callback (first, end);
|
||||
});
|
||||
{ return callback (first, end); });
|
||||
first = end;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user