struct value *
value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
{
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value *stringValue[3];
struct value *function, *nsstringValue;
struct symbol *sym;
struct type *type;
if (!target_has_execution)
return 0; /* Can't call into inferior to create NSString. */
stringValue[2] = value_string(ptr, len, char_type);
stringValue[2] = value_coerce_array(stringValue[2]);
/* _NSNewStringFromCString replaces "istr" after Lantern2A. */
if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym)
{
function = find_function_in_inferior("_NSNewStringFromCString", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("istr", 0, 0).minsym)
{
function = find_function_in_inferior("istr", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym)
{
function
= find_function_in_inferior("+[NSString stringWithCString:]", NULL);
type = builtin_type (gdbarch)->builtin_long;
stringValue[0] = value_from_longest
(type, lookup_objc_class (gdbarch, "NSString"));
stringValue[1] = value_from_longest
(type, lookup_child_selector (gdbarch, "stringWithCString:"));
nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
}
else
error (_("NSString: internal error -- no way to create new NSString"));
sym = lookup_struct_typedef("NSString", 0, 1);
if (sym == NULL)
sym = lookup_struct_typedef("NXString", 0, 1);
if (sym == NULL)
type = builtin_type (gdbarch)->builtin_data_ptr;
else
type = lookup_pointer_type(SYMBOL_TYPE (sym));
deprecated_set_value_type (nsstringValue, type);
return nsstringValue;
}
/* Use inferior's dlopen() to bring in some helper functions: */
void
load_helpers(void)
{
struct value *dlfn, *args[2], *val;
long rslt;
args[0] = value_string(LIBCHECKPOINT_NAME,
(strlen(LIBCHECKPOINT_NAME) + 1UL));
args[0] = value_coerce_array(args[0]);
args[1] = value_from_longest(builtin_type_int, (LONGEST)RTLD_NOW);
if (lookup_minimal_symbol("dlopen", 0, 0)
&& (dlfn = find_function_in_inferior("dlopen", builtin_type_int)))
{
val = call_function_by_hand_expecting_type(dlfn,
builtin_type_int, 2,
args, 1);
rslt = (long)value_as_long(val);
if (rslt == 0)
warning("dlopen of checkpoint library returned NULL");
}
else
{
warning("dlopen not found, libcheckpoint functions not loaded");
}
}
static void
ada_varobj_simple_array_elt (struct value *parent_value,
struct type *parent_type,
int elt_index,
struct value **child_value,
struct type **child_type)
{
struct value *value = NULL;
struct type *type = NULL;
if (parent_value)
{
struct value *index_value =
value_from_longest (TYPE_INDEX_TYPE (parent_type), elt_index);
value = ada_value_subscript (parent_value, 1, &index_value);
type = value_type (value);
}
else
type = TYPE_TARGET_TYPE (parent_type);
if (child_value)
*child_value = value;
if (child_type)
*child_type = type;
}
static SCM
vlscm_unop (enum valscm_unary_opcode opcode, SCM x, const char *func_name)
{
struct gdbarch *gdbarch = get_current_arch ();
const struct language_defn *language = current_language;
struct value *arg1;
SCM result = SCM_BOOL_F;
struct value *res_val = NULL;
SCM except_scm;
struct cleanup *cleanups;
cleanups = make_cleanup_value_free_to_mark (value_mark ());
arg1 = vlscm_convert_value_from_scheme (func_name, SCM_ARG1, x,
&except_scm, gdbarch, language);
if (arg1 == NULL)
{
do_cleanups (cleanups);
gdbscm_throw (except_scm);
}
TRY
{
switch (opcode)
{
case VALSCM_NOT:
/* Alas gdb and guile use the opposite meaning for "logical not". */
{
struct type *type = language_bool_type (language, gdbarch);
res_val
= value_from_longest (type, (LONGEST) value_logical_not (arg1));
}
break;
case VALSCM_NEG:
res_val = value_neg (arg1);
break;
case VALSCM_NOP:
/* Seemingly a no-op, but if X was a Scheme value it is now
a <gdb:value> object. */
res_val = arg1;
break;
case VALSCM_ABS:
if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
res_val = value_neg (arg1);
else
res_val = arg1;
break;
case VALSCM_LOGNOT:
res_val = value_complement (arg1);
break;
default:
gdb_assert_not_reached ("unsupported operation");
}
}
CATCH (except, RETURN_MASK_ALL)
{
GDBSCM_HANDLE_GDB_EXCEPTION_WITH_CLEANUPS (except, cleanups);
}
static struct value *
gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
{
struct gdbarch *gdbarch;
const gdb_byte *contents = value_contents (method_ptr);
CORE_ADDR ptr_value;
struct type *domain_type, *final_type, *method_type;
LONGEST adjustment;
struct value *adjval;
int vbit;
domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
final_type = lookup_pointer_type (domain_type);
method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
/* Extract the pointer to member. */
gdbarch = get_class_arch (domain_type);
vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
/* First convert THIS to match the containing type of the pointer to
member. This cast may adjust the value of THIS. */
*this_p = value_cast (final_type, *this_p);
/* Then apply whatever adjustment is necessary. This creates a somewhat
strange pointer: it claims to have type FINAL_TYPE, but in fact it
might not be a valid FINAL_TYPE. For instance, it might be a
base class of FINAL_TYPE. And if it's not the primary base class,
then printing it out as a FINAL_TYPE object would produce some pretty
garbage.
But we don't really know the type of the first argument in
METHOD_TYPE either, which is why this happens. We can't
dereference this later as a FINAL_TYPE, but once we arrive in the
called method we'll have debugging information for the type of
"this" - and that'll match the value we produce here.
You can provoke this case by casting a Base::* to a Derived::*, for
instance. */
*this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
adjval = value_from_longest (builtin_type (gdbarch)->builtin_long,
adjustment);
*this_p = value_ptradd (*this_p, adjval);
*this_p = value_cast (final_type, *this_p);
if (vbit)
{
LONGEST voffset;
voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
method_type, voffset);
}
else
return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
}
static bfd_vma
call_target_sbrk (int sbrk_arg)
{
struct objfile *sbrk_objf;
struct gdbarch *gdbarch;
bfd_vma top_of_heap;
struct value *target_sbrk_arg;
struct value *sbrk_fn, *ret;
bfd_vma tmp;
if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
{
sbrk_fn = find_function_in_inferior ("sbrk", &sbrk_objf);
if (sbrk_fn == NULL)
return (bfd_vma) 0;
}
else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
{
sbrk_fn = find_function_in_inferior ("_sbrk", &sbrk_objf);
if (sbrk_fn == NULL)
return (bfd_vma) 0;
}
else
return (bfd_vma) 0;
gdbarch = get_objfile_arch (sbrk_objf);
target_sbrk_arg = value_from_longest (builtin_type (gdbarch)->builtin_int,
sbrk_arg);
gdb_assert (target_sbrk_arg);
ret = call_function_by_hand (sbrk_fn, 1, &target_sbrk_arg);
if (ret == NULL)
return (bfd_vma) 0;
tmp = value_as_long (ret);
if ((LONGEST) tmp <= 0 || (LONGEST) tmp == 0xffffffff)
return (bfd_vma) 0;
top_of_heap = tmp;
return top_of_heap;
}
struct value *
value_bitstring_subscript (struct type *type,
struct value *bitstring, LONGEST index)
{
struct type *bitstring_type, *range_type;
struct value *v;
int offset, byte, bit_index;
LONGEST lowerbound, upperbound;
bitstring_type = check_typedef (value_type (bitstring));
gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
range_type = TYPE_INDEX_TYPE (bitstring_type);
get_discrete_bounds (range_type, &lowerbound, &upperbound);
if (index < lowerbound || index > upperbound)
error (_("bitstring index out of range"));
index -= lowerbound;
offset = index / TARGET_CHAR_BIT;
byte = *((char *) value_contents (bitstring) + offset);
bit_index = index % TARGET_CHAR_BIT;
byte >>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type)) ?
TARGET_CHAR_BIT - 1 - bit_index : bit_index);
v = value_from_longest (type, byte & 1);
set_value_bitpos (v, bit_index);
set_value_bitsize (v, 1);
set_value_component_location (v, bitstring);
VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
set_value_offset (v, offset + value_offset (bitstring));
return v;
}
static struct value *
gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
struct type *fntype, int vtable_index)
{
struct value *vtable = gnuv3_get_vtable (gdbarch, container);
struct value *vfn;
/* Fetch the appropriate function pointer from the vtable. */
vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
value_from_longest (builtin_type_int32, vtable_index));
/* If this architecture uses function descriptors directly in the vtable,
then the address of the vtable entry is actually a "function pointer"
(i.e. points to the descriptor). We don't need to scale the index
by the size of a function descriptor; GCC does that before outputing
debug information. */
if (gdbarch_vtable_function_descriptors (gdbarch))
vfn = value_addr (vfn);
/* Cast the function pointer to the appropriate type. */
vfn = value_cast (lookup_pointer_type (fntype), vfn);
return vfn;
}
static int
derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
{
bfd_vma top_of_data_memory = 0;
bfd_vma top_of_heap = 0;
bfd_size_type sec_size;
struct value *zero, *sbrk;
bfd_vma sec_vaddr;
asection *sec;
gdb_assert (bottom);
gdb_assert (top);
/* This function depends on being able to call a function in the
inferior. */
if (!target_has_execution)
return 0;
/* The following code assumes that the link map is arranged as
follows (low to high addresses):
---------------------------------
| text sections |
---------------------------------
| data sections (including bss) |
---------------------------------
| heap |
--------------------------------- */
for (sec = abfd->sections; sec; sec = sec->next)
{
if (bfd_get_section_flags (abfd, sec) & SEC_DATA
|| strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
{
sec_vaddr = bfd_get_section_vma (abfd, sec);
sec_size = bfd_get_section_size (sec);
if (sec_vaddr + sec_size > top_of_data_memory)
top_of_data_memory = sec_vaddr + sec_size;
}
}
/* Now get the top-of-heap by calling sbrk in the inferior. */
if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
{
sbrk = find_function_in_inferior ("sbrk");
if (sbrk == NULL)
return 0;
}
else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
{
sbrk = find_function_in_inferior ("_sbrk");
if (sbrk == NULL)
return 0;
}
else
return 0;
zero = value_from_longest (builtin_type_int, 0);
gdb_assert (zero);
sbrk = call_function_by_hand (sbrk, 1, &zero);
if (sbrk == NULL)
return 0;
top_of_heap = value_as_long (sbrk);
/* Return results. */
if (top_of_heap > top_of_data_memory)
{
*bottom = top_of_data_memory;
*top = top_of_heap;
return 1;
}
/* No additional heap space needs to be saved. */
return 0;
}
struct value *
evaluate_subexp_c (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
switch (op)
{
case OP_STRING:
{
int oplen, limit;
struct type *type;
struct obstack output;
struct cleanup *cleanup;
struct value *result;
enum c_string_type dest_type;
const char *dest_charset;
int satisfy_expected = 0;
obstack_init (&output);
cleanup = make_cleanup_obstack_free (&output);
++*pos;
oplen = longest_to_int (exp->elts[*pos].longconst);
++*pos;
limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
dest_type
= (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
switch (dest_type & ~C_CHAR)
{
case C_STRING:
type = language_string_char_type (exp->language_defn,
exp->gdbarch);
break;
case C_WIDE_STRING:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"wchar_t", NULL, 0);
break;
case C_STRING_16:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char16_t", NULL, 0);
break;
case C_STRING_32:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char32_t", NULL, 0);
break;
default:
internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
}
/* Ensure TYPE_LENGTH is valid for TYPE. */
check_typedef (type);
/* If the caller expects an array of some integral type,
satisfy them. If something odder is expected, rely on the
caller to cast. */
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
{
struct type *element_type
= check_typedef (TYPE_TARGET_TYPE (expect_type));
if (TYPE_CODE (element_type) == TYPE_CODE_INT
|| TYPE_CODE (element_type) == TYPE_CODE_CHAR)
{
type = element_type;
satisfy_expected = 1;
}
}
dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
++*pos;
while (*pos < limit)
{
int len;
len = longest_to_int (exp->elts[*pos].longconst);
++*pos;
if (noside != EVAL_SKIP)
parse_one_string (&output, &exp->elts[*pos].string, len,
dest_charset, type);
*pos += BYTES_TO_EXP_ELEM (len);
}
/* Skip the trailing length and opcode. */
*pos += 2;
if (noside == EVAL_SKIP)
{
/* Return a dummy value of the appropriate type. */
if (expect_type != NULL)
result = allocate_value (expect_type);
else if ((dest_type & C_CHAR) != 0)
result = allocate_value (type);
else
result = value_cstring ("", 0, type);
do_cleanups (cleanup);
return result;
}
if ((dest_type & C_CHAR) != 0)
{
LONGEST value;
if (obstack_object_size (&output) != TYPE_LENGTH (type))
error (_("Could not convert character "
"constant to target character set"));
value = unpack_long (type, (gdb_byte *) obstack_base (&output));
result = value_from_longest (type, value);
}
else
{
int i;
/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
obstack_1grow (&output, 0);
if (satisfy_expected)
{
LONGEST low_bound, high_bound;
int element_size = TYPE_LENGTH (type);
if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
&low_bound, &high_bound) < 0)
{
low_bound = 0;
high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
}
if (obstack_object_size (&output) / element_size
> (high_bound - low_bound + 1))
error (_("Too many array elements"));
result = allocate_value (expect_type);
memcpy (value_contents_raw (result), obstack_base (&output),
obstack_object_size (&output));
}
else
result = value_cstring (obstack_base (&output),
obstack_object_size (&output),
type);
}
do_cleanups (cleanup);
return result;
}
break;
default:
break;
}
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
void
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct ui_file *stream,
int format, int recurse,
enum val_prettyprint pretty,
struct type **dont_print_vb,
int dont_print_statmem)
{
int i, len, n_baseclasses;
char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
/* Print out baseclasses such that we don't print
duplicates of virtual baseclasses. */
if (n_baseclasses > 0)
pascal_object_print_value (type, valaddr, address, stream,
format, recurse + 1, pretty, dont_print_vb);
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "<No data fields>");
else
{
struct obstack tmp_obstack = dont_print_statmem_obstack;
int fields_seen = 0;
if (dont_print_statmem == 0)
{
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
obstack_finish (&dont_print_statmem_obstack);
}
for (i = n_baseclasses; i < len; i++)
{
/* If requested, skip printing of static fields. */
if (!pascal_static_field_print && TYPE_FIELD_STATIC (type, i))
continue;
if (fields_seen)
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
if (pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
fputs_filtered ("members of ", stream);
fputs_filtered (type_name_no_tag (type), stream);
fputs_filtered (": ", stream);
}
}
fields_seen = 1;
if (pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
if (inspect_it)
{
if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
fputs_filtered ("\"( ptr \"", stream);
else
fputs_filtered ("\"( nodef \"", stream);
if (TYPE_FIELD_STATIC (type, i))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\" \"", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\") \"", stream);
}
else
{
annotate_field_begin (TYPE_FIELD_TYPE (type, i));
if (TYPE_FIELD_STATIC (type, i))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
annotate_field_name_end ();
fputs_filtered (" = ", stream);
annotate_field_value ();
}
if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
{
struct value *v;
/* Bitfields require special handling, especially due to byte
order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else
{
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr, i));
common_val_print (v, stream, format, 0, recurse + 1, pretty);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (TYPE_FIELD_STATIC (type, i))
{
/* struct value *v = value_static_field (type, i); v4.17 specific */
struct value *v;
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr, i));
if (v == NULL)
fputs_filtered ("<optimized out>", stream);
else
pascal_object_print_static_field (v, stream, format,
recurse + 1, pretty);
}
else
{
/* val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
stream, format, 0, recurse + 1, pretty); */
val_print (TYPE_FIELD_TYPE (type, i),
valaddr, TYPE_FIELD_BITPOS (type, i) / 8,
address + TYPE_FIELD_BITPOS (type, i) / 8,
stream, format, 0, recurse + 1, pretty);
}
}
annotate_field_end ();
}
if (dont_print_statmem == 0)
{
/* Free the space used to deal with the printing
of the members from top level. */
obstack_free (&dont_print_statmem_obstack, last_dont_print);
dont_print_statmem_obstack = tmp_obstack;
}
if (pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
}
fprintf_filtered (stream, "}");
}
/* Compute the offset of the baseclass which is
the INDEXth baseclass of class TYPE,
for value at VALADDR (in host) at ADDRESS (in target).
The result is the offset of the baseclass value relative
to (the address of)(ARG) + OFFSET.
-1 is returned on error. */
static int
gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr,
CORE_ADDR address)
{
struct gdbarch *gdbarch;
struct type *vtable_type;
struct type *ptr_type;
struct value *vtable;
struct type *vbasetype;
struct value *offset_val, *vbase_array;
CORE_ADDR vtable_address;
long int cur_base_offset, base_offset;
int vbasetype_vptr_fieldno;
/* Determine architecture. */
gdbarch = get_class_arch (type);
vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
/* If it isn't a virtual base, this is easy. The offset is in the
type definition. */
if (!BASETYPE_VIA_VIRTUAL (type, index))
return TYPE_BASECLASS_BITPOS (type, index) / 8;
/* To access a virtual base, we need to use the vbase offset stored in
our vtable. Recent GCC versions provide this information. If it isn't
available, we could get what we needed from RTTI, or from drawing the
complete inheritance graph based on the debug info. Neither is
worthwhile. */
cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
error (_("Expected a negative vbase offset (old compiler?)"));
cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
error (_("Misaligned vbase offset."));
cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
/* We're now looking for the cur_base_offset'th entry (negative index)
in the vcall_and_vbase_offsets array. We used to cast the object to
its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO;
however, that cast can not be done without calling baseclass_offset again
if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the
v3 C++ ABI Section 2.4.I.2.b. Fortunately the ABI guarantees that the
vtable pointer will be located at the beginning of the object, so we can
bypass the casting. Verify that the TYPE_VPTR_FIELDNO is in fact at the
start of whichever baseclass it resides in, as a sanity measure - iff
we have debugging information for that baseclass. */
vbasetype = check_typedef (TYPE_VPTR_BASETYPE (type));
vbasetype_vptr_fieldno = get_vptr_fieldno (vbasetype, NULL);
if (vbasetype_vptr_fieldno >= 0
&& TYPE_FIELD_BITPOS (vbasetype, vbasetype_vptr_fieldno) != 0)
error (_("Illegal vptr offset in class %s"),
TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>");
vtable_address = value_as_address (value_at_lazy (ptr_type, address));
vtable
= value_at_lazy (vtable_type,
vtable_address - vtable_address_point_offset (gdbarch));
offset_val = value_from_longest (builtin_type_int32, cur_base_offset);
vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
base_offset = value_as_long (value_subscript (vbase_array, offset_val));
return base_offset;
}
static struct value *
evaluate_subexp_java (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
int pc = *pos;
int i;
const char *name;
enum exp_opcode op = exp->elts[*pos].opcode;
struct value *arg1;
struct value *arg2;
struct type *type;
switch (op)
{
case UNOP_IND:
if (noside == EVAL_SKIP)
goto standard;
(*pos)++;
arg1 = evaluate_subexp_java (NULL_TYPE, exp, pos, EVAL_NORMAL);
if (is_object_type (value_type (arg1)))
{
struct type *type;
type = type_from_class (exp->gdbarch, java_class_from_object (arg1));
arg1 = value_cast (lookup_pointer_type (type), arg1);
}
return value_ind (arg1);
case BINOP_SUBSCRIPT:
(*pos)++;
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
/* If the user attempts to subscript something that is not an
array or pointer type (like a plain int variable for example),
then report this as an error. */
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
type = check_typedef (TYPE_TARGET_TYPE (type));
name = TYPE_NAME (type);
if (name == NULL)
name = TYPE_TAG_NAME (type);
i = name == NULL ? 0 : strlen (name);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& i > 2 && name[i - 1] == ']')
{
enum bfd_endian byte_order = gdbarch_byte_order (exp->gdbarch);
CORE_ADDR address;
long length, index;
struct type *el_type;
gdb_byte buf4[4];
struct value *clas = java_class_from_object (arg1);
struct value *temp = clas;
/* Get CLASS_ELEMENT_TYPE of the array type. */
temp = value_struct_elt (&temp, NULL, "methods",
NULL, "structure");
deprecated_set_value_type (temp, value_type (clas));
el_type = type_from_class (exp->gdbarch, temp);
if (TYPE_CODE (el_type) == TYPE_CODE_STRUCT)
el_type = lookup_pointer_type (el_type);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (el_type, VALUE_LVAL (arg1));
address = value_as_address (arg1);
address += get_java_object_header_size (exp->gdbarch);
read_memory (address, buf4, 4);
length = (long) extract_signed_integer (buf4, 4, byte_order);
index = (long) value_as_long (arg2);
if (index >= length || index < 0)
error (_("array index (%ld) out of bounds (length: %ld)"),
index, length);
address = (address + 4) + index * TYPE_LENGTH (el_type);
return value_at (el_type, address);
}
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
else
return value_subscript (arg1, value_as_long (arg2));
}
if (name)
error (_("cannot subscript something of type `%s'"), name);
else
error (_("cannot subscript requested type"));
case OP_STRING:
(*pos)++;
i = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (i + 1);
if (noside == EVAL_SKIP)
goto nosideret;
return java_value_string (&exp->elts[pc + 2].string, i);
case STRUCTOP_PTR:
arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
/* Convert object field (such as TYPE.class) to reference. */
if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_STRUCT)
arg1 = value_addr (arg1);
return arg1;
default:
break;
}
standard:
return evaluate_subexp_standard (expect_type, exp, pos, noside);
nosideret:
return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
}
static void
execute_stack_op (struct dwarf_expr_context *ctx,
gdb_byte *op_ptr, gdb_byte *op_end)
{
enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
ctx->location = DWARF_VALUE_MEMORY;
ctx->initialized = 1; /* Default is initialized. */
if (ctx->recursion_depth > ctx->max_recursion_depth)
error (_("DWARF-2 expression error: Loop detected (%d)."),
ctx->recursion_depth);
ctx->recursion_depth++;
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
CORE_ADDR result;
/* Assume the value is not in stack memory.
Code that knows otherwise sets this to 1.
Some arithmetic on stack addresses can probably be assumed to still
be a stack address, but we skip this complication for now.
This is just an optimization, so it's always ok to punt
and leave this as 0. */
int in_stack_memory = 0;
ULONGEST uoffset, reg;
LONGEST offset;
switch (op)
{
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
result = op - DW_OP_lit0;
break;
case DW_OP_addr:
result = dwarf2_read_address (ctx->gdbarch,
op_ptr, op_end, ctx->addr_size);
op_ptr += ctx->addr_size;
break;
case DW_OP_const1u:
result = extract_unsigned_integer (op_ptr, 1, byte_order);
op_ptr += 1;
break;
case DW_OP_const1s:
result = extract_signed_integer (op_ptr, 1, byte_order);
op_ptr += 1;
break;
case DW_OP_const2u:
result = extract_unsigned_integer (op_ptr, 2, byte_order);
op_ptr += 2;
break;
case DW_OP_const2s:
result = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
break;
case DW_OP_const4u:
result = extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
break;
case DW_OP_const4s:
result = extract_signed_integer (op_ptr, 4, byte_order);
op_ptr += 4;
break;
case DW_OP_const8u:
result = extract_unsigned_integer (op_ptr, 8, byte_order);
op_ptr += 8;
break;
case DW_OP_const8s:
result = extract_signed_integer (op_ptr, 8, byte_order);
op_ptr += 8;
break;
case DW_OP_constu:
op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
result = uoffset;
break;
case DW_OP_consts:
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = offset;
break;
/* The DW_OP_reg operations are required to occur alone in
location expressions. */
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
if (op_ptr != op_end
&& *op_ptr != DW_OP_piece
&& *op_ptr != DW_OP_GNU_uninit)
error (_("DWARF-2 expression error: DW_OP_reg operations must be "
"used either alone or in conjuction with DW_OP_piece."));
result = op - DW_OP_reg0;
ctx->location = DWARF_VALUE_REGISTER;
break;
case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
require_composition (op_ptr, op_end, "DW_OP_regx");
result = reg;
ctx->location = DWARF_VALUE_REGISTER;
break;
case DW_OP_implicit_value:
{
ULONGEST len;
op_ptr = read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
error (_("DW_OP_implicit_value: too few bytes available."));
ctx->len = len;
ctx->data = op_ptr;
ctx->location = DWARF_VALUE_LITERAL;
op_ptr += len;
require_composition (op_ptr, op_end, "DW_OP_implicit_value");
}
goto no_push;
case DW_OP_stack_value:
ctx->location = DWARF_VALUE_STACK;
require_composition (op_ptr, op_end, "DW_OP_stack_value");
goto no_push;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
{
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
result += offset;
}
break;
case DW_OP_bregx:
{
op_ptr = read_uleb128 (op_ptr, op_end, ®);
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->read_reg) (ctx->baton, reg);
result += offset;
}
break;
case DW_OP_fbreg:
{
gdb_byte *datastart;
size_t datalen;
unsigned int before_stack_len;
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
/* Rather than create a whole new context, we simply
record the stack length before execution, then reset it
afterwards, effectively erasing whatever the recursive
call put there. */
before_stack_len = ctx->stack_len;
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2
specific this_base method. */
(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
dwarf_expr_eval (ctx, datastart, datalen);
if (ctx->location == DWARF_VALUE_LITERAL
|| ctx->location == DWARF_VALUE_STACK)
error (_("Not implemented: computing frame base using explicit value operator"));
result = dwarf_expr_fetch (ctx, 0);
if (ctx->location == DWARF_VALUE_REGISTER)
result = (ctx->read_reg) (ctx->baton, result);
result = result + offset;
in_stack_memory = 1;
ctx->stack_len = before_stack_len;
ctx->location = DWARF_VALUE_MEMORY;
}
break;
case DW_OP_dup:
result = dwarf_expr_fetch (ctx, 0);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
break;
case DW_OP_drop:
dwarf_expr_pop (ctx);
goto no_push;
case DW_OP_pick:
offset = *op_ptr++;
result = dwarf_expr_fetch (ctx, offset);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
break;
case DW_OP_swap:
{
struct dwarf_stack_value t1, t2;
if (ctx->stack_len < 2)
error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
ctx->stack_len);
t1 = ctx->stack[ctx->stack_len - 1];
t2 = ctx->stack[ctx->stack_len - 2];
ctx->stack[ctx->stack_len - 1] = t2;
ctx->stack[ctx->stack_len - 2] = t1;
goto no_push;
}
case DW_OP_over:
result = dwarf_expr_fetch (ctx, 1);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
break;
case DW_OP_rot:
{
struct dwarf_stack_value t1, t2, t3;
if (ctx->stack_len < 3)
error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
ctx->stack_len);
t1 = ctx->stack[ctx->stack_len - 1];
t2 = ctx->stack[ctx->stack_len - 2];
t3 = ctx->stack[ctx->stack_len - 3];
ctx->stack[ctx->stack_len - 1] = t2;
ctx->stack[ctx->stack_len - 2] = t3;
ctx->stack[ctx->stack_len - 3] = t1;
goto no_push;
}
case DW_OP_deref:
case DW_OP_deref_size:
case DW_OP_abs:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_plus_uconst:
/* Unary operations. */
result = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
switch (op)
{
case DW_OP_deref:
{
gdb_byte *buf = alloca (ctx->addr_size);
(ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
result = dwarf2_read_address (ctx->gdbarch,
buf, buf + ctx->addr_size,
ctx->addr_size);
}
break;
case DW_OP_deref_size:
{
int addr_size = *op_ptr++;
gdb_byte *buf = alloca (addr_size);
(ctx->read_mem) (ctx->baton, buf, result, addr_size);
result = dwarf2_read_address (ctx->gdbarch,
buf, buf + addr_size,
addr_size);
}
break;
case DW_OP_abs:
if ((signed int) result < 0)
result = -result;
break;
case DW_OP_neg:
result = -result;
break;
case DW_OP_not:
result = ~result;
break;
case DW_OP_plus_uconst:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
result += reg;
break;
}
break;
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_or:
case DW_OP_plus:
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
{
/* Binary operations. Use the value engine to do computations in
the right width. */
CORE_ADDR first, second;
enum exp_opcode binop;
struct value *val1 = NULL, *val2 = NULL;
struct type *stype, *utype;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
utype = unsigned_address_type (ctx->gdbarch, ctx->addr_size);
stype = signed_address_type (ctx->gdbarch, ctx->addr_size);
switch (op)
{
case DW_OP_and:
binop = BINOP_BITWISE_AND;
break;
case DW_OP_div:
binop = BINOP_DIV;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_minus:
binop = BINOP_SUB;
break;
case DW_OP_mod:
binop = BINOP_MOD;
break;
case DW_OP_mul:
binop = BINOP_MUL;
break;
case DW_OP_or:
binop = BINOP_BITWISE_IOR;
break;
case DW_OP_plus:
binop = BINOP_ADD;
break;
case DW_OP_shl:
binop = BINOP_LSH;
break;
case DW_OP_shr:
binop = BINOP_RSH;
break;
case DW_OP_shra:
binop = BINOP_RSH;
val1 = value_from_longest (stype, first);
break;
case DW_OP_xor:
binop = BINOP_BITWISE_XOR;
break;
case DW_OP_le:
binop = BINOP_LEQ;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_ge:
binop = BINOP_GEQ;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_eq:
binop = BINOP_EQUAL;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_lt:
binop = BINOP_LESS;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_gt:
binop = BINOP_GTR;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
case DW_OP_ne:
binop = BINOP_NOTEQUAL;
val1 = value_from_longest (stype, first);
val2 = value_from_longest (stype, second);
break;
default:
internal_error (__FILE__, __LINE__,
_("Can't be reached."));
}
/* We use unsigned operands by default. */
if (val1 == NULL)
val1 = value_from_longest (utype, first);
if (val2 == NULL)
val2 = value_from_longest (utype, second);
result = value_as_long (value_binop (val1, val2, binop));
}
break;
case DW_OP_call_frame_cfa:
result = (ctx->get_frame_cfa) (ctx->baton);
in_stack_memory = 1;
break;
case DW_OP_GNU_push_tls_address:
/* Variable is at a constant offset in the thread-local
storage block into the objfile for the current thread and
the dynamic linker module containing this expression. Here
we return returns the offset from that base. The top of the
stack has the offset from the beginning of the thread
control block at which the variable is located. Nothing
should follow this operator, so the top of stack would be
returned. */
result = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
result = (ctx->get_tls_address) (ctx->baton, result);
break;
case DW_OP_skip:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
op_ptr += offset;
goto no_push;
case DW_OP_bra:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
if (dwarf_expr_fetch (ctx, 0) != 0)
op_ptr += offset;
dwarf_expr_pop (ctx);
goto no_push;
case DW_OP_nop:
goto no_push;
case DW_OP_piece:
{
ULONGEST size;
/* Record the piece. */
op_ptr = read_uleb128 (op_ptr, op_end, &size);
add_piece (ctx, size);
/* Pop off the address/regnum, and reset the location
type. */
if (ctx->location != DWARF_VALUE_LITERAL)
dwarf_expr_pop (ctx);
ctx->location = DWARF_VALUE_MEMORY;
}
goto no_push;
case DW_OP_GNU_uninit:
if (op_ptr != op_end)
error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
"be the very last op."));
ctx->initialized = 0;
goto no_push;
default:
error (_("Unhandled dwarf expression opcode 0x%x"), op);
}
/* Most things push a result value. */
dwarf_expr_push (ctx, result, in_stack_memory);
no_push:;
}
ctx->recursion_depth--;
gdb_assert (ctx->recursion_depth >= 0);
}
static struct value *
evaluate_subexp_c (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
switch (op)
{
case OP_STRING:
{
int oplen, limit;
struct type *type;
struct obstack output;
struct cleanup *cleanup;
struct value *result;
enum c_string_type dest_type;
const char *dest_charset;
obstack_init (&output);
cleanup = make_cleanup_obstack_free (&output);
++*pos;
oplen = longest_to_int (exp->elts[*pos].longconst);
++*pos;
limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
dest_type
= (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
switch (dest_type & ~C_CHAR)
{
case C_STRING:
type = language_string_char_type (exp->language_defn,
exp->gdbarch);
break;
case C_WIDE_STRING:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"wchar_t", NULL, 0);
break;
case C_STRING_16:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char16_t", NULL, 0);
break;
case C_STRING_32:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char32_t", NULL, 0);
break;
default:
internal_error (__FILE__, __LINE__, "unhandled c_string_type");
}
/* Ensure TYPE_LENGTH is valid for TYPE. */
check_typedef (type);
dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
++*pos;
while (*pos < limit)
{
int len;
len = longest_to_int (exp->elts[*pos].longconst);
++*pos;
if (noside != EVAL_SKIP)
parse_one_string (&output, &exp->elts[*pos].string, len,
dest_charset, type);
*pos += BYTES_TO_EXP_ELEM (len);
}
/* Skip the trailing length and opcode. */
*pos += 2;
if (noside == EVAL_SKIP)
{
/* Return a dummy value of the appropriate type. */
if ((dest_type & C_CHAR) != 0)
result = allocate_value (type);
else
result = value_cstring ("", 0, type);
do_cleanups (cleanup);
return result;
}
if ((dest_type & C_CHAR) != 0)
{
LONGEST value;
if (obstack_object_size (&output) != TYPE_LENGTH (type))
error (_("Could not convert character constant to target character set"));
value = unpack_long (type, obstack_base (&output));
result = value_from_longest (type, value);
}
else
{
int i;
/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
obstack_1grow (&output, 0);
result = value_cstring (obstack_base (&output),
obstack_object_size (&output),
type);
}
do_cleanups (cleanup);
return result;
}
break;
default:
break;
}
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
struct value *
value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
{
struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
struct value **argvec;
char *ptr, *mangle_ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
arg1 = coerce_ref (arg1);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
error (_("Can't do that unary op on that type")); /* FIXME be explicit */
argvec = (struct value **) alloca (sizeof (struct value *) * 4);
argvec[1] = value_addr (arg1);
argvec[2] = 0;
nargs = 1;
/* Make the right function name up. */
strcpy (tstr, "operator__");
ptr = tstr + 8;
strcpy (mangle_tstr, "__");
mangle_ptr = mangle_tstr + 2;
switch (op)
{
case UNOP_PREINCREMENT:
strcpy (ptr, "++");
break;
case UNOP_PREDECREMENT:
strcpy (ptr, "--");
break;
case UNOP_POSTINCREMENT:
strcpy (ptr, "++");
argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
argvec[3] = 0;
nargs ++;
break;
case UNOP_POSTDECREMENT:
strcpy (ptr, "--");
argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
argvec[3] = 0;
nargs ++;
break;
case UNOP_LOGICAL_NOT:
strcpy (ptr, "!");
break;
case UNOP_COMPLEMENT:
strcpy (ptr, "~");
break;
case UNOP_NEG:
strcpy (ptr, "-");
break;
case UNOP_PLUS:
strcpy (ptr, "+");
break;
case UNOP_IND:
strcpy (ptr, "*");
break;
case STRUCTOP_PTR:
strcpy (ptr, "->");
break;
default:
error (_("Invalid unary operation specified."));
}
argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
&static_memfuncp, nargs);
if (argvec[0])
{
if (static_memfuncp)
{
argvec[1] = argvec[0];
nargs --;
argvec++;
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
return_type
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], nargs, argvec + 1);
}
throw_error (NOT_FOUND_ERROR,
_("member function %s not found"), tstr);
return 0; /* For lint -- never reached */
}
struct value *
value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
{
struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
char *ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
arg1 = coerce_ref (arg1);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
error (_("Can't do that unary op on that type")); /* FIXME be explicit */
value *argvec_storage[3];
gdb::array_view<value *> argvec = argvec_storage;
argvec[1] = value_addr (arg1);
argvec[2] = 0;
nargs = 1;
/* Make the right function name up. */
strcpy (tstr, "operator__");
ptr = tstr + 8;
strcpy (mangle_tstr, "__");
switch (op)
{
case UNOP_PREINCREMENT:
strcpy (ptr, "++");
break;
case UNOP_PREDECREMENT:
strcpy (ptr, "--");
break;
case UNOP_POSTINCREMENT:
strcpy (ptr, "++");
argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
nargs ++;
break;
case UNOP_POSTDECREMENT:
strcpy (ptr, "--");
argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
nargs ++;
break;
case UNOP_LOGICAL_NOT:
strcpy (ptr, "!");
break;
case UNOP_COMPLEMENT:
strcpy (ptr, "~");
break;
case UNOP_NEG:
strcpy (ptr, "-");
break;
case UNOP_PLUS:
strcpy (ptr, "+");
break;
case UNOP_IND:
strcpy (ptr, "*");
break;
case STRUCTOP_PTR:
strcpy (ptr, "->");
break;
default:
error (_("Invalid unary operation specified."));
}
argvec[0] = value_user_defined_op (&arg1, argvec.slice (1, nargs), tstr,
&static_memfuncp, noside);
if (argvec[0])
{
if (static_memfuncp)
{
argvec[1] = argvec[0];
argvec = argvec.slice (1);
}
if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
{
/* Static xmethods are not supported yet. */
gdb_assert (static_memfuncp == 0);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type
= result_type_of_xmethod (argvec[0], argvec[1]);
if (return_type == NULL)
error (_("Xmethod is missing return type."));
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_xmethod (argvec[0], argvec[1]);
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
return_type
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], NULL,
argvec.slice (1, nargs));
}
throw_error (NOT_FOUND_ERROR,
_("member function %s not found"), tstr);
}
static struct value *
evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
struct value *arg1;
struct value *arg2;
struct type *type;
switch (op)
{
case UNOP_HIGH:
(*pos)++;
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
else
{
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
if (m2_is_unbounded_array (type))
{
struct value *temp = arg1;
type = TYPE_FIELD_TYPE (type, 1);
/* i18n: Do not translate the "_m2_high" part! */
arg1 = value_struct_elt (&temp, NULL, "_m2_high", NULL,
_("unbounded structure "
"missing _m2_high field"));
if (value_type (arg1) != type)
arg1 = value_cast (type, arg1);
}
}
return arg1;
case BINOP_SUBSCRIPT:
(*pos)++;
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
/* If the user attempts to subscript something that is not an
array or pointer type (like a plain int variable for example),
then report this as an error. */
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
if (m2_is_unbounded_array (type))
{
struct value *temp = arg1;
type = TYPE_FIELD_TYPE (type, 0);
if (type == NULL || (TYPE_CODE (type) != TYPE_CODE_PTR))
{
warning (_("internal error: unbounded "
"array structure is unknown"));
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
/* i18n: Do not translate the "_m2_contents" part! */
arg1 = value_struct_elt (&temp, NULL, "_m2_contents", NULL,
_("unbounded structure "
"missing _m2_contents field"));
if (value_type (arg1) != type)
arg1 = value_cast (type, arg1);
check_typedef (value_type (arg1));
return value_ind (value_ptradd (arg1, value_as_long (arg2)));
}
else
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
{
if (TYPE_NAME (type))
error (_("cannot subscript something of type `%s'"),
TYPE_NAME (type));
else
error (_("cannot subscript requested type"));
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
else
return value_subscript (arg1, value_as_long (arg2));
default:
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
nosideret:
return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
}
static void
java_print_value_fields (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value_print_options *options)
{
int i, len, n_baseclasses;
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
if (n_baseclasses > 0)
{
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
for (i = 0; i < n_baseclasses; i++)
{
int boffset;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
char *basename = TYPE_NAME (baseclass);
const gdb_byte *base_valaddr;
if (BASETYPE_VIA_VIRTUAL (type, i))
continue;
if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
continue;
boffset = 0;
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * (recurse + 1), stream);
}
fputs_filtered ("<", stream);
/* Not sure what the best notation is in the case where there is no
baseclass name. */
fputs_filtered (basename ? basename : "", stream);
fputs_filtered ("> = ", stream);
base_valaddr = valaddr;
java_print_value_fields (baseclass, base_valaddr, address + boffset,
stream, recurse + 1, options);
fputs_filtered (", ", stream);
}
}
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "<No data fields>");
else
{
int fields_seen = 0;
for (i = n_baseclasses; i < len; i++)
{
/* If requested, skip printing of static fields. */
if (field_is_static (&TYPE_FIELD (type, i)))
{
char *name = TYPE_FIELD_NAME (type, i);
if (!options->static_field_print)
continue;
if (name != NULL && strcmp (name, "class") == 0)
continue;
}
if (fields_seen)
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
fputs_filtered ("members of ", stream);
fputs_filtered (type_name_no_tag (type), stream);
fputs_filtered (": ", stream);
}
}
fields_seen = 1;
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
if (options->inspect_it)
{
if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
fputs_filtered ("\"( ptr \"", stream);
else
fputs_filtered ("\"( nodef \"", stream);
if (field_is_static (&TYPE_FIELD (type, i)))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\" \"", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\") \"", stream);
}
else
{
annotate_field_begin (TYPE_FIELD_TYPE (type, i));
if (field_is_static (&TYPE_FIELD (type, i)))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
language_cplus,
DMGL_PARAMS | DMGL_ANSI);
annotate_field_name_end ();
fputs_filtered (": ", stream);
annotate_field_value ();
}
if (!field_is_static (&TYPE_FIELD (type, i))
&& TYPE_FIELD_PACKED (type, i))
{
struct value *v;
/* Bitfields require special handling, especially due to byte
order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else
{
struct value_print_options opts;
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr, i));
opts = *options;
opts.deref_ref = 0;
common_val_print (v, stream, recurse + 1,
&opts, current_language);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (field_is_static (&TYPE_FIELD (type, i)))
{
struct value *v = value_static_field (type, i);
if (v == NULL)
fputs_filtered ("<optimized out>", stream);
else
{
struct value_print_options opts;
struct type *t = check_typedef (value_type (v));
if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
v = value_addr (v);
opts = *options;
opts.deref_ref = 0;
common_val_print (v, stream, recurse + 1,
&opts, current_language);
}
}
else if (TYPE_FIELD_TYPE (type, i) == NULL)
fputs_filtered ("<unknown type>", stream);
else
{
struct value_print_options opts = *options;
opts.deref_ref = 0;
val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
address + TYPE_FIELD_BITPOS (type, i) / 8,
stream, recurse + 1, &opts,
current_language);
}
}
annotate_field_end ();
}
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
}
fprintf_filtered (stream, "}");
}
static int
ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int format,
int deref_ref, int recurse, enum val_prettyprint pretty)
{
unsigned int len;
int i;
struct type *elttype;
unsigned int eltlen;
LONGEST val;
char *valaddr = valaddr0 + embedded_offset;
CHECK_TYPEDEF (type);
if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
{
int retn;
struct value *mark = value_mark ();
struct value *val;
val = value_from_contents_and_address (type, valaddr, address);
val = ada_coerce_to_simple_array_ptr (val);
if (val == NULL)
{
fprintf_filtered (stream, "(null)");
retn = 0;
}
else
retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
VALUE_ADDRESS (val), stream, format,
deref_ref, recurse, pretty);
value_free_to_mark (mark);
return retn;
}
valaddr = ada_aligned_value_addr (type, valaddr);
embedded_offset -= valaddr - valaddr0 - embedded_offset;
type = printable_val_type (type, valaddr);
switch (TYPE_CODE (type))
{
default:
return c_val_print (type, valaddr0, embedded_offset, address, stream,
format, deref_ref, recurse, pretty);
case TYPE_CODE_PTR:
{
int ret = c_val_print (type, valaddr0, embedded_offset, address,
stream, format, deref_ref, recurse, pretty);
if (ada_is_tag_type (type))
{
struct value *val =
value_from_contents_and_address (type, valaddr, address);
const char *name = ada_tag_name (val);
if (name != NULL)
fprintf_filtered (stream, " (%s)", name);
return 0;
}
return ret;
}
case TYPE_CODE_INT:
case TYPE_CODE_RANGE:
if (ada_is_fixed_point_type (type))
{
LONGEST v = unpack_long (type, valaddr);
int len = TYPE_LENGTH (type);
fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
(double) ada_fixed_to_float (type, v));
return 0;
}
else if (ada_is_vax_floating_type (type))
{
struct value *val =
value_from_contents_and_address (type, valaddr, address);
struct value *func = ada_vax_float_print_function (type);
if (func != 0)
{
static struct type *parray_of_char = NULL;
struct value *printable_val;
if (parray_of_char == NULL)
parray_of_char =
make_pointer_type
(create_array_type
(NULL, builtin_type_char,
create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
printable_val =
value_ind (value_cast (parray_of_char,
call_function_by_hand (func, 1,
&val)));
fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
return 0;
}
/* No special printing function. Do as best we can. */
}
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
struct type *target_type = TYPE_TARGET_TYPE (type);
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
{
/* Obscure case of range type that has different length from
its base type. Perform a conversion, or we will get a
nonsense value. Actually, we could use the same
code regardless of lengths; I'm just avoiding a cast. */
struct value *v = value_cast (target_type,
value_from_contents_and_address
(type, valaddr, 0));
return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0,
stream, format, 0, recurse + 1, pretty);
}
else
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
valaddr0, embedded_offset,
address, stream, format, deref_ref,
recurse, pretty);
}
else
{
format = format ? format : output_format;
if (format)
{
print_scalar_formatted (valaddr, type, format, 0, stream);
}
else if (ada_is_system_address_type (type))
{
/* FIXME: We want to print System.Address variables using
the same format as for any access type. But for some
reason GNAT encodes the System.Address type as an int,
so we have to work-around this deficiency by handling
System.Address values as a special case. */
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
print_address_numeric
(extract_typed_address (valaddr, builtin_type_void_data_ptr),
1, stream);
}
else
{
val_print_type_code_int (type, valaddr, stream);
if (ada_is_character_type (type))
{
fputs_filtered (" ", stream);
ada_printchar ((unsigned char) unpack_long (type, valaddr),
stream);
}
}
return 0;
}
case TYPE_CODE_ENUM:
if (format)
{
print_scalar_formatted (valaddr, type, format, 0, stream);
break;
}
len = TYPE_NFIELDS (type);
val = unpack_long (type, valaddr);
for (i = 0; i < len; i++)
{
QUIT;
if (val == TYPE_FIELD_BITPOS (type, i))
{
break;
}
}
if (i < len)
{
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
if (name[0] == '\'')
fprintf_filtered (stream, "%ld %s", (long) val, name);
else
fputs_filtered (name, stream);
}
else
{
print_longest (stream, 'd', 0, val);
}
break;
case TYPE_CODE_FLT:
if (format)
return c_val_print (type, valaddr0, embedded_offset, address, stream,
format, deref_ref, recurse, pretty);
else
ada_print_floating (valaddr0 + embedded_offset, type, stream);
break;
case TYPE_CODE_UNION:
case TYPE_CODE_STRUCT:
if (ada_is_bogus_array_descriptor (type))
{
fprintf_filtered (stream, "(...?)");
return 0;
}
else
{
print_record (type, valaddr, stream, format, recurse, pretty);
return 0;
}
case TYPE_CODE_ARRAY:
elttype = TYPE_TARGET_TYPE (type);
if (elttype == NULL)
eltlen = 0;
else
eltlen = TYPE_LENGTH (elttype);
/* FIXME: This doesn't deal with non-empty arrays of
0-length items (not a typical case!) */
if (eltlen == 0)
len = 0;
else
len = TYPE_LENGTH (type) / eltlen;
/* For an array of chars, print with string syntax. */
if (ada_is_string_type (type) && (format == 0 || format == 's'))
{
if (prettyprint_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* If requested, look for the first null char and only print
elements up to it. */
if (stop_print_at_null)
{
int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
temp_len < len && temp_len < print_max
&& char_at (valaddr, temp_len, eltlen) != 0;
temp_len += 1);
len = temp_len;
}
printstr (stream, valaddr, len, 0, eltlen);
}
else
{
len = 0;
fprintf_filtered (stream, "(");
print_optional_low_bound (stream, type);
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
val_print_packed_array_elements (type, valaddr, 0, stream,
format, recurse, pretty);
else
val_print_array_elements (type, valaddr, address, stream,
format, deref_ref, recurse,
pretty, 0);
fprintf_filtered (stream, ")");
}
gdb_flush (stream);
return len;
case TYPE_CODE_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
/* De-reference the reference */
if (deref_ref)
{
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
LONGEST deref_val_int = (LONGEST)
unpack_pointer (lookup_pointer_type (builtin_type_void),
valaddr);
if (deref_val_int != 0)
{
struct value *deref_val =
ada_value_ind (value_from_longest
(lookup_pointer_type (elttype),
deref_val_int));
val_print (VALUE_TYPE (deref_val),
VALUE_CONTENTS (deref_val), 0,
VALUE_ADDRESS (deref_val), stream, format,
deref_ref, recurse + 1, pretty);
}
else
fputs_filtered ("(null)", stream);
}
else
fputs_filtered ("???", stream);
}
break;
}
gdb_flush (stream);
return 0;
}
/* Standard implementation of print_subexp for use in language_defn
vectors. */
void
print_subexp_standard (struct expression *exp, int *pos,
struct ui_file *stream, enum precedence prec)
{
unsigned tem;
const struct op_print *op_print_tab;
int pc;
unsigned nargs;
char *op_str;
int assign_modify = 0;
enum exp_opcode opcode;
enum precedence myprec = PREC_NULL;
/* Set to 1 for a right-associative operator. */
int assoc = 0;
struct value *val;
char *tempstr = NULL;
op_print_tab = exp->language_defn->la_op_print_tab;
pc = (*pos)++;
opcode = exp->elts[pc].opcode;
switch (opcode)
{
/* Common ops */
case OP_SCOPE:
myprec = PREC_PREFIX;
assoc = 0;
fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
fputs_filtered ("::", stream);
nargs = longest_to_int (exp->elts[pc + 2].longconst);
(*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
fputs_filtered (&exp->elts[pc + 3].string, stream);
return;
case OP_LONG:
(*pos) += 3;
value_print (value_from_longest (exp->elts[pc + 1].type,
exp->elts[pc + 2].longconst),
stream, 0, Val_no_prettyprint);
return;
case OP_DOUBLE:
(*pos) += 3;
value_print (value_from_double (exp->elts[pc + 1].type,
exp->elts[pc + 2].doubleconst),
stream, 0, Val_no_prettyprint);
return;
case OP_VAR_VALUE:
{
struct block *b;
(*pos) += 3;
b = exp->elts[pc + 1].block;
if (b != NULL
&& BLOCK_FUNCTION (b) != NULL
&& SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
{
fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
fputs_filtered ("::", stream);
}
fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
}
return;
case OP_LAST:
(*pos) += 2;
fprintf_filtered (stream, "$%d",
longest_to_int (exp->elts[pc + 1].longconst));
return;
case OP_REGISTER:
{
int regnum = longest_to_int (exp->elts[pc + 1].longconst);
const char *name = user_reg_map_regnum_to_name (current_gdbarch,
regnum);
(*pos) += 2;
fprintf_filtered (stream, "$%s", name);
return;
}
case OP_BOOL:
(*pos) += 2;
fprintf_filtered (stream, "%s",
longest_to_int (exp->elts[pc + 1].longconst)
? "TRUE" : "FALSE");
return;
case OP_INTERNALVAR:
(*pos) += 2;
fprintf_filtered (stream, "$%s",
internalvar_name (exp->elts[pc + 1].internalvar));
return;
case OP_FUNCALL:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" (", stream);
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
fputs_filtered (", ", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fputs_filtered (")", stream);
return;
case OP_NAME:
case OP_EXPRSTRING:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
case OP_STRING:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
/* LA_PRINT_STRING will print using the current repeat count threshold.
If necessary, we can temporarily set it to zero, or pass it as an
additional parameter to LA_PRINT_STRING. -fnf */
LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
return;
case OP_BITSTRING:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos)
+= 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
fprintf_unfiltered (stream, "B'<unimplemented>'");
return;
case OP_OBJC_NSSTRING: /* Objective-C Foundation Class NSString constant. */
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
fputs_filtered ("@\"", stream);
LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
fputs_filtered ("\"", stream);
return;
case OP_OBJC_MSGCALL:
{ /* Objective C message (method) call. */
char *selector;
(*pos) += 3;
nargs = longest_to_int (exp->elts[pc + 2].longconst);
fprintf_unfiltered (stream, "[");
print_subexp (exp, pos, stream, PREC_SUFFIX);
if (0 == target_read_string (exp->elts[pc + 1].longconst,
&selector, 1024, NULL))
{
error (_("bad selector"));
return;
}
if (nargs)
{
char *s, *nextS;
s = alloca (strlen (selector) + 1);
strcpy (s, selector);
for (tem = 0; tem < nargs; tem++)
{
nextS = strchr (s, ':');
*nextS = '\0';
fprintf_unfiltered (stream, " %s: ", s);
s = nextS + 1;
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
}
else
{
fprintf_unfiltered (stream, " %s", selector);
}
fprintf_unfiltered (stream, "]");
/* "selector" was malloc'd by target_read_string. Free it. */
xfree (selector);
return;
}
case OP_ARRAY:
(*pos) += 3;
nargs = longest_to_int (exp->elts[pc + 2].longconst);
nargs -= longest_to_int (exp->elts[pc + 1].longconst);
nargs++;
tem = 0;
if (exp->elts[pc + 4].opcode == OP_LONG
&& exp->elts[pc + 5].type == builtin_type_char
&& exp->language_defn->la_language == language_c)
{
/* Attempt to print C character arrays using string syntax.
Walk through the args, picking up one character from each
of the OP_LONG expression elements. If any array element
does not match our expection of what we should find for
a simple string, revert back to array printing. Note that
the last expression element is an explicit null terminator
byte, which doesn't get printed. */
tempstr = alloca (nargs);
pc += 4;
while (tem < nargs)
{
if (exp->elts[pc].opcode != OP_LONG
|| exp->elts[pc + 1].type != builtin_type_char)
{
/* Not a simple array of char, use regular array printing. */
tem = 0;
break;
}
else
{
tempstr[tem++] =
longest_to_int (exp->elts[pc + 2].longconst);
pc += 4;
}
}
}
if (tem > 0)
{
LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
(*pos) = pc;
}
else
{
fputs_filtered (" {", stream);
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
{
fputs_filtered (", ", stream);
}
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fputs_filtered ("}", stream);
}
return;
case OP_LABELED:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
/* Gcc support both these syntaxes. Unsure which is preferred. */
#if 1
fputs_filtered (&exp->elts[pc + 2].string, stream);
fputs_filtered (": ", stream);
#else
fputs_filtered (".", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
fputs_filtered ("=", stream);
#endif
print_subexp (exp, pos, stream, PREC_SUFFIX);
return;
case TERNOP_COND:
if ((int) prec > (int) PREC_COMMA)
fputs_filtered ("(", stream);
/* Print the subexpressions, forcing parentheses
around any binary operations within them.
This is more parentheses than are strictly necessary,
but it looks clearer. */
print_subexp (exp, pos, stream, PREC_HYPER);
fputs_filtered (" ? ", stream);
print_subexp (exp, pos, stream, PREC_HYPER);
fputs_filtered (" : ", stream);
print_subexp (exp, pos, stream, PREC_HYPER);
if ((int) prec > (int) PREC_COMMA)
fputs_filtered (")", stream);
return;
case TERNOP_SLICE:
case TERNOP_SLICE_COUNT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("(", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered (")", stream);
return;
case STRUCTOP_STRUCT:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (".", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
/* Will not occur for Modula-2 */
case STRUCTOP_PTR:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("->", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
case BINOP_SUBSCRIPT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("[", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered ("]", stream);
return;
case UNOP_POSTINCREMENT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("++", stream);
return;
case UNOP_POSTDECREMENT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("--", stream);
return;
case UNOP_CAST:
(*pos) += 2;
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered ("(", stream);
fputs_filtered ("(", stream);
type_print (exp->elts[pc + 1].type, "", stream, 0);
fputs_filtered (") ", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered (")", stream);
return;
case UNOP_MEMVAL:
(*pos) += 2;
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered ("(", stream);
if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC &&
exp->elts[pc + 3].opcode == OP_LONG)
{
/* We have a minimal symbol fn, probably. It's encoded
as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
Swallow the OP_LONG (including both its opcodes); ignore
its type; print the value in the type of the MEMVAL. */
(*pos) += 4;
val = value_at_lazy (exp->elts[pc + 1].type,
(CORE_ADDR) exp->elts[pc + 5].longconst);
value_print (val, stream, 0, Val_no_prettyprint);
}
else
{
fputs_filtered ("{", stream);
type_print (exp->elts[pc + 1].type, "", stream, 0);
fputs_filtered ("} ", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
}
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered (")", stream);
return;
case BINOP_ASSIGN_MODIFY:
opcode = exp->elts[pc + 1].opcode;
(*pos) += 2;
myprec = PREC_ASSIGN;
assoc = 1;
assign_modify = 1;
op_str = "???";
for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
if (op_print_tab[tem].opcode == opcode)
{
op_str = op_print_tab[tem].string;
break;
}
if (op_print_tab[tem].opcode != opcode)
/* Not found; don't try to keep going because we don't know how
to interpret further elements. */
error (_("Invalid expression"));
break;
/* C++ ops */
case OP_THIS:
++(*pos);
fputs_filtered ("this", stream);
return;
/* Objective-C ops */
case OP_OBJC_SELF:
++(*pos);
fputs_filtered ("self", stream); /* The ObjC equivalent of "this". */
return;
/* Modula-2 ops */
case MULTI_SUBSCRIPT:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fprintf_unfiltered (stream, " [");
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
fprintf_unfiltered (stream, ", ");
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fprintf_unfiltered (stream, "]");
return;
case BINOP_VAL:
(*pos) += 2;
fprintf_unfiltered (stream, "VAL(");
type_print (exp->elts[pc + 1].type, "", stream, 0);
fprintf_unfiltered (stream, ",");
print_subexp (exp, pos, stream, PREC_PREFIX);
fprintf_unfiltered (stream, ")");
return;
case BINOP_INCL:
case BINOP_EXCL:
error (_("print_subexp: Not implemented."));
/* Default ops */
default:
op_str = "???";
for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
if (op_print_tab[tem].opcode == opcode)
{
op_str = op_print_tab[tem].string;
myprec = op_print_tab[tem].precedence;
assoc = op_print_tab[tem].right_assoc;
break;
}
if (op_print_tab[tem].opcode != opcode)
/* Not found; don't try to keep going because we don't know how
to interpret further elements. For example, this happens
if opcode is OP_TYPE. */
error (_("Invalid expression"));
}
/* Note that PREC_BUILTIN will always emit parentheses. */
if ((int) myprec < (int) prec)
fputs_filtered ("(", stream);
if ((int) opcode > (int) BINOP_END)
{
if (assoc)
{
/* Unary postfix operator. */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (op_str, stream);
}
else
{
/* Unary prefix operator. */
fputs_filtered (op_str, stream);
if (myprec == PREC_BUILTIN_FUNCTION)
fputs_filtered ("(", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
if (myprec == PREC_BUILTIN_FUNCTION)
fputs_filtered (")", stream);
}
}
else
{
/* Binary operator. */
/* Print left operand.
If operator is right-associative,
increment precedence for this operand. */
print_subexp (exp, pos, stream,
(enum precedence) ((int) myprec + assoc));
/* Print the operator itself. */
if (assign_modify)
fprintf_filtered (stream, " %s= ", op_str);
else if (op_str[0] == ',')
fprintf_filtered (stream, "%s ", op_str);
else
fprintf_filtered (stream, " %s ", op_str);
/* Print right operand.
If operator is left-associative,
increment precedence for this operand. */
print_subexp (exp, pos, stream,
(enum precedence) ((int) myprec + !assoc));
}
if ((int) myprec < (int) prec)
fputs_filtered (")", stream);
}
static int
captured_main (void *data)
{
/* If you add initializations here, you also need to add then to the
proc do_steps_and_nexts in selftest.exp. */
struct captured_main_args *context = data;
int argc = context->argc;
char **argv = context->argv;
int count;
static int quiet = 0;
static int batch = 0;
static int set_args = 0;
/* Pointers to various arguments from command line. */
char *symarg = NULL;
char *execarg = NULL;
char *corearg = NULL;
char *cdarg = NULL;
char *ttyarg = NULL;
/* APPLE LOCAL: Set the osabi via option. */
char *osabiarg = NULL;
/* These are static so that we can take their address in an initializer. */
static int print_help;
static int print_version;
/* Pointers to all arguments of --command option. */
char **cmdarg;
/* Allocated size of cmdarg. */
int cmdsize;
/* Number of elements of cmdarg used. */
int ncmd;
/* Indices of all arguments of --directory option. */
char **dirarg;
/* Allocated size. */
int dirsize;
/* Number of elements used. */
int ndir;
/* APPLE LOCAL globalbuf */
struct stat homebuf, cwdbuf, globalbuf;
char *homedir;
/* APPLE LOCAL attach -waitfor */
char *attach_waitfor = NULL;
/* APPLE LOCAL: set the architecture. */
char *initial_arch = NULL;
int i;
long time_at_startup = get_run_time ();
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* APPLE LOCAL memory */
#ifdef USE_MMALLOC
init_mmalloc_default_pool ((PTR) NULL);
#endif
/* This needs to happen before the first use of malloc. */
init_malloc (NULL);
#ifdef HAVE_SBRK
lim_at_start = (char *) sbrk (0);
#endif
#if defined (ALIGN_STACK_ON_STARTUP)
i = (int) &count & 0x3;
if (i != 0)
alloca (4 - i);
#endif
cmdsize = 1;
cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
ncmd = 0;
dirsize = 1;
dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
ndir = 0;
quit_flag = 0;
line = (char *) xmalloc (linesize);
line[0] = '\0'; /* Terminate saved (now empty) cmd line */
instream = stdin;
getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
current_directory = gdb_dirbuf;
/* APPLE LOCAL gdb_null */
gdb_null = ui_file_new ();
gdb_stdout = stdio_fileopen (stdout);
gdb_stderr = stdio_fileopen (stderr);
gdb_stdlog = gdb_stderr; /* for moment */
gdb_stdtarg = gdb_stderr; /* for moment */
gdb_stdin = stdio_fileopen (stdin);
gdb_stdtargerr = gdb_stderr; /* for moment */
gdb_stdtargin = gdb_stdin; /* for moment */
/* APPLE LOCAL: set our main thread's name */
#ifdef HAVE_PTHREAD_SETNAME_NP
pthread_setname_np ("gdb main thread");
#endif
/* Set the sysroot path. */
#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
if (gdb_sysroot)
{
struct stat s;
int res = 0;
if (stat (gdb_sysroot, &s) == 0)
if (S_ISDIR (s.st_mode))
res = 1;
if (res == 0)
{
xfree (gdb_sysroot);
gdb_sysroot = TARGET_SYSTEM_ROOT;
}
}
else
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
#if defined (TARGET_SYSTEM_ROOT)
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
gdb_sysroot = "";
#endif
#endif
/* There will always be an interpreter. Either the one passed into
this captured main, or one specified by the user at start up, or
the console. Initialize the interpreter to the one requested by
the application. */
interpreter_p = xstrdup (context->interpreter_p);
/* Parse arguments and options. */
{
int c;
/* When var field is 0, use flag field to record the equivalent
short option (or arbitrary numbers starting at 10 for those
with no equivalent). */
enum {
OPT_SE = 10,
OPT_CD,
OPT_ANNOTATE,
OPT_STATISTICS,
OPT_TUI,
OPT_NOWINDOWS,
OPT_WINDOWS,
OPT_WAITFOR, /* APPLE LOCAL */
OPT_ARCH, /* APPLE LOCAL */
OPT_OSABI /* APPLE LOCAL */
};
static struct option long_options[] =
{
#if defined(TUI)
{"tui", no_argument, 0, OPT_TUI},
#endif
{"xdb", no_argument, &xdb_commands, 1},
{"dbx", no_argument, &dbx_commands, 1},
{"readnow", no_argument, &readnow_symbol_files, 1},
{"r", no_argument, &readnow_symbol_files, 1},
{"quiet", no_argument, &quiet, 1},
{"q", no_argument, &quiet, 1},
{"silent", no_argument, &quiet, 1},
{"nx", no_argument, &inhibit_gdbinit, 1},
{"n", no_argument, &inhibit_gdbinit, 1},
{"batch", no_argument, &batch, 1},
{"epoch", no_argument, &epoch_interface, 1},
/* This is a synonym for "--annotate=1". --annotate is now preferred,
but keep this here for a long time because people will be running
emacses which use --fullname. */
{"fullname", no_argument, 0, 'f'},
{"f", no_argument, 0, 'f'},
{"annotate", required_argument, 0, OPT_ANNOTATE},
{"help", no_argument, &print_help, 1},
{"se", required_argument, 0, OPT_SE},
{"symbols", required_argument, 0, 's'},
{"s", required_argument, 0, 's'},
{"exec", required_argument, 0, 'e'},
{"e", required_argument, 0, 'e'},
{"core", required_argument, 0, 'c'},
{"c", required_argument, 0, 'c'},
{"pid", required_argument, 0, 'p'},
{"p", required_argument, 0, 'p'},
{"command", required_argument, 0, 'x'},
{"version", no_argument, &print_version, 1},
{"x", required_argument, 0, 'x'},
#ifdef GDBTK
{"tclcommand", required_argument, 0, 'z'},
{"enable-external-editor", no_argument, 0, 'y'},
{"editor-command", required_argument, 0, 'w'},
#endif
{"ui", required_argument, 0, 'i'},
{"interpreter", required_argument, 0, 'i'},
{"i", required_argument, 0, 'i'},
{"directory", required_argument, 0, 'd'},
{"d", required_argument, 0, 'd'},
{"cd", required_argument, 0, OPT_CD},
{"tty", required_argument, 0, 't'},
{"baud", required_argument, 0, 'b'},
{"b", required_argument, 0, 'b'},
{"nw", no_argument, NULL, OPT_NOWINDOWS},
{"nowindows", no_argument, NULL, OPT_NOWINDOWS},
{"w", no_argument, NULL, OPT_WINDOWS},
{"windows", no_argument, NULL, OPT_WINDOWS},
{"statistics", no_argument, 0, OPT_STATISTICS},
{"write", no_argument, &write_files, 1},
{"args", no_argument, &set_args, 1},
/* APPLE LOCAL: */
{"waitfor", required_argument, 0, OPT_WAITFOR},
/* APPLE LOCAL: */
{"arch", required_argument, 0, OPT_ARCH},
/* APPLE LOCAL: */
{"osabi", required_argument, 0, OPT_OSABI},
{"l", required_argument, 0, 'l'},
{0, no_argument, 0, 0}
};
while (1)
{
int option_index;
c = getopt_long_only (argc, argv, "",
long_options, &option_index);
if (c == EOF || set_args)
break;
/* Long option that takes an argument. */
if (c == 0 && long_options[option_index].flag == 0)
c = long_options[option_index].val;
switch (c)
{
case 0:
/* Long option that just sets a flag. */
break;
case OPT_SE:
symarg = optarg;
execarg = optarg;
break;
case OPT_CD:
cdarg = optarg;
break;
case OPT_ANNOTATE:
/* FIXME: what if the syntax is wrong (e.g. not digits)? */
annotation_level = atoi (optarg);
break;
case OPT_STATISTICS:
/* Enable the display of both time and space usage. */
display_time = 1;
display_space = 1;
break;
case OPT_TUI:
/* --tui is equivalent to -i=tui. */
xfree (interpreter_p);
interpreter_p = xstrdup ("tui");
break;
case OPT_WINDOWS:
/* FIXME: cagney/2003-03-01: Not sure if this option is
actually useful, and if it is, what it should do. */
use_windows = 1;
break;
case OPT_NOWINDOWS:
/* -nw is equivalent to -i=console. */
xfree (interpreter_p);
interpreter_p = xstrdup (INTERP_CONSOLE);
use_windows = 0;
break;
/* APPLE LOCAL: */
case OPT_WAITFOR:
attach_waitfor = (char *) xmalloc (12 + strlen (optarg));
sprintf (attach_waitfor, "-waitfor \"%s\"", optarg);
break;
/* APPLE LOCAL: */
case OPT_ARCH:
initial_arch = xstrdup (optarg);
break;
/* APPLE LOCAL: Set the osabi via option. This option was
added along with a modification to the gdb driver shell script
for armv6. Binaries with the "arm" architecture (ARM v4T)
and "armv6" (ARM v6) can be inter mixed on armv6 capaable
targets since all instructions in the ARM v4T instruction set
are present in the ARM v6 instruction set. The same gdb
executable is used for both, and the osabi set/show variable
controls which gets used for cross targets. We need to set this
variable prior to loading any executables so that the correct
slice of a fat file can be selected. Now gdb can be launched
with the "armv6" arch along with an executable and the correct
slice will be selected:
gdb -arch armv6 <file> */
case OPT_OSABI:
osabiarg = optarg;
break;
/* APPLE LOCAL END */
case 'f':
annotation_level = 1;
/* We have probably been invoked from emacs. Disable window interface. */
use_windows = 0;
break;
case 's':
symarg = optarg;
break;
case 'e':
execarg = optarg;
break;
case 'c':
corearg = optarg;
break;
case 'p':
/* "corearg" is shared by "--core" and "--pid" */
corearg = optarg;
break;
case 'x':
cmdarg[ncmd++] = optarg;
if (ncmd >= cmdsize)
{
cmdsize *= 2;
cmdarg = (char **) xrealloc ((char *) cmdarg,
cmdsize * sizeof (*cmdarg));
}
break;
#ifdef GDBTK
case 'z':
{
extern int gdbtk_test (char *);
if (!gdbtk_test (optarg))
{
fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
argv[0], optarg);
exit (1);
}
break;
}
case 'y':
/* Backwards compatibility only. */
break;
case 'w':
{
external_editor_command = xstrdup (optarg);
break;
}
#endif /* GDBTK */
case 'i':
xfree (interpreter_p);
interpreter_p = xstrdup (optarg);
break;
case 'd':
dirarg[ndir++] = optarg;
if (ndir >= dirsize)
{
dirsize *= 2;
dirarg = (char **) xrealloc ((char *) dirarg,
dirsize * sizeof (*dirarg));
}
break;
case 't':
ttyarg = optarg;
break;
case 'q':
quiet = 1;
break;
case 'b':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set baud rate to `%s'.\n"), optarg);
else
baud_rate = i;
}
break;
case 'l':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set timeout limit to `%s'.\n"), optarg);
else
remote_timeout = i;
}
break;
case '?':
fprintf_unfiltered (gdb_stderr,
_("Use `%s --help' for a complete list of options.\n"),
argv[0]);
exit (1);
}
}
/* If --help or --version, disable window interface. */
if (print_help || print_version)
{
use_windows = 0;
}
if (set_args)
{
/* The remaining options are the command-line options for the
inferior. The first one is the sym/exec file, and the rest
are arguments. */
if (optind >= argc)
{
fprintf_unfiltered (gdb_stderr,
_("%s: `--args' specified but no program specified\n"),
argv[0]);
exit (1);
}
symarg = argv[optind];
execarg = argv[optind];
++optind;
set_inferior_args_vector (argc - optind, &argv[optind]);
}
else
{
/* OK, that's all the options. The other arguments are filenames. */
count = 0;
for (; optind < argc; optind++)
switch (++count)
{
case 1:
symarg = argv[optind];
execarg = argv[optind];
break;
case 2:
/* The documentation says this can be a "ProcID" as well.
We will try it as both a corefile and a pid. */
corearg = argv[optind];
break;
case 3:
fprintf_unfiltered (gdb_stderr,
_("Excess command line arguments ignored. (%s%s)\n"),
argv[optind], (optind == argc - 1) ? "" : " ...");
break;
}
}
if (batch)
quiet = 1;
}
/* Initialize all files. Give the interpreter a chance to take
control of the console via the deprecated_init_ui_hook (). */
gdb_init (argv[0]);
/* Do these (and anything which might call wrap_here or *_filtered)
after initialize_all_files() but before the interpreter has been
installed. Otherwize the help/version messages will be eaten by
the interpreter's output handler. */
if (print_version)
{
print_gdb_version (gdb_stdout);
wrap_here ("");
printf_filtered ("\n");
exit (0);
}
if (print_help)
{
print_gdb_help (gdb_stdout);
fputs_unfiltered ("\n", gdb_stdout);
exit (0);
}
/* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message before the interpreter is installed. That way
it isn't encapsulated in MI output. */
if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
{
/* APPLE LOCAL begin don't print dots */
/* Print all the junk at the top. */
print_gdb_version (gdb_stdout);
printf_filtered ("\n");
/* APPLE LOCAL end don't print dots */
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
/* APPLE LOCAL begin */
if (state_change_hook)
{
state_change_hook (STATE_ACTIVE);
}
/* APPLE LOCAL end */
/* Install the default UI. All the interpreters should have had a
look at things by now. Initialize the default interpreter. */
{
/* Find it. */
struct interp *interp = interp_lookup (interpreter_p);
if (interp == NULL)
error (_("Interpreter `%s' unrecognized"), interpreter_p);
/* Install it. */
/* APPLE LOCAL clarity */
if (interp_set (interp) == NULL)
{
fprintf_unfiltered (gdb_stderr,
"Interpreter `%s' failed to initialize.\n",
interpreter_p);
exit (1);
}
}
/* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message after the interpreter is installed when it is
any sane interpreter. */
if (!quiet && !current_interp_named_p (INTERP_MI1))
{
/* Print all the junk at the top, with trailing "..." if we are about
to read a symbol file (possibly slowly). */
print_gdb_version (gdb_stdout);
if (symarg)
printf_filtered ("..");
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
error_pre_print = "\n\n";
quit_pre_print = error_pre_print;
/* We may get more than one warning, don't double space all of them... */
warning_pre_print = _("\nwarning: ");
/* APPLE LOCAL begin move inits up */
/* Make sure that they are zero in case one of them fails (this
guarantees that they won't match if either exists). */
memset (&homebuf, 0, sizeof (struct stat));
memset (&cwdbuf, 0, sizeof (struct stat));
/* APPLE LOCAL end move inits up */
/* APPLE LOCAL begin global gdbinit */
memset (&globalbuf, 0, sizeof (struct stat));
stat (gdbinit_global, &globalbuf);
if (!inhibit_gdbinit)
{
/* if (!SET_TOP_LEVEL ()) */
source_file (gdbinit_global, 0);
}
do_cleanups (ALL_CLEANUPS);
/* APPLE LOCAL end global gdbinit */
/* APPLE LOCAL: Set the $_Xcode convenience variable at '0' before sourcing
any .gdbinit files. Xcode will override this to 1 when it is launching
gdb but we need to start with a value of 0 so .gdbinit files can use it
in conditional expressions. */
set_internalvar (lookup_internalvar ("_Xcode"),
value_from_longest (builtin_type_int, (LONGEST) 0));
/* Read and execute $HOME/.gdbinit file, if it exists. This is done
*before* all the command line arguments are processed; it sets
global parameters, which are independent of what file you are
debugging or what directory you are in. */
homedir = getenv ("HOME");
if (homedir)
{
char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
/* APPLE LOCAL move inits up */
stat (homeinit, &homebuf);
/* APPLE LOCAL gdbinit */
if (!inhibit_gdbinit)
if ((globalbuf.st_dev != homebuf.st_dev) || (globalbuf.st_ino != homebuf.st_ino))
{
catch_command_errors (source_file, homeinit, 0, RETURN_MASK_ALL);
}
}
/* Now perform all the actions indicated by the arguments. */
if (cdarg != NULL)
{
catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
}
for (i = 0; i < ndir; i++)
catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
xfree (dirarg);
/* APPLE LOCAL: If an architecture has been supplied, process it.
FIXME: Note, this is a TOTAL hack. There should be some gdbarch'y type
function that processes these options. The odd thing is that you would
want the SAME function for all the gdbarch'es that are registered, so
it actually lives a little above the gdbarch....
Not sure how to do that. So instead, I just hack... */
#if defined (USE_POSIX_SPAWN) || defined (USE_ARCH_FOR_EXEC)
if (initial_arch != NULL)
{
char *arch_string = NULL;
char *osabi_string;
#if defined (TARGET_POWERPC)
if (strcmp (initial_arch, "ppc") == 0)
{
arch_string = "powerpc:common";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "ppc64") == 0)
{
arch_string = "powerpc:common64";
osabi_string = "Darwin64";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"ppc\" or \"ppc64\"\n", initial_arch);
#elif defined (TARGET_I386)
if (strcmp (initial_arch, "i386") == 0)
{
arch_string = "i386";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "x86_64") == 0)
{
arch_string = "i386:x86-64";
osabi_string = "Darwin64";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"i386\" or \"x86_64\"\n", initial_arch);
#elif defined (TARGET_ARM)
if (strcmp (initial_arch, "arm") == 0)
{
arch_string = "arm";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "armv6") == 0)
{
arch_string = "armv6";
osabi_string = "DarwinV6";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"armv\" or \"armv6\"\n", initial_arch);
#endif
if (arch_string != NULL)
{
set_architecture_from_string (arch_string);
set_osabi_from_string (osabi_string);
}
}
#else
warning ("--arch option not supported in this gdb.");
#endif
/* APPLE LOCAL BEGIN: Set the osabi via option. */
if (osabiarg != NULL)
set_osabi_option (osabiarg);
/* APPLE LOCAL END */
if (execarg != NULL
&& symarg != NULL
&& strcmp (execarg, symarg) == 0)
{
/* The exec file and the symbol-file are the same. If we can't
open it, better only print one error message.
catch_command_errors returns non-zero on success! */
if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
else
{
if (execarg != NULL)
catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
if (symarg != NULL)
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
/* APPLE LOCAL begin */
if (state_change_hook && symarg != NULL)
{
state_change_hook (STATE_INFERIOR_LOADED);
}
/* APPLE LOCAL end */
/* APPLE LOCAL begin */
if (attach_waitfor != NULL)
{
printf_filtered ("\n");
catch_command_errors (attach_command, attach_waitfor, 0, RETURN_MASK_ALL);
}
/* After the symbol file has been read, print a newline to get us
beyond the copyright line... But errors should still set off
the error message with a (single) blank line. */
if (!quiet)
printf_filtered ("\n");
error_pre_print = "\n";
quit_pre_print = error_pre_print;
warning_pre_print = _("\nwarning: ");
if (corearg != NULL)
{
if (catch_command_errors (core_file_attach, corearg, !batch, RETURN_MASK_ALL) == 0)
{
/* See if the core file is really a PID. */
/* Be careful, we have quoted the corearg above... */
if (corearg[0] == '"')
{
int len = strlen (corearg);
if (corearg[len - 1] == '"')
{
corearg[len - 1] = '\0';
corearg += 1;
}
}
if (isdigit (corearg[0]))
catch_command_errors (attach_command, corearg, !batch, RETURN_MASK_ALL);
}
}
if (ttyarg != NULL)
catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
/* Error messages should no longer be distinguished with extra output. */
error_pre_print = NULL;
quit_pre_print = NULL;
warning_pre_print = _("warning: ");
/* Read the .gdbinit file in the current directory, *if* it isn't
the same as the $HOME/.gdbinit file (it should exist, also). */
stat (gdbinit, &cwdbuf);
if (!inhibit_gdbinit)
if (((globalbuf.st_dev != cwdbuf.st_dev) || (globalbuf.st_ino != cwdbuf.st_ino))
&& ((homebuf.st_dev != cwdbuf.st_dev) || (homebuf.st_ino != cwdbuf.st_ino)))
{
/* APPLE LOCAL: fix for CVE-2005-1705 */
if (cwdbuf.st_uid == getuid ())
catch_command_errors (source_file, gdbinit, 0, RETURN_MASK_ALL);
}
/* These need to be set this late in the initialization to ensure that
they are defined for the current environment. They define the
radix variables needed by a save-breakpoints file to preserve the
radix across the breakpoints restoration assuming they are restored
using the -x (-command) command line options. */
set_internalvar (lookup_internalvar ("input_radix"),
value_from_longest (builtin_type_int, (LONGEST) input_radix));
set_internalvar (lookup_internalvar ("output_radix"),
value_from_longest (builtin_type_int, (LONGEST) output_radix));
for (i = 0; i < ncmd; i++)
{
#if 0
/* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
expanded into a call to setjmp(). */
if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
{
/* NOTE: I am commenting this out, because it is not clear
where this feature is used. It is very old and
undocumented. ezannoni: 1999-05-04 */
#if 0
if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
read_command_file (stdin);
else
#endif
source_file (cmdarg[i], !batch);
do_cleanups (ALL_CLEANUPS);
}
#endif
catch_command_errors (source_file, cmdarg[i], !batch, RETURN_MASK_ALL);
}
xfree (cmdarg);
/* Read in the old history after all the command files have been read. */
init_history ();
if (batch)
{
if (attach_flag)
/* Either there was a problem executing the command in the
batch file aborted early, or the batch file forgot to do an
explicit detach. Explicitly detach the inferior ensuring
that there are no zombies. */
target_detach (NULL, 0);
/* We have hit the end of the batch file. */
exit (0);
}
/* Do any host- or target-specific hacks. This is used for i960 targets
to force the user to set a nindy target and spec its parameters. */
#ifdef BEFORE_MAIN_LOOP_HOOK
BEFORE_MAIN_LOOP_HOOK;
#endif
/* Show time and/or space usage. */
if (display_time)
{
long init_time = get_run_time () - time_at_startup;
printf_unfiltered (_("Startup time: %ld.%06ld\n"),
init_time / 1000000, init_time % 1000000);
}
if (display_space)
{
#ifdef HAVE_SBRK
extern char **environ;
char *lim = (char *) sbrk (0);
printf_unfiltered (_("Startup size: data size %ld\n"),
(long) (lim - (char *) &environ));
#endif
}
#if 0
/* FIXME: cagney/1999-11-06: The original main loop was like: */
while (1)
{
if (!SET_TOP_LEVEL ())
{
do_cleanups (ALL_CLEANUPS); /* Do complete cleanup */
/* GUIs generally have their own command loop, mainloop, or
whatever. This is a good place to gain control because
many error conditions will end up here via longjmp(). */
if (deprecated_command_loop_hook)
deprecated_command_loop_hook ();
else
deprecated_command_loop ();
quit_command ((char *) 0, instream == stdin);
}
}
/* NOTE: If the command_loop() returned normally, the loop would
attempt to exit by calling the function quit_command(). That
function would either call exit() or throw an error returning
control to SET_TOP_LEVEL. */
/* NOTE: The function do_cleanups() was called once each time round
the loop. The usefulness of the call isn't clear. If an error
was thrown, everything would have already been cleaned up. If
command_loop() returned normally and quit_command() was called,
either exit() or error() (again cleaning up) would be called. */
#endif
/* NOTE: cagney/1999-11-07: There is probably no reason for not
moving this loop and the code found in captured_command_loop()
into the command_loop() proper. The main thing holding back that
change - SET_TOP_LEVEL() - has been eliminated. */
while (1)
{
catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
}
/* No exit -- exit is through quit_command. */
}
/* Return a virtual function as a value.
ARG1 is the object which provides the virtual function
table pointer. *ARG1P is side-effected in calling this function.
F is the list of member functions which contains the desired virtual
function.
J is an index into F which provides the desired virtual function.
TYPE is the type in which F is located. */
static struct value *
gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
struct type * type, int offset)
{
struct value *arg1 = *arg1p;
struct type *type1 = check_typedef (value_type (arg1));
struct type *entry_type;
/* First, get the virtual function table pointer. That comes
with a strange type, so cast it to type `pointer to long' (which
should serve just fine as a function type). Then, index into
the table, and convert final value to appropriate function type. */
struct value *entry;
struct value *vfn;
struct value *vtbl;
struct value *vi = value_from_longest (builtin_type_int,
(LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
struct type *context;
if (fcontext == NULL)
/* We don't have an fcontext (e.g. the program was compiled with
g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
This won't work right for multiple inheritance, but at least we
should do as well as GDB 3.x did. */
fcontext = TYPE_VPTR_BASETYPE (type);
context = lookup_pointer_type (fcontext);
/* Now context is a pointer to the basetype containing the vtbl. */
if (TYPE_TARGET_TYPE (context) != type1)
{
struct value *tmp = value_cast (context, value_addr (arg1));
arg1 = value_ind (tmp);
type1 = check_typedef (value_type (arg1));
}
context = type1;
/* Now context is the basetype containing the vtbl. */
/* This type may have been defined before its virtual function table
was. If so, fill in the virtual function table entry for the
type now. */
if (TYPE_VPTR_FIELDNO (context) < 0)
fill_in_vptr_fieldno (context);
/* The virtual function table is now an array of structures
which have the form { int16 offset, delta; void *pfn; }. */
vtbl = value_primitive_field (arg1, 0, TYPE_VPTR_FIELDNO (context),
TYPE_VPTR_BASETYPE (context));
/* With older versions of g++, the vtbl field pointed to an array
of structures. Nowadays it points directly to the structure. */
if (TYPE_CODE (value_type (vtbl)) == TYPE_CODE_PTR
&& TYPE_CODE (TYPE_TARGET_TYPE (value_type (vtbl))) == TYPE_CODE_ARRAY)
{
/* Handle the case where the vtbl field points to an
array of structures. */
vtbl = value_ind (vtbl);
/* Index into the virtual function table. This is hard-coded because
looking up a field is not cheap, and it may be important to save
time, e.g. if the user has set a conditional breakpoint calling
a virtual function. */
entry = value_subscript (vtbl, vi);
}
else
{
/* Handle the case where the vtbl field points directly to a structure. */
vtbl = value_add (vtbl, vi);
entry = value_ind (vtbl);
}
entry_type = check_typedef (value_type (entry));
if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
{
/* Move the `this' pointer according to the virtual function table. */
set_value_offset (arg1, value_offset (arg1) + value_as_long (value_field (entry, 0)));
if (!value_lazy (arg1))
{
set_value_lazy (arg1, 1);
value_fetch_lazy (arg1);
}
vfn = value_field (entry, 2);
}
else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
vfn = entry;
else
error (_("I'm confused: virtual function table has bad type"));
/* Reinstantiate the function pointer with the correct type. */
deprecated_set_value_type (vfn, lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)));
*arg1p = arg1;
return vfn;
}
static void
execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
unsigned char *op_end)
{
ctx->in_reg = 0;
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
CORE_ADDR result;
ULONGEST uoffset, reg;
LONGEST offset;
int bytes_read;
switch (op)
{
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
result = op - DW_OP_lit0;
break;
case DW_OP_addr:
result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
op_ptr += bytes_read;
break;
case DW_OP_const1u:
result = extract_unsigned_integer (op_ptr, 1);
op_ptr += 1;
break;
case DW_OP_const1s:
result = extract_signed_integer (op_ptr, 1);
op_ptr += 1;
break;
case DW_OP_const2u:
result = extract_unsigned_integer (op_ptr, 2);
op_ptr += 2;
break;
case DW_OP_const2s:
result = extract_signed_integer (op_ptr, 2);
op_ptr += 2;
break;
case DW_OP_const4u:
result = extract_unsigned_integer (op_ptr, 4);
op_ptr += 4;
break;
case DW_OP_const4s:
result = extract_signed_integer (op_ptr, 4);
op_ptr += 4;
break;
case DW_OP_const8u:
result = extract_unsigned_integer (op_ptr, 8);
op_ptr += 8;
break;
case DW_OP_const8s:
result = extract_signed_integer (op_ptr, 8);
op_ptr += 8;
break;
case DW_OP_constu:
op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
result = uoffset;
break;
case DW_OP_consts:
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = offset;
break;
/* The DW_OP_reg operations are required to occur alone in
location expressions. */
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
if (op_ptr != op_end && *op_ptr != DW_OP_piece)
error ("DWARF-2 expression error: DW_OP_reg operations must be "
"used either alone or in conjuction with DW_OP_piece.");
result = op - DW_OP_reg0;
ctx->in_reg = 1;
break;
case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
if (op_ptr != op_end && *op_ptr != DW_OP_piece)
error ("DWARF-2 expression error: DW_OP_reg operations must be "
"used either alone or in conjuction with DW_OP_piece.");
result = reg;
ctx->in_reg = 1;
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
{
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
result += offset;
}
break;
case DW_OP_bregx:
{
op_ptr = read_uleb128 (op_ptr, op_end, ®);
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->read_reg) (ctx->baton, reg);
result += offset;
}
break;
case DW_OP_fbreg:
{
unsigned char *datastart;
size_t datalen;
unsigned int before_stack_len;
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
/* Rather than create a whole new context, we simply
record the stack length before execution, then reset it
afterwards, effectively erasing whatever the recursive
call put there. */
before_stack_len = ctx->stack_len;
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2
specific this_base method. */
(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
dwarf_expr_eval (ctx, datastart, datalen);
result = dwarf_expr_fetch (ctx, 0);
if (ctx->in_reg)
result = (ctx->read_reg) (ctx->baton, result);
result = result + offset;
ctx->stack_len = before_stack_len;
ctx->in_reg = 0;
}
break;
case DW_OP_dup:
result = dwarf_expr_fetch (ctx, 0);
break;
case DW_OP_drop:
dwarf_expr_pop (ctx);
goto no_push;
case DW_OP_pick:
offset = *op_ptr++;
result = dwarf_expr_fetch (ctx, offset);
break;
case DW_OP_over:
result = dwarf_expr_fetch (ctx, 1);
break;
case DW_OP_rot:
{
CORE_ADDR t1, t2, t3;
if (ctx->stack_len < 3)
error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
ctx->stack_len);
t1 = ctx->stack[ctx->stack_len - 1];
t2 = ctx->stack[ctx->stack_len - 2];
t3 = ctx->stack[ctx->stack_len - 3];
ctx->stack[ctx->stack_len - 1] = t2;
ctx->stack[ctx->stack_len - 2] = t3;
ctx->stack[ctx->stack_len - 3] = t1;
goto no_push;
}
case DW_OP_deref:
case DW_OP_deref_size:
case DW_OP_abs:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_plus_uconst:
/* Unary operations. */
result = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
switch (op)
{
case DW_OP_deref:
{
char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
int bytes_read;
(ctx->read_mem) (ctx->baton, buf, result,
TARGET_ADDR_BIT / TARGET_CHAR_BIT);
result = dwarf2_read_address (buf,
buf + (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT),
&bytes_read);
}
break;
case DW_OP_deref_size:
{
char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
int bytes_read;
(ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
result = dwarf2_read_address (buf,
buf + (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT),
&bytes_read);
}
break;
case DW_OP_abs:
if ((signed int) result < 0)
result = -result;
break;
case DW_OP_neg:
result = -result;
break;
case DW_OP_not:
result = ~result;
break;
case DW_OP_plus_uconst:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
result += reg;
break;
}
break;
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_or:
case DW_OP_plus:
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
{
/* Binary operations. Use the value engine to do computations in
the right width. */
CORE_ADDR first, second;
enum exp_opcode binop;
struct value *val1, *val2;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
val1 = value_from_longest (unsigned_address_type (), first);
val2 = value_from_longest (unsigned_address_type (), second);
switch (op)
{
case DW_OP_and:
binop = BINOP_BITWISE_AND;
break;
case DW_OP_div:
binop = BINOP_DIV;
break;
case DW_OP_minus:
binop = BINOP_SUB;
break;
case DW_OP_mod:
binop = BINOP_MOD;
break;
case DW_OP_mul:
binop = BINOP_MUL;
break;
case DW_OP_or:
binop = BINOP_BITWISE_IOR;
break;
case DW_OP_plus:
binop = BINOP_ADD;
break;
case DW_OP_shl:
binop = BINOP_LSH;
break;
case DW_OP_shr:
binop = BINOP_RSH;
break;
case DW_OP_shra:
binop = BINOP_RSH;
val1 = value_from_longest (signed_address_type (), first);
break;
case DW_OP_xor:
binop = BINOP_BITWISE_XOR;
break;
case DW_OP_le:
binop = BINOP_LEQ;
break;
case DW_OP_ge:
binop = BINOP_GEQ;
break;
case DW_OP_eq:
binop = BINOP_EQUAL;
break;
case DW_OP_lt:
binop = BINOP_LESS;
break;
case DW_OP_gt:
binop = BINOP_GTR;
break;
case DW_OP_ne:
binop = BINOP_NOTEQUAL;
break;
default:
internal_error (__FILE__, __LINE__,
"Can't be reached.");
}
result = value_as_long (value_binop (val1, val2, binop));
}
break;
case DW_OP_GNU_push_tls_address:
/* Variable is at a constant offset in the thread-local
storage block into the objfile for the current thread and
the dynamic linker module containing this expression. Here
we return returns the offset from that base. The top of the
stack has the offset from the beginning of the thread
control block at which the variable is located. Nothing
should follow this operator, so the top of stack would be
returned. */
result = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
result = (ctx->get_tls_address) (ctx->baton, result);
break;
case DW_OP_skip:
offset = extract_signed_integer (op_ptr, 2);
op_ptr += 2;
op_ptr += offset;
goto no_push;
case DW_OP_bra:
offset = extract_signed_integer (op_ptr, 2);
op_ptr += 2;
if (dwarf_expr_fetch (ctx, 0) != 0)
op_ptr += offset;
dwarf_expr_pop (ctx);
goto no_push;
case DW_OP_nop:
goto no_push;
case DW_OP_piece:
{
ULONGEST size;
CORE_ADDR addr_or_regnum;
/* Record the piece. */
op_ptr = read_uleb128 (op_ptr, op_end, &size);
addr_or_regnum = dwarf_expr_fetch (ctx, 0);
add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
/* Pop off the address/regnum, and clear the in_reg flag. */
dwarf_expr_pop (ctx);
ctx->in_reg = 0;
}
goto no_push;
default:
error ("Unhandled dwarf expression opcode 0x%x", op);
}
/* Most things push a result value. */
dwarf_expr_push (ctx, result);
no_push:;
}
}
