1 /* Target-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 /* The following two instructions are used in the signal trampoline
36 #define INSTR_LI_R0_0x7777 0x38007777
37 #define INSTR_SC 0x44000002
39 /* Since the *-tdep.c files are platform independent (i.e, they may be
40 used to build cross platform debuggers), we can't include system
41 headers. Therefore, details concerning the sigcontext structure
42 must be painstakingly rerecorded. What's worse, if these details
43 ever change in the header files, they'll have to be changed here
46 /* __SIGNAL_FRAMESIZE from <asm/ptrace.h> */
47 #define PPC_LINUX_SIGNAL_FRAMESIZE 64
49 /* From <asm/sigcontext.h>, offsetof(struct sigcontext_struct, regs) == 0x1c */
50 #define PPC_LINUX_REGS_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x1c)
52 /* From <asm/sigcontext.h>,
53 offsetof(struct sigcontext_struct, handler) == 0x14 */
54 #define PPC_LINUX_HANDLER_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x14)
56 /* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
57 #define PPC_LINUX_PT_R0 0
58 #define PPC_LINUX_PT_R1 1
59 #define PPC_LINUX_PT_R2 2
60 #define PPC_LINUX_PT_R3 3
61 #define PPC_LINUX_PT_R4 4
62 #define PPC_LINUX_PT_R5 5
63 #define PPC_LINUX_PT_R6 6
64 #define PPC_LINUX_PT_R7 7
65 #define PPC_LINUX_PT_R8 8
66 #define PPC_LINUX_PT_R9 9
67 #define PPC_LINUX_PT_R10 10
68 #define PPC_LINUX_PT_R11 11
69 #define PPC_LINUX_PT_R12 12
70 #define PPC_LINUX_PT_R13 13
71 #define PPC_LINUX_PT_R14 14
72 #define PPC_LINUX_PT_R15 15
73 #define PPC_LINUX_PT_R16 16
74 #define PPC_LINUX_PT_R17 17
75 #define PPC_LINUX_PT_R18 18
76 #define PPC_LINUX_PT_R19 19
77 #define PPC_LINUX_PT_R20 20
78 #define PPC_LINUX_PT_R21 21
79 #define PPC_LINUX_PT_R22 22
80 #define PPC_LINUX_PT_R23 23
81 #define PPC_LINUX_PT_R24 24
82 #define PPC_LINUX_PT_R25 25
83 #define PPC_LINUX_PT_R26 26
84 #define PPC_LINUX_PT_R27 27
85 #define PPC_LINUX_PT_R28 28
86 #define PPC_LINUX_PT_R29 29
87 #define PPC_LINUX_PT_R30 30
88 #define PPC_LINUX_PT_R31 31
89 #define PPC_LINUX_PT_NIP 32
90 #define PPC_LINUX_PT_MSR 33
91 #define PPC_LINUX_PT_CTR 35
92 #define PPC_LINUX_PT_LNK 36
93 #define PPC_LINUX_PT_XER 37
94 #define PPC_LINUX_PT_CCR 38
95 #define PPC_LINUX_PT_MQ 39
96 #define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */
97 #define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
98 #define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
100 static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc
);
102 /* Determine if pc is in a signal trampoline...
104 Ha! That's not what this does at all. wait_for_inferior in infrun.c
105 calls IN_SIGTRAMP in order to detect entry into a signal trampoline
106 just after delivery of a signal. But on linux, signal trampolines
107 are used for the return path only. The kernel sets things up so that
108 the signal handler is called directly.
110 If we use in_sigtramp2() in place of in_sigtramp() (see below)
111 we'll (often) end up with stop_pc in the trampoline and prev_pc in
112 the (now exited) handler. The code there will cause a temporary
113 breakpoint to be set on prev_pc which is not very likely to get hit
116 If this is confusing, think of it this way... the code in
117 wait_for_inferior() needs to be able to detect entry into a signal
118 trampoline just after a signal is delivered, not after the handler
121 So, we define in_sigtramp() below to return 1 if the following is
124 1) The previous frame is a real signal trampoline.
128 2) pc is at the first or second instruction of the corresponding
131 Why the second instruction? It seems that wait_for_inferior()
132 never sees the first instruction when single stepping. When a
133 signal is delivered while stepping, the next instruction that
134 would've been stepped over isn't, instead a signal is delivered and
135 the first instruction of the handler is stepped over instead. That
136 puts us on the second instruction. (I added the test for the
137 first instruction long after the fact, just in case the observed
138 behavior is ever fixed.)
140 IN_SIGTRAMP is called from blockframe.c as well in order to set
141 the signal_handler_caller flag. Because of our strange definition
142 of in_sigtramp below, we can't rely on signal_handler_caller getting
143 set correctly from within blockframe.c. This is why we take pains
144 to set it in init_extra_frame_info(). */
147 ppc_linux_in_sigtramp (CORE_ADDR pc
, char *func_name
)
155 lr
= read_register (PPC_LR_REGNUM
);
156 if (!ppc_linux_at_sigtramp_return_path (lr
))
159 sp
= read_register (SP_REGNUM
);
161 if (target_read_memory (sp
, buf
, sizeof (buf
)) != 0)
164 tramp_sp
= extract_unsigned_integer (buf
, 4);
166 if (target_read_memory (tramp_sp
+ PPC_LINUX_HANDLER_PTR_OFFSET
, buf
,
170 handler
= extract_unsigned_integer (buf
, 4);
172 return (pc
== handler
|| pc
== handler
+ 4);
176 * The signal handler trampoline is on the stack and consists of exactly
177 * two instructions. The easiest and most accurate way of determining
178 * whether the pc is in one of these trampolines is by inspecting the
179 * instructions. It'd be faster though if we could find a way to do this
180 * via some simple address comparisons.
183 ppc_linux_at_sigtramp_return_path (CORE_ADDR pc
)
186 unsigned long pcinsn
;
187 if (target_read_memory (pc
- 4, buf
, sizeof (buf
)) != 0)
190 /* extract the instruction at the pc */
191 pcinsn
= extract_unsigned_integer (buf
+ 4, 4);
194 (pcinsn
== INSTR_LI_R0_0x7777
195 && extract_unsigned_integer (buf
+ 8, 4) == INSTR_SC
)
198 && extract_unsigned_integer (buf
, 4) == INSTR_LI_R0_0x7777
));
202 ppc_linux_skip_trampoline_code (CORE_ADDR pc
)
205 struct obj_section
*sect
;
206 struct objfile
*objfile
;
208 CORE_ADDR plt_start
= 0;
209 CORE_ADDR symtab
= 0;
210 CORE_ADDR strtab
= 0;
212 int reloc_index
= -1;
218 struct minimal_symbol
*msymbol
;
220 /* Find the section pc is in; return if not in .plt */
221 sect
= find_pc_section (pc
);
222 if (!sect
|| strcmp (sect
->the_bfd_section
->name
, ".plt") != 0)
225 objfile
= sect
->objfile
;
227 /* Pick up the instruction at pc. It had better be of the
231 where IDX is an index into the plt_table. */
233 if (target_read_memory (pc
, buf
, 4) != 0)
235 insn
= extract_unsigned_integer (buf
, 4);
237 if ((insn
& 0xffff0000) != 0x39600000 /* li r11, VAL */ )
240 reloc_index
= (insn
<< 16) >> 16;
242 /* Find the objfile that pc is in and obtain the information
243 necessary for finding the symbol name. */
244 for (sect
= objfile
->sections
; sect
< objfile
->sections_end
; ++sect
)
246 const char *secname
= sect
->the_bfd_section
->name
;
247 if (strcmp (secname
, ".plt") == 0)
248 plt_start
= sect
->addr
;
249 else if (strcmp (secname
, ".rela.plt") == 0)
250 num_slots
= ((int) sect
->endaddr
- (int) sect
->addr
) / 12;
251 else if (strcmp (secname
, ".dynsym") == 0)
253 else if (strcmp (secname
, ".dynstr") == 0)
257 /* Make sure we have all the information we need. */
258 if (plt_start
== 0 || num_slots
== -1 || symtab
== 0 || strtab
== 0)
261 /* Compute the value of the plt table */
262 plt_table
= plt_start
+ 72 + 8 * num_slots
;
264 /* Get address of the relocation entry (Elf32_Rela) */
265 if (target_read_memory (plt_table
+ reloc_index
, buf
, 4) != 0)
267 reloc
= extract_address (buf
, 4);
269 sect
= find_pc_section (reloc
);
273 if (strcmp (sect
->the_bfd_section
->name
, ".text") == 0)
276 /* Now get the r_info field which is the relocation type and symbol
278 if (target_read_memory (reloc
+ 4, buf
, 4) != 0)
280 symidx
= extract_unsigned_integer (buf
, 4);
282 /* Shift out the relocation type leaving just the symbol index */
283 /* symidx = ELF32_R_SYM(symidx); */
284 symidx
= symidx
>> 8;
286 /* compute the address of the symbol */
287 sym
= symtab
+ symidx
* 4;
289 /* Fetch the string table index */
290 if (target_read_memory (sym
, buf
, 4) != 0)
292 symidx
= extract_unsigned_integer (buf
, 4);
294 /* Fetch the string; we don't know how long it is. Is it possible
295 that the following will fail because we're trying to fetch too
297 if (target_read_memory (strtab
+ symidx
, symname
, sizeof (symname
)) != 0)
300 /* This might not work right if we have multiple symbols with the
301 same name; the only way to really get it right is to perform
302 the same sort of lookup as the dynamic linker. */
303 msymbol
= lookup_minimal_symbol_text (symname
, NULL
, NULL
);
307 return SYMBOL_VALUE_ADDRESS (msymbol
);
310 /* The rs6000 version of FRAME_SAVED_PC will almost work for us. The
311 signal handler details are different, so we'll handle those here
312 and call the rs6000 version to do the rest. */
314 ppc_linux_frame_saved_pc (struct frame_info
*fi
)
316 if (fi
->signal_handler_caller
)
318 CORE_ADDR regs_addr
=
319 read_memory_integer (fi
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
320 /* return the NIP in the regs array */
321 return read_memory_integer (regs_addr
+ 4 * PPC_LINUX_PT_NIP
, 4);
323 else if (fi
->next
&& fi
->next
->signal_handler_caller
)
325 CORE_ADDR regs_addr
=
326 read_memory_integer (fi
->next
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
327 /* return LNK in the regs array */
328 return read_memory_integer (regs_addr
+ 4 * PPC_LINUX_PT_LNK
, 4);
331 return rs6000_frame_saved_pc (fi
);
335 ppc_linux_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
337 rs6000_init_extra_frame_info (fromleaf
, fi
);
341 /* We're called from get_prev_frame_info; check to see if
342 this is a signal frame by looking to see if the pc points
343 at trampoline code */
344 if (ppc_linux_at_sigtramp_return_path (fi
->pc
))
345 fi
->signal_handler_caller
= 1;
347 fi
->signal_handler_caller
= 0;
352 ppc_linux_frameless_function_invocation (struct frame_info
*fi
)
354 /* We'll find the wrong thing if we let
355 rs6000_frameless_function_invocation () search for a signal trampoline */
356 if (ppc_linux_at_sigtramp_return_path (fi
->pc
))
359 return rs6000_frameless_function_invocation (fi
);
363 ppc_linux_frame_init_saved_regs (struct frame_info
*fi
)
365 if (fi
->signal_handler_caller
)
372 frame_saved_regs_zalloc (fi
);
375 read_memory_integer (fi
->frame
+ PPC_LINUX_REGS_PTR_OFFSET
, 4);
376 fi
->saved_regs
[PC_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_NIP
;
377 fi
->saved_regs
[PPC_PS_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_MSR
;
378 fi
->saved_regs
[PPC_CR_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_CCR
;
379 fi
->saved_regs
[PPC_LR_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_LNK
;
380 fi
->saved_regs
[PPC_CTR_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_CTR
;
381 fi
->saved_regs
[PPC_XER_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_XER
;
382 fi
->saved_regs
[PPC_MQ_REGNUM
] = regs_addr
+ 4 * PPC_LINUX_PT_MQ
;
383 for (i
= 0; i
< 32; i
++)
384 fi
->saved_regs
[PPC_GP0_REGNUM
+ i
] = regs_addr
+ 4 * PPC_LINUX_PT_R0
+ 4 * i
;
385 for (i
= 0; i
< 32; i
++)
386 fi
->saved_regs
[FP0_REGNUM
+ i
] = regs_addr
+ 4 * PPC_LINUX_PT_FPR0
+ 8 * i
;
389 rs6000_frame_init_saved_regs (fi
);
393 ppc_linux_frame_chain (struct frame_info
*thisframe
)
395 /* Kernel properly constructs the frame chain for the handler */
396 if (thisframe
->signal_handler_caller
)
397 return read_memory_integer ((thisframe
)->frame
, 4);
399 return rs6000_frame_chain (thisframe
);
402 /* FIXME: Move the following to rs6000-tdep.c (or some other file where
403 it may be used generically by ports which use either the SysV ABI or
406 /* round2 rounds x up to the nearest multiple of s assuming that s is a
410 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
412 /* Pass the arguments in either registers, or in the stack. Using the
413 ppc sysv ABI, the first eight words of the argument list (that might
414 be less than eight parameters if some parameters occupy more than one
415 word) are passed in r3..r10 registers. float and double parameters are
416 passed in fpr's, in addition to that. Rest of the parameters if any
417 are passed in user stack.
419 If the function is returning a structure, then the return address is passed
420 in r3, then the first 7 words of the parametes can be passed in registers,
424 ppc_sysv_abi_push_arguments (int nargs
, value_ptr
*args
, CORE_ADDR sp
,
425 int struct_return
, CORE_ADDR struct_addr
)
439 greg
= struct_return
? 4 : 3;
444 /* Figure out how much new stack space is required for arguments
445 which don't fit in registers. Unlike the PowerOpen ABI, the
446 SysV ABI doesn't reserve any extra space for parameters which
447 are put in registers. */
448 for (argno
= 0; argno
< nargs
; argno
++)
451 type
= check_typedef (VALUE_TYPE (arg
));
452 len
= TYPE_LENGTH (type
);
454 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
460 /* SysV ABI converts floats to doubles when placed in
461 memory and requires 8 byte alignment */
462 if (argstkspace
& 0x4)
467 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
472 if (argstkspace
& 0x4)
486 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
487 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
489 /* Rounding to the nearest multiple of 8 may not be necessary,
490 but it is safe. Particularly since we don't know the
491 field types of the structure */
492 structstkspace
+= round2 (len
, 8);
501 /* Get current SP location */
502 saved_sp
= read_sp ();
504 sp
-= argstkspace
+ structstkspace
;
506 /* Allocate space for backchain and callee's saved lr */
509 /* Make sure that we maintain 16 byte alignment */
512 /* Update %sp before proceeding any further */
513 write_register (SP_REGNUM
, sp
);
515 /* write the backchain */
516 store_address (old_sp_buf
, 4, saved_sp
);
517 write_memory (sp
, old_sp_buf
, 4);
520 structoffset
= argoffset
+ argstkspace
;
523 /* Fill in r3 with the return structure, if any */
527 store_address (val_buf
, 4, struct_addr
);
528 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
531 /* Now fill in the registers and stack... */
532 for (argno
= 0; argno
< nargs
; argno
++)
535 type
= check_typedef (VALUE_TYPE (arg
));
536 len
= TYPE_LENGTH (type
);
538 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
544 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
545 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
+ freg
)],
546 VALUE_CONTENTS (arg
), len
);
551 /* SysV ABI converts floats to doubles when placed in
552 memory and requires 8 byte alignment */
553 /* FIXME: Convert floats to doubles */
556 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
560 else if (TYPE_CODE (type
) == TYPE_CODE_INT
&& len
== 8) /* long long */
567 write_memory (sp
+ argoffset
, (char *) VALUE_CONTENTS (arg
), len
);
575 memcpy (®isters
[REGISTER_BYTE (greg
)],
576 VALUE_CONTENTS (arg
), 4);
577 memcpy (®isters
[REGISTER_BYTE (greg
+ 1)],
578 VALUE_CONTENTS (arg
) + 4, 4);
586 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
587 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
589 write_memory (sp
+ structoffset
, VALUE_CONTENTS (arg
), len
);
590 store_address (val_buf
, 4, sp
+ structoffset
);
591 structoffset
+= round2 (len
, 8);
595 memset (val_buf
, 0, 4);
596 memcpy (val_buf
, VALUE_CONTENTS (arg
), len
);
600 *(int *) ®isters
[REGISTER_BYTE (greg
)] = 0;
601 memcpy (®isters
[REGISTER_BYTE (greg
)], val_buf
, 4);
606 write_memory (sp
+ argoffset
, val_buf
, 4);
612 target_store_registers (-1);
616 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
617 in much the same fashion as memory_remove_breakpoint in mem-break.c,
618 but is careful not to write back the previous contents if the code
619 in question has changed in between inserting the breakpoint and
622 Here is the problem that we're trying to solve...
624 Once upon a time, before introducing this function to remove
625 breakpoints from the inferior, setting a breakpoint on a shared
626 library function prior to running the program would not work
627 properly. In order to understand the problem, it is first
628 necessary to understand a little bit about dynamic linking on
631 A call to a shared library function is accomplished via a bl
632 (branch-and-link) instruction whose branch target is an entry
633 in the procedure linkage table (PLT). The PLT in the object
634 file is uninitialized. To gdb, prior to running the program, the
635 entries in the PLT are all zeros.
637 Once the program starts running, the shared libraries are loaded
638 and the procedure linkage table is initialized, but the entries in
639 the table are not (necessarily) resolved. Once a function is
640 actually called, the code in the PLT is hit and the function is
641 resolved. In order to better illustrate this, an example is in
642 order; the following example is from the gdb testsuite.
644 We start the program shmain.
646 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
649 We place two breakpoints, one on shr1 and the other on main.
652 Breakpoint 1 at 0x100409d4
654 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
656 Examine the instruction (and the immediatly following instruction)
657 upon which the breakpoint was placed. Note that the PLT entry
658 for shr1 contains zeros.
660 (gdb) x/2i 0x100409d4
661 0x100409d4 <shr1>: .long 0x0
662 0x100409d8 <shr1+4>: .long 0x0
667 Starting program: gdb.base/shmain
668 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
670 Breakpoint 2, main ()
671 at gdb.base/shmain.c:44
674 Examine the PLT again. Note that the loading of the shared
675 library has initialized the PLT to code which loads a constant
676 (which I think is an index into the GOT) into r11 and then
677 branchs a short distance to the code which actually does the
680 (gdb) x/2i 0x100409d4
681 0x100409d4 <shr1>: li r11,4
682 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
686 Breakpoint 1, shr1 (x=1)
687 at gdb.base/shr1.c:19
690 Now we've hit the breakpoint at shr1. (The breakpoint was
691 reset from the PLT entry to the actual shr1 function after the
692 shared library was loaded.) Note that the PLT entry has been
693 resolved to contain a branch that takes us directly to shr1.
694 (The real one, not the PLT entry.)
696 (gdb) x/2i 0x100409d4
697 0x100409d4 <shr1>: b 0xffaf76c <shr1>
698 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
700 The thing to note here is that the PLT entry for shr1 has been
703 Now the problem should be obvious. GDB places a breakpoint (a
704 trap instruction) on the zero value of the PLT entry for shr1.
705 Later on, after the shared library had been loaded and the PLT
706 initialized, GDB gets a signal indicating this fact and attempts
707 (as it always does when it stops) to remove all the breakpoints.
709 The breakpoint removal was causing the former contents (a zero
710 word) to be written back to the now initialized PLT entry thus
711 destroying a portion of the initialization that had occurred only a
712 short time ago. When execution continued, the zero word would be
713 executed as an instruction an an illegal instruction trap was
714 generated instead. (0 is not a legal instruction.)
716 The fix for this problem was fairly straightforward. The function
717 memory_remove_breakpoint from mem-break.c was copied to this file,
718 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
719 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
722 The differences between ppc_linux_memory_remove_breakpoint () and
723 memory_remove_breakpoint () are minor. All that the former does
724 that the latter does not is check to make sure that the breakpoint
725 location actually contains a breakpoint (trap instruction) prior
726 to attempting to write back the old contents. If it does contain
727 a trap instruction, we allow the old contents to be written back.
728 Otherwise, we silently do nothing.
730 The big question is whether memory_remove_breakpoint () should be
731 changed to have the same functionality. The downside is that more
732 traffic is generated for remote targets since we'll have an extra
733 fetch of a memory word each time a breakpoint is removed.
735 For the time being, we'll leave this self-modifying-code-friendly
736 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
737 else in the event that some other platform has similar needs with
738 regard to removing breakpoints in some potentially self modifying
741 ppc_linux_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
746 char old_contents
[BREAKPOINT_MAX
];
748 /* Determine appropriate breakpoint contents and size for this address. */
749 bp
= BREAKPOINT_FROM_PC (&addr
, &bplen
);
751 error ("Software breakpoints not implemented for this target.");
753 val
= target_read_memory (addr
, old_contents
, bplen
);
755 /* If our breakpoint is no longer at the address, this means that the
756 program modified the code on us, so it is wrong to put back the
758 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
759 val
= target_write_memory (addr
, contents_cache
, bplen
);