FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
binutils-gdb/gdb/compile/compile-c-types.c
Pedro Alves 7022349d5c Stop assuming no-debug-info functions return int 
The fact that GDB defaults to assuming that functions return int, when
it has no debug info for the function has been a recurring source of
user confusion.  Recently this came up on the errno pretty printer
discussions.  Shortly after, it came up again on IRC, with someone
wondering why does getenv() in GDB return a negative int:

  (gdb) p getenv("PATH")
  $1 = -6185

This question (with s/getenv/random-other-C-runtime-function) is a FAQ
on IRC.

The reason for the above is:

 (gdb) p getenv
 $2 = {<text variable, no debug info>} 0x7ffff7751d80 <getenv>
 (gdb) ptype getenv
 type = int ()

... which means that GDB truncated the 64-bit pointer that is actually
returned from getent to 32-bit, and then sign-extended it:

 (gdb) p /x -6185
 $6 = 0xffffe7d7

The workaround is to cast the function to the right type, like:

 (gdb) p ((char *(*) (const char *)) getenv) ("PATH")
 $3 = 0x7fffffffe7d7 "/usr/local/bin:/"...

IMO, we should do better than this.

I see the "assume-int" issue the same way I see printing bogus values
for optimized-out variables instead of "<optimized out>" -- I'd much
rather that the debugger tells me "I don't know" and tells me how to
fix it than showing me bogus misleading results, making me go around
tilting at windmills.

If GDB prints a signed integer when you're expecting a pointer or
aggregate, you at least have some sense that something is off, but
consider the case of the function actually returning a 64-bit integer.
For example, compile this without debug info:

 unsigned long long
 function ()
 {
   return 0x7fffffffffffffff;
 }

Currently, with pristine GDB, you get:

 (gdb) p function ()
 $1 = -1                      # incorrect
 (gdb) p /x function ()
 $2 = 0xffffffff              # incorrect

maybe after spending a few hours debugging you suspect something is
wrong with that -1, and do:

 (gdb) ptype function
 type = int ()

and maybe, just maybe, you realize that the function actually returns
unsigned long long.  And you try to fix it with:

(gdb) p /x (unsigned long long) function ()
 $3 = 0xffffffffffffffff      # incorrect

... which still produces the wrong result, because GDB simply applied
int to unsigned long long conversion.  Meaning, it sign-extended the
integer that it extracted from the return of the function, to 64-bits.

and then maybe, after asking around on IRC, you realize you have to
cast the function to a pointer of the right type, and call that.  It
won't be easy, but after a few missteps, you'll get to it:

.....  (gdb) p /x ((unsigned long long(*) ()) function) ()
 $666 = 0x7fffffffffffffff             # finally! :-)


So to improve on the user experience, this patch does the following
(interrelated) things:

 - makes no-debug-info functions no longer default to "int" as return
   type.  Instead, they're left with NULL/"<unknown return type>"
   return type.

    (gdb) ptype getenv
    type = <unknown return type> ()

 - makes calling a function with unknown return type an error.

    (gdb) p getenv ("PATH")
    'getenv' has unknown return type; cast the call to its declared return type

 - and then to make it easier to call the function, makes it possible
   to _only_ cast the return of the function to the right type,
   instead of having to cast the function to a function pointer:

    (gdb) p (char *) getenv ("PATH")                      # now Just Works
    $3 = 0x7fffffffe7d7 "/usr/local/bin:/"...

    (gdb) p ((char *(*) (const char *)) getenv) ("PATH")  # continues working
    $4 = 0x7fffffffe7d7 "/usr/local/bin:/"...

   I.e., it makes GDB default the function's return type to the type
   of the cast, and the function's parameters to the type of the
   arguments passed down.

After this patch, here's what you'll get for the "unsigned long long"
example above:

 (gdb) p function ()
 'function' has unknown return type; cast the call to its declared return type
 (gdb) p /x (unsigned long long) function ()
 $4 = 0x7fffffffffffffff     # correct!

Note that while with "print" GDB shows the name of the function that
has the problem:

  (gdb) p getenv ("PATH")
  'getenv' has unknown return type; cast the call to its declared return type

which can by handy in more complicated expressions, "ptype" does not:

  (gdb) ptype getenv ("PATH")
  function has unknown return type; cast the call to its declared return type

This will be fixed in the next patch.

gdb/ChangeLog:
2017-09-04  Pedro Alves  <palves@redhat.com>

	* ada-lang.c (ada_evaluate_subexp) <TYPE_CODE_FUNC>: Don't handle
	TYPE_GNU_IFUNC specially here.  Throw error if return type is
	unknown.
	* ada-typeprint.c (print_func_type): Handle functions with unknown
	return type.
	* c-typeprint.c (c_type_print_base): Handle functions and methods
	with unknown return type.
	* compile/compile-c-symbols.c (convert_symbol_bmsym)
	<mst_text_gnu_ifunc>: Use nodebug_text_gnu_ifunc_symbol.
	* compile/compile-c-types.c: Include "objfiles.h".
	(convert_func): For functions with unknown return type, warn and
	default to int.
	* compile/compile-object-run.c (compile_object_run): Adjust call
	to call_function_by_hand_dummy.
	* elfread.c (elf_gnu_ifunc_resolve_addr): Adjust call to
	call_function_by_hand.
	* eval.c (evaluate_subexp_standard): Adjust calls to
	call_function_by_hand.  Handle functions and methods with unknown
	return type.  Pass expect_type to call_function_by_hand.
	* f-typeprint.c (f_type_print_base): Handle functions with unknown
	return type.
	* gcore.c (call_target_sbrk): Adjust call to
	call_function_by_hand.
	* gdbtypes.c (objfile_type): Leave nodebug text symbol with NULL
	return type instead of int.  Make nodebug_text_gnu_ifunc_symbol be
	an integer address type instead of nodebug.
	* guile/scm-value.c (gdbscm_value_call): Adjust call to
	call_function_by_hand.
	* infcall.c (error_call_unknown_return_type): New function.
	(call_function_by_hand): New "default_return_type" parameter.
	Pass it down.
	(call_function_by_hand_dummy): New "default_return_type"
	parameter.  Use it instead of defaulting to int.  If there's no
	default and the return type is unknown, throw an error.  If
	there's a default return type, and the called function has no
	debug info, then assume the function is prototyped.
	* infcall.h (call_function_by_hand, call_function_by_hand_dummy):
	New "default_return_type" parameter.
	(error_call_unknown_return_type): New declaration.
	* linux-fork.c (call_lseek): Cast return type of lseek.
	(inferior_call_waitpid, checkpoint_command): Adjust calls to
	call_function_by_hand.
	* linux-tdep.c (linux_infcall_mmap, linux_infcall_munmap): Adjust
	calls to call_function_by_hand.
	* m2-typeprint.c (m2_procedure): Handle functions with unknown
	return type.
	* objc-lang.c (lookup_objc_class, lookup_child_selector)
	(value_nsstring, print_object_command): Adjust calls to
	call_function_by_hand.
	* p-typeprint.c (pascal_type_print_varspec_prefix): Handle
	functions with unknown return type.
	(pascal_type_print_func_varspec_suffix): New function.
	(pascal_type_print_varspec_suffix) <TYPE_CODE_FUNC,
	TYPE_CODE_METHOD>: Use it.
	* python/py-value.c (valpy_call): Adjust call to
	call_function_by_hand.
	* rust-lang.c (rust_evaluate_funcall): Adjust call to
	call_function_by_hand.
	* valarith.c (value_x_binop, value_x_unop): Adjust calls to
	call_function_by_hand.
	* valops.c (value_allocate_space_in_inferior): Adjust call to
	call_function_by_hand.
	* typeprint.c (type_print_unknown_return_type): New function.
	* typeprint.h (type_print_unknown_return_type): New declaration.

gdb/testsuite/ChangeLog:
2017-09-04  Pedro Alves  <palves@redhat.com>

	* gdb.base/break-main-file-remove-fail.exp (test_remove_bp): Cast
	return type of munmap in infcall.
	* gdb.base/break-probes.exp: Cast return type of foo in infcall.
	* gdb.base/checkpoint.exp: Simplify using for loop.  Cast return
	type of ftell in infcall.
	* gdb.base/dprintf-detach.exp (dprintf_detach_test): Cast return
	type of getpid in infcall.
	* gdb.base/infcall-exec.exp: Cast return type of execlp in
	infcall.
	* gdb.base/info-os.exp: Cast return type of getpid in infcall.
	Bail on failure to extract the pid.
	* gdb.base/nodebug.c: #include <stdint.h>.
	(multf, multf_noproto, mult, mult_noproto, add8, add8_noproto):
	New functions.
	* gdb.base/nodebug.exp (test_call_promotion): New procedure.
	Change expected output of print/whatis/ptype with functions with
	no debug info.  Test all supported languages.  Call
	test_call_promotion.
	* gdb.compile/compile.exp: Adjust expected output to expect
	warning.
	* gdb.threads/siginfo-threads.exp: Likewise.
2017-09-04 20:21:13 +01:00

454 lines
13 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Convert types from GDB to GCC
Copyright (C) 2014-2017 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbtypes.h"
#include "compile-internal.h"
#include "objfiles.h"
/* An object that maps a gdb type to a gcc type. */
struct type_map_instance
{
/* The gdb type. */
struct type *type;
/* The corresponding gcc type handle. */
gcc_type gcc_type_handle;
};
/* Hash a type_map_instance. */
static hashval_t
hash_type_map_instance (const void *p)
{
const struct type_map_instance *inst = (const struct type_map_instance *) p;
return htab_hash_pointer (inst->type);
}
/* Check two type_map_instance objects for equality. */
static int
eq_type_map_instance (const void *a, const void *b)
{
const struct type_map_instance *insta = (const struct type_map_instance *) a;
const struct type_map_instance *instb = (const struct type_map_instance *) b;
return insta->type == instb->type;
}
/* Insert an entry into the type map associated with CONTEXT that maps
from the gdb type TYPE to the gcc type GCC_TYPE. It is ok for a
given type to be inserted more than once, provided that the exact
same association is made each time. This simplifies how type
caching works elsewhere in this file -- see how struct type caching
is handled. */
static void
insert_type (struct compile_c_instance *context, struct type *type,
gcc_type gcc_type)
{
struct type_map_instance inst, *add;
void **slot;
inst.type = type;
inst.gcc_type_handle = gcc_type;
slot = htab_find_slot (context->type_map, &inst, INSERT);
add = (struct type_map_instance *) *slot;
/* The type might have already been inserted in order to handle
recursive types. */
if (add != NULL && add->gcc_type_handle != gcc_type)
error (_("Unexpected type id from GCC, check you use recent enough GCC."));
if (add == NULL)
{
add = XNEW (struct type_map_instance);
*add = inst;
*slot = add;
}
}
/* Convert a pointer type to its gcc representation. */
static gcc_type
convert_pointer (struct compile_c_instance *context, struct type *type)
{
gcc_type target = convert_type (context, TYPE_TARGET_TYPE (type));
return C_CTX (context)->c_ops->build_pointer_type (C_CTX (context),
target);
}
/* Convert an array type to its gcc representation. */
static gcc_type
convert_array (struct compile_c_instance *context, struct type *type)
{
gcc_type element_type;
struct type *range = TYPE_INDEX_TYPE (type);
element_type = convert_type (context, TYPE_TARGET_TYPE (type));
if (TYPE_LOW_BOUND_KIND (range) != PROP_CONST)
return C_CTX (context)->c_ops->error (C_CTX (context),
_("array type with non-constant"
" lower bound is not supported"));
if (TYPE_LOW_BOUND (range) != 0)
return C_CTX (context)->c_ops->error (C_CTX (context),
_("cannot convert array type with "
"non-zero lower bound to C"));
if (TYPE_HIGH_BOUND_KIND (range) == PROP_LOCEXPR
|| TYPE_HIGH_BOUND_KIND (range) == PROP_LOCLIST)
{
gcc_type result;
if (TYPE_VECTOR (type))
return C_CTX (context)->c_ops->error (C_CTX (context),
_("variably-sized vector type"
" is not supported"));
std::string upper_bound
= c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high);
result = C_CTX (context)->c_ops->build_vla_array_type (C_CTX (context),
element_type,
upper_bound.c_str ());
return result;
}
else
{
LONGEST low_bound, high_bound, count;
if (get_array_bounds (type, &low_bound, &high_bound) == 0)
count = -1;
else
{
gdb_assert (low_bound == 0); /* Ensured above. */
count = high_bound + 1;
}
if (TYPE_VECTOR (type))
return C_CTX (context)->c_ops->build_vector_type (C_CTX (context),
element_type,
count);
return C_CTX (context)->c_ops->build_array_type (C_CTX (context),
element_type, count);
}
}
/* Convert a struct or union type to its gcc representation. */
static gcc_type
convert_struct_or_union (struct compile_c_instance *context, struct type *type)
{
int i;
gcc_type result;
/* First we create the resulting type and enter it into our hash
table. This lets recursive types work. */
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
result = C_CTX (context)->c_ops->build_record_type (C_CTX (context));
else
{
gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
result = C_CTX (context)->c_ops->build_union_type (C_CTX (context));
}
insert_type (context, type, result);
for (i = 0; i < TYPE_NFIELDS (type); ++i)
{
gcc_type field_type;
unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
field_type = convert_type (context, TYPE_FIELD_TYPE (type, i));
if (bitsize == 0)
bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type, i));
C_CTX (context)->c_ops->build_add_field (C_CTX (context), result,
TYPE_FIELD_NAME (type, i),
field_type,
bitsize,
TYPE_FIELD_BITPOS (type, i));
}
C_CTX (context)->c_ops->finish_record_or_union (C_CTX (context), result,
TYPE_LENGTH (type));
return result;
}
/* Convert an enum type to its gcc representation. */
static gcc_type
convert_enum (struct compile_c_instance *context, struct type *type)
{
gcc_type int_type, result;
int i;
struct gcc_c_context *ctx = C_CTX (context);
int_type = ctx->c_ops->int_type (ctx,
TYPE_UNSIGNED (type),
TYPE_LENGTH (type));
result = ctx->c_ops->build_enum_type (ctx, int_type);
for (i = 0; i < TYPE_NFIELDS (type); ++i)
{
ctx->c_ops->build_add_enum_constant (ctx,
result,
TYPE_FIELD_NAME (type, i),
TYPE_FIELD_ENUMVAL (type, i));
}
ctx->c_ops->finish_enum_type (ctx, result);
return result;
}
/* Convert a function type to its gcc representation. */
static gcc_type
convert_func (struct compile_c_instance *context, struct type *type)
{
int i;
gcc_type result, return_type;
struct gcc_type_array array;
int is_varargs = TYPE_VARARGS (type) || !TYPE_PROTOTYPED (type);
struct type *target_type = TYPE_TARGET_TYPE (type);
/* Functions with no debug info have no return type. Ideally we'd
want to fallback to the type of the cast just before the
function, like GDB's built-in expression parser, but we don't
have access to that type here. For now, fallback to int, like
GDB's parser used to do. */
if (target_type == NULL)
{
if (TYPE_OBJFILE_OWNED (type))
target_type = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
else
target_type = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
warning (_("function has unknown return type; assuming int"));
}
/* This approach means we can't make self-referential function
types. Those are impossible in C, though. */
return_type = convert_type (context, target_type);
array.n_elements = TYPE_NFIELDS (type);
array.elements = XNEWVEC (gcc_type, TYPE_NFIELDS (type));
for (i = 0; i < TYPE_NFIELDS (type); ++i)
array.elements[i] = convert_type (context, TYPE_FIELD_TYPE (type, i));
result = C_CTX (context)->c_ops->build_function_type (C_CTX (context),
return_type,
&array, is_varargs);
xfree (array.elements);
return result;
}
/* Convert an integer type to its gcc representation. */
static gcc_type
convert_int (struct compile_c_instance *context, struct type *type)
{
return C_CTX (context)->c_ops->int_type (C_CTX (context),
TYPE_UNSIGNED (type),
TYPE_LENGTH (type));
}
/* Convert a floating-point type to its gcc representation. */
static gcc_type
convert_float (struct compile_c_instance *context, struct type *type)
{
return C_CTX (context)->c_ops->float_type (C_CTX (context),
TYPE_LENGTH (type));
}
/* Convert the 'void' type to its gcc representation. */
static gcc_type
convert_void (struct compile_c_instance *context, struct type *type)
{
return C_CTX (context)->c_ops->void_type (C_CTX (context));
}
/* Convert a boolean type to its gcc representation. */
static gcc_type
convert_bool (struct compile_c_instance *context, struct type *type)
{
return C_CTX (context)->c_ops->bool_type (C_CTX (context));
}
/* Convert a qualified type to its gcc representation. */
static gcc_type
convert_qualified (struct compile_c_instance *context, struct type *type)
{
struct type *unqual = make_unqualified_type (type);
gcc_type unqual_converted;
gcc_qualifiers_flags quals = 0;
unqual_converted = convert_type (context, unqual);
if (TYPE_CONST (type))
quals |= GCC_QUALIFIER_CONST;
if (TYPE_VOLATILE (type))
quals |= GCC_QUALIFIER_VOLATILE;
if (TYPE_RESTRICT (type))
quals |= GCC_QUALIFIER_RESTRICT;
return C_CTX (context)->c_ops->build_qualified_type (C_CTX (context),
unqual_converted,
quals);
}
/* Convert a complex type to its gcc representation. */
static gcc_type
convert_complex (struct compile_c_instance *context, struct type *type)
{
gcc_type base = convert_type (context, TYPE_TARGET_TYPE (type));
return C_CTX (context)->c_ops->build_complex_type (C_CTX (context), base);
}
/* A helper function which knows how to convert most types from their
gdb representation to the corresponding gcc form. This examines
the TYPE and dispatches to the appropriate conversion function. It
returns the gcc type. */
static gcc_type
convert_type_basic (struct compile_c_instance *context, struct type *type)
{
/* If we are converting a qualified type, first convert the
unqualified type and then apply the qualifiers. */
if ((TYPE_INSTANCE_FLAGS (type) & (TYPE_INSTANCE_FLAG_CONST
| TYPE_INSTANCE_FLAG_VOLATILE
| TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
return convert_qualified (context, type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_PTR:
return convert_pointer (context, type);
case TYPE_CODE_ARRAY:
return convert_array (context, type);
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
return convert_struct_or_union (context, type);
case TYPE_CODE_ENUM:
return convert_enum (context, type);
case TYPE_CODE_FUNC:
return convert_func (context, type);
case TYPE_CODE_INT:
return convert_int (context, type);
case TYPE_CODE_FLT:
return convert_float (context, type);
case TYPE_CODE_VOID:
return convert_void (context, type);
case TYPE_CODE_BOOL:
return convert_bool (context, type);
case TYPE_CODE_COMPLEX:
return convert_complex (context, type);
}
return C_CTX (context)->c_ops->error (C_CTX (context),
_("cannot convert gdb type "
"to gcc type"));
}
/* See compile-internal.h. */
gcc_type
convert_type (struct compile_c_instance *context, struct type *type)
{
struct type_map_instance inst, *found;
gcc_type result;
/* We don't ever have to deal with typedefs in this code, because
those are only needed as symbols by the C compiler. */
type = check_typedef (type);
inst.type = type;
found = (struct type_map_instance *) htab_find (context->type_map, &inst);
if (found != NULL)
return found->gcc_type_handle;
result = convert_type_basic (context, type);
insert_type (context, type, result);
return result;
}
/* Delete the compiler instance C. */
static void
delete_instance (struct compile_instance *c)
{
struct compile_c_instance *context = (struct compile_c_instance *) c;
context->base.fe->ops->destroy (context->base.fe);
htab_delete (context->type_map);
if (context->symbol_err_map != NULL)
htab_delete (context->symbol_err_map);
xfree (context);
}
/* See compile-internal.h. */
struct compile_instance *
new_compile_instance (struct gcc_c_context *fe)
{
struct compile_c_instance *result = XCNEW (struct compile_c_instance);
result->base.fe = &fe->base;
result->base.destroy = delete_instance;
result->base.gcc_target_options = ("-std=gnu11"
/* Otherwise the .o file may need
"_Unwind_Resume" and
"__gcc_personality_v0". */
" -fno-exceptions");
result->type_map = htab_create_alloc (10, hash_type_map_instance,
eq_type_map_instance,
xfree, xcalloc, xfree);
fe->c_ops->set_callbacks (fe, gcc_convert_symbol,
gcc_symbol_address, result);
return &result->base;
}
Reference in a new issue View git blame Copy permalink