X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalue.c;h=53b51755d1d9d032d8deb904ae6344d202be5254;hb=63ffd7c9131c0e9723016d33cf8d435cc508d02b;hp=9f9e78ece2bf4f1e7b0d402ca37be9d2e10b2728;hpb=8b88a78e63526b84d540b9c7d5f459593a248d5e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.c b/gdb/value.c index 9f9e78ece2..53b51755d1 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1,6 +1,6 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. - Copyright (C) 1986-2018 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -41,8 +41,9 @@ #include "user-regs.h" #include #include "completer.h" -#include "selftest.h" -#include "common/array-view.h" +#include "gdbsupport/selftest.h" +#include "gdbsupport/array-view.h" +#include "cli/cli-style.h" /* Definition of a user function. */ struct internal_function @@ -272,8 +273,8 @@ struct value LONGEST bitsize = 0; /* Only used for bitfields; position of start of field. For - gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For - gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */ + little-endian targets, it is the position of the LSB. For + big-endian targets, it is the position of the MSB. */ LONGEST bitpos = 0; /* The number of references to this value. When a value is created, @@ -1405,15 +1406,14 @@ value_optimized_out (struct value *value) fetch it. */ if (value->optimized_out.empty () && value->lazy) { - TRY + try { value_fetch_lazy (value); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { /* Fall back to checking value->optimized_out. */ } - END_CATCH } return !value->optimized_out.empty (); @@ -1978,7 +1978,7 @@ init_if_undefined_command (const char* args, int from_tty) intvar = expr->elts[2].internalvar; /* Only evaluate the expression if the lvalue is void. - This may still fail if the expresssion is invalid. */ + This may still fail if the expression is invalid. */ if (intvar->kind == INTERNALVAR_VOID) evaluate_expression (expr.get ()); } @@ -2015,11 +2015,7 @@ complete_internalvar (completion_tracker &tracker, const char *name) for (var = internalvars; var; var = var->next) if (strncmp (var->name, name, len) == 0) - { - gdb::unique_xmalloc_ptr copy (xstrdup (var->name)); - - tracker.add_completion (std::move (copy)); - } + tracker.add_completion (make_unique_xstrdup (var->name)); } /* Create an internal variable with name NAME and with a void value. @@ -2030,7 +2026,7 @@ create_internalvar (const char *name) { struct internalvar *var = XNEW (struct internalvar); - var->name = concat (name, (char *)NULL); + var->name = xstrdup (name); var->kind = INTERNALVAR_VOID; var->next = internalvars; internalvars = var; @@ -2157,7 +2153,7 @@ value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var) on this value go back to affect the original internal variable. Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have - no underlying modifyable state in the internal variable. + no underlying modifiable state in the internal variable. Likewise, if the variable's value is a computed lvalue, we want references to it to produce another computed lvalue, where @@ -2274,20 +2270,20 @@ set_internalvar (struct internalvar *var, struct value *val) default: new_kind = INTERNALVAR_VALUE; - new_data.value = value_copy (val); - new_data.value->modifiable = 1; + struct value *copy = value_copy (val); + copy->modifiable = 1; /* Force the value to be fetched from the target now, to avoid problems later when this internalvar is referenced and the target is gone or has changed. */ - if (value_lazy (new_data.value)) - value_fetch_lazy (new_data.value); + if (value_lazy (copy)) + value_fetch_lazy (copy); /* Release the value from the value chain to prevent it from being deleted by free_all_values. From here on this function should not call error () until new_data is installed into the var->u to avoid leaking memory. */ - release_value (new_data.value).release (); + new_data.value = release_value (copy).release (); /* Internal variables which are created from values with a dynamic location don't need the location property of the origin anymore. @@ -2425,33 +2421,43 @@ function_command (const char *command, int from_tty) /* Do nothing. */ } -/* Clean up if an internal function's command is destroyed. */ -static void -function_destroyer (struct cmd_list_element *self, void *ignore) +/* Helper function that does the work for add_internal_function. */ + +static struct cmd_list_element * +do_add_internal_function (const char *name, const char *doc, + internal_function_fn handler, void *cookie) { - xfree ((char *) self->name); - xfree ((char *) self->doc); + struct internal_function *ifn; + struct internalvar *var = lookup_internalvar (name); + + ifn = create_internal_function (name, handler, cookie); + set_internalvar_function (var, ifn); + + return add_cmd (name, no_class, function_command, doc, &functionlist); } -/* Add a new internal function. NAME is the name of the function; DOC - is a documentation string describing the function. HANDLER is - called when the function is invoked. COOKIE is an arbitrary - pointer which is passed to HANDLER and is intended for "user - data". */ +/* See value.h. */ + void add_internal_function (const char *name, const char *doc, internal_function_fn handler, void *cookie) { - struct cmd_list_element *cmd; - struct internal_function *ifn; - struct internalvar *var = lookup_internalvar (name); + do_add_internal_function (name, doc, handler, cookie); +} - ifn = create_internal_function (name, handler, cookie); - set_internalvar_function (var, ifn); +/* See value.h. */ - cmd = add_cmd (xstrdup (name), no_class, function_command, (char *) doc, - &functionlist); - cmd->destroyer = function_destroyer; +void +add_internal_function (gdb::unique_xmalloc_ptr &&name, + gdb::unique_xmalloc_ptr &&doc, + internal_function_fn handler, void *cookie) +{ + struct cmd_list_element *cmd + = do_add_internal_function (name.get (), doc.get (), handler, cookie); + doc.release (); + cmd->doc_allocated = 1; + name.release (); + cmd->name_allocated = 1; } /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to @@ -2535,18 +2541,18 @@ show_convenience (const char *ignore, int from_tty) } printf_filtered (("$%s = "), var->name); - TRY + try { struct value *val; val = value_of_internalvar (gdbarch, var); value_print (val, gdb_stdout, &opts); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { - fprintf_filtered (gdb_stdout, _(""), ex.message); + fprintf_styled (gdb_stdout, metadata_style.style (), + _(""), ex.what ()); } - END_CATCH printf_filtered (("\n")); } @@ -2583,24 +2589,23 @@ value_from_xmethod (xmethod_worker_up &&worker) /* Return the type of the result of TYPE_CODE_XMETHOD value METHOD. */ struct type * -result_type_of_xmethod (struct value *method, int argc, struct value **argv) +result_type_of_xmethod (struct value *method, gdb::array_view argv) { gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD - && method->lval == lval_xcallable && argc > 0); + && method->lval == lval_xcallable && !argv.empty ()); - return method->location.xm_worker->get_result_type - (argv[0], argv + 1, argc - 1); + return method->location.xm_worker->get_result_type (argv[0], argv.slice (1)); } /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */ struct value * -call_xmethod (struct value *method, int argc, struct value **argv) +call_xmethod (struct value *method, gdb::array_view argv) { gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD - && method->lval == lval_xcallable && argc > 0); + && method->lval == lval_xcallable && !argv.empty ()); - return method->location.xm_worker->invoke (argv[0], argv + 1, argc - 1); + return method->location.xm_worker->invoke (argv[0], argv.slice (1)); } /* Extract a value as a C number (either long or double). @@ -2742,7 +2747,7 @@ value_as_address (struct value *val) LONGEST unpack_long (struct type *type, const gdb_byte *valaddr) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); enum type_code code = TYPE_CODE (type); int len = TYPE_LENGTH (type); int nosign = TYPE_UNSIGNED (type); @@ -2758,10 +2763,16 @@ unpack_long (struct type *type, const gdb_byte *valaddr) case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: case TYPE_CODE_MEMBERPTR: - if (nosign) - return extract_unsigned_integer (valaddr, len, byte_order); - else - return extract_signed_integer (valaddr, len, byte_order); + { + LONGEST result; + if (nosign) + result = extract_unsigned_integer (valaddr, len, byte_order); + else + result = extract_signed_integer (valaddr, len, byte_order); + if (code == TYPE_CODE_RANGE) + result += TYPE_RANGE_DATA (type)->bias; + return result; + } case TYPE_CODE_FLT: case TYPE_CODE_DECFLOAT: @@ -2777,7 +2788,6 @@ unpack_long (struct type *type, const gdb_byte *valaddr) default: error (_("Value can't be converted to integer.")); } - return 0; /* Placate lint. */ } /* Unpack raw data (copied from debugee, target byte order) at VALADDR @@ -3051,7 +3061,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f, VALUE_LVAL (v) = lval_memory; if (sym) { - set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))); + set_value_address (v, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))); } else { @@ -3100,7 +3110,7 @@ static LONGEST unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, LONGEST bitpos, LONGEST bitsize) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type)); + enum bfd_endian byte_order = type_byte_order (field_type); ULONGEST val; ULONGEST valmask; int lsbcount; @@ -3125,7 +3135,7 @@ unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, /* Extract bits. See comment above. */ - if (gdbarch_bits_big_endian (get_type_arch (field_type))) + if (byte_order == BFD_ENDIAN_BIG) lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize); else lsbcount = (bitpos % 8); @@ -3209,7 +3219,7 @@ unpack_value_bitfield (struct value *dest_val, int dst_bit_offset; struct type *field_type = value_type (dest_val); - byte_order = gdbarch_byte_order (get_type_arch (field_type)); + byte_order = type_byte_order (field_type); /* First, unpack and sign extend the bitfield as if it was wholly valid. Optimized out/unavailable bits are read as zero, but @@ -3269,7 +3279,7 @@ void modify_field (struct type *type, gdb_byte *addr, LONGEST fieldval, LONGEST bitpos, LONGEST bitsize) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); ULONGEST oword; ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize); LONGEST bytesize; @@ -3301,7 +3311,7 @@ modify_field (struct type *type, gdb_byte *addr, oword = extract_unsigned_integer (addr, bytesize, byte_order); /* Shifting for bit field depends on endianness of the target machine. */ - if (gdbarch_bits_big_endian (get_type_arch (type))) + if (byte_order == BFD_ENDIAN_BIG) bitpos = bytesize * 8 - bitpos - bitsize; oword &= ~(mask << bitpos); @@ -3315,7 +3325,7 @@ modify_field (struct type *type, gdb_byte *addr, void pack_long (gdb_byte *buf, struct type *type, LONGEST num) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); LONGEST len; type = check_typedef (type); @@ -3323,12 +3333,14 @@ pack_long (gdb_byte *buf, struct type *type, LONGEST num) switch (TYPE_CODE (type)) { + case TYPE_CODE_RANGE: + num -= TYPE_RANGE_DATA (type)->bias; + /* Fall through. */ case TYPE_CODE_INT: case TYPE_CODE_CHAR: case TYPE_CODE_ENUM: case TYPE_CODE_FLAGS: case TYPE_CODE_BOOL: - case TYPE_CODE_RANGE: case TYPE_CODE_MEMBERPTR: store_signed_integer (buf, len, byte_order, num); break; @@ -3361,7 +3373,7 @@ pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num) type = check_typedef (type); len = TYPE_LENGTH (type); - byte_order = gdbarch_byte_order (get_type_arch (type)); + byte_order = type_byte_order (type); switch (TYPE_CODE (type)) { @@ -3432,6 +3444,19 @@ value_from_pointer (struct type *type, CORE_ADDR addr) return val; } +/* Create and return a value object of TYPE containing the value D. The + TYPE must be of TYPE_CODE_FLT, and must be large enough to hold D once + it is converted to target format. */ + +struct value * +value_from_host_double (struct type *type, double d) +{ + struct value *value = allocate_value (type); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); + target_float_from_host_double (value_contents_raw (value), + value_type (value), d); + return value; +} /* Create a value of type TYPE whose contents come from VALADDR, if it is non-null, and whose memory address (in the inferior) is @@ -3726,7 +3751,6 @@ value_fetch_lazy_bitfield (struct value *val) per bitfield. It would be even better to read only the containing word, but we have no way to record that just specific bits of a value have been fetched. */ - struct type *type = check_typedef (value_type (val)); struct value *parent = value_parent (val); if (value_lazy (parent)) @@ -3923,6 +3947,44 @@ isvoid_internal_fn (struct gdbarch *gdbarch, return value_from_longest (builtin_type (gdbarch)->builtin_int, ret); } +/* Implementation of the convenience function $_creal. Extracts the + real part from a complex number. */ + +static struct value * +creal_internal_fn (struct gdbarch *gdbarch, + const struct language_defn *language, + void *cookie, int argc, struct value **argv) +{ + if (argc != 1) + error (_("You must provide one argument for $_creal.")); + + value *cval = argv[0]; + type *ctype = check_typedef (value_type (cval)); + if (TYPE_CODE (ctype) != TYPE_CODE_COMPLEX) + error (_("expected a complex number")); + return value_from_component (cval, TYPE_TARGET_TYPE (ctype), 0); +} + +/* Implementation of the convenience function $_cimag. Extracts the + imaginary part from a complex number. */ + +static struct value * +cimag_internal_fn (struct gdbarch *gdbarch, + const struct language_defn *language, + void *cookie, int argc, + struct value **argv) +{ + if (argc != 1) + error (_("You must provide one argument for $_cimag.")); + + value *cval = argv[0]; + type *ctype = check_typedef (value_type (cval)); + if (TYPE_CODE (ctype) != TYPE_CODE_COMPLEX) + error (_("expected a complex number")); + return value_from_component (cval, TYPE_TARGET_TYPE (ctype), + TYPE_LENGTH (TYPE_TARGET_TYPE (ctype))); +} + #if GDB_SELF_TEST namespace selftests { @@ -4104,6 +4166,20 @@ Usage: $_isvoid (expression)\n\ Return 1 if the expression is void, zero otherwise."), isvoid_internal_fn, NULL); + add_internal_function ("_creal", _("\ +Extract the real part of a complex number.\n\ +Usage: $_creal (expression)\n\ +Return the real part of a complex number, the type depends on the\n\ +type of a complex number."), + creal_internal_fn, NULL); + + add_internal_function ("_cimag", _("\ +Extract the imaginary part of a complex number.\n\ +Usage: $_cimag (expression)\n\ +Return the imaginary part of a complex number, the type depends on the\n\ +type of a complex number."), + cimag_internal_fn, NULL); + add_setshow_zuinteger_unlimited_cmd ("max-value-size", class_support, &max_value_size, _("\ Set maximum sized value gdb will load from the inferior."), _("\ @@ -4122,3 +4198,11 @@ prevents future values, larger than this size, from being allocated."), selftests::test_insert_into_bit_range_vector); #endif } + +/* See value.h. */ + +void +finalize_values () +{ + all_values.clear (); +}