1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 2000, 2001 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
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 infrun.c
109 calls IN_SIGTRAMP in order to detect entry into a signal trampoline
110 just after delivery of a signal. But on linux, signal trampolines
111 are used for the return path only. The kernel sets things up so that
112 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 /* round2 rounds x up to the nearest multiple of s assuming that s is a
421 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
423 /* Pass the arguments in either registers, or in the stack. Using the
424 ppc sysv ABI, the first eight words of the argument list (that might
425 be less than eight parameters if some parameters occupy more than one
426 word) are passed in r3..r10 registers. float and double parameters are
427 passed in fpr's, in addition to that. Rest of the parameters if any
428 are passed in user stack.
430 If the function is returning a structure, then the return address is passed
431 in r3, then the first 7 words of the parametes can be passed in registers,
435 ppc_sysv_abi_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
436 int struct_return
, CORE_ADDR struct_addr
)
450 greg
= struct_return
? 4 : 3;
455 /* Figure out how much new stack space is required for arguments
456 which don't fit in registers. Unlike the PowerOpen ABI, the
457 SysV ABI doesn't reserve any extra space for parameters which
458 are put in registers. */
459 for (argno
= 0; argno
< nargs
; argno
++)
462 type
= check_typedef (VALUE_TYPE (arg
));
463 len
= TYPE_LENGTH (type
);
465 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
471 /* SysV ABI converts floats to doubles when placed in
472 memory and requires 8 byte alignment */
473 if (argstkspace
& 0x4)
478 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
483 if (argstkspace
& 0x4)
497 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
498 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
500 /* Rounding to the nearest multiple of 8 may not be necessary,
501 but it is safe. Particularly since we don't know the
502 field types of the structure */
503 structstkspace
+= round2 (len
, 8);
512 /* Get current SP location */
513 saved_sp
= read_sp ();
515 sp
-= argstkspace
+ structstkspace
;
517 /* Allocate space for backchain and callee's saved lr */
520 /* Make sure that we maintain 16 byte alignment */
523 /* Update %sp before proceeding any further */
524 write_register (SP_REGNUM
, sp
);
526 /* write the backchain */
527 store_address (old_sp_buf
, 4, saved_sp
);
528 write_memory (sp
, old_sp_buf
, 4);
531 structoffset
= argoffset
+ argstkspace
;
534 /* Fill in r3 with the return structure, if any */
538 store_address (val_buf
, 4, struct_addr
);
539 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
542 /* Now fill in the registers and stack... */
543 for (argno
= 0; argno
< nargs
; argno
++)
546 type
= check_typedef (VALUE_TYPE (arg
));
547 len
= TYPE_LENGTH (type
);
549 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
555 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
556 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
+ freg
)],
557 VALUE_CONTENTS (arg
), len
);
562 /* SysV ABI converts floats to doubles when placed in
563 memory and requires 8 byte alignment */
564 /* FIXME: Convert floats to doubles */
567 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
571 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
578 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
586 memcpy (®isters
[REGISTER_BYTE (greg
)],
587 VALUE_CONTENTS (arg
), 4);
588 memcpy (®isters
[REGISTER_BYTE (greg
+ 1)],
589 VALUE_CONTENTS (arg
) + 4, 4);
597 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
598 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
600 write_memory (sp
+ structoffset
, VALUE_CONTENTS (arg
), len
);
601 store_address (val_buf
, 4, sp
+ structoffset
);
602 structoffset
+= round2 (len
, 8);
606 memset (val_buf
, 0, 4);
607 memcpy (val_buf
, VALUE_CONTENTS (arg
), len
);
611 *(int *) ®isters
[REGISTER_BYTE (greg
)] = 0;
612 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
617 write_memory (sp
+ argoffset
, val_buf
, 4);
623 target_store_registers (-1);
627 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
628 in much the same fashion as memory_remove_breakpoint in mem-break.c,
629 but is careful not to write back the previous contents if the code
630 in question has changed in between inserting the breakpoint and
633 Here is the problem that we're trying to solve...
635 Once upon a time, before introducing this function to remove
636 breakpoints from the inferior, setting a breakpoint on a shared
637 library function prior to running the program would not work
638 properly. In order to understand the problem, it is first
639 necessary to understand a little bit about dynamic linking on
642 A call to a shared library function is accomplished via a bl
643 (branch-and-link) instruction whose branch target is an entry
644 in the procedure linkage table (PLT). The PLT in the object
645 file is uninitialized. To gdb, prior to running the program, the
646 entries in the PLT are all zeros.
648 Once the program starts running, the shared libraries are loaded
649 and the procedure linkage table is initialized, but the entries in
650 the table are not (necessarily) resolved. Once a function is
651 actually called, the code in the PLT is hit and the function is
652 resolved. In order to better illustrate this, an example is in
653 order; the following example is from the gdb testsuite.
655 We start the program shmain.
657 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
660 We place two breakpoints, one on shr1 and the other on main.
663 Breakpoint 1 at 0x100409d4
665 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
667 Examine the instruction (and the immediatly following instruction)
668 upon which the breakpoint was placed. Note that the PLT entry
669 for shr1 contains zeros.
671 (gdb) x/2i 0x100409d4
672 0x100409d4 <shr1>: .long 0x0
673 0x100409d8 <shr1+4>: .long 0x0
678 Starting program: gdb.base/shmain
679 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
681 Breakpoint 2, main ()
682 at gdb.base/shmain.c:44
685 Examine the PLT again. Note that the loading of the shared
686 library has initialized the PLT to code which loads a constant
687 (which I think is an index into the GOT) into r11 and then
688 branchs a short distance to the code which actually does the
691 (gdb) x/2i 0x100409d4
692 0x100409d4 <shr1>: li r11,4
693 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
697 Breakpoint 1, shr1 (x=1)
698 at gdb.base/shr1.c:19
701 Now we've hit the breakpoint at shr1. (The breakpoint was
702 reset from the PLT entry to the actual shr1 function after the
703 shared library was loaded.) Note that the PLT entry has been
704 resolved to contain a branch that takes us directly to shr1.
705 (The real one, not the PLT entry.)
707 (gdb) x/2i 0x100409d4
708 0x100409d4 <shr1>: b 0xffaf76c <shr1>
709 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
711 The thing to note here is that the PLT entry for shr1 has been
714 Now the problem should be obvious. GDB places a breakpoint (a
715 trap instruction) on the zero value of the PLT entry for shr1.
716 Later on, after the shared library had been loaded and the PLT
717 initialized, GDB gets a signal indicating this fact and attempts
718 (as it always does when it stops) to remove all the breakpoints.
720 The breakpoint removal was causing the former contents (a zero
721 word) to be written back to the now initialized PLT entry thus
722 destroying a portion of the initialization that had occurred only a
723 short time ago. When execution continued, the zero word would be
724 executed as an instruction an an illegal instruction trap was
725 generated instead. (0 is not a legal instruction.)
727 The fix for this problem was fairly straightforward. The function
728 memory_remove_breakpoint from mem-break.c was copied to this file,
729 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
730 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
733 The differences between ppc_linux_memory_remove_breakpoint () and
734 memory_remove_breakpoint () are minor. All that the former does
735 that the latter does not is check to make sure that the breakpoint
736 location actually contains a breakpoint (trap instruction) prior
737 to attempting to write back the old contents. If it does contain
738 a trap instruction, we allow the old contents to be written back.
739 Otherwise, we silently do nothing.
741 The big question is whether memory_remove_breakpoint () should be
742 changed to have the same functionality. The downside is that more
743 traffic is generated for remote targets since we'll have an extra
744 fetch of a memory word each time a breakpoint is removed.
746 For the time being, we'll leave this self-modifying-code-friendly
747 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
748 else in the event that some other platform has similar needs with
749 regard to removing breakpoints in some potentially self modifying
752 ppc_linux_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
757 char old_contents
[BREAKPOINT_MAX
];
759 /* Determine appropriate breakpoint contents and size for this address. */
760 bp
= BREAKPOINT_FROM_PC (&addr
, &bplen
);
762 error ("Software breakpoints not implemented for this target.");
764 val
= target_read_memory (addr
, old_contents
, bplen
);
766 /* If our breakpoint is no longer at the address, this means that the
767 program modified the code on us, so it is wrong to put back the
769 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
770 val
= target_write_memory (addr
, contents_cache
, bplen
);
775 /* Fetch (and possibly build) an appropriate link_map_offsets
776 structure for Linux/PPC targets using the struct offsets
777 defined in link.h (but without actual reference to that file).
779 This makes it possible to access Linux/PPC shared libraries from a
780 GDB that was not built on an Linux/PPC host (for cross debugging). */
782 struct link_map_offsets
*
783 ppc_linux_svr4_fetch_link_map_offsets (void)
785 static struct link_map_offsets lmo
;
786 static struct link_map_offsets
*lmp
= NULL
;
792 lmo
.r_debug_size
= 8; /* The actual size is 20 bytes, but
793 this is all we need. */
794 lmo
.r_map_offset
= 4;
797 lmo
.link_map_size
= 20; /* The actual size is 560 bytes, but
798 this is all we need. */
799 lmo
.l_addr_offset
= 0;
802 lmo
.l_name_offset
= 4;
805 lmo
.l_next_offset
= 12;
808 lmo
.l_prev_offset
= 16;