}
-/* Assuming TYPE is a TYPE_CODE_STRUCT or a TYPE_CODE_TYPDEF to
+/* Assuming TYPE is a TYPE_CODE_STRUCT or a TYPE_CODE_TYPEDEF to
a TYPE_CODE_STRUCT, find the field whose name matches FIELD_NAME,
and return its index. This function also handles fields whose name
have ___ suffixes because the compiler sometimes alters their name
/* If our type is an access to an unconstrained array, which is encoded
as a TYPE_CODE_TYPEDEF of a fat pointer, then we're done.
- We don't want to strip the TYPE_CODE_TYPDEF layer, because this is
+ We don't want to strip the TYPE_CODE_TYPEDEF layer, because this is
what allows us to distinguish between fat pointers that represent
array types, and fat pointers that represent array access types
(in both cases, the compiler implements them as fat pointers). */
/* Get the type for Ada_Task_Control_Block.Common. */
common_type = common_atcb_sym->type ();
- /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
+ /* Get the type for Ada_Task_Control_Block.Common.Call.LL. */
ll_type = private_data_sym->type ();
/* Get the type for Common_ATCB.Call.all. */
}
/* Helper function that temporarily disables FLAGS->PRINT_OFFSETS,
- calls 'c_print_type_1', and then reenables FLAGS->PRINT_OFFSETS if
+ calls 'c_print_type_1', and then re-enables FLAGS->PRINT_OFFSETS if
applicable. */
static void
if (overlay_debugging)
{
struct objfile *var_objfile = var->objfile ();
- addr = symbol_overlayed_address (var->value_address (),
+ addr = symbol_overlaid_address (var->value_address (),
var->obj_section (var_objfile));
}
else
case LOC_STATIC:
if (overlay_debugging)
addr
- = symbol_overlayed_address (var->value_address (),
+ = symbol_overlaid_address (var->value_address (),
var->obj_section (var->objfile ()));
else
addr = var->value_address ();
case LOC_BLOCK:
if (overlay_debugging)
- addr = symbol_overlayed_address
+ addr = symbol_overlaid_address
(var->value_block ()->entry_pc (),
var->obj_section (var->objfile ()));
else
else
addr = bmsym.value_address ();
if (overlay_debugging)
- addr = symbol_overlayed_address (addr, obj_section);
+ addr = symbol_overlaid_address (addr, obj_section);
/* Determine address of TLS variable. */
if (obj_section
&& (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
char cpuid_vendor[13];
unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
unsigned true_dos_version = _get_dos_version (1);
- unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
+ unsigned advertised_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
int dpmi_flags;
char dpmi_vendor_info[129];
int dpmi_vendor_available;
gdb_puts ("\n");
gdb_printf ("DOS Version....................%s %s.%s",
_os_flavor, u.release, u.version);
- if (true_dos_version != advertized_dos_version)
+ if (true_dos_version != advertised_dos_version)
gdb_printf (" (disguised as v%d.%d)", _osmajor, _osminor);
gdb_puts ("\n");
if (!windows_major)
}
gdb_printf ("%s)\n", windows_flavor);
}
- else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
+ else if (true_dos_version == 0x532 && advertised_dos_version == 0x500)
gdb_printf ("Windows Version................"
"Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
gdb_puts ("\n");
(const char *func_name, int obj_arg_pos, SCM obj, SCM *except_scmp,
struct gdbarch *gdbarch, const struct language_defn *language);
\f
-/* stript_lang methods */
+/* script_lang methods */
extern objfile_script_sourcer_func gdbscm_source_objfile_script;
extern objfile_script_executor_func gdbscm_execute_objfile_script;
the expected stops. */
static void
-reenable_target_async ()
+re_enable_target_async ()
{
for (inferior *inf : all_inferiors ())
{
if (pass > 0)
pass = -1;
- reenable_target_async ();
+ re_enable_target_async ();
for (int i = 0; i < waits_needed; i++)
{
addr = bound_msym.value_address ();
if (overlay_debugging)
- addr = symbol_overlayed_address (addr, section);
+ addr = symbol_overlaid_address (addr, section);
if (is_tls)
{
heapq.heappush(self._reqs, req)
@contextmanager
- def interruptable_region(self, req):
+ def interruptible_region(self, req):
"""Return a new context manager that sets in_flight_gdb_thread to
REQ."""
if req is None:
@in_gdb_thread
def __call__(self):
try:
- with _server.canceller.interruptable_region(self.req):
+ with _server.canceller.interruptible_region(self.req):
val = self._fn()
if self._result_q is not None:
self._result_q.put(val)
return;
gdbpy_enter enter_py (objfile->arch ());
- scoped_restore restire_current_objfile
+ scoped_restore restore_current_objfile
= make_scoped_restore (&gdbpy_current_objfile, objfile);
int result = python_run_simple_file (file, filename);
return;
gdbpy_enter enter_py (objfile->arch ());
- scoped_restore restire_current_objfile
+ scoped_restore restore_current_objfile
= make_scoped_restore (&gdbpy_current_objfile, objfile);
int ret = eval_python_command (script, Py_file_input);
#define P_PPC_D(insn_prefix, insn_suffix) \
PPC_SEXT (PPC_FIELD (insn_prefix, 14, 18) << 16 \
| PPC_FIELD (insn_suffix, 16, 16), 34)
-#define P_PPC_TX5(insn_sufix) PPC_BIT (insn_suffix, 5)
+#define P_PPC_TX5(insn_suffix) PPC_BIT (insn_suffix, 5)
#define P_PPC_TX15(insn_suffix) PPC_BIT (insn_suffix, 15)
#define P_PPC_XT(insn_suffix) ((PPC_TX (insn_suffix) << 5) \
| PPC_T (insn_suffix))
movew sp@,d1 /* get status register */
movew d1,a5@(66) /* save sr */
movel sp@(2),a4 /* save pc in a4 for later use */
- movel a4,a5@(68) /* save pc in _regisers[] */
+ movel a4,a5@(68) /* save pc in _registers[] */
#
# figure out how many bytes in the stack frame
movew sp@+,d1 /* pop status register */
movel sp@+,a4 /* pop program counter */
movew d1,a5@(66) /* save sr */
- movel a4,a5@(68) /* save pc in _regisers[] */
+ movel a4,a5@(68) /* save pc in _registers[] */
movel a4,a0@- /* copy pc to frame buffer */
movew d1,a0@- /* copy sr to frame buffer */
sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
overlay_mapped_address(...): map an address from section's LMA to VMA
overlay_unmapped_address(...): map an address from section's VMA to LMA
- symbol_overlayed_address(...): Return a "current" address for symbol:
+ symbol_overlaid_address(...): Return a "current" address for symbol:
either in VMA or LMA depending on whether
the symbol's section is currently mapped. */
return pc;
}
-/* Function: symbol_overlayed_address
+/* Function: symbol_overlaid_address
Return one of two addresses (relative to the VMA or to the LMA),
depending on whether the section is mapped or not. */
CORE_ADDR
-symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
+symbol_overlaid_address (CORE_ADDR address, struct obj_section *section)
{
if (overlay_debugging)
{
extern CORE_ADDR overlay_unmapped_address (CORE_ADDR, struct obj_section *);
/* Convert an address in an overlay section (force into VMA range). */
-extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
+extern CORE_ADDR symbol_overlaid_address (CORE_ADDR, struct obj_section *);
/* Load symbols from a file. */
extern void symbol_file_add_main (const char *args,
struct obj_section *obj_section (const struct objfile *objfile) const;
};
-extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
+extern CORE_ADDR symbol_overlaid_address (CORE_ADDR, struct obj_section *);
/* Try to determine the demangled name for a symbol, based on the
language of that symbol. If the language is set to language_auto,
After running the tests, you shall see a file name 'racy.sum' in the
gdb/testsuite directory. You can also inspect the generated *.log and
-*.sum files by looking into the gdb/testsuite/racy_ouputs directory.
+*.sum files by looking into the gdb/testsuite/racy_outputs directory.
If you already have *.sum files generated from previous testsuite runs
and you would like to analyze them without having to run the testsuite
# We'll catch unhandled exceptions
# - continue, we should see the first Program_Error exception
# - continue, we should see the failed assertion
-# - continue, we should see the unhandled Constrait_Error exception
+# - continue, we should see the unhandled Constraint_Error exception
# - continue, the program exits.
if {![runto_main]} {
# We'll catch unhandled exceptions
# - continue, we should see the first Program_Error exception
# - continue, we should see the failed assertion
-# - continue, we should see the unhandled Constrait_Error exception
+# - continue, we should see the unhandled Constraint_Error exception
# - continue, the program exits.
with_test_prefix "scenario 2" {
# When kept in object file (before final executable link) it still works.
# When separate debug info file is not used it still works.
# When the ELF symbol table is kept in the main binary it still works.
-# Used .S file as in .c file we would need __attriute__((section)) which is
+# Used .S file as in .c file we would need __attribute__((section)) which is
# a GCC extension.
# This test can only be run on targets which support ELF and use gas.
if {${follow-fork-mode} == "parent"} {
set following_inf 1
} else {
- set followin_inf 2
+ set following_inf 2
}
# Next stop should be the fork catchpoint.
set expected_re ""
.*ldo 5\\(r26\\),r26.*
.*ldil -21524800,r26.*
.*addil -21524800,r5.*
-.*$gdb_prompt $" { pass "immedate_tests" }
- -re "$gdb_prompt $" { fail "immedate_tests" }
- timeout { fail "(timeout) immedate_tests " }
+.*$gdb_prompt $" { pass "immediate_tests" }
+ -re "$gdb_prompt $" { fail "immediate_tests" }
+ timeout { fail "(timeout) immediate_tests " }
}
}
.*sync.*
.*syncdma.*
.*diag 4d2.*
-.*$gdb_prompt $" { pass "system_constrol_tests" }
+.*$gdb_prompt $" { pass "system_control_tests" }
-re "$gdb_prompt $" { fail "system_control_tests" }
timeout { file "(timeout) system_control_tests" }
}
.uleb128 0x13 /* (DW_AT_language) */
.uleb128 0xb /* (DW_FORM_data1) */
.uleb128 0x3 /* (DW_AT_name) */
- .uleb128 0x8 /* (DW_FORM_sting) */
+ .uleb128 0x8 /* (DW_FORM_string) */
.byte 0x0
.byte 0x0
# the entry_pc attribute is not given. The function's entry PC will
# default to the low address.
-proc_with_prefix use_low_high_bounds_without_entry_pc { dwarf_vesion } {
+proc_with_prefix use_low_high_bounds_without_entry_pc { dwarf_version } {
set suffix [get_next_suffix]
# Make some DWARF for the test.
set asm_file [standard_output_file "$::testfile-dw-$suffix.S"]
Dwarf::assemble $asm_file {
+ upvar dwarf_version dwarf_version
global srcfile
declare_labels lines_table
- cu { version $::dwarf_version } {
+ cu { version $dwarf_version } {
compile_unit {
DW_AT_producer "gcc"
DW_AT_language @DW_LANG_C
declare_labels lines_table ranges_label
- cu { version $::dwarf_version } {
+ cu { version $dwarf_version } {
compile_unit {
DW_AT_producer "gcc"
DW_AT_language @DW_LANG_C
declare_labels lines_table ranges_label
- cu { version $::dwarf_version } {
+ cu { version $dwarf_version } {
compile_unit {
DW_AT_producer "gcc"
DW_AT_language @DW_LANG_C
set foo_offset [expr {$::foo_middle_addr - $::r1_s}]
- cu { version $::dwarf_version } {
+ cu { version $dwarf_version } {
compile_unit {
DW_AT_producer "gcc"
DW_AT_language @DW_LANG_C
return 0
}
-proc test_exec_and_symbol_mi_operatons {} {
+proc test_exec_and_symbol_mi_operations {} {
global mi_gdb_prompt
global binfile testfile
}
if { [test_mi_interpreter_selection]
- && [test_exec_and_symbol_mi_operatons] } {
+ && [test_exec_and_symbol_mi_operations] } {
test_breakpoints_deletion
test_dir_specification
test_cwd_specification
};
-void use_rtti_with_multiple_inheritence_test ()
+void use_rtti_with_multiple_inheritance_test ()
{
- /*: BEGIN: use_rtti_with_multiple_inheritence :*/
+ /*: BEGIN: use_rtti_with_multiple_inheritance :*/
MultipleDerived d;
Base* ptr = &d;
Base& ref = d;
/*:
- set testname use_rtti_with_multiple_inheritence
+ set testname use_rtti_with_multiple_inheritance
set_print_object off $testname
check_new_derived_without_rtti ptr {Base \*} $testname
check_new_derived_without_rtti ref {Base \&} $testname
"delete varobj for ptr (with RTTI) in $testname"
:*/
return;
- /*: END: use_rtti_with_multiple_inheritence :*/
+ /*: END: use_rtti_with_multiple_inheritance :*/
}
use_rtti_for_ref_test();
use_rtti_for_ptr_child_test();
use_rtti_for_ref_child_test();
- use_rtti_with_multiple_inheritence_test();
+ use_rtti_with_multiple_inheritance_test();
type_update_when_use_rtti_test();
skip_type_update_when_not_use_rtti_test();
return 0;
use_rtti_for_ref
use_rtti_for_ptr_child
use_rtti_for_ref_child
- use_rtti_with_multiple_inheritence
+ use_rtti_with_multiple_inheritance
type_update_when_use_rtti
skip_type_update_when_not_use_rtti
}
# Type exploration tests
########################
-proc scalar_type_decsription {type} {
+proc scalar_type_description {type} {
return "'$type' is a scalar type\."
}
set CU_field_1 "field 'sa' of 'union ComplexUnion'"
set CU_field_1_array_element "an array element of $CU_field_1"
-gdb_test "explore int" ".*[scalar_type_decsription {int}].*"
+gdb_test "explore int" ".*[scalar_type_description {int}].*"
gdb_test_multiple "explore struct SimpleStruct" "" {
-re ".*[compound_type_description $SS {struct/class}].*$SS_fields_types.*" {
{
for (tui_register_info &data_item_win : m_regs_content)
{
- bool was_hilighted = data_item_win.highlighted ();
+ bool was_highlighted = data_item_win.highlighted ();
data_item_win.update (frame);
- if ((data_item_win.highlighted () || was_hilighted)
+ if ((data_item_win.highlighted () || was_highlighted)
&& data_item_win.visible ())
data_item_win.rerender (handle.get (), m_item_width);
}
/* Put EVENT to the queue of NOTIF. */
void
-notif_event_enque (struct notif_server *notif,
+notif_event_enqueue (struct notif_server *notif,
struct notif_event *event)
{
notif->queue.push_back (event);
bool is_first_event = np->queue.empty ();
/* Something interesting. Tell GDB about it. */
- notif_event_enque (np, new_event);
+ notif_event_enqueue (np, new_event);
/* If this is the first stop reply in the queue, then inform GDB
about it, by sending a corresponding notification. */
void notif_write_event (struct notif_server *notif, char *own_buf);
void notif_push (struct notif_server *np, struct notif_event *event);
-void notif_event_enque (struct notif_server *notif,
+void notif_event_enqueue (struct notif_server *notif,
struct notif_event *event);
#endif /* GDBSERVER_NOTIF_H */
new_notif->ptid = ptid;
new_notif->status = status;
- notif_event_enque (¬if_stop, new_notif);
+ notif_event_enqueue (¬if_stop, new_notif);
}
static bool
new_notif->status = thread->last_status;
/* Pass the last stop reply back to GDB, but don't notify
yet. */
- notif_event_enque (¬if_stop, new_notif);
+ notif_event_enqueue (¬if_stop, new_notif);
}
else
{
projects / thirdparty / binutils-gdb.git / commitdiff
