GDB (xrefs)
Loading...
Searching...
No Matches
hppa-linux-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
2
3 Copyright (C) 2004-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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 3 of the License, or
10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "gdbcore.h"
22#include "osabi.h"
23#include "target.h"
24#include "objfiles.h"
25#include "solib-svr4.h"
26#include "glibc-tdep.h"
27#include "frame-unwind.h"
28#include "trad-frame.h"
29#include "dwarf2/frame.h"
30#include "value.h"
31#include "regset.h"
32#include "regcache.h"
33#include "hppa-tdep.h"
34#include "linux-tdep.h"
35#include "elf/common.h"
36
37/* Map DWARF DBX register numbers to GDB register numbers. */
38static int
40{
41 /* The general registers and the sar are the same in both sets. */
42 if (reg >= 0 && reg <= 32)
43 return reg;
44
45 /* fr4-fr31 (left and right halves) are mapped from 72. */
46 if (reg >= 72 && reg <= 72 + 28 * 2)
47 return HPPA_FP4_REGNUM + (reg - 72);
48
49 return -1;
50}
51
52static void
54{
55 /* Probably this should be done by the kernel, but it isn't. */
58 HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
59}
60
61/* An instruction to match. */
63{
64 unsigned int data; /* See if it matches this.... */
65 unsigned int mask; /* ... with this mask. */
66};
67
68static struct insn_pattern hppa_sigtramp[] = {
69 /* ldi 0, %r25 or ldi 1, %r25 */
70 { 0x34190000, 0xfffffffd },
71 /* ldi __NR_rt_sigreturn, %r20 */
72 { 0x3414015a, 0xffffffff },
73 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
74 { 0xe4008200, 0xffffffff },
75 /* nop */
76 { 0x08000240, 0xffffffff },
77 { 0, 0 }
78};
79
80#define HPPA_MAX_INSN_PATTERN_LEN (4)
81
82/* Return non-zero if the instructions at PC match the series
83 described in PATTERN, or zero otherwise. PATTERN is an array of
84 'struct insn_pattern' objects, terminated by an entry whose mask is
85 zero.
86
87 When the match is successful, fill INSN[i] with what PATTERN[i]
88 matched. */
89static int
90insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc,
91 struct insn_pattern *pattern,
92 unsigned int *insn)
93{
94 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
95 int i;
96 CORE_ADDR npc = pc;
97
98 for (i = 0; pattern[i].mask; i++)
99 {
100 gdb_byte buf[4];
101
102 target_read_memory (npc, buf, 4);
103 insn[i] = extract_unsigned_integer (buf, 4, byte_order);
104 if ((insn[i] & pattern[i].mask) == pattern[i].data)
105 npc += 4;
106 else
107 return 0;
108 }
109 return 1;
110}
111
112/* Signal frames. */
113
114/* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
115
116 Unfortunately, because of various bugs and changes to the kernel,
117 we have several cases to deal with.
118
119 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
120 the beginning of the trampoline and struct rt_sigframe.
121
122 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
123 the 4th word in the trampoline structure. This is wrong, it should point
124 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
125
126 To detect these cases, we first take pc, align it to 64-bytes
127 to get the beginning of the signal frame, and then check offsets 0, 4
128 and 5 to see if we found the beginning of the trampoline. This will
129 tell us how to locate the sigcontext structure.
130
131 Note that with a 2.4 64-bit kernel, the signal context is not properly
132 passed back to userspace so the unwind will not work correctly. */
133static CORE_ADDR
135{
136 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
137 int offs = 0;
138 int attempt;
139 /* offsets to try to find the trampoline */
140 static int pcoffs[] = { 0, 4*4, 5*4 };
141 /* offsets to the rt_sigframe structure */
142 static int sfoffs[] = { 4*4, 10*4, 10*4 };
143 CORE_ADDR sp;
144
145 /* Most of the time, this will be correct. The one case when this will
146 fail is if the user defined an alternate stack, in which case the
147 beginning of the stack will not be align_down (pc, 64). */
148 sp = align_down (pc, 64);
149
150 /* rt_sigreturn trampoline:
151 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
152 3414015a ldi __NR_rt_sigreturn, %r20
153 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
154 08000240 nop */
155
156 for (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
157 {
158 if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
160 {
161 offs = sfoffs[attempt];
162 break;
163 }
164 }
165
166 if (offs == 0)
167 {
169 {
170 /* sigaltstack case: we have no way of knowing which offset to
171 use in this case; default to new kernel handling. If this is
172 wrong the unwinding will fail. */
173 attempt = 2;
174 sp = pc - pcoffs[attempt];
175 }
176 else
177 return 0;
178 }
179
180 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
181 a struct siginfo and a struct ucontext. struct ucontext contains
182 a struct sigcontext. Return an offset to this sigcontext here. Too
183 bad we cannot include system specific headers :-(.
184 sizeof(struct siginfo) == 128
185 offsetof(struct ucontext, uc_mcontext) == 24. */
186 return sp + sfoffs[attempt] + 128 + 24;
187}
188
194
197 void **this_cache)
198{
199 struct gdbarch *gdbarch = get_frame_arch (this_frame);
201 CORE_ADDR pc, scptr;
202 int i;
203
204 if (*this_cache)
205 return (struct hppa_linux_sigtramp_unwind_cache *) *this_cache;
206
208 *this_cache = info;
209 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
210
211 pc = get_frame_pc (this_frame);
213
214 /* structure of struct sigcontext:
215
216 struct sigcontext {
217 unsigned long sc_flags;
218 unsigned long sc_gr[32];
219 unsigned long long sc_fr[32];
220 unsigned long sc_iasq[2];
221 unsigned long sc_iaoq[2];
222 unsigned long sc_sar; */
223
224 /* Skip sc_flags. */
225 scptr += 4;
226
227 /* GR[0] is the psw. */
228 info->saved_regs[HPPA_IPSW_REGNUM].set_addr (scptr);
229 scptr += 4;
230
231 /* General registers. */
232 for (i = 1; i < 32; i++)
233 {
234 info->saved_regs[HPPA_R0_REGNUM + i].set_addr (scptr);
235 scptr += 4;
236 }
237
238 /* Pad to long long boundary. */
239 scptr += 4;
240
241 /* FP regs; FP0-3 are not restored. */
242 scptr += (8 * 4);
243
244 for (i = 4; i < 32; i++)
245 {
246 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].set_addr (scptr);
247 scptr += 4;
248 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].set_addr (scptr);
249 scptr += 4;
250 }
251
252 /* IASQ/IAOQ. */
253 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].set_addr (scptr);
254 scptr += 4;
255 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].set_addr (scptr);
256 scptr += 4;
257
258 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_addr (scptr);
259 scptr += 4;
260 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].set_addr (scptr);
261 scptr += 4;
262
263 info->saved_regs[HPPA_SAR_REGNUM].set_addr (scptr);
264
265 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
266
267 return info;
268}
269
270static void
272 void **this_prologue_cache,
273 struct frame_id *this_id)
274{
276 = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
277 *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
278}
279
280static struct value *
282 void **this_prologue_cache,
283 int regnum)
284{
286 = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
287 return hppa_frame_prev_register_helper (this_frame,
288 info->saved_regs, regnum);
289}
290
291/* hppa-linux always uses "new-style" rt-signals. The signal handler's return
292 address should point to a signal trampoline on the stack. The signal
293 trampoline is embedded in a rt_sigframe structure that is aligned on
294 the stack. We take advantage of the fact that sp must be 64-byte aligned,
295 and the trampoline is small, so by rounding down the trampoline address
296 we can find the beginning of the struct rt_sigframe. */
297static int
299 frame_info_ptr this_frame,
300 void **this_prologue_cache)
301{
302 struct gdbarch *gdbarch = get_frame_arch (this_frame);
303 CORE_ADDR pc = get_frame_pc (this_frame);
304
306 return 1;
307
308 return 0;
309}
310
320
321/* Attempt to find (and return) the global pointer for the given
322 function.
323
324 This is a rather nasty bit of code searchs for the .dynamic section
325 in the objfile corresponding to the pc of the function we're trying
326 to call. Once it finds the addresses at which the .dynamic section
327 lives in the child process, it scans the Elf32_Dyn entries for a
328 DT_PLTGOT tag. If it finds one of these, the corresponding
329 d_un.d_ptr value is the global pointer. */
330
331static CORE_ADDR
333 struct value *function)
334{
335 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
336 struct obj_section *faddr_sect;
337 CORE_ADDR faddr;
338
339 faddr = value_as_address (function);
340
341 /* Is this a plabel? If so, dereference it to get the gp value. */
342 if (faddr & 2)
343 {
344 int status;
345 gdb_byte buf[4];
346
347 faddr &= ~3;
348
349 status = target_read_memory (faddr + 4, buf, sizeof (buf));
350 if (status == 0)
351 return extract_unsigned_integer (buf, sizeof (buf), byte_order);
352 }
353
354 /* If the address is in the plt section, then the real function hasn't
355 yet been fixed up by the linker so we cannot determine the gp of
356 that function. */
357 if (in_plt_section (faddr))
358 return 0;
359
360 faddr_sect = find_pc_section (faddr);
361 if (faddr_sect != NULL)
362 {
363 for (obj_section *osect : faddr_sect->objfile->sections ())
364 {
365 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
366 {
367 CORE_ADDR addr, endaddr;
368
369 addr = osect->addr ();
370 endaddr = osect->endaddr ();
371
372 while (addr < endaddr)
373 {
374 int status;
375 LONGEST tag;
376 gdb_byte buf[4];
377
378 status = target_read_memory (addr, buf, sizeof (buf));
379 if (status != 0)
380 break;
381 tag = extract_signed_integer (buf, byte_order);
382
383 if (tag == DT_PLTGOT)
384 {
385 CORE_ADDR global_pointer;
386
387 status = target_read_memory (addr + 4, buf,
388 sizeof (buf));
389 if (status != 0)
390 break;
391 global_pointer
392 = extract_unsigned_integer (buf, sizeof (buf),
393 byte_order);
394 /* The payoff... */
395 return global_pointer;
396 }
397
398 if (tag == DT_NULL)
399 break;
400
401 addr += 8;
402 }
403 break;
404 }
405 }
406 }
407 return 0;
408}
409
410/*
411 * Registers saved in a coredump:
412 * gr0..gr31
413 * sr0..sr7
414 * iaoq0..iaoq1
415 * iasq0..iasq1
416 * sar, iir, isr, ior, ipsw
417 * cr0, cr24..cr31
418 * cr8,9,12,13
419 * cr10, cr15
420 */
421
423 {
424 { 32, HPPA_R0_REGNUM },
425 { 1, HPPA_SR4_REGNUM+1 },
426 { 1, HPPA_SR4_REGNUM+2 },
427 { 1, HPPA_SR4_REGNUM+3 },
428 { 1, HPPA_SR4_REGNUM+4 },
429 { 1, HPPA_SR4_REGNUM },
430 { 1, HPPA_SR4_REGNUM+5 },
431 { 1, HPPA_SR4_REGNUM+6 },
432 { 1, HPPA_SR4_REGNUM+7 },
437 { 1, HPPA_SAR_REGNUM },
438 { 1, HPPA_IIR_REGNUM },
439 { 1, HPPA_ISR_REGNUM },
440 { 1, HPPA_IOR_REGNUM },
441 { 1, HPPA_IPSW_REGNUM },
442 { 1, HPPA_RCR_REGNUM },
443 { 8, HPPA_TR0_REGNUM },
444 { 4, HPPA_PID0_REGNUM },
445 { 1, HPPA_CCR_REGNUM },
446 { 1, HPPA_EIEM_REGNUM },
447 { 0 }
448 };
449
451 {
452 /* FIXME: Only works for 32-bit mode. In 64-bit mode there should
453 be 32 fpregs, 8 bytes each. */
454 { 64, HPPA_FP0_REGNUM, 4 },
455 { 0 }
456 };
457
458/* HPPA Linux kernel register set. */
464
470
471static void
474 void *cb_data,
475 const struct regcache *regcache)
476{
477 hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
478
479 cb (".reg", 80 * tdep->bytes_per_address, 80 * tdep->bytes_per_address,
480 &hppa_linux_regset, NULL, cb_data);
481 cb (".reg2", 64 * 4, 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
482}
483
484static void
486{
487 hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
488
489 linux_init_abi (info, gdbarch, 0);
490
491 /* GNU/Linux is always ELF. */
492 tdep->is_elf = 1;
493
495
497
499
500 /* GNU/Linux uses SVR4-style shared libraries. */
503
506
507 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
509
510 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
511 some discussions to support 128-bit long double, but it requires some
512 more work in gcc and glibc first. */
515
518
520
521 /* Enable TLS support. */
524}
525
527void
int regnum
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:465
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
@ SIGTRAMP_FRAME
Definition frame.h:198
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition gdbarch.c:1663
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:89
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition glibc-tdep.c:38
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
unsigned dummy
Definition go32-nat.c:8
static int hppa_linux_sigtramp_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
static void hppa_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static const struct regcache_map_entry hppa_linux_gregmap[]
static CORE_ADDR hppa_linux_sigtramp_find_sigcontext(struct gdbarch *gdbarch, CORE_ADDR pc)
static void hppa_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
#define HPPA_MAX_INSN_PATTERN_LEN
static void hppa_linux_target_write_pc(struct regcache *regcache, CORE_ADDR v)
static const struct regcache_map_entry hppa_linux_fpregmap[]
static const struct regset hppa_linux_regset
static int hppa_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static const struct regset hppa_linux_fpregset
static struct insn_pattern hppa_sigtramp[]
static int insns_match_pattern(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
void _initialize_hppa_linux_tdep()
static void hppa_linux_sigtramp_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static struct hppa_linux_sigtramp_unwind_cache * hppa_linux_sigtramp_frame_unwind_cache(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR hppa_linux_find_global_pointer(struct gdbarch *gdbarch, struct value *function)
static const struct frame_unwind hppa_linux_sigtramp_frame_unwind
static struct value * hppa_linux_sigtramp_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
CORE_ADDR hppa_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
Definition hppa-tdep.c:2887
int hppa_in_solib_call_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition hppa-tdep.c:2859
struct value * hppa_frame_prev_register_helper(frame_info_ptr this_frame, trad_frame_saved_reg saved_regs[], int regnum)
Definition hppa-tdep.c:2709
@ HPPA_CCR_REGNUM
Definition hppa-tdep.h:67
@ HPPA_PCSQ_HEAD_REGNUM
Definition hppa-tdep.h:47
@ HPPA_IOR_REGNUM
Definition hppa-tdep.h:53
@ HPPA_SAR_REGNUM
Definition hppa-tdep.h:44
@ HPPA_TR0_REGNUM
Definition hppa-tdep.h:68
@ HPPA_IPSW_REGNUM
Definition hppa-tdep.h:45
@ HPPA_ISR_REGNUM
Definition hppa-tdep.h:52
@ HPPA_SP_REGNUM
Definition hppa-tdep.h:42
@ HPPA_PID0_REGNUM
Definition hppa-tdep.h:63
@ HPPA_PCOQ_HEAD_REGNUM
Definition hppa-tdep.h:46
@ HPPA_FP4_REGNUM
Definition hppa-tdep.h:73
@ HPPA_PCSQ_TAIL_REGNUM
Definition hppa-tdep.h:49
@ HPPA_PCOQ_TAIL_REGNUM
Definition hppa-tdep.h:48
@ HPPA_FP0_REGNUM
Definition hppa-tdep.h:72
@ HPPA_RCR_REGNUM
Definition hppa-tdep.h:62
@ HPPA_EIEM_REGNUM
Definition hppa-tdep.h:50
@ HPPA_SR4_REGNUM
Definition hppa-tdep.h:54
@ HPPA_IIR_REGNUM
Definition hppa-tdep.h:51
@ HPPA_R0_REGNUM
Definition hppa-tdep.h:33
link_map_offsets * linux_ilp32_fetch_link_map_offsets()
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1128
static int in_plt_section(CORE_ADDR pc)
Definition objfiles.h:972
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
@ GDB_OSABI_LINUX
Definition osabi.h:32
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1273
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1251
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
CORE_ADDR(* find_global_pointer)(struct gdbarch *, struct value *)
Definition hppa-tdep.h:99
int(* in_solib_call_trampoline)(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition hppa-tdep.h:104
trad_frame_saved_reg * saved_regs
unsigned int mask
unsigned int data
CORE_ADDR addr() const
Definition objfiles.h:385
CORE_ADDR endaddr() const
Definition objfiles.h:392
struct objfile * objfile
Definition objfiles.h:401
iterator_range< section_iterator > sections()
Definition objfiles.h:685
Definition regcache.h:111
Definition value.h:130
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2636