X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalue.c;h=e620550eca3ec768f70f4ffa0ebf4d6cb12967e2;hb=83116857a35fc5125d098984fae29a549a2b29f3;hp=1a8796e332cd985d8e5ceed9e4e0f71544d2d451;hpb=13bb5560e268fc77450c7e689f4b46e4dfbc9225;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.c b/gdb/value.c index 1a8796e332..e620550eca 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1,14 +1,14 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005 Free - Software Foundation, Inc. + Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008 + Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,9 +17,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "gdb_string.h" @@ -31,17 +29,153 @@ #include "gdbcmd.h" #include "target.h" #include "language.h" -#include "scm-lang.h" #include "demangle.h" #include "doublest.h" #include "gdb_assert.h" #include "regcache.h" #include "block.h" +#include "dfp.h" /* Prototypes for exported functions. */ void _initialize_values (void); +struct value +{ + /* Type of value; either not an lval, or one of the various + different possible kinds of lval. */ + enum lval_type lval; + + /* Is it modifiable? Only relevant if lval != not_lval. */ + int modifiable; + + /* Location of value (if lval). */ + union + { + /* If lval == lval_memory, this is the address in the inferior. + If lval == lval_register, this is the byte offset into the + registers structure. */ + CORE_ADDR address; + + /* Pointer to internal variable. */ + struct internalvar *internalvar; + } location; + + /* Describes offset of a value within lval of a structure in bytes. + If lval == lval_memory, this is an offset to the address. If + lval == lval_register, this is a further offset from + location.address within the registers structure. Note also the + member embedded_offset below. */ + int offset; + + /* Only used for bitfields; number of bits contained in them. */ + int bitsize; + + /* 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. */ + int bitpos; + + /* Frame register value is relative to. This will be described in + the lval enum above as "lval_register". */ + struct frame_id frame_id; + + /* Type of the value. */ + struct type *type; + + /* If a value represents a C++ object, then the `type' field gives + the object's compile-time type. If the object actually belongs + to some class derived from `type', perhaps with other base + classes and additional members, then `type' is just a subobject + of the real thing, and the full object is probably larger than + `type' would suggest. + + If `type' is a dynamic class (i.e. one with a vtable), then GDB + can actually determine the object's run-time type by looking at + the run-time type information in the vtable. When this + information is available, we may elect to read in the entire + object, for several reasons: + + - When printing the value, the user would probably rather see the + full object, not just the limited portion apparent from the + compile-time type. + + - If `type' has virtual base classes, then even printing `type' + alone may require reaching outside the `type' portion of the + object to wherever the virtual base class has been stored. + + When we store the entire object, `enclosing_type' is the run-time + type -- the complete object -- and `embedded_offset' is the + offset of `type' within that larger type, in bytes. The + value_contents() macro takes `embedded_offset' into account, so + most GDB code continues to see the `type' portion of the value, + just as the inferior would. + + If `type' is a pointer to an object, then `enclosing_type' is a + pointer to the object's run-time type, and `pointed_to_offset' is + the offset in bytes from the full object to the pointed-to object + -- that is, the value `embedded_offset' would have if we followed + the pointer and fetched the complete object. (I don't really see + the point. Why not just determine the run-time type when you + indirect, and avoid the special case? The contents don't matter + until you indirect anyway.) + + If we're not doing anything fancy, `enclosing_type' is equal to + `type', and `embedded_offset' is zero, so everything works + normally. */ + struct type *enclosing_type; + int embedded_offset; + int pointed_to_offset; + + /* Values are stored in a chain, so that they can be deleted easily + over calls to the inferior. Values assigned to internal + variables or put into the value history are taken off this + list. */ + struct value *next; + + /* Register number if the value is from a register. */ + short regnum; + + /* If zero, contents of this value are in the contents field. If + nonzero, contents are in inferior memory at address in the + location.address field plus the offset field (and the lval field + should be lval_memory). + + WARNING: This field is used by the code which handles watchpoints + (see breakpoint.c) to decide whether a particular value can be + watched by hardware watchpoints. If the lazy flag is set for + some member of a value chain, it is assumed that this member of + the chain doesn't need to be watched as part of watching the + value itself. This is how GDB avoids watching the entire struct + or array when the user wants to watch a single struct member or + array element. If you ever change the way lazy flag is set and + reset, be sure to consider this use as well! */ + char lazy; + + /* If nonzero, this is the value of a variable which does not + actually exist in the program. */ + char optimized_out; + + /* If value is a variable, is it initialized or not. */ + int initialized; + + /* Actual contents of the value. For use of this value; setting it + uses the stuff above. Not valid if lazy is nonzero. Target + byte-order. We force it to be aligned properly for any possible + value. Note that a value therefore extends beyond what is + declared here. */ + union + { + gdb_byte contents[1]; + DOUBLEST force_doublest_align; + LONGEST force_longest_align; + CORE_ADDR force_core_addr_align; + void *force_pointer_align; + } aligner; + /* Do not add any new members here -- contents above will trash + them. */ +}; + /* Prototypes for local functions. */ static void show_values (char *, int); @@ -100,6 +234,7 @@ allocate_value (struct type *type) val->embedded_offset = 0; val->pointed_to_offset = 0; val->modifiable = 1; + val->initialized = 1; /* Default to initialized. */ return val; } @@ -123,37 +258,63 @@ allocate_repeat_value (struct type *type, int count) /* Accessor methods. */ +struct value * +value_next (struct value *value) +{ + return value->next; +} + struct type * value_type (struct value *value) { return value->type; } +void +deprecated_set_value_type (struct value *value, struct type *type) +{ + value->type = type; +} int value_offset (struct value *value) { return value->offset; } +void +set_value_offset (struct value *value, int offset) +{ + value->offset = offset; +} int value_bitpos (struct value *value) { return value->bitpos; } +void +set_value_bitpos (struct value *value, int bit) +{ + value->bitpos = bit; +} int value_bitsize (struct value *value) { return value->bitsize; } +void +set_value_bitsize (struct value *value, int bit) +{ + value->bitsize = bit; +} -bfd_byte * +gdb_byte * value_contents_raw (struct value *value) { return value->aligner.contents + value->embedded_offset; } -bfd_byte * +gdb_byte * value_contents_all_raw (struct value *value) { return value->aligner.contents; @@ -165,7 +326,7 @@ value_enclosing_type (struct value *value) return value->enclosing_type; } -const bfd_byte * +const gdb_byte * value_contents_all (struct value *value) { if (value->lazy) @@ -185,18 +346,38 @@ set_value_lazy (struct value *value, int val) value->lazy = val; } -const bfd_byte * +const gdb_byte * value_contents (struct value *value) { return value_contents_writeable (value); } -bfd_byte * +gdb_byte * value_contents_writeable (struct value *value) { if (value->lazy) value_fetch_lazy (value); - return value->aligner.contents; + return value_contents_raw (value); +} + +/* Return non-zero if VAL1 and VAL2 have the same contents. Note that + this function is different from value_equal; in C the operator == + can return 0 even if the two values being compared are equal. */ + +int +value_contents_equal (struct value *val1, struct value *val2) +{ + struct type *type1; + struct type *type2; + int len; + + type1 = check_typedef (value_type (val1)); + type2 = check_typedef (value_type (val2)); + len = TYPE_LENGTH (type1); + if (len != TYPE_LENGTH (type2)) + return 0; + + return (memcmp (value_contents (val1), value_contents (val2), len) == 0); } int @@ -264,6 +445,17 @@ deprecated_value_regnum_hack (struct value *value) { return &value->regnum; } + +int +deprecated_value_modifiable (struct value *value) +{ + return value->modifiable; +} +void +deprecated_set_value_modifiable (struct value *value, int modifiable) +{ + value->modifiable = modifiable; +} /* Return a mark in the value chain. All values allocated after the mark is obtained (except for those released) are subject to being freed @@ -361,7 +553,7 @@ value_copy (struct value *arg) struct value *val = allocate_value (encl_type); val->type = arg->type; VALUE_LVAL (val) = VALUE_LVAL (arg); - VALUE_ADDRESS (val) = VALUE_ADDRESS (arg); + val->location = arg->location; val->offset = arg->offset; val->bitpos = arg->bitpos; val->bitsize = arg->bitsize; @@ -442,14 +634,14 @@ access_value_history (int num) if (absnum <= 0) { if (num == 0) - error ("The history is empty."); + error (_("The history is empty.")); else if (num == 1) - error ("There is only one value in the history."); + error (_("There is only one value in the history.")); else - error ("History does not go back to $$%d.", -num); + error (_("History does not go back to $$%d."), -num); } if (absnum > value_history_count) - error ("History has not yet reached $%d.", absnum); + error (_("History has not yet reached $%d."), absnum); absnum--; @@ -463,29 +655,6 @@ access_value_history (int num) return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]); } -/* Clear the value history entirely. - Must be done when new symbol tables are loaded, - because the type pointers become invalid. */ - -void -clear_value_history (void) -{ - struct value_history_chunk *next; - int i; - struct value *val; - - while (value_history_chain) - { - for (i = 0; i < VALUE_HISTORY_CHUNK; i++) - if ((val = value_history_chain->values[i]) != NULL) - xfree (val); - next = value_history_chain->next; - xfree (value_history_chain); - value_history_chain = next; - } - value_history_count = 0; -} - static void show_values (char *num_exp, int from_tty) { @@ -512,9 +681,9 @@ show_values (char *num_exp, int from_tty) for (i = num; i < num + 10 && i <= value_history_count; i++) { val = access_value_history (i); - printf_filtered ("$%d = ", i); + printf_filtered (("$%d = "), i); value_print (val, gdb_stdout, 0, Val_pretty_default); - printf_filtered ("\n"); + printf_filtered (("\n")); } /* The next "info history +" should start after what we just printed. */ @@ -537,14 +706,47 @@ show_values (char *num_exp, int from_tty) static struct internalvar *internalvars; +/* If the variable does not already exist create it and give it the value given. + If no value is given then the default is zero. */ +static void +init_if_undefined_command (char* args, int from_tty) +{ + struct internalvar* intvar; + + /* Parse the expression - this is taken from set_command(). */ + struct expression *expr = parse_expression (args); + register struct cleanup *old_chain = + make_cleanup (free_current_contents, &expr); + + /* Validate the expression. + Was the expression an assignment? + Or even an expression at all? */ + if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN) + error (_("Init-if-undefined requires an assignment expression.")); + + /* Extract the variable from the parsed expression. + In the case of an assign the lvalue will be in elts[1] and elts[2]. */ + if (expr->elts[1].opcode != OP_INTERNALVAR) + error (_("The first parameter to init-if-undefined should be a GDB variable.")); + intvar = expr->elts[2].internalvar; + + /* Only evaluate the expression if the lvalue is void. + This may still fail if the expresssion is invalid. */ + if (TYPE_CODE (value_type (intvar->value)) == TYPE_CODE_VOID) + evaluate_expression (expr); + + do_cleanups (old_chain); +} + + /* Look up an internal variable with name NAME. NAME should not normally include a dollar sign. If the specified internal variable does not exist, - one is created, with a void value. */ + the return value is NULL. */ struct internalvar * -lookup_internalvar (char *name) +lookup_only_internalvar (char *name) { struct internalvar *var; @@ -552,25 +754,90 @@ lookup_internalvar (char *name) if (strcmp (var->name, name) == 0) return var; + return NULL; +} + + +/* Create an internal variable with name NAME and with a void value. + NAME should not normally include a dollar sign. */ + +struct internalvar * +create_internalvar (char *name) +{ + struct internalvar *var; var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); - var->name = concat (name, NULL); + var->name = concat (name, (char *)NULL); var->value = allocate_value (builtin_type_void); + var->endian = gdbarch_byte_order (current_gdbarch); release_value (var->value); var->next = internalvars; internalvars = var; return var; } + +/* Look up an internal variable with name NAME. NAME should not + normally include a dollar sign. + + If the specified internal variable does not exist, + one is created, with a void value. */ + +struct internalvar * +lookup_internalvar (char *name) +{ + struct internalvar *var; + + var = lookup_only_internalvar (name); + if (var) + return var; + + return create_internalvar (name); +} + struct value * value_of_internalvar (struct internalvar *var) { struct value *val; + int i, j; + gdb_byte temp; val = value_copy (var->value); if (value_lazy (val)) value_fetch_lazy (val); VALUE_LVAL (val) = lval_internalvar; VALUE_INTERNALVAR (val) = var; + + /* Values are always stored in the target's byte order. When connected to a + target this will most likely always be correct, so there's normally no + need to worry about it. + + However, internal variables can be set up before the target endian is + known and so may become out of date. Fix it up before anybody sees. + + Internal variables usually hold simple scalar values, and we can + correct those. More complex values (e.g. structures and floating + point types) are left alone, because they would be too complicated + to correct. */ + + if (var->endian != gdbarch_byte_order (current_gdbarch)) + { + gdb_byte *array = value_contents_raw (val); + struct type *type = check_typedef (value_enclosing_type (val)); + switch (TYPE_CODE (type)) + { + case TYPE_CODE_INT: + case TYPE_CODE_PTR: + /* Reverse the bytes. */ + for (i = 0, j = TYPE_LENGTH (type) - 1; i < j; i++, j--) + { + temp = array[j]; + array[j] = array[i]; + array[i] = temp; + } + break; + } + } + return val; } @@ -578,7 +845,7 @@ void set_internalvar_component (struct internalvar *var, int offset, int bitpos, int bitsize, struct value *newval) { - bfd_byte *addr = value_contents_writeable (var->value) + offset; + gdb_byte *addr = value_contents_writeable (var->value) + offset; if (bitsize) modify_field (addr, value_as_long (newval), @@ -609,6 +876,7 @@ set_internalvar (struct internalvar *var, struct value *val) long. */ xfree (var->value); var->value = newval; + var->endian = gdbarch_byte_order (current_gdbarch); release_value (newval); /* End code which must not call error(). */ } @@ -619,22 +887,49 @@ internalvar_name (struct internalvar *var) return var->name; } -/* Free all internalvars. Done when new symtabs are loaded, - because that makes the values invalid. */ +/* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to + prevent cycles / duplicates. */ + +static void +preserve_one_value (struct value *value, struct objfile *objfile, + htab_t copied_types) +{ + if (TYPE_OBJFILE (value->type) == objfile) + value->type = copy_type_recursive (objfile, value->type, copied_types); + + if (TYPE_OBJFILE (value->enclosing_type) == objfile) + value->enclosing_type = copy_type_recursive (objfile, + value->enclosing_type, + copied_types); +} + +/* Update the internal variables and value history when OBJFILE is + discarded; we must copy the types out of the objfile. New global types + will be created for every convenience variable which currently points to + this objfile's types, and the convenience variables will be adjusted to + use the new global types. */ void -clear_internalvars (void) +preserve_values (struct objfile *objfile) { + htab_t copied_types; + struct value_history_chunk *cur; struct internalvar *var; + int i; - while (internalvars) - { - var = internalvars; - internalvars = var->next; - xfree (var->name); - xfree (var->value); - xfree (var); - } + /* Create the hash table. We allocate on the objfile's obstack, since + it is soon to be deleted. */ + copied_types = create_copied_types_hash (objfile); + + for (cur = value_history_chain; cur; cur = cur->next) + for (i = 0; i < VALUE_HISTORY_CHUNK; i++) + if (cur->values[i]) + preserve_one_value (cur->values[i], objfile, copied_types); + + for (var = internalvars; var; var = var->next) + preserve_one_value (var->value, objfile, copied_types); + + htab_delete (copied_types); } static void @@ -649,14 +944,16 @@ show_convenience (char *ignore, int from_tty) { varseen = 1; } - printf_filtered ("$%s = ", var->name); - value_print (var->value, gdb_stdout, 0, Val_pretty_default); - printf_filtered ("\n"); + printf_filtered (("$%s = "), var->name); + value_print (value_of_internalvar (var), gdb_stdout, + 0, Val_pretty_default); + printf_filtered (("\n")); } if (!varseen) - printf_unfiltered ("No debugger convenience variables now defined.\n\ + printf_unfiltered (_("\ +No debugger convenience variables now defined.\n\ Convenience variables have names starting with \"$\";\n\ -use \"set\" as in \"set $foo = 5\" to define them.\n"); +use \"set\" as in \"set $foo = 5\" to define them.\n")); } /* Extract a value as a C number (either long or double). @@ -682,9 +979,10 @@ value_as_double (struct value *val) foo = unpack_double (value_type (val), value_contents (val), &inv); if (inv) - error ("Invalid floating value found in program."); + error (_("Invalid floating value found in program.")); return foo; } + /* Extract a value as a C pointer. Does not deallocate the value. Note that val's type may not actually be a pointer; value_as_long handles all the cases. */ @@ -694,10 +992,10 @@ value_as_address (struct value *val) /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ #if 0 - /* ADDR_BITS_REMOVE is wrong if we are being called for a + /* gdbarch_addr_bits_remove is wrong if we are being called for a non-address (e.g. argument to "signal", "info break", etc.), or for pointers to char, in which the low bits *are* significant. */ - return ADDR_BITS_REMOVE (value_as_long (val)); + return gdbarch_addr_bits_remove (current_gdbarch, value_as_long (val)); #else /* There are several targets (IA-64, PowerPC, and others) which @@ -805,25 +1103,23 @@ value_as_address (struct value *val) to an INT (or some size). After all, it is only an offset. */ LONGEST -unpack_long (struct type *type, const char *valaddr) +unpack_long (struct type *type, const gdb_byte *valaddr) { enum type_code code = TYPE_CODE (type); int len = TYPE_LENGTH (type); int nosign = TYPE_UNSIGNED (type); - if (current_language->la_language == language_scm - && is_scmvalue_type (type)) - return scm_unpack (type, valaddr, TYPE_CODE_INT); - switch (code) { case TYPE_CODE_TYPEDEF: return unpack_long (check_typedef (type), valaddr); case TYPE_CODE_ENUM: + case TYPE_CODE_FLAGS: case TYPE_CODE_BOOL: case TYPE_CODE_INT: case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: + case TYPE_CODE_MEMBERPTR: if (nosign) return extract_unsigned_integer (valaddr, len); else @@ -832,17 +1128,19 @@ unpack_long (struct type *type, const char *valaddr) case TYPE_CODE_FLT: return extract_typed_floating (valaddr, type); + case TYPE_CODE_DECFLOAT: + /* libdecnumber has a function to convert from decimal to integer, but + it doesn't work when the decimal number has a fractional part. */ + return decimal_to_doublest (valaddr, len); + case TYPE_CODE_PTR: case TYPE_CODE_REF: /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ return extract_typed_address (valaddr, type); - case TYPE_CODE_MEMBER: - error ("not implemented: member types in unpack_long"); - default: - error ("Value can't be converted to integer."); + error (_("Value can't be converted to integer.")); } return 0; /* Placate lint. */ } @@ -854,7 +1152,7 @@ unpack_long (struct type *type, const char *valaddr) format, result is in host format. */ DOUBLEST -unpack_double (struct type *type, const char *valaddr, int *invp) +unpack_double (struct type *type, const gdb_byte *valaddr, int *invp) { enum type_code code; int len; @@ -875,7 +1173,7 @@ unpack_double (struct type *type, const char *valaddr, int *invp) only in a non-portable way. Fixing the portability problem wouldn't help since the VAX floating-point code is also badly bit-rotten. The target needs to add definitions for the - methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these + methods gdbarch_float_format and gdbarch_double_format - these exactly describe the target floating-point format. The problem here is that the corresponding floatformat_vax_f and floatformat_vax_d values these methods should be set to are @@ -892,6 +1190,8 @@ unpack_double (struct type *type, const char *valaddr, int *invp) return extract_typed_floating (valaddr, type); } + else if (code == TYPE_CODE_DECFLOAT) + return decimal_to_doublest (valaddr, len); else if (nosign) { /* Unsigned -- be sure we compensate for signed LONGEST. */ @@ -918,7 +1218,7 @@ unpack_double (struct type *type, const char *valaddr, int *invp) to an INT (or some size). After all, it is only an offset. */ CORE_ADDR -unpack_pointer (struct type *type, const char *valaddr) +unpack_pointer (struct type *type, const gdb_byte *valaddr) { /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ @@ -962,8 +1262,8 @@ value_static_field (struct type *type, int fieldno) /* SYM should never have a SYMBOL_CLASS which will require read_var_value to use the FRAME parameter. */ if (symbol_read_needs_frame (sym)) - warning ("static field's value depends on the current " - "frame - bad debug info?"); + warning (_("static field's value depends on the current " + "frame - bad debug info?")); retval = read_var_value (sym, NULL); } if (retval && VALUE_LVAL (retval) == lval_memory) @@ -1079,11 +1379,9 @@ value_primitive_field (struct value *arg1, int offset, VALUE_LVAL (v) = VALUE_LVAL (arg1); if (VALUE_LVAL (arg1) == lval_internalvar) VALUE_LVAL (v) = lval_internalvar_component; - VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1); + v->location = arg1->location; VALUE_REGNUM (v) = VALUE_REGNUM (arg1); VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1); -/* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset - + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */ return v; } @@ -1168,7 +1466,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *ty If the field is signed, we also do sign extension. */ LONGEST -unpack_field_as_long (struct type *type, const char *valaddr, int fieldno) +unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno) { ULONGEST val; ULONGEST valmask; @@ -1183,7 +1481,7 @@ unpack_field_as_long (struct type *type, const char *valaddr, int fieldno) /* Extract bits. See comment above. */ - if (BITS_BIG_ENDIAN) + if (gdbarch_bits_big_endian (current_gdbarch)) lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize); else lsbcount = (bitpos % 8); @@ -1215,7 +1513,7 @@ unpack_field_as_long (struct type *type, const char *valaddr, int fieldno) 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */ void -modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) +modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize) { ULONGEST oword; ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize); @@ -1230,7 +1528,7 @@ modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) { /* FIXME: would like to include fieldval in the message, but we don't have a sprintf_longest. */ - warning ("Value does not fit in %d bits.", bitsize); + warning (_("Value does not fit in %d bits."), bitsize); /* Truncate it, otherwise adjoining fields may be corrupted. */ fieldval &= mask; @@ -1239,7 +1537,7 @@ modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) oword = extract_unsigned_integer (addr, sizeof oword); /* Shifting for bit field depends on endianness of the target machine. */ - if (BITS_BIG_ENDIAN) + if (gdbarch_bits_big_endian (current_gdbarch)) bitpos = sizeof (oword) * 8 - bitpos - bitsize; oword &= ~(mask << bitpos); @@ -1248,39 +1546,49 @@ modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) store_unsigned_integer (addr, sizeof oword, oword); } -/* Convert C numbers into newly allocated values */ +/* Pack NUM into BUF using a target format of TYPE. */ -struct value * -value_from_longest (struct type *type, LONGEST num) +void +pack_long (gdb_byte *buf, struct type *type, LONGEST num) { - struct value *val = allocate_value (type); - enum type_code code; int len; -retry: - code = TYPE_CODE (type); + + type = check_typedef (type); len = TYPE_LENGTH (type); - switch (code) + switch (TYPE_CODE (type)) { - case TYPE_CODE_TYPEDEF: - type = check_typedef (type); - goto retry; case TYPE_CODE_INT: case TYPE_CODE_CHAR: case TYPE_CODE_ENUM: + case TYPE_CODE_FLAGS: case TYPE_CODE_BOOL: case TYPE_CODE_RANGE: - store_signed_integer (value_contents_raw (val), len, num); + case TYPE_CODE_MEMBERPTR: + store_signed_integer (buf, len, num); break; case TYPE_CODE_REF: case TYPE_CODE_PTR: - store_typed_address (value_contents_raw (val), type, (CORE_ADDR) num); + store_typed_address (buf, type, (CORE_ADDR) num); break; default: - error ("Unexpected type (%d) encountered for integer constant.", code); + error (_("Unexpected type (%d) encountered for integer constant."), + TYPE_CODE (type)); } +} + + +/* Convert C numbers into newly allocated values. */ + +struct value * +value_from_longest (struct type *type, LONGEST num) +{ + struct value *val = allocate_value (type); + + pack_long (value_contents_raw (val), type, num); + return val; } @@ -1337,7 +1645,17 @@ value_from_double (struct type *type, DOUBLEST num) store_typed_floating (value_contents_raw (val), base_type, num); } else - error ("Unexpected type encountered for floating constant."); + error (_("Unexpected type encountered for floating constant.")); + + return val; +} + +struct value * +value_from_decfloat (struct type *type, const gdb_byte *dec) +{ + struct value *val = allocate_value (type); + + memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type)); return val; } @@ -1382,44 +1700,17 @@ coerce_enum (struct value *arg) } -/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of - EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE - is the type (which is known to be struct, union or array). - - On most machines, the struct convention is used unless we are - using gcc and the type is of a special size. */ -/* As of about 31 Mar 93, GCC was changed to be compatible with the - native compiler. GCC 2.3.3 was the last release that did it the - old way. Since gcc2_compiled was not changed, we have no - way to correctly win in all cases, so we just do the right thing - for gcc1 and for gcc2 after this change. Thus it loses for gcc - 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled - would cause more chaos than dealing with some struct returns being - handled wrong. */ -/* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is - dead. */ - -int -generic_use_struct_convention (int gcc_p, struct type *value_type) -{ - return !(TYPE_LENGTH (value_type) == 1 - || TYPE_LENGTH (value_type) == 2 - || TYPE_LENGTH (value_type) == 4 - || TYPE_LENGTH (value_type) == 8); -} - /* Return true if the function returning the specified type is using the convention of returning structures in memory (passing in the - address as a hidden first parameter). GCC_P is nonzero if compiled - with GCC. */ + address as a hidden first parameter). */ int -using_struct_return (struct type *value_type, int gcc_p) +using_struct_return (struct type *value_type) { enum type_code code = TYPE_CODE (value_type); if (code == TYPE_CODE_ERROR) - error ("Function return type unknown."); + error (_("Function return type unknown.")); if (code == TYPE_CODE_VOID) /* A void return value is never in memory. See also corresponding @@ -1432,19 +1723,43 @@ using_struct_return (struct type *value_type, int gcc_p) != RETURN_VALUE_REGISTER_CONVENTION); } +/* Set the initialized field in a value struct. */ + +void +set_value_initialized (struct value *val, int status) +{ + val->initialized = status; +} + +/* Return the initialized field in a value struct. */ + +int +value_initialized (struct value *val) +{ + return val->initialized; +} + void _initialize_values (void) { - add_cmd ("convenience", no_class, show_convenience, - "Debugger convenience (\"$foo\") variables.\n\ + add_cmd ("convenience", no_class, show_convenience, _("\ +Debugger convenience (\"$foo\") variables.\n\ These variables are created when you assign them values;\n\ -thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\ +thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\ +\n\ A few convenience variables are given values automatically:\n\ \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\ -\"$__\" holds the contents of the last address examined with \"x\".", +\"$__\" holds the contents of the last address examined with \"x\"."), &showlist); add_cmd ("values", no_class, show_values, - "Elements of value history around item number IDX (or last ten).", + _("Elements of value history around item number IDX (or last ten)."), &showlist); + + add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\ +Initialize a convenience variable if necessary.\n\ +init-if-undefined VARIABLE = EXPRESSION\n\ +Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\ +exist or does not contain a value. The EXPRESSION is not evaluated if the\n\ +VARIABLE is already initialized.")); }