#include "gdb_regex.h"
#include "job-control.h"
#include "common/selftest.h"
+#include "common/gdb_optional.h"
+#include "cp-support.h"
+#include <algorithm>
#if !HAVE_DECL_MALLOC
extern PTR malloc (); /* ARI: PTR */
return make_cleanup (do_free_section_addr_info, addrs);
}
-struct restore_integer_closure
-{
- int *variable;
- int value;
-};
-
-static void
-restore_integer (void *p)
-{
- struct restore_integer_closure *closure
- = (struct restore_integer_closure *) p;
-
- *(closure->variable) = closure->value;
-}
-
-/* Remember the current value of *VARIABLE and make it restored when
- the cleanup is run. */
-
-struct cleanup *
-make_cleanup_restore_integer (int *variable)
-{
- struct restore_integer_closure *c = XNEW (struct restore_integer_closure);
-
- c->variable = variable;
- c->value = *variable;
-
- return make_cleanup_dtor (restore_integer, (void *) c, xfree);
-}
-
-/* Remember the current value of *VARIABLE and make it restored when
- the cleanup is run. */
-
-struct cleanup *
-make_cleanup_restore_uinteger (unsigned int *variable)
-{
- return make_cleanup_restore_integer ((int *) variable);
-}
-
/* Helper for make_cleanup_unpush_target. */
static void
return make_cleanup (do_value_free_to_mark, mark);
}
-/* Helper for make_cleanup_value_free. */
-
-static void
-do_value_free (void *value)
-{
- value_free ((struct value *) value);
-}
-
-/* Free VALUE. */
-
-struct cleanup *
-make_cleanup_value_free (struct value *value)
-{
- return make_cleanup (do_value_free, value);
-}
-
/* This function is useful for cleanups.
Do
(*deprecated_warning_hook) (string, args);
else
{
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
-
+ gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
if (target_supports_terminal_ours ())
{
- make_cleanup_restore_target_terminal ();
- target_terminal_ours_for_output ();
+ term_state.emplace ();
+ target_terminal::ours_for_output ();
}
if (filtered_printing_initialized ())
wrap_here (""); /* Force out any buffered output. */
fputs_unfiltered (warning_pre_print, gdb_stderr);
vfprintf_unfiltered (gdb_stderr, string, args);
fprintf_unfiltered (gdb_stderr, "\n");
-
- do_cleanups (old_chain);
}
}
static int dejavu;
int quit_p;
int dump_core_p;
- char *reason;
- struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
+ std::string reason;
/* Don't allow infinite error/warning recursion. */
{
style similar to a compiler error message. Include extra detail
so that the user knows that they are living on the edge. */
{
- char *msg;
-
- msg = xstrvprintf (fmt, ap);
- reason = xstrprintf ("%s:%d: %s: %s\n"
- "A problem internal to GDB has been detected,\n"
- "further debugging may prove unreliable.",
- file, line, problem->name, msg);
- xfree (msg);
- make_cleanup (xfree, reason);
+ std::string msg = string_vprintf (fmt, ap);
+ reason = string_printf ("%s:%d: %s: %s\n"
+ "A problem internal to GDB has been detected,\n"
+ "further debugging may prove unreliable.",
+ file, line, problem->name, msg.c_str ());
}
/* Fall back to abort_with_message if gdb_stderr is not set up. */
if (current_ui == NULL)
{
- fputs (reason, stderr);
+ fputs (reason.c_str (), stderr);
abort_with_message ("\n");
}
/* Try to get the message out and at the start of a new line. */
+ gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
if (target_supports_terminal_ours ())
{
- make_cleanup_restore_target_terminal ();
- target_terminal_ours_for_output ();
+ term_state.emplace ();
+ target_terminal::ours_for_output ();
}
if (filtered_printing_initialized ())
begin_line ();
if (problem->should_quit != internal_problem_ask
|| !confirm
|| !filtered_printing_initialized ())
- fprintf_unfiltered (gdb_stderr, "%s\n", reason);
+ fprintf_unfiltered (gdb_stderr, "%s\n", reason.c_str ());
if (problem->should_quit == internal_problem_ask)
{
if (!confirm || !filtered_printing_initialized ())
quit_p = 1;
else
- quit_p = query (_("%s\nQuit this debugging session? "), reason);
+ quit_p = query (_("%s\nQuit this debugging session? "),
+ reason.c_str ());
}
else if (problem->should_quit == internal_problem_yes)
quit_p = 1;
if (problem->should_dump_core == internal_problem_ask)
{
- if (!can_dump_core_warn (LIMIT_MAX, reason))
+ if (!can_dump_core_warn (LIMIT_MAX, reason.c_str ()))
dump_core_p = 0;
else if (!filtered_printing_initialized ())
dump_core_p = 1;
/* Default (yes/batch case) is to dump core. This leaves a GDB
`dropping' so that it is easier to see that something went
wrong in GDB. */
- dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
+ dump_core_p = query (_("%s\nCreate a core file of GDB? "),
+ reason.c_str ());
}
}
else if (problem->should_dump_core == internal_problem_yes)
- dump_core_p = can_dump_core_warn (LIMIT_MAX, reason);
+ dump_core_p = can_dump_core_warn (LIMIT_MAX, reason.c_str ());
else if (problem->should_dump_core == internal_problem_no)
dump_core_p = 0;
else
}
dejavu = 0;
- do_cleanups (cleanup);
}
static struct internal_problem internal_error_problem = {
/* Dummy functions to keep add_prefix_cmd happy. */
static void
-set_internal_problem_cmd (char *args, int from_tty)
+set_internal_problem_cmd (const char *args, int from_tty)
{
}
static void
-show_internal_problem_cmd (char *args, int from_tty)
+show_internal_problem_cmd (const char *args, int from_tty)
{
}
show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
problem->name);
- add_prefix_cmd ((char*) problem->name,
+ add_prefix_cmd (problem->name,
class_maintenance, set_internal_problem_cmd, set_doc,
set_cmd_list,
concat ("maintenance set ", problem->name, " ",
(char *) NULL),
0/*allow-unknown*/, &maintenance_set_cmdlist);
- add_prefix_cmd ((char*) problem->name,
+ add_prefix_cmd (problem->name,
class_maintenance, show_internal_problem_cmd, show_doc,
show_cmd_list,
concat ("maintenance show ", problem->name, " ",
void
quit (void)
{
- struct ui *ui = current_ui;
-
if (sync_quit_force_run)
{
sync_quit_force_run = 0;
\f
-/* A cleanup that simply calls ui_unregister_input_event_handler. */
+/* An RAII class that sets up to handle input and then tears down
+ during destruction. */
-static void
-ui_unregister_input_event_handler_cleanup (void *ui)
+class scoped_input_handler
{
- ui_unregister_input_event_handler ((struct ui *) ui);
-}
+public:
+
+ scoped_input_handler ()
+ : m_quit_handler (&quit_handler, default_quit_handler),
+ m_ui (NULL)
+ {
+ target_terminal::ours ();
+ ui_register_input_event_handler (current_ui);
+ if (current_ui->prompt_state == PROMPT_BLOCKED)
+ m_ui = current_ui;
+ }
-/* Set up to handle input. */
+ ~scoped_input_handler ()
+ {
+ if (m_ui != NULL)
+ ui_unregister_input_event_handler (m_ui);
+ }
-static struct cleanup *
-prepare_to_handle_input (void)
-{
- struct cleanup *old_chain;
+ DISABLE_COPY_AND_ASSIGN (scoped_input_handler);
- old_chain = make_cleanup_restore_target_terminal ();
- target_terminal_ours ();
+private:
- ui_register_input_event_handler (current_ui);
- if (current_ui->prompt_state == PROMPT_BLOCKED)
- make_cleanup (ui_unregister_input_event_handler_cleanup, current_ui);
+ /* Save and restore the terminal state. */
+ target_terminal::scoped_restore_terminal_state m_term_state;
- make_cleanup_override_quit_handler (default_quit_handler);
+ /* Save and restore the quit handler. */
+ scoped_restore_tmpl<quit_handler_ftype *> m_quit_handler;
- return old_chain;
-}
+ /* The saved UI, if non-NULL. */
+ struct ui *m_ui;
+};
\f
static int ATTRIBUTE_PRINTF (1, 0)
defaulted_query (const char *ctlstr, const char defchar, va_list args)
{
- int ans2;
int retval;
int def_value;
char def_answer, not_def_answer;
const char *y_string, *n_string;
- char *question, *prompt;
- struct cleanup *old_chain;
/* Set up according to which answer is the default. */
if (defchar == '\0')
/* Restrict queries to the main UI. */
|| current_ui != main_ui)
{
- old_chain = make_cleanup_restore_target_terminal ();
-
- target_terminal_ours_for_output ();
+ target_terminal::scoped_restore_terminal_state term_state;
+ target_terminal::ours_for_output ();
wrap_here ("");
vfprintf_filtered (gdb_stdout, ctlstr, args);
y_string, n_string, def_answer);
gdb_flush (gdb_stdout);
- do_cleanups (old_chain);
return def_value;
}
if (deprecated_query_hook)
{
- int res;
-
- old_chain = make_cleanup_restore_target_terminal ();
- res = deprecated_query_hook (ctlstr, args);
- do_cleanups (old_chain);
- return res;
+ target_terminal::scoped_restore_terminal_state term_state;
+ return deprecated_query_hook (ctlstr, args);
}
/* Format the question outside of the loop, to avoid reusing args. */
- question = xstrvprintf (ctlstr, args);
- old_chain = make_cleanup (xfree, question);
- prompt = xstrprintf (_("%s%s(%s or %s) %s"),
- annotation_level > 1 ? "\n\032\032pre-query\n" : "",
- question, y_string, n_string,
- annotation_level > 1 ? "\n\032\032query\n" : "");
- make_cleanup (xfree, prompt);
+ std::string question = string_vprintf (ctlstr, args);
+ std::string prompt
+ = string_printf (_("%s%s(%s or %s) %s"),
+ annotation_level > 1 ? "\n\032\032pre-query\n" : "",
+ question.c_str (), y_string, n_string,
+ annotation_level > 1 ? "\n\032\032query\n" : "");
/* Used to add duration we waited for user to respond to
prompt_for_continue_wait_time. */
using namespace std::chrono;
steady_clock::time_point prompt_started = steady_clock::now ();
- prepare_to_handle_input ();
+ scoped_input_handler prepare_input;
while (1)
{
char *response, answer;
gdb_flush (gdb_stdout);
- response = gdb_readline_wrapper (prompt);
+ response = gdb_readline_wrapper (prompt.c_str ());
if (response == NULL) /* C-d */
{
if (annotation_level > 1)
printf_filtered (("\n\032\032post-query\n"));
- do_cleanups (old_chain);
return retval;
}
\f
return wrap_buffer != NULL;
}
-/* Helper for make_cleanup_restore_page_info. */
-
-static void
-do_restore_page_info_cleanup (void *arg)
-{
- set_screen_size ();
- set_width ();
-}
-
-/* Provide cleanup for restoring the terminal size. */
-
-struct cleanup *
-make_cleanup_restore_page_info (void)
+set_batch_flag_and_restore_page_info::set_batch_flag_and_restore_page_info ()
+ : m_save_lines_per_page (lines_per_page),
+ m_save_chars_per_line (chars_per_line),
+ m_save_batch_flag (batch_flag)
{
- struct cleanup *back_to;
-
- back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
- make_cleanup_restore_uinteger (&lines_per_page);
- make_cleanup_restore_uinteger (&chars_per_line);
-
- return back_to;
+ batch_flag = 1;
+ init_page_info ();
}
-/* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
- Provide cleanup for restoring the original state. */
-
-struct cleanup *
-set_batch_flag_and_make_cleanup_restore_page_info (void)
+set_batch_flag_and_restore_page_info::~set_batch_flag_and_restore_page_info ()
{
- struct cleanup *back_to = make_cleanup_restore_page_info ();
-
- make_cleanup_restore_integer (&batch_flag);
- batch_flag = 1;
- init_page_info ();
+ batch_flag = m_save_batch_flag;
+ chars_per_line = m_save_chars_per_line;
+ lines_per_page = m_save_lines_per_page;
- return back_to;
+ set_screen_size ();
+ set_width ();
}
/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
}
static void
-set_width_command (char *args, int from_tty, struct cmd_list_element *c)
+set_width_command (const char *args, int from_tty, struct cmd_list_element *c)
{
set_screen_size ();
set_width ();
}
static void
-set_height_command (char *args, int from_tty, struct cmd_list_element *c)
+set_height_command (const char *args, int from_tty, struct cmd_list_element *c)
{
set_screen_size ();
}
beyond the end of the screen. */
reinitialize_more_filter ();
- prepare_to_handle_input ();
+ scoped_input_handler prepare_input;
/* Call gdb_readline_wrapper, not readline, in order to keep an
event loop running. */
vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
va_list args, int filter)
{
- char *linebuffer;
- struct cleanup *old_cleanups;
-
- linebuffer = xstrvprintf (format, args);
- old_cleanups = make_cleanup (xfree, linebuffer);
- fputs_maybe_filtered (linebuffer, stream, filter);
- do_cleanups (old_cleanups);
+ std::string linebuffer = string_vprintf (format, args);
+ fputs_maybe_filtered (linebuffer.c_str (), stream, filter);
}
void
vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
{
- char *linebuffer;
- struct cleanup *old_cleanups;
-
- linebuffer = xstrvprintf (format, args);
- old_cleanups = make_cleanup (xfree, linebuffer);
+ std::string linebuffer = string_vprintf (format, args);
if (debug_timestamp && stream == gdb_stdlog)
{
using namespace std::chrono;
seconds s = duration_cast<seconds> (now.time_since_epoch ());
microseconds us = duration_cast<microseconds> (now.time_since_epoch () - s);
- len = strlen (linebuffer);
+ len = linebuffer.size ();
need_nl = (len > 0 && linebuffer[len - 1] != '\n');
std::string timestamp = string_printf ("%ld.%06ld %s%s",
(long) s.count (),
(long) us.count (),
- linebuffer, need_nl ? "\n": "");
+ linebuffer.c_str (),
+ need_nl ? "\n": "");
fputs_unfiltered (timestamp.c_str (), stream);
}
else
- fputs_unfiltered (linebuffer, stream);
- do_cleanups (old_cleanups);
+ fputs_unfiltered (linebuffer.c_str (), stream);
}
void
}
}
-/* Modes of operation for strncmp_iw_with_mode. */
+/* True if CH is a character that can be part of a symbol name. I.e.,
+ either a number, a letter, or a '_'. */
-enum class strncmp_iw_mode
+static bool
+valid_identifier_name_char (int ch)
{
- /* Work like strncmp, while ignoring whitespace. */
- NORMAL,
+ return (isalnum (ch) || ch == '_');
+}
- /* Like NORMAL, but also apply the strcmp_iw hack. I.e.,
- string1=="FOO(PARAMS)" matches string2=="FOO". */
- MATCH_PARAMS,
-};
+/* Skip to end of token, or to END, whatever comes first. Input is
+ assumed to be a C++ operator name. */
-/* Helper for strncmp_iw and strcmp_iw. */
+static const char *
+cp_skip_operator_token (const char *token, const char *end)
+{
+ const char *p = token;
+ while (p != end && !isspace (*p) && *p != '(')
+ {
+ if (valid_identifier_name_char (*p))
+ {
+ while (p != end && valid_identifier_name_char (*p))
+ p++;
+ return p;
+ }
+ else
+ {
+ /* Note, ordered such that among ops that share a prefix,
+ longer comes first. This is so that the loop below can
+ bail on first match. */
+ static const char *ops[] =
+ {
+ "[",
+ "]",
+ "~",
+ ",",
+ "-=", "--", "->", "-",
+ "+=", "++", "+",
+ "*=", "*",
+ "/=", "/",
+ "%=", "%",
+ "|=", "||", "|",
+ "&=", "&&", "&",
+ "^=", "^",
+ "!=", "!",
+ "<<=", "<=", "<<", "<",
+ ">>=", ">=", ">>", ">",
+ "==", "=",
+ };
+
+ for (const char *op : ops)
+ {
+ size_t oplen = strlen (op);
+ size_t lencmp = std::min<size_t> (oplen, end - p);
-static int
+ if (strncmp (p, op, lencmp) == 0)
+ return p + lencmp;
+ }
+ /* Some unidentified character. Return it. */
+ return p + 1;
+ }
+ }
+
+ return p;
+}
+
+/* Advance STRING1/STRING2 past whitespace. */
+
+static void
+skip_ws (const char *&string1, const char *&string2, const char *end_str2)
+{
+ while (isspace (*string1))
+ string1++;
+ while (string2 < end_str2 && isspace (*string2))
+ string2++;
+}
+
+/* True if STRING points at the start of a C++ operator name. START
+ is the start of the string that STRING points to, hence when
+ reading backwards, we must not read any character before START. */
+
+static bool
+cp_is_operator (const char *string, const char *start)
+{
+ return ((string == start
+ || !valid_identifier_name_char (string[-1]))
+ && strncmp (string, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0
+ && !valid_identifier_name_char (string[CP_OPERATOR_LEN]));
+}
+
+/* If *NAME points at an ABI tag, skip it and return true. Otherwise
+ leave *NAME unmodified and return false. (see GCC's abi_tag
+ attribute), such names are demangled as e.g.,
+ "function[abi:cxx11]()". */
+
+static bool
+skip_abi_tag (const char **name)
+{
+ const char *p = *name;
+
+ if (startswith (p, "[abi:"))
+ {
+ p += 5;
+
+ while (valid_identifier_name_char (*p))
+ p++;
+
+ if (*p == ']')
+ {
+ p++;
+ *name = p;
+ return true;
+ }
+ }
+ return false;
+}
+
+/* See utils.h. */
+
+int
strncmp_iw_with_mode (const char *string1, const char *string2,
- size_t string2_len, strncmp_iw_mode mode)
+ size_t string2_len, strncmp_iw_mode mode,
+ enum language language,
+ completion_match_for_lcd *match_for_lcd)
{
+ const char *string1_start = string1;
const char *end_str2 = string2 + string2_len;
+ bool skip_spaces = true;
+ bool have_colon_op = (language == language_cplus
+ || language == language_rust
+ || language == language_fortran);
while (1)
{
- while (isspace (*string1))
- string1++;
- while (string2 < end_str2 && isspace (*string2))
- string2++;
+ if (skip_spaces
+ || ((isspace (*string1) && !valid_identifier_name_char (*string2))
+ || (isspace (*string2) && !valid_identifier_name_char (*string1))))
+ {
+ skip_ws (string1, string2, end_str2);
+ skip_spaces = false;
+ }
+
+ /* Skip [abi:cxx11] tags in the symbol name if the lookup name
+ doesn't include them. E.g.:
+
+ string1: function[abi:cxx1](int)
+ string2: function
+
+ string1: function[abi:cxx1](int)
+ string2: function(int)
+
+ string1: Struct[abi:cxx1]::function()
+ string2: Struct::function()
+
+ string1: function(Struct[abi:cxx1], int)
+ string2: function(Struct, int)
+ */
+ if (string2 == end_str2
+ || (*string2 != '[' && !valid_identifier_name_char (*string2)))
+ {
+ const char *abi_start = string1;
+
+ /* There can be more than one tag. */
+ while (*string1 == '[' && skip_abi_tag (&string1))
+ ;
+
+ if (match_for_lcd != NULL && abi_start != string1)
+ match_for_lcd->mark_ignored_range (abi_start, string1);
+
+ while (isspace (*string1))
+ string1++;
+ }
+
if (*string1 == '\0' || string2 == end_str2)
break;
+
+ /* Handle the :: operator. */
+ if (have_colon_op && string1[0] == ':' && string1[1] == ':')
+ {
+ if (*string2 != ':')
+ return 1;
+
+ string1++;
+ string2++;
+
+ if (string2 == end_str2)
+ break;
+
+ if (*string2 != ':')
+ return 1;
+
+ string1++;
+ string2++;
+
+ while (isspace (*string1))
+ string1++;
+ while (string2 < end_str2 && isspace (*string2))
+ string2++;
+ continue;
+ }
+
+ /* Handle C++ user-defined operators. */
+ else if (language == language_cplus
+ && *string1 == 'o')
+ {
+ if (cp_is_operator (string1, string1_start))
+ {
+ /* An operator name in STRING1. Check STRING2. */
+ size_t cmplen
+ = std::min<size_t> (CP_OPERATOR_LEN, end_str2 - string2);
+ if (strncmp (string1, string2, cmplen) != 0)
+ return 1;
+
+ string1 += cmplen;
+ string2 += cmplen;
+
+ if (string2 != end_str2)
+ {
+ /* Check for "operatorX" in STRING2. */
+ if (valid_identifier_name_char (*string2))
+ return 1;
+
+ skip_ws (string1, string2, end_str2);
+ }
+
+ /* Handle operator(). */
+ if (*string1 == '(')
+ {
+ if (string2 == end_str2)
+ {
+ if (mode == strncmp_iw_mode::NORMAL)
+ return 0;
+ else
+ {
+ /* Don't break for the regular return at the
+ bottom, because "operator" should not
+ match "operator()", since this open
+ parentheses is not the parameter list
+ start. */
+ return *string1 != '\0';
+ }
+ }
+
+ if (*string1 != *string2)
+ return 1;
+
+ string1++;
+ string2++;
+ }
+
+ while (1)
+ {
+ skip_ws (string1, string2, end_str2);
+
+ /* Skip to end of token, or to END, whatever comes
+ first. */
+ const char *end_str1 = string1 + strlen (string1);
+ const char *p1 = cp_skip_operator_token (string1, end_str1);
+ const char *p2 = cp_skip_operator_token (string2, end_str2);
+
+ cmplen = std::min (p1 - string1, p2 - string2);
+ if (p2 == end_str2)
+ {
+ if (strncmp (string1, string2, cmplen) != 0)
+ return 1;
+ }
+ else
+ {
+ if (p1 - string1 != p2 - string2)
+ return 1;
+ if (strncmp (string1, string2, cmplen) != 0)
+ return 1;
+ }
+
+ string1 += cmplen;
+ string2 += cmplen;
+
+ if (*string1 == '\0' || string2 == end_str2)
+ break;
+ if (*string1 == '(' || *string2 == '(')
+ break;
+ }
+
+ continue;
+ }
+ }
+
if (case_sensitivity == case_sensitive_on && *string1 != *string2)
break;
if (case_sensitivity == case_sensitive_off
!= tolower ((unsigned char) *string2)))
break;
+ /* If we see any non-whitespace, non-identifier-name character
+ (any of "()<>*&" etc.), then skip spaces the next time
+ around. */
+ if (!isspace (*string1) && !valid_identifier_name_char (*string1))
+ skip_spaces = true;
+
string1++;
string2++;
}
if (string2 == end_str2)
{
if (mode == strncmp_iw_mode::NORMAL)
- return 0;
+ {
+ /* Strip abi tag markers from the matched symbol name.
+ Usually the ABI marker will be found on function name
+ (automatically added because the function returns an
+ object marked with an ABI tag). However, it's also
+ possible to see a marker in one of the function
+ parameters, for example.
+
+ string2 (lookup name):
+ func
+ symbol name:
+ function(some_struct[abi:cxx11], int)
+
+ and for completion LCD computation we want to say that
+ the match was for:
+ function(some_struct, int)
+ */
+ if (match_for_lcd != NULL)
+ {
+ while ((string1 = strstr (string1, "[abi:")) != NULL)
+ {
+ const char *abi_start = string1;
+
+ /* There can be more than one tag. */
+ while (skip_abi_tag (&string1) && *string1 == '[')
+ ;
+
+ if (abi_start != string1)
+ match_for_lcd->mark_ignored_range (abi_start, string1);
+ }
+ }
+
+ return 0;
+ }
else
return (*string1 != '\0' && *string1 != '(');
}
strncmp_iw (const char *string1, const char *string2, size_t string2_len)
{
return strncmp_iw_with_mode (string1, string2, string2_len,
- strncmp_iw_mode::NORMAL);
+ strncmp_iw_mode::NORMAL, language_minimal);
}
/* See utils.h. */
strcmp_iw (const char *string1, const char *string2)
{
return strncmp_iw_with_mode (string1, string2, strlen (string2),
- strncmp_iw_mode::MATCH_PARAMS);
+ strncmp_iw_mode::MATCH_PARAMS, language_minimal);
}
/* This is like strcmp except that it ignores whitespace and treats
&setdebuglist, &showdebuglist);
}
+/* See utils.h. */
+
+CORE_ADDR
+address_significant (gdbarch *gdbarch, CORE_ADDR addr)
+{
+ /* Truncate address to the significant bits of a target address,
+ avoiding shifts larger or equal than the width of a CORE_ADDR.
+ The local variable ADDR_BIT stops the compiler reporting a shift
+ overflow when it won't occur. */
+ int addr_bit = gdbarch_significant_addr_bit (gdbarch);
+
+ if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
+ addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
+
+ return addr;
+}
+
const char *
paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
{
return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
}
-/* Check for GCC >= 4.x according to the symtab->producer string. Return minor
- version (x) of 4.x in such case. If it is not GCC or it is GCC older than
- 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
-
-int
-producer_is_gcc_ge_4 (const char *producer)
-{
- int major, minor;
-
- if (! producer_is_gcc (producer, &major, &minor))
- return -1;
- if (major < 4)
- return -1;
- if (major > 4)
- return INT_MAX;
- return minor;
-}
-
-/* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
- and MINOR versions when not NULL. Returns zero if the given PRODUCER
- is NULL or it isn't GCC. */
-
-int
-producer_is_gcc (const char *producer, int *major, int *minor)
-{
- const char *cs;
-
- if (producer != NULL && startswith (producer, "GNU "))
- {
- int maj, min;
-
- if (major == NULL)
- major = &maj;
- if (minor == NULL)
- minor = &min;
-
- /* Skip any identifier after "GNU " - such as "C11" or "C++".
- A full producer string might look like:
- "GNU C 4.7.2"
- "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
- "GNU C++14 5.0.0 20150123 (experimental)"
- */
- cs = &producer[strlen ("GNU ")];
- while (*cs && !isspace (*cs))
- cs++;
- if (*cs && isspace (*cs))
- cs++;
- if (sscanf (cs, "%d.%d", major, minor) == 2)
- return 1;
- }
-
- /* Not recognized as GCC. */
- return 0;
-}
/* Helper for make_cleanup_free_char_ptr_vec. */