1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 2000, 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
35 #include "solib-svr4.h"
38 /* The following two instructions are used in the signal trampoline
39 code on GNU/Linux PPC. */
40 #define INSTR_LI_R0_0x7777 0x38007777
41 #define INSTR_SC 0x44000002
43 /* Since the *-tdep.c files are platform independent (i.e, they may be
44 used to build cross platform debuggers), we can't include system
45 headers. Therefore, details concerning the sigcontext structure
46 must be painstakingly rerecorded. What's worse, if these details
47 ever change in the header files, they'll have to be changed here
50 /* __SIGNAL_FRAMESIZE from <asm/ptrace.h> */
51 #define PPC_LINUX_SIGNAL_FRAMESIZE 64
53 /* From <asm/sigcontext.h>, offsetof(struct sigcontext_struct, regs) == 0x1c */
54 #define PPC_LINUX_REGS_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x1c)
56 /* From <asm/sigcontext.h>,
57 offsetof(struct sigcontext_struct, handler) == 0x14 */
58 #define PPC_LINUX_HANDLER_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x14)
60 /* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
61 #define PPC_LINUX_PT_R0 0
62 #define PPC_LINUX_PT_R1 1
63 #define PPC_LINUX_PT_R2 2
64 #define PPC_LINUX_PT_R3 3
65 #define PPC_LINUX_PT_R4 4
66 #define PPC_LINUX_PT_R5 5
67 #define PPC_LINUX_PT_R6 6
68 #define PPC_LINUX_PT_R7 7
69 #define PPC_LINUX_PT_R8 8
70 #define PPC_LINUX_PT_R9 9
71 #define PPC_LINUX_PT_R10 10
72 #define PPC_LINUX_PT_R11 11
73 #define PPC_LINUX_PT_R12 12
74 #define PPC_LINUX_PT_R13 13
75 #define PPC_LINUX_PT_R14 14
76 #define PPC_LINUX_PT_R15 15
77 #define PPC_LINUX_PT_R16 16
78 #define PPC_LINUX_PT_R17 17
79 #define PPC_LINUX_PT_R18 18
80 #define PPC_LINUX_PT_R19 19
81 #define PPC_LINUX_PT_R20 20
82 #define PPC_LINUX_PT_R21 21
83 #define PPC_LINUX_PT_R22 22
84 #define PPC_LINUX_PT_R23 23
85 #define PPC_LINUX_PT_R24 24
86 #define PPC_LINUX_PT_R25 25
87 #define PPC_LINUX_PT_R26 26
88 #define PPC_LINUX_PT_R27 27
89 #define PPC_LINUX_PT_R28 28
90 #define PPC_LINUX_PT_R29 29
91 #define PPC_LINUX_PT_R30 30
92 #define PPC_LINUX_PT_R31 31
93 #define PPC_LINUX_PT_NIP 32
94 #define PPC_LINUX_PT_MSR 33
95 #define PPC_LINUX_PT_CTR 35
96 #define PPC_LINUX_PT_LNK 36
97 #define PPC_LINUX_PT_XER 37
98 #define PPC_LINUX_PT_CCR 38
99 #define PPC_LINUX_PT_MQ 39
100 #define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */
101 #define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
102 #define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
104 static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc
);
106 /* Determine if pc is in a signal trampoline...
108 Ha! That's not what this does at all. wait_for_inferior in
109 infrun.c calls IN_SIGTRAMP in order to detect entry into a signal
110 trampoline just after delivery of a signal. But on GNU/Linux,
111 signal trampolines are used for the return path only. The kernel
112 sets things up so that the signal handler is called directly.
114 If we use in_sigtramp2() in place of in_sigtramp() (see below)
115 we'll (often) end up with stop_pc in the trampoline and prev_pc in
116 the (now exited) handler. The code there will cause a temporary
117 breakpoint to be set on prev_pc which is not very likely to get hit
120 If this is confusing, think of it this way... the code in
121 wait_for_inferior() needs to be able to detect entry into a signal
122 trampoline just after a signal is delivered, not after the handler
125 So, we define in_sigtramp() below to return 1 if the following is
128 1) The previous frame is a real signal trampoline.
132 2) pc is at the first or second instruction of the corresponding
135 Why the second instruction? It seems that wait_for_inferior()
136 never sees the first instruction when single stepping. When a
137 signal is delivered while stepping, the next instruction that
138 would've been stepped over isn't, instead a signal is delivered and
139 the first instruction of the handler is stepped over instead. That
140 puts us on the second instruction. (I added the test for the
141 first instruction long after the fact, just in case the observed
142 behavior is ever fixed.)
144 IN_SIGTRAMP is called from blockframe.c as well in order to set
145 the signal_handler_caller flag. Because of our strange definition
146 of in_sigtramp below, we can't rely on signal_handler_caller getting
147 set correctly from within blockframe.c. This is why we take pains
148 to set it in init_extra_frame_info(). */
151 ppc_linux_in_sigtramp (CORE_ADDR pc
, char *func_name
)
159 lr
= read_register (gdbarch_tdep (current_gdbarch
)->ppc_lr_regnum
);
160 if (!ppc_linux_at_sigtramp_return_path (lr
))
163 sp
= read_register (SP_REGNUM
);
165 if (target_read_memory (sp
, buf
, sizeof (buf
)) != 0)
168 tramp_sp
= extract_unsigned_integer (buf
, 4);
170 if (target_read_memory (tramp_sp
+ PPC_LINUX_HANDLER_PTR_OFFSET
, buf
,
174 handler
= extract_unsigned_integer (buf
, 4);
176 return (pc
== handler
|| pc
== handler
+ 4);
180 * The signal handler trampoline is on the stack and consists of exactly
181 * two instructions. The easiest and most accurate way of determining
182 * whether the pc is in one of these trampolines is by inspecting the
183 * instructions. It'd be faster though if we could find a way to do this
184 * via some simple address comparisons.
187 ppc_linux_at_sigtramp_return_path (CORE_ADDR pc
)
190 unsigned long pcinsn
;
191 if (target_read_memory (pc
- 4, buf
, sizeof (buf
)) != 0)
194 /* extract the instruction at the pc */
195 pcinsn
= extract_unsigned_integer (buf
+ 4, 4);
198 (pcinsn
== INSTR_LI_R0_0x7777
199 && extract_unsigned_integer (buf
+ 8, 4) == INSTR_SC
)
202 && extract_unsigned_integer (buf
, 4) == INSTR_LI_R0_0x7777
));
206 ppc_linux_skip_trampoline_code (CORE_ADDR pc
)
209 struct obj_section
*sect
;
210 struct objfile
*objfile
;
212 CORE_ADDR plt_start
= 0;
213 CORE_ADDR symtab
= 0;
214 CORE_ADDR strtab
= 0;
216 int reloc_index
= -1;
222 struct minimal_symbol
*msymbol
;
224 /* Find the section pc is in; return if not in .plt */
225 sect
= find_pc_section (pc
);
226 if (!sect
|| strcmp (sect
->the_bfd_section
->name
, ".plt") != 0)
229 objfile
= sect
->objfile
;
231 /* Pick up the instruction at pc. It had better be of the
235 where IDX is an index into the plt_table. */
237 if (target_read_memory (pc
, buf
, 4) != 0)
239 insn
= extract_unsigned_integer (buf
, 4);
241 if ((insn
& 0xffff0000) != 0x39600000 /* li r11, VAL */ )
244 reloc_index
= (insn
<< 16) >> 16;
246 /* Find the objfile that pc is in and obtain the information
247 necessary for finding the symbol name. */
248 for (sect
= objfile
->sections
; sect
< objfile
->sections_end
; ++sect
)
250 const char *secname
= sect
->the_bfd_section
->name
;
251 if (strcmp (secname
, ".plt") == 0)
252 plt_start
= sect
->addr
;
253 else if (strcmp (secname
, ".rela.plt") == 0)
254 num_slots
= ((int) sect
->endaddr
- (int) sect
->addr
) / 12;
255 else if (strcmp (secname
, ".dynsym") == 0)
257 else if (strcmp (secname
, ".dynstr") == 0)
261 /* Make sure we have all the information we need. */
262 if (plt_start
== 0 || num_slots
== -1 || symtab
== 0 || strtab
== 0)
265 /* Compute the value of the plt table */
266 plt_table
= plt_start
+ 72 + 8 * num_slots
;
268 /* Get address of the relocation entry (Elf32_Rela) */
269 if (target_read_memory (plt_table
+ reloc_index
, buf
, 4) != 0)
271 reloc
= extract_address (buf
, 4);
273 sect
= find_pc_section (reloc
);
277 if (strcmp (sect
->the_bfd_section
->name
, ".text") == 0)
280 /* Now get the r_info field which is the relocation type and symbol
282 if (target_read_memory (reloc
+ 4, buf
, 4) != 0)
284 symidx
= extract_unsigned_integer (buf
, 4);
286 /* Shift out the relocation type leaving just the symbol index */
287 /* symidx = ELF32_R_SYM(symidx); */
288 symidx
= symidx
>> 8;
290 /* compute the address of the symbol */
291 sym
= symtab
+ symidx
* 4;
293 /* Fetch the string table index */
294 if (target_read_memory (sym
, buf
, 4) != 0)
296 symidx
= extract_unsigned_integer (buf
, 4);
298 /* Fetch the string; we don't know how long it is. Is it possible
299 that the following will fail because we're trying to fetch too
301 if (target_read_memory (strtab
+ symidx
, symname
, sizeof (symname
)) != 0)
304 /* This might not work right if we have multiple symbols with the
305 same name; the only way to really get it right is to perform
306 the same sort of lookup as the dynamic linker. */
307 msymbol
= lookup_minimal_symbol_text (symname
, NULL
, NULL
);
311 return SYMBOL_VALUE_ADDRESS (msymbol
);
314 /* The rs6000 version of FRAME_SAVED_PC will almost work for us. The
315 signal handler details are different, so we'll handle those here
316 and call the rs6000 version to do the rest. */
318 ppc_linux_frame_saved_pc (struct frame_info
*fi
)
320 if (fi
->signal_handler_caller
)
322 CORE_ADDR regs_addr
=
323 read_memory_integer (fi
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
324 /* return the NIP in the regs array */
325 return read_memory_integer (regs_addr
+ 4 * PPC_LINUX_PT_NIP
, 4);
327 else if (fi
->next
&& fi
->next
->signal_handler_caller
)
329 CORE_ADDR regs_addr
=
330 read_memory_integer (fi
->next
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
331 /* return LNK in the regs array */
332 return read_memory_integer (regs_addr
+ 4 * PPC_LINUX_PT_LNK
, 4);
335 return rs6000_frame_saved_pc (fi
);
339 ppc_linux_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
341 rs6000_init_extra_frame_info (fromleaf
, fi
);
345 /* We're called from get_prev_frame_info; check to see if
346 this is a signal frame by looking to see if the pc points
347 at trampoline code */
348 if (ppc_linux_at_sigtramp_return_path (fi
->pc
))
349 fi
->signal_handler_caller
= 1;
351 fi
->signal_handler_caller
= 0;
356 ppc_linux_frameless_function_invocation (struct frame_info
*fi
)
358 /* We'll find the wrong thing if we let
359 rs6000_frameless_function_invocation () search for a signal trampoline */
360 if (ppc_linux_at_sigtramp_return_path (fi
->pc
))
363 return rs6000_frameless_function_invocation (fi
);
367 ppc_linux_frame_init_saved_regs (struct frame_info
*fi
)
369 if (fi
->signal_handler_caller
)
376 frame_saved_regs_zalloc (fi
);
379 read_memory_integer (fi
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
380 fi
->saved_regs
[PC_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_NIP
;
381 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_ps_regnum
] =
382 regs_addr
+ 4 * PPC_LINUX_PT_MSR
;
383 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_cr_regnum
] =
384 regs_addr
+ 4 * PPC_LINUX_PT_CCR
;
385 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_lr_regnum
] =
386 regs_addr
+ 4 * PPC_LINUX_PT_LNK
;
387 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_ctr_regnum
] =
388 regs_addr
+ 4 * PPC_LINUX_PT_CTR
;
389 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_xer_regnum
] =
390 regs_addr
+ 4 * PPC_LINUX_PT_XER
;
391 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_mq_regnum
] =
392 regs_addr
+ 4 * PPC_LINUX_PT_MQ
;
393 for (i
= 0; i
< 32; i
++)
394 fi
->saved_regs
[gdbarch_tdep (current_gdbarch
)->ppc_gp0_regnum
+ i
] =
395 regs_addr
+ 4 * PPC_LINUX_PT_R0
+ 4 * i
;
396 for (i
= 0; i
< 32; i
++)
397 fi
->saved_regs
[FP0_REGNUM
+ i
] = regs_addr
+ 4 * PPC_LINUX_PT_FPR0
+ 8 * i
;
400 rs6000_frame_init_saved_regs (fi
);
404 ppc_linux_frame_chain (struct frame_info
*thisframe
)
406 /* Kernel properly constructs the frame chain for the handler */
407 if (thisframe
->signal_handler_caller
)
408 return read_memory_integer ((thisframe
)->frame
, 4);
410 return rs6000_frame_chain (thisframe
);
413 /* FIXME: Move the following to rs6000-tdep.c (or some other file where
414 it may be used generically by ports which use either the SysV ABI or
417 /* Structures 8 bytes or less long are returned in the r3 & r4
418 registers, according to the SYSV ABI. */
420 ppc_sysv_abi_use_struct_convention (int gcc_p
, struct type
*value_type
)
422 return (TYPE_LENGTH (value_type
) > 8);
425 /* round2 rounds x up to the nearest multiple of s assuming that s is a
429 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
431 /* Pass the arguments in either registers, or in the stack. Using the
432 ppc sysv ABI, the first eight words of the argument list (that might
433 be less than eight parameters if some parameters occupy more than one
434 word) are passed in r3..r10 registers. float and double parameters are
435 passed in fpr's, in addition to that. Rest of the parameters if any
436 are passed in user stack.
438 If the function is returning a structure, then the return address is passed
439 in r3, then the first 7 words of the parametes can be passed in registers,
443 ppc_sysv_abi_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
444 int struct_return
, CORE_ADDR struct_addr
)
458 greg
= struct_return
? 4 : 3;
463 /* Figure out how much new stack space is required for arguments
464 which don't fit in registers. Unlike the PowerOpen ABI, the
465 SysV ABI doesn't reserve any extra space for parameters which
466 are put in registers. */
467 for (argno
= 0; argno
< nargs
; argno
++)
470 type
= check_typedef (VALUE_TYPE (arg
));
471 len
= TYPE_LENGTH (type
);
473 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
479 /* SysV ABI converts floats to doubles when placed in
480 memory and requires 8 byte alignment */
481 if (argstkspace
& 0x4)
486 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
491 if (argstkspace
& 0x4)
505 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
506 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
508 /* Rounding to the nearest multiple of 8 may not be necessary,
509 but it is safe. Particularly since we don't know the
510 field types of the structure */
511 structstkspace
+= round2 (len
, 8);
520 /* Get current SP location */
521 saved_sp
= read_sp ();
523 sp
-= argstkspace
+ structstkspace
;
525 /* Allocate space for backchain and callee's saved lr */
528 /* Make sure that we maintain 16 byte alignment */
531 /* Update %sp before proceeding any further */
532 write_register (SP_REGNUM
, sp
);
534 /* write the backchain */
535 store_address (old_sp_buf
, 4, saved_sp
);
536 write_memory (sp
, old_sp_buf
, 4);
539 structoffset
= argoffset
+ argstkspace
;
542 /* Fill in r3 with the return structure, if any */
546 store_address (val_buf
, 4, struct_addr
);
547 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
550 /* Now fill in the registers and stack... */
551 for (argno
= 0; argno
< nargs
; argno
++)
554 type
= check_typedef (VALUE_TYPE (arg
));
555 len
= TYPE_LENGTH (type
);
557 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
563 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
564 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
+ freg
)],
565 VALUE_CONTENTS (arg
), len
);
570 /* SysV ABI converts floats to doubles when placed in
571 memory and requires 8 byte alignment */
572 /* FIXME: Convert floats to doubles */
575 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
579 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
586 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
594 memcpy (®isters
[REGISTER_BYTE (greg
)],
595 VALUE_CONTENTS (arg
), 4);
596 memcpy (®isters
[REGISTER_BYTE (greg
+ 1)],
597 VALUE_CONTENTS (arg
) + 4, 4);
605 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
606 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
608 write_memory (sp
+ structoffset
, VALUE_CONTENTS (arg
), len
);
609 store_address (val_buf
, 4, sp
+ structoffset
);
610 structoffset
+= round2 (len
, 8);
614 memset (val_buf
, 0, 4);
615 memcpy (val_buf
, VALUE_CONTENTS (arg
), len
);
619 *(int *) ®isters
[REGISTER_BYTE (greg
)] = 0;
620 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
625 write_memory (sp
+ argoffset
, val_buf
, 4);
631 target_store_registers (-1);
635 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
636 in much the same fashion as memory_remove_breakpoint in mem-break.c,
637 but is careful not to write back the previous contents if the code
638 in question has changed in between inserting the breakpoint and
641 Here is the problem that we're trying to solve...
643 Once upon a time, before introducing this function to remove
644 breakpoints from the inferior, setting a breakpoint on a shared
645 library function prior to running the program would not work
646 properly. In order to understand the problem, it is first
647 necessary to understand a little bit about dynamic linking on
650 A call to a shared library function is accomplished via a bl
651 (branch-and-link) instruction whose branch target is an entry
652 in the procedure linkage table (PLT). The PLT in the object
653 file is uninitialized. To gdb, prior to running the program, the
654 entries in the PLT are all zeros.
656 Once the program starts running, the shared libraries are loaded
657 and the procedure linkage table is initialized, but the entries in
658 the table are not (necessarily) resolved. Once a function is
659 actually called, the code in the PLT is hit and the function is
660 resolved. In order to better illustrate this, an example is in
661 order; the following example is from the gdb testsuite.
663 We start the program shmain.
665 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
668 We place two breakpoints, one on shr1 and the other on main.
671 Breakpoint 1 at 0x100409d4
673 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
675 Examine the instruction (and the immediatly following instruction)
676 upon which the breakpoint was placed. Note that the PLT entry
677 for shr1 contains zeros.
679 (gdb) x/2i 0x100409d4
680 0x100409d4 <shr1>: .long 0x0
681 0x100409d8 <shr1+4>: .long 0x0
686 Starting program: gdb.base/shmain
687 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
689 Breakpoint 2, main ()
690 at gdb.base/shmain.c:44
693 Examine the PLT again. Note that the loading of the shared
694 library has initialized the PLT to code which loads a constant
695 (which I think is an index into the GOT) into r11 and then
696 branchs a short distance to the code which actually does the
699 (gdb) x/2i 0x100409d4
700 0x100409d4 <shr1>: li r11,4
701 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
705 Breakpoint 1, shr1 (x=1)
706 at gdb.base/shr1.c:19
709 Now we've hit the breakpoint at shr1. (The breakpoint was
710 reset from the PLT entry to the actual shr1 function after the
711 shared library was loaded.) Note that the PLT entry has been
712 resolved to contain a branch that takes us directly to shr1.
713 (The real one, not the PLT entry.)
715 (gdb) x/2i 0x100409d4
716 0x100409d4 <shr1>: b 0xffaf76c <shr1>
717 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
719 The thing to note here is that the PLT entry for shr1 has been
722 Now the problem should be obvious. GDB places a breakpoint (a
723 trap instruction) on the zero value of the PLT entry for shr1.
724 Later on, after the shared library had been loaded and the PLT
725 initialized, GDB gets a signal indicating this fact and attempts
726 (as it always does when it stops) to remove all the breakpoints.
728 The breakpoint removal was causing the former contents (a zero
729 word) to be written back to the now initialized PLT entry thus
730 destroying a portion of the initialization that had occurred only a
731 short time ago. When execution continued, the zero word would be
732 executed as an instruction an an illegal instruction trap was
733 generated instead. (0 is not a legal instruction.)
735 The fix for this problem was fairly straightforward. The function
736 memory_remove_breakpoint from mem-break.c was copied to this file,
737 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
738 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
741 The differences between ppc_linux_memory_remove_breakpoint () and
742 memory_remove_breakpoint () are minor. All that the former does
743 that the latter does not is check to make sure that the breakpoint
744 location actually contains a breakpoint (trap instruction) prior
745 to attempting to write back the old contents. If it does contain
746 a trap instruction, we allow the old contents to be written back.
747 Otherwise, we silently do nothing.
749 The big question is whether memory_remove_breakpoint () should be
750 changed to have the same functionality. The downside is that more
751 traffic is generated for remote targets since we'll have an extra
752 fetch of a memory word each time a breakpoint is removed.
754 For the time being, we'll leave this self-modifying-code-friendly
755 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
756 else in the event that some other platform has similar needs with
757 regard to removing breakpoints in some potentially self modifying
760 ppc_linux_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
765 char old_contents
[BREAKPOINT_MAX
];
767 /* Determine appropriate breakpoint contents and size for this address. */
768 bp
= BREAKPOINT_FROM_PC (&addr
, &bplen
);
770 error ("Software breakpoints not implemented for this target.");
772 val
= target_read_memory (addr
, old_contents
, bplen
);
774 /* If our breakpoint is no longer at the address, this means that the
775 program modified the code on us, so it is wrong to put back the
777 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
778 val
= target_write_memory (addr
, contents_cache
, bplen
);
783 /* Fetch (and possibly build) an appropriate link_map_offsets
784 structure for GNU/Linux PPC targets using the struct offsets
785 defined in link.h (but without actual reference to that file).
787 This makes it possible to access GNU/Linux PPC shared libraries
788 from a GDB that was not built on an GNU/Linux PPC host (for cross
791 struct link_map_offsets
*
792 ppc_linux_svr4_fetch_link_map_offsets (void)
794 static struct link_map_offsets lmo
;
795 static struct link_map_offsets
*lmp
= NULL
;
801 lmo
.r_debug_size
= 8; /* The actual size is 20 bytes, but
802 this is all we need. */
803 lmo
.r_map_offset
= 4;
806 lmo
.link_map_size
= 20; /* The actual size is 560 bytes, but
807 this is all we need. */
808 lmo
.l_addr_offset
= 0;
811 lmo
.l_name_offset
= 4;
814 lmo
.l_next_offset
= 12;
817 lmo
.l_prev_offset
= 16;