* gdb.threads/manythreads.c (main): Increase thread stack size

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

diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index 2b0f585e3dc1ec050573df7ad7cd32898b423b3c..46bc9d758b267b44268b5b56edbb8dc3d8cc49d0 100644 (file)
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -87,7 +87,7 @@ dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
     {
       size_t newlen = ctx->stack_len + need + 10;
       ctx->stack = xrealloc (ctx->stack,
-                            newlen * sizeof (CORE_ADDR));
+                            newlen * sizeof (struct dwarf_stack_value));
       ctx->stack_allocated = newlen;
     }
 }
@@ -95,10 +95,15 @@ dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
 /* Push VALUE onto CTX's stack.  */
 
 void
-dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
+dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value,
+                int in_stack_memory)
 {
+  struct dwarf_stack_value *v;
+
   dwarf_expr_grow_stack (ctx, 1);
-  ctx->stack[ctx->stack_len++] = value;
+  v = &ctx->stack[ctx->stack_len++];
+  v->value = value;
+  v->in_stack_memory = in_stack_memory;
 }
 
 /* Pop the top item off of CTX's stack.  */
@@ -119,7 +124,19 @@ dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
   if (ctx->stack_len <= n)
      error (_("Asked for position %d of stack, stack only has %d elements on it."),
            n, ctx->stack_len);
-  return ctx->stack[ctx->stack_len - (1 + n)];
+  return ctx->stack[ctx->stack_len - (1 + n)].value;
+
+}
+
+/* Retrieve the in_stack_memory flag of the N'th item on CTX's stack.  */
+
+int
+dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
+{
+  if (ctx->stack_len <= n)
+     error (_("Asked for position %d of stack, stack only has %d elements on it."),
+           n, ctx->stack_len);
+  return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
 
 }
 
@@ -148,7 +165,10 @@ add_piece (struct dwarf_expr_context *ctx, ULONGEST size)
       p->v.literal.length = ctx->len;
     }
   else
-    p->v.value = dwarf_expr_fetch (ctx, 0);
+    {
+      p->v.expr.value = dwarf_expr_fetch (ctx, 0);
+      p->v.expr.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+    }
 }
 
 /* Evaluate the expression at ADDR (LEN bytes long) using the context
@@ -329,6 +349,13 @@ execute_stack_op (struct dwarf_expr_context *ctx,
     {
       enum dwarf_location_atom op = *op_ptr++;
       CORE_ADDR result;
+      /* Assume the value is not in stack memory.
+        Code that knows otherwise sets this to 1.
+        Some arithmetic on stack addresses can probably be assumed to still
+        be a stack address, but we skip this complication for now.
+        This is just an optimization, so it's always ok to punt
+        and leave this as 0.  */
+      int in_stack_memory = 0;
       ULONGEST uoffset, reg;
       LONGEST offset;
 
@@ -557,12 +584,15 @@ execute_stack_op (struct dwarf_expr_context *ctx,
            if (ctx->location == DWARF_VALUE_REGISTER)
              result = (ctx->read_reg) (ctx->baton, result);
            result = result + offset;
+           in_stack_memory = 1;
            ctx->stack_len = before_stack_len;
            ctx->location = DWARF_VALUE_MEMORY;
          }
          break;
+
        case DW_OP_dup:
          result = dwarf_expr_fetch (ctx, 0);
+         in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
          break;
 
        case DW_OP_drop:
@@ -572,11 +602,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
        case DW_OP_pick:
          offset = *op_ptr++;
          result = dwarf_expr_fetch (ctx, offset);
+         in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
          break;
          
        case DW_OP_swap:
          {
-           CORE_ADDR t1, t2;
+           struct dwarf_stack_value t1, t2;
 
            if (ctx->stack_len < 2)
               error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
@@ -590,11 +621,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
        case DW_OP_over:
          result = dwarf_expr_fetch (ctx, 1);
+         in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
          break;
 
        case DW_OP_rot:
          {
-           CORE_ADDR t1, t2, t3;
+           struct dwarf_stack_value t1, t2, t3;
 
            if (ctx->stack_len < 3)
               error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
@@ -758,6 +790,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
        case DW_OP_call_frame_cfa:
          result = (ctx->get_frame_cfa) (ctx->baton);
+         in_stack_memory = 1;
          break;
 
        case DW_OP_GNU_push_tls_address:
@@ -820,7 +853,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
        }
 
       /* Most things push a result value.  */
-      dwarf_expr_push (ctx, result);
+      dwarf_expr_push (ctx, result, in_stack_memory);
     no_push:;
     }