aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gdb/ChangeLog16
-rw-r--r--gdb/buildsym.c42
-rw-r--r--gdb/c-typeprint.c14
-rw-r--r--gdb/ch-typeprint.c21
-rw-r--r--gdb/dwarfread.c1
-rw-r--r--gdb/gdbtypes.c18
-rw-r--r--gdb/gdbtypes.h9
7 files changed, 92 insertions, 29 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 9ac6b29..42ea03e 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,19 @@
+Sun Feb 12 10:02:16 1995 Per Bothner <bothner@cygnus.com>
+
+ * buildsym.c (finish_block): If finishing a function without known
+ parameter type info, set that from parameter symbols.
+ * c-typeprint.c (c_type_print_varspec_suffix): For TYPE_CODE_FUNC,
+ print parameter types, if available.
+ * ch-typeprint.c (chill_type_print_base): Likewise.
+
+ * gdbtypes.h (struct type): Remove function type field.
+ (TYPE_FUNCTION_TYPE): Remove macro. We can't as simply re-use
+ function types now that we're also storing parameter types.
+ And the payoff is much less.
+ * gdbtypes.c (make_function_type): Don't use/set TYPE_FUNCTION_TYPE.
+ (recursive_dump_type): Don't print TYPE_FUNCTION_TYPE.
+ * dwarfread.c (read_subroutine_type): Don't set TYPE_FUNCTION_TYPE.
+
Sun Feb 12 09:03:47 1995 Jim Kingdon (kingdon@lioth.cygnus.com)
* buildsym.c (start_subfile): Set language for f2c like for cfront.
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index fc03378..45ee77a 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -31,6 +31,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "symtab.h"
#include "symfile.h" /* Needed for "struct complaint" */
#include "objfiles.h"
+#include "gdbtypes.h"
#include "complaints.h"
#include <string.h>
@@ -226,8 +227,49 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile)
if (symbol)
{
+ struct type *ftype = SYMBOL_TYPE (symbol);
SYMBOL_BLOCK_VALUE (symbol) = block;
BLOCK_FUNCTION (block) = symbol;
+
+ if (TYPE_NFIELDS (ftype) <= 0)
+ {
+ /* No parameter type information is recorded with the function's
+ type. Set that from the type of the parameter symbols. */
+ int nparams = 0, iparams;
+ struct symbol *sym;
+ for (i = 0; i < BLOCK_NSYMS (block); i++)
+ {
+ sym = BLOCK_SYM (block, i);
+ switch (SYMBOL_CLASS (sym))
+ {
+ case LOC_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
+ nparams++;
+ }
+ }
+ if (nparams > 0)
+ {
+ TYPE_NFIELDS (ftype) = nparams;
+ TYPE_FIELDS (ftype) = (struct field *)
+ TYPE_ALLOC (ftype, nparams * sizeof (struct field));
+
+ for (i = iparams = 0; iparams < nparams; i++)
+ {
+ sym = BLOCK_SYM (block, i);
+ switch (SYMBOL_CLASS (sym))
+ {
+ case LOC_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
+ TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
+ iparams++;
+ }
+ }
+ }
+ }
}
else
{
diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index 306123d..3968737 100644
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -420,7 +420,19 @@ c_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
if (passed_a_ptr)
fprintf_filtered (stream, ")");
if (!demangled_args)
- fprintf_filtered (stream, "()");
+ { int i, len = TYPE_NFIELDS (type);
+ fprintf_filtered (stream, "(");
+ for (i = 0; i < len; i++)
+ {
+ if (i > 0)
+ {
+ fputs_filtered (", ", stream);
+ wrap_here (" ");
+ }
+ c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
+ }
+ fprintf_filtered (stream, ")");
+ }
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
passed_a_ptr, 0);
break;
diff --git a/gdb/ch-typeprint.c b/gdb/ch-typeprint.c
index 8474cce..f06a85c 100644
--- a/gdb/ch-typeprint.c
+++ b/gdb/ch-typeprint.c
@@ -165,7 +165,26 @@ chill_type_print_base (type, stream, show, level)
chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
break;
case TYPE_CODE_FUNC:
- fprintf_filtered (stream, "PROC (?)");
+ fprintf_filtered (stream, "PROC (");
+ len = TYPE_NFIELDS (type);
+ for (i = 0; i < len; i++)
+ {
+ struct type *param_type = TYPE_FIELD_TYPE (type, i);
+ if (i > 0)
+ {
+ fputs_filtered (", ", stream);
+ wrap_here (" ");
+ }
+ if (TYPE_CODE (param_type) == TYPE_CODE_REF)
+ {
+ chill_type_print_base (TYPE_TARGET_TYPE (param_type),
+ stream, show, level);
+ fputs_filtered (" LOC", stream);
+ }
+ else
+ chill_type_print_base (param_type, stream, show, level);
+ }
+ fprintf_filtered (stream, ")");
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
{
fputs_filtered (" RETURNS (", stream);
diff --git a/gdb/dwarfread.c b/gdb/dwarfread.c
index 5afe795..ec6182d 100644
--- a/gdb/dwarfread.c
+++ b/gdb/dwarfread.c
@@ -1600,7 +1600,6 @@ read_subroutine_type (dip, thisdie, enddie)
/* We have an existing partially constructed type, so bash it
into the correct type. */
TYPE_TARGET_TYPE (ftype) = type;
- TYPE_FUNCTION_TYPE (type) = ftype;
TYPE_LENGTH (ftype) = 1;
TYPE_CODE (ftype) = TYPE_CODE_FUNC;
}
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 2ccc845..1a281c8 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -226,17 +226,6 @@ make_function_type (type, typeptr)
register struct type *ntype; /* New type */
struct objfile *objfile;
- ntype = TYPE_FUNCTION_TYPE (type);
-
- if (ntype)
- if (typeptr == 0)
- return ntype; /* Don't care about alloc, and have new type. */
- else if (*typeptr == 0)
- {
- *typeptr = ntype; /* Tracking alloc, and we have new type. */
- return ntype;
- }
-
if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
{
ntype = alloc_type (TYPE_OBJFILE (type));
@@ -252,14 +241,10 @@ make_function_type (type, typeptr)
}
TYPE_TARGET_TYPE (ntype) = type;
- TYPE_FUNCTION_TYPE (type) = ntype;
TYPE_LENGTH (ntype) = 1;
TYPE_CODE (ntype) = TYPE_CODE_FUNC;
- if (!TYPE_FUNCTION_TYPE (type)) /* Remember it, if don't have one. */
- TYPE_FUNCTION_TYPE (type) = ntype;
-
return ntype;
}
@@ -1444,9 +1429,6 @@ recursive_dump_type (type, spaces)
printfi_filtered (spaces, "reference_type ");
gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "function_type ");
- gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
- printf_filtered ("\n");
printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
{
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 27166c1..c6b9551 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -228,13 +228,6 @@ struct type
struct type *reference_type;
- /* Type that is a function returning this type.
- NULL if no such function type is known here.
- The debugger may add the address of such a type
- if it has to construct one later. */
-
- struct type *function_type;
-
/* Flags about this type. */
short flags;
@@ -249,6 +242,7 @@ struct type
For range types, there are two "fields",
the minimum and maximum values (both inclusive).
For enum types, each possible value is described by one "field".
+ For a function type, a "field" for each parameter type.
For C++ classes, there is one field for each base class (if it is
a derived class) plus one field for each class data member. Member
functions are recorded elsewhere.
@@ -484,7 +478,6 @@ allocate_cplus_struct_type PARAMS ((struct type *));
#define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
#define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
-#define TYPE_FUNCTION_TYPE(thistype) (thistype)->function_type
#define TYPE_LENGTH(thistype) (thistype)->length
#define TYPE_OBJFILE(thistype) (thistype)->objfile
#define TYPE_FLAGS(thistype) (thistype)->flags
generated by cgit v1.1 at 2024-12-12 07:45:52 +0000