From 433732f25e8aeb3587a1d4fe612009352cbb880c Mon Sep 17 00:00:00 2001 From: Stu Grossman Date: Wed, 12 Aug 1998 15:50:59 +0000 Subject: [PATCH] * c-typeprint.c (c_print_type): Don't crash if varstring is null. * expprint.c expression.h (dump_expression): Rename to dump_prefix_expression. * Print out the expression in normal form. Call print_longest instead of trying to do it ourselves. * (dump_postfix_expression): New function, prints out the expression with indentation and better formatting and interpretation. * parse.c (parse_exp_1): Put calls to dump expressions under ifdef MAINTENANCE_CMDS and expressiondebug variable. --- gdb/ChangeLog | 17 +++ gdb/c-typeprint.c | 14 ++- gdb/expprint.c | 368 +++++++++++++++++++++++++++++++++++++++++++++++++----- gdb/parse.c | 29 ++++- 4 files changed, 389 insertions(+), 39 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 1471ff5..d7fd377 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,20 @@ +Tue Aug 11 11:33:25 1998 Stu Grossman + + * c-typeprint.c (c_print_type): Don't crash if varstring is null. + * expprint.c expression.h (dump_expression): Rename to + dump_prefix_expression. + * Print out the expression in normal form. Call print_longest + instead of trying to do it ourselves. + * (dump_postfix_expression): New function, prints out the expression + with indentation and better formatting and interpretation. + * parse.c (parse_exp_1): Put calls to dump expressions under ifdef + MAINTENANCE_CMDS and expressiondebug variable. + +Thu Aug 6 13:20:02 1998 Ron Unrau + + * infrun.c (wait_for_inferior): use stop_func_name instead of + stop_func_start to decide that no debug info exists. + start-sanitize-sky Thu Aug 6 13:15:05 1998 Ron Unrau diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c index 3347050..689988d 100644 --- a/gdb/c-typeprint.c +++ b/gdb/c-typeprint.c @@ -135,14 +135,16 @@ c_print_type (type, varstring, stream, show, level) fputs_filtered (" ", stream); c_type_print_varspec_prefix (type, stream, show, 0); - fputs_filtered (varstring, stream); - - /* For demangled function names, we have the arglist as part of the name, - so don't print an additional pair of ()'s */ + if (varstring != NULL) + { + fputs_filtered (varstring, stream); - demangled_args = strchr(varstring, '(') != NULL; - c_type_print_varspec_suffix (type, stream, show, 0, demangled_args); + /* For demangled function names, we have the arglist as part of the name, + so don't print an additional pair of ()'s */ + demangled_args = strchr(varstring, '(') != NULL; + c_type_print_varspec_suffix (type, stream, show, 0, demangled_args); + } } /* If TYPE is a derived type, then print out derivation information. diff --git a/gdb/expprint.c b/gdb/expprint.c index 4effea2..e4746be 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -300,19 +300,6 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (&exp->elts[pc + 2].string, stream); return; -/* start-sanitize-gm */ -#ifdef GENERAL_MAGIC_HACKS - case STRUCTOP_FIELD: - 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; - -#endif /* GENERAL_MAGIC_HACKS */ -/* end-sanitize-gm */ - case BINOP_SUBSCRIPT: print_subexp (exp, pos, stream, PREC_SUFFIX); fputs_filtered ("[", stream); @@ -354,7 +341,8 @@ print_subexp (exp, pos, stream, prec) 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); + (CORE_ADDR) exp->elts[pc + 5].longconst, + NULL); value_print (val, stream, 0, Val_no_prettyprint); } else { fputs_filtered ("{", stream); @@ -505,13 +493,13 @@ op_string(op) return NULL; } -#ifdef DEBUG_EXPRESSIONS +#ifdef MAINTENANCE_CMDS /* Support for dumping the raw data from expressions in a human readable form. */ void -dump_expression (exp, stream, note) +dump_prefix_expression (exp, stream, note) struct expression *exp; GDB_FILE *stream; char *note; @@ -523,8 +511,9 @@ dump_expression (exp, stream, note) fprintf_filtered (stream, "Dump of expression @ "); gdb_print_address (exp, stream); - fprintf_filtered (stream, ", %s:\n", note); - fprintf_filtered (stream, "\tLanguage %s, %d elements, %d bytes each.\n", + fprintf_filtered (stream, ", %s:\nExpression: `", note); + print_expression (exp, stream); + fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n", exp->language_defn->la_name, exp -> nelts, sizeof (union exp_element)); fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode", @@ -572,6 +561,7 @@ dump_expression (exp, stream, note) case BINOP_INCL: opcode_name = "BINOP_INCL"; break; case BINOP_EXCL: opcode_name = "BINOP_EXCL"; break; case BINOP_CONCAT: opcode_name = "BINOP_CONCAT"; break; + case BINOP_RANGE: opcode_name = "BINOP_RANGE"; break; case BINOP_END: opcode_name = "BINOP_END"; break; case TERNOP_COND: opcode_name = "TERNOP_COND"; break; case TERNOP_SLICE: opcode_name = "TERNOP_SLICE"; break; @@ -616,24 +606,14 @@ dump_expression (exp, stream, note) case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break; case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break; case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break; -/* start-sanitize-gm */ -#ifdef GENERAL_MAGIC_HACKS -+ case STRUCTOP_FIELD: opcode_name = "STRUCTOP_FIELD"; break; -#endif /* GENERAL_MAGIC_HACKS */ -/* end-sanitize-gm */ case OP_THIS: opcode_name = "OP_THIS"; break; case OP_SCOPE: opcode_name = "OP_SCOPE"; break; case OP_TYPE: opcode_name = "OP_TYPE"; break; case OP_LABELED: opcode_name = "OP_LABELED"; break; } fprintf_filtered (stream, "%20s ", opcode_name); - fprintf_filtered (stream, -#if defined (PRINTF_HAS_LONG_LONG) - "%ll16x ", -#else - "%l16x ", -#endif - exp -> elts[elt].longconst); + print_longest (stream, 'd', 0, exp -> elts[elt].longconst); + fprintf_filtered (stream, " "); for (eltscan = (char *) &exp->elts[elt], eltsize = sizeof (union exp_element) ; @@ -647,4 +627,330 @@ dump_expression (exp, stream, note) } } -#endif /* DEBUG_EXPRESSIONS */ +static int dump_subexp PARAMS ((struct expression *exp, GDB_FILE *stream, int elt)); + +static int +dump_subexp (exp, stream, elt) + struct expression *exp; + GDB_FILE *stream; + int elt; +{ + char *opcode_name; + static int indent = 0; + int i; + + fprintf_filtered (stream, "\n"); + fprintf_filtered (stream, "\t%5d ", elt); + + for (i = 1; i <= indent; i++) + fprintf_filtered (stream, " "); + indent += 2; + + switch (exp -> elts[elt].opcode) + { + default: opcode_name = ""; break; + case OP_NULL: opcode_name = "OP_NULL"; break; + case BINOP_ADD: opcode_name = "BINOP_ADD"; break; + case BINOP_SUB: opcode_name = "BINOP_SUB"; break; + case BINOP_MUL: opcode_name = "BINOP_MUL"; break; + case BINOP_DIV: opcode_name = "BINOP_DIV"; break; + case BINOP_REM: opcode_name = "BINOP_REM"; break; + case BINOP_MOD: opcode_name = "BINOP_MOD"; break; + case BINOP_LSH: opcode_name = "BINOP_LSH"; break; + case BINOP_RSH: opcode_name = "BINOP_RSH"; break; + case BINOP_LOGICAL_AND: opcode_name = "BINOP_LOGICAL_AND"; break; + case BINOP_LOGICAL_OR: opcode_name = "BINOP_LOGICAL_OR"; break; + case BINOP_BITWISE_AND: opcode_name = "BINOP_BITWISE_AND"; break; + case BINOP_BITWISE_IOR: opcode_name = "BINOP_BITWISE_IOR"; break; + case BINOP_BITWISE_XOR: opcode_name = "BINOP_BITWISE_XOR"; break; + case BINOP_EQUAL: opcode_name = "BINOP_EQUAL"; break; + case BINOP_NOTEQUAL: opcode_name = "BINOP_NOTEQUAL"; break; + case BINOP_LESS: opcode_name = "BINOP_LESS"; break; + case BINOP_GTR: opcode_name = "BINOP_GTR"; break; + case BINOP_LEQ: opcode_name = "BINOP_LEQ"; break; + case BINOP_GEQ: opcode_name = "BINOP_GEQ"; break; + case BINOP_REPEAT: opcode_name = "BINOP_REPEAT"; break; + case BINOP_ASSIGN: opcode_name = "BINOP_ASSIGN"; break; + case BINOP_COMMA: opcode_name = "BINOP_COMMA"; break; + case BINOP_SUBSCRIPT: opcode_name = "BINOP_SUBSCRIPT"; break; + case MULTI_SUBSCRIPT: opcode_name = "MULTI_SUBSCRIPT"; break; + case BINOP_EXP: opcode_name = "BINOP_EXP"; break; + case BINOP_MIN: opcode_name = "BINOP_MIN"; break; + case BINOP_MAX: opcode_name = "BINOP_MAX"; break; + case BINOP_SCOPE: opcode_name = "BINOP_SCOPE"; break; + case STRUCTOP_MEMBER: opcode_name = "STRUCTOP_MEMBER"; break; + case STRUCTOP_MPTR: opcode_name = "STRUCTOP_MPTR"; break; + case BINOP_INTDIV: opcode_name = "BINOP_INTDIV"; break; + case BINOP_ASSIGN_MODIFY: opcode_name = "BINOP_ASSIGN_MODIFY"; break; + case BINOP_VAL: opcode_name = "BINOP_VAL"; break; + case BINOP_INCL: opcode_name = "BINOP_INCL"; break; + case BINOP_EXCL: opcode_name = "BINOP_EXCL"; break; + case BINOP_CONCAT: opcode_name = "BINOP_CONCAT"; break; + case BINOP_RANGE: opcode_name = "BINOP_RANGE"; break; + case BINOP_END: opcode_name = "BINOP_END"; break; + case TERNOP_COND: opcode_name = "TERNOP_COND"; break; + case TERNOP_SLICE: opcode_name = "TERNOP_SLICE"; break; + case TERNOP_SLICE_COUNT: opcode_name = "TERNOP_SLICE_COUNT"; break; + case OP_LONG: opcode_name = "OP_LONG"; break; + case OP_DOUBLE: opcode_name = "OP_DOUBLE"; break; + case OP_VAR_VALUE: opcode_name = "OP_VAR_VALUE"; break; + case OP_LAST: opcode_name = "OP_LAST"; break; + case OP_REGISTER: opcode_name = "OP_REGISTER"; break; + case OP_INTERNALVAR: opcode_name = "OP_INTERNALVAR"; break; + case OP_FUNCALL: opcode_name = "OP_FUNCALL"; break; + case OP_STRING: opcode_name = "OP_STRING"; break; + case OP_BITSTRING: opcode_name = "OP_BITSTRING"; break; + case OP_ARRAY: opcode_name = "OP_ARRAY"; break; + case UNOP_CAST: opcode_name = "UNOP_CAST"; break; + case UNOP_MEMVAL: opcode_name = "UNOP_MEMVAL"; break; + case UNOP_NEG: opcode_name = "UNOP_NEG"; break; + case UNOP_LOGICAL_NOT: opcode_name = "UNOP_LOGICAL_NOT"; break; + case UNOP_COMPLEMENT: opcode_name = "UNOP_COMPLEMENT"; break; + case UNOP_IND: opcode_name = "UNOP_IND"; break; + case UNOP_ADDR: opcode_name = "UNOP_ADDR"; break; + case UNOP_PREINCREMENT: opcode_name = "UNOP_PREINCREMENT"; break; + case UNOP_POSTINCREMENT: opcode_name = "UNOP_POSTINCREMENT"; break; + case UNOP_PREDECREMENT: opcode_name = "UNOP_PREDECREMENT"; break; + case UNOP_POSTDECREMENT: opcode_name = "UNOP_POSTDECREMENT"; break; + case UNOP_SIZEOF: opcode_name = "UNOP_SIZEOF"; break; + case UNOP_LOWER: opcode_name = "UNOP_LOWER"; break; + case UNOP_UPPER: opcode_name = "UNOP_UPPER"; break; + case UNOP_LENGTH: opcode_name = "UNOP_LENGTH"; break; + case UNOP_PLUS: opcode_name = "UNOP_PLUS"; break; + case UNOP_CAP: opcode_name = "UNOP_CAP"; break; + case UNOP_CHR: opcode_name = "UNOP_CHR"; break; + case UNOP_ORD: opcode_name = "UNOP_ORD"; break; + case UNOP_ABS: opcode_name = "UNOP_ABS"; break; + case UNOP_FLOAT: opcode_name = "UNOP_FLOAT"; break; + case UNOP_HIGH: opcode_name = "UNOP_HIGH"; break; + case UNOP_MAX: opcode_name = "UNOP_MAX"; break; + case UNOP_MIN: opcode_name = "UNOP_MIN"; break; + case UNOP_ODD: opcode_name = "UNOP_ODD"; break; + case UNOP_TRUNC: opcode_name = "UNOP_TRUNC"; break; + case OP_BOOL: opcode_name = "OP_BOOL"; break; + case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break; + case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break; + case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break; + case OP_THIS: opcode_name = "OP_THIS"; break; + case OP_SCOPE: opcode_name = "OP_SCOPE"; break; + case OP_TYPE: opcode_name = "OP_TYPE"; break; + case OP_LABELED: opcode_name = "OP_LABELED"; break; + } + + fprintf_filtered (stream, "%-20s ", opcode_name); + + switch (exp -> elts[elt++].opcode) + { + case TERNOP_COND: + case TERNOP_SLICE: + case TERNOP_SLICE_COUNT: + elt = dump_subexp (exp, stream, elt); + case BINOP_ADD: + case BINOP_SUB: + case BINOP_MUL: + case BINOP_DIV: + case BINOP_REM: + case BINOP_MOD: + case BINOP_LSH: + case BINOP_RSH: + case BINOP_LOGICAL_AND: + case BINOP_LOGICAL_OR: + case BINOP_BITWISE_AND: + case BINOP_BITWISE_IOR: + case BINOP_BITWISE_XOR: + case BINOP_EQUAL: + case BINOP_NOTEQUAL: + case BINOP_LESS: + case BINOP_GTR: + case BINOP_LEQ: + case BINOP_GEQ: + case BINOP_REPEAT: + case BINOP_ASSIGN: + case BINOP_COMMA: + case BINOP_SUBSCRIPT: + case BINOP_EXP: + case BINOP_MIN: + case BINOP_MAX: + case BINOP_SCOPE: + case BINOP_INTDIV: + case BINOP_ASSIGN_MODIFY: + case BINOP_VAL: + case BINOP_INCL: + case BINOP_EXCL: + case BINOP_CONCAT: + case BINOP_IN: + case BINOP_RANGE: + case BINOP_END: + elt = dump_subexp (exp, stream, elt); + case UNOP_NEG: + case UNOP_LOGICAL_NOT: + case UNOP_COMPLEMENT: + case UNOP_IND: + case UNOP_ADDR: + case UNOP_PREINCREMENT: + case UNOP_POSTINCREMENT: + case UNOP_PREDECREMENT: + case UNOP_POSTDECREMENT: + case UNOP_SIZEOF: + case UNOP_PLUS: + case UNOP_CAP: + case UNOP_CHR: + case UNOP_ORD: + case UNOP_ABS: + case UNOP_FLOAT: + case UNOP_HIGH: + case UNOP_MAX: + case UNOP_MIN: + case UNOP_ODD: + case UNOP_TRUNC: + case UNOP_LOWER: + case UNOP_UPPER: + case UNOP_LENGTH: + case UNOP_CARD: + case UNOP_CHMAX: + case UNOP_CHMIN: + elt = dump_subexp (exp, stream, elt); + break; + case OP_LONG: + fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, "), value %ld (0x%lx)", + (long)exp->elts[elt+1].longconst, + (long)exp->elts[elt+1].longconst); + elt += 3; + break; + case OP_DOUBLE: + fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, "), value %g", + (double)exp->elts[elt+1].doubleconst); + elt += 3; + break; + case OP_VAR_VALUE: + fprintf_filtered (stream, "Block @0x%x, symbol @0x%x (%s)", + exp->elts[elt].block, + exp->elts[elt+1].symbol, + SYMBOL_NAME (exp->elts[elt+1].symbol)); + elt += 3; + break; + case OP_LAST: + fprintf_filtered (stream, "History element %ld", + (long)exp->elts[elt].longconst); + elt += 2; + break; + case OP_REGISTER: + fprintf_filtered (stream, "Register %ld", + (long)exp->elts[elt].longconst); + elt += 2; + break; + case OP_INTERNALVAR: + fprintf_filtered (stream, "Internal var @0x%x (%s)", + exp->elts[elt].internalvar, + exp->elts[elt].internalvar->name); + elt += 2; + break; + case OP_FUNCALL: + { + int nargs; + + nargs = longest_to_int (exp->elts[elt].longconst); + + fprintf_filtered (stream, "Number of args: %d", nargs); + elt += 2; + + for (i = 1; i <= nargs + 1; i++) + elt = dump_subexp (exp, stream, elt); + } + break; + case OP_ARRAY: + { + int lower, upper; + int i; + + lower = longest_to_int (exp->elts[elt].longconst); + upper = longest_to_int (exp->elts[elt + 1].longconst); + + fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper); + elt += 3; + + for (i = 1; i <= upper - lower + 1; i++) + elt = dump_subexp (exp, stream, elt); + } + break; + case UNOP_MEMVAL: + case UNOP_CAST: + fprintf_filtered (stream, "Type @0x%x (", + exp->elts[elt].type); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, ")"); + elt = dump_subexp (exp, stream, elt + 2); + break; + case OP_TYPE: + fprintf_filtered (stream, "Type @0x%x (", + exp->elts[elt].type); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, ")"); + elt += 2; + break; + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + { + char *elem_name; + int len; + + len = longest_to_int (exp->elts[elt].longconst); + elem_name = &exp->elts[elt + 1].string; + + fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name); + elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1)); + } + break; + + default: + case OP_NULL: + case STRUCTOP_MEMBER: + case STRUCTOP_MPTR: + case MULTI_SUBSCRIPT: + case OP_F77_UNDETERMINED_ARGLIST: + case OP_COMPLEX: + case OP_STRING: + case OP_BITSTRING: + case OP_BOOL: + case OP_M2_STRING: + case OP_THIS: + case OP_SCOPE: + case OP_LABELED: + case OP_NAME: + case OP_EXPRSTRING: + fprintf_filtered (stream, "Unknown format"); + } + + indent -= 2; + + return elt; +} + +void +dump_postfix_expression (exp, stream, note) + struct expression *exp; + GDB_FILE *stream; + char *note; +{ + int elt; + + fprintf_filtered (stream, "Dump of expression @ "); + gdb_print_address (exp, stream); + fprintf_filtered (stream, ", %s:\nExpression: `", note); + /* XXX - doesn't work for types print_expression (exp, stream);*/ + fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n", + exp->language_defn->la_name, exp -> nelts, + sizeof (union exp_element)); + fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode", + "Hex Value", "String Value"); + + for (elt = 0; elt < exp -> nelts;) + elt = dump_subexp (exp, stream, elt); + fprintf_filtered (stream, "\n"); +} + +#endif /* MAINTENANCE_CMDS */ diff --git a/gdb/parse.c b/gdb/parse.c index 1cb6217..a7cd80d 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -38,6 +38,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "command.h" #include "language.h" #include "parser-defs.h" +#include "gdbcmd.h" #include "symfile.h" /* for overlay functions */ /* Global variables declared in parser-defs.h (and commented there). */ @@ -54,6 +55,10 @@ char *namecopy; int paren_depth; int comma_terminates; +#ifdef MAINTENANCE_CMDS +static int expressiondebug = 0; +#endif + static void free_funcalls PARAMS ((void)); @@ -911,9 +916,19 @@ parse_exp_1 (stringptr, block, comma) /* Convert expression from postfix form as generated by yacc parser, to a prefix form. */ - DUMP_EXPRESSION (expout, gdb_stdout, "before conversion to prefix form"); +#ifdef MAINTENANCE_CMDS + if (expressiondebug) + dump_prefix_expression (expout, gdb_stdout, + "before conversion to prefix form"); +#endif /* MAINTENANCE_CMDS */ + prefixify_expression (expout); - DUMP_EXPRESSION (expout, gdb_stdout, "after conversion to prefix form"); + +#ifdef MAINTENANCE_CMDS + if (expressiondebug) + dump_postfix_expression (expout, gdb_stdout, + "after conversion to prefix form"); +#endif /* MAINTENANCE_CMDS */ *stringptr = lexptr; return expout; @@ -1043,4 +1058,14 @@ _initialize_parse () init_type (TYPE_CODE_INT, 1, 0, "", NULL); + +#ifdef MAINTENANCE_CMDS + add_show_from_set ( + add_set_cmd ("expressiondebug", class_maintenance, var_zinteger, + (char *)&expressiondebug, + "Set expression debugging.\n\ +When non-zero, the internal representation of expressions will be printed.", + &setlist), + &showlist); +#endif } -- 2.7.4