Riscv shared libraries should not export __global_pointer$.

[deliverable/binutils-gdb.git] / gdb / expprint.c

diff --git a/gdb/expprint.c b/gdb/expprint.c
index 9b8ac4c070b4db0729eff48261405ab8117492ad..a99832c7aba7d5f25f2e1d35fe473456009ccb47 100644 (file)
--- a/gdb/expprint.c
+++ b/gdb/expprint.c
@@ -105,14 +105,14 @@ print_subexp_standard (struct expression *exp, int *pos,
       }
       return;
 
-    case OP_DOUBLE:
+    case OP_FLOAT:
       {
        struct value_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;
@@ -134,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;
@@ -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,6 +562,12 @@ 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;
       }
@@ -858,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:
@@ -876,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);
@@ -945,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)"
-                        : objfile_name (exp->elts[elt].objfile)));
-      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);
@@ -1005,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)
          {
@@ -1022,6 +1045,22 @@ 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);