OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [gdbserver/] [target.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Target operations for the remote server for GDB.
2
   Copyright (C) 2002, 2004, 2005, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   Contributed by MontaVista Software.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "server.h"
23
 
24
struct target_ops *the_target;
25
 
26
void
27
set_desired_inferior (int use_general)
28
{
29
  struct thread_info *found;
30
 
31
  if (use_general == 1)
32
    found = find_thread_ptid (general_thread);
33
  else
34
    {
35
      found = NULL;
36
 
37
      /* If we are continuing any (all) thread(s), use step_thread
38
         to decide which thread to step and/or send the specified
39
         signal to.  */
40
      if ((!ptid_equal (step_thread, null_ptid)
41
           && !ptid_equal (step_thread, minus_one_ptid))
42
          && (ptid_equal (cont_thread, null_ptid)
43
              || ptid_equal (cont_thread, minus_one_ptid)))
44
        found = find_thread_ptid (step_thread);
45
 
46
      if (found == NULL)
47
        found = find_thread_ptid (cont_thread);
48
    }
49
 
50
  if (found == NULL)
51
    current_inferior = (struct thread_info *) all_threads.head;
52
  else
53
    current_inferior = found;
54
}
55
 
56
int
57
read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
58
{
59
  int res;
60
  res = (*the_target->read_memory) (memaddr, myaddr, len);
61
  check_mem_read (memaddr, myaddr, len);
62
  return res;
63
}
64
 
65
int
66
write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
67
                       int len)
68
{
69
  /* Lacking cleanups, there is some potential for a memory leak if the
70
     write fails and we go through error().  Make sure that no more than
71
     one buffer is ever pending by making BUFFER static.  */
72
  static unsigned char *buffer = 0;
73
  int res;
74
 
75
  if (buffer != NULL)
76
    free (buffer);
77
 
78
  buffer = xmalloc (len);
79
  memcpy (buffer, myaddr, len);
80
  check_mem_write (memaddr, buffer, len);
81
  res = (*the_target->write_memory) (memaddr, buffer, len);
82
  free (buffer);
83
  buffer = NULL;
84
 
85
  return res;
86
}
87
 
88
ptid_t
89
mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options,
90
        int connected_wait)
91
{
92
  ptid_t ret;
93
 
94
  if (connected_wait)
95
    server_waiting = 1;
96
 
97
  ret = (*the_target->wait) (ptid, ourstatus, options);
98
 
99
  if (ourstatus->kind == TARGET_WAITKIND_EXITED)
100
    fprintf (stderr,
101
             "\nChild exited with status %d\n", ourstatus->value.sig);
102
  else if (ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
103
    fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
104
             target_signal_to_host (ourstatus->value.sig),
105
             target_signal_to_name (ourstatus->value.sig));
106
 
107
  if (connected_wait)
108
    server_waiting = 0;
109
 
110
  return ret;
111
}
112
 
113
int
114
start_non_stop (int nonstop)
115
{
116
  if (the_target->start_non_stop == NULL)
117
    {
118
      if (nonstop)
119
        return -1;
120
      else
121
        return 0;
122
    }
123
 
124
  return (*the_target->start_non_stop) (nonstop);
125
}
126
 
127
void
128
set_target_ops (struct target_ops *target)
129
{
130
  the_target = (struct target_ops *) xmalloc (sizeof (*the_target));
131
  memcpy (the_target, target, sizeof (*the_target));
132
}
133
 
134
/* Convert pid to printable format.  */
135
 
136
const char *
137
target_pid_to_str (ptid_t ptid)
138
{
139
  static char buf[80];
140
 
141
  if (ptid_equal (ptid, minus_one_ptid))
142
    snprintf (buf, sizeof (buf), "<all threads>");
143
  else if (ptid_equal (ptid, null_ptid))
144
    snprintf (buf, sizeof (buf), "<null thread>");
145
  else if (ptid_get_tid (ptid) != 0)
146
    snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
147
              ptid_get_pid (ptid), ptid_get_tid (ptid));
148
  else if (ptid_get_lwp (ptid) != 0)
149
    snprintf (buf, sizeof (buf), "LWP %d.%ld",
150
              ptid_get_pid (ptid), ptid_get_lwp (ptid));
151
  else
152
    snprintf (buf, sizeof (buf), "Process %d",
153
              ptid_get_pid (ptid));
154
 
155
  return buf;
156
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.