#include "cli/cli-utils.h"
#include "common/function-view.h"
#include "common/byte-vector.h"
+#include <algorithm>
/* Define whether or not the C operator '/' truncates towards zero for
differently signed operands (truncation direction is undefined in C).
/* Implement the "maintenance set ada" (prefix) command. */
static void
-maint_set_ada_cmd (char *args, int from_tty)
+maint_set_ada_cmd (const char *args, int from_tty)
{
help_list (maint_set_ada_cmdlist, "maintenance set ada ", all_commands,
gdb_stdout);
/* Implement the "maintenance show ada" (prefix) command. */
static void
-maint_show_ada_cmd (char *args, int from_tty)
+maint_show_ada_cmd (const char *args, int from_tty)
{
cmd_show_list (maint_show_ada_cmdlist, from_tty, "");
}
break;
case OP_LONG:
- case OP_DOUBLE:
+ case OP_FLOAT:
case OP_VAR_VALUE:
+ case OP_VAR_MSYM_VALUE:
*pos += 4;
break;
}
static struct value *
-cast_to_fixed (struct type *type, struct value *arg)
+cast_from_fixed (struct type *type, struct value *arg)
{
- LONGEST val;
-
- if (type == value_type (arg))
- return arg;
- else if (ada_is_fixed_point_type (value_type (arg)))
- val = ada_float_to_fixed (type,
- ada_fixed_to_float (value_type (arg),
- value_as_long (arg)));
- else
- {
- DOUBLEST argd = value_as_double (arg);
+ struct value *scale = ada_scaling_factor (value_type (arg));
+ arg = value_cast (value_type (scale), arg);
- val = ada_float_to_fixed (type, argd);
- }
-
- return value_from_longest (type, val);
+ arg = value_binop (arg, scale, BINOP_MUL);
+ return value_cast (type, arg);
}
static struct value *
-cast_from_fixed (struct type *type, struct value *arg)
+cast_to_fixed (struct type *type, struct value *arg)
{
- DOUBLEST val = ada_fixed_to_float (value_type (arg),
- value_as_long (arg));
+ if (type == value_type (arg))
+ return arg;
+
+ struct value *scale = ada_scaling_factor (type);
+ if (ada_is_fixed_point_type (value_type (arg)))
+ arg = cast_from_fixed (value_type (scale), arg);
+ else
+ arg = value_cast (value_type (scale), arg);
- return value_from_double (type, val);
+ arg = value_binop (arg, scale, BINOP_DIV);
+ return value_cast (type, arg);
}
/* Given two array types T1 and T2, return nonzero iff both arrays
if (noside == EVAL_NORMAL)
arg1 = unwrap_value (arg1);
- /* If evaluating an OP_DOUBLE and an EXPECT_TYPE was provided,
+ /* If evaluating an OP_FLOAT and an EXPECT_TYPE was provided,
then we need to perform the conversion manually, because
evaluate_subexp_standard doesn't do it. This conversion is
necessary in Ada because the different kinds of float/fixed
Similarly, we need to perform the conversion from OP_LONG
ourselves. */
- if ((op == OP_DOUBLE || op == OP_LONG) && expect_type != NULL)
+ if ((op == OP_FLOAT || op == OP_LONG) && expect_type != NULL)
arg1 = ada_value_cast (expect_type, arg1, noside);
return arg1;
case TYPE_CODE_FUNC:
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *rtype = TYPE_TARGET_TYPE (type);
-
- if (TYPE_GNU_IFUNC (type))
- return allocate_value (TYPE_TARGET_TYPE (rtype));
- return allocate_value (rtype);
+ if (TYPE_TARGET_TYPE (type) == NULL)
+ error_call_unknown_return_type (NULL);
+ return allocate_value (TYPE_TARGET_TYPE (type));
}
- return call_function_by_hand (argvec[0], nargs, argvec + 1);
+ return call_function_by_hand (argvec[0], NULL, nargs, argvec + 1);
case TYPE_CODE_INTERNAL_FUNCTION:
if (noside == EVAL_AVOID_SIDE_EFFECTS)
/* We don't know anything about what the internal
}
/* Assuming that TYPE is the representation of an Ada fixed-point
- type, return its delta, or -1 if the type is malformed and the
+ type, return the target floating-point type to be used to represent
+ of this type during internal computation. */
+
+static struct type *
+ada_scaling_type (struct type *type)
+{
+ return builtin_type (get_type_arch (type))->builtin_long_double;
+}
+
+/* Assuming that TYPE is the representation of an Ada fixed-point
+ type, return its delta, or NULL if the type is malformed and the
delta cannot be determined. */
-DOUBLEST
+struct value *
ada_delta (struct type *type)
{
const char *encoding = fixed_type_info (type);
- DOUBLEST num, den;
-
- /* Strictly speaking, num and den are encoded as integer. However,
- they may not fit into a long, and they will have to be converted
- to DOUBLEST anyway. So scan them as DOUBLEST. */
- if (sscanf (encoding, "_%" DOUBLEST_SCAN_FORMAT "_%" DOUBLEST_SCAN_FORMAT,
- &num, &den) < 2)
- return -1.0;
+ struct type *scale_type = ada_scaling_type (type);
+
+ long long num, den;
+
+ if (sscanf (encoding, "_%lld_%lld", &num, &den) < 2)
+ return nullptr;
else
- return num / den;
+ return value_binop (value_from_longest (scale_type, num),
+ value_from_longest (scale_type, den), BINOP_DIV);
}
/* Assuming that ada_is_fixed_point_type (TYPE), return the scaling
factor ('SMALL value) associated with the type. */
-static DOUBLEST
-scaling_factor (struct type *type)
+struct value *
+ada_scaling_factor (struct type *type)
{
const char *encoding = fixed_type_info (type);
- DOUBLEST num0, den0, num1, den1;
+ struct type *scale_type = ada_scaling_type (type);
+
+ long long num0, den0, num1, den1;
int n;
- /* Strictly speaking, num's and den's are encoded as integer. However,
- they may not fit into a long, and they will have to be converted
- to DOUBLEST anyway. So scan them as DOUBLEST. */
- n = sscanf (encoding,
- "_%" DOUBLEST_SCAN_FORMAT "_%" DOUBLEST_SCAN_FORMAT
- "_%" DOUBLEST_SCAN_FORMAT "_%" DOUBLEST_SCAN_FORMAT,
+ n = sscanf (encoding, "_%lld_%lld_%lld_%lld",
&num0, &den0, &num1, &den1);
if (n < 2)
- return 1.0;
+ return value_from_longest (scale_type, 1);
else if (n == 4)
- return num1 / den1;
+ return value_binop (value_from_longest (scale_type, num1),
+ value_from_longest (scale_type, den1), BINOP_DIV);
else
- return num0 / den0;
-}
-
-
-/* Assuming that X is the representation of a value of fixed-point
- type TYPE, return its floating-point equivalent. */
-
-DOUBLEST
-ada_fixed_to_float (struct type *type, LONGEST x)
-{
- return (DOUBLEST) x *scaling_factor (type);
-}
-
-/* The representation of a fixed-point value of type TYPE
- corresponding to the value X. */
-
-LONGEST
-ada_float_to_fixed (struct type *type, DOUBLEST x)
-{
- return (LONGEST) (x / scaling_factor (type) + 0.5);
+ return value_binop (value_from_longest (scale_type, num0),
+ value_from_longest (scale_type, den0), BINOP_DIV);
}
\f
static int
is_known_support_routine (struct frame_info *frame)
{
- struct symtab_and_line sal;
- char *func_name;
enum language func_lang;
int i;
const char *fullname;
/* If this code does not have any debugging information (no symtab),
This cannot be any user code. */
- find_frame_sal (frame, &sal);
+ symtab_and_line sal = find_frame_sal (frame);
if (sal.symtab == NULL)
return 1;
/* Check whether the function is a GNAT-generated entity. */
- find_frame_funname (frame, &func_name, &func_lang, NULL);
+ gdb::unique_xmalloc_ptr<char> func_name
+ = find_frame_funname (frame, &func_lang, NULL);
if (func_name == NULL)
return 1;
for (i = 0; known_auxiliary_function_name_patterns[i] != NULL; i += 1)
{
re_comp (known_auxiliary_function_name_patterns[i]);
- if (re_exec (func_name))
- {
- xfree (func_name);
- return 1;
- }
+ if (re_exec (func_name.get ()))
+ return 1;
}
- xfree (func_name);
return 0;
}
int frame_level;
struct frame_info *fi;
struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
- struct cleanup *old_chain;
/* To determine the name of this exception, we need to select
the frame corresponding to RAISE_SYM_NAME. This frame is
if (fi != NULL)
fi = get_prev_frame (fi);
- old_chain = make_cleanup (null_cleanup, NULL);
while (fi != NULL)
{
- char *func_name;
enum language func_lang;
- find_frame_funname (fi, &func_name, &func_lang, NULL);
+ gdb::unique_xmalloc_ptr<char> func_name
+ = find_frame_funname (fi, &func_lang, NULL);
if (func_name != NULL)
{
- make_cleanup (xfree, func_name);
-
- if (strcmp (func_name,
+ if (strcmp (func_name.get (),
data->exception_info->catch_exception_sym) == 0)
break; /* We found the frame we were looking for... */
fi = get_prev_frame (fi);
}
}
- do_cleanups (old_chain);
if (fi == NULL)
return 0;
const char *end;
char *result;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
return NULL; /* No more arguments. */
/* Find the end of the current argument. */
- end = skip_to_space_const (args);
+ end = skip_to_space (args);
/* Adjust ARGSP to point to the start of the next argument. */
/* Check to see if we have a condition. */
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (startswith (args, "if")
&& (isspace (args[2]) || args[2] == '\0'))
{
args += 2;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
error (_("Condition missing after `if' keyword"));
static struct symtab_and_line
ada_exception_sal (enum ada_exception_catchpoint_kind ex, char *excep_string,
- char **addr_string, const struct breakpoint_ops **ops)
+ const char **addr_string, const struct breakpoint_ops **ops)
{
const char *sym_name;
struct symbol *sym;
int disabled,
int from_tty)
{
- char *addr_string = NULL;
+ const char *addr_string = NULL;
const struct breakpoint_ops *ops = NULL;
struct symtab_and_line sal
= ada_exception_sal (ex_kind, excep_string, &addr_string, &ops);
static void
catch_ada_assert_command_split (const char *args, char **cond_string)
{
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
/* Check whether a condition was provided. */
if (startswith (args, "if")
&& (isspace (args[2]) || args[2] == '\0'))
{
args += 2;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
error (_("condition missing after `if' keyword"));
*cond_string = xstrdup (args);
return 1;
}
-/* A helper function for qsort, comparing two struct ada_exc_info
+/* A helper function for std::sort, comparing two struct ada_exc_info
objects.
The comparison is determined first by exception name, and then
by exception address. */
-static int
-compare_ada_exception_info (const void *a, const void *b)
+bool
+ada_exc_info::operator< (const ada_exc_info &other) const
{
- const struct ada_exc_info *exc_a = (struct ada_exc_info *) a;
- const struct ada_exc_info *exc_b = (struct ada_exc_info *) b;
int result;
- result = strcmp (exc_a->name, exc_b->name);
- if (result != 0)
- return result;
-
- if (exc_a->addr < exc_b->addr)
- return -1;
- if (exc_a->addr > exc_b->addr)
- return 1;
+ result = strcmp (name, other.name);
+ if (result < 0)
+ return true;
+ if (result == 0 && addr < other.addr)
+ return true;
+ return false;
+}
- return 0;
+bool
+ada_exc_info::operator== (const ada_exc_info &other) const
+{
+ return addr == other.addr && strcmp (name, other.name) == 0;
}
/* Sort EXCEPTIONS using compare_ada_exception_info as the comparison
All duplicates are also removed. */
static void
-sort_remove_dups_ada_exceptions_list (VEC(ada_exc_info) **exceptions,
+sort_remove_dups_ada_exceptions_list (std::vector<ada_exc_info> *exceptions,
int skip)
{
- struct ada_exc_info *to_sort
- = VEC_address (ada_exc_info, *exceptions) + skip;
- int to_sort_len
- = VEC_length (ada_exc_info, *exceptions) - skip;
- int i, j;
-
- qsort (to_sort, to_sort_len, sizeof (struct ada_exc_info),
- compare_ada_exception_info);
-
- for (i = 1, j = 1; i < to_sort_len; i++)
- if (compare_ada_exception_info (&to_sort[i], &to_sort[j - 1]) != 0)
- to_sort[j++] = to_sort[i];
- to_sort_len = j;
- VEC_truncate(ada_exc_info, *exceptions, skip + to_sort_len);
+ std::sort (exceptions->begin () + skip, exceptions->end ());
+ exceptions->erase (std::unique (exceptions->begin () + skip, exceptions->end ()),
+ exceptions->end ());
}
/* Add all exceptions defined by the Ada standard whose name match
static void
ada_add_standard_exceptions (compiled_regex *preg,
- VEC(ada_exc_info) **exceptions)
+ std::vector<ada_exc_info> *exceptions)
{
int i;
struct ada_exc_info info
= {standard_exc[i], BMSYMBOL_VALUE_ADDRESS (msymbol)};
- VEC_safe_push (ada_exc_info, *exceptions, &info);
+ exceptions->push_back (info);
}
}
}
static void
ada_add_exceptions_from_frame (compiled_regex *preg,
struct frame_info *frame,
- VEC(ada_exc_info) **exceptions)
+ std::vector<ada_exc_info> *exceptions)
{
const struct block *block = get_frame_block (frame, 0);
struct ada_exc_info info = {SYMBOL_PRINT_NAME (sym),
SYMBOL_VALUE_ADDRESS (sym)};
- VEC_safe_push (ada_exc_info, *exceptions, &info);
+ exceptions->push_back (info);
}
}
}
static void
ada_add_global_exceptions (compiled_regex *preg,
- VEC(ada_exc_info) **exceptions)
+ std::vector<ada_exc_info> *exceptions)
{
struct objfile *objfile;
struct compunit_symtab *s;
struct ada_exc_info info
= {SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE_ADDRESS (sym)};
- VEC_safe_push (ada_exc_info, *exceptions, &info);
+ exceptions->push_back (info);
}
}
}
If not NULL, PREG is used to filter out exceptions whose names
do not match. Otherwise, all exceptions are listed. */
-static VEC(ada_exc_info) *
+static std::vector<ada_exc_info>
ada_exceptions_list_1 (compiled_regex *preg)
{
- VEC(ada_exc_info) *result = NULL;
- struct cleanup *old_chain
- = make_cleanup (VEC_cleanup (ada_exc_info), &result);
+ std::vector<ada_exc_info> result;
int prev_len;
/* First, list the known standard exceptions. These exceptions
if (has_stack_frames ())
{
- prev_len = VEC_length (ada_exc_info, result);
+ prev_len = result.size ();
ada_add_exceptions_from_frame (preg, get_selected_frame (NULL),
&result);
- if (VEC_length (ada_exc_info, result) > prev_len)
+ if (result.size () > prev_len)
sort_remove_dups_ada_exceptions_list (&result, prev_len);
}
/* Add all exceptions whose scope is global. */
- prev_len = VEC_length (ada_exc_info, result);
+ prev_len = result.size ();
ada_add_global_exceptions (preg, &result);
- if (VEC_length (ada_exc_info, result) > prev_len)
+ if (result.size () > prev_len)
sort_remove_dups_ada_exceptions_list (&result, prev_len);
- discard_cleanups (old_chain);
return result;
}
alphabetical order;
- Exceptions whose scope is global, in alphabetical order. */
-VEC(ada_exc_info) *
+std::vector<ada_exc_info>
ada_exceptions_list (const char *regexp)
{
if (regexp == NULL)
static void
info_exceptions_command (char *regexp, int from_tty)
{
- VEC(ada_exc_info) *exceptions;
- struct cleanup *cleanup;
struct gdbarch *gdbarch = get_current_arch ();
- int ix;
- struct ada_exc_info *info;
- exceptions = ada_exceptions_list (regexp);
- cleanup = make_cleanup (VEC_cleanup (ada_exc_info), &exceptions);
+ std::vector<ada_exc_info> exceptions = ada_exceptions_list (regexp);
if (regexp != NULL)
printf_filtered
else
printf_filtered (_("All defined Ada exceptions:\n"));
- for (ix = 0; VEC_iterate(ada_exc_info, exceptions, ix, info); ix++)
- printf_filtered ("%s: %s\n", info->name, paddress (gdbarch, info->addr));
-
- do_cleanups (cleanup);
+ for (const ada_exc_info &info : exceptions)
+ printf_filtered ("%s: %s\n", info.name, paddress (gdbarch, info.addr));
}
/* Operators */
= builtin->builtin_void;
lai->primitive_type_vector [ada_primitive_type_system_address]
- = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"));
+ = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
+ "void"));
TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address])
= "system__address";
LANG_MAGIC
};
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_ada_language;
-
/* Command-list for the "set/show ada" prefix command. */
static struct cmd_list_element *set_ada_list;
static struct cmd_list_element *show_ada_list;
/* Implement the "set ada" prefix command. */
static void
-set_ada_command (char *arg, int from_tty)
+set_ada_command (const char *arg, int from_tty)
{
printf_unfiltered (_(\
"\"set ada\" must be followed by the name of a setting.\n"));
/* Implement the "show ada" prefix command. */
static void
-show_ada_command (char *args, int from_tty)
+show_ada_command (const char *args, int from_tty)
{
cmd_show_list (show_ada_list, from_tty, "");
}
projects / deliverable / binutils-gdb.git / blobdiff