[SCM] archer-sergiodj-stap-patch-split: Fixing some gdbarch bugs, implementing stap_fetch_register, implementing arch-specific methods.

[SCM] archer-sergiodj-stap-patch-split: Fixing some gdbarch bugs, implementing stap_fetch_register, implementing arch-specific methods.

[sergiodj]

The branch, archer-sergiodj-stap-patch-split has been updated
       via  4530787bc40d7e9ba75b1fb0643c45a69fa2f245 (commit)
      from  a5e3177d79455f705dac963071e25d2da6c1b748 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email.

- Log -----------------------------------------------------------------
commit 4530787bc40d7e9ba75b1fb0643c45a69fa2f245
Author: Sergio Durigan Junior <sergiodj@redhat.com>
Date:   Tue Aug 23 10:29:17 2011 -0300

    Fixing some gdbarch bugs, implementing stap_fetch_register, implementing arch-specific methods.

-----------------------------------------------------------------------

Summary of changes:
 gdb/amd64-linux-tdep.c |    5 +-
 gdb/gdbarch.c          |   53 +++++--------
 gdb/gdbarch.h          |   59 ++++++++-----
 gdb/gdbarch.sh         |   44 +++++-----
 gdb/i386-linux-tdep.c  |    5 +-
 gdb/i386-tdep.c        |    2 +
 gdb/i386-tdep.h        |    6 +-
 gdb/ppc-linux-tdep.c   |   79 ++++++++++++++++++
 gdb/s390-tdep.c        |   11 +++
 gdb/stap-probe.c       |  209 ++++++++++++++++++++++++++++++++++++------------
 10 files changed, 337 insertions(+), 136 deletions(-)

First 500 lines of diff:
diff --git a/gdb/amd64-linux-tdep.c b/gdb/amd64-linux-tdep.c
index a2d643a..dd22c3a 100644
--- a/gdb/amd64-linux-tdep.c
+++ b/gdb/amd64-linux-tdep.c
@@ -1369,9 +1369,8 @@ amd64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
   set_gdbarch_stap_register_prefix (gdbarch, "%");
   set_gdbarch_stap_register_sufix (gdbarch, NULL);
   set_gdbarch_stap_register_indirection_prefix (gdbarch, "(");
-  set_gdbarch_stap_register_indirection_sufix (gdbarch, NULL);
-  set_gdbarch_stap_register_displacement_prefix (gdbarch, "(");
-  set_gdbarch_stap_register_displacement_sufix (gdbarch, NULL);
+  set_gdbarch_stap_register_indirection_sufix (gdbarch, ")");
+  set_gdbarch_stap_is_single_operand (gdbarch, i386_stap_is_single_operand);
   set_gdbarch_stap_parse_special_token (gdbarch, NULL);
   set_gdbarch_stap_evaluate_special_token (gdbarch, NULL);
 #if 0
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 74a3fb0..3971301 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -268,8 +268,7 @@ struct gdbarch
   const char * stap_register_sufix;
   const char * stap_register_indirection_prefix;
   const char * stap_register_indirection_sufix;
-  const char * stap_register_displacement_prefix;
-  const char * stap_register_displacement_sufix;
+  gdbarch_stap_is_single_operand_ftype *stap_is_single_operand;
   gdbarch_stap_parse_special_token_ftype *stap_parse_special_token;
   gdbarch_stap_evaluate_special_token_ftype *stap_evaluate_special_token;
   int has_global_solist;
@@ -431,8 +430,7 @@ struct gdbarch startup_gdbarch =
   0,  /* stap_register_sufix */
   0,  /* stap_register_indirection_prefix */
   0,  /* stap_register_indirection_sufix */
-  0,  /* stap_register_displacement_prefix */
-  0,  /* stap_register_displacement_sufix */
+  0,  /* stap_is_single_operand */
   0,  /* stap_parse_special_token */
   0,  /* stap_evaluate_special_token */
   0,  /* has_global_solist */
@@ -726,8 +724,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of stap_register_sufix, invalid_p == 0 */
   /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
   /* Skip verify of stap_register_indirection_sufix, invalid_p == 0 */
-  /* Skip verify of stap_register_displacement_prefix, invalid_p == 0 */
-  /* Skip verify of stap_register_displacement_sufix, invalid_p == 0 */
+  /* Skip verify of stap_is_single_operand, has predicate.  */
   /* Skip verify of stap_parse_special_token, has predicate.  */
   /* Skip verify of stap_evaluate_special_token, has predicate.  */
   /* Skip verify of has_global_solist, invalid_p == 0 */
@@ -1268,18 +1265,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: stap_integer_sufix = %s\n",
                       gdbarch->stap_integer_sufix);
   fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_stap_is_single_operand_p() = %d\n",
+                      gdbarch_stap_is_single_operand_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_is_single_operand = <%s>\n",
+                      host_address_to_string (gdbarch->stap_is_single_operand));
+  fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_stap_parse_special_token_p() = %d\n",
                       gdbarch_stap_parse_special_token_p (gdbarch));
   fprintf_unfiltered (file,
                       "gdbarch_dump: stap_parse_special_token = <%s>\n",
                       host_address_to_string (gdbarch->stap_parse_special_token));
   fprintf_unfiltered (file,
-                      "gdbarch_dump: stap_register_displacement_prefix = %s\n",
-                      gdbarch->stap_register_displacement_prefix);
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: stap_register_displacement_sufix = %s\n",
-                      gdbarch->stap_register_displacement_sufix);
-  fprintf_unfiltered (file,
                       "gdbarch_dump: stap_register_indirection_prefix = %s\n",
                       gdbarch->stap_register_indirection_prefix);
   fprintf_unfiltered (file,
@@ -3896,38 +3893,28 @@ set_gdbarch_stap_register_indirection_sufix (struct gdbarch *gdbarch,
   gdbarch->stap_register_indirection_sufix = stap_register_indirection_sufix;
 }
 
-const char *
-gdbarch_stap_register_displacement_prefix (struct gdbarch *gdbarch)
+int
+gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of stap_register_displacement_prefix, invalid_p == 0 */
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_displacement_prefix called\n");
-  return gdbarch->stap_register_displacement_prefix;
+  return gdbarch->stap_is_single_operand != NULL;
 }
 
-void
-set_gdbarch_stap_register_displacement_prefix (struct gdbarch *gdbarch,
-                                               const char * stap_register_displacement_prefix)
-{
-  gdbarch->stap_register_displacement_prefix = stap_register_displacement_prefix;
-}
-
-const char *
-gdbarch_stap_register_displacement_sufix (struct gdbarch *gdbarch)
+int
+gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of stap_register_displacement_sufix, invalid_p == 0 */
+  gdb_assert (gdbarch->stap_is_single_operand != NULL);
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_displacement_sufix called\n");
-  return gdbarch->stap_register_displacement_sufix;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_is_single_operand called\n");
+  return gdbarch->stap_is_single_operand (gdbarch, s);
 }
 
 void
-set_gdbarch_stap_register_displacement_sufix (struct gdbarch *gdbarch,
-                                              const char * stap_register_displacement_sufix)
+set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch,
+                                    gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
 {
-  gdbarch->stap_register_displacement_sufix = stap_register_displacement_sufix;
+  gdbarch->stap_is_single_operand = stap_is_single_operand;
 }
 
 int
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 74d47bc..c369d5b 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -993,7 +993,10 @@ extern void set_gdbarch_stap_register_sufix (struct gdbarch *gdbarch, const char
   
     (%eax) ;; indirecting eax
   
-   in this case, this prefix would be the charater `('. */
+   in this case, this prefix would be the charater `('.
+  
+   Please note that we use the indirection prefix also for register
+   displacement, e.g., `4(%eax)' on x86. */
 
 extern const char * gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch);
 extern void set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch, const char * stap_register_indirection_prefix);
@@ -1003,34 +1006,32 @@ extern void set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarc
   
     (%eax) ;; indirecting eax
   
-   in this case, this prefix would be the charater `)'. */
+   in this case, this prefix would be the charater `)'.
+  
+   Please note that we use the indirection sufix also for register
+   displacement, e.g., `4(%eax)' on x86. */
 
 extern const char * gdbarch_stap_register_indirection_sufix (struct gdbarch *gdbarch);
 extern void set_gdbarch_stap_register_indirection_sufix (struct gdbarch *gdbarch, const char * stap_register_indirection_sufix);
 
-/* Prefix used to mark a register displacement on the architecture's assembly.
-   For example, on x86 the register displacement is written as:
-  
-    4(%eax) ;; indirecting eax
+/* Check if S is a single operand.
   
-   in this case, this prefix would be the charater `('.  Note that we do NOT
-   include the number(s) before the parenthesis, because the parser already
-   assumes that the displacement will be of the form:
+   Single operands can be:
+    - Literal integers, e.g. `$10' on x86
+    - Register access, e.g. `%eax' on x86
+    - Register indirection, e.g. `(%eax)' on x86
+    - Register displacement, e.g. `4(%eax)' on x86
   
-   <number> <displacement_prefix> <register_name> <displacement_sufix> */
+   This function should check for these patterns on the string
+   and return 1 if some were found, or zero otherwise.  Please try to match
+   as much info as you can from the string, i.e., if you have to match
+   something like `(%', do not match just the `('. */
 
-extern const char * gdbarch_stap_register_displacement_prefix (struct gdbarch *gdbarch);
-extern void set_gdbarch_stap_register_displacement_prefix (struct gdbarch *gdbarch, const char * stap_register_displacement_prefix);
+extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch);
 
-/* Sufix used to mark a register indirection on the architecture's assembly.
-   For example, on x86 the register indirection is written as:
-  
-    (%eax) ;; indirecting eax
-  
-   in this case, this prefix would be the charater `)'. */
-
-extern const char * gdbarch_stap_register_displacement_sufix (struct gdbarch *gdbarch);
-extern void set_gdbarch_stap_register_displacement_sufix (struct gdbarch *gdbarch, const char * stap_register_displacement_sufix);
+typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s);
+extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s);
+extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand);
 
 /* Function used to handle a "special case" in the parser.
   
@@ -1042,7 +1043,7 @@ extern void set_gdbarch_stap_register_displacement_sufix (struct gdbarch *gdbarc
   
    Since the parser assumes that a register displacement is of the form:
   
-    <number> <displacement_prefix> <register_name> <displacement_sufix>
+    <number> <indirection_prefix> <register_name> <indirection_sufix>
   
    it means that it will not be able to recognize and parse this odd syntax.
    Therefore, we should add a special case function that will handle this token.
@@ -1062,7 +1063,19 @@ extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbar
   
    It should return the value associated with the special token, or NULL
    otherwise.  It should also compile the expression for the agent if
-   requested.  The pointer `eval_info->exp_buf' should be advanced accordingly. */
+   requested.  The pointer `eval_info->exp_buf' should be advanced accordingly.
+  
+   It is important to know that if this function returns NULL, GDB will still
+   try to evaluate this token using the default methods (i.e., using the
+   methods listed on `stap_evaluate_single_operand').  Therefore, if you want
+   to stop the evaluation here, the best thing to do is to call `error'.
+  
+   This behaviour is interesting because by returning NULL this function can
+   "defer" the evaluation of the token.  For example, on PPC the registers
+   are numbers, so this can confuse the evaluator and thus PPC implements
+   special evaluation of direct register access.  However, for register
+   indirection or displacements, PPC does not need to implement anything
+   because the evaluator can handle these cases. */
 
 extern int gdbarch_stap_evaluate_special_token_p (struct gdbarch *gdbarch);
 
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 87aa0d9..5a1806c 100755
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -791,7 +791,7 @@ M:LONGEST:get_syscall_number:ptid_t ptid:ptid
 #
 #  \$10 ;; integer constant 10
 #
-# in this case, this prefix would be the character \`$\'.
+# in this case, this prefix would be the character \`\$\'.
 v:const char *:stap_integer_prefix:::0:0::0:gdbarch->stap_integer_prefix
 
 # Sufix used to mark an integer constant on the architecture's assembly.
@@ -802,7 +802,7 @@ v:const char *:stap_integer_sufix:::0:0::0:gdbarch->stap_integer_sufix
 #
 #  \%eax ;; register eax
 #
-# in this case, this prefix would be the character \`%\'.
+# in this case, this prefix would be the character \`\%\'.
 v:const char *:stap_register_prefix:::0:0::0:gdbarch->stap_register_prefix
 
 # Sufix used to mark a register name on the architecture's assembly
@@ -814,6 +814,9 @@ v:const char *:stap_register_sufix:::0:0::0:gdbarch->stap_register_sufix
 #  \(\%eax\) ;; indirecting eax
 #
 # in this case, this prefix would be the charater \`\(\'.
+#
+# Please note that we use the indirection prefix also for register
+# displacement, e.g., \`4\(\%eax\)\' on x86.
 v:const char *:stap_register_indirection_prefix:::0:0::0:gdbarch->stap_register_indirection_prefix
 
 # Sufix used to mark a register indirection on the architecture's assembly.
@@ -822,27 +825,24 @@ v:const char *:stap_register_indirection_prefix:::0:0::0:gdbarch->stap_register_
 #  \(\%eax\) ;; indirecting eax
 #
 # in this case, this prefix would be the charater \`\)\'.
-v:const char *:stap_register_indirection_sufix:::0:0::0:gdbarch->stap_register_indirection_sufix
-
-# Prefix used to mark a register displacement on the architecture's assembly.
-# For example, on x86 the register displacement is written as:
-#
-#  4\(\%eax\) ;; indirecting eax
-#
-# in this case, this prefix would be the charater \`\(\'.  Note that we do NOT
-# include the number(s) before the parenthesis, because the parser already
-# assumes that the displacement will be of the form:
 #
-# <number> <displacement_prefix> <register_name> <displacement_sufix>
-v:const char *:stap_register_displacement_prefix:::0:0::0:gdbarch->stap_register_displacement_prefix
+# Please note that we use the indirection sufix also for register
+# displacement, e.g., \`4\(\%eax\)\' on x86.
+v:const char *:stap_register_indirection_sufix:::0:0::0:gdbarch->stap_register_indirection_sufix
 
-# Sufix used to mark a register indirection on the architecture's assembly.
-# For example, on x86 the register indirection is written as:
+# Check if S is a single operand.
 #
-#  \(\%eax\) ;; indirecting eax
+# Single operands can be:
+#  \- Literal integers, e.g. \`\$10\' on x86
+#  \- Register access, e.g. \`\%eax\' on x86
+#  \- Register indirection, e.g. \`\(\%eax\)\' on x86
+#  \- Register displacement, e.g. \`4\(\%eax\)\' on x86
 #
-# in this case, this prefix would be the charater \`\)\'.
-v:const char *:stap_register_displacement_sufix:::0:0::0:gdbarch->stap_register_displacement_sufix
+# This function should check for these patterns on the string
+# and return 1 if some were found, or zero otherwise.  Please try to match
+# as much info as you can from the string, i.e., if you have to match
+# something like \`\(\%\', do not match just the \`\(\'.
+M:int:stap_is_single_operand:const char *s:s
 
 # Function used to handle a "special case" in the parser.
 #
@@ -854,7 +854,7 @@ v:const char *:stap_register_displacement_sufix:::0:0::0:gdbarch->stap_register_
 #
 # Since the parser assumes that a register displacement is of the form:
 #
-#  <number> <displacement_prefix> <register_name> <displacement_sufix>
+#  <number> <indirection_prefix> <register_name> <indirection_sufix>
 #
 # it means that it will not be able to recognize and parse this odd syntax.
 # Therefore, we should add a special case function that will handle this token.
@@ -873,8 +873,8 @@ M:int:stap_parse_special_token:const char **token:token
 #
 # It is important to know that if this function returns NULL, GDB will still
 # try to evaluate this token using the default methods (i.e., using the
-# methods listed on `stap_evaluate_single_operand').  Therefore, if you want
-# to stop the evaluation here, the best thing to do is to call `error'.
+# methods listed on \`stap_evaluate_single_operand\').  Therefore, if you want
+# to stop the evaluation here, the best thing to do is to call \`error\'.
 #
 # This behaviour is interesting because by returning NULL this function can
 # "defer" the evaluation of the token.  For example, on PPC the registers
diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c
index a03f2be..a4bc0a9 100644
--- a/gdb/i386-linux-tdep.c
+++ b/gdb/i386-linux-tdep.c
@@ -911,9 +911,8 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
   set_gdbarch_stap_register_prefix (gdbarch, "%");
   set_gdbarch_stap_register_sufix (gdbarch, NULL);
   set_gdbarch_stap_register_indirection_prefix (gdbarch, "(");
-  set_gdbarch_stap_register_indirection_sufix (gdbarch, NULL);
-  set_gdbarch_stap_register_displacement_prefix (gdbarch, "(");
-  set_gdbarch_stap_register_displacement_sufix (gdbarch, NULL);
+  set_gdbarch_stap_register_indirection_sufix (gdbarch, ")");
+  set_gdbarch_stap_is_single_operand (gdbarch, i386_stap_is_single_operand);
   set_gdbarch_stap_parse_special_token (gdbarch, NULL);
   set_gdbarch_stap_evaluate_special_token (gdbarch, NULL);
 #if 0
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index ed5d26d..a9defb7 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -7437,6 +7437,7 @@ i386_stap_parse_arg (struct gdbarch *gdbarch, const char **arg)
   *arg = cur;
   return 1;
 }
+#endif
 
 int
 i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
@@ -7447,6 +7448,7 @@ i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
 	  || (*s == '%' && isalpha (s[1]))); /* Register access.  */
 }
 
+#if 0
 struct value *
 i386_stap_evaluate_single_operand (struct gdbarch *gdbarch,
 				   struct stap_evaluation_info *eval_info)
diff --git a/gdb/i386-tdep.h b/gdb/i386-tdep.h
index 39b4a90..06e8863 100644
--- a/gdb/i386-tdep.h
+++ b/gdb/i386-tdep.h
@@ -382,13 +382,15 @@ extern int i386_process_record (struct gdbarch *gdbarch,
                                 struct regcache *regcache, CORE_ADDR addr);
 
 #if 0
-/* SystemTap related functions.  */
 
 extern int i386_stap_parse_arg (struct gdbarch *gdbarch, const char **arg);
+#endif
+
+/* SystemTap related functions.  */
 
 extern int i386_stap_is_single_operand (struct gdbarch *gdbarch,
 					const char *s);
-
+#if 0
 extern struct value *i386_stap_evaluate_single_operand
   (struct gdbarch *gdbarch,
    struct stap_evaluation_info *eval_info);
diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index ff7ef48..71f724d 100644
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -1363,6 +1363,7 @@ ppc_stap_parse_arg (struct gdbarch *gdbarch, const char **arg)
   *arg = cur;
   return 1;
 }
+#endif
 
 static int
 ppc_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
@@ -1374,6 +1375,7 @@ ppc_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
 	  || isdigit (*s)); /* Register value.  */
 }
 
+#if 0
 static struct value *
 ppc_stap_evaluate_single_operand (struct gdbarch *gdbarch,
 				  struct stap_evaluation_info *eval_info)
@@ -1617,6 +1619,72 @@ ppc_stap_fetch_register_value (struct gdbarch *gdbarch,
 }
 #endif
 
+static int
+ppc_stap_parse_special_token (struct gdbarch *gdbarch,
+			      const char **token)
+{
+  char *s = (char *) *token;
+
+  /* The special tokens to be parsed here are:
+
+     - register access.  */
+
+  if (isdigit (*s))
+    {
+      while (isdigit (*s))
+	++s;
+
+      s = skip_spaces (s);
+
+      /* We shall not see a parenthesis here, because that would mean
+	 a register displacement, which should have been handled already.  */
+      if (*s == '(')
+	return 0;
+    }
+  else
+    /* There should not be more special tokens to parse.  */
+    return 0;
+
+  *token = s;
+
+  return 1;
+}
+
+static struct value *
+ppc_stap_evaluate_special_token (struct gdbarch *gdbarch,
+				 struct stap_evaluation_info *eval_info)
+{
+  struct value *ret = NULL;
+
+  if (isdigit (*eval_info->exp_buf))
+    {
+      /* This temporary pointer is needed because we have to do a lookahead.
+	  We could be dealing with a register displacement, and in such case
+	  we would not need to do anything.  */
+      char *s = eval_info->exp_buf;
+
+      while (isdigit (*s))
+	++s;
+      s = skip_spaces (s);
+
+      if (*s == '(')
+	/* It is a register displacement indeed.  Returning NULL means we are
+	   deferring the treatment of this case to the generic evaluator.  */
+	return NULL;
+
+      /* We don't need to worry about generating code for AX because
+	 `stap_fetch_reg_value' will do that already.  */
+      ret = stap_fetch_reg_value (eval_info, NULL);
+
+      eval_info->exp_buf = skip_spaces (eval_info->exp_buf);
+    }
+  else
+    /* All the other tokens should be handled correctly by the generic
+       evaluator.  */
+    return NULL;
+
+  return ret;
+}
 
 /* Cell/B.E. active SPE context tracking support.  */
 
@@ -1935,6 +2003,17 @@ ppc_linux_init_abi (struct gdbarch_info info,
   set_gdbarch_get_syscall_number (gdbarch, ppc_linux_get_syscall_number);
 
   /* SystemTap functions.  */
+  set_gdbarch_stap_integer_prefix (gdbarch, "i");
+  set_gdbarch_stap_integer_sufix (gdbarch, NULL);
+  set_gdbarch_stap_register_prefix (gdbarch, NULL);
+  set_gdbarch_stap_register_sufix (gdbarch, NULL);
+  set_gdbarch_stap_register_indirection_prefix (gdbarch, "(");
+  set_gdbarch_stap_register_indirection_sufix (gdbarch, ")");
+  set_gdbarch_stap_is_single_operand (gdbarch, ppc_stap_is_single_operand);
+  set_gdbarch_stap_parse_special_token (gdbarch,
+					ppc_stap_parse_special_token);
+  set_gdbarch_stap_evaluate_special_token (gdbarch,
+					   ppc_stap_evaluate_special_token);
 #if 0
   set_gdbarch_stap_parse_arg (gdbarch, ppc_stap_parse_arg);
   set_gdbarch_stap_is_single_operand (gdbarch, ppc_stap_is_single_operand);
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 76914de..275a9a1 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -2892,6 +2892,7 @@ s390_stap_parse_arg (struct gdbarch *gdbarch, const char **arg)
   *arg = cur;
   return 1;
 }
+#endif
 
 static int
 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
@@ -2901,6 +2902,7 @@ s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)


hooks/post-receive
--
Repository for Project Archer.