Fix bug in sh_elf_reloc_loop

[deliverable/binutils-gdb.git] / gdb / ax-general.c

diff --git a/gdb/ax-general.c b/gdb/ax-general.c
index 34ec3b3071ed42273b35ccbb9e69d5f9da7ba187..91aefff544287ba0a6386551dc5118315591d879 100644 (file)
--- a/gdb/ax-general.c
+++ b/gdb/ax-general.c
@@ -28,20 +28,19 @@
 
 #include "value.h"
 
-static void grow_expr PARAMS ((struct agent_expr * x, int n));
+static void grow_expr (struct agent_expr *x, int n);
 
-static void append_const PARAMS ((struct agent_expr * x, LONGEST val, int n));
+static void append_const (struct agent_expr *x, LONGEST val, int n);
 
-static LONGEST read_const PARAMS ((struct agent_expr * x, int o, int n));
+static LONGEST read_const (struct agent_expr *x, int o, int n);
 
-static void generic_ext PARAMS ((struct agent_expr * x, enum agent_op op, int n));
+static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
 \f
 /* Functions for building expressions.  */
 
 /* Allocate a new, empty agent expression.  */
 struct agent_expr *
-new_agent_expr (scope)
-     CORE_ADDR scope;
+new_agent_expr (CORE_ADDR scope)
 {
   struct agent_expr *x = xmalloc (sizeof (*x));
   x->len = 0;
@@ -55,20 +54,29 @@ new_agent_expr (scope)
 
 /* Free a agent expression.  */
 void
-free_agent_expr (x)
-     struct agent_expr *x;
+free_agent_expr (struct agent_expr *x)
 {
   free (x->buf);
   free (x);
 }
 
+static void
+do_free_agent_expr_cleanup (void *x)
+{
+  free_agent_expr (x);
+}
+
+struct cleanup *
+make_cleanup_free_agent_expr (struct agent_expr *x)
+{
+  return make_cleanup (do_free_agent_expr_cleanup, x);
+}
+
 
 /* Make sure that X has room for at least N more bytes.  This doesn't
    affect the length, just the allocated size.  */
 static void
-grow_expr (x, n)
-     struct agent_expr *x;
-     int n;
+grow_expr (struct agent_expr *x, int n)
 {
   if (x->len + n > x->size)
     {
@@ -83,10 +91,7 @@ grow_expr (x, n)
 /* Append the low N bytes of VAL as an N-byte integer to the
    expression X, in big-endian order.  */
 static void
-append_const (x, val, n)
-     struct agent_expr *x;
-     LONGEST val;
-     int n;
+append_const (struct agent_expr *x, LONGEST val, int n)
 {
   int i;
 
@@ -103,9 +108,7 @@ append_const (x, val, n)
 /* Extract an N-byte big-endian unsigned integer from expression X at
    offset O.  */
 static LONGEST
-read_const (x, o, n)
-     struct agent_expr *x;
-     int o, n;
+read_const (struct agent_expr *x, int o, int n)
 {
   int i;
   LONGEST accum = 0;
@@ -123,9 +126,7 @@ read_const (x, o, n)
 
 /* Append a simple operator OP to EXPR.  */
 void
-ax_simple (x, op)
-     struct agent_expr *x;
-     enum agent_op op;
+ax_simple (struct agent_expr *x, enum agent_op op)
 {
   grow_expr (x, 1);
   x->buf[x->len++] = op;
@@ -135,10 +136,7 @@ ax_simple (x, op)
 /* Append a sign-extension or zero-extension instruction to EXPR, to
    extend an N-bit value.  */
 static void
-generic_ext (x, op, n)
-     struct agent_expr *x;
-     enum agent_op op;
-     int n;
+generic_ext (struct agent_expr *x, enum agent_op op, int n)
 {
   /* N must fit in a byte.  */
   if (n < 0 || n > 255)
@@ -155,9 +153,7 @@ generic_ext (x, op, n)
 
 /* Append a sign-extension instruction to EXPR, to extend an N-bit value.  */
 void
-ax_ext (x, n)
-     struct agent_expr *x;
-     int n;
+ax_ext (struct agent_expr *x, int n)
 {
   generic_ext (x, aop_ext, n);
 }
@@ -165,9 +161,7 @@ ax_ext (x, n)
 
 /* Append a zero-extension instruction to EXPR, to extend an N-bit value.  */
 void
-ax_zero_ext (x, n)
-     struct agent_expr *x;
-     int n;
+ax_zero_ext (struct agent_expr *x, int n)
 {
   generic_ext (x, aop_zero_ext, n);
 }
@@ -175,9 +169,7 @@ ax_zero_ext (x, n)
 
 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
 void
-ax_trace_quick (x, n)
-     struct agent_expr *x;
-     int n;
+ax_trace_quick (struct agent_expr *x, int n)
 {
   /* N must fit in a byte.  */
   if (n < 0 || n > 255)
@@ -196,9 +188,7 @@ ax_trace_quick (x, n)
    can backpatch it once we do know the target offset.  Use ax_label
    to do the backpatching.  */
 int
-ax_goto (x, op)
-     struct agent_expr *x;
-     enum agent_op op;
+ax_goto (struct agent_expr *x, enum agent_op op)
 {
   grow_expr (x, 3);
   x->buf[x->len + 0] = op;
@@ -213,10 +203,7 @@ ax_goto (x, op)
    ax_label (EXPR, PATCH, TARGET)
    to patch TARGET into the ax_goto instruction.  */
 void
-ax_label (x, patch, target)
-     struct agent_expr *x;
-     int patch;
-     int target;
+ax_label (struct agent_expr *x, int patch, int target)
 {
   /* Make sure the value is in range.  Don't accept 0xffff as an
      offset; that's our magic sentinel value for unpatched branches.  */
@@ -230,9 +217,7 @@ ax_label (x, patch, target)
 
 /* Assemble code to push a constant on the stack.  */
 void
-ax_const_l (x, l)
-     struct agent_expr *x;
-     LONGEST l;
+ax_const_l (struct agent_expr *x, LONGEST l)
 {
   static enum agent_op ops[]
   =
@@ -262,9 +247,7 @@ ax_const_l (x, l)
 
 
 void
-ax_const_d (x, d)
-     struct agent_expr *x;
-     LONGEST d;
+ax_const_d (struct agent_expr *x, LONGEST d)
 {
   /* FIXME: floating-point support not present yet.  */
   error ("GDB bug: ax-general.c (ax_const_d): floating point not supported yet");
@@ -274,9 +257,7 @@ ax_const_d (x, d)
 /* Assemble code to push the value of register number REG on the
    stack.  */
 void
-ax_reg (x, reg)
-     struct agent_expr *x;
-     int reg;
+ax_reg (struct agent_expr *x, int reg)
 {
   /* Make sure the register number is in range.  */
   if (reg < 0 || reg > 0xffff)
@@ -349,9 +330,7 @@ struct aop_map aop_map[] =
 
 /* Disassemble the expression EXPR, writing to F.  */
 void
-ax_print (f, x)
-     struct ui_file *f;
-     struct agent_expr *x;
+ax_print (struct ui_file *f, struct agent_expr *x)
 {
   int i;
   int is_float = 0;
@@ -399,9 +378,7 @@ ax_print (f, x)
 /* Given an agent expression AX, fill in an agent_reqs structure REQS
    describing it.  */
 void
-ax_reqs (ax, reqs)
-     struct agent_expr *ax;
-     struct agent_reqs *reqs;
+ax_reqs (struct agent_expr *ax, struct agent_reqs *reqs)
 {
   int i;
   int height;