Initial creation of sourceware repositorygdb-4_18-branchpoint

1 files changed, 452 insertions, 0 deletions

diff --git a/gdb/pyr-tdep.c b/gdb/pyr-tdep.c
new file mode 100644
index 0000000..85e9a07
--- /dev/null
+++ b/gdb/pyr-tdep.c
@@ -0,0 +1,452 @@
+/* Pyramid target-dependent code for GDB.
+   Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+
+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"
+
+/*** Prettier register printing. ***/
+
+/* Print registers in the same format as pyramid's dbx, adb, sdb.  */
+pyr_print_registers(reg_buf, regnum)
+    long *reg_buf[];
+{
+  register int regno;
+  int usp, ksp;
+  struct user u;
+
+  for (regno = 0; regno < 16; regno++) {
+    printf_unfiltered/*_filtered*/ ("%6.6s: %8x  %6.6s: %8x  %6s: %8x  %6s: %8x\n",
+		     REGISTER_NAME (regno), reg_buf[regno],
+		     REGISTER_NAME (regno+16), reg_buf[regno+16],
+		     REGISTER_NAME (regno+32), reg_buf[regno+32],
+		     REGISTER_NAME (regno+48), reg_buf[regno+48]);
+  }
+  usp = ptrace (3, inferior_pid,
+		(PTRACE_ARG3_TYPE) ((char *)&u.u_pcb.pcb_usp) -
+		((char *)&u), 0);
+  ksp = ptrace (3, inferior_pid,
+		(PTRACE_ARG3_TYPE) ((char *)&u.u_pcb.pcb_ksp) -
+		((char *)&u), 0);
+  printf_unfiltered/*_filtered*/ ("\n%6.6s: %8x  %6.6s: %8x (%08x) %6.6s %8x\n",
+		   REGISTER_NAME (CSP_REGNUM),reg_buf[CSP_REGNUM],
+		   REGISTER_NAME (KSP_REGNUM), reg_buf[KSP_REGNUM], ksp,
+		   "usp", usp);
+}
+
+/* Print the register regnum, or all registers if regnum is -1.
+   fpregs is currently ignored.  */
+
+pyr_do_registers_info (regnum, fpregs)
+    int regnum;
+    int fpregs;
+{
+  /* On a pyr, we know a virtual register can always fit in an long.
+     Here (and elsewhere) we take advantage of that.  Yuk.  */
+  long raw_regs[MAX_REGISTER_RAW_SIZE*NUM_REGS];
+  register int i;
+  
+  for (i = 0 ; i < 64 ; i++) {
+    read_relative_register_raw_bytes(i, raw_regs+i);
+  }
+  if (regnum == -1)
+    pyr_print_registers (raw_regs, regnum);
+  else
+    for (i = 0; i < NUM_REGS; i++)
+      if (i == regnum) {
+	long val = raw_regs[i];
+	
+	fputs_filtered (REGISTER_NAME (i), gdb_stdout);
+	printf_filtered(":");
+	print_spaces_filtered (6 - strlen (REGISTER_NAME (i)), gdb_stdout);
+	if (val == 0)
+	  printf_filtered ("0");
+	else
+	  printf_filtered ("%s  %d", local_hex_string_custom(val,"08"), val);
+	printf_filtered("\n");
+      }
+}
+
+/*** Debugging editions of various macros from m-pyr.h ****/
+
+CORE_ADDR frame_locals_address (frame)
+    struct frame_info *frame;
+{
+  register int addr = find_saved_register (frame,CFP_REGNUM);
+  register int result = read_memory_integer (addr, 4);
+#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING
+  fprintf_unfiltered (gdb_stderr,
+	   "\t[[..frame_locals:%8x, %s= %x @%x fcfp= %x foo= %x\n\t gr13=%x pr13=%x tr13=%x @%x]]\n",
+	   frame->frame,
+	   REGISTER_NAME (CFP_REGNUM),
+	   result, addr,
+	   frame->frame_cfp, (CFP_REGNUM),
+
+
+	   read_register(13), read_register(29), read_register(61),
+	   find_saved_register(frame, 61));
+#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
+
+  /* FIXME: I thought read_register (CFP_REGNUM) should be the right answer;
+     or at least CFP_REGNUM relative to FRAME (ie, result).
+     There seems to be a bug in the way the innermost frame is set up.  */
+
+    return ((frame->next) ? result: frame->frame_cfp);
+}
+
+CORE_ADDR frame_args_addr (frame)
+    struct frame_info *frame;
+{
+  register int addr = find_saved_register (frame,CFP_REGNUM);
+  register int result = read_memory_integer (addr, 4);
+
+#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING
+  fprintf_unfiltered (gdb_stderr,
+	   "\t[[..frame_args:%8x, %s= %x @%x fcfp= %x r_r= %x\n\t gr13=%x pr13=%x tr13=%x @%x]]\n",
+	   frame->frame,
+	   REGISTER_NAME (CFP_REGNUM),
+	   result, addr,
+	   frame->frame_cfp, read_register(CFP_REGNUM),
+
+	   read_register(13), read_register(29), read_register(61),
+	   find_saved_register(frame, 61));
+#endif /*  PYRAMID_CONTROL_FRAME_DEBUGGING */
+
+  /* FIXME: I thought read_register (CFP_REGNUM) should be the right answer;
+     or at least CFP_REGNUM relative to FRAME (ie, result).
+     There seems to be a bug in the way the innermost frame is set up.  */
+    return ((frame->next) ? result: frame->frame_cfp);
+}
+
+#include "symtab.h"
+#include "opcode/pyr.h"
+#include "gdbcore.h"
+
+
+/*  A couple of functions used for debugging frame-handling on
+    Pyramids. (The Pyramid-dependent handling of register values for
+    windowed registers is known to be buggy.)
+
+    When debugging, these functions can supplant the normal definitions of some
+    of the macros in tm-pyramid.h  The quantity of information produced
+    when these functions are used makes the gdb  unusable as a
+    debugger for user programs.  */
+    
+extern unsigned pyr_saved_pc(), pyr_frame_chain();
+
+CORE_ADDR pyr_frame_chain(frame)
+    CORE_ADDR frame;
+{
+    int foo=frame - CONTROL_STACK_FRAME_SIZE;
+    /* printf_unfiltered ("...following chain from %x: got %x\n", frame, foo);*/
+    return foo;
+}
+
+CORE_ADDR pyr_saved_pc(frame)
+    CORE_ADDR frame;
+{
+    int foo=0;
+    foo = read_memory_integer (((CORE_ADDR)(frame))+60, 4);
+    printf_unfiltered ("..reading pc from frame 0x%0x+%d regs: got %0x\n",
+	    frame, 60/4, foo);
+    return foo;
+}
+
+/* Pyramid instructions are never longer than this many bytes.  */
+#define MAXLEN 24
+
+/* Number of elements in the opcode table.  */
+/*const*/ static int nopcodes = (sizeof (pyr_opcodes) / sizeof( pyr_opcodes[0]));
+#define NOPCODES (nopcodes)
+
+/* Let's be byte-independent so we can use this as a cross-assembler.  */
+
+#define NEXTLONG(p)  \
+  (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
+
+/* Print one instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+pyr_print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     GDB_FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  register int i, nargs, insn_size =4;
+  register unsigned char *p;
+  register char *d;
+  register int insn_opcode, operand_mode;
+  register int index_multiplier, index_reg_regno, op_1_regno, op_2_regno ;
+  long insn;			/* first word of the insn, not broken down. */
+  pyr_insn_format insn_decode;	/* the same, broken out into op{code,erands} */
+  long extra_1, extra_2;
+
+  read_memory (memaddr, buffer, MAXLEN);
+  insn_decode = *((pyr_insn_format *) buffer);
+  insn = * ((int *) buffer);
+  insn_opcode = insn_decode.operator;
+  operand_mode = insn_decode.mode;
+  index_multiplier = insn_decode.index_scale;
+  index_reg_regno = insn_decode.index_reg;
+  op_1_regno = insn_decode.operand_1;
+  op_2_regno = insn_decode.operand_2;
+  
+  
+  if (*((int *)buffer) == 0x0) {
+    /* "halt" looks just like an invalid "jump" to the insn decoder,
+       so is dealt with as a special case */
+    fprintf_unfiltered (stream, "halt");
+    return (4);
+  }
+
+  for (i = 0; i < NOPCODES; i++)
+	  if (pyr_opcodes[i].datum.code == insn_opcode)
+		  break;
+
+  if (i == NOPCODES)
+	  /* FIXME: Handle unrecognised instructions better.  */
+	  fprintf_unfiltered (stream, "???\t#%08x\t(op=%x mode =%x)",
+		   insn, insn_decode.operator, insn_decode.mode);
+  else
+    {
+      /* Print the mnemonic for the instruction.  Pyramid insn operands
+         are so regular that we can deal with almost all of them
+         separately.
+	 Unconditional branches are an exception: they are encoded as
+	 conditional branches (branch if false condition, I think)
+	 with no condition specified. The average user will not be
+	 aware of this. To maintain their illusion that an
+	 unconditional branch insn exists, we will have to FIXME to
+	 treat the insn mnemnonic of all branch instructions here as a
+	 special case: check the operands of branch insn and print an
+	 appropriate mnemonic. */ 
+
+      fprintf_unfiltered (stream, "%s\t", pyr_opcodes[i].name);
+
+    /* Print the operands of the insn (as specified in
+       insn.operand_mode). 
+       Branch operands of branches are a special case: they are a word
+       offset, not a byte offset. */
+  
+    if (insn_decode.operator == 0x01 || insn_decode.operator == 0x02) {
+      register int bit_codes=(insn >> 16)&0xf;
+      register int i;
+      register int displacement = (insn & 0x0000ffff) << 2;
+
+      static char cc_bit_names[] = "cvzn";	/* z,n,c,v: strange order? */
+
+      /* Is bfc and no bits specified an unconditional branch?*/
+      for (i=0;i<4;i++) {
+	if ((bit_codes) & 0x1)
+		fputc_unfiltered (cc_bit_names[i], stream);
+	bit_codes >>= 1;
+      }
+
+      fprintf_unfiltered (stream, ",%0x",
+	       displacement + memaddr);
+      return (insn_size);
+    }
+
+      switch (operand_mode) {
+      case 0:
+	fprintf_unfiltered (stream, "%s,%s",
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno));
+	break;
+	    
+      case 1:
+	fprintf_unfiltered (stream, " 0x%0x,%s",
+		 op_1_regno,
+		 REGISTER_NAME (op_2_regno));
+	break;
+	
+      case 2:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream, " $0x%0x,%s",
+		 extra_1,
+		 REGISTER_NAME (op_2_regno));
+	break;
+      case 3:
+	fprintf_unfiltered (stream, " (%s),%s",
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno));
+	break;
+	
+      case 4:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream, " 0x%0x(%s),%s",
+		 extra_1,
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno));
+	break;
+	
+	/* S1 destination mode */
+      case 5:
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? "%s,(%s)[%s*%1d]" : "%s,(%s)"),
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      case 6:
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? " $%#0x,(%s)[%s*%1d]"
+		  : " $%#0x,(%s)"),
+		 op_1_regno,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      case 7:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? " $%#0x,(%s)[%s*%1d]"
+		  : " $%#0x,(%s)"),
+		 extra_1,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      case 8:
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? " (%s),(%s)[%s*%1d]" : " (%s),(%s)"),
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      case 9:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno)
+		  ? "%#0x(%s),(%s)[%s*%1d]"
+		  : "%#0x(%s),(%s)"),
+		 extra_1,
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+	/* S2 destination mode */
+      case 10:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? "%s,%#0x(%s)[%s*%1d]" : "%s,%#0x(%s)"),
+		 REGISTER_NAME (op_1_regno),
+		 extra_1,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+      case 11:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ?
+		  " $%#0x,%#0x(%s)[%s*%1d]" : " $%#0x,%#0x(%s)"),
+		 op_1_regno,
+		 extra_1,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+      case 12:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	read_memory (memaddr+8, buffer, MAXLEN);
+	insn_size += 4;
+	extra_2 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ?
+		  " $%#0x,%#0x(%s)[%s*%1d]" : " $%#0x,%#0x(%s)"),
+		 extra_1,
+		 extra_2,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      case 13:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno)
+		  ? " (%s),%#0x(%s)[%s*%1d]" 
+		  : " (%s),%#0x(%s)"),
+		 REGISTER_NAME (op_1_regno),
+		 extra_1,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+      case 14:
+	read_memory (memaddr+4, buffer, MAXLEN);
+	insn_size += 4;
+	extra_1 = * ((int *) buffer);
+	read_memory (memaddr+8, buffer, MAXLEN);
+	insn_size += 4;
+	extra_2 = * ((int *) buffer);
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? "%#0x(%s),%#0x(%s)[%s*%1d]"
+		  : "%#0x(%s),%#0x(%s) "),
+		 extra_1,
+		 REGISTER_NAME (op_1_regno),
+		 extra_2,
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	break;
+	
+      default:
+	fprintf_unfiltered (stream,
+		 ((index_reg_regno) ? "%s,%s [%s*%1d]" : "%s,%s"),
+		 REGISTER_NAME (op_1_regno),
+		 REGISTER_NAME (op_2_regno),
+		 REGISTER_NAME (index_reg_regno),
+		 index_multiplier);
+	fprintf_unfiltered (stream,
+		 "\t\t# unknown mode in %08x",
+		 insn);
+	break;
+      } /* switch */
+    }
+  
+  {
+    return insn_size;
+  }
+  abort ();
+}