X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexpprint.c;h=a99832c7aba7d5f25f2e1d35fe473456009ccb47;hb=858c9d13240e695bc3b750368f5d4e524b12112e;hp=4dd2d7c9f7285fbcd41cfea3ae1d75574e25a986;hpb=28e7fd62340426746f9c896cbc40c5d374ec47aa;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/expprint.c b/gdb/expprint.c
index 4dd2d7c9f7..a99832c7ab 100644
--- a/gdb/expprint.c
+++ b/gdb/expprint.c
@@ -1,6 +1,6 @@
 /* Print in infix form a struct expression.
 
-   Copyright (C) 1986-2013 Free Software Foundation, Inc.
+   Copyright (C) 1986-2017 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -26,10 +26,8 @@
 #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 <ctype.h>
@@ -64,7 +62,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;
@@ -99,7 +97,7 @@ print_subexp_standard (struct expression *exp, int *pos,
       {
 	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),
@@ -107,14 +105,14 @@ 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;
@@ -136,6 +134,21 @@ print_subexp_standard (struct expression *exp, int *pos,
       }
       return;
 
+    case OP_VAR_MSYM_VALUE:
+      {
+	(*pos) += 3;
+	fputs_filtered (MSYMBOL_PRINT_NAME (exp->elts[pc + 2].msymbol), 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;
@@ -203,7 +216,8 @@ print_subexp_standard (struct expression *exp, int *pos,
 	   additional parameter to LA_PRINT_STRING.  -fnf */
 	get_user_print_options (&opts);
 	LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
-			 &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
+			 (gdb_byte *) &exp->elts[pc + 2].string, nargs,
+			 NULL, 0, &opts);
       }
       return;
 
@@ -217,7 +231,8 @@ print_subexp_standard (struct expression *exp, int *pos,
 	fputs_filtered ("@\"", stream);
 	get_user_print_options (&opts);
 	LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
-			 &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
+			 (gdb_byte *) &exp->elts[pc + 2].string, nargs,
+			 NULL, 0, &opts);
 	fputs_filtered ("\"", stream);
       }
       return;
@@ -240,7 +255,7 @@ print_subexp_standard (struct expression *exp, int *pos,
 	  {
 	    char *s, *nextS;
 
-	    s = alloca (strlen (selector) + 1);
+	    s = (char *) alloca (strlen (selector) + 1);
 	    strcpy (s, selector);
 	    for (tem = 0; tem < nargs; tem++)
 	      {
@@ -280,7 +295,7 @@ print_subexp_standard (struct expression *exp, int *pos,
 	     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);
+	  tempstr = (char *) alloca (nargs);
 	  pc += 4;
 	  while (tem < nargs)
 	    {
@@ -307,7 +322,7 @@ print_subexp_standard (struct expression *exp, int *pos,
 
 	  get_user_print_options (&opts);
 	  LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
-			   tempstr, nargs - 1, NULL, 0, &opts);
+			   (gdb_byte *) tempstr, nargs - 1, NULL, 0, &opts);
 	  (*pos) = pc;
 	}
       else
@@ -446,7 +461,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
@@ -471,18 +486,6 @@ print_subexp_standard (struct expression *exp, int *pos,
 	fputs_filtered (")", stream);
       return;
 
-    case UNOP_MEMVAL_TLS:
-      (*pos) += 3;
-      if ((int) prec > (int) PREC_PREFIX)
-	fputs_filtered ("(", stream);
-      fputs_filtered ("{", stream);
-      type_print (exp->elts[pc + 2].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;
@@ -540,11 +543,15 @@ print_subexp_standard (struct expression *exp, int *pos,
 
     case TYPE_INSTANCE:
       {
-	LONGEST count = exp->elts[pc + 1].longconst;
+	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 ("TypesInstance(", stream);
+	fputs_unfiltered ("TypeInstance(", stream);
 	while (count-- > 0)
 	  {
 	    type_print (exp->elts[(*pos)++].type, "", stream, 0);
@@ -555,10 +562,36 @@ print_subexp_standard (struct expression *exp, int *pos,
 	/* 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;
+
+	fputs_filtered ("RANGE(", stream);
+	if (range_type == HIGH_BOUND_DEFAULT
+	    || range_type == NONE_BOUND_DEFAULT)
+	  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 */
 
     default:
@@ -629,7 +662,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;
@@ -649,7 +682,7 @@ static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
 
 /* Name for OPCODE, when it appears in expression EXP.  */
 
-char *
+const char *
 op_name (struct expression *exp, enum exp_opcode opcode)
 {
   return exp->language_defn->la_exp_desc->op_name (opcode);
@@ -658,7 +691,7 @@ op_name (struct expression *exp, enum exp_opcode 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)
@@ -683,10 +716,9 @@ op_name_standard (enum exp_opcode opcode)
 
 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;
 
@@ -702,9 +734,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, "  ");
 
@@ -800,8 +833,6 @@ dump_subexp_body_standard (struct expression *exp,
     case BINOP_ASSIGN_MODIFY:
     case BINOP_VAL:
     case BINOP_CONCAT:
-    case BINOP_IN:
-    case BINOP_RANGE:
     case BINOP_END:
     case STRUCTOP_MEMBER:
     case STRUCTOP_MPTR:
@@ -840,13 +871,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:
@@ -858,6 +890,15 @@ dump_subexp_body_standard (struct expression *exp,
 			SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
       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)",
+			MSYMBOL_PRINT_NAME (exp->elts[elt + 1].msymbol));
+      elt += 3;
+      break;
     case OP_VAR_ENTRY_VALUE:
       fprintf_filtered (stream, "Entry value of symbol @");
       gdb_print_host_address (exp->elts[elt].symbol, stream);
@@ -927,16 +968,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);
@@ -951,6 +982,11 @@ dump_subexp_body_standard (struct expression *exp,
       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:
       {
@@ -982,11 +1018,21 @@ dump_subexp_body_standard (struct expression *exp,
 	elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
       }
       break;
-    case TYPE_INSTANCE:
+
+    case OP_FUNC_STATIC_VAR:
       {
-	LONGEST len;
+	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;
 
-	len = exp->elts[elt++].longconst;
+    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)
 	  {
@@ -999,17 +1045,86 @@ dump_subexp_body_standard (struct expression *exp,
 	    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 HIGH_BOUND_DEFAULT:
+	    fputs_filtered ("Range 'EXP..'", stream);
+	    break;
+	  case NONE_BOUND_DEFAULT:
+	    fputs_filtered ("Range '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_BOOL:
     case OP_M2_STRING:
     case OP_THIS: