projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2003-04-15 David Carlton <carlton@math.stanford.edu>
[deliverable/binutils-gdb.git] / gdb / mn10200-tdep.c
CommitLineData
67f16606
AC		 1// OBSOLETE /* Target-dependent code for the Matsushita MN10200 for GDB, the GNU debugger.
2// OBSOLETE
3// OBSOLETE Copyright 1997, 1998, 1999, 2000, 2001, 2003 Free Software
4// OBSOLETE Foundation, Inc.
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 #include "defs.h"
24// OBSOLETE #include "frame.h"
25// OBSOLETE #include "inferior.h"
26// OBSOLETE #include "target.h"
27// OBSOLETE #include "value.h"
28// OBSOLETE #include "bfd.h"
29// OBSOLETE #include "gdb_string.h"
30// OBSOLETE #include "gdbcore.h"
31// OBSOLETE #include "symfile.h"
32// OBSOLETE #include "regcache.h"
33// OBSOLETE
34// OBSOLETE
35// OBSOLETE /* Should call_function allocate stack space for a struct return? */
36// OBSOLETE int
37// OBSOLETE mn10200_use_struct_convention (int gcc_p, struct type *type)
38// OBSOLETE {
39// OBSOLETE return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
40// OBSOLETE }
41// OBSOLETE /* *INDENT-OFF* */
42// OBSOLETE /* The main purpose of this file is dealing with prologues to extract
43// OBSOLETE information about stack frames and saved registers.
44// OBSOLETE
45// OBSOLETE For reference here's how prologues look on the mn10200:
46// OBSOLETE
47// OBSOLETE With frame pointer:
48// OBSOLETE mov fp,a0
49// OBSOLETE mov sp,fp
50// OBSOLETE add <size>,sp
51// OBSOLETE Register saves for d2, d3, a1, a2 as needed. Saves start
52// OBSOLETE at fp - <size> + <outgoing_args_size> and work towards higher
53// OBSOLETE addresses. Note that the saves are actually done off the stack
54// OBSOLETE pointer in the prologue! This makes for smaller code and easier
55// OBSOLETE prologue scanning as the displacement fields will unlikely
56// OBSOLETE be more than 8 bits!
57// OBSOLETE
58// OBSOLETE Without frame pointer:
59// OBSOLETE add <size>,sp
60// OBSOLETE Register saves for d2, d3, a1, a2 as needed. Saves start
61// OBSOLETE at sp + <outgoing_args_size> and work towards higher addresses.
62// OBSOLETE
63// OBSOLETE Out of line prologue:
64// OBSOLETE add <local size>,sp -- optional
65// OBSOLETE jsr __prologue
66// OBSOLETE add <outgoing_size>,sp -- optional
67// OBSOLETE
68// OBSOLETE The stack pointer remains constant throughout the life of most
69// OBSOLETE functions. As a result the compiler will usually omit the
70// OBSOLETE frame pointer, so we must handle frame pointerless functions. */
71// OBSOLETE
72// OBSOLETE /* Analyze the prologue to determine where registers are saved,
73// OBSOLETE the end of the prologue, etc etc. Return the end of the prologue
74// OBSOLETE scanned.
75// OBSOLETE
76// OBSOLETE We store into FI (if non-null) several tidbits of information:
77// OBSOLETE
78// OBSOLETE * stack_size -- size of this stack frame. Note that if we stop in
79// OBSOLETE certain parts of the prologue/epilogue we may claim the size of the
80// OBSOLETE current frame is zero. This happens when the current frame has
81// OBSOLETE not been allocated yet or has already been deallocated.
82// OBSOLETE
83// OBSOLETE * fsr -- Addresses of registers saved in the stack by this frame.
84// OBSOLETE
85// OBSOLETE * status -- A (relatively) generic status indicator. It's a bitmask
86// OBSOLETE with the following bits:
87// OBSOLETE
88// OBSOLETE MY_FRAME_IN_SP: The base of the current frame is actually in
89// OBSOLETE the stack pointer. This can happen for frame pointerless
90// OBSOLETE functions, or cases where we're stopped in the prologue/epilogue
91// OBSOLETE itself. For these cases mn10200_analyze_prologue will need up
92// OBSOLETE update fi->frame before returning or analyzing the register
93// OBSOLETE save instructions.
94// OBSOLETE
95// OBSOLETE MY_FRAME_IN_FP: The base of the current frame is in the
96// OBSOLETE frame pointer register ($a2).
97// OBSOLETE
98// OBSOLETE CALLER_A2_IN_A0: $a2 from the caller's frame is temporarily
99// OBSOLETE in $a0. This can happen if we're stopped in the prologue.
100// OBSOLETE
101// OBSOLETE NO_MORE_FRAMES: Set this if the current frame is "start" or
102// OBSOLETE if the first instruction looks like mov <imm>,sp. This tells
103// OBSOLETE frame chain to not bother trying to unwind past this frame. */
104// OBSOLETE /* *INDENT-ON* */
105// OBSOLETE
106// OBSOLETE
107// OBSOLETE
108// OBSOLETE
109// OBSOLETE #define MY_FRAME_IN_SP 0x1
110// OBSOLETE #define MY_FRAME_IN_FP 0x2
111// OBSOLETE #define CALLER_A2_IN_A0 0x4
112// OBSOLETE #define NO_MORE_FRAMES 0x8
113// OBSOLETE
114// OBSOLETE static CORE_ADDR
115// OBSOLETE mn10200_analyze_prologue (struct frame_info *fi, CORE_ADDR pc)
116// OBSOLETE {
117// OBSOLETE CORE_ADDR func_addr, func_end, addr, stop;
118// OBSOLETE CORE_ADDR stack_size = 0;
119// OBSOLETE unsigned char buf[4];
120// OBSOLETE int status;
121// OBSOLETE char *name;
122// OBSOLETE int out_of_line_prologue = 0;
123// OBSOLETE
124// OBSOLETE /* Use the PC in the frame if it's provided to look up the
125// OBSOLETE start of this function. */
126// OBSOLETE pc = (fi ? get_frame_pc (fi) : pc);
127// OBSOLETE
128// OBSOLETE /* Find the start of this function. */
129// OBSOLETE status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
130// OBSOLETE
131// OBSOLETE /* Do nothing if we couldn't find the start of this function or if we're
132// OBSOLETE stopped at the first instruction in the prologue. */
133// OBSOLETE if (status == 0)
134// OBSOLETE return pc;
135// OBSOLETE
136// OBSOLETE /* If we're in start, then give up. */
137// OBSOLETE if (strcmp (name, "start") == 0)
138// OBSOLETE {
139// OBSOLETE if (fi)
140// OBSOLETE fi->status = NO_MORE_FRAMES;
141// OBSOLETE return pc;
142// OBSOLETE }
143// OBSOLETE
144// OBSOLETE /* At the start of a function our frame is in the stack pointer. */
145// OBSOLETE if (fi)
146// OBSOLETE fi->status = MY_FRAME_IN_SP;
147// OBSOLETE
148// OBSOLETE /* If we're physically on an RTS instruction, then our frame has already
149// OBSOLETE been deallocated.
150// OBSOLETE
151// OBSOLETE fi->frame is bogus, we need to fix it. */
152// OBSOLETE if (fi && get_frame_pc (fi) + 1 == func_end)
153// OBSOLETE {
154// OBSOLETE status = target_read_memory (get_frame_pc (fi), buf, 1);
155// OBSOLETE if (status != 0)
156// OBSOLETE {
157// OBSOLETE if (get_next_frame (fi) == NULL)
158// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
159// OBSOLETE return get_frame_pc (fi);
160// OBSOLETE }
161// OBSOLETE
162// OBSOLETE if (buf[0] == 0xfe)
163// OBSOLETE {
164// OBSOLETE if (get_next_frame (fi) == NULL)
165// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
166// OBSOLETE return get_frame_pc (fi);
167// OBSOLETE }
168// OBSOLETE }
169// OBSOLETE
170// OBSOLETE /* Similarly if we're stopped on the first insn of a prologue as our
171// OBSOLETE frame hasn't been allocated yet. */
172// OBSOLETE if (fi && get_frame_pc (fi) == func_addr)
173// OBSOLETE {
174// OBSOLETE if (get_next_frame (fi) == NULL)
175// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
176// OBSOLETE return get_frame_pc (fi);
177// OBSOLETE }
178// OBSOLETE
179// OBSOLETE /* Figure out where to stop scanning. */
180// OBSOLETE stop = fi ? get_frame_pc (fi) : func_end;
181// OBSOLETE
182// OBSOLETE /* Don't walk off the end of the function. */
183// OBSOLETE stop = stop > func_end ? func_end : stop;
184// OBSOLETE
185// OBSOLETE /* Start scanning on the first instruction of this function. */
186// OBSOLETE addr = func_addr;
187// OBSOLETE
188// OBSOLETE status = target_read_memory (addr, buf, 2);
189// OBSOLETE if (status != 0)
190// OBSOLETE {
191// OBSOLETE if (fi && get_next_frame (fi) == NULL && fi->status & MY_FRAME_IN_SP)
192// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
193// OBSOLETE return addr;
194// OBSOLETE }
195// OBSOLETE
196// OBSOLETE /* First see if this insn sets the stack pointer; if so, it's something
197// OBSOLETE we won't understand, so quit now. */
198// OBSOLETE if (buf[0] == 0xdf
199// OBSOLETE || (buf[0] == 0xf4 && buf[1] == 0x77))
200// OBSOLETE {
201// OBSOLETE if (fi)
202// OBSOLETE fi->status = NO_MORE_FRAMES;
203// OBSOLETE return addr;
204// OBSOLETE }
205// OBSOLETE
206// OBSOLETE /* Now see if we have a frame pointer.
207// OBSOLETE
208// OBSOLETE Search for mov a2,a0 (0xf278)
209// OBSOLETE then mov a3,a2 (0xf27e). */
210// OBSOLETE
211// OBSOLETE if (buf[0] == 0xf2 && buf[1] == 0x78)
212// OBSOLETE {
213// OBSOLETE /* Our caller's $a2 will be found in $a0 now. Note it for
214// OBSOLETE our callers. */
215// OBSOLETE if (fi)
216// OBSOLETE fi->status |= CALLER_A2_IN_A0;
217// OBSOLETE addr += 2;
218// OBSOLETE if (addr >= stop)
219// OBSOLETE {
220// OBSOLETE /* We still haven't allocated our local stack. Handle this
221// OBSOLETE as if we stopped on the first or last insn of a function. */
222// OBSOLETE if (fi && get_next_frame (fi) == NULL)
223// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
224// OBSOLETE return addr;
225// OBSOLETE }
226// OBSOLETE
227// OBSOLETE status = target_read_memory (addr, buf, 2);
228// OBSOLETE if (status != 0)
229// OBSOLETE {
230// OBSOLETE if (fi && get_next_frame (fi) == NULL)
231// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
232// OBSOLETE return addr;
233// OBSOLETE }
234// OBSOLETE if (buf[0] == 0xf2 && buf[1] == 0x7e)
235// OBSOLETE {
236// OBSOLETE addr += 2;
237// OBSOLETE
238// OBSOLETE /* Our frame pointer is valid now. */
239// OBSOLETE if (fi)
240// OBSOLETE {
241// OBSOLETE fi->status |= MY_FRAME_IN_FP;
242// OBSOLETE fi->status &= ~MY_FRAME_IN_SP;
243// OBSOLETE }
244// OBSOLETE if (addr >= stop)
245// OBSOLETE return addr;
246// OBSOLETE }
247// OBSOLETE else
248// OBSOLETE {
249// OBSOLETE if (fi && get_next_frame (fi) == NULL)
250// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
251// OBSOLETE return addr;
252// OBSOLETE }
253// OBSOLETE }
254// OBSOLETE
255// OBSOLETE /* Next we should allocate the local frame.
256// OBSOLETE
257// OBSOLETE Search for add imm8,a3 (0xd3XX)
258// OBSOLETE or add imm16,a3 (0xf70bXXXX)
259// OBSOLETE or add imm24,a3 (0xf467XXXXXX).
260// OBSOLETE
261// OBSOLETE If none of the above was found, then this prologue has
262// OBSOLETE no stack, and therefore can't have any register saves,
263// OBSOLETE so quit now. */
264// OBSOLETE status = target_read_memory (addr, buf, 2);
265// OBSOLETE if (status != 0)
266// OBSOLETE {
267// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
268// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
269// OBSOLETE return addr;
270// OBSOLETE }
271// OBSOLETE if (buf[0] == 0xd3)
272// OBSOLETE {
273// OBSOLETE stack_size = extract_signed_integer (&buf[1], 1);
274// OBSOLETE if (fi)
275// OBSOLETE fi->stack_size = stack_size;
276// OBSOLETE addr += 2;
277// OBSOLETE if (addr >= stop)
278// OBSOLETE {
279// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
280// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - stack_size);
281// OBSOLETE return addr;
282// OBSOLETE }
283// OBSOLETE }
284// OBSOLETE else if (buf[0] == 0xf7 && buf[1] == 0x0b)
285// OBSOLETE {
286// OBSOLETE status = target_read_memory (addr + 2, buf, 2);
287// OBSOLETE if (status != 0)
288// OBSOLETE {
289// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
290// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
291// OBSOLETE return addr;
292// OBSOLETE }
293// OBSOLETE stack_size = extract_signed_integer (buf, 2);
294// OBSOLETE if (fi)
295// OBSOLETE fi->stack_size = stack_size;
296// OBSOLETE addr += 4;
297// OBSOLETE if (addr >= stop)
298// OBSOLETE {
299// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
300// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - stack_size);
301// OBSOLETE return addr;
302// OBSOLETE }
303// OBSOLETE }
304// OBSOLETE else if (buf[0] == 0xf4 && buf[1] == 0x67)
305// OBSOLETE {
306// OBSOLETE status = target_read_memory (addr + 2, buf, 3);
307// OBSOLETE if (status != 0)
308// OBSOLETE {
309// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
310// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
311// OBSOLETE return addr;
312// OBSOLETE }
313// OBSOLETE stack_size = extract_signed_integer (buf, 3);
314// OBSOLETE if (fi)
315// OBSOLETE fi->stack_size = stack_size;
316// OBSOLETE addr += 5;
317// OBSOLETE if (addr >= stop)
318// OBSOLETE {
319// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
320// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - stack_size);
321// OBSOLETE return addr;
322// OBSOLETE }
323// OBSOLETE }
324// OBSOLETE
325// OBSOLETE /* Now see if we have a call to __prologue for an out of line
326// OBSOLETE prologue. */
327// OBSOLETE status = target_read_memory (addr, buf, 2);
328// OBSOLETE if (status != 0)
329// OBSOLETE return addr;
330// OBSOLETE
331// OBSOLETE /* First check for 16bit pc-relative call to __prologue. */
332// OBSOLETE if (buf[0] == 0xfd)
333// OBSOLETE {
334// OBSOLETE CORE_ADDR temp;
335// OBSOLETE status = target_read_memory (addr + 1, buf, 2);
336// OBSOLETE if (status != 0)
337// OBSOLETE {
338// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
339// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
340// OBSOLETE return addr;
341// OBSOLETE }
342// OBSOLETE
343// OBSOLETE /* Get the PC this instruction will branch to. */
344// OBSOLETE temp = (extract_signed_integer (buf, 2) + addr + 3) & 0xffffff;
345// OBSOLETE
346// OBSOLETE /* Get the name of the function at the target address. */
347// OBSOLETE status = find_pc_partial_function (temp, &name, NULL, NULL);
348// OBSOLETE if (status == 0)
349// OBSOLETE {
350// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
351// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
352// OBSOLETE return addr;
353// OBSOLETE }
354// OBSOLETE
355// OBSOLETE /* Note if it is an out of line prologue. */
356// OBSOLETE out_of_line_prologue = (strcmp (name, "__prologue") == 0);
357// OBSOLETE
358// OBSOLETE /* This sucks up 3 bytes of instruction space. */
359// OBSOLETE if (out_of_line_prologue)
360// OBSOLETE addr += 3;
361// OBSOLETE
362// OBSOLETE if (addr >= stop)
363// OBSOLETE {
364// OBSOLETE if (fi && get_next_frame (fi) == NULL)
365// OBSOLETE {
366// OBSOLETE fi->stack_size -= 16;
367// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - fi->stack_size);
368// OBSOLETE }
369// OBSOLETE return addr;
370// OBSOLETE }
371// OBSOLETE }
372// OBSOLETE /* Now check for the 24bit pc-relative call to __prologue. */
373// OBSOLETE else if (buf[0] == 0xf4 && buf[1] == 0xe1)
374// OBSOLETE {
375// OBSOLETE CORE_ADDR temp;
376// OBSOLETE status = target_read_memory (addr + 2, buf, 3);
377// OBSOLETE if (status != 0)
378// OBSOLETE {
379// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
380// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
381// OBSOLETE return addr;
382// OBSOLETE }
383// OBSOLETE
384// OBSOLETE /* Get the PC this instruction will branch to. */
385// OBSOLETE temp = (extract_signed_integer (buf, 3) + addr + 5) & 0xffffff;
386// OBSOLETE
387// OBSOLETE /* Get the name of the function at the target address. */
388// OBSOLETE status = find_pc_partial_function (temp, &name, NULL, NULL);
389// OBSOLETE if (status == 0)
390// OBSOLETE {
391// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
392// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp ());
393// OBSOLETE return addr;
394// OBSOLETE }
395// OBSOLETE
396// OBSOLETE /* Note if it is an out of line prologue. */
397// OBSOLETE out_of_line_prologue = (strcmp (name, "__prologue") == 0);
398// OBSOLETE
399// OBSOLETE /* This sucks up 5 bytes of instruction space. */
400// OBSOLETE if (out_of_line_prologue)
401// OBSOLETE addr += 5;
402// OBSOLETE
403// OBSOLETE if (addr >= stop)
404// OBSOLETE {
405// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP))
406// OBSOLETE {
407// OBSOLETE fi->stack_size -= 16;
408// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - fi->stack_size);
409// OBSOLETE }
410// OBSOLETE return addr;
411// OBSOLETE }
412// OBSOLETE }
413// OBSOLETE
414// OBSOLETE /* Now actually handle the out of line prologue. */
415// OBSOLETE if (out_of_line_prologue)
416// OBSOLETE {
417// OBSOLETE int outgoing_args_size = 0;
418// OBSOLETE
419// OBSOLETE /* First adjust the stack size for this function. The out of
420// OBSOLETE line prologue saves 4 registers (16bytes of data). */
421// OBSOLETE if (fi)
422// OBSOLETE fi->stack_size -= 16;
423// OBSOLETE
424// OBSOLETE /* Update fi->frame if necessary. */
425// OBSOLETE if (fi && get_next_frame (fi) == NULL)
426// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - fi->stack_size);
427// OBSOLETE
428// OBSOLETE /* After the out of line prologue, there may be another
429// OBSOLETE stack adjustment for the outgoing arguments.
430// OBSOLETE
431// OBSOLETE Search for add imm8,a3 (0xd3XX)
432// OBSOLETE or add imm16,a3 (0xf70bXXXX)
433// OBSOLETE or add imm24,a3 (0xf467XXXXXX). */
434// OBSOLETE
435// OBSOLETE status = target_read_memory (addr, buf, 2);
436// OBSOLETE if (status != 0)
437// OBSOLETE {
438// OBSOLETE if (fi)
439// OBSOLETE {
440// OBSOLETE fi->fsr.regs[2] = get_frame_base (fi) + fi->stack_size + 4;
441// OBSOLETE fi->fsr.regs[3] = get_frame_base (fi) + fi->stack_size + 8;
442// OBSOLETE fi->fsr.regs[5] = get_frame_base (fi) + fi->stack_size + 12;
443// OBSOLETE fi->fsr.regs[6] = get_frame_base (fi) + fi->stack_size + 16;
444// OBSOLETE }
445// OBSOLETE return addr;
446// OBSOLETE }
447// OBSOLETE
448// OBSOLETE if (buf[0] == 0xd3)
449// OBSOLETE {
450// OBSOLETE outgoing_args_size = extract_signed_integer (&buf[1], 1);
451// OBSOLETE addr += 2;
452// OBSOLETE }
453// OBSOLETE else if (buf[0] == 0xf7 && buf[1] == 0x0b)
454// OBSOLETE {
455// OBSOLETE status = target_read_memory (addr + 2, buf, 2);
456// OBSOLETE if (status != 0)
457// OBSOLETE {
458// OBSOLETE if (fi)
459// OBSOLETE {
460// OBSOLETE fi->fsr.regs[2] = get_frame_base (fi) + fi->stack_size + 4;
461// OBSOLETE fi->fsr.regs[3] = get_frame_base (fi) + fi->stack_size + 8;
462// OBSOLETE fi->fsr.regs[5] = get_frame_base (fi) + fi->stack_size + 12;
463// OBSOLETE fi->fsr.regs[6] = get_frame_base (fi) + fi->stack_size + 16;
464// OBSOLETE }
465// OBSOLETE return addr;
466// OBSOLETE }
467// OBSOLETE outgoing_args_size = extract_signed_integer (buf, 2);
468// OBSOLETE addr += 4;
469// OBSOLETE }
470// OBSOLETE else if (buf[0] == 0xf4 && buf[1] == 0x67)
471// OBSOLETE {
472// OBSOLETE status = target_read_memory (addr + 2, buf, 3);
473// OBSOLETE if (status != 0)
474// OBSOLETE {
475// OBSOLETE if (fi && get_next_frame (fi) == NULL)
476// OBSOLETE {
477// OBSOLETE fi->fsr.regs[2] = get_frame_base (fi) + fi->stack_size + 4;
478// OBSOLETE fi->fsr.regs[3] = get_frame_base (fi) + fi->stack_size + 8;
479// OBSOLETE fi->fsr.regs[5] = get_frame_base (fi) + fi->stack_size + 12;
480// OBSOLETE fi->fsr.regs[6] = get_frame_base (fi) + fi->stack_size + 16;
481// OBSOLETE }
482// OBSOLETE return addr;
483// OBSOLETE }
484// OBSOLETE outgoing_args_size = extract_signed_integer (buf, 3);
485// OBSOLETE addr += 5;
486// OBSOLETE }
487// OBSOLETE else
488// OBSOLETE outgoing_args_size = 0;
489// OBSOLETE
490// OBSOLETE /* Now that we know the size of the outgoing arguments, fix
491// OBSOLETE fi->frame again if this is the innermost frame. */
492// OBSOLETE if (fi && get_next_frame (fi) == NULL)
493// OBSOLETE deprecated_update_frame_base_hack (fi, get_frame_base (fi) - outgoing_args_size);
494// OBSOLETE
495// OBSOLETE /* Note the register save information and update the stack
496// OBSOLETE size for this frame too. */
497// OBSOLETE if (fi)
498// OBSOLETE {
499// OBSOLETE fi->fsr.regs[2] = get_frame_base (fi) + fi->stack_size + 4;
500// OBSOLETE fi->fsr.regs[3] = get_frame_base (fi) + fi->stack_size + 8;
501// OBSOLETE fi->fsr.regs[5] = get_frame_base (fi) + fi->stack_size + 12;
502// OBSOLETE fi->fsr.regs[6] = get_frame_base (fi) + fi->stack_size + 16;
503// OBSOLETE fi->stack_size += outgoing_args_size;
504// OBSOLETE }
505// OBSOLETE /* There can be no more prologue insns, so return now. */
506// OBSOLETE return addr;
507// OBSOLETE }
508// OBSOLETE
509// OBSOLETE /* At this point fi->frame needs to be correct.
510// OBSOLETE
511// OBSOLETE If MY_FRAME_IN_SP is set and we're the innermost frame, then we
512// OBSOLETE need to fix fi->frame so that backtracing, find_frame_saved_regs,
513// OBSOLETE etc work correctly. */
514// OBSOLETE if (fi && get_next_frame (fi) == NULL && (fi->status & MY_FRAME_IN_SP) != 0)
515// OBSOLETE deprecated_update_frame_base_hack (fi, read_sp () - fi->stack_size);
516// OBSOLETE
517// OBSOLETE /* And last we have the register saves. These are relatively
518// OBSOLETE simple because they're physically done off the stack pointer,
519// OBSOLETE and thus the number of different instructions we need to
520// OBSOLETE check is greatly reduced because we know the displacements
521// OBSOLETE will be small.
522// OBSOLETE
523// OBSOLETE Search for movx d2,(X,a3) (0xf55eXX)
524// OBSOLETE then movx d3,(X,a3) (0xf55fXX)
525// OBSOLETE then mov a1,(X,a3) (0x5dXX) No frame pointer case
526// OBSOLETE then mov a2,(X,a3) (0x5eXX) No frame pointer case
527// OBSOLETE or mov a0,(X,a3) (0x5cXX) Frame pointer case. */
528// OBSOLETE
529// OBSOLETE status = target_read_memory (addr, buf, 2);
530// OBSOLETE if (status != 0)
531// OBSOLETE return addr;
532// OBSOLETE if (buf[0] == 0xf5 && buf[1] == 0x5e)
533// OBSOLETE {
534// OBSOLETE if (fi)
535// OBSOLETE {
536// OBSOLETE status = target_read_memory (addr + 2, buf, 1);
537// OBSOLETE if (status != 0)
538// OBSOLETE return addr;
539// OBSOLETE fi->fsr.regs[2] = (get_frame_base (fi) + stack_size
540// OBSOLETE + extract_signed_integer (buf, 1));
541// OBSOLETE }
542// OBSOLETE addr += 3;
543// OBSOLETE if (addr >= stop)
544// OBSOLETE return addr;
545// OBSOLETE status = target_read_memory (addr, buf, 2);
546// OBSOLETE if (status != 0)
547// OBSOLETE return addr;
548// OBSOLETE }
549// OBSOLETE if (buf[0] == 0xf5 && buf[1] == 0x5f)
550// OBSOLETE {
551// OBSOLETE if (fi)
552// OBSOLETE {
553// OBSOLETE status = target_read_memory (addr + 2, buf, 1);
554// OBSOLETE if (status != 0)
555// OBSOLETE return addr;
556// OBSOLETE fi->fsr.regs[3] = (get_frame_base (fi) + stack_size
557// OBSOLETE + extract_signed_integer (buf, 1));
558// OBSOLETE }
559// OBSOLETE addr += 3;
560// OBSOLETE if (addr >= stop)
561// OBSOLETE return addr;
562// OBSOLETE status = target_read_memory (addr, buf, 2);
563// OBSOLETE if (status != 0)
564// OBSOLETE return addr;
565// OBSOLETE }
566// OBSOLETE if (buf[0] == 0x5d)
567// OBSOLETE {
568// OBSOLETE if (fi)
569// OBSOLETE {
570// OBSOLETE status = target_read_memory (addr + 1, buf, 1);
571// OBSOLETE if (status != 0)
572// OBSOLETE return addr;
573// OBSOLETE fi->fsr.regs[5] = (get_frame_base (fi) + stack_size
574// OBSOLETE + extract_signed_integer (buf, 1));
575// OBSOLETE }
576// OBSOLETE addr += 2;
577// OBSOLETE if (addr >= stop)
578// OBSOLETE return addr;
579// OBSOLETE status = target_read_memory (addr, buf, 2);
580// OBSOLETE if (status != 0)
581// OBSOLETE return addr;
582// OBSOLETE }
583// OBSOLETE if (buf[0] == 0x5e || buf[0] == 0x5c)
584// OBSOLETE {
585// OBSOLETE if (fi)
586// OBSOLETE {
587// OBSOLETE status = target_read_memory (addr + 1, buf, 1);
588// OBSOLETE if (status != 0)
589// OBSOLETE return addr;
590// OBSOLETE fi->fsr.regs[6] = (get_frame_base (fi) + stack_size
591// OBSOLETE + extract_signed_integer (buf, 1));
592// OBSOLETE fi->status &= ~CALLER_A2_IN_A0;
593// OBSOLETE }
594// OBSOLETE addr += 2;
595// OBSOLETE if (addr >= stop)
596// OBSOLETE return addr;
597// OBSOLETE return addr;
598// OBSOLETE }
599// OBSOLETE return addr;
600// OBSOLETE }
601// OBSOLETE
602// OBSOLETE /* Function: frame_chain
603// OBSOLETE Figure out and return the caller's frame pointer given current
604// OBSOLETE frame_info struct.
605// OBSOLETE
606// OBSOLETE We don't handle dummy frames yet but we would probably just return the
607// OBSOLETE stack pointer that was in use at the time the function call was made? */
608// OBSOLETE
609// OBSOLETE CORE_ADDR
610// OBSOLETE mn10200_frame_chain (struct frame_info *fi)
611// OBSOLETE {
612// OBSOLETE struct frame_info *dummy_frame = deprecated_frame_xmalloc ();
613// OBSOLETE struct cleanup *old_chain = make_cleanup (xfree, dummy_frame);
614// OBSOLETE CORE_ADDR ret;
615// OBSOLETE
616// OBSOLETE /* Walk through the prologue to determine the stack size,
617// OBSOLETE location of saved registers, end of the prologue, etc. */
618// OBSOLETE if (fi->status == 0)
619// OBSOLETE mn10200_analyze_prologue (fi, (CORE_ADDR) 0);
620// OBSOLETE
621// OBSOLETE /* Quit now if mn10200_analyze_prologue set NO_MORE_FRAMES. */
622// OBSOLETE if (fi->status & NO_MORE_FRAMES)
623// OBSOLETE return 0;
624// OBSOLETE
625// OBSOLETE /* Now that we've analyzed our prologue, determine the frame
626// OBSOLETE pointer for our caller.
627// OBSOLETE
628// OBSOLETE If our caller has a frame pointer, then we need to
629// OBSOLETE find the entry value of $a2 to our function.
630// OBSOLETE
631// OBSOLETE If CALLER_A2_IN_A0, then the chain is in $a0.
632// OBSOLETE
633// OBSOLETE If fsr.regs[6] is nonzero, then it's at the memory
634// OBSOLETE location pointed to by fsr.regs[6].
635// OBSOLETE
636// OBSOLETE Else it's still in $a2.
637// OBSOLETE
638// OBSOLETE If our caller does not have a frame pointer, then his
639// OBSOLETE frame base is fi->frame + -caller's stack size + 4. */
640// OBSOLETE
641// OBSOLETE /* The easiest way to get that info is to analyze our caller's frame.
642// OBSOLETE
643// OBSOLETE So we set up a dummy frame and call mn10200_analyze_prologue to
644// OBSOLETE find stuff for us. */
645// OBSOLETE deprecated_update_frame_pc_hack (dummy_frame, FRAME_SAVED_PC (fi));
646// OBSOLETE deprecated_update_frame_base_hack (dummy_frame, get_frame_base (fi));
647// OBSOLETE memset (dummy_frame->fsr.regs, '\000', sizeof dummy_frame->fsr.regs);
648// OBSOLETE dummy_frame->status = 0;
649// OBSOLETE dummy_frame->stack_size = 0;
650// OBSOLETE mn10200_analyze_prologue (dummy_frame, 0);
651// OBSOLETE
652// OBSOLETE if (dummy_frame->status & MY_FRAME_IN_FP)
653// OBSOLETE {
654// OBSOLETE /* Our caller has a frame pointer. So find the frame in $a2, $a0,
655// OBSOLETE or in the stack. */
656// OBSOLETE if (fi->fsr.regs[6])
657// OBSOLETE ret = (read_memory_integer (fi->fsr.regs[FP_REGNUM], REGISTER_SIZE)
658// OBSOLETE & 0xffffff);
659// OBSOLETE else if (fi->status & CALLER_A2_IN_A0)
660// OBSOLETE ret = read_register (4);
661// OBSOLETE else
662// OBSOLETE ret = read_register (FP_REGNUM);
663// OBSOLETE }
664// OBSOLETE else
665// OBSOLETE {
666// OBSOLETE /* Our caller does not have a frame pointer. So his frame starts
667// OBSOLETE at the base of our frame (fi->frame) + <his size> + 4 (saved pc). */
668// OBSOLETE ret = get_frame_base (fi) + -dummy_frame->stack_size + 4;
669// OBSOLETE }
670// OBSOLETE do_cleanups (old_chain);
671// OBSOLETE return ret;
672// OBSOLETE }
673// OBSOLETE
674// OBSOLETE /* Function: skip_prologue
675// OBSOLETE Return the address of the first inst past the prologue of the function. */
676// OBSOLETE
677// OBSOLETE CORE_ADDR
678// OBSOLETE mn10200_skip_prologue (CORE_ADDR pc)
679// OBSOLETE {
680// OBSOLETE /* We used to check the debug symbols, but that can lose if
681// OBSOLETE we have a null prologue. */
682// OBSOLETE return mn10200_analyze_prologue (NULL, pc);
683// OBSOLETE }
684// OBSOLETE
685// OBSOLETE /* Function: pop_frame
686// OBSOLETE This routine gets called when either the user uses the `return'
687// OBSOLETE command, or the call dummy breakpoint gets hit. */
688// OBSOLETE
689// OBSOLETE void
690// OBSOLETE mn10200_pop_frame (struct frame_info *frame)
691// OBSOLETE {
692// OBSOLETE int regnum;
693// OBSOLETE
694// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
695// OBSOLETE get_frame_base (frame),
696// OBSOLETE get_frame_base (frame)))
697// OBSOLETE generic_pop_dummy_frame ();
698// OBSOLETE else
699// OBSOLETE {
700// OBSOLETE write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
701// OBSOLETE
702// OBSOLETE /* Restore any saved registers. */
703// OBSOLETE for (regnum = 0; regnum < NUM_REGS; regnum++)
704// OBSOLETE if (frame->fsr.regs[regnum] != 0)
705// OBSOLETE {
706// OBSOLETE ULONGEST value;
707// OBSOLETE
708// OBSOLETE value = read_memory_unsigned_integer (frame->fsr.regs[regnum],
709// OBSOLETE REGISTER_RAW_SIZE (regnum));
710// OBSOLETE write_register (regnum, value);
711// OBSOLETE }
712// OBSOLETE
713// OBSOLETE /* Actually cut back the stack. */
714// OBSOLETE write_register (SP_REGNUM, get_frame_base (frame));
715// OBSOLETE
716// OBSOLETE /* Don't we need to set the PC?!? XXX FIXME. */
717// OBSOLETE }
718// OBSOLETE
719// OBSOLETE /* Throw away any cached frame information. */
720// OBSOLETE flush_cached_frames ();
721// OBSOLETE }
722// OBSOLETE
723// OBSOLETE /* Function: push_arguments
724// OBSOLETE Setup arguments for a call to the target. Arguments go in
725// OBSOLETE order on the stack. */
726// OBSOLETE
727// OBSOLETE CORE_ADDR
728// OBSOLETE mn10200_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
729// OBSOLETE unsigned char struct_return, CORE_ADDR struct_addr)
730// OBSOLETE {
731// OBSOLETE int argnum = 0;
732// OBSOLETE int len = 0;
733// OBSOLETE int stack_offset = 0;
734// OBSOLETE int regsused = struct_return ? 1 : 0;
735// OBSOLETE
736// OBSOLETE /* This should be a nop, but align the stack just in case something
737// OBSOLETE went wrong. Stacks are two byte aligned on the mn10200. */
738// OBSOLETE sp &= ~1;
739// OBSOLETE
740// OBSOLETE /* Now make space on the stack for the args.
741// OBSOLETE
742// OBSOLETE XXX This doesn't appear to handle pass-by-invisible reference
743// OBSOLETE arguments. */
744// OBSOLETE for (argnum = 0; argnum < nargs; argnum++)
745// OBSOLETE {
746// OBSOLETE int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 1) & ~1;
747// OBSOLETE
748// OBSOLETE /* If we've used all argument registers, then this argument is
749// OBSOLETE pushed. */
750// OBSOLETE if (regsused >= 2 || arg_length > 4)
751// OBSOLETE {
752// OBSOLETE regsused = 2;
753// OBSOLETE len += arg_length;
754// OBSOLETE }
755// OBSOLETE /* We know we've got some arg register space left. If this argument
756// OBSOLETE will fit entirely in regs, then put it there. */
757// OBSOLETE else if (arg_length <= 2
758// OBSOLETE || TYPE_CODE (VALUE_TYPE (args[argnum])) == TYPE_CODE_PTR)
759// OBSOLETE {
760// OBSOLETE regsused++;
761// OBSOLETE }
762// OBSOLETE else if (regsused == 0)
763// OBSOLETE {
764// OBSOLETE regsused = 2;
765// OBSOLETE }
766// OBSOLETE else
767// OBSOLETE {
768// OBSOLETE regsused = 2;
769// OBSOLETE len += arg_length;
770// OBSOLETE }
771// OBSOLETE }
772// OBSOLETE
773// OBSOLETE /* Allocate stack space. */
774// OBSOLETE sp -= len;
775// OBSOLETE
776// OBSOLETE regsused = struct_return ? 1 : 0;
777// OBSOLETE /* Push all arguments onto the stack. */
778// OBSOLETE for (argnum = 0; argnum < nargs; argnum++)
779// OBSOLETE {
780// OBSOLETE int len;
781// OBSOLETE char *val;
782// OBSOLETE
783// OBSOLETE /* XXX Check this. What about UNIONS? */
784// OBSOLETE if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
785// OBSOLETE && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
786// OBSOLETE {
787// OBSOLETE /* XXX Wrong, we want a pointer to this argument. */
788// OBSOLETE len = TYPE_LENGTH (VALUE_TYPE (*args));
789// OBSOLETE val = (char *) VALUE_CONTENTS (*args);
790// OBSOLETE }
791// OBSOLETE else
792// OBSOLETE {
793// OBSOLETE len = TYPE_LENGTH (VALUE_TYPE (*args));
794// OBSOLETE val = (char *) VALUE_CONTENTS (*args);
795// OBSOLETE }
796// OBSOLETE
797// OBSOLETE if (regsused < 2
798// OBSOLETE && (len <= 2
799// OBSOLETE || TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_PTR))
800// OBSOLETE {
801// OBSOLETE write_register (regsused, extract_unsigned_integer (val, 4));
802// OBSOLETE regsused++;
803// OBSOLETE }
804// OBSOLETE else if (regsused == 0 && len == 4)
805// OBSOLETE {
806// OBSOLETE write_register (regsused, extract_unsigned_integer (val, 2));
807// OBSOLETE write_register (regsused + 1, extract_unsigned_integer (val + 2, 2));
808// OBSOLETE regsused = 2;
809// OBSOLETE }
810// OBSOLETE else
811// OBSOLETE {
812// OBSOLETE regsused = 2;
813// OBSOLETE while (len > 0)
814// OBSOLETE {
815// OBSOLETE write_memory (sp + stack_offset, val, 2);
816// OBSOLETE
817// OBSOLETE len -= 2;
818// OBSOLETE val += 2;
819// OBSOLETE stack_offset += 2;
820// OBSOLETE }
821// OBSOLETE }
822// OBSOLETE args++;
823// OBSOLETE }
824// OBSOLETE
825// OBSOLETE return sp;
826// OBSOLETE }
827// OBSOLETE
828// OBSOLETE /* Function: push_return_address (pc)
829// OBSOLETE Set up the return address for the inferior function call.
830// OBSOLETE Needed for targets where we don't actually execute a JSR/BSR instruction */
831// OBSOLETE
832// OBSOLETE CORE_ADDR
833// OBSOLETE mn10200_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
834// OBSOLETE {
835// OBSOLETE unsigned char buf[4];
836// OBSOLETE
837// OBSOLETE store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
838// OBSOLETE write_memory (sp - 4, buf, 4);
839// OBSOLETE return sp - 4;
840// OBSOLETE }
841// OBSOLETE
842// OBSOLETE /* Function: store_struct_return (addr,sp)
843// OBSOLETE Store the structure value return address for an inferior function
844// OBSOLETE call. */
845// OBSOLETE
846// OBSOLETE CORE_ADDR
847// OBSOLETE mn10200_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
848// OBSOLETE {
849// OBSOLETE /* The structure return address is passed as the first argument. */
850// OBSOLETE write_register (0, addr);
851// OBSOLETE return sp;
852// OBSOLETE }
853// OBSOLETE
854// OBSOLETE /* Function: frame_saved_pc
855// OBSOLETE Find the caller of this frame. We do this by seeing if RP_REGNUM
856// OBSOLETE is saved in the stack anywhere, otherwise we get it from the
857// OBSOLETE registers. If the inner frame is a dummy frame, return its PC
858// OBSOLETE instead of RP, because that's where "caller" of the dummy-frame
859// OBSOLETE will be found. */
860// OBSOLETE
861// OBSOLETE CORE_ADDR
862// OBSOLETE mn10200_frame_saved_pc (struct frame_info *fi)
863// OBSOLETE {
864// OBSOLETE /* The saved PC will always be at the base of the current frame. */
865// OBSOLETE return (read_memory_integer (get_frame_base (fi), REGISTER_SIZE) & 0xffffff);
866// OBSOLETE }
867// OBSOLETE
868// OBSOLETE /* Function: init_extra_frame_info
869// OBSOLETE Setup the frame's frame pointer, pc, and frame addresses for saved
870// OBSOLETE registers. Most of the work is done in mn10200_analyze_prologue().
871// OBSOLETE
872// OBSOLETE Note that when we are called for the last frame (currently active frame),
873// OBSOLETE that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
874// OBSOLETE be valid only if this routine uses FP. For previous frames, fi-frame will
875// OBSOLETE always be correct. mn10200_analyze_prologue will fix fi->frame if
876// OBSOLETE it's not valid.
877// OBSOLETE
878// OBSOLETE We can be called with the PC in the call dummy under two circumstances.
879// OBSOLETE First, during normal backtracing, second, while figuring out the frame
880// OBSOLETE pointer just prior to calling the target function (see run_stack_dummy). */
881// OBSOLETE
882// OBSOLETE void
883// OBSOLETE mn10200_init_extra_frame_info (struct frame_info *fi)
884// OBSOLETE {
885// OBSOLETE if (get_next_frame (fi))
886// OBSOLETE deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (get_next_frame (fi)));
887// OBSOLETE
888// OBSOLETE memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
889// OBSOLETE fi->status = 0;
890// OBSOLETE fi->stack_size = 0;
891// OBSOLETE
892// OBSOLETE mn10200_analyze_prologue (fi, 0);
893// OBSOLETE }
894// OBSOLETE
895// OBSOLETE void
896// OBSOLETE _initialize_mn10200_tdep (void)
897// OBSOLETE {
898// OBSOLETE tm_print_insn = print_insn_mn10200;
899// OBSOLETE }
GDB Binutils - Deliverables
This page took 0.074895 seconds and 4 git commands to generate.