Initial revision

1 files changed, 563 insertions, 0 deletions

diff --git a/gdb/target.c b/gdb/target.c
new file mode 100644
index 0000000000..a58d0cd5c8
--- /dev/null
+++ b/gdb/target.c
@@ -0,0 +1,563 @@
+/* Select target systems and architectures at runtime for GDB.
+   Copyright (C) 1990 Free Software Foundation, Inc.
+   Contributed by Cygnus Support.
+
+This file is part of GDB.
+
+GDB 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 1, or (at your option)
+any later version.
+
+GDB 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 GDB; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.h>
+#include "defs.h"
+#include "target.h"
+#include "gdbcmd.h"
+#include "symtab.h"
+#include "inferior.h"
+#include "bfd.h"
+#include "symfile.h"
+
+extern int memory_insert_breakpoint(), memory_remove_breakpoint();
+extern void host_convert_to_virtual(), host_convert_from_virtual();
+
+static void cleanup_target ();
+
+/* Pointer to array of target architecture structures; the size of the
+   array; the current index into the array; the allocated size of the 
+   array.  */
+struct target_ops **target_structs;
+unsigned target_struct_size;
+unsigned target_struct_index;
+unsigned target_struct_allocsize;
+#define	DEFAULT_ALLOCSIZE	10
+
+/* The initial current target, so that there is always a semi-valid
+   current target.  */
+
+struct target_ops dummy_target = {"None", "None",
+    0, 0, 0, 0,		/* open, close, attach, detach */
+    0, 0,		/* resume, wait */
+    0, 0, 0, 0, 0,	/* registers */
+    0, 0, 		/* memory */
+    0, 0, 		/* bkpts */
+    0, 0, 0, 0, 0, 	/* terminal */
+    0, 0, 0,		/* kill, load, add_syms */
+    0, 0, 		/* call_function, lookup_symbol */
+    0, 0,		/* create_inferior, mourn_inferior */
+    dummy_stratum, 0,	/* stratum, next */
+    0, 0, 0, 0, 0,	/* all mem, mem, stack, regs, exec */
+    OPS_MAGIC,
+};
+
+/* The target structure we are currently using to talk to a process
+   or file or whatever "inferior" we have.  */
+
+struct target_ops *current_target;
+
+/* The stack of target structures that have been pushed.  */
+
+struct target_ops **current_target_stack;
+
+
+/* Add a possible target architecture to the list.  */
+
+void
+add_target (t)
+     struct target_ops *t;
+{
+  if (t->to_magic != OPS_MAGIC)
+    {
+      fprintf(stderr, "Magic number of %s target struct wrong\n", 
+	t->to_shortname);
+      abort();
+    }
+
+  if (!target_structs)
+    {
+      target_struct_allocsize = DEFAULT_ALLOCSIZE;
+      target_structs = (struct target_ops **) xmalloc
+	(target_struct_allocsize * sizeof (*target_structs));
+    }
+  if (target_struct_size >= target_struct_allocsize)
+    {
+      target_struct_allocsize *= 2;
+      target_structs = (struct target_ops **) xrealloc (target_structs, 
+	target_struct_allocsize * sizeof (*target_structs));
+    }
+  target_structs[target_struct_size++] = t;
+  cleanup_target (t);
+}
+
+/* Stub functions */
+
+static void
+ignore ()
+{
+}
+
+/* ARGSUSED */
+static int
+nomemory (memaddr, myaddr, len, write)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+     int write;
+{
+  return 0;		/* No bytes handled */
+}
+
+static void
+tcomplain ()
+{
+  error ("You can't do that when your target is `%s'",
+	 current_target->to_shortname);
+}
+
+static int
+noprocess ()
+{
+  error ("You can't do that without a process to debug");
+}
+
+static int
+nosymbol (name, addrp)
+     char *name;
+     CORE_ADDR *addrp;
+{
+  return 1;		/* Symbol does not exist in target env */
+}
+
+static void
+default_terminal_info (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  printf("No saved terminal information.\n");
+}
+
+#if 0
+/* With strata, this function is no longer needed.  FIXME.  */
+/* This is the default target_create_inferior function.  It looks up
+   the stack for some target that cares to create inferiors, then
+   calls it -- or complains if not found.  */
+
+static void
+upstack_create_inferior (exec, args, env)
+     char *exec;
+     char *args;
+     char **env;
+{
+  struct target_ops *t;
+
+  for (t = current_target;
+       t;
+       t = t->to_next)
+    {
+      if (t->to_create_inferior != upstack_create_inferior)
+	{
+          t->to_create_inferior (exec, args, env);
+	  return;
+	}
+
+    }
+  tcomplain();
+}
+#endif
+
+/* This is the default target_create_inferior and target_attach function.
+   If the current target is executing, it asks whether to kill it off.
+   If this function returns without calling error(), it has killed off
+   the target, and the operation should be attempted.  */
+
+static void
+kill_or_be_killed (from_tty)
+     int from_tty;
+{
+  struct target_ops *savecur;
+
+  if (target_has_execution)
+    {
+      printf ("You are already running a program:\n");
+      target_files_info ();
+      if (query ("Kill it? ")) {
+	savecur = current_target;
+	target_kill (0, from_tty);
+	if (target_has_execution)
+	  error ("Killing the program did not help.");
+	return;
+      } else {
+	error ("Program not killed.");
+      }
+    }
+  tcomplain();
+}
+
+static void
+maybe_kill_then_attach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  kill_or_be_killed (from_tty);
+  target_attach (args, from_tty);
+}
+
+static void
+maybe_kill_then_create_inferior (exec, args, env)
+     char *exec;
+     char *args;
+     char **env;
+{
+  kill_or_be_killed (0);
+  target_create_inferior (exec, args, env);
+}
+
+/* Clean up a target struct so it no longer has any zero pointers in it.
+   We default entries, at least to stubs that print error messages.  */
+
+static void
+cleanup_target (t)
+     struct target_ops *t;
+{
+
+  /* Check magic number.  If wrong, it probably means someone changed
+     the struct definition, but not all the places that initialize one.  */
+  if (t->to_magic != OPS_MAGIC)
+    {
+      fprintf(stderr, "Magic number of %s target struct wrong\n", 
+	t->to_shortname);
+      abort();
+    }
+
+#define de_fault(field, value) \
+  if (!t->field)	t->field = value
+
+  /*        FIELD			DEFAULT VALUE        */
+
+  de_fault (to_open, 			tcomplain);
+  de_fault (to_close, 			(void (*)())ignore);
+  de_fault (to_attach, 			maybe_kill_then_attach);
+  de_fault (to_detach, 			(void (*)())ignore);
+  de_fault (to_resume, 			(void (*)())noprocess);
+  de_fault (to_wait, 			noprocess);
+  de_fault (to_fetch_registers, 	noprocess);
+  de_fault (to_store_registers,		noprocess);
+  de_fault (to_prepare_to_store,	(void (*)())noprocess);
+  de_fault (to_convert_to_virtual,	host_convert_to_virtual);
+  de_fault (to_convert_from_virtual,	host_convert_from_virtual);
+  de_fault (to_xfer_memory,		nomemory);
+  de_fault (to_files_info,		ignore);
+  de_fault (to_insert_breakpoint,	memory_insert_breakpoint);
+  de_fault (to_remove_breakpoint,	memory_remove_breakpoint);
+  de_fault (to_terminal_init,		ignore);
+  de_fault (to_terminal_inferior,	ignore);
+  de_fault (to_terminal_ours_for_output,ignore);
+  de_fault (to_terminal_ours,		ignore);
+  de_fault (to_terminal_info,		default_terminal_info);
+  de_fault (to_kill,			(void (*)())noprocess);
+  de_fault (to_load,			tcomplain);
+  de_fault (to_add_syms,		tcomplain);
+  de_fault (to_call_function,		(struct value *(*)())noprocess);
+  de_fault (to_lookup_symbol,		nosymbol);
+  de_fault (to_create_inferior,		maybe_kill_then_create_inferior);
+  de_fault (to_mourn_inferior,		(void (*)())noprocess);
+  de_fault (to_next,			0);
+  de_fault (to_has_all_memory,		0);
+  de_fault (to_has_memory,		0);
+  de_fault (to_has_stack,		0);
+  de_fault (to_has_registers,		0);
+  de_fault (to_has_execution,		0);
+
+#undef de_fault
+}
+
+/* Push a new target type into the stack of the existing target accessors,
+   possibly superseding some of the existing accessors.
+
+   Result is zero if the pushed target ended up on top of the stack,
+   nonzero if at least one target is on top of it.
+
+   Rather than allow an empty stack, we always have the dummy target at
+   the bottom stratum, so we can call the function vectors without
+   checking them.  */
+
+int
+push_target (t)
+     struct target_ops *t;
+{
+  struct target_ops *st, *prev;
+
+  for (prev = 0, st = current_target;
+       st;
+       prev = st, st = st->to_next) {
+    if ((int)(t->to_stratum) >= (int)(st->to_stratum))
+      break;
+  }
+
+  while (t->to_stratum == st->to_stratum) {
+    /* There's already something on this stratum.  Close it off.  */
+    (st->to_close) (0);
+    if (prev)
+      prev->to_next = st->to_next;	/* Unchain old target_ops */
+    else
+      current_target = st->to_next;	/* Unchain first on list */
+    st = st->to_next;
+  }
+
+  /* We have removed all targets in our stratum, now add ourself.  */
+  t->to_next = st;
+  if (prev)
+    prev->to_next = t;
+  else
+    current_target = t;
+
+  cleanup_target (current_target);
+  return prev != 0;
+}
+
+/* Remove a target_ops vector from the stack, wherever it may be. 
+   Return how many times it was removed (0 or 1 unless bug).  */
+
+int
+unpush_target (t)
+     struct target_ops *t;
+{
+  struct target_ops *u, *v;
+  int result = 0;
+
+  for (u = current_target, v = 0;
+       u;
+       v = u, u = u->to_next)
+    if (u == t)
+      {
+	if (v == 0)
+	  pop_target();			/* unchain top copy */
+	else {
+	  (t->to_close)(0);		/* Let it clean up */
+	  v->to_next = t->to_next;	/* unchain middle copy */
+	}
+	result++;
+      }
+  return result;
+}
+
+void
+pop_target ()
+{
+  (current_target->to_close)(0);	/* Let it clean up */
+  current_target = current_target->to_next;
+  if (!current_target)		/* At bottom, push dummy.  */
+    push_target (&dummy_target);
+}
+
+/* Print things about the whole set of targets and about the
+   current target stack.  */
+static void
+targets_info ()
+{
+  int i;
+
+  printf("Possible targets:\n\n");
+  for (i = 0; i < target_struct_size; i++)
+    printf ("%-15s %s\n",
+      target_structs[i]->to_shortname, 
+      target_structs[i]->to_longname);
+}
+
+/* Move memory to or from the targets.  Iterate until all of it has
+   been moved, if necessary.  The top target gets priority; anything
+   it doesn't want, is offered to the next one down, etc.  Note the
+   business with curlen:  if an early target says "no, but I have a
+   boundary overlapping this xfer" then we shorten what we offer to
+   the subsequent targets so the early guy will get a chance at the
+   tail before the subsequent ones do. 
+
+   Result is 0 or errno value.  */
+
+int
+target_read_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  return target_xfer_memory (memaddr, myaddr, len, 0);
+}
+
+int
+target_write_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  return target_xfer_memory (memaddr, myaddr, len, 1);
+}
+ 
+int
+target_xfer_memory (memaddr, myaddr, len, write)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+     int write;
+{
+  int curlen;
+  int res;
+  struct target_ops *t;
+  
+  /* The quick case is that the top target does it all.  */
+  res = current_target->to_xfer_memory(memaddr, myaddr, len, write);
+  if (res == len)
+    return 0;
+
+  if (res > 0)
+    goto bump;
+  /* If res <= 0 then we call it again in the loop.  Ah well.  */
+
+  for (; len > 0;)
+    {
+      curlen = len;		/* Want to do it all */
+      for (t = current_target;
+	   t;
+	   t = t->to_has_all_memory? 0: t->to_next)
+	{
+	  res = t->to_xfer_memory(memaddr, myaddr, curlen, write);
+	  if (res > 0) break;	/* Handled all or part of xfer */
+	  if (res == 0) continue;	/* Handled none */
+	  curlen = -res;	/* Could handle once we get past res bytes */
+	}
+      if (res <= 0)
+	{
+	  /* If this address is for nonexistent memory,
+	     read zeros if reading, or do nothing if writing.  Return error. */
+	  if (!write)
+	    bzero (myaddr, len);
+	  return EIO;
+	}
+bump:
+      memaddr += res;
+      myaddr  += res;
+      len     -= res;
+    }
+  return 0;			/* We managed to cover it all somehow. */
+}
+
+
+static void
+target_info (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  struct target_ops *t;
+  int has_all_mem = 0;
+  
+  if (symfile != 0)
+    printf ("Symbols from \"%s\".\n", symfile);
+
+#ifdef FILES_INFO_HOOK
+  if (FILES_INFO_HOOK ())
+    return;
+#endif
+
+  for (t = current_target;
+       t;
+       t = t->to_next)
+    {
+      if ((int)(t->to_stratum) <= (int)dummy_stratum)
+	continue;
+      if (has_all_mem)
+	printf("\tWhile running this, gdb does not access memory from...\n");
+      printf("%s:\n", t->to_longname);
+      (t->to_files_info)();
+      has_all_mem = t->to_has_all_memory;
+    }
+}
+
+/* The target command selects a target and calls its open routine.
+   The open routine takes the rest of the parameters from the command,
+   and (if successful) pushes a new target onto the stack.  */
+
+static void
+target_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  int i;
+  char *rest;
+
+  dont_repeat();
+
+  if (!args)
+    error (
+     "Argument required (target name).  `info targets' lists possible targets");
+
+  if (target_has_execution)
+    {   
+      if (query ("A program is being debugged already.  Kill it? "))
+        target_kill ((char *)0, from_tty);
+      else
+        error ("Program not killed.");
+    }
+        
+  /* Skip to first space, or end of args */
+  for (rest = args; *rest && !isspace(*rest); rest++) ;
+  if (*rest == '\0')
+    rest = 0;		/* Only one word in args */
+  else
+    {
+      *rest = '\0';	/* Terminate first word, scan for next */
+      for (rest++; isspace (*rest); rest++) ;
+      if (*rest == '\0')	/* Only one word w/trailing blanks */
+	rest = 0;
+    }
+
+  /* Search target list for a match */
+
+  for (i = 0; i < target_struct_size; i++)
+    {
+      if (!strcmp (args, target_structs[i]->to_shortname))
+	goto gotit;
+    }
+  error ("No such target.  `info targets' will list all targets");
+
+gotit:
+  (*target_structs[i]->to_open) (rest, from_tty);
+}
+
+static char targ_desc[] = 
+    "Names of targets and files being debugged.\n\
+Shows the entire stack of targets currently in use (including the exec-file,\n\
+core-file, and process, if any), as well as the symbol file name.";
+
+void
+_initialize_targets ()
+{
+  current_target = &dummy_target;
+  cleanup_target (current_target);
+
+  add_info ("targets", targets_info,
+    "Names of all possible targets.\n\
+A target is typically a protocol for talking to debugging facilities;\n\
+for example, `child' for Unix child processes, or `vxworks' for a\n\
+TCP/IP link to a VxWorks system.");
+
+  add_info ("target", target_info, targ_desc);
+  add_info ("files", target_info, targ_desc);
+
+  add_com ("target", class_run, target_command,
+"Connect to a target machine or process.\n\
+The first argument is the type or protocol of the target machine.  Remaining\n\
+arguments are interpreted by the target protocol, but typically include\n\
+things like device names or host names to connect with, process numbers,\n\
+baud rates, etc.  You can list all possible targets with the `info targets'\n\
+command.");
+}