diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index e7de300..fbbd640 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,25 @@
 2016-09-26  Tom Tromey  <tom@tromey.com>
 
+	* dwarf2loc.c (per_cu_dwarf_call)
+	(dwarf_expr_push_dwarf_reg_entry_value)
+	(dwarf2_evaluate_loc_desc_full, dwarf2_locexpr_baton_eval)
+	(needs_dwarf_reg_entry_value)
+	(dwarf2_loc_desc_get_symbol_read_needs): Update.
+	* dwarf2expr.h (dwarf_expr_context) <push_address, eval, fetch,
+	fetch_address, fetch_in_stack_memory, address_type, grow_stack,
+	push, stack_empty_p, add_piece, get_base_type, execute_stack_op,
+	pop>: New method declarations.
+	(dwarf_expr_push_address, dwarf_expr_eval, dwarf_expr_fetch)
+	(dwarf_expr_fetch_address, dwarf_expr_fetch_in_stack_memory):
+	Don't declare.
+	* dwarf2expr.c (address_type, grow_stack, push, push_address)
+	(pop, fetch, fetch_address, fetch_in_stack_memory)
+	(stack_empty_p, add_piece, eval, get_base_type)
+	(execute_stack_op): Rename.  Turn into methods.
+	* dwarf2-frame.c (execute_stack_op): Update.
+
+2016-09-26  Tom Tromey  <tom@tromey.com>
+
 	* dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Stack-allocate
 	dwarf_expr_context.  Remove cleanups.
 	(dwarf2_locexpr_baton_eval)
diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c
index 48963de..c93c362 100644
--- a/gdb/dwarf2-frame.c
+++ b/gdb/dwarf2-frame.c
@@ -382,14 +382,14 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
   ctx.baton = this_frame;
   ctx.funcs = &dwarf2_frame_ctx_funcs;
 
-  dwarf_expr_push_address (&ctx, initial, initial_in_stack_memory);
-  dwarf_expr_eval (&ctx, exp, len);
+  ctx.push_address (initial, initial_in_stack_memory);
+  ctx.eval (exp, len);
 
   if (ctx.location == DWARF_VALUE_MEMORY)
-    result = dwarf_expr_fetch_address (&ctx, 0);
+    result = ctx.fetch_address (0);
   else if (ctx.location == DWARF_VALUE_REGISTER)
     result = read_addr_from_reg (this_frame,
-				 value_as_long (dwarf_expr_fetch (&ctx, 0)));
+				 value_as_long (ctx.fetch (0)));
   else
     {
       /* This is actually invalid DWARF, but if we ever do run across
diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index a965987..2b22e0b 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -28,11 +28,6 @@
 #include "dwarf2expr.h"
 #include "dwarf2loc.h"
 
-/* Local prototypes.  */
-
-static void execute_stack_op (struct dwarf_expr_context *,
-			      const gdb_byte *, const gdb_byte *);
-
 /* Cookie for gdbarch data.  */
 
 static struct gdbarch_data *dwarf_arch_cookie;
@@ -62,28 +57,28 @@ dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
    unspecified in the DWARF spec.  Only certain sizes are
    supported.  */
 
-static struct type *
-dwarf_expr_address_type (struct dwarf_expr_context *ctx)
+struct type *
+dwarf_expr_context::address_type () const
 {
   struct dwarf_gdbarch_types *types
-    = (struct dwarf_gdbarch_types *) gdbarch_data (ctx->gdbarch,
+    = (struct dwarf_gdbarch_types *) gdbarch_data (this->gdbarch,
 						   dwarf_arch_cookie);
   int ndx;
 
-  if (ctx->addr_size == 2)
+  if (this->addr_size == 2)
     ndx = 0;
-  else if (ctx->addr_size == 4)
+  else if (this->addr_size == 4)
     ndx = 1;
-  else if (ctx->addr_size == 8)
+  else if (this->addr_size == 8)
     ndx = 2;
   else
     error (_("Unsupported address size in DWARF expressions: %d bits"),
-	   8 * ctx->addr_size);
+	   8 * this->addr_size);
 
   if (types->dw_types[ndx] == NULL)
     types->dw_types[ndx]
-      = arch_integer_type (ctx->gdbarch,
-			   8 * ctx->addr_size,
+      = arch_integer_type (this->gdbarch,
+			   8 * this->addr_size,
 			   0, "<signed DWARF address type>");
 
   return types->dw_types[ndx];
@@ -122,28 +117,27 @@ dwarf_expr_context::~dwarf_expr_context ()
 /* Expand the memory allocated to CTX's stack to contain at least
    NEED more elements than are currently used.  */
 
-static void
-dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
+void
+dwarf_expr_context::grow_stack (size_t need)
 {
-  if (ctx->stack_len + need > ctx->stack_allocated)
+  if (this->stack_len + need > this->stack_allocated)
     {
-      size_t newlen = ctx->stack_len + need + 10;
+      size_t newlen = this->stack_len + need + 10;
 
-      ctx->stack = XRESIZEVEC (struct dwarf_stack_value, ctx->stack, newlen);
-      ctx->stack_allocated = newlen;
+      this->stack = XRESIZEVEC (struct dwarf_stack_value, this->stack, newlen);
+      this->stack_allocated = newlen;
     }
 }
 
 /* Push VALUE onto CTX's stack.  */
 
-static void
-dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
-		 int in_stack_memory)
+void
+dwarf_expr_context::push (struct value *value, int in_stack_memory)
 {
   struct dwarf_stack_value *v;
 
-  dwarf_expr_grow_stack (ctx, 1);
-  v = &ctx->stack[ctx->stack_len++];
+  grow_stack (1);
+  v = &this->stack[this->stack_len++];
   v->value = value;
   v->in_stack_memory = in_stack_memory;
 }
@@ -151,34 +145,31 @@ dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
 /* Push VALUE onto CTX's stack.  */
 
 void
-dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
-			 int in_stack_memory)
+dwarf_expr_context::push_address (CORE_ADDR value, int in_stack_memory)
 {
-  dwarf_expr_push (ctx,
-		   value_from_ulongest (dwarf_expr_address_type (ctx), value),
-		   in_stack_memory);
+  push (value_from_ulongest (address_type (), value), in_stack_memory);
 }
 
 /* Pop the top item off of CTX's stack.  */
 
-static void
-dwarf_expr_pop (struct dwarf_expr_context *ctx)
+void
+dwarf_expr_context::pop ()
 {
-  if (ctx->stack_len <= 0)
+  if (this->stack_len <= 0)
     error (_("dwarf expression stack underflow"));
-  ctx->stack_len--;
+  this->stack_len--;
 }
 
 /* Retrieve the N'th item on CTX's stack.  */
 
 struct value *
-dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
+dwarf_expr_context::fetch (int n)
 {
-  if (ctx->stack_len <= n)
+  if (this->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)].value;
+	    n, this->stack_len);
+  return this->stack[this->stack_len - (1 + n)].value;
 }
 
 /* Require that TYPE be an integral type; throw an exception if not.  */
@@ -239,10 +230,10 @@ get_signed_type (struct gdbarch *gdbarch, struct type *type)
 /* Retrieve the N'th item on CTX's stack, converted to an address.  */
 
 CORE_ADDR
-dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
+dwarf_expr_context::fetch_address (int n)
 {
-  struct value *result_val = dwarf_expr_fetch (ctx, n);
-  enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+  struct value *result_val = fetch (n);
+  enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch);
   ULONGEST result;
 
   dwarf_require_integral (value_type (result_val));
@@ -256,14 +247,14 @@ dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
      extract_unsigned_integer() will not produce a correct
      result.  Make sure we invoke gdbarch_integer_to_address()
      for those architectures which require it.  */
-  if (gdbarch_integer_to_address_p (ctx->gdbarch))
+  if (gdbarch_integer_to_address_p (this->gdbarch))
     {
-      gdb_byte *buf = (gdb_byte *) alloca (ctx->addr_size);
-      struct type *int_type = get_unsigned_type (ctx->gdbarch,
+      gdb_byte *buf = (gdb_byte *) alloca (this->addr_size);
+      struct type *int_type = get_unsigned_type (this->gdbarch,
 						 value_type (result_val));
 
-      store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
-      return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
+      store_unsigned_integer (buf, this->addr_size, byte_order, result);
+      return gdbarch_integer_to_address (this->gdbarch, int_type, buf);
     }
 
   return (CORE_ADDR) result;
@@ -272,68 +263,68 @@ dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
 /* 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)
+dwarf_expr_context::fetch_in_stack_memory (int n)
 {
-  if (ctx->stack_len <= n)
+  if (this->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;
+	    n, this->stack_len);
+  return this->stack[this->stack_len - (1 + n)].in_stack_memory;
 }
 
 /* Return true if the expression stack is empty.  */
 
-static int
-dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
+int
+dwarf_expr_context::stack_empty_p () const
 {
-  return ctx->stack_len == 0;
+  return this->stack_len == 0;
 }
 
-/* Add a new piece to CTX's piece list.  */
-static void
-add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
+/* Add a new piece to the dwarf_expr_context's piece list.  */
+void
+dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset)
 {
   struct dwarf_expr_piece *p;
 
-  ctx->num_pieces++;
+  this->num_pieces++;
 
-  ctx->pieces
-    = XRESIZEVEC (struct dwarf_expr_piece, ctx->pieces, ctx->num_pieces);
+  this->pieces
+    = XRESIZEVEC (struct dwarf_expr_piece, this->pieces, this->num_pieces);
 
-  p = &ctx->pieces[ctx->num_pieces - 1];
-  p->location = ctx->location;
+  p = &this->pieces[this->num_pieces - 1];
+  p->location = this->location;
   p->size = size;
   p->offset = offset;
 
   if (p->location == DWARF_VALUE_LITERAL)
     {
-      p->v.literal.data = ctx->data;
-      p->v.literal.length = ctx->len;
+      p->v.literal.data = this->data;
+      p->v.literal.length = this->len;
     }
-  else if (dwarf_expr_stack_empty_p (ctx))
+  else if (stack_empty_p ())
     {
       p->location = DWARF_VALUE_OPTIMIZED_OUT;
       /* Also reset the context's location, for our callers.  This is
 	 a somewhat strange approach, but this lets us avoid setting
 	 the location to DWARF_VALUE_MEMORY in all the individual
 	 cases in the evaluator.  */
-      ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
+      this->location = DWARF_VALUE_OPTIMIZED_OUT;
     }
   else if (p->location == DWARF_VALUE_MEMORY)
     {
-      p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
-      p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+      p->v.mem.addr = fetch_address (0);
+      p->v.mem.in_stack_memory = fetch_in_stack_memory (0);
     }
   else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
     {
-      p->v.ptr.die.sect_off = ctx->len;
-      p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
+      p->v.ptr.die.sect_off = this->len;
+      p->v.ptr.offset = value_as_long (fetch (0));
     }
   else if (p->location == DWARF_VALUE_REGISTER)
-    p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
+    p->v.regno = value_as_long (fetch (0));
   else
     {
-      p->v.value = dwarf_expr_fetch (ctx, 0);
+      p->v.value = fetch (0);
     }
 }
 
@@ -341,16 +332,15 @@ add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
    CTX.  */
 
 void
-dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
-		 size_t len)
+dwarf_expr_context::eval (const gdb_byte *addr, size_t len)
 {
-  int old_recursion_depth = ctx->recursion_depth;
+  int old_recursion_depth = this->recursion_depth;
 
-  execute_stack_op (ctx, addr, addr + len);
+  execute_stack_op (addr, addr + len);
 
   /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here.  */
 
-  gdb_assert (ctx->recursion_depth == old_recursion_depth);
+  gdb_assert (this->recursion_depth == old_recursion_depth);
 }
 
 /* Helper to read a uleb128 value or throw an error.  */
@@ -423,14 +413,14 @@ base_types_equal_p (struct type *t1, struct type *t2)
    this function should verify that the resulting type has the correct
    size.  */
 
-static struct type *
-dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
+struct type *
+dwarf_expr_context::get_base_type (cu_offset die, int size)
 {
   struct type *result;
 
-  if (ctx->funcs->get_base_type)
+  if (this->funcs->get_base_type)
     {
-      result = ctx->funcs->get_base_type (ctx, die);
+      result = this->funcs->get_base_type (this, die);
       if (result == NULL)
 	error (_("Could not find type for DW_OP_GNU_const_type"));
       if (size != 0 && TYPE_LENGTH (result) != size)
@@ -438,7 +428,7 @@ dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
     }
   else
     /* Anything will do.  */
-    result = builtin_type (ctx->gdbarch)->builtin_int;
+    result = builtin_type (this->gdbarch)->builtin_int;
 
   return result;
 }
@@ -613,14 +603,14 @@ dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
   return 1;
 }
 
-/* The engine for the expression evaluator.  Using the context in CTX,
-   evaluate the expression between OP_PTR and OP_END.  */
+/* The engine for the expression evaluator.  Using the context in this
+   object, evaluate the expression between OP_PTR and OP_END.  */
 
-static void
-execute_stack_op (struct dwarf_expr_context *ctx,
-		  const gdb_byte *op_ptr, const gdb_byte *op_end)
+void
+dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
+				      const gdb_byte *op_end)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch);
   /* Old-style "untyped" DWARF values need special treatment in a
      couple of places, specifically DW_OP_mod and DW_OP_shr.  We need
      a special type for these values so we can distinguish them from
@@ -628,15 +618,15 @@ execute_stack_op (struct dwarf_expr_context *ctx,
      values do not need special treatment.  This special type must be
      different (in the `==' sense) from any base type coming from the
      CU.  */
-  struct type *address_type = dwarf_expr_address_type (ctx);
+  struct type *address_type = this->address_type ();
 
-  ctx->location = DWARF_VALUE_MEMORY;
-  ctx->initialized = 1;  /* Default is initialized.  */
+  this->location = DWARF_VALUE_MEMORY;
+  this->initialized = 1;  /* Default is initialized.  */
 
-  if (ctx->recursion_depth > ctx->max_recursion_depth)
+  if (this->recursion_depth > this->max_recursion_depth)
     error (_("DWARF-2 expression error: Loop detected (%d)."),
-	   ctx->recursion_depth);
-  ctx->recursion_depth++;
+	   this->recursion_depth);
+  this->recursion_depth++;
 
   while (op_ptr < op_end)
     {
@@ -697,26 +687,26 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	case DW_OP_addr:
 	  result = extract_unsigned_integer (op_ptr,
-					     ctx->addr_size, byte_order);
-	  op_ptr += ctx->addr_size;
+					     this->addr_size, byte_order);
+	  op_ptr += this->addr_size;
 	  /* Some versions of GCC emit DW_OP_addr before
 	     DW_OP_GNU_push_tls_address.  In this case the value is an
 	     index, not an address.  We don't support things like
 	     branching between the address and the TLS op.  */
 	  if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
-	    result += ctx->offset;
+	    result += this->offset;
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 
 	case DW_OP_GNU_addr_index:
 	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
-	  result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
-	  result += ctx->offset;
+	  result = (this->funcs->get_addr_index) (this->baton, uoffset);
+	  result += this->offset;
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 	case DW_OP_GNU_const_index:
 	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
-	  result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
+	  result = (this->funcs->get_addr_index) (this->baton, uoffset);
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 
@@ -815,7 +805,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	  result = op - DW_OP_reg0;
 	  result_val = value_from_ulongest (address_type, result);
-	  ctx->location = DWARF_VALUE_REGISTER;
+	  this->location = DWARF_VALUE_REGISTER;
 	  break;
 
 	case DW_OP_regx:
@@ -824,7 +814,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	  result = reg;
 	  result_val = value_from_ulongest (address_type, result);
-	  ctx->location = DWARF_VALUE_REGISTER;
+	  this->location = DWARF_VALUE_REGISTER;
 	  break;
 
 	case DW_OP_implicit_value:
@@ -834,9 +824,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
 	    if (op_ptr + len > op_end)
 	      error (_("DW_OP_implicit_value: too few bytes available."));
-	    ctx->len = len;
-	    ctx->data = op_ptr;
-	    ctx->location = DWARF_VALUE_LITERAL;
+	    this->len = len;
+	    this->data = op_ptr;
+	    this->location = DWARF_VALUE_LITERAL;
 	    op_ptr += len;
 	    dwarf_expr_require_composition (op_ptr, op_end,
 					    "DW_OP_implicit_value");
@@ -844,7 +834,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  goto no_push;
 
 	case DW_OP_stack_value:
-	  ctx->location = DWARF_VALUE_STACK;
+	  this->location = DWARF_VALUE_STACK;
 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 	  goto no_push;
 
@@ -852,21 +842,21 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  {
 	    int64_t len;
 
-	    if (ctx->ref_addr_size == -1)
+	    if (this->ref_addr_size == -1)
 	      error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
 		       "is not allowed in frame context"));
 
 	    /* The referred-to DIE of sect_offset kind.  */
-	    ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
+	    this->len = extract_unsigned_integer (op_ptr, this->ref_addr_size,
 						 byte_order);
-	    op_ptr += ctx->ref_addr_size;
+	    op_ptr += this->ref_addr_size;
 
 	    /* The byte offset into the data.  */
 	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
 	    result = (ULONGEST) len;
 	    result_val = value_from_ulongest (address_type, result);
 
-	    ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
+	    this->location = DWARF_VALUE_IMPLICIT_POINTER;
 	    dwarf_expr_require_composition (op_ptr, op_end,
 					    "DW_OP_GNU_implicit_pointer");
 	  }
@@ -906,7 +896,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	case DW_OP_breg31:
 	  {
 	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
-	    result = (ctx->funcs->read_addr_from_reg) (ctx->baton,
+	    result = (this->funcs->read_addr_from_reg) (this->baton,
 						       op - DW_OP_breg0);
 	    result += offset;
 	    result_val = value_from_ulongest (address_type, result);
@@ -916,7 +906,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  {
 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
-	    result = (ctx->funcs->read_addr_from_reg) (ctx->baton, reg);
+	    result = (this->funcs->read_addr_from_reg) (this->baton, reg);
 	    result += offset;
 	    result_val = value_from_ulongest (address_type, result);
 	  }
@@ -932,78 +922,78 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	       record the stack length before execution, then reset it
 	       afterwards, effectively erasing whatever the recursive
 	       call put there.  */
-	    before_stack_len = ctx->stack_len;
+	    before_stack_len = this->stack_len;
 	    /* FIXME: cagney/2003-03-26: This code should be using
                get_frame_base_address(), and then implement a dwarf2
                specific this_base method.  */
-	    (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
-	    dwarf_expr_eval (ctx, datastart, datalen);
-	    if (ctx->location == DWARF_VALUE_MEMORY)
-	      result = dwarf_expr_fetch_address (ctx, 0);
-	    else if (ctx->location == DWARF_VALUE_REGISTER)
-	      result = (ctx->funcs->read_addr_from_reg)
-			  (ctx->baton,
-			   value_as_long (dwarf_expr_fetch (ctx, 0)));
+	    (this->funcs->get_frame_base) (this->baton, &datastart, &datalen);
+	    eval (datastart, datalen);
+	    if (this->location == DWARF_VALUE_MEMORY)
+	      result = fetch_address (0);
+	    else if (this->location == DWARF_VALUE_REGISTER)
+	      result = (this->funcs->read_addr_from_reg)
+			  (this->baton,
+			   value_as_long (fetch (0)));
 	    else
 	      error (_("Not implemented: computing frame "
 		       "base using explicit value operator"));
 	    result = result + offset;
 	    result_val = value_from_ulongest (address_type, result);
 	    in_stack_memory = 1;
-	    ctx->stack_len = before_stack_len;
-	    ctx->location = DWARF_VALUE_MEMORY;
+	    this->stack_len = before_stack_len;
+	    this->location = DWARF_VALUE_MEMORY;
 	  }
 	  break;
 
 	case DW_OP_dup:
-	  result_val = dwarf_expr_fetch (ctx, 0);
-	  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+	  result_val = fetch (0);
+	  in_stack_memory = fetch_in_stack_memory (0);
 	  break;
 
 	case DW_OP_drop:
-	  dwarf_expr_pop (ctx);
+	  pop ();
 	  goto no_push;
 
 	case DW_OP_pick:
 	  offset = *op_ptr++;
-	  result_val = dwarf_expr_fetch (ctx, offset);
-	  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
+	  result_val = fetch (offset);
+	  in_stack_memory = fetch_in_stack_memory (offset);
 	  break;
 	  
 	case DW_OP_swap:
 	  {
 	    struct dwarf_stack_value t1, t2;
 
-	    if (ctx->stack_len < 2)
+	    if (this->stack_len < 2)
 	       error (_("Not enough elements for "
 			"DW_OP_swap.  Need 2, have %d."),
-		      ctx->stack_len);
-	    t1 = ctx->stack[ctx->stack_len - 1];
-	    t2 = ctx->stack[ctx->stack_len - 2];
-	    ctx->stack[ctx->stack_len - 1] = t2;
-	    ctx->stack[ctx->stack_len - 2] = t1;
+		      this->stack_len);
+	    t1 = this->stack[this->stack_len - 1];
+	    t2 = this->stack[this->stack_len - 2];
+	    this->stack[this->stack_len - 1] = t2;
+	    this->stack[this->stack_len - 2] = t1;
 	    goto no_push;
 	  }
 
 	case DW_OP_over:
-	  result_val = dwarf_expr_fetch (ctx, 1);
-	  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
+	  result_val = fetch (1);
+	  in_stack_memory = fetch_in_stack_memory (1);
 	  break;
 
 	case DW_OP_rot:
 	  {
 	    struct dwarf_stack_value t1, t2, t3;
 
-	    if (ctx->stack_len < 3)
+	    if (this->stack_len < 3)
 	       error (_("Not enough elements for "
 			"DW_OP_rot.  Need 3, have %d."),
-		      ctx->stack_len);
-	    t1 = ctx->stack[ctx->stack_len - 1];
-	    t2 = ctx->stack[ctx->stack_len - 2];
-	    t3 = ctx->stack[ctx->stack_len - 3];
-	    ctx->stack[ctx->stack_len - 1] = t2;
-	    ctx->stack[ctx->stack_len - 2] = t3;
-	    ctx->stack[ctx->stack_len - 3] = t1;
+		      this->stack_len);
+	    t1 = this->stack[this->stack_len - 1];
+	    t2 = this->stack[this->stack_len - 2];
+	    t3 = this->stack[this->stack_len - 3];
+	    this->stack[this->stack_len - 1] = t2;
+	    this->stack[this->stack_len - 2] = t3;
+	    this->stack[this->stack_len - 3] = t1;
 	    goto no_push;
 	  }
 
@@ -1011,12 +1001,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	case DW_OP_deref_size:
 	case DW_OP_GNU_deref_type:
 	  {
-	    int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
+	    int addr_size = (op == DW_OP_deref ? this->addr_size : *op_ptr++);
 	    gdb_byte *buf = (gdb_byte *) alloca (addr_size);
-	    CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
+	    CORE_ADDR addr = fetch_address (0);
 	    struct type *type;
 
-	    dwarf_expr_pop (ctx);
+	    pop ();
 
 	    if (op == DW_OP_GNU_deref_type)
 	      {
@@ -1024,12 +1014,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 		op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 		type_die.cu_off = uoffset;
-		type = dwarf_get_base_type (ctx, type_die, 0);
+		type = get_base_type (type_die, 0);
 	      }
 	    else
 	      type = address_type;
 
-	    (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
+	    (this->funcs->read_mem) (this->baton, buf, addr, addr_size);
 
 	    /* If the size of the object read from memory is different
 	       from the type length, we need to zero-extend it.  */
@@ -1053,8 +1043,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	case DW_OP_plus_uconst:
 	  {
 	    /* Unary operations.  */
-	    result_val = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
+	    result_val = fetch (0);
+	    pop ();
 
 	    switch (op)
 	      {
@@ -1102,11 +1092,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    /* Binary operations.  */
 	    struct value *first, *second;
 
-	    second = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
+	    second = fetch (0);
+	    pop ();
 
-	    first = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
+	    first = fetch (0);
+	    pop ();
 
 	    if (! base_types_equal_p (value_type (first), value_type (second)))
 	      error (_("Incompatible types on DWARF stack"));
@@ -1135,7 +1125,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 		  if (orig_type == address_type)
 		    {
 		      struct type *utype
-			= get_unsigned_type (ctx->gdbarch, orig_type);
+			= get_unsigned_type (this->gdbarch, orig_type);
 
 		      cast_back = 1;
 		      first = value_cast (utype, first);
@@ -1170,7 +1160,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 		if (!TYPE_UNSIGNED (value_type (first)))
 		  {
 		    struct type *utype
-		      = get_unsigned_type (ctx->gdbarch, value_type (first));
+		      = get_unsigned_type (this->gdbarch, value_type (first));
 
 		    first = value_cast (utype, first);
 		  }
@@ -1187,7 +1177,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 		if (TYPE_UNSIGNED (value_type (first)))
 		  {
 		    struct type *stype
-		      = get_signed_type (ctx->gdbarch, value_type (first));
+		      = get_signed_type (this->gdbarch, value_type (first));
 
 		    first = value_cast (stype, first);
 		  }
@@ -1238,7 +1228,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  break;
 
 	case DW_OP_call_frame_cfa:
-	  result = (ctx->funcs->get_frame_cfa) (ctx->baton);
+	  result = (this->funcs->get_frame_cfa) (this->baton);
 	  result_val = value_from_ulongest (address_type, result);
 	  in_stack_memory = 1;
 	  break;
@@ -1253,9 +1243,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  control block at which the variable is located.  Nothing
 	  should follow this operator, so the top of stack would be
 	  returned.  */
-	  result = value_as_long (dwarf_expr_fetch (ctx, 0));
-	  dwarf_expr_pop (ctx);
-	  result = (ctx->funcs->get_tls_address) (ctx->baton, result);
+	  result = value_as_long (fetch (0));
+	  pop ();
+	  result = (this->funcs->get_tls_address) (this->baton, result);
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 
@@ -1271,11 +1261,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	    offset = extract_signed_integer (op_ptr, 2, byte_order);
 	    op_ptr += 2;
-	    val = dwarf_expr_fetch (ctx, 0);
+	    val = fetch (0);
 	    dwarf_require_integral (value_type (val));
 	    if (value_as_long (val) != 0)
 	      op_ptr += offset;
-	    dwarf_expr_pop (ctx);
+	    pop ();
 	  }
 	  goto no_push;
 
@@ -1288,14 +1278,14 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
             /* Record the piece.  */
             op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
-	    add_piece (ctx, 8 * size, 0);
+	    add_piece (8 * size, 0);
 
             /* Pop off the address/regnum, and reset the location
 	       type.  */
-	    if (ctx->location != DWARF_VALUE_LITERAL
-		&& ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
-	      dwarf_expr_pop (ctx);
-            ctx->location = DWARF_VALUE_MEMORY;
+	    if (this->location != DWARF_VALUE_LITERAL
+		&& this->location != DWARF_VALUE_OPTIMIZED_OUT)
+	      pop ();
+            this->location = DWARF_VALUE_MEMORY;
           }
           goto no_push;
 
@@ -1306,14 +1296,14 @@ execute_stack_op (struct dwarf_expr_context *ctx,
             /* Record the piece.  */
 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
-	    add_piece (ctx, size, offset);
+	    add_piece (size, offset);
 
             /* Pop off the address/regnum, and reset the location
 	       type.  */
-	    if (ctx->location != DWARF_VALUE_LITERAL
-		&& ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
-	      dwarf_expr_pop (ctx);
-            ctx->location = DWARF_VALUE_MEMORY;
+	    if (this->location != DWARF_VALUE_LITERAL
+		&& this->location != DWARF_VALUE_OPTIMIZED_OUT)
+	      pop ();
+            this->location = DWARF_VALUE_MEMORY;
 	  }
 	  goto no_push;
 
@@ -1322,7 +1312,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
 		   "be the very last op."));
 
-	  ctx->initialized = 0;
+	  this->initialized = 0;
 	  goto no_push;
 
 	case DW_OP_call2:
@@ -1331,7 +1321,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	    offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
 	    op_ptr += 2;
-	    ctx->funcs->dwarf_call (ctx, offset);
+	    this->funcs->dwarf_call (this, offset);
 	  }
 	  goto no_push;
 
@@ -1341,7 +1331,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	    offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
 	    op_ptr += 4;
-	    ctx->funcs->dwarf_call (ctx, offset);
+	    this->funcs->dwarf_call (this, offset);
 	  }
 	  goto no_push;
 	
@@ -1359,7 +1349,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    if (kind_u.dwarf_reg != -1)
 	      {
 		op_ptr += len;
-		ctx->funcs->push_dwarf_reg_entry_value (ctx,
+		this->funcs->push_dwarf_reg_entry_value (this,
 						  CALL_SITE_PARAMETER_DWARF_REG,
 							kind_u,
 							-1 /* deref_size */);
@@ -1372,9 +1362,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    if (kind_u.dwarf_reg != -1)
 	      {
 		if (deref_size == -1)
-		  deref_size = ctx->addr_size;
+		  deref_size = this->addr_size;
 		op_ptr += len;
-		ctx->funcs->push_dwarf_reg_entry_value (ctx,
+		this->funcs->push_dwarf_reg_entry_value (this,
 						  CALL_SITE_PARAMETER_DWARF_REG,
 							kind_u, deref_size);
 		goto no_push;
@@ -1392,7 +1382,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
 								   byte_order);
 	    op_ptr += 4;
-	    ctx->funcs->push_dwarf_reg_entry_value (ctx,
+	    this->funcs->push_dwarf_reg_entry_value (this,
 					       CALL_SITE_PARAMETER_PARAM_OFFSET,
 						    kind_u,
 						    -1 /* deref_size */);
@@ -1412,7 +1402,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    data = op_ptr;
 	    op_ptr += n;
 
-	    type = dwarf_get_base_type (ctx, type_die, n);
+	    type = get_base_type (type_die, n);
 	    result_val = value_from_contents (type, data);
 	  }
 	  break;
@@ -1426,8 +1416,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	    type_die.cu_off = uoffset;
 
-	    type = dwarf_get_base_type (ctx, type_die, 0);
-	    result_val = ctx->funcs->get_reg_value (ctx->baton, type, reg);
+	    type = get_base_type (type_die, 0);
+	    result_val = this->funcs->get_reg_value (this->baton, type, reg);
 	  }
 	  break;
 
@@ -1443,10 +1433,10 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    if (type_die.cu_off == 0)
 	      type = address_type;
 	    else
-	      type = dwarf_get_base_type (ctx, type_die, 0);
+	      type = get_base_type (type_die, 0);
 
-	    result_val = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
+	    result_val = fetch (0);
+	    pop ();
 
 	    if (op == DW_OP_GNU_convert)
 	      result_val = value_cast (type, result_val);
@@ -1466,7 +1456,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	case DW_OP_push_object_address:
 	  /* Return the address of the object we are currently observing.  */
-	  result = (ctx->funcs->get_object_address) (ctx->baton);
+	  result = (this->funcs->get_object_address) (this->baton);
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 
@@ -1476,7 +1466,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
       /* Most things push a result value.  */
       gdb_assert (result_val != NULL);
-      dwarf_expr_push (ctx, result_val, in_stack_memory);
+      push (result_val, in_stack_memory);
     no_push:
       ;
     }
@@ -1484,12 +1474,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
   /* To simplify our main caller, if the result is an implicit
      pointer, then make a pieced value.  This is ok because we can't
      have implicit pointers in contexts where pieces are invalid.  */
-  if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
-    add_piece (ctx, 8 * ctx->addr_size, 0);
+  if (this->location == DWARF_VALUE_IMPLICIT_POINTER)
+    add_piece (8 * this->addr_size, 0);
 
 abort_expression:
-  ctx->recursion_depth--;
-  gdb_assert (ctx->recursion_depth >= 0);
+  this->recursion_depth--;
+  gdb_assert (this->recursion_depth >= 0);
 }
 
 /* Stub dwarf_expr_context_funcs.get_frame_base implementation.  */
diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 0f94f1e..4706bb3 100644
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -133,6 +133,12 @@ struct dwarf_expr_context
   dwarf_expr_context ();
   ~dwarf_expr_context ();
 
+  void push_address (CORE_ADDR value, int in_stack_memory);
+  void eval (const gdb_byte *addr, size_t len);
+  struct value *fetch (int n);
+  CORE_ADDR fetch_address (int n);
+  int fetch_in_stack_memory (int n);
+
   /* The stack of values, allocated with xmalloc.  */
   struct dwarf_stack_value *stack;
 
@@ -203,6 +209,17 @@ struct dwarf_expr_context
      two cases need to be handled separately.)  */
   int num_pieces;
   struct dwarf_expr_piece *pieces;
+
+private:
+
+  struct type *address_type () const;
+  void grow_stack (size_t need);
+  void push (struct value *value, int in_stack_memory);
+  int stack_empty_p () const;
+  void add_piece (ULONGEST size, ULONGEST offset);
+  struct type *get_base_type (cu_offset die, int size);
+  void execute_stack_op (const gdb_byte *op_ptr, const gdb_byte *op_end);
+  void pop ();
 };
 
 
@@ -253,15 +270,6 @@ struct dwarf_expr_piece
   ULONGEST offset;
 };
 
-void dwarf_expr_push_address (struct dwarf_expr_context *ctx,
-			      CORE_ADDR value,
-			      int in_stack_memory);
-void dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
-		      size_t len);
-struct value *dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
-CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
-int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
-
 void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
 				     const char *);
 
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 066f55b..d6ffd85 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -561,7 +561,7 @@ per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
   /* DW_OP_call_ref is currently not supported.  */
   gdb_assert (block.per_cu == per_cu);
 
-  dwarf_expr_eval (ctx, block.data, block.size);
+  ctx->eval (block.data, block.size);
 }
 
 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc.  */
@@ -1300,7 +1300,7 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
   ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
   ctx->baton = &baton_local;
 
-  dwarf_expr_eval (ctx, data_src, size);
+  ctx->eval (data_src, size);
 
   ctx->gdbarch = saved_ctx.gdbarch;
   ctx->addr_size = saved_ctx.addr_size;
@@ -2319,7 +2319,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
 
   TRY
     {
-      dwarf_expr_eval (&ctx, data, size);
+      ctx.eval (data, size);
     }
   CATCH (ex, RETURN_MASK_ERROR)
     {
@@ -2371,7 +2371,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
 	  {
 	    struct gdbarch *arch = get_frame_arch (frame);
 	    int dwarf_regnum
-	      = longest_to_int (value_as_long (dwarf_expr_fetch (&ctx, 0)));
+	      = longest_to_int (value_as_long (ctx.fetch (0)));
 	    int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum);
 
 	    if (byte_offset != 0)
@@ -2399,8 +2399,8 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
 	case DWARF_VALUE_MEMORY:
 	  {
 	    struct type *ptr_type;
-	    CORE_ADDR address = dwarf_expr_fetch_address (&ctx, 0);
-	    int in_stack_memory = dwarf_expr_fetch_in_stack_memory (&ctx, 0);
+	    CORE_ADDR address = ctx.fetch_address (0);
+	    int in_stack_memory = ctx.fetch_in_stack_memory (0);
 
 	    /* DW_OP_deref_size (and possibly other operations too) may
 	       create a pointer instead of an address.  Ideally, the
@@ -2431,7 +2431,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
 
 	case DWARF_VALUE_STACK:
 	  {
-	    struct value *value = dwarf_expr_fetch (&ctx, 0);
+	    struct value *value = ctx.fetch (0);
 	    gdb_byte *contents;
 	    const gdb_byte *val_bytes;
 	    size_t n = TYPE_LENGTH (value_type (value));
@@ -2559,14 +2559,14 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
   ctx.funcs = &dwarf_expr_ctx_funcs;
   ctx.baton = &baton;
 
-  dwarf_expr_eval (&ctx, dlbaton->data, dlbaton->size);
+  ctx.eval (dlbaton->data, dlbaton->size);
 
   switch (ctx.location)
     {
     case DWARF_VALUE_REGISTER:
     case DWARF_VALUE_MEMORY:
     case DWARF_VALUE_STACK:
-      *valp = dwarf_expr_fetch_address (&ctx, 0);
+      *valp = ctx.fetch_address (0);
       if (ctx.location == DWARF_VALUE_REGISTER)
 	*valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
       return 1;
@@ -2809,7 +2809,7 @@ needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
   nf_baton->needs = SYMBOL_NEEDS_FRAME;
 
   /* The expression may require some stub values on DWARF stack.  */
-  dwarf_expr_push_address (ctx, 0, 0);
+  ctx->push_address (0, 0);
 }
 
 /* DW_OP_GNU_addr_index doesn't require a frame.  */
@@ -2874,7 +2874,7 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size,
   ctx.baton = &baton;
   ctx.funcs = &symbol_needs_ctx_funcs;
 
-  dwarf_expr_eval (&ctx, data, size);
+  ctx.eval (data, size);
 
   in_reg = ctx.location == DWARF_VALUE_REGISTER;
 
