gdb/ChangeLog:

2004-08-25  Jim Blandy  <jimb@redhat.com>

	Merge changes from trunk:

	2004-08-09  Jim Blandy  <jimb@redhat.com>

	* rs6000-tdep.c (set_sim_regno, init_sim_regno_table,
	rs6000_register_sim_regno): Doc fixes.

	2004-08-04  Jim Blandy  <jimb@redhat.com>

	* ppc-linux-nat.c (fetch_register): Replace 'gdb_assert (0)' with
	a call to 'internal_error', with a more helpful error message.
	* rs6000-tdep.c (e500_pseudo_register_read,
	e500_pseudo_register_write, rs6000_store_return_value): Same.

	Change the layout of the PowerPC E500 raw register cache to allow
	the lower 32-bit halves of the GPRS to be their own raw registers,
	not pseudoregisters.
	* ppc-tdep.h (struct gdbarch_tdep): Remove ppc_gprs_pseudo_p flag;
	add ppc_ev0_upper_regnum flag.
	* rs6000-tdep.c: #include "reggroups.h".
	(spe_register_p): Recognize the ev upper half registers as SPE
	registers.
	(init_sim_regno_table): Build gdb->sim mappings for the upper-half
	registers.
	(e500_move_ev_register): New function.
	(e500_pseudo_register_read, e500_pseudo_register_write): The 'ev'
	vector registers are the pseudo-registers now, formed by splicing
	together the gprs and the upper-half registers.
	(e500_register_reggroup_p): New function.
	(P): Macro deleted.
	(P8, A4): New macro.
	(PPC_EV_REGS, PPC_GPRS_PSEUDO_REGS): Macros deleted.
	(PPC_SPE_GP_REGS, PPC_SPE_UPPER_GP_REGS, PPC_EV_PSEUDO_REGS): New
	macros.
	(registers_e500): Rearrange register set so that the raw register
	set contains 32-bit GPRs and upper-half registers, and the SPE
	vector registers become pseudo-registers.
	(rs6000_gdbarch_init): Don't initialize tdep->ppc_gprs_pseudo_p;
	it has been deleted.  Initialize ppc_ev0_upper_regnum.  Many other
	register numbers are now the same for the E500 as they are for
	other PowerPC variants.  Register e500_register_reggroup_p as the
	register group function for the E500.
	* Makefile.in (rs6000-tdep.o): Update dependencies.

	Adapt PPC E500 native support to the new raw regcache layout.
	* ppc-linux-nat.c (struct gdb_evrregset_t): Doc fixes.
	(read_spliced_spe_reg, write_spliced_spe_reg): Deleted.
	(fetch_spe_register, store_spe_register): Handle fetching/storing
	all the SPE registers at once, if regno == -1.  These now take
	over the job of fetch_spe_registers and store_spe_registers.
	(fetch_spe_registers, store_spe_registers): Deleted.
	(fetch_ppc_registers, store_ppc_registers): Fetch/store gprs
	unconditionally; they're always raw.  Fetch/store SPE upper half
	registers, if present, instead of ev registers.
	(fetch_register, store_register): Remove sanity checks: gprs are
	never pseudo-registers now, so we never need to even mention any
	registers that are ever pseudoregisters.

	Use a fixed register numbering when communicating with the PowerPC
	simulator.
	* ppc-tdep.h (struct gdbarch_tdep): New member: 'sim_regno'.
	* rs6000-tdep.c: #include "sim-regno.h" and "gdb/sim-ppc.h".
	(set_sim_regno, init_sim_regno_table, rs6000_register_sim_regno):
	New functions.
	(rs6000_gdbarch_init): Register rs6000_register_sim_regno.  Call
	init_sim_regno_table.
	* Makefile.in (gdb_sim_ppc_h): New variable.
	(rs6000-tdep.o): Update dependencies.

	2004-08-02  Andrew Cagney  <cagney@gnu.org>

	Replace DEPRECATED_REGISTER_RAW_SIZE with register_size.
	* rs6000-tdep.c (rs6000_push_dummy_call)
	(rs6000_extract_return_value): Use register_size.
	...
	* ppc-linux-nat.c (fetch_altivec_register, fetch_register)
	(supply_vrregset, store_altivec_register, fill_vrregset): Ditto.

	2004-07-20  Jim Blandy  <jimb@redhat.com>

	* rs6000-tdep.c (rs6000_gdbarch_init): The register set used for
	bfd_mach_ppc has no segment registers.

	Include PowerPC SPR numbers for special-purpose registers.
	* rs6000-tdep.c (struct reg): Add new member, 'spr_num'.
	(R, R4, R8, R16, F, P, R32, R64, R0): Include value for
	new member in initializer.
	(S, S4, SN4, S64): New macros for defining special-purpose
	registers.
	(PPC_UISA_SPRS, PPC_UISA_NOFP_SPRS, PPC_OEA_SPRS, registers_power,
	registers_403, registers_403GC, registers_505, registers_860,
	registers_601, registers_602, registers_603, registers_604,
	registers_750, registers_e500): Use them.

	* rs6000-tdep.c (rs6000_gdbarch_init): Delete variable 'power';
	replace references with expression used to initialize variable.

	2004-07-16  Jim Blandy  <jimb@redhat.com>

	* ppc-tdep.h (ppc_spr_asr): Add missing OEA SPR.
        (ppc_spr_mi_dbcam, ppc_spr_mi_dbram0, ppc_spr_mi_dbram1)
	(ppc_spr_md_cam, ppc_spr_md_ram0, ppc_spr_md_ram1): Add
	missing MPC823 SPRs.
	(ppc_spr_m_twb): Renamed from ppc_spr_md_twb; the old name was
	incorrect.  (This was corrected in GDB's register name tables on
	2004-07-14.)

	* rs6000-tdep.c (registers_602): Correct register name: "esassr"
	should be "esasrr" ("ESA Save and Restore Register").

	2004-07-15  Jim Blandy  <jimb@redhat.com>

	* ppc-tdep.h (struct gdbarch_tdep): New member: ppc_sr0_regnum.
	* rs6000-tdep.c (rs6000_gdbarch_init): Initialize it.

	2004-07-14  Jim Blandy  <jimb@redhat.com>

	* rs6000-tdep.c (COMMON_UISA_NOFP_REGS): Delete; unused.

	* ppc-tdep.h (ppc_num_vrs): New enum constant.

	* ppc-tdep.h (ppc_num_srs): New enum constant.

	* ppc-tdep.h (ppc_spr_mq, ppc_spr_xer, ppc_spr_rtcu, ppc_spr_rtcl)
	(ppc_spr_lr, ppc_spr_ctr, ppc_spr_cnt, ppc_spr_dsisr, ppc_spr_dar)
	(ppc_spr_dec, ppc_spr_sdr1, ppc_spr_srr0, ppc_spr_srr1)
	(ppc_spr_eie, ppc_spr_eid, ppc_spr_nri, ppc_spr_sp, ppc_spr_cmpa)
	(ppc_spr_cmpb, ppc_spr_cmpc, ppc_spr_cmpd, ppc_spr_icr)
	(ppc_spr_der, ppc_spr_counta, ppc_spr_countb, ppc_spr_cmpe)
	(ppc_spr_cmpf, ppc_spr_cmpg, ppc_spr_cmph, ppc_spr_lctrl1)
	(ppc_spr_lctrl2, ppc_spr_ictrl, ppc_spr_bar, ppc_spr_vrsave)
	(ppc_spr_sprg0, ppc_spr_sprg1, ppc_spr_sprg2, ppc_spr_sprg3)
	(ppc_spr_ear, ppc_spr_tbl, ppc_spr_tbu, ppc_spr_pvr)
	(ppc_spr_spefscr, ppc_spr_ibat0u, ppc_spr_ibat0l, ppc_spr_ibat1u)
	(ppc_spr_ibat1l, ppc_spr_ibat2u, ppc_spr_ibat2l, ppc_spr_ibat3u)
	(ppc_spr_ibat3l, ppc_spr_dbat0u, ppc_spr_dbat0l, ppc_spr_dbat1u)
	(ppc_spr_dbat1l, ppc_spr_dbat2u, ppc_spr_dbat2l, ppc_spr_dbat3u)
	(ppc_spr_dbat3l, ppc_spr_ic_cst, ppc_spr_ic_adr, ppc_spr_ic_dat)
	(ppc_spr_dc_cst, ppc_spr_dc_adr, ppc_spr_dc_dat, ppc_spr_dpdr)
	(ppc_spr_dpir, ppc_spr_immr, ppc_spr_mi_ctr, ppc_spr_mi_ap)
	(ppc_spr_mi_epn, ppc_spr_mi_twc, ppc_spr_mi_rpn, ppc_spr_mi_cam)
	(ppc_spr_mi_ram0, ppc_spr_mi_ram1, ppc_spr_md_ctr, ppc_spr_m_casid)
	(ppc_spr_md_ap, ppc_spr_md_epn, ppc_spr_md_twb, ppc_spr_md_twc)
	(ppc_spr_md_rpn, ppc_spr_m_tw, ppc_spr_md_dbcam, ppc_spr_md_dbram0)
	(ppc_spr_md_dbram1, ppc_spr_ummcr0, ppc_spr_upmc1, ppc_spr_upmc2)
	(ppc_spr_usia, ppc_spr_ummcr1, ppc_spr_upmc3, ppc_spr_upmc4)
	(ppc_spr_zpr, ppc_spr_pid, ppc_spr_mmcr0, ppc_spr_pmc1)
	(ppc_spr_sgr, ppc_spr_pmc2, ppc_spr_dcwr, ppc_spr_sia)
	(ppc_spr_mmcr1, ppc_spr_pmc3, ppc_spr_pmc4, ppc_spr_sda)
	(ppc_spr_tbhu, ppc_spr_tblu, ppc_spr_dmiss, ppc_spr_dcmp)
	(ppc_spr_hash1, ppc_spr_hash2, ppc_spr_icdbdr, ppc_spr_imiss)
	(ppc_spr_esr, ppc_spr_icmp, ppc_spr_dear, ppc_spr_rpa)
	(ppc_spr_evpr, ppc_spr_cdbcr, ppc_spr_tsr, ppc_spr_602_tcr)
	(ppc_spr_403_tcr, ppc_spr_ibr, ppc_spr_pit, ppc_spr_esasrr)
	(ppc_spr_tbhi, ppc_spr_tblo, ppc_spr_srr2, ppc_spr_sebr)
	(ppc_spr_srr3, ppc_spr_ser, ppc_spr_hid0, ppc_spr_dbsr)
	(ppc_spr_hid1, ppc_spr_iabr, ppc_spr_dbcr, ppc_spr_iac1)
	(ppc_spr_dabr, ppc_spr_iac2, ppc_spr_dac1, ppc_spr_dac2)
	(ppc_spr_l2cr, ppc_spr_dccr, ppc_spr_ictc, ppc_spr_iccr)
	(ppc_spr_thrm1, ppc_spr_pbl1, ppc_spr_thrm2, ppc_spr_pbu1)
	(ppc_spr_thrm3, ppc_spr_pbl2, ppc_spr_fpecr, ppc_spr_lt)
	(ppc_spr_pir, ppc_spr_pbu2): New enum constants for PowerPC
	special-purpose register numbers.

	* rs6000-tdep.c (registers_860): Correct register name.  (No PPC
	manual mentions 'md_twb', but many mention 'm_twb', and at that
	point in the register list.)

include/gdb/ChangeLog:
2004-08-04  Andrew Cagney  <cagney@gnu.org>

	* sim-ppc.h: Add extern "C" wrapper.
	(enum sim_ppc_regnum): Add full list of SPRs.

2004-08-04  Jim Blandy  <jimb@redhat.com>

	* sim-ppc.h: New file.

sim/ppc/ChangeLog:
2004-08-04  Andrew Cagney  <cagney@gnu.org>
	    Jim Blandy <jimb@redhat.com>

	* sim_callbacks.h (simulator): Declare.
	* Makefile.in (gdb-sim.o): New rule.
	(MAIN_SRC, GDB_OBJ): Add gdb-sim.o, gdb-sim.c.
	(DEFS_H): Delete.
	(GDB_SIM_PPC_H): Define.
	* gdb-sim.c: New file.
	* sim_calls.c: Do not include "defs.h".
	(simulator): Drop static.
	(sim_store_register, sim_fetch_register): Delete.

1 files changed, 0 insertions, 672 deletions

diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
deleted file mode 100644
index 294afa06c63..00000000000
--- a/gdb/dwarf2expr.c
+++ /dev/null
@@ -1,672 +0,0 @@
-/* Dwarf2 Expression Evaluator
-   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
-   Contributed by Daniel Berlin (dan@dberlin.org)
-
-   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 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "symtab.h"
-#include "gdbtypes.h"
-#include "value.h"
-#include "gdbcore.h"
-#include "elf/dwarf2.h"
-#include "dwarf2expr.h"
-
-/* Local prototypes.  */
-
-static void execute_stack_op (struct dwarf_expr_context *,
-			      unsigned char *, unsigned char *);
-
-/* Create a new context for the expression evaluator.  */
-
-struct dwarf_expr_context *
-new_dwarf_expr_context (void)
-{
-  struct dwarf_expr_context *retval;
-  retval = xcalloc (1, sizeof (struct dwarf_expr_context));
-  retval->stack_len = 0;
-  retval->stack_allocated = 10;
-  retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
-  return retval;
-}
-
-/* Release the memory allocated to CTX.  */
-
-void
-free_dwarf_expr_context (struct dwarf_expr_context *ctx)
-{
-  xfree (ctx->stack);
-  xfree (ctx);
-}
-
-/* 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)
-{
-  if (ctx->stack_len + need > ctx->stack_allocated)
-    {
-      size_t newlen = ctx->stack_len + need + 10;
-      ctx->stack = xrealloc (ctx->stack,
-			     newlen * sizeof (CORE_ADDR));
-      ctx->stack_allocated = newlen;
-    }
-}
-
-/* Push VALUE onto CTX's stack.  */
-
-void
-dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
-{
-  dwarf_expr_grow_stack (ctx, 1);
-  ctx->stack[ctx->stack_len++] = value;
-}
-
-/* Pop the top item off of CTX's stack.  */
-
-void
-dwarf_expr_pop (struct dwarf_expr_context *ctx)
-{
-  if (ctx->stack_len <= 0)
-    error ("dwarf expression stack underflow");
-  ctx->stack_len--;
-}
-
-/* Retrieve the N'th item on CTX's stack.  */
-
-CORE_ADDR
-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",
-	    n, ctx->stack_len);
-  return ctx->stack[ctx->stack_len - (1 + n)];
-
-}
-
-/* Evaluate the expression at ADDR (LEN bytes long) using the context
-   CTX.  */
-
-void
-dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
-		 size_t len)
-{
-  execute_stack_op (ctx, addr, addr + len);
-}
-
-/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
-   by R, and return the new value of BUF.  Verify that it doesn't extend
-   past BUF_END.  */
-
-unsigned char *
-read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
-{
-  unsigned shift = 0;
-  ULONGEST result = 0;
-  unsigned char byte;
-
-  while (1)
-    {
-      if (buf >= buf_end)
-	error ("read_uleb128: Corrupted DWARF expression.");
-
-      byte = *buf++;
-      result |= (byte & 0x7f) << shift;
-      if ((byte & 0x80) == 0)
-	break;
-      shift += 7;
-    }
-  *r = result;
-  return buf;
-}
-
-/* Decode the signed LEB128 constant at BUF into the variable pointed to
-   by R, and return the new value of BUF.  Verify that it doesn't extend
-   past BUF_END.  */
-
-unsigned char *
-read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
-{
-  unsigned shift = 0;
-  LONGEST result = 0;
-  unsigned char byte;
-
-  while (1)
-    {
-      if (buf >= buf_end)
-	error ("read_sleb128: Corrupted DWARF expression.");
-
-      byte = *buf++;
-      result |= (byte & 0x7f) << shift;
-      shift += 7;
-      if ((byte & 0x80) == 0)
-	break;
-    }
-  if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
-    result |= -(1 << shift);
-
-  *r = result;
-  return buf;
-}
-
-/* Read an address from BUF, and verify that it doesn't extend past
-   BUF_END.  The address is returned, and *BYTES_READ is set to the
-   number of bytes read from BUF.  */
-
-CORE_ADDR
-dwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
-{
-  CORE_ADDR result;
-
-  if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
-    error ("dwarf2_read_address: Corrupted DWARF expression.");
-
-  *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
-  /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
-     address is always unsigned.  That may or may not be true.  */
-  result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
-  return result;
-}
-
-/* Return the type of an address, for unsigned arithmetic.  */
-
-static struct type *
-unsigned_address_type (void)
-{
-  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
-    {
-    case 2:
-      return builtin_type_uint16;
-    case 4:
-      return builtin_type_uint32;
-    case 8:
-      return builtin_type_uint64;
-    default:
-      internal_error (__FILE__, __LINE__,
-		      "Unsupported address size.\n");
-    }
-}
-
-/* Return the type of an address, for signed arithmetic.  */
-
-static struct type *
-signed_address_type (void)
-{
-  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
-    {
-    case 2:
-      return builtin_type_int16;
-    case 4:
-      return builtin_type_int32;
-    case 8:
-      return builtin_type_int64;
-    default:
-      internal_error (__FILE__, __LINE__,
-		      "Unsupported address size.\n");
-    }
-}
-
-/* The engine for the expression evaluator.  Using the context in CTX,
-   evaluate the expression between OP_PTR and OP_END.  */
-
-static void
-execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
-		  unsigned char *op_end)
-{
-  ctx->in_reg = 0;
-
-  while (op_ptr < op_end)
-    {
-      enum dwarf_location_atom op = *op_ptr++;
-      CORE_ADDR result;
-      ULONGEST uoffset, reg;
-      LONGEST offset;
-      int bytes_read;
-
-      switch (op)
-	{
-	case DW_OP_lit0:
-	case DW_OP_lit1:
-	case DW_OP_lit2:
-	case DW_OP_lit3:
-	case DW_OP_lit4:
-	case DW_OP_lit5:
-	case DW_OP_lit6:
-	case DW_OP_lit7:
-	case DW_OP_lit8:
-	case DW_OP_lit9:
-	case DW_OP_lit10:
-	case DW_OP_lit11:
-	case DW_OP_lit12:
-	case DW_OP_lit13:
-	case DW_OP_lit14:
-	case DW_OP_lit15:
-	case DW_OP_lit16:
-	case DW_OP_lit17:
-	case DW_OP_lit18:
-	case DW_OP_lit19:
-	case DW_OP_lit20:
-	case DW_OP_lit21:
-	case DW_OP_lit22:
-	case DW_OP_lit23:
-	case DW_OP_lit24:
-	case DW_OP_lit25:
-	case DW_OP_lit26:
-	case DW_OP_lit27:
-	case DW_OP_lit28:
-	case DW_OP_lit29:
-	case DW_OP_lit30:
-	case DW_OP_lit31:
-	  result = op - DW_OP_lit0;
-	  break;
-
-	case DW_OP_addr:
-	  result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
-	  op_ptr += bytes_read;
-	  break;
-
-	case DW_OP_const1u:
-	  result = extract_unsigned_integer (op_ptr, 1);
-	  op_ptr += 1;
-	  break;
-	case DW_OP_const1s:
-	  result = extract_signed_integer (op_ptr, 1);
-	  op_ptr += 1;
-	  break;
-	case DW_OP_const2u:
-	  result = extract_unsigned_integer (op_ptr, 2);
-	  op_ptr += 2;
-	  break;
-	case DW_OP_const2s:
-	  result = extract_signed_integer (op_ptr, 2);
-	  op_ptr += 2;
-	  break;
-	case DW_OP_const4u:
-	  result = extract_unsigned_integer (op_ptr, 4);
-	  op_ptr += 4;
-	  break;
-	case DW_OP_const4s:
-	  result = extract_signed_integer (op_ptr, 4);
-	  op_ptr += 4;
-	  break;
-	case DW_OP_const8u:
-	  result = extract_unsigned_integer (op_ptr, 8);
-	  op_ptr += 8;
-	  break;
-	case DW_OP_const8s:
-	  result = extract_signed_integer (op_ptr, 8);
-	  op_ptr += 8;
-	  break;
-	case DW_OP_constu:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
-	  result = uoffset;
-	  break;
-	case DW_OP_consts:
-	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
-	  result = offset;
-	  break;
-
-	/* The DW_OP_reg operations are required to occur alone in
-	   location expressions.  */
-	case DW_OP_reg0:
-	case DW_OP_reg1:
-	case DW_OP_reg2:
-	case DW_OP_reg3:
-	case DW_OP_reg4:
-	case DW_OP_reg5:
-	case DW_OP_reg6:
-	case DW_OP_reg7:
-	case DW_OP_reg8:
-	case DW_OP_reg9:
-	case DW_OP_reg10:
-	case DW_OP_reg11:
-	case DW_OP_reg12:
-	case DW_OP_reg13:
-	case DW_OP_reg14:
-	case DW_OP_reg15:
-	case DW_OP_reg16:
-	case DW_OP_reg17:
-	case DW_OP_reg18:
-	case DW_OP_reg19:
-	case DW_OP_reg20:
-	case DW_OP_reg21:
-	case DW_OP_reg22:
-	case DW_OP_reg23:
-	case DW_OP_reg24:
-	case DW_OP_reg25:
-	case DW_OP_reg26:
-	case DW_OP_reg27:
-	case DW_OP_reg28:
-	case DW_OP_reg29:
-	case DW_OP_reg30:
-	case DW_OP_reg31:
-	  if (op_ptr != op_end && *op_ptr != DW_OP_piece)
-	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
-		   "used either alone or in conjuction with DW_OP_piece.");
-
-	  result = op - DW_OP_reg0;
-	  ctx->in_reg = 1;
-
-	  break;
-
-	case DW_OP_regx:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	  if (op_ptr != op_end && *op_ptr != DW_OP_piece)
-	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
-		   "used either alone or in conjuction with DW_OP_piece.");
-
-	  result = reg;
-	  ctx->in_reg = 1;
-	  break;
-
-	case DW_OP_breg0:
-	case DW_OP_breg1:
-	case DW_OP_breg2:
-	case DW_OP_breg3:
-	case DW_OP_breg4:
-	case DW_OP_breg5:
-	case DW_OP_breg6:
-	case DW_OP_breg7:
-	case DW_OP_breg8:
-	case DW_OP_breg9:
-	case DW_OP_breg10:
-	case DW_OP_breg11:
-	case DW_OP_breg12:
-	case DW_OP_breg13:
-	case DW_OP_breg14:
-	case DW_OP_breg15:
-	case DW_OP_breg16:
-	case DW_OP_breg17:
-	case DW_OP_breg18:
-	case DW_OP_breg19:
-	case DW_OP_breg20:
-	case DW_OP_breg21:
-	case DW_OP_breg22:
-	case DW_OP_breg23:
-	case DW_OP_breg24:
-	case DW_OP_breg25:
-	case DW_OP_breg26:
-	case DW_OP_breg27:
-	case DW_OP_breg28:
-	case DW_OP_breg29:
-	case DW_OP_breg30:
-	case DW_OP_breg31:
-	  {
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
-	    result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
-	    result += offset;
-	  }
-	  break;
-	case DW_OP_bregx:
-	  {
-	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
-	    result = (ctx->read_reg) (ctx->baton, reg);
-	    result += offset;
-	  }
-	  break;
-	case DW_OP_fbreg:
-	  {
-	    unsigned char *datastart;
-	    size_t datalen;
-	    unsigned int before_stack_len;
-
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
-	    /* Rather than create a whole new context, we simply
-	       record the stack length before execution, then reset it
-	       afterwards, effectively erasing whatever the recursive
-	       call put there.  */
-	    before_stack_len = ctx->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->get_frame_base) (ctx->baton, &datastart, &datalen);
-	    dwarf_expr_eval (ctx, datastart, datalen);
-	    result = dwarf_expr_fetch (ctx, 0);
-	    if (ctx->in_reg)
-	      result = (ctx->read_reg) (ctx->baton, result);
-	    result = result + offset;
-	    ctx->stack_len = before_stack_len;
-	    ctx->in_reg = 0;
-	  }
-	  break;
-	case DW_OP_dup:
-	  result = dwarf_expr_fetch (ctx, 0);
-	  break;
-
-	case DW_OP_drop:
-	  dwarf_expr_pop (ctx);
-	  goto no_push;
-
-	case DW_OP_pick:
-	  offset = *op_ptr++;
-	  result = dwarf_expr_fetch (ctx, offset);
-	  break;
-
-	case DW_OP_over:
-	  result = dwarf_expr_fetch (ctx, 1);
-	  break;
-
-	case DW_OP_rot:
-	  {
-	    CORE_ADDR t1, t2, t3;
-
-	    if (ctx->stack_len < 3)
-	       error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
-		      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;
-	    goto no_push;
-	  }
-
-	case DW_OP_deref:
-	case DW_OP_deref_size:
-	case DW_OP_abs:
-	case DW_OP_neg:
-	case DW_OP_not:
-	case DW_OP_plus_uconst:
-	  /* Unary operations.  */
-	  result = dwarf_expr_fetch (ctx, 0);
-	  dwarf_expr_pop (ctx);
-
-	  switch (op)
-	    {
-	    case DW_OP_deref:
-	      {
-		char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
-		int bytes_read;
-
-		(ctx->read_mem) (ctx->baton, buf, result,
-				 TARGET_ADDR_BIT / TARGET_CHAR_BIT);
-		result = dwarf2_read_address (buf,
-					      buf + (TARGET_ADDR_BIT
-						     / TARGET_CHAR_BIT),
-					      &bytes_read);
-	      }
-	      break;
-
-	    case DW_OP_deref_size:
-	      {
-		char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
-		int bytes_read;
-
-		(ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
-		result = dwarf2_read_address (buf,
-					      buf + (TARGET_ADDR_BIT
-						     / TARGET_CHAR_BIT),
-					      &bytes_read);
-	      }
-	      break;
-
-	    case DW_OP_abs:
-	      if ((signed int) result < 0)
-		result = -result;
-	      break;
-	    case DW_OP_neg:
-	      result = -result;
-	      break;
-	    case DW_OP_not:
-	      result = ~result;
-	      break;
-	    case DW_OP_plus_uconst:
-	      op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	      result += reg;
-	      break;
-	    }
-	  break;
-
-	case DW_OP_and:
-	case DW_OP_div:
-	case DW_OP_minus:
-	case DW_OP_mod:
-	case DW_OP_mul:
-	case DW_OP_or:
-	case DW_OP_plus:
-	case DW_OP_shl:
-	case DW_OP_shr:
-	case DW_OP_shra:
-	case DW_OP_xor:
-	case DW_OP_le:
-	case DW_OP_ge:
-	case DW_OP_eq:
-	case DW_OP_lt:
-	case DW_OP_gt:
-	case DW_OP_ne:
-	  {
-	    /* Binary operations.  Use the value engine to do computations in
-	       the right width.  */
-	    CORE_ADDR first, second;
-	    enum exp_opcode binop;
-	    struct value *val1, *val2;
-
-	    second = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
-
-	    first = dwarf_expr_fetch (ctx, 0);
-	    dwarf_expr_pop (ctx);
-
-	    val1 = value_from_longest (unsigned_address_type (), first);
-	    val2 = value_from_longest (unsigned_address_type (), second);
-
-	    switch (op)
-	      {
-	      case DW_OP_and:
-		binop = BINOP_BITWISE_AND;
-		break;
-	      case DW_OP_div:
-		binop = BINOP_DIV;
-                break;
-	      case DW_OP_minus:
-		binop = BINOP_SUB;
-		break;
-	      case DW_OP_mod:
-		binop = BINOP_MOD;
-		break;
-	      case DW_OP_mul:
-		binop = BINOP_MUL;
-		break;
-	      case DW_OP_or:
-		binop = BINOP_BITWISE_IOR;
-		break;
-	      case DW_OP_plus:
-		binop = BINOP_ADD;
-		break;
-	      case DW_OP_shl:
-		binop = BINOP_LSH;
-		break;
-	      case DW_OP_shr:
-		binop = BINOP_RSH;
-                break;
-	      case DW_OP_shra:
-		binop = BINOP_RSH;
-		val1 = value_from_longest (signed_address_type (), first);
-		break;
-	      case DW_OP_xor:
-		binop = BINOP_BITWISE_XOR;
-		break;
-	      case DW_OP_le:
-		binop = BINOP_LEQ;
-		break;
-	      case DW_OP_ge:
-		binop = BINOP_GEQ;
-		break;
-	      case DW_OP_eq:
-		binop = BINOP_EQUAL;
-		break;
-	      case DW_OP_lt:
-		binop = BINOP_LESS;
-		break;
-	      case DW_OP_gt:
-		binop = BINOP_GTR;
-		break;
-	      case DW_OP_ne:
-		binop = BINOP_NOTEQUAL;
-		break;
-	      default:
-		internal_error (__FILE__, __LINE__,
-				"Can't be reached.");
-	      }
-	    result = value_as_long (value_binop (val1, val2, binop));
-	  }
-	  break;
-
-	case DW_OP_GNU_push_tls_address:
-	  /* Variable is at a constant offset in the thread-local
-	  storage block into the objfile for the current thread and
-	  the dynamic linker module containing this expression. Here
-	  we return returns the offset from that base.  The top of the
-	  stack has the offset from the beginning of the thread
-	  control block at which the variable is located.  Nothing
-	  should follow this operator, so the top of stack would be
-	  returned.  */
-	  result = dwarf_expr_fetch (ctx, 0);
-	  dwarf_expr_pop (ctx);
-	  result = (ctx->get_tls_address) (ctx->baton, result);
-	  break;
-
-	case DW_OP_skip:
-	  offset = extract_signed_integer (op_ptr, 2);
-	  op_ptr += 2;
-	  op_ptr += offset;
-	  goto no_push;
-
-	case DW_OP_bra:
-	  offset = extract_signed_integer (op_ptr, 2);
-	  op_ptr += 2;
-	  if (dwarf_expr_fetch (ctx, 0) != 0)
-	    op_ptr += offset;
-	  dwarf_expr_pop (ctx);
-	  goto no_push;
-
-	case DW_OP_nop:
-	  goto no_push;
-
-	default:
-	  error ("Unhandled dwarf expression opcode 0x%x", op);
-	}
-
-      /* Most things push a result value.  */
-      dwarf_expr_push (ctx, result);
-    no_push:;
-    }
-}