Merge GDB 7.5.1

gdb/tracepoint.c

 /* Tracing functionality for remote targets in custom GDB protocol
 
    Copyright (C) 1997-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 34 matching lines @@
 #include "gdbthread.h"
 #include "stack.h"
 #include "gdbcore.h"
 #include "remote.h"
 #include "source.h"
 #include "ax.h"
 #include "ax-gdb.h"
 #include "memrange.h"
 #include "exceptions.h"
 #include "cli/cli-utils.h"
+#include "probe.h"
 
 /* readline include files */
 #include "readline/readline.h"
 #include "readline/history.h"
 
 /* readline defines this.  */
 #undef savestring
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ skipping 275 matching lines @@
   struct trace_state_variable *tsv;
   int ix;
 
   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
     if (strcmp (name, tsv->name) == 0)
       return tsv;
 
   return NULL;
 }
 
-void
+static void
 delete_trace_state_variable (const char *name)
 {
   struct trace_state_variable *tsv;
   int ix;
 
   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
     if (strcmp (name, tsv->name) == 0)
       {
         xfree ((void *)tsv->name);
         VEC_unordered_remove (tsv_s, tvariables, ix);
         return;
       }
 
   warning (_("No trace variable named \"$%s\", not deleting"), name);
 }
 
 /* The 'tvariable' command collects a name and optional expression to
    evaluate into an initial value.  */
 
-void
+static void
 trace_variable_command (char *args, int from_tty)
 {
   struct expression *expr;
   struct cleanup *old_chain;
   struct internalvar *intvar = NULL;
   LONGEST initval = 0;
   struct trace_state_variable *tsv;
 
   if (!args || !*args)
     error_no_arg (_("trace state variable name"));
@@ skipping 41 matching lines @@
   tsv = create_trace_state_variable (internalvar_name (intvar));
   tsv->initial_value = initval;
 
   printf_filtered (_("Trace state variable $%s "
                      "created, with initial value %s.\n"),
                    tsv->name, plongest (tsv->initial_value));
 
   do_cleanups (old_chain);
 }
 
-void
+static void
 delete_trace_variable_command (char *args, int from_tty)
 {
   int ix;
   char **argv;
   struct cleanup *back_to;
 
   if (args == NULL)
     {
       if (query (_("Delete all trace state variables? ")))
         VEC_free (tsv_s, tvariables);
@@ skipping 283 matching lines @@
                 {
                   p = strchr (p, ',');
                   continue;
                 }
               /* else fall thru, treat p as an expression and parse it!  */
             }
           tmp_p = p;
           for (loc = t->base.loc; loc; loc = loc->next)
             {
               p = tmp_p;
-              exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
+              exp = parse_exp_1 (&p, loc->address,
+                                 block_for_pc (loc->address), 1);
               old_chain = make_cleanup (free_current_contents, &exp);
 
               if (exp->elts[0].opcode == OP_VAR_VALUE)
                 {
                   if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
                     {
-                      error (_("constant `%s' (value %ld) "
+                      error (_("constant `%s' (value %s) "
                                "will not be collected."),
                              SYMBOL_PRINT_NAME (exp->elts[2].symbol),
-                             SYMBOL_VALUE (exp->elts[2].symbol));
+                             plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
                     }
                   else if (SYMBOL_CLASS (exp->elts[2].symbol)
                            == LOC_OPTIMIZED_OUT)
                     {
                       error (_("`%s' is optimized away "
                                "and cannot be collected."),
                              SYMBOL_PRINT_NAME (exp->elts[2].symbol));
                     }
                 }
 
@@ skipping 22 matching lines @@
         {                       /* Repeat over a comma-separated list.  */
           QUIT;                 /* Allow user to bail out with ^C.  */
           while (isspace ((int) *p))
             p++;
 
           tmp_p = p;
           for (loc = t->base.loc; loc; loc = loc->next)
             {
               p = tmp_p;
               /* Only expressions are allowed for this action.  */
-              exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
+              exp = parse_exp_1 (&p, loc->address,
+                                 block_for_pc (loc->address), 1);
               old_chain = make_cleanup (free_current_contents, &exp);
 
               /* We have something to evaluate, make sure that the expr to
                  bytecode translator can handle it and that it's not too
                  long.  */
               aexpr = gen_eval_for_expr (loc->address, exp);
               make_cleanup_free_agent_expr (aexpr);
 
               if (aexpr->len > MAX_AGENT_EXPR_LEN)
                 error (_("Expression is too complicated."));
@@ skipping 173 matching lines @@
 
   len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
   switch (SYMBOL_CLASS (sym))
     {
     default:
       printf_filtered ("%s: don't know symbol class %d\n",
                        SYMBOL_PRINT_NAME (sym),
                        SYMBOL_CLASS (sym));
       break;
     case LOC_CONST:
-      printf_filtered ("constant %s (value %ld) will not be collected.\n",
-                       SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
+      printf_filtered ("constant %s (value %s) will not be collected.\n",
+                       SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
       break;
     case LOC_STATIC:
       offset = SYMBOL_VALUE_ADDRESS (sym);
       if (info_verbose)
         {
           char tmp[40];
 
           sprintf_vma (tmp, offset);
           printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
                            SYMBOL_PRINT_NAME (sym), len,
@@ skipping 449 matching lines @@
                 {
                   add_static_trace_data (collect);
                   action_exp = strchr (action_exp, ',');        /* more? */
                 }
               else
                 {
                   unsigned long addr, len;
                   struct cleanup *old_chain = NULL;
                   struct cleanup *old_chain1 = NULL;
 
-                  exp = parse_exp_1 (&action_exp, 
+                  exp = parse_exp_1 (&action_exp, tloc->address,
                                      block_for_pc (tloc->address), 1);
                   old_chain = make_cleanup (free_current_contents, &exp);
 
                   switch (exp->elts[0].opcode)
                     {
                     case OP_REGISTER:
                       {
                         const char *name = &exp->elts[2].string;
 
                         i = user_reg_map_name_to_regnum (tloc->gdbarch,
@@ skipping 69 matching lines @@
           do
             {                   /* Repeat over a comma-separated list.  */
               QUIT;             /* Allow user to bail out with ^C.  */
               while (isspace ((int) *action_exp))
                 action_exp++;
 
                 {
                   struct cleanup *old_chain = NULL;
                   struct cleanup *old_chain1 = NULL;
 
-                  exp = parse_exp_1 (&action_exp, 
+                  exp = parse_exp_1 (&action_exp, tloc->address,
                                      block_for_pc (tloc->address), 1);
                   old_chain = make_cleanup (free_current_contents, &exp);
 
                   aexpr = gen_eval_for_expr (tloc->address, exp);
                   old_chain1 = make_cleanup_free_agent_expr (aexpr);
 
                   ax_reqs (aexpr);
                   report_agent_reqs_errors (aexpr);
 
                   discard_cleanups (old_chain1);
@@ skipping 15 matching lines @@
 
           encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
                             frame_offset, stepping_list, NULL);
         }
       else
         error (_("Invalid tracepoint command '%s'"), action->line);
     }                           /* for */
 }
 
 /* Render all actions into gdb protocol.  */
-/*static*/ void
+
+void
 encode_actions (struct breakpoint *t, struct bp_location *tloc,
                 char ***tdp_actions, char ***stepping_actions)
 {
   static char tdp_buff[2048], step_buff[2048];
   char *default_collect_line = NULL;
   struct command_line *actions;
   struct command_line *default_collect_action = NULL;
   int frame_reg;
   LONGEST frame_offset;
   struct cleanup *back_to;
@@ skipping 118 matching lines @@
   /* No point in tracing without any tracepoints...  */
   if (VEC_length (breakpoint_p, tp_vec) == 0)
     {
       VEC_free (breakpoint_p, tp_vec);
       error (_("No tracepoints defined, not starting trace"));
     }
 
   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
     {
       struct tracepoint *t = (struct tracepoint *) b;
+      struct bp_location *loc;
 
       if (b->enable_state == bp_enabled)
         any_enabled = 1;
 
       if ((b->type == bp_fast_tracepoint
            ? may_insert_fast_tracepoints
            : may_insert_tracepoints))
         ++num_to_download;
       else
         warning (_("May not insert %stracepoints, skipping tracepoint %d"),
@@ skipping 42 matching lines @@
           /* Since tracepoint locations are never duplicated, `inserted'
              flag should be zero.  */
           gdb_assert (!loc->inserted);
 
           target_download_tracepoint (loc);
 
           loc->inserted = 1;
         }
 
       t->number_on_target = b->number;
+
+      for (loc = b->loc; loc; loc = loc->next)
+        if (loc->probe != NULL)
+          loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
     }
   VEC_free (breakpoint_p, tp_vec);
 
   /* Send down all the trace state variables too.  */
   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
     {
       target_download_trace_state_variable (tsv);
     }
   
   /* Tell target to treat text-like sections as transparent.  */
   target_trace_set_readonly_regions ();
   /* Set some mode flags.  */
   target_set_disconnected_tracing (disconnected_tracing);
   target_set_circular_trace_buffer (circular_trace_buffer);
 
   if (!notes)
     notes = trace_notes;
   ret = target_set_trace_notes (trace_user, notes, NULL);
 
   if (!ret && (trace_user || notes))
-    warning ("Target does not support trace user/notes, info ignored");
+    warning (_("Target does not support trace user/notes, info ignored"));
 
   /* Now insert traps and begin collecting data.  */
   target_trace_start ();
 
   /* Reset our local state.  */
   set_traceframe_num (-1);
   set_tracepoint_num (-1);
   set_traceframe_context (NULL);
   current_trace_status()->running = 1;
   clear_traceframe_info ();
@@ skipping 31 matching lines @@
   if (!current_trace_status ()->running)
     error (_("Trace is not running."));
 
   stop_tracing (args);
 }
 
 void
 stop_tracing (char *note)
 {
   int ret;
+  VEC(breakpoint_p) *tp_vec = NULL;
+  int ix;
+  struct breakpoint *t;
 
   target_trace_stop ();
 
+  tp_vec = all_tracepoints ();
+  for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+    {
+      struct bp_location *loc;
+
+      if ((t->type == bp_fast_tracepoint
+           ? !may_insert_fast_tracepoints
+           : !may_insert_tracepoints))
+        continue;
+
+      for (loc = t->loc; loc; loc = loc->next)
+        {
+          /* GDB can be totally absent in some disconnected trace scenarios,
+             but we don't really care if this semaphore goes out of sync.
+             That's why we are decrementing it here, but not taking care
+             in other places.  */
+          if (loc->probe != NULL)
+            loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
+        }
+    }
+
+  VEC_free (breakpoint_p, tp_vec);
+
   if (!note)
     note = trace_stop_notes;
   ret = target_set_trace_notes (NULL, NULL, note);
 
   if (!ret && note)
-    warning ("Target does not support trace notes, note ignored");
+    warning (_("Target does not support trace notes, note ignored"));
 
   /* Should change in response to reply?  */
   current_trace_status ()->running = 0;
 }
 
 /* tstatus command */
 static void
 trace_status_command (char *args, int from_tty)
 {
   struct trace_status *ts = current_trace_status ();
@@ skipping 580 matching lines @@
   if (args == 0 || *args == 0)
     {
       sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
       sals.nelts = 1;
       sals.sals = (struct symtab_and_line *)
         xmalloc (sizeof (struct symtab_and_line));
       sals.sals[0] = sal;
     }
   else
     {
-      sals = decode_line_spec (args, DECODE_LINE_FUNFIRSTLINE);
+      sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
       sal = sals.sals[0];
     }
   
   old_chain = make_cleanup (xfree, sals.sals);
   if (sal.symtab == 0)
     error (_("No line number information available."));
 
   if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
     {
       if (start_pc == end_pc)
@@ skipping 97 matching lines @@
 }
 
 /* info scope command: list the locals for a scope.  */
 static void
 scope_info (char *args, int from_tty)
 {
   struct symtabs_and_lines sals;
   struct symbol *sym;
   struct minimal_symbol *msym;
   struct block *block;
-  char *symname, *save_args = args;
-  struct dict_iterator iter;
+  const char *symname;
+  char *save_args = args;
+  struct block_iterator iter;
   int j, count = 0;
   struct gdbarch *gdbarch;
   int regno;
 
   if (args == 0 || *args == 0)
     error (_("requires an argument (function, "
              "line or *addr) to define a scope"));
 
   sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
   if (sals.nelts == 0)
@@ skipping 22 matching lines @@
           printf_filtered ("Symbol %s is ", symname);
           switch (SYMBOL_CLASS (sym))
             {
             default:
             case LOC_UNDEF:     /* Messed up symbol?  */
               printf_filtered ("a bogus symbol, class %d.\n",
                                SYMBOL_CLASS (sym));
               count--;          /* Don't count this one.  */
               continue;
             case LOC_CONST:
-              printf_filtered ("a constant with value %ld (0x%lx)",
-                               SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
+              printf_filtered ("a constant with value %s (%s)",
+                               plongest (SYMBOL_VALUE (sym)),
+                               hex_string (SYMBOL_VALUE (sym)));
               break;
             case LOC_CONST_BYTES:
               printf_filtered ("constant bytes: ");
               if (SYMBOL_TYPE (sym))
                 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
                   fprintf_filtered (gdb_stdout, " %02x",
                                     (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
               break;
             case LOC_STATIC:
               printf_filtered ("in static storage at address ");
@@ skipping 12 matching lines @@
                                                                   gdbarch);
 
               if (SYMBOL_IS_ARGUMENT (sym))
                 printf_filtered ("an argument in register $%s",
                                  gdbarch_register_name (gdbarch, regno));
               else
                 printf_filtered ("a local variable in register $%s",
                                  gdbarch_register_name (gdbarch, regno));
               break;
             case LOC_ARG:
-              printf_filtered ("an argument at stack/frame offset %ld",
-                               SYMBOL_VALUE (sym));
+              printf_filtered ("an argument at stack/frame offset %s",
+                               plongest (SYMBOL_VALUE (sym)));
               break;
             case LOC_LOCAL:
-              printf_filtered ("a local variable at frame offset %ld",
-                               SYMBOL_VALUE (sym));
+              printf_filtered ("a local variable at frame offset %s",
+                               plongest (SYMBOL_VALUE (sym)));
               break;
             case LOC_REF_ARG:
-              printf_filtered ("a reference argument at offset %ld",
-                               SYMBOL_VALUE (sym));
+              printf_filtered ("a reference argument at offset %s",
+                               plongest (SYMBOL_VALUE (sym)));
               break;
             case LOC_REGPARM_ADDR:
               /* Note comment at LOC_REGISTER.  */
               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
                                                                   gdbarch);
               printf_filtered ("the address of an argument, in register $%s",
                                gdbarch_register_name (gdbarch, regno));
               break;
             case LOC_TYPEDEF:
               printf_filtered ("a typedef.\n");
@@ skipping 481 matching lines @@
 
 static void
 set_trace_user (char *args, int from_tty,
                 struct cmd_list_element *c)
 {
   int ret;
 
   ret = target_set_trace_notes (trace_user, NULL, NULL);
 
   if (!ret)
-    warning ("Target does not support trace notes, user ignored");
+    warning (_("Target does not support trace notes, user ignored"));
 }
 
 static void
 set_trace_notes (char *args, int from_tty,
                  struct cmd_list_element *c)
 {
   int ret;
 
   ret = target_set_trace_notes (NULL, trace_notes, NULL);
 
   if (!ret)
-    warning ("Target does not support trace notes, note ignored");
+    warning (_("Target does not support trace notes, note ignored"));
 }
 
 static void
 set_trace_stop_notes (char *args, int from_tty,
                       struct cmd_list_element *c)
 {
   int ret;
 
   ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
 
   if (!ret)
-    warning ("Target does not support trace notes, stop note ignored");
+    warning (_("Target does not support trace notes, stop note ignored"));
 }
 
 /* Convert the memory pointed to by mem into hex, placing result in buf.
  * Return a pointer to the last char put in buf (null)
  * "stolen" from sparc-stub.c
  */
 
 static const char hexchars[] = "0123456789abcdef";
 
 static char *
@@ skipping 131 matching lines @@
     {
       next_one = (*utpp)->next;
       xfree (*utpp);
       *utpp = next_one;
     }
 }
 
 /* Given a number and address, return an uploaded tracepoint with that
    number, creating if necessary.  */
 
-struct uploaded_tsv *
+static struct uploaded_tsv *
 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
 {
   struct uploaded_tsv *utsv;
 
   for (utsv = *utsvp; utsv; utsv = utsv->next)
     if (utsv->number == num)
       return utsv;
   utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
   memset (utsv, 0, sizeof (struct uploaded_tsv));
   utsv->number = num;
@@ skipping 26 matching lines @@
     return (str1 == str2);
 
   return (strcmp (str1, str2) == 0);
 }
 
 /* Look for an existing tracepoint that seems similar enough to the
    uploaded one.  Enablement isn't compared, because the user can
    toggle that freely, and may have done so in anticipation of the
    next trace run.  Return the location of matched tracepoint.  */
 
-struct bp_location *
+static struct bp_location *
 find_matching_tracepoint_location (struct uploaded_tp *utp)
 {
   VEC(breakpoint_p) *tp_vec = all_tracepoints ();
   int ix;
   struct breakpoint *b;
   struct bp_location *loc;
 
   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
     {
       struct tracepoint *t = (struct tracepoint *) b;
@@ skipping 62 matching lines @@
       if (t)
         t->number_on_target = utp->number;
     }
 
   free_uploaded_tps (uploaded_tps);
 }
 
 /* Trace state variables don't have much to identify them beyond their
    name, so just use that to detect matches.  */
 
-struct trace_state_variable *
+static struct trace_state_variable *
 find_matching_tsv (struct uploaded_tsv *utsv)
 {
   if (!utsv->name)
     return NULL;
 
   return find_trace_state_variable (utsv->name);
 }
 
-struct trace_state_variable *
+static struct trace_state_variable *
 create_tsv_from_upload (struct uploaded_tsv *utsv)
 {
   const char *namebase;
   char *buf;
   int try_num = 0;
   struct trace_state_variable *tsv;
   struct cleanup *old_chain;
 
   if (utsv->name)
     {
@@ skipping 884 matching lines @@
 }
 
 /* Look for a block of saved registers in the traceframe, and get the
    requested register from it.  */
 
 static void
 tfile_fetch_registers (struct target_ops *ops,
                        struct regcache *regcache, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
-  char block_type;
-  int pos, offset, regn, regsize, pc_regno;
-  unsigned short mlen;
+  int offset, regn, regsize, pc_regno;
   char *regs;
 
   /* An uninitialized reg size says we're not going to be
      successful at getting register blocks.  */
   if (!trace_regblock_size)
     return;
 
   set_tfile_traceframe ();
 
   regs = alloca (trace_regblock_size);
@@ skipping 103 matching lines @@
           /* If the block includes the first part of the desired
              range, return as much it has; GDB will re-request the
              remainder, which might be in a different block of this
              trace frame.  */
           if (maddr <= offset && offset < (maddr + mlen))
             {
               amt = (maddr + mlen) - offset;
               if (amt > len)
                 amt = len;
 
+              if (maddr != offset)
+                lseek (trace_fd, offset - maddr, SEEK_CUR);
               tfile_read (readbuf, amt);
               return amt;
             }
 
           /* Skip over this block.  */
           pos += (8 + 2 + mlen);
         }
     }
 
   /* It's unduly pedantic to refuse to look at the executable for
@@ skipping 167 matching lines @@
   tfile_ops.to_stratum = process_stratum;
   tfile_ops.to_has_all_memory = tfile_has_all_memory;
   tfile_ops.to_has_memory = tfile_has_memory;
   tfile_ops.to_has_stack = tfile_has_stack;
   tfile_ops.to_has_registers = tfile_has_registers;
   tfile_ops.to_traceframe_info = tfile_traceframe_info;
   tfile_ops.to_thread_alive = tfile_thread_alive;
   tfile_ops.to_magic = OPS_MAGIC;
 }
 
+void
+free_current_marker (void *arg)
+{
+  struct static_tracepoint_marker **marker_p = arg;
+
+  if (*marker_p != NULL)
+    {
+      release_static_tracepoint_marker (*marker_p);
+      xfree (*marker_p);
+    }
+  else
+    *marker_p = NULL;
+}
+
 /* Given a line of text defining a static tracepoint marker, parse it
    into a "static tracepoint marker" object.  Throws an error is
    parsing fails.  If PP is non-null, it points to one past the end of
    the parsed marker definition.  */
 
 void
 parse_static_tracepoint_marker_definition (char *line, char **pp,
                                            struct static_tracepoint_marker *marker)
 {
   char *p, *endp;
@@ skipping 42 matching lines @@
 static void
 print_one_static_tracepoint_marker (int count,
                                     struct static_tracepoint_marker *marker)
 {
   struct command_line *l;
   struct symbol *sym;
 
   char wrap_indent[80];
   char extra_field_indent[80];
   struct ui_out *uiout = current_uiout;
-  struct ui_stream *stb = ui_out_stream_new (uiout);
-  struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
   struct cleanup *bkpt_chain;
   VEC(breakpoint_p) *tracepoints;
 
   struct symtab_and_line sal;
 
   init_sal (&sal);
 
   sal.pc = marker->address;
 
   tracepoints = static_tracepoints_here (marker->address);
@@ skipping 86 matching lines @@
 
       if (ui_out_is_mi_like_p (uiout))
         ui_out_field_int (uiout, "number-of-tracepoints",
                           VEC_length(breakpoint_p, tracepoints));
       else
         ui_out_text (uiout, "\n");
     }
   VEC_free (breakpoint_p, tracepoints);
 
   do_cleanups (bkpt_chain);
-  do_cleanups (old_chain);
 }
 
 static void
 info_static_tracepoint_markers_command (char *arg, int from_tty)
 {
   VEC(static_tracepoint_marker_p) *markers;
   struct cleanup *old_chain;
   struct static_tracepoint_marker *marker;
   struct ui_out *uiout = current_uiout;
   int i;
 
+  /* We don't have to check target_can_use_agent and agent's capability on
+     static tracepoint here, in order to be compatible with older GDBserver.
+     We don't check USE_AGENT is true or not, because static tracepoints
+     don't work without in-process agent, so we don't bother users to type
+     `set agent on' when to use static tracepoint.  */
+
   old_chain
     = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
                                            "StaticTracepointMarkersTable");
 
   ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
 
   ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
 
   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
   if (gdbarch_addr_bit (target_gdbarch) <= 32)
@@ skipping 23 matching lines @@
    for sure type of the value until we actually have a chance to fetch
    the data --- the size of the object depends on what has been
    collected.  We solve this by making $_sdata be an internalvar that
    creates a new value on access.  */
 
 /* Return a new value with the correct type for the sdata object of
    the current trace frame.  Return a void value if there's no object
    available.  */
 
 static struct value *
-sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
+sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
+                  void *ignore)
 {
   LONGEST size;
   gdb_byte *buf;
 
   /* We need to read the whole object before we know its size.  */
   size = target_read_alloc (&current_target,
                             TARGET_OBJECT_STATIC_TRACE_DATA,
                             NULL, &buf);
   if (size >= 0)
     {
@@ skipping 105 matching lines @@
   do_cleanups (back_to);
   return NULL;
 }
 
 #endif /* HAVE_LIBEXPAT */
 
 /* Returns the traceframe_info object for the current traceframe.
    This is where we avoid re-fetching the object from the target if we
    already have it cached.  */
 
-struct traceframe_info *
+static struct traceframe_info *
 get_traceframe_info (void)
 {
   if (traceframe_info == NULL)
     traceframe_info = target_traceframe_info ();
 
   return traceframe_info;
 }
 
 /* If the target supports the query, return in RESULT the set of
    collected memory in the current traceframe, found within the LEN
@@ skipping 32 matching lines @@
             nr->length = min (hi1, hi2) - nr->start;
           }
 
       normalize_mem_ranges (*result);
       return 1;
     }
 
   return 0;
 }
 
+/* Implementation of `sdata' variable.  */
+
+static const struct internalvar_funcs sdata_funcs =
+{
+  sdata_make_value,
+  NULL,
+  NULL
+};
+
 /* module initialization */
 void
 _initialize_tracepoint (void)
 {
   struct cmd_list_element *c;
 
   /* Explicitly create without lookup, since that tries to create a
      value with a void typed value, and when we get here, gdbarch
      isn't initialized yet.  At this point, we're quite sure there
      isn't another convenience variable of the same name.  */
-  create_internalvar_type_lazy ("_sdata", sdata_make_value);
+  create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
 
   traceframe_number = -1;
   tracepoint_number = -1;
 
   if (tracepoint_list.list == NULL)
     {
       tracepoint_list.listsize = 128;
       tracepoint_list.list = xmalloc
         (tracepoint_list.listsize * sizeof (struct memrange));
     }
@@ skipping 206 matching lines @@
                           &trace_stop_notes, _("\
 Set notes string to use for future tstop commands"), _("\
 Show the notes string to use for future tstop commands"), NULL,
                           set_trace_stop_notes, NULL,
                           &setlist, &showlist);
 
   init_tfile_ops ();
 
   add_target (&tfile_ops);
 }