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, 2003 Free Software Foundation, Inc.
5
Copyright (c) 2004, 2005 Red Hat, Inc. All rights reserved.
7
This file is part of GDB.
9
This program is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 2 of the License, or
12
(at your option) any later version.
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
GNU General Public License for more details.
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 59 Temple Place - Suite 330,
22
Boston, MA 02111-1307, USA. */
37
#include "solib-svr4.h"
40
/* The following instructions are used in the signal trampoline code
41
on GNU/Linux PPC. The kernel used to use magic syscalls 0x6666 and
42
0x7777 but now uses the sigreturn syscalls. We check for both. */
43
#define INSTR_LI_R0_0x6666 0x38006666
44
#define INSTR_LI_R0_0x7777 0x38007777
45
#define INSTR_LI_R0_NR_sigreturn 0x38000077
46
#define INSTR_LI_R0_NR_rt_sigreturn 0x380000AC
48
#define INSTR_SC 0x44000002
50
/* Since the *-tdep.c files are platform independent (i.e, they may be
51
used to build cross platform debuggers), we can't include system
52
headers. Therefore, details concerning the sigcontext structure
53
must be painstakingly rerecorded. What's worse, if these details
54
ever change in the header files, they'll have to be changed here
57
/* __SIGNAL_FRAMESIZE from <asm/ptrace.h> */
58
#define PPC_LINUX_SIGNAL_FRAMESIZE 64
60
/* From <asm/sigcontext.h>, offsetof(struct sigcontext_struct, regs) == 0x1c */
61
#define PPC_LINUX_REGS_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x1c)
63
/* From <asm/sigcontext.h>,
64
offsetof(struct sigcontext_struct, handler) == 0x14 */
65
#define PPC_LINUX_HANDLER_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x14)
67
/* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
68
#define PPC_LINUX_PT_R0 0
69
#define PPC_LINUX_PT_R1 1
70
#define PPC_LINUX_PT_R2 2
71
#define PPC_LINUX_PT_R3 3
72
#define PPC_LINUX_PT_R4 4
73
#define PPC_LINUX_PT_R5 5
74
#define PPC_LINUX_PT_R6 6
75
#define PPC_LINUX_PT_R7 7
76
#define PPC_LINUX_PT_R8 8
77
#define PPC_LINUX_PT_R9 9
78
#define PPC_LINUX_PT_R10 10
79
#define PPC_LINUX_PT_R11 11
80
#define PPC_LINUX_PT_R12 12
81
#define PPC_LINUX_PT_R13 13
82
#define PPC_LINUX_PT_R14 14
83
#define PPC_LINUX_PT_R15 15
84
#define PPC_LINUX_PT_R16 16
85
#define PPC_LINUX_PT_R17 17
86
#define PPC_LINUX_PT_R18 18
87
#define PPC_LINUX_PT_R19 19
88
#define PPC_LINUX_PT_R20 20
89
#define PPC_LINUX_PT_R21 21
90
#define PPC_LINUX_PT_R22 22
91
#define PPC_LINUX_PT_R23 23
92
#define PPC_LINUX_PT_R24 24
93
#define PPC_LINUX_PT_R25 25
94
#define PPC_LINUX_PT_R26 26
95
#define PPC_LINUX_PT_R27 27
96
#define PPC_LINUX_PT_R28 28
97
#define PPC_LINUX_PT_R29 29
98
#define PPC_LINUX_PT_R30 30
99
#define PPC_LINUX_PT_R31 31
100
#define PPC_LINUX_PT_NIP 32
101
#define PPC_LINUX_PT_MSR 33
102
#define PPC_LINUX_PT_CTR 35
103
#define PPC_LINUX_PT_LNK 36
104
#define PPC_LINUX_PT_XER 37
105
#define PPC_LINUX_PT_CCR 38
106
#define PPC_LINUX_PT_MQ 39
107
#define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */
108
#define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
109
#define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
111
static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc);
113
/* Determine if pc is in a signal trampoline...
115
Ha! That's not what this does at all. wait_for_inferior in
116
infrun.c calls PC_IN_SIGTRAMP in order to detect entry into a
117
signal trampoline just after delivery of a signal. But on
118
GNU/Linux, signal trampolines are used for the return path only.
119
The kernel sets things up so that the signal handler is called
122
If we use in_sigtramp2() in place of in_sigtramp() (see below)
123
we'll (often) end up with stop_pc in the trampoline and prev_pc in
124
the (now exited) handler. The code there will cause a temporary
125
breakpoint to be set on prev_pc which is not very likely to get hit
128
If this is confusing, think of it this way... the code in
129
wait_for_inferior() needs to be able to detect entry into a signal
130
trampoline just after a signal is delivered, not after the handler
133
So, we define in_sigtramp() below to return 1 if the following is
136
1) The previous frame is a real signal trampoline.
140
2) pc is at the first or second instruction of the corresponding
143
Why the second instruction? It seems that wait_for_inferior()
144
never sees the first instruction when single stepping. When a
145
signal is delivered while stepping, the next instruction that
146
would've been stepped over isn't, instead a signal is delivered and
147
the first instruction of the handler is stepped over instead. That
148
puts us on the second instruction. (I added the test for the
149
first instruction long after the fact, just in case the observed
150
behavior is ever fixed.)
152
PC_IN_SIGTRAMP is called from blockframe.c as well in order to set
153
the frame's type (if a SIGTRAMP_FRAME). Because of our strange
154
definition of in_sigtramp below, we can't rely on the frame's type
155
getting set correctly from within blockframe.c. This is why we
156
take pains to set it in init_extra_frame_info().
158
NOTE: cagney/2002-11-10: I suspect the real problem here is that
159
the get_prev_frame() only initializes the frame's type after the
160
call to INIT_FRAME_INFO. get_prev_frame() should be fixed, this
161
code shouldn't be working its way around a bug :-(. */
164
ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
172
lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
173
if (!ppc_linux_at_sigtramp_return_path (lr))
176
sp = read_register (SP_REGNUM);
178
if (target_read_memory (sp, buf, sizeof (buf)) != 0)
181
tramp_sp = extract_unsigned_integer (buf, 4);
183
if (target_read_memory (tramp_sp + PPC_LINUX_HANDLER_PTR_OFFSET, buf,
187
handler = extract_unsigned_integer (buf, 4);
189
return (pc == handler || pc == handler + 4);
193
insn_is_sigreturn (unsigned long pcinsn)
197
case INSTR_LI_R0_0x6666:
198
case INSTR_LI_R0_0x7777:
199
case INSTR_LI_R0_NR_sigreturn:
200
case INSTR_LI_R0_NR_rt_sigreturn:
208
* The signal handler trampoline is on the stack and consists of exactly
209
* two instructions. The easiest and most accurate way of determining
210
* whether the pc is in one of these trampolines is by inspecting the
211
* instructions. It'd be faster though if we could find a way to do this
212
* via some simple address comparisons.
215
ppc_linux_at_sigtramp_return_path (CORE_ADDR pc)
218
unsigned long pcinsn;
219
if (target_read_memory (pc - 4, buf, sizeof (buf)) != 0)
222
/* extract the instruction at the pc */
223
pcinsn = extract_unsigned_integer (buf + 4, 4);
226
(insn_is_sigreturn (pcinsn)
227
&& extract_unsigned_integer (buf + 8, 4) == INSTR_SC)
230
&& insn_is_sigreturn (extract_unsigned_integer (buf, 4))));
234
ppc_linux_skip_trampoline_code (CORE_ADDR pc)
237
struct obj_section *sect;
238
struct objfile *objfile;
240
CORE_ADDR plt_start = 0;
241
CORE_ADDR symtab = 0;
242
CORE_ADDR strtab = 0;
244
int reloc_index = -1;
250
struct minimal_symbol *msymbol;
252
/* Find the section pc is in; return if not in .plt */
253
sect = find_pc_section (pc);
254
if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0)
257
objfile = sect->objfile;
259
/* Pick up the instruction at pc. It had better be of the
263
where IDX is an index into the plt_table. */
265
if (target_read_memory (pc, buf, 4) != 0)
267
insn = extract_unsigned_integer (buf, 4);
269
if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ )
272
reloc_index = (insn << 16) >> 16;
274
/* Find the objfile that pc is in and obtain the information
275
necessary for finding the symbol name. */
276
for (sect = objfile->sections; sect < objfile->sections_end; ++sect)
278
const char *secname = sect->the_bfd_section->name;
279
if (strcmp (secname, ".plt") == 0)
280
plt_start = sect->addr;
281
else if (strcmp (secname, ".rela.plt") == 0)
282
num_slots = ((int) sect->endaddr - (int) sect->addr) / 12;
283
else if (strcmp (secname, ".dynsym") == 0)
285
else if (strcmp (secname, ".dynstr") == 0)
289
/* Make sure we have all the information we need. */
290
if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0)
293
/* Compute the value of the plt table */
294
plt_table = plt_start + 72 + 8 * num_slots;
296
/* Get address of the relocation entry (Elf32_Rela) */
297
if (target_read_memory (plt_table + reloc_index, buf, 4) != 0)
299
reloc = extract_unsigned_integer (buf, 4);
301
sect = find_pc_section (reloc);
305
if (strcmp (sect->the_bfd_section->name, ".text") == 0)
308
/* Now get the r_info field which is the relocation type and symbol
310
if (target_read_memory (reloc + 4, buf, 4) != 0)
312
symidx = extract_unsigned_integer (buf, 4);
314
/* Shift out the relocation type leaving just the symbol index */
315
/* symidx = ELF32_R_SYM(symidx); */
316
symidx = symidx >> 8;
318
/* compute the address of the symbol */
319
sym = symtab + symidx * 4;
321
/* Fetch the string table index */
322
if (target_read_memory (sym, buf, 4) != 0)
324
symidx = extract_unsigned_integer (buf, 4);
326
/* Fetch the string; we don't know how long it is. Is it possible
327
that the following will fail because we're trying to fetch too
329
if (target_read_memory (strtab + symidx, symname, sizeof (symname)) != 0)
332
/* This might not work right if we have multiple symbols with the
333
same name; the only way to really get it right is to perform
334
the same sort of lookup as the dynamic linker. */
335
msymbol = lookup_minimal_symbol_text (symname, NULL);
339
return SYMBOL_VALUE_ADDRESS (msymbol);
342
/* The rs6000 version of FRAME_SAVED_PC will almost work for us. The
343
signal handler details are different, so we'll handle those here
344
and call the rs6000 version to do the rest. */
346
ppc_linux_frame_saved_pc (struct frame_info *fi)
348
if ((get_frame_type (fi) == SIGTRAMP_FRAME))
350
CORE_ADDR regs_addr =
351
read_memory_integer (get_frame_base (fi)
352
+ PPC_LINUX_REGS_PTR_OFFSET, 4);
353
/* return the NIP in the regs array */
354
return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_NIP, 4);
356
else if (get_next_frame (fi)
357
&& (get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME))
359
CORE_ADDR regs_addr =
360
read_memory_integer (get_frame_base (get_next_frame (fi))
361
+ PPC_LINUX_REGS_PTR_OFFSET, 4);
362
/* return LNK in the regs array */
363
return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_LNK, 4);
366
return rs6000_frame_saved_pc (fi);
370
ppc_linux_init_extra_frame_info (int fromleaf, struct frame_info *fi)
372
rs6000_init_extra_frame_info (fromleaf, fi);
374
if (get_next_frame (fi) != 0)
376
/* We're called from get_prev_frame_info; check to see if
377
this is a signal frame by looking to see if the pc points
378
at trampoline code */
379
if (ppc_linux_at_sigtramp_return_path (get_frame_pc (fi)))
380
deprecated_set_frame_type (fi, SIGTRAMP_FRAME);
382
/* FIXME: cagney/2002-11-10: Is this double bogus? What
383
happens if the frame has previously been marked as a dummy? */
384
deprecated_set_frame_type (fi, NORMAL_FRAME);
389
ppc_linux_frameless_function_invocation (struct frame_info *fi)
391
/* We'll find the wrong thing if we let
392
rs6000_frameless_function_invocation () search for a signal trampoline */
393
if (ppc_linux_at_sigtramp_return_path (get_frame_pc (fi)))
396
return rs6000_frameless_function_invocation (fi);
400
ppc_linux_frame_init_saved_regs (struct frame_info *fi)
402
if ((get_frame_type (fi) == SIGTRAMP_FRAME))
406
if (deprecated_get_frame_saved_regs (fi))
409
frame_saved_regs_zalloc (fi);
412
read_memory_integer (get_frame_base (fi)
413
+ PPC_LINUX_REGS_PTR_OFFSET, 4);
414
deprecated_get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
415
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
416
regs_addr + 4 * PPC_LINUX_PT_MSR;
417
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
418
regs_addr + 4 * PPC_LINUX_PT_CCR;
419
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
420
regs_addr + 4 * PPC_LINUX_PT_LNK;
421
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
422
regs_addr + 4 * PPC_LINUX_PT_CTR;
423
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
424
regs_addr + 4 * PPC_LINUX_PT_XER;
425
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
426
regs_addr + 4 * PPC_LINUX_PT_MQ;
427
for (i = 0; i < 32; i++)
428
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
429
regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i;
430
for (i = 0; i < 32; i++)
431
deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
434
rs6000_frame_init_saved_regs (fi);
438
ppc_linux_frame_chain (struct frame_info *thisframe)
440
/* Kernel properly constructs the frame chain for the handler */
441
if ((get_frame_type (thisframe) == SIGTRAMP_FRAME))
442
return read_memory_integer (get_frame_base (thisframe), 4);
444
return rs6000_frame_chain (thisframe);
447
/* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
448
in much the same fashion as memory_remove_breakpoint in mem-break.c,
449
but is careful not to write back the previous contents if the code
450
in question has changed in between inserting the breakpoint and
453
Here is the problem that we're trying to solve...
455
Once upon a time, before introducing this function to remove
456
breakpoints from the inferior, setting a breakpoint on a shared
457
library function prior to running the program would not work
458
properly. In order to understand the problem, it is first
459
necessary to understand a little bit about dynamic linking on
462
A call to a shared library function is accomplished via a bl
463
(branch-and-link) instruction whose branch target is an entry
464
in the procedure linkage table (PLT). The PLT in the object
465
file is uninitialized. To gdb, prior to running the program, the
466
entries in the PLT are all zeros.
468
Once the program starts running, the shared libraries are loaded
469
and the procedure linkage table is initialized, but the entries in
470
the table are not (necessarily) resolved. Once a function is
471
actually called, the code in the PLT is hit and the function is
472
resolved. In order to better illustrate this, an example is in
473
order; the following example is from the gdb testsuite.
475
We start the program shmain.
477
[kev@arroyo testsuite]$ ../gdb gdb.base/shmain
480
We place two breakpoints, one on shr1 and the other on main.
483
Breakpoint 1 at 0x100409d4
485
Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
487
Examine the instruction (and the immediatly following instruction)
488
upon which the breakpoint was placed. Note that the PLT entry
489
for shr1 contains zeros.
491
(gdb) x/2i 0x100409d4
492
0x100409d4 <shr1>: .long 0x0
493
0x100409d8 <shr1+4>: .long 0x0
498
Starting program: gdb.base/shmain
499
Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
501
Breakpoint 2, main ()
502
at gdb.base/shmain.c:44
505
Examine the PLT again. Note that the loading of the shared
506
library has initialized the PLT to code which loads a constant
507
(which I think is an index into the GOT) into r11 and then
508
branchs a short distance to the code which actually does the
511
(gdb) x/2i 0x100409d4
512
0x100409d4 <shr1>: li r11,4
513
0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
517
Breakpoint 1, shr1 (x=1)
518
at gdb.base/shr1.c:19
521
Now we've hit the breakpoint at shr1. (The breakpoint was
522
reset from the PLT entry to the actual shr1 function after the
523
shared library was loaded.) Note that the PLT entry has been
524
resolved to contain a branch that takes us directly to shr1.
525
(The real one, not the PLT entry.)
527
(gdb) x/2i 0x100409d4
528
0x100409d4 <shr1>: b 0xffaf76c <shr1>
529
0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
531
The thing to note here is that the PLT entry for shr1 has been
534
Now the problem should be obvious. GDB places a breakpoint (a
535
trap instruction) on the zero value of the PLT entry for shr1.
536
Later on, after the shared library had been loaded and the PLT
537
initialized, GDB gets a signal indicating this fact and attempts
538
(as it always does when it stops) to remove all the breakpoints.
540
The breakpoint removal was causing the former contents (a zero
541
word) to be written back to the now initialized PLT entry thus
542
destroying a portion of the initialization that had occurred only a
543
short time ago. When execution continued, the zero word would be
544
executed as an instruction an an illegal instruction trap was
545
generated instead. (0 is not a legal instruction.)
547
The fix for this problem was fairly straightforward. The function
548
memory_remove_breakpoint from mem-break.c was copied to this file,
549
modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
550
In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
553
The differences between ppc_linux_memory_remove_breakpoint () and
554
memory_remove_breakpoint () are minor. All that the former does
555
that the latter does not is check to make sure that the breakpoint
556
location actually contains a breakpoint (trap instruction) prior
557
to attempting to write back the old contents. If it does contain
558
a trap instruction, we allow the old contents to be written back.
559
Otherwise, we silently do nothing.
561
The big question is whether memory_remove_breakpoint () should be
562
changed to have the same functionality. The downside is that more
563
traffic is generated for remote targets since we'll have an extra
564
fetch of a memory word each time a breakpoint is removed.
566
For the time being, we'll leave this self-modifying-code-friendly
567
version in ppc-linux-tdep.c, but it ought to be migrated somewhere
568
else in the event that some other platform has similar needs with
569
regard to removing breakpoints in some potentially self modifying
572
ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
574
const unsigned char *bp;
577
char old_contents[BREAKPOINT_MAX];
579
/* Determine appropriate breakpoint contents and size for this address. */
580
bp = BREAKPOINT_FROM_PC (&addr, &bplen);
582
error ("Software breakpoints not implemented for this target.");
584
val = target_read_memory (addr, old_contents, bplen);
586
/* If our breakpoint is no longer at the address, this means that the
587
program modified the code on us, so it is wrong to put back the
589
if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
590
val = target_write_memory (addr, contents_cache, bplen);
595
/* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
596
than the 32 bit SYSV R4 ABI structure return convention - all
597
structures, no matter their size, are put in memory. Vectors,
598
which were added later, do get returned in a register though. */
600
static enum return_value_convention
601
ppc_linux_return_value (struct gdbarch *gdbarch, struct type *valtype,
602
struct regcache *regcache, void *readbuf,
603
const void *writebuf)
605
if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
606
|| TYPE_CODE (valtype) == TYPE_CODE_UNION)
607
&& !((TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 8)
608
&& TYPE_VECTOR (valtype)))
609
return RETURN_VALUE_STRUCT_CONVENTION;
611
return ppc_sysv_abi_return_value (gdbarch, valtype, regcache, readbuf,
615
/* Fetch (and possibly build) an appropriate link_map_offsets
616
structure for GNU/Linux PPC targets using the struct offsets
617
defined in link.h (but without actual reference to that file).
619
This makes it possible to access GNU/Linux PPC shared libraries
620
from a GDB that was not built on an GNU/Linux PPC host (for cross
623
struct link_map_offsets *
624
ppc_linux_svr4_fetch_link_map_offsets (void)
626
static struct link_map_offsets lmo;
627
static struct link_map_offsets *lmp = NULL;
633
lmo.r_debug_size = 8; /* The actual size is 20 bytes, but
634
this is all we need. */
635
lmo.r_map_offset = 4;
638
lmo.link_map_size = 20; /* The actual size is 560 bytes, but
639
this is all we need. */
640
lmo.l_addr_offset = 0;
643
lmo.l_name_offset = 4;
646
lmo.l_next_offset = 12;
649
lmo.l_prev_offset = 16;
657
/* Macros for matching instructions. Note that, since all the
658
operands are masked off before they're or-ed into the instruction,
659
you can use -1 to make masks. */
661
#define insn_d(opcd, rts, ra, d) \
662
((((opcd) & 0x3f) << 26) \
663
| (((rts) & 0x1f) << 21) \
664
| (((ra) & 0x1f) << 16) \
667
#define insn_ds(opcd, rts, ra, d, xo) \
668
((((opcd) & 0x3f) << 26) \
669
| (((rts) & 0x1f) << 21) \
670
| (((ra) & 0x1f) << 16) \
674
#define insn_xfx(opcd, rts, spr, xo) \
675
((((opcd) & 0x3f) << 26) \
676
| (((rts) & 0x1f) << 21) \
677
| (((spr) & 0x1f) << 16) \
678
| (((spr) & 0x3e0) << 6) \
679
| (((xo) & 0x3ff) << 1))
681
/* Read a PPC instruction from memory. PPC instructions are always
682
big-endian, no matter what endianness the program is running in, so
683
we can't use read_memory_integer or one of its friends here. */
685
read_insn (CORE_ADDR pc)
687
unsigned char buf[4];
689
read_memory (pc, buf, 4);
690
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
694
/* An instruction to match. */
697
unsigned int mask; /* mask the insn with this... */
698
unsigned int data; /* ...and see if it matches this. */
699
int optional; /* If non-zero, this insn may be absent. */
702
/* Return non-zero if the instructions at PC match the series
703
described in PATTERN, or zero otherwise. PATTERN is an array of
704
'struct insn_pattern' objects, terminated by an entry whose mask is
707
When the match is successful, fill INSN[i] with what PATTERN[i]
708
matched. If PATTERN[i] is optional, and the instruction wasn't
709
present, set INSN[i] to 0 (which is not a valid PPC instruction).
710
INSN should have as many elements as PATTERN. Note that, if
711
PATTERN contains optional instructions which aren't present in
712
memory, then INSN will have holes, so INSN[i] isn't necessarily the
713
i'th instruction in memory. */
715
insns_match_pattern (CORE_ADDR pc,
716
struct insn_pattern *pattern,
721
for (i = 0; pattern[i].mask; i++)
723
insn[i] = read_insn (pc);
724
if ((insn[i] & pattern[i].mask) == pattern[i].data)
726
else if (pattern[i].optional)
736
/* Return the 'd' field of the d-form instruction INSN, properly
739
insn_d_field (unsigned int insn)
741
return ((((CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000);
745
/* Return the 'ds' field of the ds-form instruction INSN, with the two
746
zero bits concatenated at the right, and properly
749
insn_ds_field (unsigned int insn)
751
return ((((CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000);
755
/* If DESC is the address of a 64-bit PowerPC GNU/Linux function
756
descriptor, return the descriptor's entry point. */
758
ppc64_desc_entry_point (CORE_ADDR desc)
760
/* The first word of the descriptor is the entry point. */
761
return (CORE_ADDR) read_memory_unsigned_integer (desc, 8);
765
/* Pattern for the standard linkage function. These are built by
766
build_plt_stub in elf64-ppc.c, whose GLINK argument is always
768
static struct insn_pattern ppc64_standard_linkage[] =
770
/* addis r12, r2, <any> */
771
{ insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
774
{ -1, insn_ds (62, 2, 1, 40, 0), 0 },
776
/* ld r11, <any>(r12) */
777
{ insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
779
/* addis r12, r12, 1 <optional> */
780
{ insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
782
/* ld r2, <any>(r12) */
783
{ insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
785
/* addis r12, r12, 1 <optional> */
786
{ insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
789
{ insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467),
792
/* ld r11, <any>(r12) */
793
{ insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
796
{ -1, 0x4e800420, 0 },
800
#define PPC64_STANDARD_LINKAGE_LEN \
801
(sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0]))
804
/* Recognize a 64-bit PowerPC GNU/Linux linkage function --- what GDB
805
calls a "solib trampoline". */
807
ppc64_in_solib_call_trampoline (CORE_ADDR pc, char *name)
809
/* Detecting solib call trampolines on PPC64 GNU/Linux is a pain.
811
It's not specifically solib call trampolines that are the issue.
812
Any call from one function to another function that uses a
813
different TOC requires a trampoline, to save the caller's TOC
814
pointer and then load the callee's TOC. An executable or shared
815
library may have more than one TOC, so even intra-object calls
816
may require a trampoline. Since executable and shared libraries
817
will all have their own distinct TOCs, every inter-object call is
818
also an inter-TOC call, and requires a trampoline --- so "solib
819
call trampolines" are just a special case.
821
The 64-bit PowerPC GNU/Linux ABI calls these call trampolines
822
"linkage functions". Since they need to be near the functions
823
that call them, they all appear in .text, not in any special
824
section. The .plt section just contains an array of function
825
descriptors, from which the linkage functions load the callee's
826
entry point, TOC value, and environment pointer. So
827
in_plt_section is useless. The linkage functions don't have any
828
special linker symbols to name them, either.
830
The only way I can see to recognize them is to actually look at
831
their code. They're generated by ppc_build_one_stub and some
832
other functions in bfd/elf64-ppc.c, so that should show us all
833
the instruction sequences we need to recognize. */
834
unsigned int insn[PPC64_STANDARD_LINKAGE_LEN];
836
return insns_match_pattern (pc, ppc64_standard_linkage, insn);
840
/* When the dynamic linker is doing lazy symbol resolution, the first
841
call to a function in another object will go like this:
843
- The user's function calls the linkage function:
845
100007c4: 4b ff fc d5 bl 10000498
846
100007c8: e8 41 00 28 ld r2,40(r1)
848
- The linkage function loads the entry point (and other stuff) from
849
the function descriptor in the PLT, and jumps to it:
851
10000498: 3d 82 00 00 addis r12,r2,0
852
1000049c: f8 41 00 28 std r2,40(r1)
853
100004a0: e9 6c 80 98 ld r11,-32616(r12)
854
100004a4: e8 4c 80 a0 ld r2,-32608(r12)
855
100004a8: 7d 69 03 a6 mtctr r11
856
100004ac: e9 6c 80 a8 ld r11,-32600(r12)
857
100004b0: 4e 80 04 20 bctr
859
- But since this is the first time that PLT entry has been used, it
860
sends control to its glink entry. That loads the number of the
861
PLT entry and jumps to the common glink0 code:
863
10000c98: 38 00 00 00 li r0,0
864
10000c9c: 4b ff ff dc b 10000c78
866
- The common glink0 code then transfers control to the dynamic
869
10000c78: e8 41 00 28 ld r2,40(r1)
870
10000c7c: 3d 82 00 00 addis r12,r2,0
871
10000c80: e9 6c 80 80 ld r11,-32640(r12)
872
10000c84: e8 4c 80 88 ld r2,-32632(r12)
873
10000c88: 7d 69 03 a6 mtctr r11
874
10000c8c: e9 6c 80 90 ld r11,-32624(r12)
875
10000c90: 4e 80 04 20 bctr
877
Eventually, this code will figure out how to skip all of this,
878
including the dynamic linker. At the moment, we just get through
879
the linkage function. */
881
/* If the current thread is about to execute a series of instructions
882
at PC matching the ppc64_standard_linkage pattern, and INSN is the result
883
from that pattern match, return the code address to which the
884
standard linkage function will send them. (This doesn't deal with
885
dynamic linker lazy symbol resolution stubs.) */
887
ppc64_standard_linkage_target (CORE_ADDR pc, unsigned int *insn)
889
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
891
/* The address of the function descriptor this linkage function
894
= ((CORE_ADDR) read_register (tdep->ppc_gp0_regnum + 2)
895
+ (insn_d_field (insn[0]) << 16)
896
+ insn_ds_field (insn[2]));
898
/* The first word of the descriptor is the entry point. Return that. */
899
return ppc64_desc_entry_point (desc);
903
/* Given that we've begun executing a call trampoline at PC, return
904
the entry point of the function the trampoline will go to. */
906
ppc64_skip_trampoline_code (CORE_ADDR pc)
908
unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN];
910
if (insns_match_pattern (pc, ppc64_standard_linkage,
911
ppc64_standard_linkage_insn))
912
return ppc64_standard_linkage_target (pc, ppc64_standard_linkage_insn);
918
/* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG) on PPC64
921
Usually a function pointer's representation is simply the address
922
of the function. On GNU/Linux on the 64-bit PowerPC however, a
923
function pointer is represented by a pointer to a TOC entry. This
924
TOC entry contains three words, the first word is the address of
925
the function, the second word is the TOC pointer (r2), and the
926
third word is the static chain value. Throughout GDB it is
927
currently assumed that a function pointer contains the address of
928
the function, which is not easy to fix. In addition, the
929
conversion of a function address to a function pointer would
930
require allocation of a TOC entry in the inferior's memory space,
931
with all its drawbacks. To be able to call C++ virtual methods in
932
the inferior (which are called via function pointers),
933
find_function_addr uses this function to get the function address
934
from a function pointer. */
936
/* If ADDR points at what is clearly a function descriptor, transform
937
it into the address of the corresponding function. Be
938
conservative, otherwize GDB will do the transformation on any
939
random addresses such as occures when there is no symbol table. */
942
ppc64_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
944
struct target_ops *targ)
946
struct section_table *s = target_section_by_addr (targ, addr);
948
/* Check if ADDR points to a function descriptor. */
949
if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
950
return get_target_memory_unsigned (targ, addr, 8);
963
ELF_GREGSET_SIZE = (PPC_ELF_NGREG * 4),
964
ELF_FPREGSET_SIZE = (PPC_ELF_NFPREG * 8)
974
ELF_GREGSET_SIZE = (ELF_NGREG * 4),
975
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
980
ppc_linux_supply_gregset (char *buf)
983
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
985
for (regi = 0; regi < 32; regi++)
986
supply_register (regi, buf + 4 * regi);
988
supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
989
supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
990
supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
991
supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
992
supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
993
if (tdep->ppc_mq_regnum != -1)
994
supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
995
supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
999
ppc_linux_supply_fpregset (char *buf)
1002
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1004
for (regi = 0; regi < 32; regi++)
1005
supply_register (FP0_REGNUM + regi, buf + 8 * regi);
1007
/* The FPSCR is stored in the low order word of the last doubleword in the
1009
supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
1013
Use a local version of this function to get the correct types for regsets.
1017
fetch_core_registers (char *core_reg_sect,
1018
unsigned core_reg_size,
1024
if (core_reg_size == ELF_GREGSET_SIZE)
1025
ppc_linux_supply_gregset (core_reg_sect);
1027
warning ("wrong size gregset struct in core file");
1029
else if (which == 2)
1031
if (core_reg_size == ELF_FPREGSET_SIZE)
1032
ppc_linux_supply_fpregset (core_reg_sect);
1034
warning ("wrong size fpregset struct in core file");
1038
/* Register that we are able to handle ELF file formats using standard
1039
procfs "regset" structures. */
1041
static struct core_fns ppc_linux_regset_core_fns =
1043
bfd_target_elf_flavour, /* core_flavour */
1044
default_check_format, /* check_format */
1045
default_core_sniffer, /* core_sniffer */
1046
fetch_core_registers, /* core_read_registers */
1051
ppc_linux_init_abi (struct gdbarch_info info,
1052
struct gdbarch *gdbarch)
1054
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1056
if (tdep->wordsize == 4)
1058
/* Until November 2001, gcc did not comply with the 32 bit SysV
1059
R4 ABI requirement that structures less than or equal to 8
1060
bytes should be returned in registers. Instead GCC was using
1061
the the AIX/PowerOpen ABI - everything returned in memory
1062
(well ignoring vectors that is). When this was corrected, it
1063
wasn't fixed for GNU/Linux native platform. Use the
1064
PowerOpen struct convention. */
1065
set_gdbarch_return_value (gdbarch, ppc_linux_return_value);
1067
/* Note: kevinb/2002-04-12: See note in rs6000_gdbarch_init regarding
1068
*_push_arguments(). The same remarks hold for the methods below. */
1069
set_gdbarch_deprecated_frameless_function_invocation (gdbarch, ppc_linux_frameless_function_invocation);
1070
set_gdbarch_deprecated_frame_chain (gdbarch, ppc_linux_frame_chain);
1071
set_gdbarch_deprecated_frame_saved_pc (gdbarch, ppc_linux_frame_saved_pc);
1073
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
1074
ppc_linux_frame_init_saved_regs);
1075
set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
1076
ppc_linux_init_extra_frame_info);
1078
set_gdbarch_memory_remove_breakpoint (gdbarch,
1079
ppc_linux_memory_remove_breakpoint);
1080
/* Shared library handling. */
1081
set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
1082
set_gdbarch_skip_trampoline_code (gdbarch,
1083
ppc_linux_skip_trampoline_code);
1084
set_solib_svr4_fetch_link_map_offsets
1085
(gdbarch, ppc_linux_svr4_fetch_link_map_offsets);
1088
if (tdep->wordsize == 8)
1090
/* Handle PPC64 GNU/Linux function pointers (which are really
1091
function descriptors). */
1092
set_gdbarch_convert_from_func_ptr_addr
1093
(gdbarch, ppc64_linux_convert_from_func_ptr_addr);
1095
set_gdbarch_in_solib_call_trampoline
1096
(gdbarch, ppc64_in_solib_call_trampoline);
1097
set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code);
1099
/* PPC64 malloc's entry-point is called ".malloc". */
1100
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
1105
_initialize_ppc_linux_tdep (void)
1107
/* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1108
64-bit PowerPC, and the older rs6k. */
1109
gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc, GDB_OSABI_LINUX,
1110
ppc_linux_init_abi);
1111
gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc64, GDB_OSABI_LINUX,
1112
ppc_linux_init_abi);
1113
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
1114
ppc_linux_init_abi);
1115
add_core_fns (&ppc_linux_regset_core_fns);
added
removed
debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb/ppc-linux-tdep.c
