Make print_command_trace varargs

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

diff --git a/gdb/parse.c b/gdb/parse.c
index 8b2bb22c76e1ff1d63f0d5ff1f3297a7b624c727..193abe853f4bb543a037f741aea8eed2c55cd2b8 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -68,7 +68,7 @@ const struct exp_descriptor exp_descriptor_standard =
 /* Global variables declared in parser-defs.h (and commented there).  */
 const struct block *expression_context_block;
 CORE_ADDR expression_context_pc;
-const struct block *innermost_block;
+innermost_block_tracker innermost_block;
 int arglist_len;
 static struct type_stack type_stack;
 const char *lexptr;
@@ -88,7 +88,7 @@ static int expout_last_struct = -1;
 static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
 
 /* The token for tagged type name completion.  */
-static char *expout_completion_name;
+static gdb::unique_xmalloc_ptr<char> expout_completion_name;
 
 \f
 static unsigned int expressiondebug = 0;
@@ -121,6 +121,18 @@ static expression_up parse_exp_in_context_1 (const char **, CORE_ADDR,
                                             const struct block *, int,
                                             int, int *);
 
+/* Documented at it's declaration.  */
+
+void
+innermost_block_tracker::update (const struct block *b,
+                                innermost_block_tracker_types t)
+{
+  if ((m_types & t) != 0
+      && (m_innermost_block == NULL
+         || contained_in (b, m_innermost_block)))
+    m_innermost_block = b;
+}
+
 /* Data structure for saving values of arglist_len for function calls whose
    arguments contain other function calls.  */
 
@@ -449,42 +461,35 @@ find_minsym_type_and_address (minimal_symbol *msymbol,
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
-  CORE_ADDR pc;
 
   bool is_tls = (section != NULL
                 && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
 
-  /* Addresses of TLS symbols are really offsets into a
-     per-objfile/per-thread storage block.  */
-  CORE_ADDR addr = (is_tls
-                   ? MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym)
-                   : BMSYMBOL_VALUE_ADDRESS (bound_msym));
-
   /* The minimal symbol might point to a function descriptor;
      resolve it to the actual code address instead.  */
-  pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
-  if (pc != addr)
+  CORE_ADDR addr;
+  if (is_tls)
     {
-      struct bound_minimal_symbol ifunc_msym = lookup_minimal_symbol_by_pc (pc);
-
-      /* In this case, assume we have a code symbol instead of
-        a data symbol.  */
-
-      if (ifunc_msym.minsym != NULL
-         && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
-         && BMSYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
+      /* Addresses of TLS symbols are really offsets into a
+        per-objfile/per-thread storage block.  */
+      addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
+    }
+  else if (msymbol_is_function (objfile, msymbol, &addr))
+    {
+      if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))
        {
-         /* A function descriptor has been resolved but PC is still in the
-            STT_GNU_IFUNC resolver body (such as because inferior does not
-            run to be able to call it).  */
-
-         type = mst_text_gnu_ifunc;
+         /* This means we resolved a function descriptor, and we now
+            have an address for a code/text symbol instead of a data
+            symbol.  */
+         if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
+           type = mst_text_gnu_ifunc;
+         else
+           type = mst_text;
+         section = NULL;
        }
-      else
-       type = mst_text;
-      section = NULL;
-      addr = pc;
     }
+  else
+    addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
 
   if (overlay_debugging)
     addr = symbol_overlayed_address (addr, section);
@@ -563,9 +568,7 @@ mark_completion_tag (enum type_code tag, const char *ptr, int length)
              || tag == TYPE_CODE_STRUCT
              || tag == TYPE_CODE_ENUM);
   expout_tag_completion_type = tag;
-  expout_completion_name = (char *) xmalloc (length + 1);
-  memcpy (expout_completion_name, ptr, length);
-  expout_completion_name[length] = '\0';
+  expout_completion_name.reset (xstrndup (ptr, length));
 }
 
 \f
@@ -682,6 +685,8 @@ handle_register:
   str.ptr++;
   write_exp_string (ps, str);
   write_exp_elt_opcode (ps, OP_REGISTER);
+  innermost_block.update (expression_context_block,
+                         INNERMOST_BLOCK_FOR_REGISTERS);
   return;
 }
 
@@ -990,6 +995,7 @@ operator_length_standard (const struct expression *expr, int endpos,
       switch (range_type)
        {
        case LOW_BOUND_DEFAULT:
+       case LOW_BOUND_DEFAULT_EXCLUSIVE:
        case HIGH_BOUND_DEFAULT:
          args = 1;
          break;
@@ -997,6 +1003,7 @@ operator_length_standard (const struct expression *expr, int endpos,
          args = 0;
          break;
        case NONE_BOUND_DEFAULT:
+       case NONE_BOUND_DEFAULT_EXCLUSIVE:
          args = 2;
          break;
        }
@@ -1123,8 +1130,7 @@ parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
   type_stack.depth = 0;
   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;
-  xfree (expout_completion_name);
-  expout_completion_name = NULL;
+  expout_completion_name.reset ();
 
   comma_terminates = comma;
 
@@ -1263,11 +1269,11 @@ parse_expression_with_language (const char *string, enum language lang)
    reference; furthermore, if the parsing ends in the field name,
    return the field name in *NAME.  If the parsing ends in the middle
    of a field reference, but the reference is somehow invalid, throw
-   an exception.  In all other cases, return NULL.  Returned non-NULL
-   *NAME must be freed by the caller.  */
+   an exception.  In all other cases, return NULL.  */
 
 struct type *
-parse_expression_for_completion (const char *string, char **name,
+parse_expression_for_completion (const char *string,
+                                gdb::unique_xmalloc_ptr<char> *name,
                                 enum type_code *code)
 {
   expression_up exp;
@@ -1292,23 +1298,24 @@ parse_expression_for_completion (const char *string, char **name,
   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
     {
       *code = expout_tag_completion_type;
-      *name = expout_completion_name;
-      expout_completion_name = NULL;
+      *name = std::move (expout_completion_name);
       return NULL;
     }
 
   if (expout_last_struct == -1)
     return NULL;
 
-  *name = extract_field_op (exp.get (), &subexp);
-  if (!*name)
-    return NULL;
+  const char *fieldname = extract_field_op (exp.get (), &subexp);
+  if (fieldname == NULL)
+    {
+      name->reset ();
+      return NULL;
+    }
 
+  name->reset (xstrdup (fieldname));
   /* This might throw an exception.  If so, we want to let it
      propagate.  */
   val = evaluate_subexpression_type (exp.get (), subexp);
-  /* (*NAME) is a part of the EXP memory block freed below.  */
-  *name = xstrdup (*name);
 
   return value_type (val);
 }