X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexpprint.c;h=70cc7ca594a87e0cc405052eeabd52acf856a029;hb=f65fe5704af56aca58fd5547d0841a9512e540af;hp=756a02eb8763108815ad198777e45ee253087e23;hpb=79a45b7d67b37d45cdb44d3ee2761a768474dd73;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/expprint.c b/gdb/expprint.c index 756a02eb87..70cc7ca594 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -1,7 +1,6 @@ /* Print in infix form a struct expression. - Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, - 1998, 1999, 2000, 2003, 2007, 2008 Free Software Foundation, Inc. + Copyright (C) 1986-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -27,20 +26,18 @@ #include "parser-defs.h" #include "user-regs.h" /* For user_reg_map_regnum_to_name. */ #include "target.h" -#include "gdb_string.h" #include "block.h" #include "objfiles.h" -#include "gdb_assert.h" #include "valprint.h" +#include "cli/cli-style.h" -#ifdef HAVE_CTYPE_H #include -#endif void print_expression (struct expression *exp, struct ui_file *stream) { int pc = 0; + print_subexp (exp, &pc, stream, PREC_NULL); } @@ -66,7 +63,7 @@ print_subexp_standard (struct expression *exp, int *pos, const struct op_print *op_print_tab; int pc; unsigned nargs; - char *op_str; + const char *op_str; int assign_modify = 0; enum exp_opcode opcode; enum precedence myprec = PREC_NULL; @@ -82,10 +79,15 @@ print_subexp_standard (struct expression *exp, int *pos, { /* Common ops */ + case OP_TYPE: + (*pos) += 2; + type_print (exp->elts[pc + 1].type, "", stream, 0); + return; + case OP_SCOPE: myprec = PREC_PREFIX; assoc = 0; - fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream); + fputs_filtered (TYPE_NAME (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); @@ -95,7 +97,8 @@ print_subexp_standard (struct expression *exp, int *pos, case OP_LONG: { struct value_print_options opts; - get_raw_print_options (&opts); + + get_no_prettyformat_print_options (&opts); (*pos) += 3; value_print (value_from_longest (exp->elts[pc + 1].type, exp->elts[pc + 2].longconst), @@ -103,30 +106,55 @@ print_subexp_standard (struct expression *exp, int *pos, } return; - case OP_DOUBLE: + case OP_FLOAT: { struct value_print_options opts; - get_raw_print_options (&opts); + + get_no_prettyformat_print_options (&opts); (*pos) += 3; - value_print (value_from_double (exp->elts[pc + 1].type, - exp->elts[pc + 2].doubleconst), + value_print (value_from_contents (exp->elts[pc + 1].type, + exp->elts[pc + 2].floatconst), stream, &opts); } return; case OP_VAR_VALUE: { - struct block *b; + const 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) + && BLOCK_FUNCTION (b)->print_name () != NULL) { - fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream); + fputs_filtered (BLOCK_FUNCTION (b)->print_name (), stream); fputs_filtered ("::", stream); } - fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream); + fputs_filtered (exp->elts[pc + 2].symbol->print_name (), stream); + } + return; + + case OP_VAR_MSYM_VALUE: + { + (*pos) += 3; + fputs_filtered (exp->elts[pc + 2].msymbol->print_name (), stream); + } + return; + + case OP_FUNC_STATIC_VAR: + { + tem = longest_to_int (exp->elts[pc + 1].longconst); + (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); + fputs_filtered (&exp->elts[pc + 1].string, stream); + } + return; + + case OP_VAR_ENTRY_VALUE: + { + (*pos) += 2; + fprintf_filtered (stream, "%s@entry", + exp->elts[pc + 1].symbol->print_name ()); } return; @@ -139,6 +167,7 @@ print_subexp_standard (struct expression *exp, int *pos, case OP_REGISTER: { const char *name = &exp->elts[pc + 2].string; + (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1); fprintf_filtered (stream, "$%s", name); return; @@ -158,6 +187,7 @@ print_subexp_standard (struct expression *exp, int *pos, return; case OP_FUNCALL: + case OP_F77_UNDETERMINED_ARGLIST: (*pos) += 2; nargs = longest_to_int (exp->elts[pc + 1].longconst); print_subexp (exp, pos, stream, PREC_SUFFIX); @@ -180,40 +210,39 @@ print_subexp_standard (struct expression *exp, int *pos, case OP_STRING: { struct value_print_options opts; + 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 */ get_user_print_options (&opts); - LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0, - &opts); + LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, + (gdb_byte *) &exp->elts[pc + 2].string, nargs, + NULL, 0, &opts); } 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''"); - return; - - case OP_OBJC_NSSTRING: /* Objective-C Foundation Class NSString constant. */ + case OP_OBJC_NSSTRING: /* Objective-C Foundation Class + NSString constant. */ { struct value_print_options opts; + nargs = longest_to_int (exp->elts[pc + 1].longconst); (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); fputs_filtered ("@\"", stream); get_user_print_options (&opts); - LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0, - &opts); + LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, + (gdb_byte *) &exp->elts[pc + 2].string, nargs, + NULL, 0, &opts); fputs_filtered ("\"", stream); } return; case OP_OBJC_MSGCALL: { /* Objective C message (method) call. */ - char *selector; + gdb::unique_xmalloc_ptr selector; + (*pos) += 3; nargs = longest_to_int (exp->elts[pc + 2].longconst); fprintf_unfiltered (stream, "["); @@ -227,8 +256,8 @@ print_subexp_standard (struct expression *exp, int *pos, if (nargs) { char *s, *nextS; - s = alloca (strlen (selector) + 1); - strcpy (s, selector); + + s = selector.get (); for (tem = 0; tem < nargs; tem++) { nextS = strchr (s, ':'); @@ -241,11 +270,9 @@ print_subexp_standard (struct expression *exp, int *pos, } else { - fprintf_unfiltered (stream, " %s", selector); + fprintf_unfiltered (stream, " %s", selector.get ()); } fprintf_unfiltered (stream, "]"); - /* "selector" was malloc'd by target_read_string. Free it. */ - xfree (selector); return; } @@ -266,8 +293,8 @@ print_subexp_standard (struct expression *exp, int *pos, 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); + byte, which doesn't get printed. */ + tempstr = (char *) alloca (nargs); pc += 4; while (tem < nargs) { @@ -275,7 +302,8 @@ print_subexp_standard (struct expression *exp, int *pos, || exp->elts[pc + 1].type != builtin_type (exp->gdbarch)->builtin_char) { - /* Not a simple array of char, use regular array printing. */ + /* Not a simple array of char, use regular array + printing. */ tem = 0; break; } @@ -290,9 +318,10 @@ print_subexp_standard (struct expression *exp, int *pos, if (tem > 0) { struct value_print_options opts; + get_user_print_options (&opts); - LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0, - &opts); + LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, + (gdb_byte *) tempstr, nargs - 1, NULL, 0, &opts); (*pos) = pc; } else @@ -310,21 +339,6 @@ print_subexp_standard (struct expression *exp, int *pos, } 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); @@ -342,7 +356,6 @@ print_subexp_standard (struct expression *exp, int *pos, 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); @@ -359,7 +372,7 @@ print_subexp_standard (struct expression *exp, int *pos, fputs_filtered (&exp->elts[pc + 2].string, stream); return; - /* Will not occur for Modula-2 */ + /* 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); @@ -409,12 +422,34 @@ print_subexp_standard (struct expression *exp, int *pos, fputs_filtered (")", stream); return; + case UNOP_CAST_TYPE: + if ((int) prec > (int) PREC_PREFIX) + fputs_filtered ("(", stream); + fputs_filtered ("(", stream); + print_subexp (exp, pos, stream, PREC_PREFIX); + fputs_filtered (") ", stream); + print_subexp (exp, pos, stream, PREC_PREFIX); + if ((int) prec > (int) PREC_PREFIX) + fputs_filtered (")", stream); + return; + + case UNOP_DYNAMIC_CAST: + case UNOP_REINTERPRET_CAST: + fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast" + : "reinterpret_cast", stream); + fputs_filtered ("<", stream); + print_subexp (exp, pos, stream, PREC_PREFIX); + fputs_filtered ("> (", stream); + print_subexp (exp, pos, stream, 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) + if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC + && exp->elts[pc + 3].opcode == OP_LONG) { struct value_print_options opts; @@ -425,7 +460,7 @@ print_subexp_standard (struct expression *exp, int *pos, (*pos) += 4; val = value_at_lazy (exp->elts[pc + 1].type, (CORE_ADDR) exp->elts[pc + 5].longconst); - get_raw_print_options (&opts); + get_no_prettyformat_print_options (&opts); value_print (val, stream, &opts); } else @@ -439,12 +474,11 @@ print_subexp_standard (struct expression *exp, int *pos, fputs_filtered (")", stream); return; - case UNOP_MEMVAL_TLS: - (*pos) += 3; + case UNOP_MEMVAL_TYPE: if ((int) prec > (int) PREC_PREFIX) fputs_filtered ("(", stream); fputs_filtered ("{", stream); - type_print (exp->elts[pc + 2].type, "", stream, 0); + print_subexp (exp, pos, stream, PREC_PREFIX); fputs_filtered ("} ", stream); print_subexp (exp, pos, stream, PREC_PREFIX); if ((int) prec > (int) PREC_PREFIX) @@ -474,14 +508,12 @@ print_subexp_standard (struct expression *exp, int *pos, 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". */ + if (exp->language_defn->la_name_of_this) + fputs_filtered (exp->language_defn->la_name_of_this, stream); + else + fprintf_styled (stream, metadata_style.style (), + _(""), + exp->language_defn->la_name); return; /* Modula-2 ops */ @@ -509,9 +541,60 @@ print_subexp_standard (struct expression *exp, int *pos, fprintf_unfiltered (stream, ")"); return; - case BINOP_INCL: - case BINOP_EXCL: - error (_("print_subexp: Not implemented.")); + case TYPE_INSTANCE: + { + type_instance_flags flags + = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst); + LONGEST count = exp->elts[pc + 2].longconst; + + /* The FLAGS. */ + (*pos)++; + /* The COUNT. */ + (*pos)++; + fputs_unfiltered ("TypeInstance(", stream); + while (count-- > 0) + { + type_print (exp->elts[(*pos)++].type, "", stream, 0); + if (count > 0) + fputs_unfiltered (",", stream); + } + fputs_unfiltered (",", stream); + /* Ending COUNT and ending TYPE_INSTANCE. */ + (*pos) += 2; + print_subexp (exp, pos, stream, PREC_PREFIX); + + if (flags & TYPE_INSTANCE_FLAG_CONST) + fputs_unfiltered (",const", stream); + if (flags & TYPE_INSTANCE_FLAG_VOLATILE) + fputs_unfiltered (",volatile", stream); + + fputs_unfiltered (")", stream); + return; + } + + case OP_RANGE: + { + enum range_type range_type; + + range_type = (enum range_type) + longest_to_int (exp->elts[pc + 1].longconst); + *pos += 2; + + if (range_type == NONE_BOUND_DEFAULT_EXCLUSIVE + || range_type == LOW_BOUND_DEFAULT_EXCLUSIVE) + fputs_filtered ("EXCLUSIVE_", stream); + fputs_filtered ("RANGE(", stream); + if (range_type == HIGH_BOUND_DEFAULT + || range_type == NONE_BOUND_DEFAULT + || range_type == NONE_BOUND_DEFAULT_EXCLUSIVE) + print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); + fputs_filtered ("..", stream); + if (range_type == LOW_BOUND_DEFAULT + || range_type == NONE_BOUND_DEFAULT) + print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); + fputs_filtered (")", stream); + return; + } /* Default ops */ @@ -532,7 +615,7 @@ print_subexp_standard (struct expression *exp, int *pos, error (_("Invalid expression")); } - /* Note that PREC_BUILTIN will always emit parentheses. */ + /* Note that PREC_BUILTIN will always emit parentheses. */ if ((int) myprec < (int) prec) fputs_filtered ("(", stream); if ((int) opcode > (int) BINOP_END) @@ -583,7 +666,7 @@ print_subexp_standard (struct expression *exp, int *pos, /* Return the operator corresponding to opcode OP as a string. NULL indicates that the opcode was not found in the current language table. */ -char * +const char * op_string (enum exp_opcode op) { int tem; @@ -599,21 +682,27 @@ op_string (enum exp_opcode op) /* Support for dumping the raw data from expressions in a human readable form. */ -static char *op_name (struct expression *, enum exp_opcode); static int dump_subexp_body (struct expression *exp, struct ui_file *, int); -/* Name for OPCODE, when it appears in expression EXP. */ +/* Name for OPCODE, when it appears in expression EXP. */ -static char * +const char * op_name (struct expression *exp, enum exp_opcode opcode) { + if (opcode >= OP_UNUSED_LAST) + { + char *cell = get_print_cell (); + xsnprintf (cell, PRINT_CELL_SIZE, "unknown opcode: %u", + unsigned (opcode)); + return cell; + } return exp->language_defn->la_exp_desc->op_name (opcode); } /* Default name for the standard operator OPCODE (i.e., one defined in the definition of enum exp_opcode). */ -char * +const char * op_name_standard (enum exp_opcode opcode) { switch (opcode) @@ -622,198 +711,33 @@ op_name_standard (enum exp_opcode opcode) { static char buf[30]; - sprintf (buf, "", opcode); + xsnprintf (buf, sizeof (buf), "", opcode); return buf; } - case OP_NULL: - return "OP_NULL"; - case BINOP_ADD: - return "BINOP_ADD"; - case BINOP_SUB: - return "BINOP_SUB"; - case BINOP_MUL: - return "BINOP_MUL"; - case BINOP_DIV: - return "BINOP_DIV"; - case BINOP_REM: - return "BINOP_REM"; - case BINOP_MOD: - return "BINOP_MOD"; - case BINOP_LSH: - return "BINOP_LSH"; - case BINOP_RSH: - return "BINOP_RSH"; - case BINOP_LOGICAL_AND: - return "BINOP_LOGICAL_AND"; - case BINOP_LOGICAL_OR: - return "BINOP_LOGICAL_OR"; - case BINOP_BITWISE_AND: - return "BINOP_BITWISE_AND"; - case BINOP_BITWISE_IOR: - return "BINOP_BITWISE_IOR"; - case BINOP_BITWISE_XOR: - return "BINOP_BITWISE_XOR"; - case BINOP_EQUAL: - return "BINOP_EQUAL"; - case BINOP_NOTEQUAL: - return "BINOP_NOTEQUAL"; - case BINOP_LESS: - return "BINOP_LESS"; - case BINOP_GTR: - return "BINOP_GTR"; - case BINOP_LEQ: - return "BINOP_LEQ"; - case BINOP_GEQ: - return "BINOP_GEQ"; - case BINOP_REPEAT: - return "BINOP_REPEAT"; - case BINOP_ASSIGN: - return "BINOP_ASSIGN"; - case BINOP_COMMA: - return "BINOP_COMMA"; - case BINOP_SUBSCRIPT: - return "BINOP_SUBSCRIPT"; - case MULTI_SUBSCRIPT: - return "MULTI_SUBSCRIPT"; - case BINOP_EXP: - return "BINOP_EXP"; - case BINOP_MIN: - return "BINOP_MIN"; - case BINOP_MAX: - return "BINOP_MAX"; - case STRUCTOP_MEMBER: - return "STRUCTOP_MEMBER"; - case STRUCTOP_MPTR: - return "STRUCTOP_MPTR"; - case BINOP_INTDIV: - return "BINOP_INTDIV"; - case BINOP_ASSIGN_MODIFY: - return "BINOP_ASSIGN_MODIFY"; - case BINOP_VAL: - return "BINOP_VAL"; - case BINOP_INCL: - return "BINOP_INCL"; - case BINOP_EXCL: - return "BINOP_EXCL"; - case BINOP_CONCAT: - return "BINOP_CONCAT"; - case BINOP_RANGE: - return "BINOP_RANGE"; - case BINOP_END: - return "BINOP_END"; - case TERNOP_COND: - return "TERNOP_COND"; - case TERNOP_SLICE: - return "TERNOP_SLICE"; - case TERNOP_SLICE_COUNT: - return "TERNOP_SLICE_COUNT"; - case OP_LONG: - return "OP_LONG"; - case OP_DOUBLE: - return "OP_DOUBLE"; - case OP_VAR_VALUE: - return "OP_VAR_VALUE"; - case OP_LAST: - return "OP_LAST"; - case OP_REGISTER: - return "OP_REGISTER"; - case OP_INTERNALVAR: - return "OP_INTERNALVAR"; - case OP_FUNCALL: - return "OP_FUNCALL"; - case OP_STRING: - return "OP_STRING"; - case OP_BITSTRING: - return "OP_BITSTRING"; - case OP_ARRAY: - return "OP_ARRAY"; - case UNOP_CAST: - return "UNOP_CAST"; - case UNOP_MEMVAL: - return "UNOP_MEMVAL"; - case UNOP_MEMVAL_TLS: - return "UNOP_MEMVAL_TLS"; - case UNOP_NEG: - return "UNOP_NEG"; - case UNOP_LOGICAL_NOT: - return "UNOP_LOGICAL_NOT"; - case UNOP_COMPLEMENT: - return "UNOP_COMPLEMENT"; - case UNOP_IND: - return "UNOP_IND"; - case UNOP_ADDR: - return "UNOP_ADDR"; - case UNOP_PREINCREMENT: - return "UNOP_PREINCREMENT"; - case UNOP_POSTINCREMENT: - return "UNOP_POSTINCREMENT"; - case UNOP_PREDECREMENT: - return "UNOP_PREDECREMENT"; - case UNOP_POSTDECREMENT: - return "UNOP_POSTDECREMENT"; - case UNOP_SIZEOF: - return "UNOP_SIZEOF"; - case UNOP_LOWER: - return "UNOP_LOWER"; - case UNOP_UPPER: - return "UNOP_UPPER"; - case UNOP_LENGTH: - return "UNOP_LENGTH"; - case UNOP_PLUS: - return "UNOP_PLUS"; - case UNOP_CAP: - return "UNOP_CAP"; - case UNOP_CHR: - return "UNOP_CHR"; - case UNOP_ORD: - return "UNOP_ORD"; - case UNOP_ABS: - return "UNOP_ABS"; - case UNOP_FLOAT: - return "UNOP_FLOAT"; - case UNOP_HIGH: - return "UNOP_HIGH"; - case UNOP_MAX: - return "UNOP_MAX"; - case UNOP_MIN: - return "UNOP_MIN"; - case UNOP_ODD: - return "UNOP_ODD"; - case UNOP_TRUNC: - return "UNOP_TRUNC"; - case OP_BOOL: - return "OP_BOOL"; - case OP_M2_STRING: - return "OP_M2_STRING"; - case STRUCTOP_STRUCT: - return "STRUCTOP_STRUCT"; - case STRUCTOP_PTR: - return "STRUCTOP_PTR"; - case OP_THIS: - return "OP_THIS"; - case OP_OBJC_SELF: - return "OP_OBJC_SELF"; - case OP_SCOPE: - return "OP_SCOPE"; - case OP_TYPE: - return "OP_TYPE"; - case OP_LABELED: - return "OP_LABELED"; +#define OP(name) \ + case name: \ + return #name ; +#include "std-operator.def" +#undef OP } } +/* Print a raw dump of expression EXP to STREAM. + NOTE, if non-NULL, is printed as extra explanatory text. */ + void dump_raw_expression (struct expression *exp, struct ui_file *stream, - char *note) + const char *note) { int elt; - char *opcode_name; char *eltscan; int eltsize; fprintf_filtered (stream, "Dump of expression @ "); gdb_print_host_address (exp, stream); - fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n", + if (note) + fprintf_filtered (stream, ", %s:", note); + fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n", exp->language_defn->la_name, exp->nelts, (long) sizeof (union exp_element)); fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode", @@ -821,9 +745,10 @@ dump_raw_expression (struct expression *exp, struct ui_file *stream, for (elt = 0; elt < exp->nelts; elt++) { fprintf_filtered (stream, "\t%5d ", elt); - opcode_name = op_name (exp, exp->elts[elt].opcode); + const char *opcode_name = op_name (exp, exp->elts[elt].opcode); fprintf_filtered (stream, "%20s ", opcode_name); + print_longest (stream, 'd', 0, exp->elts[elt].longconst); fprintf_filtered (stream, " "); @@ -887,8 +812,8 @@ dump_subexp_body_standard (struct expression *exp, { case TERNOP_COND: case TERNOP_SLICE: - case TERNOP_SLICE_COUNT: elt = dump_subexp (exp, stream, elt); + /* FALL THROUGH */ case BINOP_ADD: case BINOP_SUB: case BINOP_MUL: @@ -918,15 +843,12 @@ dump_subexp_body_standard (struct expression *exp, 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: case STRUCTOP_MEMBER: case STRUCTOP_MPTR: elt = dump_subexp (exp, stream, elt); + /* FALL THROUGH */ case UNOP_NEG: case UNOP_LOGICAL_NOT: case UNOP_COMPLEMENT: @@ -937,6 +859,7 @@ dump_subexp_body_standard (struct expression *exp, case UNOP_PREDECREMENT: case UNOP_POSTDECREMENT: case UNOP_SIZEOF: + case UNOP_ALIGNOF: case UNOP_PLUS: case UNOP_CAP: case UNOP_CHR: @@ -948,12 +871,6 @@ dump_subexp_body_standard (struct expression *exp, 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: @@ -966,13 +883,14 @@ dump_subexp_body_standard (struct expression *exp, (long) exp->elts[elt + 1].longconst); elt += 3; break; - case OP_DOUBLE: + case OP_FLOAT: fprintf_filtered (stream, "Type @"); gdb_print_host_address (exp->elts[elt].type, stream); fprintf_filtered (stream, " ("); type_print (exp->elts[elt].type, NULL, stream, 0); - fprintf_filtered (stream, "), value %g", - (double) exp->elts[elt + 1].doubleconst); + fprintf_filtered (stream, "), value "); + print_floating (exp->elts[elt + 1].floatconst, + exp->elts[elt].type, stream); elt += 3; break; case OP_VAR_VALUE: @@ -981,9 +899,25 @@ dump_subexp_body_standard (struct expression *exp, fprintf_filtered (stream, ", symbol @"); gdb_print_host_address (exp->elts[elt + 1].symbol, stream); fprintf_filtered (stream, " (%s)", - SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol)); + exp->elts[elt + 1].symbol->print_name ()); + elt += 3; + break; + case OP_VAR_MSYM_VALUE: + fprintf_filtered (stream, "Objfile @"); + gdb_print_host_address (exp->elts[elt].objfile, stream); + fprintf_filtered (stream, ", msymbol @"); + gdb_print_host_address (exp->elts[elt + 1].msymbol, stream); + fprintf_filtered (stream, " (%s)", + exp->elts[elt + 1].msymbol->print_name ()); elt += 3; break; + case OP_VAR_ENTRY_VALUE: + fprintf_filtered (stream, "Entry value of symbol @"); + gdb_print_host_address (exp->elts[elt].symbol, stream); + fprintf_filtered (stream, " (%s)", + exp->elts[elt].symbol->print_name ()); + elt += 2; + break; case OP_LAST: fprintf_filtered (stream, "History element %ld", (long) exp->elts[elt].longconst); @@ -997,10 +931,11 @@ dump_subexp_body_standard (struct expression *exp, fprintf_filtered (stream, "Internal var @"); gdb_print_host_address (exp->elts[elt].internalvar, stream); fprintf_filtered (stream, " (%s)", - exp->elts[elt].internalvar->name); + internalvar_name (exp->elts[elt].internalvar)); elt += 2; break; case OP_FUNCALL: + case OP_F77_UNDETERMINED_ARGLIST: { int i, nargs; @@ -1028,6 +963,15 @@ dump_subexp_body_standard (struct expression *exp, elt = dump_subexp (exp, stream, elt); } break; + case UNOP_DYNAMIC_CAST: + case UNOP_REINTERPRET_CAST: + case UNOP_CAST_TYPE: + case UNOP_MEMVAL_TYPE: + fprintf_filtered (stream, " ("); + elt = dump_subexp (exp, stream, elt); + fprintf_filtered (stream, ")"); + elt = dump_subexp (exp, stream, elt); + break; case UNOP_MEMVAL: case UNOP_CAST: fprintf_filtered (stream, "Type @"); @@ -1037,16 +981,6 @@ dump_subexp_body_standard (struct expression *exp, fprintf_filtered (stream, ")"); elt = dump_subexp (exp, stream, elt + 2); break; - case UNOP_MEMVAL_TLS: - fprintf_filtered (stream, "TLS type @"); - gdb_print_host_address (exp->elts[elt + 1].type, stream); - fprintf_filtered (stream, " (__thread /* \"%s\" */ ", - (exp->elts[elt].objfile == NULL ? "(null)" - : exp->elts[elt].objfile->name)); - type_print (exp->elts[elt + 1].type, NULL, stream, 0); - fprintf_filtered (stream, ")"); - elt = dump_subexp (exp, stream, elt + 3); - break; case OP_TYPE: fprintf_filtered (stream, "Type @"); gdb_print_host_address (exp->elts[elt].type, stream); @@ -1055,6 +989,17 @@ dump_subexp_body_standard (struct expression *exp, fprintf_filtered (stream, ")"); elt += 2; break; + case OP_TYPEOF: + case OP_DECLTYPE: + fprintf_filtered (stream, "Typeof ("); + elt = dump_subexp (exp, stream, elt); + fprintf_filtered (stream, ")"); + break; + case OP_TYPEID: + fprintf_filtered (stream, "typeid ("); + elt = dump_subexp (exp, stream, elt); + fprintf_filtered (stream, ")"); + break; case STRUCTOP_STRUCT: case STRUCTOP_PTR: { @@ -1086,17 +1031,121 @@ dump_subexp_body_standard (struct expression *exp, elt += 4 + BYTES_TO_EXP_ELEM (len + 1); } break; + + case OP_FUNC_STATIC_VAR: + { + int len = longest_to_int (exp->elts[elt].longconst); + const char *var_name = &exp->elts[elt + 1].string; + fprintf_filtered (stream, "Field name: `%.*s'", len, var_name); + elt += 3 + BYTES_TO_EXP_ELEM (len + 1); + } + break; + + case TYPE_INSTANCE: + { + type_instance_flags flags + = (type_instance_flag_value) longest_to_int (exp->elts[elt++].longconst); + LONGEST len = exp->elts[elt++].longconst; + fprintf_filtered (stream, "%s TypeInstance: ", plongest (len)); + while (len-- > 0) + { + fprintf_filtered (stream, "Type @"); + gdb_print_host_address (exp->elts[elt].type, stream); + fprintf_filtered (stream, " ("); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, ")"); + elt++; + if (len > 0) + fputs_filtered (", ", stream); + } + + fprintf_filtered (stream, " Flags: %s (", hex_string (flags)); + bool space = false; + auto print_one = [&] (const char *mod) + { + if (space) + fputs_filtered (" ", stream); + space = true; + fprintf_filtered (stream, "%s", mod); + }; + if (flags & TYPE_INSTANCE_FLAG_CONST) + print_one ("const"); + if (flags & TYPE_INSTANCE_FLAG_VOLATILE) + print_one ("volatile"); + fprintf_filtered (stream, ")"); + + /* Ending LEN and ending TYPE_INSTANCE. */ + elt += 2; + elt = dump_subexp (exp, stream, elt); + } + break; + case OP_STRING: + { + LONGEST len = exp->elts[elt].longconst; + LONGEST type = exp->elts[elt + 1].longconst; + + fprintf_filtered (stream, "Language-specific string type: %s", + plongest (type)); + + /* Skip length. */ + elt += 1; + + /* Skip string content. */ + elt += BYTES_TO_EXP_ELEM (len); + + /* Skip length and ending OP_STRING. */ + elt += 2; + } + break; + case OP_RANGE: + { + enum range_type range_type; + + range_type = (enum range_type) + longest_to_int (exp->elts[elt].longconst); + elt += 2; + + switch (range_type) + { + case BOTH_BOUND_DEFAULT: + fputs_filtered ("Range '..'", stream); + break; + case LOW_BOUND_DEFAULT: + fputs_filtered ("Range '..EXP'", stream); + break; + case LOW_BOUND_DEFAULT_EXCLUSIVE: + fputs_filtered ("ExclusiveRange '..EXP'", stream); + break; + case HIGH_BOUND_DEFAULT: + fputs_filtered ("Range 'EXP..'", stream); + break; + case NONE_BOUND_DEFAULT: + fputs_filtered ("Range 'EXP..EXP'", stream); + break; + case NONE_BOUND_DEFAULT_EXCLUSIVE: + fputs_filtered ("ExclusiveRange 'EXP..EXP'", stream); + break; + default: + fputs_filtered ("Invalid Range!", stream); + break; + } + + if (range_type == HIGH_BOUND_DEFAULT + || range_type == NONE_BOUND_DEFAULT) + elt = dump_subexp (exp, stream, elt); + if (range_type == LOW_BOUND_DEFAULT + || range_type == NONE_BOUND_DEFAULT) + elt = dump_subexp (exp, stream, elt); + } + break; + default: case OP_NULL: 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_LABELED: case OP_NAME: fprintf_filtered (stream, "Unknown format"); } @@ -1112,10 +1161,7 @@ dump_prefix_expression (struct expression *exp, struct ui_file *stream) fprintf_filtered (stream, "Dump of expression @ "); gdb_print_host_address (exp, stream); fputs_filtered (", after conversion to prefix form:\nExpression: `", stream); - if (exp->elts[0].opcode != OP_TYPE) - print_expression (exp, stream); - else - fputs_filtered ("Type printing not yet supported....", stream); + print_expression (exp, stream); fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n", exp->language_defn->la_name, exp->nelts, (long) sizeof (union exp_element));