Commit | Line | Data |
---|---|---|
9b4ff276 AC |
1 | /* OBSOLETE /* Remote debugging interface for AMD 29k interfaced via UDI, for GDB. */ |
2 | /* OBSOLETE Copyright 1990, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 */ | |
3 | /* OBSOLETE Free Software Foundation, Inc. */ | |
4 | /* OBSOLETE Written by Daniel Mann. Contributed by AMD. */ | |
5 | /* OBSOLETE */ | |
6 | /* OBSOLETE This file is part of GDB. */ | |
7 | /* OBSOLETE */ | |
8 | /* OBSOLETE This program is free software; you can redistribute it and/or modify */ | |
9 | /* OBSOLETE it under the terms of the GNU General Public License as published by */ | |
10 | /* OBSOLETE the Free Software Foundation; either version 2 of the License, or */ | |
11 | /* OBSOLETE (at your option) any later version. */ | |
12 | /* OBSOLETE */ | |
13 | /* OBSOLETE This program is distributed in the hope that it will be useful, */ | |
14 | /* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */ | |
15 | /* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ | |
16 | /* OBSOLETE GNU General Public License for more details. */ | |
17 | /* OBSOLETE */ | |
18 | /* OBSOLETE You should have received a copy of the GNU General Public License */ | |
19 | /* OBSOLETE along with this program; if not, write to the Free Software */ | |
20 | /* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, */ | |
21 | /* OBSOLETE Boston, MA 02111-1307, USA. */ */ | |
22 | /* OBSOLETE */ | |
23 | /* OBSOLETE /* This is like remote.c but uses the Universal Debug Interface (UDI) to */ | |
24 | /* OBSOLETE talk to the target hardware (or simulator). UDI is a TCP/IP based */ | |
25 | /* OBSOLETE protocol; for hardware that doesn't run TCP, an interface adapter */ | |
26 | /* OBSOLETE daemon talks UDI on one side, and talks to the hardware (typically */ | |
27 | /* OBSOLETE over a serial port) on the other side. */ | |
28 | /* OBSOLETE */ | |
29 | /* OBSOLETE - Originally written by Daniel Mann at AMD for MiniMON and gdb 3.91.6. */ | |
30 | /* OBSOLETE - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this */ | |
31 | /* OBSOLETE file to gdb 3.95. I was unable to get this working on sun3os4 */ | |
32 | /* OBSOLETE with termio, only with sgtty. */ | |
33 | /* OBSOLETE - Daniel Mann at AMD took the 3.95 adaptions above and replaced */ | |
34 | /* OBSOLETE MiniMON interface with UDI-p interface. */ */ | |
35 | /* OBSOLETE */ | |
36 | /* OBSOLETE #include "defs.h" */ | |
37 | /* OBSOLETE #include "frame.h" */ | |
38 | /* OBSOLETE #include "inferior.h" */ | |
39 | /* OBSOLETE #include "value.h" */ | |
40 | /* OBSOLETE #include <ctype.h> */ | |
41 | /* OBSOLETE #include <fcntl.h> */ | |
42 | /* OBSOLETE #include <errno.h> */ | |
43 | /* OBSOLETE #include "gdb_string.h" */ | |
44 | /* OBSOLETE #include "terminal.h" */ | |
45 | /* OBSOLETE #include "target.h" */ | |
46 | /* OBSOLETE #include "29k-share/udi/udiproc.h" */ | |
47 | /* OBSOLETE #include "gdbcmd.h" */ | |
48 | /* OBSOLETE #include "bfd.h" */ | |
49 | /* OBSOLETE #include "gdbcore.h" /* For download function */ */ | |
50 | /* OBSOLETE #include "regcache.h" */ | |
51 | /* OBSOLETE */ | |
52 | /* OBSOLETE /* access the register store directly, without going through */ | |
53 | /* OBSOLETE the normal handler functions. This avoids an extra data copy. */ */ | |
54 | /* OBSOLETE */ | |
55 | /* OBSOLETE extern int stop_soon_quietly; /* for wait_for_inferior */ */ | |
56 | /* OBSOLETE extern struct value *call_function_by_hand (); */ | |
57 | /* OBSOLETE static void udi_resume (ptid_t ptid, int step, enum target_signal sig); */ | |
58 | /* OBSOLETE static void udi_fetch_registers (int regno); */ | |
59 | /* OBSOLETE static void udi_load (char *args, int from_tty); */ | |
60 | /* OBSOLETE static void fetch_register (int regno); */ | |
61 | /* OBSOLETE static void udi_store_registers (int regno); */ | |
62 | /* OBSOLETE static int store_register (int regno); */ | |
63 | /* OBSOLETE static int regnum_to_srnum (int regno); */ | |
64 | /* OBSOLETE static void udi_close (int quitting); */ | |
65 | /* OBSOLETE static CPUSpace udi_memory_space (CORE_ADDR addr); */ | |
66 | /* OBSOLETE static int udi_write_inferior_memory (CORE_ADDR memaddr, char *myaddr, */ | |
67 | /* OBSOLETE int len); */ | |
68 | /* OBSOLETE static int udi_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, */ | |
69 | /* OBSOLETE int len); */ | |
70 | /* OBSOLETE static void download (char *load_arg_string, int from_tty); */ | |
71 | /* OBSOLETE char CoffFileName[100] = ""; */ | |
72 | /* OBSOLETE */ | |
73 | /* OBSOLETE #define FREEZE_MODE (read_register(CPS_REGNUM) & 0x400) */ | |
74 | /* OBSOLETE #define USE_SHADOW_PC ((processor_type == a29k_freeze_mode) && FREEZE_MODE) */ | |
75 | /* OBSOLETE */ | |
76 | /* OBSOLETE static int timeout = 5; */ | |
77 | /* OBSOLETE extern struct target_ops udi_ops; /* Forward declaration */ */ | |
78 | /* OBSOLETE */ | |
79 | /* OBSOLETE /* Special register enumeration. */ | |
80 | /* OBSOLETE */ */ | |
81 | /* OBSOLETE */ | |
82 | /* OBSOLETE /******************************************************************* UDI DATA*/ */ | |
83 | /* OBSOLETE #define MAXDATA 2*1024 /* max UDI[read/write] byte size */ */ | |
84 | /* OBSOLETE /* Descriptor for I/O to remote machine. Initialize it to -1 so that */ | |
85 | /* OBSOLETE udi_open knows that we don't have a file open when the program */ | |
86 | /* OBSOLETE starts. */ */ | |
87 | /* OBSOLETE */ | |
88 | /* OBSOLETE UDISessionId udi_session_id = -1; */ | |
89 | /* OBSOLETE static char *udi_config_id; */ | |
90 | /* OBSOLETE */ | |
91 | /* OBSOLETE CPUOffset IMemStart = 0; */ | |
92 | /* OBSOLETE CPUSizeT IMemSize = 0; */ | |
93 | /* OBSOLETE CPUOffset DMemStart = 0; */ | |
94 | /* OBSOLETE CPUSizeT DMemSize = 0; */ | |
95 | /* OBSOLETE CPUOffset RMemStart = 0; */ | |
96 | /* OBSOLETE CPUSizeT RMemSize = 0; */ | |
97 | /* OBSOLETE UDIUInt32 CPUPRL; */ | |
98 | /* OBSOLETE UDIUInt32 CoProcPRL; */ | |
99 | /* OBSOLETE */ | |
100 | /* OBSOLETE UDIMemoryRange address_ranges[2]; /* Text and data */ */ | |
101 | /* OBSOLETE UDIResource entry = */ | |
102 | /* OBSOLETE {0, 0}; /* Entry point */ */ | |
103 | /* OBSOLETE CPUSizeT stack_sizes[2]; /* Regular and memory stacks */ */ | |
104 | /* OBSOLETE */ | |
105 | /* OBSOLETE #define SBUF_MAX 1024 /* maximum size of string handling buffer */ */ | |
106 | /* OBSOLETE char sbuf[SBUF_MAX]; */ | |
107 | /* OBSOLETE */ | |
108 | /* OBSOLETE typedef struct bkpt_entry_str */ | |
109 | /* OBSOLETE { */ | |
110 | /* OBSOLETE UDIResource Addr; */ | |
111 | /* OBSOLETE UDIUInt32 PassCount; */ | |
112 | /* OBSOLETE UDIBreakType Type; */ | |
113 | /* OBSOLETE unsigned int BreakId; */ | |
114 | /* OBSOLETE } */ | |
115 | /* OBSOLETE bkpt_entry_t; */ | |
116 | /* OBSOLETE #define BKPT_TABLE_SIZE 40 */ | |
117 | /* OBSOLETE static bkpt_entry_t bkpt_table[BKPT_TABLE_SIZE]; */ | |
118 | /* OBSOLETE extern char dfe_errmsg[]; /* error string */ */ | |
119 | /* OBSOLETE */ | |
120 | /* OBSOLETE /* malloc'd name of the program on the remote system. */ */ | |
121 | /* OBSOLETE static char *prog_name = NULL; */ | |
122 | /* OBSOLETE */ | |
123 | /* OBSOLETE /* This is called not only when we first attach, but also when the */ | |
124 | /* OBSOLETE user types "run" after having attached. */ */ | |
125 | /* OBSOLETE */ | |
126 | /* OBSOLETE static void */ | |
127 | /* OBSOLETE udi_create_inferior (char *execfile, char *args, char **env) */ | |
128 | /* OBSOLETE { */ | |
129 | /* OBSOLETE char *args1; */ | |
130 | /* OBSOLETE */ | |
131 | /* OBSOLETE if (execfile) */ | |
132 | /* OBSOLETE { */ | |
133 | /* OBSOLETE if (prog_name != NULL) */ | |
134 | /* OBSOLETE xfree (prog_name); */ | |
135 | /* OBSOLETE prog_name = savestring (execfile, strlen (execfile)); */ | |
136 | /* OBSOLETE } */ | |
137 | /* OBSOLETE else if (entry.Offset) */ | |
138 | /* OBSOLETE execfile = ""; */ | |
139 | /* OBSOLETE else */ | |
140 | /* OBSOLETE error ("No image loaded into target."); */ | |
141 | /* OBSOLETE */ | |
142 | /* OBSOLETE if (udi_session_id < 0) */ | |
143 | /* OBSOLETE { */ | |
144 | /* OBSOLETE /* If the TIP is not open, open it. */ */ | |
145 | /* OBSOLETE if (UDIConnect (udi_config_id, &udi_session_id)) */ | |
146 | /* OBSOLETE error ("UDIConnect() failed: %s\n", dfe_errmsg); */ | |
147 | /* OBSOLETE /* We will need to download the program. */ */ | |
148 | /* OBSOLETE entry.Offset = 0; */ | |
149 | /* OBSOLETE } */ | |
150 | /* OBSOLETE */ | |
151 | /* OBSOLETE inferior_ptid = pid_to_ptid (40000); */ | |
152 | /* OBSOLETE */ | |
153 | /* OBSOLETE if (!entry.Offset) */ | |
154 | /* OBSOLETE download (execfile, 0); */ | |
155 | /* OBSOLETE */ | |
156 | /* OBSOLETE args1 = alloca (strlen (execfile) + strlen (args) + 2); */ | |
157 | /* OBSOLETE */ | |
158 | /* OBSOLETE if (execfile[0] == '\0') */ | |
159 | /* OBSOLETE */ | |
160 | /* OBSOLETE /* It is empty. We need to quote it somehow, or else the target */ | |
161 | /* OBSOLETE will think there is no argument being passed here. According */ | |
162 | /* OBSOLETE to the UDI spec it is quoted "according to TIP OS rules" which */ | |
163 | /* OBSOLETE I guess means quoting it like the Unix shell should work */ | |
164 | /* OBSOLETE (sounds pretty bogus to me...). In fact it doesn't work (with */ | |
165 | /* OBSOLETE isstip anyway), but passing in two quotes as the argument seems */ | |
166 | /* OBSOLETE like a reasonable enough behavior anyway (I guess). */ */ | |
167 | /* OBSOLETE */ | |
168 | /* OBSOLETE strcpy (args1, "''"); */ | |
169 | /* OBSOLETE else */ | |
170 | /* OBSOLETE strcpy (args1, execfile); */ | |
171 | /* OBSOLETE strcat (args1, " "); */ | |
172 | /* OBSOLETE strcat (args1, args); */ | |
173 | /* OBSOLETE */ | |
174 | /* OBSOLETE UDIInitializeProcess (address_ranges, /* ProcessMemory[] */ */ | |
175 | /* OBSOLETE (UDIInt) 2, /* NumberOfRanges */ */ | |
176 | /* OBSOLETE entry, /* EntryPoint */ */ | |
177 | /* OBSOLETE stack_sizes, /* *StackSizes */ */ | |
178 | /* OBSOLETE (UDIInt) 2, /* NumberOfStacks */ */ | |
179 | /* OBSOLETE args1); /* ArgString */ */ | |
180 | /* OBSOLETE */ | |
181 | /* OBSOLETE init_wait_for_inferior (); */ | |
182 | /* OBSOLETE clear_proceed_status (); */ | |
183 | /* OBSOLETE proceed (-1, TARGET_SIGNAL_DEFAULT, 0); */ | |
184 | /* OBSOLETE } */ | |
185 | /* OBSOLETE */ | |
186 | /* OBSOLETE static void */ | |
187 | /* OBSOLETE udi_mourn (void) */ | |
188 | /* OBSOLETE { */ | |
189 | /* OBSOLETE #if 0 */ | |
190 | /* OBSOLETE /* Requiring "target udi" each time you run is a major pain. I suspect */ | |
191 | /* OBSOLETE this was just blindy copied from remote.c, in which "target" and */ | |
192 | /* OBSOLETE "run" are combined. Having a udi target without an inferior seems */ | |
193 | /* OBSOLETE to work between "target udi" and "run", so why not now? */ */ | |
194 | /* OBSOLETE pop_target (); /* Pop back to no-child state */ */ | |
195 | /* OBSOLETE #endif */ | |
196 | /* OBSOLETE /* But if we're going to want to run it again, we better remove the */ | |
197 | /* OBSOLETE breakpoints... */ */ | |
198 | /* OBSOLETE remove_breakpoints (); */ | |
199 | /* OBSOLETE generic_mourn_inferior (); */ | |
200 | /* OBSOLETE } */ | |
201 | /* OBSOLETE */ | |
202 | /* OBSOLETE /******************************************************************** UDI_OPEN */ | |
203 | /* OBSOLETE ** Open a connection to remote TIP. */ | |
204 | /* OBSOLETE NAME is the socket domain used for communication with the TIP, */ | |
205 | /* OBSOLETE then a space and the socket name or TIP-host name. */ | |
206 | /* OBSOLETE '<udi_udi_config_id>' for example. */ | |
207 | /* OBSOLETE */ */ | |
208 | /* OBSOLETE */ | |
209 | /* OBSOLETE /* XXX - need cleanups for udiconnect for various failures!!! */ */ | |
210 | /* OBSOLETE */ | |
211 | /* OBSOLETE static void */ | |
212 | /* OBSOLETE udi_open (char *name, int from_tty) */ | |
213 | /* OBSOLETE { */ | |
214 | /* OBSOLETE unsigned int prl; */ | |
215 | /* OBSOLETE char *p; */ | |
216 | /* OBSOLETE int cnt; */ | |
217 | /* OBSOLETE UDIMemoryRange KnownMemory[10]; */ | |
218 | /* OBSOLETE UDIUInt32 ChipVersions[10]; */ | |
219 | /* OBSOLETE UDIInt NumberOfRanges = 10; */ | |
220 | /* OBSOLETE UDIInt NumberOfChips = 10; */ | |
221 | /* OBSOLETE UDIPId PId; */ | |
222 | /* OBSOLETE UDIUInt32 TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId, TIPIPCId; */ | |
223 | /* OBSOLETE */ | |
224 | /* OBSOLETE target_preopen (from_tty); */ | |
225 | /* OBSOLETE */ | |
226 | /* OBSOLETE entry.Offset = 0; */ | |
227 | /* OBSOLETE */ | |
228 | /* OBSOLETE for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) */ | |
229 | /* OBSOLETE bkpt_table[cnt].Type = 0; */ | |
230 | /* OBSOLETE */ | |
231 | /* OBSOLETE if (udi_config_id) */ | |
232 | /* OBSOLETE xfree (udi_config_id); */ | |
233 | /* OBSOLETE */ | |
234 | /* OBSOLETE if (!name) */ | |
235 | /* OBSOLETE error ("Usage: target udi config_id, where config_id appears in udi_soc file"); */ | |
236 | /* OBSOLETE */ | |
237 | /* OBSOLETE udi_config_id = xstrdup (strtok (name, " \t")); */ | |
238 | /* OBSOLETE */ | |
239 | /* OBSOLETE if (UDIConnect (udi_config_id, &udi_session_id)) */ | |
240 | /* OBSOLETE /* FIXME: Should set udi_session_id to -1 here. */ */ | |
241 | /* OBSOLETE error ("UDIConnect() failed: %s\n", dfe_errmsg); */ | |
242 | /* OBSOLETE */ | |
243 | /* OBSOLETE push_target (&udi_ops); */ | |
244 | /* OBSOLETE */ | |
245 | /* OBSOLETE /* */ | |
246 | /* OBSOLETE ** Initialize target configuration structure (global) */ | |
247 | /* OBSOLETE */ */ | |
248 | /* OBSOLETE if (UDIGetTargetConfig (KnownMemory, &NumberOfRanges, */ | |
249 | /* OBSOLETE ChipVersions, &NumberOfChips)) */ | |
250 | /* OBSOLETE error ("UDIGetTargetConfig() failed"); */ | |
251 | /* OBSOLETE if (NumberOfChips > 2) */ | |
252 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "Target has more than one processor\n"); */ | |
253 | /* OBSOLETE for (cnt = 0; cnt < NumberOfRanges; cnt++) */ | |
254 | /* OBSOLETE { */ | |
255 | /* OBSOLETE switch (KnownMemory[cnt].Space) */ | |
256 | /* OBSOLETE { */ | |
257 | /* OBSOLETE default: */ | |
258 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "UDIGetTargetConfig() unknown memory space\n"); */ | |
259 | /* OBSOLETE break; */ | |
260 | /* OBSOLETE case UDI29KCP_S: */ | |
261 | /* OBSOLETE break; */ | |
262 | /* OBSOLETE case UDI29KIROMSpace: */ | |
263 | /* OBSOLETE RMemStart = KnownMemory[cnt].Offset; */ | |
264 | /* OBSOLETE RMemSize = KnownMemory[cnt].Size; */ | |
265 | /* OBSOLETE break; */ | |
266 | /* OBSOLETE case UDI29KIRAMSpace: */ | |
267 | /* OBSOLETE IMemStart = KnownMemory[cnt].Offset; */ | |
268 | /* OBSOLETE IMemSize = KnownMemory[cnt].Size; */ | |
269 | /* OBSOLETE break; */ | |
270 | /* OBSOLETE case UDI29KDRAMSpace: */ | |
271 | /* OBSOLETE DMemStart = KnownMemory[cnt].Offset; */ | |
272 | /* OBSOLETE DMemSize = KnownMemory[cnt].Size; */ | |
273 | /* OBSOLETE break; */ | |
274 | /* OBSOLETE } */ | |
275 | /* OBSOLETE } */ | |
276 | /* OBSOLETE */ | |
277 | /* OBSOLETE a29k_get_processor_type (); */ | |
278 | /* OBSOLETE */ | |
279 | /* OBSOLETE if (UDICreateProcess (&PId)) */ | |
280 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "UDICreateProcess() failed\n"); */ | |
281 | /* OBSOLETE */ | |
282 | /* OBSOLETE /* Print out some stuff, letting the user now what's going on */ */ | |
283 | /* OBSOLETE if (UDICapabilities (&TIPId, &TargetId, DFEId, DFE, &TIP, &DFEIPCId, */ | |
284 | /* OBSOLETE &TIPIPCId, sbuf)) */ | |
285 | /* OBSOLETE error ("UDICapabilities() failed"); */ | |
286 | /* OBSOLETE if (from_tty) */ | |
287 | /* OBSOLETE { */ | |
288 | /* OBSOLETE printf_filtered ("Connected via UDI socket,\n\ */ | |
289 | /* OBSOLETE DFE-IPC version %x.%x.%x TIP-IPC version %x.%x.%x TIP version %x.%x.%x\n %s\n", */ | |
290 | /* OBSOLETE (DFEIPCId >> 8) & 0xf, (DFEIPCId >> 4) & 0xf, DFEIPCId & 0xf, */ | |
291 | /* OBSOLETE (TIPIPCId >> 8) & 0xf, (TIPIPCId >> 4) & 0xf, TIPIPCId & 0xf, */ | |
292 | /* OBSOLETE (TargetId >> 8) & 0xf, (TargetId >> 4) & 0xf, TargetId & 0xf, */ | |
293 | /* OBSOLETE sbuf); */ | |
294 | /* OBSOLETE } */ | |
295 | /* OBSOLETE } */ | |
296 | /* OBSOLETE */ | |
297 | /* OBSOLETE /******************************************************************* UDI_CLOSE */ | |
298 | /* OBSOLETE Close the open connection to the TIP process. */ | |
299 | /* OBSOLETE Use this when you want to detach and do something else */ | |
300 | /* OBSOLETE with your gdb. */ */ | |
301 | /* OBSOLETE static void */ | |
302 | /* OBSOLETE udi_close ( /*FIXME: how is quitting used */ */ | |
303 | /* OBSOLETE int quitting) */ | |
304 | /* OBSOLETE { */ | |
305 | /* OBSOLETE if (udi_session_id < 0) */ | |
306 | /* OBSOLETE return; */ | |
307 | /* OBSOLETE */ | |
308 | /* OBSOLETE /* We should never get here if there isn't something valid in */ | |
309 | /* OBSOLETE udi_session_id. */ */ | |
310 | /* OBSOLETE */ | |
311 | /* OBSOLETE if (UDIDisconnect (udi_session_id, UDITerminateSession)) */ | |
312 | /* OBSOLETE { */ | |
313 | /* OBSOLETE if (quitting) */ | |
314 | /* OBSOLETE warning ("UDIDisconnect() failed in udi_close"); */ | |
315 | /* OBSOLETE else */ | |
316 | /* OBSOLETE error ("UDIDisconnect() failed in udi_close"); */ | |
317 | /* OBSOLETE } */ | |
318 | /* OBSOLETE */ | |
319 | /* OBSOLETE /* Do not try to close udi_session_id again, later in the program. */ */ | |
320 | /* OBSOLETE udi_session_id = -1; */ | |
321 | /* OBSOLETE inferior_ptid = null_ptid; */ | |
322 | /* OBSOLETE */ | |
323 | /* OBSOLETE printf_filtered (" Ending remote debugging\n"); */ | |
324 | /* OBSOLETE } */ | |
325 | /* OBSOLETE */ | |
326 | /* OBSOLETE /**************************************************************** UDI_ATACH */ */ | |
327 | /* OBSOLETE /* Attach to a program that is already loaded and running */ | |
328 | /* OBSOLETE * Upon exiting the process's execution is stopped. */ | |
329 | /* OBSOLETE */ */ | |
330 | /* OBSOLETE static void */ | |
331 | /* OBSOLETE udi_attach (char *args, int from_tty) */ | |
332 | /* OBSOLETE { */ | |
333 | /* OBSOLETE UDIResource From; */ | |
334 | /* OBSOLETE UDIInt32 PC_adds; */ | |
335 | /* OBSOLETE UDICount Count = 1; */ | |
336 | /* OBSOLETE UDISizeT Size = 4; */ | |
337 | /* OBSOLETE UDICount CountDone; */ | |
338 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
339 | /* OBSOLETE UDIError err; */ | |
340 | /* OBSOLETE */ | |
341 | /* OBSOLETE if (args == NULL) */ | |
342 | /* OBSOLETE error_no_arg ("program to attach"); */ | |
343 | /* OBSOLETE */ | |
344 | /* OBSOLETE if (udi_session_id < 0) */ | |
345 | /* OBSOLETE error ("UDI connection not opened yet, use the 'target udi' command.\n"); */ | |
346 | /* OBSOLETE */ | |
347 | /* OBSOLETE if (from_tty) */ | |
348 | /* OBSOLETE printf_unfiltered ("Attaching to remote program %s...\n", prog_name); */ | |
349 | /* OBSOLETE */ | |
350 | /* OBSOLETE UDIStop (); */ | |
351 | /* OBSOLETE From.Space = UDI29KSpecialRegs; */ | |
352 | /* OBSOLETE From.Offset = 11; */ | |
353 | /* OBSOLETE if (err = UDIRead (From, &PC_adds, Count, Size, &CountDone, HostEndian)) */ | |
354 | /* OBSOLETE error ("UDIRead failed in udi_attach"); */ | |
355 | /* OBSOLETE printf_unfiltered ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds); */ | |
356 | /* OBSOLETE } */ | |
357 | /* OBSOLETE /************************************************************* UDI_DETACH */ */ | |
358 | /* OBSOLETE /* Terminate the open connection to the TIP process. */ | |
359 | /* OBSOLETE Use this when you want to detach and do something else */ | |
360 | /* OBSOLETE with your gdb. Leave remote process running (with no breakpoints set). */ */ | |
361 | /* OBSOLETE static void */ | |
362 | /* OBSOLETE udi_detach (char *args, int from_tty) */ | |
363 | /* OBSOLETE { */ | |
364 | /* OBSOLETE */ | |
365 | /* OBSOLETE remove_breakpoints (); /* Just in case there were any left in */ */ | |
366 | /* OBSOLETE */ | |
367 | /* OBSOLETE if (UDIDisconnect (udi_session_id, UDIContinueSession)) */ | |
368 | /* OBSOLETE error ("UDIDisconnect() failed in udi_detach"); */ | |
369 | /* OBSOLETE */ | |
370 | /* OBSOLETE /* Don't try to UDIDisconnect it again in udi_close, which is called from */ | |
371 | /* OBSOLETE pop_target. */ */ | |
372 | /* OBSOLETE udi_session_id = -1; */ | |
373 | /* OBSOLETE inferior_ptid = null_ptid; */ | |
374 | /* OBSOLETE */ | |
375 | /* OBSOLETE pop_target (); */ | |
376 | /* OBSOLETE */ | |
377 | /* OBSOLETE if (from_tty) */ | |
378 | /* OBSOLETE printf_unfiltered ("Detaching from TIP\n"); */ | |
379 | /* OBSOLETE } */ | |
380 | /* OBSOLETE */ | |
381 | /* OBSOLETE */ | |
382 | /* OBSOLETE /****************************************************************** UDI_RESUME */ | |
383 | /* OBSOLETE ** Tell the remote machine to resume. */ */ | |
384 | /* OBSOLETE */ | |
385 | /* OBSOLETE static void */ | |
386 | /* OBSOLETE udi_resume (ptid_t ptid, int step, enum target_signal sig) */ | |
387 | /* OBSOLETE { */ | |
388 | /* OBSOLETE UDIError tip_error; */ | |
389 | /* OBSOLETE UDIUInt32 Steps = 1; */ | |
390 | /* OBSOLETE UDIStepType StepType = UDIStepNatural; */ | |
391 | /* OBSOLETE UDIRange Range; */ | |
392 | /* OBSOLETE */ | |
393 | /* OBSOLETE if (step) /* step 1 instruction */ */ | |
394 | /* OBSOLETE { */ | |
395 | /* OBSOLETE tip_error = UDIStep (Steps, StepType, Range); */ | |
396 | /* OBSOLETE if (!tip_error) */ | |
397 | /* OBSOLETE return; */ | |
398 | /* OBSOLETE */ | |
399 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "UDIStep() error = %d\n", tip_error); */ | |
400 | /* OBSOLETE error ("failed in udi_resume"); */ | |
401 | /* OBSOLETE } */ | |
402 | /* OBSOLETE */ | |
403 | /* OBSOLETE if (UDIExecute ()) */ | |
404 | /* OBSOLETE error ("UDIExecute() failed in udi_resume"); */ | |
405 | /* OBSOLETE } */ | |
406 | /* OBSOLETE */ | |
407 | /* OBSOLETE /******************************************************************** UDI_WAIT */ | |
408 | /* OBSOLETE ** Wait until the remote machine stops, then return, */ | |
409 | /* OBSOLETE storing status in STATUS just as `wait' would. */ */ | |
410 | /* OBSOLETE */ | |
411 | /* OBSOLETE static ptid_t */ | |
412 | /* OBSOLETE udi_wait (ptid_t ptid, struct target_waitstatus *status) */ | |
413 | /* OBSOLETE { */ | |
414 | /* OBSOLETE UDIInt32 MaxTime; */ | |
415 | /* OBSOLETE UDIPId PId; */ | |
416 | /* OBSOLETE UDIInt32 StopReason; */ | |
417 | /* OBSOLETE UDISizeT CountDone; */ | |
418 | /* OBSOLETE int old_timeout = timeout; */ | |
419 | /* OBSOLETE int old_immediate_quit = immediate_quit; */ | |
420 | /* OBSOLETE int i; */ | |
421 | /* OBSOLETE */ | |
422 | /* OBSOLETE status->kind = TARGET_WAITKIND_EXITED; */ | |
423 | /* OBSOLETE status->value.integer = 0; */ | |
424 | /* OBSOLETE */ | |
425 | /* OBSOLETE /* wait for message to arrive. It should be: */ | |
426 | /* OBSOLETE If the target stops executing, udi_wait() should return. */ | |
427 | /* OBSOLETE */ */ | |
428 | /* OBSOLETE timeout = 0; /* Wait indefinetly for a message */ */ | |
429 | /* OBSOLETE immediate_quit = 1; /* Helps ability to QUIT */ */ | |
430 | /* OBSOLETE */ | |
431 | /* OBSOLETE while (1) */ | |
432 | /* OBSOLETE { */ | |
433 | /* OBSOLETE i = 0; */ | |
434 | /* OBSOLETE MaxTime = UDIWaitForever; */ | |
435 | /* OBSOLETE UDIWait (MaxTime, &PId, &StopReason); */ | |
436 | /* OBSOLETE QUIT; /* Let user quit if they want */ */ | |
437 | /* OBSOLETE */ | |
438 | /* OBSOLETE switch (StopReason & UDIGrossState) */ | |
439 | /* OBSOLETE { */ | |
440 | /* OBSOLETE case UDIStdoutReady: */ | |
441 | /* OBSOLETE if (UDIGetStdout (sbuf, (UDISizeT) SBUF_MAX, &CountDone)) */ | |
442 | /* OBSOLETE /* This is said to happen if the program tries to output */ | |
443 | /* OBSOLETE a whole bunch of output (more than SBUF_MAX, I would */ | |
444 | /* OBSOLETE guess). It doesn't seem to happen with the simulator. */ */ | |
445 | /* OBSOLETE warning ("UDIGetStdout() failed in udi_wait"); */ | |
446 | /* OBSOLETE fwrite (sbuf, 1, CountDone, stdout); */ | |
447 | /* OBSOLETE gdb_flush (gdb_stdout); */ | |
448 | /* OBSOLETE continue; */ | |
449 | /* OBSOLETE */ | |
450 | /* OBSOLETE case UDIStderrReady: */ | |
451 | /* OBSOLETE UDIGetStderr (sbuf, (UDISizeT) SBUF_MAX, &CountDone); */ | |
452 | /* OBSOLETE fwrite (sbuf, 1, CountDone, stderr); */ | |
453 | /* OBSOLETE gdb_flush (gdb_stderr); */ | |
454 | /* OBSOLETE continue; */ | |
455 | /* OBSOLETE */ | |
456 | /* OBSOLETE case UDIStdinNeeded: */ | |
457 | /* OBSOLETE { */ | |
458 | /* OBSOLETE int ch; */ | |
459 | /* OBSOLETE i = 0; */ | |
460 | /* OBSOLETE do */ | |
461 | /* OBSOLETE { */ | |
462 | /* OBSOLETE ch = getchar (); */ | |
463 | /* OBSOLETE if (ch == EOF) */ | |
464 | /* OBSOLETE break; */ | |
465 | /* OBSOLETE sbuf[i++] = ch; */ | |
466 | /* OBSOLETE } */ | |
467 | /* OBSOLETE while (i < SBUF_MAX && ch != '\n'); */ | |
468 | /* OBSOLETE UDIPutStdin (sbuf, (UDISizeT) i, &CountDone); */ | |
469 | /* OBSOLETE continue; */ | |
470 | /* OBSOLETE } */ | |
471 | /* OBSOLETE */ | |
472 | /* OBSOLETE case UDIRunning: */ | |
473 | /* OBSOLETE /* In spite of the fact that we told UDIWait to wait forever, it will */ | |
474 | /* OBSOLETE return spuriously sometimes. */ */ | |
475 | /* OBSOLETE case UDIStdinModeX: */ | |
476 | /* OBSOLETE continue; */ | |
477 | /* OBSOLETE default: */ | |
478 | /* OBSOLETE break; */ | |
479 | /* OBSOLETE } */ | |
480 | /* OBSOLETE break; */ | |
481 | /* OBSOLETE } */ | |
482 | /* OBSOLETE */ | |
483 | /* OBSOLETE switch (StopReason & UDIGrossState) */ | |
484 | /* OBSOLETE { */ | |
485 | /* OBSOLETE case UDITrapped: */ | |
486 | /* OBSOLETE printf_unfiltered ("Am290*0 received vector number %d\n", StopReason >> 24); */ | |
487 | /* OBSOLETE */ | |
488 | /* OBSOLETE switch ((StopReason >> 8) & 0xff) */ | |
489 | /* OBSOLETE { */ | |
490 | /* OBSOLETE case 0: /* Illegal opcode */ */ | |
491 | /* OBSOLETE printf_unfiltered (" (break point)\n"); */ | |
492 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
493 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */ | |
494 | /* OBSOLETE break; */ | |
495 | /* OBSOLETE case 1: /* Unaligned Access */ */ | |
496 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
497 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_BUS; */ | |
498 | /* OBSOLETE break; */ | |
499 | /* OBSOLETE case 3: */ | |
500 | /* OBSOLETE case 4: */ | |
501 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
502 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_FPE; */ | |
503 | /* OBSOLETE break; */ | |
504 | /* OBSOLETE case 5: /* Protection Violation */ */ | |
505 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
506 | /* OBSOLETE /* Why not SEGV? What is a Protection Violation? */ */ | |
507 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_ILL; */ | |
508 | /* OBSOLETE break; */ | |
509 | /* OBSOLETE case 6: */ | |
510 | /* OBSOLETE case 7: */ | |
511 | /* OBSOLETE case 8: /* User Instruction Mapping Miss */ */ | |
512 | /* OBSOLETE case 9: /* User Data Mapping Miss */ */ | |
513 | /* OBSOLETE case 10: /* Supervisor Instruction Mapping Miss */ */ | |
514 | /* OBSOLETE case 11: /* Supervisor Data Mapping Miss */ */ | |
515 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
516 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_SEGV; */ | |
517 | /* OBSOLETE break; */ | |
518 | /* OBSOLETE case 12: */ | |
519 | /* OBSOLETE case 13: */ | |
520 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
521 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_ILL; */ | |
522 | /* OBSOLETE break; */ | |
523 | /* OBSOLETE case 14: /* Timer */ */ | |
524 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
525 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_ALRM; */ | |
526 | /* OBSOLETE break; */ | |
527 | /* OBSOLETE case 15: /* Trace */ */ | |
528 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
529 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */ | |
530 | /* OBSOLETE break; */ | |
531 | /* OBSOLETE case 16: /* INTR0 */ */ | |
532 | /* OBSOLETE case 17: /* INTR1 */ */ | |
533 | /* OBSOLETE case 18: /* INTR2 */ */ | |
534 | /* OBSOLETE case 19: /* INTR3/Internal */ */ | |
535 | /* OBSOLETE case 20: /* TRAP0 */ */ | |
536 | /* OBSOLETE case 21: /* TRAP1 */ */ | |
537 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
538 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_INT; */ | |
539 | /* OBSOLETE break; */ | |
540 | /* OBSOLETE case 22: /* Floating-Point Exception */ */ | |
541 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
542 | /* OBSOLETE /* Why not FPE? */ */ | |
543 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_ILL; */ | |
544 | /* OBSOLETE break; */ | |
545 | /* OBSOLETE case 77: /* assert 77 */ */ | |
546 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
547 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */ | |
548 | /* OBSOLETE break; */ | |
549 | /* OBSOLETE default: */ | |
550 | /* OBSOLETE status->kind = TARGET_WAITKIND_EXITED; */ | |
551 | /* OBSOLETE status->value.integer = 0; */ | |
552 | /* OBSOLETE } */ | |
553 | /* OBSOLETE break; */ | |
554 | /* OBSOLETE case UDINotExecuting: */ | |
555 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
556 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TERM; */ | |
557 | /* OBSOLETE break; */ | |
558 | /* OBSOLETE case UDIStopped: */ | |
559 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
560 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TSTP; */ | |
561 | /* OBSOLETE break; */ | |
562 | /* OBSOLETE case UDIWarned: */ | |
563 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
564 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_URG; */ | |
565 | /* OBSOLETE break; */ | |
566 | /* OBSOLETE case UDIStepped: */ | |
567 | /* OBSOLETE case UDIBreak: */ | |
568 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
569 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */ | |
570 | /* OBSOLETE break; */ | |
571 | /* OBSOLETE case UDIWaiting: */ | |
572 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
573 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_STOP; */ | |
574 | /* OBSOLETE break; */ | |
575 | /* OBSOLETE case UDIHalted: */ | |
576 | /* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */ | |
577 | /* OBSOLETE status->value.sig = TARGET_SIGNAL_KILL; */ | |
578 | /* OBSOLETE break; */ | |
579 | /* OBSOLETE case UDIExited: */ | |
580 | /* OBSOLETE default: */ | |
581 | /* OBSOLETE status->kind = TARGET_WAITKIND_EXITED; */ | |
582 | /* OBSOLETE status->value.integer = 0; */ | |
583 | /* OBSOLETE } */ | |
584 | /* OBSOLETE */ | |
585 | /* OBSOLETE timeout = old_timeout; /* Restore original timeout value */ */ | |
586 | /* OBSOLETE immediate_quit = old_immediate_quit; */ | |
587 | /* OBSOLETE return inferior_ptid; */ | |
588 | /* OBSOLETE } */ | |
589 | /* OBSOLETE */ | |
590 | /* OBSOLETE #if 0 */ | |
591 | /* OBSOLETE /* Handy for debugging */ */ | |
592 | /* OBSOLETE udi_pc (void) */ | |
593 | /* OBSOLETE { */ | |
594 | /* OBSOLETE UDIResource From; */ | |
595 | /* OBSOLETE UDIUInt32 *To; */ | |
596 | /* OBSOLETE UDICount Count; */ | |
597 | /* OBSOLETE UDISizeT Size = 4; */ | |
598 | /* OBSOLETE UDICount CountDone; */ | |
599 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
600 | /* OBSOLETE UDIError err; */ | |
601 | /* OBSOLETE int pc[2]; */ | |
602 | /* OBSOLETE unsigned long myregs[256]; */ | |
603 | /* OBSOLETE int i; */ | |
604 | /* OBSOLETE */ | |
605 | /* OBSOLETE From.Space = UDI29KPC; */ | |
606 | /* OBSOLETE From.Offset = 0; */ | |
607 | /* OBSOLETE To = (UDIUInt32 *) pc; */ | |
608 | /* OBSOLETE Count = 2; */ | |
609 | /* OBSOLETE */ | |
610 | /* OBSOLETE err = UDIRead (From, To, Count, Size, &CountDone, HostEndian); */ | |
611 | /* OBSOLETE */ | |
612 | /* OBSOLETE printf_unfiltered ("err = %d, CountDone = %d, pc[0] = 0x%x, pc[1] = 0x%x\n", */ | |
613 | /* OBSOLETE err, CountDone, pc[0], pc[1]); */ | |
614 | /* OBSOLETE */ | |
615 | /* OBSOLETE udi_fetch_registers (-1); */ | |
616 | /* OBSOLETE */ | |
617 | /* OBSOLETE printf_unfiltered ("other pc1 = 0x%x, pc0 = 0x%x\n", *(int *) ®isters[4 * PC_REGNUM], */ | |
618 | /* OBSOLETE *(int *) ®isters[4 * NPC_REGNUM]); */ | |
619 | /* OBSOLETE */ | |
620 | /* OBSOLETE /* Now, read all the registers globally */ */ | |
621 | /* OBSOLETE */ | |
622 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
623 | /* OBSOLETE From.Offset = 0; */ | |
624 | /* OBSOLETE err = UDIRead (From, myregs, 256, 4, &CountDone, HostEndian); */ | |
625 | /* OBSOLETE */ | |
626 | /* OBSOLETE printf ("err = %d, CountDone = %d\n", err, CountDone); */ | |
627 | /* OBSOLETE */ | |
628 | /* OBSOLETE printf ("\n"); */ | |
629 | /* OBSOLETE */ | |
630 | /* OBSOLETE for (i = 0; i < 256; i += 2) */ | |
631 | /* OBSOLETE printf ("%d:\t%#10x\t%11d\t%#10x\t%11d\n", i, myregs[i], myregs[i], */ | |
632 | /* OBSOLETE myregs[i + 1], myregs[i + 1]); */ | |
633 | /* OBSOLETE printf ("\n"); */ | |
634 | /* OBSOLETE */ | |
635 | /* OBSOLETE return pc[0]; */ | |
636 | /* OBSOLETE } */ | |
637 | /* OBSOLETE #endif */ | |
638 | /* OBSOLETE */ | |
639 | /* OBSOLETE /********************************************************** UDI_FETCH_REGISTERS */ | |
640 | /* OBSOLETE * Read a remote register 'regno'. */ | |
641 | /* OBSOLETE * If regno==-1 then read all the registers. */ | |
642 | /* OBSOLETE */ */ | |
643 | /* OBSOLETE static void */ | |
644 | /* OBSOLETE udi_fetch_registers (int regno) */ | |
645 | /* OBSOLETE { */ | |
646 | /* OBSOLETE UDIResource From; */ | |
647 | /* OBSOLETE UDIUInt32 *To; */ | |
648 | /* OBSOLETE UDICount Count; */ | |
649 | /* OBSOLETE UDISizeT Size = 4; */ | |
650 | /* OBSOLETE UDICount CountDone; */ | |
651 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
652 | /* OBSOLETE UDIError err; */ | |
653 | /* OBSOLETE int i; */ | |
654 | /* OBSOLETE */ | |
655 | /* OBSOLETE if (regno >= 0) */ | |
656 | /* OBSOLETE { */ | |
657 | /* OBSOLETE fetch_register (regno); */ | |
658 | /* OBSOLETE return; */ | |
659 | /* OBSOLETE } */ | |
660 | /* OBSOLETE */ | |
661 | /* OBSOLETE /* Gr1/rsp */ */ | |
662 | /* OBSOLETE */ | |
663 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
664 | /* OBSOLETE From.Offset = 1; */ | |
665 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * GR1_REGNUM]; */ | |
666 | /* OBSOLETE Count = 1; */ | |
667 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
668 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
669 | /* OBSOLETE */ | |
670 | /* OBSOLETE register_valid[GR1_REGNUM] = 1; */ | |
671 | /* OBSOLETE */ | |
672 | /* OBSOLETE #if defined(GR64_REGNUM) /* Read gr64-127 */ */ | |
673 | /* OBSOLETE */ | |
674 | /* OBSOLETE /* Global Registers gr64-gr95 */ */ | |
675 | /* OBSOLETE */ | |
676 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
677 | /* OBSOLETE From.Offset = 64; */ | |
678 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * GR64_REGNUM]; */ | |
679 | /* OBSOLETE Count = 32; */ | |
680 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
681 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
682 | /* OBSOLETE */ | |
683 | /* OBSOLETE for (i = GR64_REGNUM; i < GR64_REGNUM + 32; i++) */ | |
684 | /* OBSOLETE register_valid[i] = 1; */ | |
685 | /* OBSOLETE */ | |
686 | /* OBSOLETE #endif /* GR64_REGNUM */ */ | |
687 | /* OBSOLETE */ | |
688 | /* OBSOLETE /* Global Registers gr96-gr127 */ */ | |
689 | /* OBSOLETE */ | |
690 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
691 | /* OBSOLETE From.Offset = 96; */ | |
692 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * GR96_REGNUM]; */ | |
693 | /* OBSOLETE Count = 32; */ | |
694 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
695 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
696 | /* OBSOLETE */ | |
697 | /* OBSOLETE for (i = GR96_REGNUM; i < GR96_REGNUM + 32; i++) */ | |
698 | /* OBSOLETE register_valid[i] = 1; */ | |
699 | /* OBSOLETE */ | |
700 | /* OBSOLETE /* Local Registers */ */ | |
701 | /* OBSOLETE */ | |
702 | /* OBSOLETE From.Space = UDI29KLocalRegs; */ | |
703 | /* OBSOLETE From.Offset = 0; */ | |
704 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * LR0_REGNUM]; */ | |
705 | /* OBSOLETE Count = 128; */ | |
706 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
707 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
708 | /* OBSOLETE */ | |
709 | /* OBSOLETE for (i = LR0_REGNUM; i < LR0_REGNUM + 128; i++) */ | |
710 | /* OBSOLETE register_valid[i] = 1; */ | |
711 | /* OBSOLETE */ | |
712 | /* OBSOLETE /* Protected Special Registers */ */ | |
713 | /* OBSOLETE */ | |
714 | /* OBSOLETE From.Space = UDI29KSpecialRegs; */ | |
715 | /* OBSOLETE From.Offset = 0; */ | |
716 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * SR_REGNUM (0)]; */ | |
717 | /* OBSOLETE Count = 15; */ | |
718 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
719 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
720 | /* OBSOLETE */ | |
721 | /* OBSOLETE for (i = SR_REGNUM (0); i < SR_REGNUM (0) + 15; i++) */ | |
722 | /* OBSOLETE register_valid[i] = 1; */ | |
723 | /* OBSOLETE */ | |
724 | /* OBSOLETE if (USE_SHADOW_PC) */ | |
725 | /* OBSOLETE { /* Let regno_to_srnum() handle the register number */ */ | |
726 | /* OBSOLETE fetch_register (NPC_REGNUM); */ | |
727 | /* OBSOLETE fetch_register (PC_REGNUM); */ | |
728 | /* OBSOLETE fetch_register (PC2_REGNUM); */ | |
729 | /* OBSOLETE */ | |
730 | /* OBSOLETE /* Unprotected Special Registers sr128-sr135 */ */ | |
731 | /* OBSOLETE */ | |
732 | /* OBSOLETE From.Space = UDI29KSpecialRegs; */ | |
733 | /* OBSOLETE From.Offset = 128; */ | |
734 | /* OBSOLETE To = (UDIUInt32 *) & registers[4 * SR_REGNUM (128)]; */ | |
735 | /* OBSOLETE Count = 135 - 128 + 1; */ | |
736 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
737 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
738 | /* OBSOLETE */ | |
739 | /* OBSOLETE for (i = SR_REGNUM (128); i < SR_REGNUM (128) + 135 - 128 + 1; i++) */ | |
740 | /* OBSOLETE register_valid[i] = 1; */ | |
741 | /* OBSOLETE } */ | |
742 | /* OBSOLETE */ | |
743 | /* OBSOLETE if (remote_debug) */ | |
744 | /* OBSOLETE { */ | |
745 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, "Fetching all registers\n"); */ | |
746 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, */ | |
747 | /* OBSOLETE "Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", */ | |
748 | /* OBSOLETE read_register (NPC_REGNUM), */ | |
749 | /* OBSOLETE read_register (PC_REGNUM), */ | |
750 | /* OBSOLETE read_register (PC2_REGNUM)); */ | |
751 | /* OBSOLETE } */ | |
752 | /* OBSOLETE */ | |
753 | /* OBSOLETE /* There doesn't seem to be any way to get these. */ */ | |
754 | /* OBSOLETE { */ | |
755 | /* OBSOLETE int val = -1; */ | |
756 | /* OBSOLETE supply_register (FPE_REGNUM, (char *) &val); */ | |
757 | /* OBSOLETE supply_register (INTE_REGNUM, (char *) &val); */ | |
758 | /* OBSOLETE supply_register (FPS_REGNUM, (char *) &val); */ | |
759 | /* OBSOLETE supply_register (EXO_REGNUM, (char *) &val); */ | |
760 | /* OBSOLETE } */ | |
761 | /* OBSOLETE } */ | |
762 | /* OBSOLETE */ | |
763 | /* OBSOLETE */ | |
764 | /* OBSOLETE /********************************************************* UDI_STORE_REGISTERS */ | |
765 | /* OBSOLETE ** Store register regno into the target. */ | |
766 | /* OBSOLETE * If regno==-1 then store all the registers. */ | |
767 | /* OBSOLETE */ */ | |
768 | /* OBSOLETE */ | |
769 | /* OBSOLETE static void */ | |
770 | /* OBSOLETE udi_store_registers (int regno) */ | |
771 | /* OBSOLETE { */ | |
772 | /* OBSOLETE UDIUInt32 *From; */ | |
773 | /* OBSOLETE UDIResource To; */ | |
774 | /* OBSOLETE UDICount Count; */ | |
775 | /* OBSOLETE UDISizeT Size = 4; */ | |
776 | /* OBSOLETE UDICount CountDone; */ | |
777 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
778 | /* OBSOLETE */ | |
779 | /* OBSOLETE if (regno >= 0) */ | |
780 | /* OBSOLETE { */ | |
781 | /* OBSOLETE store_register (regno); */ | |
782 | /* OBSOLETE return; */ | |
783 | /* OBSOLETE } */ | |
784 | /* OBSOLETE */ | |
785 | /* OBSOLETE if (remote_debug) */ | |
786 | /* OBSOLETE { */ | |
787 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, "Storing all registers\n"); */ | |
788 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, */ | |
789 | /* OBSOLETE "PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", */ | |
790 | /* OBSOLETE read_register (NPC_REGNUM), */ | |
791 | /* OBSOLETE read_register (PC_REGNUM), */ | |
792 | /* OBSOLETE read_register (PC2_REGNUM)); */ | |
793 | /* OBSOLETE } */ | |
794 | /* OBSOLETE */ | |
795 | /* OBSOLETE /* Gr1/rsp */ */ | |
796 | /* OBSOLETE */ | |
797 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * GR1_REGNUM]; */ | |
798 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
799 | /* OBSOLETE To.Offset = 1; */ | |
800 | /* OBSOLETE Count = 1; */ | |
801 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
802 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
803 | /* OBSOLETE */ | |
804 | /* OBSOLETE #if defined(GR64_REGNUM) */ | |
805 | /* OBSOLETE */ | |
806 | /* OBSOLETE /* Global registers gr64-gr95 */ */ | |
807 | /* OBSOLETE */ | |
808 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * GR64_REGNUM]; */ | |
809 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
810 | /* OBSOLETE To.Offset = 64; */ | |
811 | /* OBSOLETE Count = 32; */ | |
812 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
813 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
814 | /* OBSOLETE */ | |
815 | /* OBSOLETE #endif /* GR64_REGNUM */ */ | |
816 | /* OBSOLETE */ | |
817 | /* OBSOLETE /* Global registers gr96-gr127 */ */ | |
818 | /* OBSOLETE */ | |
819 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * GR96_REGNUM]; */ | |
820 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
821 | /* OBSOLETE To.Offset = 96; */ | |
822 | /* OBSOLETE Count = 32; */ | |
823 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
824 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
825 | /* OBSOLETE */ | |
826 | /* OBSOLETE /* Local Registers */ */ | |
827 | /* OBSOLETE */ | |
828 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * LR0_REGNUM]; */ | |
829 | /* OBSOLETE To.Space = UDI29KLocalRegs; */ | |
830 | /* OBSOLETE To.Offset = 0; */ | |
831 | /* OBSOLETE Count = 128; */ | |
832 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
833 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
834 | /* OBSOLETE */ | |
835 | /* OBSOLETE */ | |
836 | /* OBSOLETE /* Protected Special Registers *//* VAB through TMR */ */ | |
837 | /* OBSOLETE */ | |
838 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * SR_REGNUM (0)]; */ | |
839 | /* OBSOLETE To.Space = UDI29KSpecialRegs; */ | |
840 | /* OBSOLETE To.Offset = 0; */ | |
841 | /* OBSOLETE Count = 10; */ | |
842 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
843 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
844 | /* OBSOLETE */ | |
845 | /* OBSOLETE /* PC0, PC1, PC2 possibly as shadow registers */ */ | |
846 | /* OBSOLETE */ | |
847 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * SR_REGNUM (10)]; */ | |
848 | /* OBSOLETE To.Space = UDI29KSpecialRegs; */ | |
849 | /* OBSOLETE Count = 3; */ | |
850 | /* OBSOLETE if (USE_SHADOW_PC) */ | |
851 | /* OBSOLETE To.Offset = 20; /* SPC0 */ */ | |
852 | /* OBSOLETE else */ | |
853 | /* OBSOLETE To.Offset = 10; /* PC0 */ */ | |
854 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
855 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
856 | /* OBSOLETE */ | |
857 | /* OBSOLETE /* PC1 via UDI29KPC */ */ | |
858 | /* OBSOLETE */ | |
859 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * PC_REGNUM]; */ | |
860 | /* OBSOLETE To.Space = UDI29KPC; */ | |
861 | /* OBSOLETE To.Offset = 0; /* PC1 */ */ | |
862 | /* OBSOLETE Count = 1; */ | |
863 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
864 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
865 | /* OBSOLETE */ | |
866 | /* OBSOLETE /* LRU and MMU */ */ | |
867 | /* OBSOLETE */ | |
868 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * SR_REGNUM (13)]; */ | |
869 | /* OBSOLETE To.Space = UDI29KSpecialRegs; */ | |
870 | /* OBSOLETE To.Offset = 13; */ | |
871 | /* OBSOLETE Count = 2; */ | |
872 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
873 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
874 | /* OBSOLETE */ | |
875 | /* OBSOLETE /* Unprotected Special Registers */ */ | |
876 | /* OBSOLETE */ | |
877 | /* OBSOLETE From = (UDIUInt32 *) & registers[4 * SR_REGNUM (128)]; */ | |
878 | /* OBSOLETE To.Space = UDI29KSpecialRegs; */ | |
879 | /* OBSOLETE To.Offset = 128; */ | |
880 | /* OBSOLETE Count = 135 - 128 + 1; */ | |
881 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
882 | /* OBSOLETE error ("UDIWrite() failed in udi_store_regisetrs"); */ | |
883 | /* OBSOLETE */ | |
884 | /* OBSOLETE registers_changed (); */ | |
885 | /* OBSOLETE } */ | |
886 | /* OBSOLETE */ | |
887 | /* OBSOLETE /****************************************************** UDI_PREPARE_TO_STORE */ */ | |
888 | /* OBSOLETE /* Get ready to modify the registers array. On machines which store */ | |
889 | /* OBSOLETE individual registers, this doesn't need to do anything. On machines */ | |
890 | /* OBSOLETE which store all the registers in one fell swoop, this makes sure */ | |
891 | /* OBSOLETE that registers contains all the registers from the program being */ | |
892 | /* OBSOLETE debugged. */ */ | |
893 | /* OBSOLETE */ | |
894 | /* OBSOLETE static void */ | |
895 | /* OBSOLETE udi_prepare_to_store (void) */ | |
896 | /* OBSOLETE { */ | |
897 | /* OBSOLETE /* Do nothing, since we can store individual regs */ */ | |
898 | /* OBSOLETE } */ | |
899 | /* OBSOLETE */ | |
900 | /* OBSOLETE /********************************************************** TRANSLATE_ADDR */ */ | |
901 | /* OBSOLETE static CORE_ADDR */ | |
902 | /* OBSOLETE translate_addr (CORE_ADDR addr) */ | |
903 | /* OBSOLETE { */ | |
904 | /* OBSOLETE #if defined(ULTRA3) && defined(KERNEL_DEBUGGING) */ | |
905 | /* OBSOLETE /* Check for a virtual address in the kernel */ */ | |
906 | /* OBSOLETE /* Assume physical address of ublock is in paddr_u register */ */ | |
907 | /* OBSOLETE /* FIXME: doesn't work for user virtual addresses */ */ | |
908 | /* OBSOLETE if (addr >= UVADDR) */ | |
909 | /* OBSOLETE { */ | |
910 | /* OBSOLETE /* PADDR_U register holds the physical address of the ublock */ */ | |
911 | /* OBSOLETE CORE_ADDR i = (CORE_ADDR) read_register (PADDR_U_REGNUM); */ | |
912 | /* OBSOLETE return (i + addr - (CORE_ADDR) UVADDR); */ | |
913 | /* OBSOLETE } */ | |
914 | /* OBSOLETE else */ | |
915 | /* OBSOLETE { */ | |
916 | /* OBSOLETE return (addr); */ | |
917 | /* OBSOLETE } */ | |
918 | /* OBSOLETE #else */ | |
919 | /* OBSOLETE return (addr); */ | |
920 | /* OBSOLETE #endif */ | |
921 | /* OBSOLETE } */ | |
922 | /* OBSOLETE /************************************************* UDI_XFER_INFERIOR_MEMORY */ */ | |
923 | /* OBSOLETE /* FIXME! Merge these two. */ */ | |
924 | /* OBSOLETE static int */ | |
925 | /* OBSOLETE udi_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, */ | |
926 | /* OBSOLETE struct mem_attrib *attrib ATTRIBUTE_UNUSED, */ | |
927 | /* OBSOLETE struct target_ops *target ATTRIBUTE_UNUSED) */ | |
928 | /* OBSOLETE { */ | |
929 | /* OBSOLETE */ | |
930 | /* OBSOLETE memaddr = translate_addr (memaddr); */ | |
931 | /* OBSOLETE */ | |
932 | /* OBSOLETE if (write) */ | |
933 | /* OBSOLETE return udi_write_inferior_memory (memaddr, myaddr, len); */ | |
934 | /* OBSOLETE else */ | |
935 | /* OBSOLETE return udi_read_inferior_memory (memaddr, myaddr, len); */ | |
936 | /* OBSOLETE } */ | |
937 | /* OBSOLETE */ | |
938 | /* OBSOLETE /********************************************************** UDI_FILES_INFO */ */ | |
939 | /* OBSOLETE static void */ | |
940 | /* OBSOLETE udi_files_info (struct target_ops *target) */ | |
941 | /* OBSOLETE { */ | |
942 | /* OBSOLETE printf_unfiltered ("\tAttached to UDI socket to %s", udi_config_id); */ | |
943 | /* OBSOLETE if (prog_name != NULL) */ | |
944 | /* OBSOLETE printf_unfiltered ("and running program %s", prog_name); */ | |
945 | /* OBSOLETE printf_unfiltered (".\n"); */ | |
946 | /* OBSOLETE } */ | |
947 | /* OBSOLETE */ | |
948 | /* OBSOLETE /**************************************************** UDI_INSERT_BREAKPOINT */ */ | |
949 | /* OBSOLETE static int */ | |
950 | /* OBSOLETE udi_insert_breakpoint (CORE_ADDR addr, char *contents_cache) */ | |
951 | /* OBSOLETE { */ | |
952 | /* OBSOLETE int cnt; */ | |
953 | /* OBSOLETE UDIError err; */ | |
954 | /* OBSOLETE */ | |
955 | /* OBSOLETE for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) */ | |
956 | /* OBSOLETE if (bkpt_table[cnt].Type == 0) /* Find first free slot */ */ | |
957 | /* OBSOLETE break; */ | |
958 | /* OBSOLETE */ | |
959 | /* OBSOLETE if (cnt >= BKPT_TABLE_SIZE) */ | |
960 | /* OBSOLETE error ("Too many breakpoints set"); */ | |
961 | /* OBSOLETE */ | |
962 | /* OBSOLETE bkpt_table[cnt].Addr.Offset = addr; */ | |
963 | /* OBSOLETE bkpt_table[cnt].Addr.Space = UDI29KIRAMSpace; */ | |
964 | /* OBSOLETE bkpt_table[cnt].PassCount = 1; */ | |
965 | /* OBSOLETE bkpt_table[cnt].Type = UDIBreakFlagExecute; */ | |
966 | /* OBSOLETE */ | |
967 | /* OBSOLETE err = UDISetBreakpoint (bkpt_table[cnt].Addr, */ | |
968 | /* OBSOLETE bkpt_table[cnt].PassCount, */ | |
969 | /* OBSOLETE bkpt_table[cnt].Type, */ | |
970 | /* OBSOLETE &bkpt_table[cnt].BreakId); */ | |
971 | /* OBSOLETE */ | |
972 | /* OBSOLETE if (err == 0) */ | |
973 | /* OBSOLETE return 0; /* Success */ */ | |
974 | /* OBSOLETE */ | |
975 | /* OBSOLETE bkpt_table[cnt].Type = 0; */ | |
976 | /* OBSOLETE error ("UDISetBreakpoint returned error code %d\n", err); */ | |
977 | /* OBSOLETE } */ | |
978 | /* OBSOLETE */ | |
979 | /* OBSOLETE /**************************************************** UDI_REMOVE_BREAKPOINT */ */ | |
980 | /* OBSOLETE static int */ | |
981 | /* OBSOLETE udi_remove_breakpoint (CORE_ADDR addr, char *contents_cache) */ | |
982 | /* OBSOLETE { */ | |
983 | /* OBSOLETE int cnt; */ | |
984 | /* OBSOLETE UDIError err; */ | |
985 | /* OBSOLETE */ | |
986 | /* OBSOLETE for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) */ | |
987 | /* OBSOLETE if (bkpt_table[cnt].Addr.Offset == addr) /* Find matching breakpoint */ */ | |
988 | /* OBSOLETE break; */ | |
989 | /* OBSOLETE */ | |
990 | /* OBSOLETE if (cnt >= BKPT_TABLE_SIZE) */ | |
991 | /* OBSOLETE error ("Can't find breakpoint in table"); */ | |
992 | /* OBSOLETE */ | |
993 | /* OBSOLETE bkpt_table[cnt].Type = 0; */ | |
994 | /* OBSOLETE */ | |
995 | /* OBSOLETE err = UDIClearBreakpoint (bkpt_table[cnt].BreakId); */ | |
996 | /* OBSOLETE if (err == 0) */ | |
997 | /* OBSOLETE return 0; /* Success */ */ | |
998 | /* OBSOLETE */ | |
999 | /* OBSOLETE error ("UDIClearBreakpoint returned error code %d\n", err); */ | |
1000 | /* OBSOLETE } */ | |
1001 | /* OBSOLETE */ | |
1002 | /* OBSOLETE static void */ | |
1003 | /* OBSOLETE udi_kill (void) */ | |
1004 | /* OBSOLETE { */ | |
1005 | /* OBSOLETE */ | |
1006 | /* OBSOLETE #if 0 */ | |
1007 | /* OBSOLETE /* */ | |
1008 | /* OBSOLETE UDIStop does not really work as advertised. It causes the TIP to close it's */ | |
1009 | /* OBSOLETE connection, which usually results in GDB dying with a SIGPIPE. For now, we */ | |
1010 | /* OBSOLETE just invoke udi_close, which seems to get things right. */ | |
1011 | /* OBSOLETE */ */ | |
1012 | /* OBSOLETE UDIStop (); */ | |
1013 | /* OBSOLETE */ | |
1014 | /* OBSOLETE udi_session_id = -1; */ | |
1015 | /* OBSOLETE inferior_ptid = null_ptid; */ | |
1016 | /* OBSOLETE */ | |
1017 | /* OBSOLETE if (from_tty) */ | |
1018 | /* OBSOLETE printf_unfiltered ("Target has been stopped."); */ | |
1019 | /* OBSOLETE #endif /* 0 */ */ | |
1020 | /* OBSOLETE #if 0 */ | |
1021 | /* OBSOLETE udi_close (0); */ | |
1022 | /* OBSOLETE pop_target (); */ | |
1023 | /* OBSOLETE #endif /* 0 */ */ | |
1024 | /* OBSOLETE */ | |
1025 | /* OBSOLETE /* Keep the target around, e.g. so "run" can do the right thing when */ | |
1026 | /* OBSOLETE we are already debugging something. */ */ | |
1027 | /* OBSOLETE */ | |
1028 | /* OBSOLETE if (UDIDisconnect (udi_session_id, UDITerminateSession)) */ | |
1029 | /* OBSOLETE { */ | |
1030 | /* OBSOLETE warning ("UDIDisconnect() failed"); */ | |
1031 | /* OBSOLETE } */ | |
1032 | /* OBSOLETE */ | |
1033 | /* OBSOLETE /* Do not try to close udi_session_id again, later in the program. */ */ | |
1034 | /* OBSOLETE udi_session_id = -1; */ | |
1035 | /* OBSOLETE inferior_ptid = null_ptid; */ | |
1036 | /* OBSOLETE } */ | |
1037 | /* OBSOLETE */ | |
1038 | /* OBSOLETE /* */ | |
1039 | /* OBSOLETE Load a program into the target. Args are: `program {options}'. The options */ | |
1040 | /* OBSOLETE are used to control loading of the program, and are NOT passed onto the */ | |
1041 | /* OBSOLETE loaded code as arguments. (You need to use the `run' command to do that.) */ | |
1042 | /* OBSOLETE */ | |
1043 | /* OBSOLETE The options are: */ | |
1044 | /* OBSOLETE -ms %d Set mem stack size to %d */ | |
1045 | /* OBSOLETE -rs %d Set regular stack size to %d */ | |
1046 | /* OBSOLETE -i send init info (default) */ | |
1047 | /* OBSOLETE -noi don't send init info */ | |
1048 | /* OBSOLETE -[tT] Load Text section */ | |
1049 | /* OBSOLETE -[dD] Load Data section */ | |
1050 | /* OBSOLETE -[bB] Load BSS section */ | |
1051 | /* OBSOLETE -[lL] Load Lit section */ | |
1052 | /* OBSOLETE */ */ | |
1053 | /* OBSOLETE */ | |
1054 | /* OBSOLETE static void */ | |
1055 | /* OBSOLETE download (char *load_arg_string, int from_tty) */ | |
1056 | /* OBSOLETE { */ | |
1057 | /* OBSOLETE #define DEFAULT_MEM_STACK_SIZE 0x6000 */ | |
1058 | /* OBSOLETE #define DEFAULT_REG_STACK_SIZE 0x2000 */ | |
1059 | /* OBSOLETE */ | |
1060 | /* OBSOLETE char *token; */ | |
1061 | /* OBSOLETE char *filename; */ | |
1062 | /* OBSOLETE asection *section; */ | |
1063 | /* OBSOLETE bfd *pbfd; */ | |
1064 | /* OBSOLETE UDIError err; */ | |
1065 | /* OBSOLETE int load_text = 1, load_data = 1, load_bss = 1, load_lit = 1; */ | |
1066 | /* OBSOLETE */ | |
1067 | /* OBSOLETE address_ranges[0].Space = UDI29KIRAMSpace; */ | |
1068 | /* OBSOLETE address_ranges[0].Offset = 0xffffffff; */ | |
1069 | /* OBSOLETE address_ranges[0].Size = 0; */ | |
1070 | /* OBSOLETE */ | |
1071 | /* OBSOLETE address_ranges[1].Space = UDI29KDRAMSpace; */ | |
1072 | /* OBSOLETE address_ranges[1].Offset = 0xffffffff; */ | |
1073 | /* OBSOLETE address_ranges[1].Size = 0; */ | |
1074 | /* OBSOLETE */ | |
1075 | /* OBSOLETE stack_sizes[0] = DEFAULT_REG_STACK_SIZE; */ | |
1076 | /* OBSOLETE stack_sizes[1] = DEFAULT_MEM_STACK_SIZE; */ | |
1077 | /* OBSOLETE */ | |
1078 | /* OBSOLETE dont_repeat (); */ | |
1079 | /* OBSOLETE */ | |
1080 | /* OBSOLETE filename = strtok (load_arg_string, " \t"); */ | |
1081 | /* OBSOLETE if (!filename) */ | |
1082 | /* OBSOLETE error ("Must specify at least a file name with the load command"); */ | |
1083 | /* OBSOLETE */ | |
1084 | /* OBSOLETE filename = tilde_expand (filename); */ | |
1085 | /* OBSOLETE make_cleanup (xfree, filename); */ | |
1086 | /* OBSOLETE */ | |
1087 | /* OBSOLETE while (token = strtok (NULL, " \t")) */ | |
1088 | /* OBSOLETE { */ | |
1089 | /* OBSOLETE if (token[0] == '-') */ | |
1090 | /* OBSOLETE { */ | |
1091 | /* OBSOLETE token++; */ | |
1092 | /* OBSOLETE */ | |
1093 | /* OBSOLETE if (STREQ (token, "ms")) */ | |
1094 | /* OBSOLETE stack_sizes[1] = atol (strtok (NULL, " \t")); */ | |
1095 | /* OBSOLETE else if (STREQ (token, "rs")) */ | |
1096 | /* OBSOLETE stack_sizes[0] = atol (strtok (NULL, " \t")); */ | |
1097 | /* OBSOLETE else */ | |
1098 | /* OBSOLETE { */ | |
1099 | /* OBSOLETE load_text = load_data = load_bss = load_lit = 0; */ | |
1100 | /* OBSOLETE */ | |
1101 | /* OBSOLETE while (*token) */ | |
1102 | /* OBSOLETE { */ | |
1103 | /* OBSOLETE switch (*token++) */ | |
1104 | /* OBSOLETE { */ | |
1105 | /* OBSOLETE case 't': */ | |
1106 | /* OBSOLETE case 'T': */ | |
1107 | /* OBSOLETE load_text = 1; */ | |
1108 | /* OBSOLETE break; */ | |
1109 | /* OBSOLETE case 'd': */ | |
1110 | /* OBSOLETE case 'D': */ | |
1111 | /* OBSOLETE load_data = 1; */ | |
1112 | /* OBSOLETE break; */ | |
1113 | /* OBSOLETE case 'b': */ | |
1114 | /* OBSOLETE case 'B': */ | |
1115 | /* OBSOLETE load_bss = 1; */ | |
1116 | /* OBSOLETE break; */ | |
1117 | /* OBSOLETE case 'l': */ | |
1118 | /* OBSOLETE case 'L': */ | |
1119 | /* OBSOLETE load_lit = 1; */ | |
1120 | /* OBSOLETE break; */ | |
1121 | /* OBSOLETE default: */ | |
1122 | /* OBSOLETE error ("Unknown UDI load option -%s", token - 1); */ | |
1123 | /* OBSOLETE } */ | |
1124 | /* OBSOLETE } */ | |
1125 | /* OBSOLETE } */ | |
1126 | /* OBSOLETE } */ | |
1127 | /* OBSOLETE } */ | |
1128 | /* OBSOLETE */ | |
1129 | /* OBSOLETE pbfd = bfd_openr (filename, gnutarget); */ | |
1130 | /* OBSOLETE */ | |
1131 | /* OBSOLETE if (!pbfd) */ | |
1132 | /* OBSOLETE /* FIXME: should be using bfd_errmsg, not assuming it was */ | |
1133 | /* OBSOLETE bfd_error_system_call. */ */ | |
1134 | /* OBSOLETE perror_with_name (filename); */ | |
1135 | /* OBSOLETE */ | |
1136 | /* OBSOLETE /* FIXME: should be checking for errors from bfd_close (for one thing, */ | |
1137 | /* OBSOLETE on error it does not free all the storage associated with the */ | |
1138 | /* OBSOLETE bfd). */ */ | |
1139 | /* OBSOLETE make_cleanup_bfd_close (pbfd); */ | |
1140 | /* OBSOLETE */ | |
1141 | /* OBSOLETE QUIT; */ | |
1142 | /* OBSOLETE immediate_quit++; */ | |
1143 | /* OBSOLETE */ | |
1144 | /* OBSOLETE if (!bfd_check_format (pbfd, bfd_object)) */ | |
1145 | /* OBSOLETE error ("It doesn't seem to be an object file"); */ | |
1146 | /* OBSOLETE */ | |
1147 | /* OBSOLETE for (section = pbfd->sections; section; section = section->next) */ | |
1148 | /* OBSOLETE { */ | |
1149 | /* OBSOLETE if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC) */ | |
1150 | /* OBSOLETE { */ | |
1151 | /* OBSOLETE UDIResource To; */ | |
1152 | /* OBSOLETE UDICount Count; */ | |
1153 | /* OBSOLETE unsigned long section_size, section_end; */ | |
1154 | /* OBSOLETE const char *section_name; */ | |
1155 | /* OBSOLETE */ | |
1156 | /* OBSOLETE section_name = bfd_get_section_name (pbfd, section); */ | |
1157 | /* OBSOLETE if (STREQ (section_name, ".text") && !load_text) */ | |
1158 | /* OBSOLETE continue; */ | |
1159 | /* OBSOLETE else if (STREQ (section_name, ".data") && !load_data) */ | |
1160 | /* OBSOLETE continue; */ | |
1161 | /* OBSOLETE else if (STREQ (section_name, ".bss") && !load_bss) */ | |
1162 | /* OBSOLETE continue; */ | |
1163 | /* OBSOLETE else if (STREQ (section_name, ".lit") && !load_lit) */ | |
1164 | /* OBSOLETE continue; */ | |
1165 | /* OBSOLETE */ | |
1166 | /* OBSOLETE To.Offset = bfd_get_section_vma (pbfd, section); */ | |
1167 | /* OBSOLETE section_size = bfd_section_size (pbfd, section); */ | |
1168 | /* OBSOLETE section_end = To.Offset + section_size; */ | |
1169 | /* OBSOLETE */ | |
1170 | /* OBSOLETE if (section_size == 0) */ | |
1171 | /* OBSOLETE /* This is needed at least in the BSS case, where the code */ | |
1172 | /* OBSOLETE below starts writing before it even checks the size. */ */ | |
1173 | /* OBSOLETE continue; */ | |
1174 | /* OBSOLETE */ | |
1175 | /* OBSOLETE printf_unfiltered ("[Loading section %s at %x (%d bytes)]\n", */ | |
1176 | /* OBSOLETE section_name, */ | |
1177 | /* OBSOLETE To.Offset, */ | |
1178 | /* OBSOLETE section_size); */ | |
1179 | /* OBSOLETE */ | |
1180 | /* OBSOLETE if (bfd_get_section_flags (pbfd, section) & SEC_CODE) */ | |
1181 | /* OBSOLETE { */ | |
1182 | /* OBSOLETE To.Space = UDI29KIRAMSpace; */ | |
1183 | /* OBSOLETE */ | |
1184 | /* OBSOLETE address_ranges[0].Offset = min (address_ranges[0].Offset, */ | |
1185 | /* OBSOLETE To.Offset); */ | |
1186 | /* OBSOLETE address_ranges[0].Size = max (address_ranges[0].Size, */ | |
1187 | /* OBSOLETE section_end */ | |
1188 | /* OBSOLETE - address_ranges[0].Offset); */ | |
1189 | /* OBSOLETE } */ | |
1190 | /* OBSOLETE else */ | |
1191 | /* OBSOLETE { */ | |
1192 | /* OBSOLETE To.Space = UDI29KDRAMSpace; */ | |
1193 | /* OBSOLETE */ | |
1194 | /* OBSOLETE address_ranges[1].Offset = min (address_ranges[1].Offset, */ | |
1195 | /* OBSOLETE To.Offset); */ | |
1196 | /* OBSOLETE address_ranges[1].Size = max (address_ranges[1].Size, */ | |
1197 | /* OBSOLETE section_end */ | |
1198 | /* OBSOLETE - address_ranges[1].Offset); */ | |
1199 | /* OBSOLETE } */ | |
1200 | /* OBSOLETE */ | |
1201 | /* OBSOLETE if (bfd_get_section_flags (pbfd, section) & SEC_LOAD) /* Text, data or lit */ */ | |
1202 | /* OBSOLETE { */ | |
1203 | /* OBSOLETE file_ptr fptr; */ | |
1204 | /* OBSOLETE */ | |
1205 | /* OBSOLETE fptr = 0; */ | |
1206 | /* OBSOLETE */ | |
1207 | /* OBSOLETE while (section_size > 0) */ | |
1208 | /* OBSOLETE { */ | |
1209 | /* OBSOLETE char buffer[1024]; */ | |
1210 | /* OBSOLETE */ | |
1211 | /* OBSOLETE Count = min (section_size, 1024); */ | |
1212 | /* OBSOLETE */ | |
1213 | /* OBSOLETE bfd_get_section_contents (pbfd, section, buffer, fptr, */ | |
1214 | /* OBSOLETE Count); */ | |
1215 | /* OBSOLETE */ | |
1216 | /* OBSOLETE err = UDIWrite ((UDIHostMemPtr) buffer, /* From */ */ | |
1217 | /* OBSOLETE To, /* To */ */ | |
1218 | /* OBSOLETE Count, /* Count */ */ | |
1219 | /* OBSOLETE (UDISizeT) 1, /* Size */ */ | |
1220 | /* OBSOLETE &Count, /* CountDone */ */ | |
1221 | /* OBSOLETE (UDIBool) 0); /* HostEndian */ */ | |
1222 | /* OBSOLETE if (err) */ | |
1223 | /* OBSOLETE error ("UDIWrite failed, error = %d", err); */ | |
1224 | /* OBSOLETE */ | |
1225 | /* OBSOLETE To.Offset += Count; */ | |
1226 | /* OBSOLETE fptr += Count; */ | |
1227 | /* OBSOLETE section_size -= Count; */ | |
1228 | /* OBSOLETE } */ | |
1229 | /* OBSOLETE } */ | |
1230 | /* OBSOLETE else */ | |
1231 | /* OBSOLETE /* BSS */ */ | |
1232 | /* OBSOLETE { */ | |
1233 | /* OBSOLETE UDIResource From; */ | |
1234 | /* OBSOLETE unsigned long zero = 0; */ | |
1235 | /* OBSOLETE */ | |
1236 | /* OBSOLETE /* Write a zero byte at the vma */ */ | |
1237 | /* OBSOLETE /* FIXME: Broken for sections of 1-3 bytes (we test for */ | |
1238 | /* OBSOLETE zero above). */ */ | |
1239 | /* OBSOLETE err = UDIWrite ((UDIHostMemPtr) & zero, /* From */ */ | |
1240 | /* OBSOLETE To, /* To */ */ | |
1241 | /* OBSOLETE (UDICount) 1, /* Count */ */ | |
1242 | /* OBSOLETE (UDISizeT) 4, /* Size */ */ | |
1243 | /* OBSOLETE &Count, /* CountDone */ */ | |
1244 | /* OBSOLETE (UDIBool) 0); /* HostEndian */ */ | |
1245 | /* OBSOLETE if (err) */ | |
1246 | /* OBSOLETE error ("UDIWrite failed, error = %d", err); */ | |
1247 | /* OBSOLETE */ | |
1248 | /* OBSOLETE From = To; */ | |
1249 | /* OBSOLETE To.Offset += 4; */ | |
1250 | /* OBSOLETE */ | |
1251 | /* OBSOLETE /* Now, duplicate it for the length of the BSS */ */ | |
1252 | /* OBSOLETE err = UDICopy (From, /* From */ */ | |
1253 | /* OBSOLETE To, /* To */ */ | |
1254 | /* OBSOLETE (UDICount) (section_size / 4 - 1), /* Count */ */ | |
1255 | /* OBSOLETE (UDISizeT) 4, /* Size */ */ | |
1256 | /* OBSOLETE &Count, /* CountDone */ */ | |
1257 | /* OBSOLETE (UDIBool) 1); /* Direction */ */ | |
1258 | /* OBSOLETE if (err) */ | |
1259 | /* OBSOLETE { */ | |
1260 | /* OBSOLETE char message[100]; */ | |
1261 | /* OBSOLETE int xerr; */ | |
1262 | /* OBSOLETE */ | |
1263 | /* OBSOLETE xerr = UDIGetErrorMsg (err, 100, message, &Count); */ | |
1264 | /* OBSOLETE if (!xerr) */ | |
1265 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "Error is %s\n", message); */ | |
1266 | /* OBSOLETE else */ | |
1267 | /* OBSOLETE fprintf_unfiltered (gdb_stderr, "xerr is %d\n", xerr); */ | |
1268 | /* OBSOLETE error ("UDICopy failed, error = %d", err); */ | |
1269 | /* OBSOLETE } */ | |
1270 | /* OBSOLETE } */ | |
1271 | /* OBSOLETE */ | |
1272 | /* OBSOLETE } */ | |
1273 | /* OBSOLETE } */ | |
1274 | /* OBSOLETE */ | |
1275 | /* OBSOLETE entry.Space = UDI29KIRAMSpace; */ | |
1276 | /* OBSOLETE entry.Offset = bfd_get_start_address (pbfd); */ | |
1277 | /* OBSOLETE */ | |
1278 | /* OBSOLETE immediate_quit--; */ | |
1279 | /* OBSOLETE } */ | |
1280 | /* OBSOLETE */ | |
1281 | /* OBSOLETE /* Function to download an image into the remote target. */ */ | |
1282 | /* OBSOLETE */ | |
1283 | /* OBSOLETE static void */ | |
1284 | /* OBSOLETE udi_load (char *args, int from_tty) */ | |
1285 | /* OBSOLETE { */ | |
1286 | /* OBSOLETE download (args, from_tty); */ | |
1287 | /* OBSOLETE */ | |
1288 | /* OBSOLETE /* As a convenience, pick up any symbol info that is in the program */ | |
1289 | /* OBSOLETE being loaded. Note that we assume that the program is the``mainline''; */ | |
1290 | /* OBSOLETE if this is not always true, then this code will need to be augmented. */ */ | |
1291 | /* OBSOLETE symbol_file_add (strtok (args, " \t"), from_tty, NULL, 1, 0); */ | |
1292 | /* OBSOLETE */ | |
1293 | /* OBSOLETE /* Getting new symbols may change our opinion about what is */ | |
1294 | /* OBSOLETE frameless. */ */ | |
1295 | /* OBSOLETE reinit_frame_cache (); */ | |
1296 | /* OBSOLETE } */ | |
1297 | /* OBSOLETE */ | |
1298 | /* OBSOLETE /*************************************************** UDI_WRITE_INFERIOR_MEMORY */ | |
1299 | /* OBSOLETE ** Copy LEN bytes of data from debugger memory at MYADDR */ | |
1300 | /* OBSOLETE to inferior's memory at MEMADDR. Returns number of bytes written. */ */ | |
1301 | /* OBSOLETE static int */ | |
1302 | /* OBSOLETE udi_write_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) */ | |
1303 | /* OBSOLETE { */ | |
1304 | /* OBSOLETE int nwritten = 0; */ | |
1305 | /* OBSOLETE UDIUInt32 *From; */ | |
1306 | /* OBSOLETE UDIResource To; */ | |
1307 | /* OBSOLETE UDICount Count; */ | |
1308 | /* OBSOLETE UDISizeT Size = 1; */ | |
1309 | /* OBSOLETE UDICount CountDone = 0; */ | |
1310 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
1311 | /* OBSOLETE */ | |
1312 | /* OBSOLETE To.Space = udi_memory_space (memaddr); */ | |
1313 | /* OBSOLETE From = (UDIUInt32 *) myaddr; */ | |
1314 | /* OBSOLETE */ | |
1315 | /* OBSOLETE while (nwritten < len) */ | |
1316 | /* OBSOLETE { */ | |
1317 | /* OBSOLETE Count = len - nwritten; */ | |
1318 | /* OBSOLETE if (Count > MAXDATA) */ | |
1319 | /* OBSOLETE Count = MAXDATA; */ | |
1320 | /* OBSOLETE To.Offset = memaddr + nwritten; */ | |
1321 | /* OBSOLETE if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) */ | |
1322 | /* OBSOLETE { */ | |
1323 | /* OBSOLETE error ("UDIWrite() failed in udi_write_inferior_memory"); */ | |
1324 | /* OBSOLETE break; */ | |
1325 | /* OBSOLETE } */ | |
1326 | /* OBSOLETE else */ | |
1327 | /* OBSOLETE { */ | |
1328 | /* OBSOLETE nwritten += CountDone; */ | |
1329 | /* OBSOLETE From += CountDone; */ | |
1330 | /* OBSOLETE } */ | |
1331 | /* OBSOLETE } */ | |
1332 | /* OBSOLETE return (nwritten); */ | |
1333 | /* OBSOLETE } */ | |
1334 | /* OBSOLETE */ | |
1335 | /* OBSOLETE /**************************************************** UDI_READ_INFERIOR_MEMORY */ | |
1336 | /* OBSOLETE ** Read LEN bytes from inferior memory at MEMADDR. Put the result */ | |
1337 | /* OBSOLETE at debugger address MYADDR. Returns number of bytes read. */ */ | |
1338 | /* OBSOLETE static int */ | |
1339 | /* OBSOLETE udi_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) */ | |
1340 | /* OBSOLETE { */ | |
1341 | /* OBSOLETE int nread = 0; */ | |
1342 | /* OBSOLETE UDIResource From; */ | |
1343 | /* OBSOLETE UDIUInt32 *To; */ | |
1344 | /* OBSOLETE UDICount Count; */ | |
1345 | /* OBSOLETE UDISizeT Size = 1; */ | |
1346 | /* OBSOLETE UDICount CountDone = 0; */ | |
1347 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
1348 | /* OBSOLETE UDIError err; */ | |
1349 | /* OBSOLETE */ | |
1350 | /* OBSOLETE From.Space = udi_memory_space (memaddr); */ | |
1351 | /* OBSOLETE To = (UDIUInt32 *) myaddr; */ | |
1352 | /* OBSOLETE */ | |
1353 | /* OBSOLETE while (nread < len) */ | |
1354 | /* OBSOLETE { */ | |
1355 | /* OBSOLETE Count = len - nread; */ | |
1356 | /* OBSOLETE if (Count > MAXDATA) */ | |
1357 | /* OBSOLETE Count = MAXDATA; */ | |
1358 | /* OBSOLETE From.Offset = memaddr + nread; */ | |
1359 | /* OBSOLETE if (err = UDIRead (From, To, Count, Size, &CountDone, HostEndian)) */ | |
1360 | /* OBSOLETE { */ | |
1361 | /* OBSOLETE error ("UDIRead() failed in udi_read_inferior_memory"); */ | |
1362 | /* OBSOLETE break; */ | |
1363 | /* OBSOLETE } */ | |
1364 | /* OBSOLETE else */ | |
1365 | /* OBSOLETE { */ | |
1366 | /* OBSOLETE nread += CountDone; */ | |
1367 | /* OBSOLETE To += CountDone; */ | |
1368 | /* OBSOLETE } */ | |
1369 | /* OBSOLETE } */ | |
1370 | /* OBSOLETE return (nread); */ | |
1371 | /* OBSOLETE } */ | |
1372 | /* OBSOLETE */ | |
1373 | /* OBSOLETE /********************************************************************* WARNING */ | |
1374 | /* OBSOLETE */ */ | |
1375 | /* OBSOLETE udi_warning (int num) */ | |
1376 | /* OBSOLETE { */ | |
1377 | /* OBSOLETE error ("ERROR while loading program into remote TIP: $d\n", num); */ | |
1378 | /* OBSOLETE } */ | |
1379 | /* OBSOLETE */ | |
1380 | /* OBSOLETE */ | |
1381 | /* OBSOLETE /*****************************************************************************/ */ | |
1382 | /* OBSOLETE /* Fetch a single register indicatated by 'regno'. */ | |
1383 | /* OBSOLETE * Returns 0/-1 on success/failure. */ | |
1384 | /* OBSOLETE */ */ | |
1385 | /* OBSOLETE static void */ | |
1386 | /* OBSOLETE fetch_register (int regno) */ | |
1387 | /* OBSOLETE { */ | |
1388 | /* OBSOLETE UDIResource From; */ | |
1389 | /* OBSOLETE UDIUInt32 To; */ | |
1390 | /* OBSOLETE UDICount Count = 1; */ | |
1391 | /* OBSOLETE UDISizeT Size = 4; */ | |
1392 | /* OBSOLETE UDICount CountDone; */ | |
1393 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
1394 | /* OBSOLETE UDIError err; */ | |
1395 | /* OBSOLETE int result; */ | |
1396 | /* OBSOLETE */ | |
1397 | /* OBSOLETE if (regno == GR1_REGNUM) */ | |
1398 | /* OBSOLETE { */ | |
1399 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
1400 | /* OBSOLETE From.Offset = 1; */ | |
1401 | /* OBSOLETE } */ | |
1402 | /* OBSOLETE else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) */ | |
1403 | /* OBSOLETE { */ | |
1404 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
1405 | /* OBSOLETE From.Offset = (regno - GR96_REGNUM) + 96;; */ | |
1406 | /* OBSOLETE } */ | |
1407 | /* OBSOLETE */ | |
1408 | /* OBSOLETE #if defined(GR64_REGNUM) */ | |
1409 | /* OBSOLETE */ | |
1410 | /* OBSOLETE else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32) */ | |
1411 | /* OBSOLETE { */ | |
1412 | /* OBSOLETE From.Space = UDI29KGlobalRegs; */ | |
1413 | /* OBSOLETE From.Offset = (regno - GR64_REGNUM) + 64; */ | |
1414 | /* OBSOLETE } */ | |
1415 | /* OBSOLETE */ | |
1416 | /* OBSOLETE #endif /* GR64_REGNUM */ */ | |
1417 | /* OBSOLETE */ | |
1418 | /* OBSOLETE else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) */ | |
1419 | /* OBSOLETE { */ | |
1420 | /* OBSOLETE From.Space = UDI29KLocalRegs; */ | |
1421 | /* OBSOLETE From.Offset = (regno - LR0_REGNUM); */ | |
1422 | /* OBSOLETE } */ | |
1423 | /* OBSOLETE else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM) */ | |
1424 | /* OBSOLETE { */ | |
1425 | /* OBSOLETE int val = -1; */ | |
1426 | /* OBSOLETE /*supply_register(160 + (regno - FPE_REGNUM),(char *) &val); */ */ | |
1427 | /* OBSOLETE supply_register (regno, (char *) &val); */ | |
1428 | /* OBSOLETE return; /* Pretend Success */ */ | |
1429 | /* OBSOLETE } */ | |
1430 | /* OBSOLETE else */ | |
1431 | /* OBSOLETE { */ | |
1432 | /* OBSOLETE From.Space = UDI29KSpecialRegs; */ | |
1433 | /* OBSOLETE From.Offset = regnum_to_srnum (regno); */ | |
1434 | /* OBSOLETE } */ | |
1435 | /* OBSOLETE */ | |
1436 | /* OBSOLETE if (err = UDIRead (From, &To, Count, Size, &CountDone, HostEndian)) */ | |
1437 | /* OBSOLETE error ("UDIRead() failed in udi_fetch_registers"); */ | |
1438 | /* OBSOLETE */ | |
1439 | /* OBSOLETE supply_register (regno, (char *) &To); */ | |
1440 | /* OBSOLETE */ | |
1441 | /* OBSOLETE if (remote_debug) */ | |
1442 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, "Fetching register %s = 0x%x\n", */ | |
1443 | /* OBSOLETE REGISTER_NAME (regno), To); */ | |
1444 | /* OBSOLETE } */ | |
1445 | /* OBSOLETE /*****************************************************************************/ */ | |
1446 | /* OBSOLETE /* Store a single register indicated by 'regno'. */ | |
1447 | /* OBSOLETE * Returns 0/-1 on success/failure. */ | |
1448 | /* OBSOLETE */ */ | |
1449 | /* OBSOLETE static int */ | |
1450 | /* OBSOLETE store_register (int regno) */ | |
1451 | /* OBSOLETE { */ | |
1452 | /* OBSOLETE int result; */ | |
1453 | /* OBSOLETE UDIUInt32 From; */ | |
1454 | /* OBSOLETE UDIResource To; */ | |
1455 | /* OBSOLETE UDICount Count = 1; */ | |
1456 | /* OBSOLETE UDISizeT Size = 4; */ | |
1457 | /* OBSOLETE UDICount CountDone; */ | |
1458 | /* OBSOLETE UDIBool HostEndian = 0; */ | |
1459 | /* OBSOLETE */ | |
1460 | /* OBSOLETE From = read_register (regno); /* get data value */ */ | |
1461 | /* OBSOLETE */ | |
1462 | /* OBSOLETE if (remote_debug) */ | |
1463 | /* OBSOLETE fprintf_unfiltered (gdb_stdlog, "Storing register %s = 0x%x\n", */ | |
1464 | /* OBSOLETE REGISTER_NAME (regno), From); */ | |
1465 | /* OBSOLETE */ | |
1466 | /* OBSOLETE if (regno == GR1_REGNUM) */ | |
1467 | /* OBSOLETE { */ | |
1468 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
1469 | /* OBSOLETE To.Offset = 1; */ | |
1470 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1471 | /* OBSOLETE /* Setting GR1 changes the numbers of all the locals, so invalidate the */ | |
1472 | /* OBSOLETE * register cache. Do this *after* calling read_register, because we want */ | |
1473 | /* OBSOLETE * read_register to return the value that write_register has just stuffed */ | |
1474 | /* OBSOLETE * into the registers array, not the value of the register fetched from */ | |
1475 | /* OBSOLETE * the inferior. */ | |
1476 | /* OBSOLETE */ */ | |
1477 | /* OBSOLETE registers_changed (); */ | |
1478 | /* OBSOLETE } */ | |
1479 | /* OBSOLETE #if defined(GR64_REGNUM) */ | |
1480 | /* OBSOLETE else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32) */ | |
1481 | /* OBSOLETE { */ | |
1482 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
1483 | /* OBSOLETE To.Offset = (regno - GR64_REGNUM) + 64; */ | |
1484 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1485 | /* OBSOLETE } */ | |
1486 | /* OBSOLETE #endif /* GR64_REGNUM */ */ | |
1487 | /* OBSOLETE else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) */ | |
1488 | /* OBSOLETE { */ | |
1489 | /* OBSOLETE To.Space = UDI29KGlobalRegs; */ | |
1490 | /* OBSOLETE To.Offset = (regno - GR96_REGNUM) + 96; */ | |
1491 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1492 | /* OBSOLETE } */ | |
1493 | /* OBSOLETE else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) */ | |
1494 | /* OBSOLETE { */ | |
1495 | /* OBSOLETE To.Space = UDI29KLocalRegs; */ | |
1496 | /* OBSOLETE To.Offset = (regno - LR0_REGNUM); */ | |
1497 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1498 | /* OBSOLETE } */ | |
1499 | /* OBSOLETE else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM) */ | |
1500 | /* OBSOLETE return 0; /* Pretend Success */ */ | |
1501 | /* OBSOLETE else if (regno == PC_REGNUM) */ | |
1502 | /* OBSOLETE { */ | |
1503 | /* OBSOLETE /* PC1 via UDI29KPC */ */ | |
1504 | /* OBSOLETE */ | |
1505 | /* OBSOLETE To.Space = UDI29KPC; */ | |
1506 | /* OBSOLETE To.Offset = 0; /* PC1 */ */ | |
1507 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1508 | /* OBSOLETE */ | |
1509 | /* OBSOLETE /* Writing to this loc actually changes the values of pc0 & pc1 */ */ | |
1510 | /* OBSOLETE */ | |
1511 | /* OBSOLETE register_valid[PC_REGNUM] = 0; /* pc1 */ */ | |
1512 | /* OBSOLETE register_valid[NPC_REGNUM] = 0; /* pc0 */ */ | |
1513 | /* OBSOLETE } */ | |
1514 | /* OBSOLETE else */ | |
1515 | /* OBSOLETE /* An unprotected or protected special register */ */ | |
1516 | /* OBSOLETE { */ | |
1517 | /* OBSOLETE To.Space = UDI29KSpecialRegs; */ | |
1518 | /* OBSOLETE To.Offset = regnum_to_srnum (regno); */ | |
1519 | /* OBSOLETE result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); */ | |
1520 | /* OBSOLETE } */ | |
1521 | /* OBSOLETE */ | |
1522 | /* OBSOLETE if (result != 0) */ | |
1523 | /* OBSOLETE error ("UDIWrite() failed in store_registers"); */ | |
1524 | /* OBSOLETE */ | |
1525 | /* OBSOLETE return 0; */ | |
1526 | /* OBSOLETE } */ | |
1527 | /* OBSOLETE /********************************************************** REGNUM_TO_SRNUM */ */ | |
1528 | /* OBSOLETE /* */ | |
1529 | /* OBSOLETE * Convert a gdb special register number to a 29000 special register number. */ | |
1530 | /* OBSOLETE */ */ | |
1531 | /* OBSOLETE static int */ | |
1532 | /* OBSOLETE regnum_to_srnum (int regno) */ | |
1533 | /* OBSOLETE { */ | |
1534 | /* OBSOLETE switch (regno) */ | |
1535 | /* OBSOLETE { */ | |
1536 | /* OBSOLETE case VAB_REGNUM: */ | |
1537 | /* OBSOLETE return (0); */ | |
1538 | /* OBSOLETE case OPS_REGNUM: */ | |
1539 | /* OBSOLETE return (1); */ | |
1540 | /* OBSOLETE case CPS_REGNUM: */ | |
1541 | /* OBSOLETE return (2); */ | |
1542 | /* OBSOLETE case CFG_REGNUM: */ | |
1543 | /* OBSOLETE return (3); */ | |
1544 | /* OBSOLETE case CHA_REGNUM: */ | |
1545 | /* OBSOLETE return (4); */ | |
1546 | /* OBSOLETE case CHD_REGNUM: */ | |
1547 | /* OBSOLETE return (5); */ | |
1548 | /* OBSOLETE case CHC_REGNUM: */ | |
1549 | /* OBSOLETE return (6); */ | |
1550 | /* OBSOLETE case RBP_REGNUM: */ | |
1551 | /* OBSOLETE return (7); */ | |
1552 | /* OBSOLETE case TMC_REGNUM: */ | |
1553 | /* OBSOLETE return (8); */ | |
1554 | /* OBSOLETE case TMR_REGNUM: */ | |
1555 | /* OBSOLETE return (9); */ | |
1556 | /* OBSOLETE case NPC_REGNUM: */ | |
1557 | /* OBSOLETE return (USE_SHADOW_PC ? (20) : (10)); */ | |
1558 | /* OBSOLETE case PC_REGNUM: */ | |
1559 | /* OBSOLETE return (USE_SHADOW_PC ? (21) : (11)); */ | |
1560 | /* OBSOLETE case PC2_REGNUM: */ | |
1561 | /* OBSOLETE return (USE_SHADOW_PC ? (22) : (12)); */ | |
1562 | /* OBSOLETE case MMU_REGNUM: */ | |
1563 | /* OBSOLETE return (13); */ | |
1564 | /* OBSOLETE case LRU_REGNUM: */ | |
1565 | /* OBSOLETE return (14); */ | |
1566 | /* OBSOLETE case IPC_REGNUM: */ | |
1567 | /* OBSOLETE return (128); */ | |
1568 | /* OBSOLETE case IPA_REGNUM: */ | |
1569 | /* OBSOLETE return (129); */ | |
1570 | /* OBSOLETE case IPB_REGNUM: */ | |
1571 | /* OBSOLETE return (130); */ | |
1572 | /* OBSOLETE case Q_REGNUM: */ | |
1573 | /* OBSOLETE return (131); */ | |
1574 | /* OBSOLETE case ALU_REGNUM: */ | |
1575 | /* OBSOLETE return (132); */ | |
1576 | /* OBSOLETE case BP_REGNUM: */ | |
1577 | /* OBSOLETE return (133); */ | |
1578 | /* OBSOLETE case FC_REGNUM: */ | |
1579 | /* OBSOLETE return (134); */ | |
1580 | /* OBSOLETE case CR_REGNUM: */ | |
1581 | /* OBSOLETE return (135); */ | |
1582 | /* OBSOLETE case FPE_REGNUM: */ | |
1583 | /* OBSOLETE return (160); */ | |
1584 | /* OBSOLETE case INTE_REGNUM: */ | |
1585 | /* OBSOLETE return (161); */ | |
1586 | /* OBSOLETE case FPS_REGNUM: */ | |
1587 | /* OBSOLETE return (162); */ | |
1588 | /* OBSOLETE case EXO_REGNUM: */ | |
1589 | /* OBSOLETE return (164); */ | |
1590 | /* OBSOLETE default: */ | |
1591 | /* OBSOLETE return (255); /* Failure ? */ */ | |
1592 | /* OBSOLETE } */ | |
1593 | /* OBSOLETE } */ | |
1594 | /* OBSOLETE /****************************************************************************/ */ | |
1595 | /* OBSOLETE /* */ | |
1596 | /* OBSOLETE * Determine the Target memory space qualifier based on the addr. */ | |
1597 | /* OBSOLETE * FIXME: Can't distinguis I_ROM/D_ROM. */ | |
1598 | /* OBSOLETE * FIXME: Doesn't know anything about I_CACHE/D_CACHE. */ | |
1599 | /* OBSOLETE */ */ | |
1600 | /* OBSOLETE static CPUSpace */ | |
1601 | /* OBSOLETE udi_memory_space (CORE_ADDR addr) */ | |
1602 | /* OBSOLETE { */ | |
1603 | /* OBSOLETE UDIUInt32 tstart = IMemStart; */ | |
1604 | /* OBSOLETE UDIUInt32 tend = tstart + IMemSize; */ | |
1605 | /* OBSOLETE UDIUInt32 dstart = DMemStart; */ | |
1606 | /* OBSOLETE UDIUInt32 dend = tstart + DMemSize; */ | |
1607 | /* OBSOLETE UDIUInt32 rstart = RMemStart; */ | |
1608 | /* OBSOLETE UDIUInt32 rend = tstart + RMemSize; */ | |
1609 | /* OBSOLETE */ | |
1610 | /* OBSOLETE if (((UDIUInt32) addr >= tstart) && ((UDIUInt32) addr < tend)) */ | |
1611 | /* OBSOLETE { */ | |
1612 | /* OBSOLETE return UDI29KIRAMSpace; */ | |
1613 | /* OBSOLETE } */ | |
1614 | /* OBSOLETE else if (((UDIUInt32) addr >= dstart) && ((UDIUInt32) addr < dend)) */ | |
1615 | /* OBSOLETE { */ | |
1616 | /* OBSOLETE return UDI29KDRAMSpace; */ | |
1617 | /* OBSOLETE } */ | |
1618 | /* OBSOLETE else if (((UDIUInt32) addr >= rstart) && ((UDIUInt32) addr < rend)) */ | |
1619 | /* OBSOLETE { */ | |
1620 | /* OBSOLETE /* FIXME: how do we determine between D_ROM and I_ROM */ */ | |
1621 | /* OBSOLETE return UDI29KIROMSpace; */ | |
1622 | /* OBSOLETE } */ | |
1623 | /* OBSOLETE else /* FIXME: what do me do now? */ */ | |
1624 | /* OBSOLETE return UDI29KDRAMSpace; /* Hmmm! */ */ | |
1625 | /* OBSOLETE } */ | |
1626 | /* OBSOLETE /*********************************************************************** STUBS */ | |
1627 | /* OBSOLETE */ */ | |
1628 | /* OBSOLETE */ | |
1629 | /* OBSOLETE void */ | |
1630 | /* OBSOLETE convert16 (void) */ | |
1631 | /* OBSOLETE {; */ | |
1632 | /* OBSOLETE } */ | |
1633 | /* OBSOLETE void */ | |
1634 | /* OBSOLETE convert32 (void) */ | |
1635 | /* OBSOLETE {; */ | |
1636 | /* OBSOLETE } */ | |
1637 | /* OBSOLETE struct ui_file *EchoFile = 0; /* used for debugging */ */ | |
1638 | /* OBSOLETE int QuietMode = 0; /* used for debugging */ */ | |
1639 | /* OBSOLETE \f */ | |
1640 | /* OBSOLETE #ifdef NO_HIF_SUPPORT */ | |
1641 | /* OBSOLETE service_HIF (union msg_t *msg) */ | |
1642 | /* OBSOLETE { */ | |
1643 | /* OBSOLETE return (0); /* Emulate a failure */ */ | |
1644 | /* OBSOLETE } */ | |
1645 | /* OBSOLETE #endif */ | |
1646 | /* OBSOLETE \f */ | |
1647 | /* OBSOLETE /* Target_ops vector. Not static because there does not seem to be */ | |
1648 | /* OBSOLETE any portable way to do a forward declaration of a static variable. */ | |
1649 | /* OBSOLETE The RS/6000 doesn't like "extern" followed by "static"; SunOS */ | |
1650 | /* OBSOLETE /bin/cc doesn't like "static" twice. */ */ | |
1651 | /* OBSOLETE */ | |
1652 | /* OBSOLETE struct target_ops udi_ops; */ | |
1653 | /* OBSOLETE */ | |
1654 | /* OBSOLETE static void */ | |
1655 | /* OBSOLETE init_udi_ops (void) */ | |
1656 | /* OBSOLETE { */ | |
1657 | /* OBSOLETE udi_ops.to_shortname = "udi"; */ | |
1658 | /* OBSOLETE udi_ops.to_longname = "Remote UDI connected TIP"; */ | |
1659 | /* OBSOLETE udi_ops.to_doc = "Remote debug an AMD 29k using UDI socket connection to TIP process.\n\ */ | |
1660 | /* OBSOLETE Arguments are\n\ */ | |
1661 | /* OBSOLETE `configuration-id AF_INET hostname port-number'\n\ */ | |
1662 | /* OBSOLETE To connect via the network, where hostname and port-number specify the\n\ */ | |
1663 | /* OBSOLETE host and port where you can connect via UDI.\n\ */ | |
1664 | /* OBSOLETE configuration-id is unused.\n\ */ | |
1665 | /* OBSOLETE \n\ */ | |
1666 | /* OBSOLETE `configuration-id AF_UNIX socket-name tip-program'\n\ */ | |
1667 | /* OBSOLETE To connect using a local connection to the \"tip.exe\" program which is\n\ */ | |
1668 | /* OBSOLETE supplied by AMD. If socket-name specifies an AF_UNIX socket then the\n\ */ | |
1669 | /* OBSOLETE tip program must already be started; connect to it using that socket.\n\ */ | |
1670 | /* OBSOLETE If not, start up tip-program, which should be the name of the tip\n\ */ | |
1671 | /* OBSOLETE program. If appropriate, the PATH environment variable is searched.\n\ */ | |
1672 | /* OBSOLETE configuration-id is unused.\n\ */ | |
1673 | /* OBSOLETE \n\ */ | |
1674 | /* OBSOLETE `configuration-id'\n\ */ | |
1675 | /* OBSOLETE Look up the configuration in ./udi_soc or /etc/udi_soc, which\n\ */ | |
1676 | /* OBSOLETE are files containing lines in the above formats. configuration-id is\n\ */ | |
1677 | /* OBSOLETE used to pick which line of the file to use."; */ | |
1678 | /* OBSOLETE udi_ops.to_open = udi_open; */ | |
1679 | /* OBSOLETE udi_ops.to_close = udi_close; */ | |
1680 | /* OBSOLETE udi_ops.to_attach = udi_attach; */ | |
1681 | /* OBSOLETE udi_ops.to_detach = udi_detach; */ | |
1682 | /* OBSOLETE udi_ops.to_resume = udi_resume; */ | |
1683 | /* OBSOLETE udi_ops.to_wait = udi_wait; */ | |
1684 | /* OBSOLETE udi_ops.to_fetch_registers = udi_fetch_registers; */ | |
1685 | /* OBSOLETE udi_ops.to_store_registers = udi_store_registers; */ | |
1686 | /* OBSOLETE udi_ops.to_prepare_to_store = udi_prepare_to_store; */ | |
1687 | /* OBSOLETE udi_ops.to_xfer_memory = udi_xfer_inferior_memory; */ | |
1688 | /* OBSOLETE udi_ops.to_files_info = udi_files_info; */ | |
1689 | /* OBSOLETE udi_ops.to_insert_breakpoint = udi_insert_breakpoint; */ | |
1690 | /* OBSOLETE udi_ops.to_remove_breakpoint = udi_remove_breakpoint; */ | |
1691 | /* OBSOLETE udi_ops.to_terminal_init = 0; */ | |
1692 | /* OBSOLETE udi_ops.to_terminal_inferior = 0; */ | |
1693 | /* OBSOLETE udi_ops.to_terminal_ours_for_output = 0; */ | |
1694 | /* OBSOLETE udi_ops.to_terminal_ours = 0; */ | |
1695 | /* OBSOLETE udi_ops.to_terminal_info = 0; */ | |
1696 | /* OBSOLETE udi_ops.to_kill = udi_kill; */ | |
1697 | /* OBSOLETE udi_ops.to_load = udi_load; */ | |
1698 | /* OBSOLETE udi_ops.to_lookup_symbol = 0; */ | |
1699 | /* OBSOLETE udi_ops.to_create_inferior = udi_create_inferior; */ | |
1700 | /* OBSOLETE udi_ops.to_mourn_inferior = udi_mourn; */ | |
1701 | /* OBSOLETE udi_ops.to_can_run = 0; */ | |
1702 | /* OBSOLETE udi_ops.to_notice_signals = 0; */ | |
1703 | /* OBSOLETE udi_ops.to_thread_alive = 0; */ | |
1704 | /* OBSOLETE udi_ops.to_stop = 0; */ | |
1705 | /* OBSOLETE udi_ops.to_stratum = process_stratum; */ | |
1706 | /* OBSOLETE udi_ops.DONT_USE = 0; */ | |
1707 | /* OBSOLETE udi_ops.to_has_all_memory = 1; */ | |
1708 | /* OBSOLETE udi_ops.to_has_memory = 1; */ | |
1709 | /* OBSOLETE udi_ops.to_has_stack = 1; */ | |
1710 | /* OBSOLETE udi_ops.to_has_registers = 1; */ | |
1711 | /* OBSOLETE udi_ops.to_has_execution = 1; */ | |
1712 | /* OBSOLETE udi_ops.to_sections = 0; */ | |
1713 | /* OBSOLETE udi_ops.to_sections_end = 0; */ | |
1714 | /* OBSOLETE udi_ops.to_magic = OPS_MAGIC; */ | |
1715 | /* OBSOLETE }; */ | |
1716 | /* OBSOLETE */ | |
1717 | /* OBSOLETE void */ | |
1718 | /* OBSOLETE _initialize_remote_udi (void) */ | |
1719 | /* OBSOLETE { */ | |
1720 | /* OBSOLETE init_udi_ops (); */ | |
1721 | /* OBSOLETE add_target (&udi_ops); */ | |
1722 | /* OBSOLETE } */ |