GDB (xrefs)

/tmp/gdb-8.1/gdb/amd64-windows-tdep.c
Go to the documentation of this file.
1 /* Copyright (C) 2009-2018 Free Software Foundation, Inc.
2
3 This file is part of GDB.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17
18 #include "defs.h"
19 #include "osabi.h"
20 #include "amd64-tdep.h"
21 #include "x86-xstate.h"
22 #include "gdbtypes.h"
23 #include "gdbcore.h"
24 #include "regcache.h"
25 #include "windows-tdep.h"
26 #include "frame.h"
27 #include "objfiles.h"
28 #include "frame-unwind.h"
29 #include "coff/internal.h"
30 #include "coff/i386.h"
31 #include "coff/pe.h"
32 #include "libcoff.h"
33 #include "value.h"
34 #include <algorithm>
35
36 /* The registers used to pass integer arguments during a function call. */
37 static int amd64_windows_dummy_call_integer_regs[] =
38 {
39 AMD64_RCX_REGNUM, /* %rcx */
40 AMD64_RDX_REGNUM, /* %rdx */
41 AMD64_R8_REGNUM, /* %r8 */
42 AMD64_R9_REGNUM /* %r9 */
43 };
44
45 /* Return nonzero if an argument of type TYPE should be passed
46 via one of the integer registers. */
47
48 static int
49 amd64_windows_passed_by_integer_register (struct type *type)
50 {
51 switch (TYPE_CODE (type))
52 {
53 case TYPE_CODE_INT:
54 case TYPE_CODE_ENUM:
55 case TYPE_CODE_BOOL:
56 case TYPE_CODE_RANGE:
57 case TYPE_CODE_CHAR:
58 case TYPE_CODE_PTR:
59 case TYPE_CODE_REF:
60 case TYPE_CODE_RVALUE_REF:
61 case TYPE_CODE_STRUCT:
62 case TYPE_CODE_UNION:
63 return (TYPE_LENGTH (type) == 1
64 || TYPE_LENGTH (type) == 2
65 || TYPE_LENGTH (type) == 4
66 || TYPE_LENGTH (type) == 8);
67
68 default:
69 return 0;
70 }
71 }
72
73 /* Return nonzero if an argument of type TYPE should be passed
74 via one of the XMM registers. */
75
76 static int
77 amd64_windows_passed_by_xmm_register (struct type *type)
78 {
79 return ((TYPE_CODE (type) == TYPE_CODE_FLT
80 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
81 && (TYPE_LENGTH (type) == 4 || TYPE_LENGTH (type) == 8));
82 }
83
84 /* Return non-zero iff an argument of the given TYPE should be passed
85 by pointer. */
86
87 static int
88 amd64_windows_passed_by_pointer (struct type *type)
89 {
90 if (amd64_windows_passed_by_integer_register (type))
91 return 0;
92
93 if (amd64_windows_passed_by_xmm_register (type))
94 return 0;
95
96 return 1;
97 }
98
99 /* For each argument that should be passed by pointer, reserve some
100 stack space, store a copy of the argument on the stack, and replace
101 the argument by its address. Return the new Stack Pointer value.
102
103 NARGS is the number of arguments. ARGS is the array containing
104 the value of each argument. SP is value of the Stack Pointer. */
105
106 static CORE_ADDR
107 amd64_windows_adjust_args_passed_by_pointer (struct value **args,
108 int nargs, CORE_ADDR sp)
109 {
110 int i;
111
112 for (i = 0; i < nargs; i++)
113 if (amd64_windows_passed_by_pointer (value_type (args[i])))
114 {
115 struct type *type = value_type (args[i]);
116 const gdb_byte *valbuf = value_contents (args[i]);
117 const int len = TYPE_LENGTH (type);
118
119 /* Store a copy of that argument on the stack, aligned to
120 a 16 bytes boundary, and then use the copy's address as
121 the argument. */
122
123 sp -= len;
124 sp &= ~0xf;
125 write_memory (sp, valbuf, len);
126
127 args[i]
128 = value_addr (value_from_contents_and_address (type, valbuf, sp));
129 }
130
131 return sp;
132 }
133
134 /* Store the value of ARG in register REGNO (right-justified).
135 REGCACHE is the register cache. */
136
137 static void
138 amd64_windows_store_arg_in_reg (struct regcache *regcache,
139 struct value *arg, int regno)
140 {
141 struct type *type = value_type (arg);
142 const gdb_byte *valbuf = value_contents (arg);
143 gdb_byte buf[8];
144
145 gdb_assert (TYPE_LENGTH (type) <= 8);
146 memset (buf, 0, sizeof buf);
147 memcpy (buf, valbuf, std::min (TYPE_LENGTH (type), (unsigned int) 8));
148 regcache_cooked_write (regcache, regno, buf);
149 }
150
151 /* Push the arguments for an inferior function call, and return
152 the updated value of the SP (Stack Pointer).
153
154 All arguments are identical to the arguments used in
155 amd64_windows_push_dummy_call. */
156
157 static CORE_ADDR
158 amd64_windows_push_arguments (struct regcache *regcache, int nargs,
159 struct value **args, CORE_ADDR sp,
160 int struct_return)
161 {
162 int reg_idx = 0;
163 int i;
164 struct value **stack_args = XALLOCAVEC (struct value *, nargs);
165 int num_stack_args = 0;
166 int num_elements = 0;
167 int element = 0;
168
169 /* First, handle the arguments passed by pointer.
170
171 These arguments are replaced by pointers to a copy we are making
172 in inferior memory. So use a copy of the ARGS table, to avoid
173 modifying the original one. */
174 {
175 struct value **args1 = XALLOCAVEC (struct value *, nargs);
176
177 memcpy (args1, args, nargs * sizeof (struct value *));
178 sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);
179 args = args1;
180 }
181
182 /* Reserve a register for the "hidden" argument. */
183 if (struct_return)
184 reg_idx++;
185
186 for (i = 0; i < nargs; i++)
187 {
188 struct type *type = value_type (args[i]);
189 int len = TYPE_LENGTH (type);
190 int on_stack_p = 1;
191
192 if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs))
193 {
194 if (amd64_windows_passed_by_integer_register (type))
195 {
196 amd64_windows_store_arg_in_reg
197 (regcache, args[i],
198 amd64_windows_dummy_call_integer_regs[reg_idx]);
199 on_stack_p = 0;
200 reg_idx++;
201 }
202 else if (amd64_windows_passed_by_xmm_register (type))
203 {
204 amd64_windows_store_arg_in_reg
205 (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx);
206 /* In case of varargs, these parameters must also be
207 passed via the integer registers. */
208 amd64_windows_store_arg_in_reg
209 (regcache, args[i],
210 amd64_windows_dummy_call_integer_regs[reg_idx]);
211 on_stack_p = 0;
212 reg_idx++;
213 }
214 }
215
216 if (on_stack_p)
217 {
218 num_elements += ((len + 7) / 8);
219 stack_args[num_stack_args++] = args[i];
220 }
221 }
222
223 /* Allocate space for the arguments on the stack, keeping it
224 aligned on a 16 byte boundary. */
225 sp -= num_elements * 8;
226 sp &= ~0xf;
227
228 /* Write out the arguments to the stack. */
229 for (i = 0; i < num_stack_args; i++)
230 {
231 struct type *type = value_type (stack_args[i]);
232 const gdb_byte *valbuf = value_contents (stack_args[i]);
233
234 write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type));
235 element += ((TYPE_LENGTH (type) + 7) / 8);
236 }
237
238 return sp;
239 }
240
241 /* Implement the "push_dummy_call" gdbarch method. */
242
243 static CORE_ADDR
244 amd64_windows_push_dummy_call
245 (struct gdbarch *gdbarch, struct value *function,
246 struct regcache *regcache, CORE_ADDR bp_addr,
247 int nargs, struct value **args,
248 CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
249 {
250 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
251 gdb_byte buf[8];
252
253 /* Pass arguments. */
254 sp = amd64_windows_push_arguments (regcache, nargs, args, sp,
255 struct_return);
256
257 /* Pass "hidden" argument". */
258 if (struct_return)
259 {
260 /* The "hidden" argument is passed throught the first argument
261 register. */
262 const int arg_regnum = amd64_windows_dummy_call_integer_regs[0];
263
264 store_unsigned_integer (buf, 8, byte_order, struct_addr);
265 regcache_cooked_write (regcache, arg_regnum, buf);
266 }
267
268 /* Reserve some memory on the stack for the integer-parameter
269 registers, as required by the ABI. */
270 sp -= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs) * 8;
271
272 /* Store return address. */
273 sp -= 8;
274 store_unsigned_integer (buf, 8, byte_order, bp_addr);
275 write_memory (sp, buf, 8);
276
277 /* Update the stack pointer... */
278 store_unsigned_integer (buf, 8, byte_order, sp);
279 regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);
280
281 /* ...and fake a frame pointer. */
282 regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);
283
284 return sp + 16;
285 }
286
287 /* Implement the "return_value" gdbarch method for amd64-windows. */
288
289 static enum return_value_convention
290 amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
291 struct type *type, struct regcache *regcache,
292 gdb_byte *readbuf, const gdb_byte *writebuf)
293 {
294 int len = TYPE_LENGTH (type);
295 int regnum = -1;
296
297 /* See if our value is returned through a register. If it is, then
298 store the associated register number in REGNUM. */
299 switch (TYPE_CODE (type))
300 {
301 case TYPE_CODE_FLT:
302 case TYPE_CODE_DECFLOAT:
303 /* __m128, __m128i, __m128d, floats, and doubles are returned
304 via XMM0. */
305 if (len == 4 || len == 8 || len == 16)
306 regnum = AMD64_XMM0_REGNUM;
307 break;
308 default:
309 /* All other values that are 1, 2, 4 or 8 bytes long are returned
310 via RAX. */
311 if (len == 1 || len == 2 || len == 4 || len == 8)
312 regnum = AMD64_RAX_REGNUM;
313 break;
314 }
315
316 if (regnum < 0)
317 {
318 /* RAX contains the address where the return value has been stored. */
319 if (readbuf)
320 {
321 ULONGEST addr;
322
323 regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
324 read_memory (addr, readbuf, TYPE_LENGTH (type));
325 }
326 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
327 }
328 else
329 {
330 /* Extract the return value from the register where it was stored. */
331 if (readbuf)
332 regcache_raw_read_part (regcache, regnum, 0, len, readbuf);
333 if (writebuf)
334 regcache_raw_write_part (regcache, regnum, 0, len, writebuf);
335 return RETURN_VALUE_REGISTER_CONVENTION;
336 }
337 }
338
339 /* Check that the code pointed to by PC corresponds to a call to
340 __main, skip it if so. Return PC otherwise. */
341
342 static CORE_ADDR
343 amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
344 {
345 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
346 gdb_byte op;
347
348 target_read_memory (pc, &op, 1);
349 if (op == 0xe8)
350 {
351 gdb_byte buf[4];
352
353 if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
354 {
355 struct bound_minimal_symbol s;
356 CORE_ADDR call_dest;
357
358 call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
359 s = lookup_minimal_symbol_by_pc (call_dest);
360 if (s.minsym != NULL
361 && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
362 && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
363 pc += 5;
364 }
365 }
366
367 return pc;
368 }
369
370 struct amd64_windows_frame_cache
371 {
372 /* ImageBase for the module. */
373 CORE_ADDR image_base;
374
375 /* Function start and end rva. */
376 CORE_ADDR start_rva;
377 CORE_ADDR end_rva;
378
379 /* Next instruction to be executed. */
380 CORE_ADDR pc;
381
382 /* Current sp. */
383 CORE_ADDR sp;
384
385 /* Address of saved integer and xmm registers. */
386 CORE_ADDR prev_reg_addr[16];
387 CORE_ADDR prev_xmm_addr[16];
388
389 /* These two next fields are set only for machine info frames. */
390
391 /* Likewise for RIP. */
392 CORE_ADDR prev_rip_addr;
393
394 /* Likewise for RSP. */
395 CORE_ADDR prev_rsp_addr;
396
397 /* Address of the previous frame. */
398 CORE_ADDR prev_sp;
399 };
400
401 /* Convert a Windows register number to gdb. */
402 static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =
403 {
404 AMD64_RAX_REGNUM,
405 AMD64_RCX_REGNUM,
406 AMD64_RDX_REGNUM,
407 AMD64_RBX_REGNUM,
408 AMD64_RSP_REGNUM,
409 AMD64_RBP_REGNUM,
410 AMD64_RSI_REGNUM,
411 AMD64_RDI_REGNUM,
412 AMD64_R8_REGNUM,
413 AMD64_R9_REGNUM,
414 AMD64_R10_REGNUM,
415 AMD64_R11_REGNUM,
416 AMD64_R12_REGNUM,
417 AMD64_R13_REGNUM,
418 AMD64_R14_REGNUM,
419 AMD64_R15_REGNUM
420 };
421
422 /* Return TRUE iff PC is the the range of the function corresponding to
423 CACHE. */
424
425 static int
426 pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
427 {
428 return (pc >= cache->image_base + cache->start_rva
429 && pc < cache->image_base + cache->end_rva);
430 }
431
432 /* Try to recognize and decode an epilogue sequence.
433
434 Return -1 if we fail to read the instructions for any reason.
435 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
436
437 static int
438 amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
439 struct amd64_windows_frame_cache *cache)
440 {
441 /* According to MSDN an epilogue "must consist of either an add RSP,constant
442 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
443 register pops and a return or a jmp".
444
445 Furthermore, according to RtlVirtualUnwind, the complete list of
446 epilog marker is:
447 - ret [c3]
448 - ret n [c2 imm16]
449 - rep ret [f3 c3]
450 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
451 - jmp qword ptr imm32 - not handled
452 - rex.w jmp reg [4X ff eY]
453 */
454
455 CORE_ADDR pc = cache->pc;
456 CORE_ADDR cur_sp = cache->sp;
457 struct gdbarch *gdbarch = get_frame_arch (this_frame);
458 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
459 gdb_byte op;
460 gdb_byte rex;
461
462 /* We don't care about the instruction deallocating the frame:
463 if it hasn't been executed, the pc is still in the body,
464 if it has been executed, the following epilog decoding will work. */
465
466 /* First decode:
467 - pop reg [41 58-5f] or [58-5f]. */
468
469 while (1)
470 {
471 /* Read opcode. */
472 if (target_read_memory (pc, &op, 1) != 0)
473 return -1;
474
475 if (op >= 0x40 && op <= 0x4f)
476 {
477 /* REX prefix. */
478 rex = op;
479
480 /* Read opcode. */
481 if (target_read_memory (pc + 1, &op, 1) != 0)
482 return -1;
483 }
484 else
485 rex = 0;
486
487 if (op >= 0x58 && op <= 0x5f)
488 {
489 /* pop reg */
490 gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);
491
492 cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
493 cur_sp += 8;
494 pc += rex ? 2 : 1;
495 }
496 else
497 break;
498
499 /* Allow the user to break this loop. This shouldn't happen as the
500 number of consecutive pop should be small. */
501 QUIT;
502 }
503
504 /* Then decode the marker. */
505
506 /* Read opcode. */
507 if (target_read_memory (pc, &op, 1) != 0)
508 return -1;
509
510 switch (op)
511 {
512 case 0xc3:
513 /* Ret. */
514 cache->prev_rip_addr = cur_sp;
515 cache->prev_sp = cur_sp + 8;
516 return 1;
517
518 case 0xeb:
519 {
520 /* jmp rel8 */
521 gdb_byte rel8;
522 CORE_ADDR npc;
523
524 if (target_read_memory (pc + 1, &rel8, 1) != 0)
525 return -1;
526 npc = pc + 2 + (signed char) rel8;
527
528 /* If the jump is within the function, then this is not a marker,
529 otherwise this is a tail-call. */
530 return !pc_in_range (npc, cache);
531 }
532
533 case 0xec:
534 {
535 /* jmp rel32 */
536 gdb_byte rel32[4];
537 CORE_ADDR npc;
538
539 if (target_read_memory (pc + 1, rel32, 4) != 0)
540 return -1;
541 npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
542
543 /* If the jump is within the function, then this is not a marker,
544 otherwise this is a tail-call. */
545 return !pc_in_range (npc, cache);
546 }
547
548 case 0xc2:
549 {
550 /* ret n */
551 gdb_byte imm16[2];
552
553 if (target_read_memory (pc + 1, imm16, 2) != 0)
554 return -1;
555 cache->prev_rip_addr = cur_sp;
556 cache->prev_sp = cur_sp
557 + extract_unsigned_integer (imm16, 4, byte_order);
558 return 1;
559 }
560
561 case 0xf3:
562 {
563 /* rep; ret */
564 gdb_byte op1;
565
566 if (target_read_memory (pc + 2, &op1, 1) != 0)
567 return -1;
568 if (op1 != 0xc3)
569 return 0;
570
571 cache->prev_rip_addr = cur_sp;
572 cache->prev_sp = cur_sp + 8;
573 return 1;
574 }
575
576 case 0x40:
577 case 0x41:
578 case 0x42:
579 case 0x43:
580 case 0x44:
581 case 0x45:
582 case 0x46:
583 case 0x47:
584 case 0x48:
585 case 0x49:
586 case 0x4a:
587 case 0x4b:
588 case 0x4c:
589 case 0x4d:
590 case 0x4e:
591 case 0x4f:
592 /* Got a REX prefix, read next byte. */
593 rex = op;
594 if (target_read_memory (pc + 1, &op, 1) != 0)
595 return -1;
596
597 if (op == 0xff)
598 {
599 /* rex jmp reg */
600 gdb_byte op1;
601
602 if (target_read_memory (pc + 2, &op1, 1) != 0)
603 return -1;
604 return (op1 & 0xf8) == 0xe0;
605 }
606 else
607 return 0;
608
609 default:
610 /* Not REX, so unknown. */
611 return 0;
612 }
613 }
614
615 /* Decode and execute unwind insns at UNWIND_INFO. */
616
617 static void
618 amd64_windows_frame_decode_insns (struct frame_info *this_frame,
619 struct amd64_windows_frame_cache *cache,
620 CORE_ADDR unwind_info)
621 {
622 CORE_ADDR save_addr = 0;
623 CORE_ADDR cur_sp = cache->sp;
624 struct gdbarch *gdbarch = get_frame_arch (this_frame);
625 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
626 int first = 1;
627
628 /* There are at least 3 possibilities to share an unwind info entry:
629 1. Two different runtime_function entries (in .pdata) can point to the
630 same unwind info entry. There is no such indication while unwinding,
631 so we don't really care about that case. We suppose this scheme is
632 used to save memory when the unwind entries are exactly the same.
633 2. Chained unwind_info entries, with no unwind codes (no prologue).
634 There is a major difference with the previous case: the pc range for
635 the function is different (in case 1, the pc range comes from the
636 runtime_function entry; in case 2, the pc range for the chained entry
637 comes from the first unwind entry). Case 1 cannot be used instead as
638 the pc is not in the prologue. This case is officially documented.
639 (There might be unwind code in the first unwind entry to handle
640 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
641 entries.
642 3. Undocumented unwind info redirection. Hard to know the exact purpose,
643 so it is considered as a memory optimization of case 2.
644 */
645
646 if (unwind_info & 1)
647 {
648 /* Unofficially documented unwind info redirection, when UNWIND_INFO
649 address is odd (http://www.codemachine.com/article_x64deepdive.html).
650 */
651 struct external_pex64_runtime_function d;
652
653 if (target_read_memory (cache->image_base + (unwind_info & ~1),
654 (gdb_byte *) &d, sizeof (d)) != 0)
655 return;
656
657 cache->start_rva
658 = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
659 cache->end_rva
660 = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
661 unwind_info
662 = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
663 }
664
665 while (1)
666 {
667 struct external_pex64_unwind_info ex_ui;
668 /* There are at most 256 16-bit unwind insns. */
669 gdb_byte insns[2 * 256];
670 gdb_byte *p;
671 gdb_byte *end_insns;
672 unsigned char codes_count;
673 unsigned char frame_reg;
674 CORE_ADDR start;
675
676 /* Read and decode header. */
677 if (target_read_memory (cache->image_base + unwind_info,
678 (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
679 return;
680
681 if (frame_debug)
682 fprintf_unfiltered
683 (gdb_stdlog,
684 "amd64_windows_frame_decodes_insn: "
685 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
686 paddress (gdbarch, unwind_info),
687 ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
688 ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);
689
690 /* Check version. */
691 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
692 && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
693 return;
694
695 start = cache->image_base + cache->start_rva;
696 if (first
697 && !(cache->pc >= start && cache->pc < start + ex_ui.SizeOfPrologue))
698 {
699 /* We want to detect if the PC points to an epilogue. This needs
700 to be checked only once, and an epilogue can be anywhere but in
701 the prologue. If so, the epilogue detection+decoding function is
702 sufficient. Otherwise, the unwinder will consider that the PC
703 is in the body of the function and will need to decode unwind
704 info. */
705 if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
706 return;
707
708 /* Not in an epilog. Clear possible side effects. */
709 memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
710 }
711
712 codes_count = ex_ui.CountOfCodes;
713 frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
714
715 if (frame_reg != 0)
716 {
717 /* According to msdn:
718 If an FP reg is used, then any unwind code taking an offset must
719 only be used after the FP reg is established in the prolog. */
720 gdb_byte buf[8];
721 int frreg = amd64_windows_w2gdb_regnum[frame_reg];
722
723 get_frame_register (this_frame, frreg, buf);
724 save_addr = extract_unsigned_integer (buf, 8, byte_order);
725
726 if (frame_debug)
727 fprintf_unfiltered (gdb_stdlog, " frame_reg=%s, val=%s\n",
728 gdbarch_register_name (gdbarch, frreg),
729 paddress (gdbarch, save_addr));
730 }
731
732 /* Read opcodes. */
733 if (codes_count != 0
734 && target_read_memory (cache->image_base + unwind_info
735 + sizeof (ex_ui),
736 insns, codes_count * 2) != 0)
737 return;
738
739 end_insns = &insns[codes_count * 2];
740 p = insns;
741
742 /* Skip opcodes 6 of version 2. This opcode is not documented. */
743 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
744 {
745 for (; p < end_insns; p += 2)
746 if (PEX64_UNWCODE_CODE (p[1]) != 6)
747 break;
748 }
749
750 for (; p < end_insns; p += 2)
751 {
752 int reg;
753
754 /* Virtually execute the operation if the pc is after the
755 corresponding instruction (that does matter in case of break
756 within the prologue). Note that for chained info (!first), the
757 prologue has been fully executed. */
758 if (cache->pc >= start + p[0] || cache->pc < start)
759 {
760 if (frame_debug)
761 fprintf_unfiltered
762 (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n",
763 (unsigned) (p - insns), p[0], p[1]);
764
765 /* If there is no frame registers defined, the current value of
766 rsp is used instead. */
767 if (frame_reg == 0)
768 save_addr = cur_sp;
769
770 reg = -1;
771
772 switch (PEX64_UNWCODE_CODE (p[1]))
773 {
774 case UWOP_PUSH_NONVOL:
775 /* Push pre-decrements RSP. */
776 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
777 cache->prev_reg_addr[reg] = cur_sp;
778 cur_sp += 8;
779 break;
780 case UWOP_ALLOC_LARGE:
781 if (PEX64_UNWCODE_INFO (p[1]) == 0)
782 cur_sp +=
783 8 * extract_unsigned_integer (p + 2, 2, byte_order);
784 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
785 cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
786 else
787 return;
788 break;
789 case UWOP_ALLOC_SMALL:
790 cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
791 break;
792 case UWOP_SET_FPREG:
793 cur_sp = save_addr
794 - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
795 break;
796 case UWOP_SAVE_NONVOL:
797 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
798 cache->prev_reg_addr[reg] = save_addr
799 + 8 * extract_unsigned_integer (p + 2, 2, byte_order);
800 break;
801 case UWOP_SAVE_NONVOL_FAR:
802 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
803 cache->prev_reg_addr[reg] = save_addr
804 + 8 * extract_unsigned_integer (p + 2, 4, byte_order);
805 break;
806 case UWOP_SAVE_XMM128:
807 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
808 save_addr
809 - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
810 break;
811 case UWOP_SAVE_XMM128_FAR:
812 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
813 save_addr
814 - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
815 break;
816 case UWOP_PUSH_MACHFRAME:
817 if (PEX64_UNWCODE_INFO (p[1]) == 0)
818 {
819 cache->prev_rip_addr = cur_sp + 0;
820 cache->prev_rsp_addr = cur_sp + 24;
821 cur_sp += 40;
822 }
823 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
824 {
825 cache->prev_rip_addr = cur_sp + 8;
826 cache->prev_rsp_addr = cur_sp + 32;
827 cur_sp += 48;
828 }
829 else
830 return;
831 break;
832 default:
833 return;
834 }
835
836 /* Display address where the register was saved. */
837 if (frame_debug && reg >= 0)
838 fprintf_unfiltered
839 (gdb_stdlog, " [reg %s at %s]\n",
840 gdbarch_register_name (gdbarch, reg),
841 paddress (gdbarch, cache->prev_reg_addr[reg]));
842 }
843
844 /* Adjust with the length of the opcode. */
845 switch (PEX64_UNWCODE_CODE (p[1]))
846 {
847 case UWOP_PUSH_NONVOL:
848 case UWOP_ALLOC_SMALL:
849 case UWOP_SET_FPREG:
850 case UWOP_PUSH_MACHFRAME:
851 break;
852 case UWOP_ALLOC_LARGE:
853 if (PEX64_UNWCODE_INFO (p[1]) == 0)
854 p += 2;
855 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
856 p += 4;
857 else
858 return;
859 break;
860 case UWOP_SAVE_NONVOL:
861 case UWOP_SAVE_XMM128:
862 p += 2;
863 break;
864 case UWOP_SAVE_NONVOL_FAR:
865 case UWOP_SAVE_XMM128_FAR:
866 p += 4;
867 break;
868 default:
869 return;
870 }
871 }
872 if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
873 {
874 /* End of unwind info. */
875 break;
876 }
877 else
878 {
879 /* Read the chained unwind info. */
880 struct external_pex64_runtime_function d;
881 CORE_ADDR chain_vma;
882
883 /* Not anymore the first entry. */
884 first = 0;
885
886 /* Stay aligned on word boundary. */
887 chain_vma = cache->image_base + unwind_info
888 + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2;
889
890 if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
891 return;
892
893 /* Decode begin/end. This may be different from .pdata index, as
894 an unwind info may be shared by several functions (in particular
895 if many functions have the same prolog and handler. */
896 cache->start_rva =
897 extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
898 cache->end_rva =
899 extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
900 unwind_info =
901 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
902
903 if (frame_debug)
904 fprintf_unfiltered
905 (gdb_stdlog,
906 "amd64_windows_frame_decodes_insn (next in chain):"
907 " unwind_data=%s, start_rva=%s, end_rva=%s\n",
908 paddress (gdbarch, unwind_info),
909 paddress (gdbarch, cache->start_rva),
910 paddress (gdbarch, cache->end_rva));
911 }
912
913 /* Allow the user to break this loop. */
914 QUIT;
915 }
916 /* PC is saved by the call. */
917 if (cache->prev_rip_addr == 0)
918 cache->prev_rip_addr = cur_sp;
919 cache->prev_sp = cur_sp + 8;
920
921 if (frame_debug)
922 fprintf_unfiltered (gdb_stdlog, " prev_sp: %s, prev_pc @%s\n",
923 paddress (gdbarch, cache->prev_sp),
924 paddress (gdbarch, cache->prev_rip_addr));
925 }
926
927 /* Find SEH unwind info for PC, returning 0 on success.
928
929 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
930 to the base address of the corresponding image, and START_RVA
931 to the rva of the function containing PC. */
932
933 static int
934 amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
935 CORE_ADDR *unwind_info,
936 CORE_ADDR *image_base,
937 CORE_ADDR *start_rva,
938 CORE_ADDR *end_rva)
939 {
940 struct obj_section *sec;
941 pe_data_type *pe;
942 IMAGE_DATA_DIRECTORY *dir;
943 struct objfile *objfile;
944 unsigned long lo, hi;
945 CORE_ADDR base;
946 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
947
948 /* Get the corresponding exception directory. */
949 sec = find_pc_section (pc);
950 if (sec == NULL)
951 return -1;
952 objfile = sec->objfile;
953 pe = pe_data (sec->objfile->obfd);
954 dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
955
956 base = pe->pe_opthdr.ImageBase
957 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
958 *image_base = base;
959
960 /* Find the entry.
961
962 Note: This does not handle dynamically added entries (for JIT
963 engines). For this, we would need to ask the kernel directly,
964 which means getting some info from the native layer. For the
965 rest of the code, however, it's probably faster to search
966 the entry ourselves. */
967 lo = 0;
968 hi = dir->Size / sizeof (struct external_pex64_runtime_function);
969 *unwind_info = 0;
970 while (lo <= hi)
971 {
972 unsigned long mid = lo + (hi - lo) / 2;
973 struct external_pex64_runtime_function d;
974 CORE_ADDR sa, ea;
975
976 if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
977 (gdb_byte *) &d, sizeof (d)) != 0)
978 return -1;
979
980 sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
981 ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
982 if (pc < base + sa)
983 hi = mid - 1;
984 else if (pc >= base + ea)
985 lo = mid + 1;
986 else if (pc >= base + sa && pc < base + ea)
987 {
988 /* Got it. */
989 *start_rva = sa;
990 *end_rva = ea;
991 *unwind_info =
992 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
993 break;
994 }
995 else
996 break;
997 }
998
999 if (frame_debug)
1000 fprintf_unfiltered
1001 (gdb_stdlog,
1002 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
1003 paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
1004
1005 return 0;
1006 }
1007
1008 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1009 for THIS_FRAME. */
1010
1011 static struct amd64_windows_frame_cache *
1012 amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
1013 {
1014 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1015 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1016 struct amd64_windows_frame_cache *cache;
1017 gdb_byte buf[8];
1018 CORE_ADDR pc;
1019 CORE_ADDR unwind_info = 0;
1020
1021 if (*this_cache)
1022 return (struct amd64_windows_frame_cache *) *this_cache;
1023
1024 cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
1025 *this_cache = cache;
1026
1027 /* Get current PC and SP. */
1028 pc = get_frame_pc (this_frame);
1029 get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
1030 cache->sp = extract_unsigned_integer (buf, 8, byte_order);
1031 cache->pc = pc;
1032
1033 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1034 &cache->image_base,
1035 &cache->start_rva,
1036 &cache->end_rva))
1037 return cache;
1038
1039 if (unwind_info == 0)
1040 {
1041 /* Assume a leaf function. */
1042 cache->prev_sp = cache->sp + 8;
1043 cache->prev_rip_addr = cache->sp;
1044 }
1045 else
1046 {
1047 /* Decode unwind insns to compute saved addresses. */
1048 amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1049 }
1050 return cache;
1051 }
1052
1053 /* Implement the "prev_register" method of struct frame_unwind
1054 using the standard Windows x64 SEH info. */
1055
1056 static struct value *
1057 amd64_windows_frame_prev_register (struct frame_info *this_frame,
1058 void **this_cache, int regnum)
1059 {
1060 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1061 struct amd64_windows_frame_cache *cache =
1062 amd64_windows_frame_cache (this_frame, this_cache);
1063 CORE_ADDR prev;
1064
1065 if (frame_debug)
1066 fprintf_unfiltered (gdb_stdlog,
1067 "amd64_windows_frame_prev_register %s for sp=%s\n",
1068 gdbarch_register_name (gdbarch, regnum),
1069 paddress (gdbarch, cache->prev_sp));
1070
1071 if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1072 prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1073 else if (regnum == AMD64_RSP_REGNUM)
1074 {
1075 prev = cache->prev_rsp_addr;
1076 if (prev == 0)
1077 return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1078 }
1079 else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1080 prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1081 else if (regnum == AMD64_RIP_REGNUM)
1082 prev = cache->prev_rip_addr;
1083 else
1084 prev = 0;
1085
1086 if (prev && frame_debug)
1087 fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, prev));
1088
1089 if (prev)
1090 {
1091 /* Register was saved. */
1092 return frame_unwind_got_memory (this_frame, regnum, prev);
1093 }
1094 else
1095 {
1096 /* Register is either volatile or not modified. */
1097 return frame_unwind_got_register (this_frame, regnum, regnum);
1098 }
1099 }
1100
1101 /* Implement the "this_id" method of struct frame_unwind using
1102 the standard Windows x64 SEH info. */
1103
1104 static void
1105 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1106 struct frame_id *this_id)
1107 {
1108 struct amd64_windows_frame_cache *cache =
1109 amd64_windows_frame_cache (this_frame, this_cache);
1110
1111 *this_id = frame_id_build (cache->prev_sp,
1112 cache->image_base + cache->start_rva);
1113 }
1114
1115 /* Windows x64 SEH unwinder. */
1116
1117 static const struct frame_unwind amd64_windows_frame_unwind =
1118 {
1119 NORMAL_FRAME,
1120 default_frame_unwind_stop_reason,
1121 &amd64_windows_frame_this_id,
1122 &amd64_windows_frame_prev_register,
1123 NULL,
1124 default_frame_sniffer
1125 };
1126
1127 /* Implement the "skip_prologue" gdbarch method. */
1128
1129 static CORE_ADDR
1130 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1131 {
1132 CORE_ADDR func_addr;
1133 CORE_ADDR unwind_info = 0;
1134 CORE_ADDR image_base, start_rva, end_rva;
1135 struct external_pex64_unwind_info ex_ui;
1136
1137 /* Use prologue size from unwind info. */
1138 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1139 &image_base, &start_rva, &end_rva) == 0)
1140 {
1141 if (unwind_info == 0)
1142 {
1143 /* Leaf function. */
1144 return pc;
1145 }
1146 else if (target_read_memory (image_base + unwind_info,
1147 (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1148 && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1149 return std::max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1150 }
1151
1152 /* See if we can determine the end of the prologue via the symbol
1153 table. If so, then return either the PC, or the PC after
1154 the prologue, whichever is greater. */
1155 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1156 {
1157 CORE_ADDR post_prologue_pc
1158 = skip_prologue_using_sal (gdbarch, func_addr);
1159
1160 if (post_prologue_pc != 0)
1161 return std::max (pc, post_prologue_pc);
1162 }
1163
1164 return pc;
1165 }
1166
1167 /* Check Win64 DLL jmp trampolines and find jump destination. */
1168
1169 static CORE_ADDR
1170 amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1171 {
1172 CORE_ADDR destination = 0;
1173 struct gdbarch *gdbarch = get_frame_arch (frame);
1174 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1175
1176 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1177 if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1178 {
1179 /* Get opcode offset and see if we can find a reference in our data. */
1180 ULONGEST offset
1181 = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1182
1183 /* Get address of function pointer at end of pc. */
1184 CORE_ADDR indirect_addr = pc + offset + 6;
1185
1186 struct minimal_symbol *indsym
1187 = (indirect_addr
1188 ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1189 : NULL);
1190 const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
1191
1192 if (symname)
1193 {
1194 if (startswith (symname, "__imp_")
1195 || startswith (symname, "_imp_"))
1196 destination
1197 = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1198 }
1199 }
1200
1201 return destination;
1202 }
1203
1204 /* Implement the "auto_wide_charset" gdbarch method. */
1205
1206 static const char *
1207 amd64_windows_auto_wide_charset (void)
1208 {
1209 return "UTF-16";
1210 }
1211
1212 static void
1213 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1214 {
1215 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1216 preferred over the SEH one. The reasons are:
1217 - binaries without SEH but with dwarf2 debug info are correcly handled
1218 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1219 info).
1220 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1221 handled if the dwarf2 unwinder is used).
1222
1223 The call to amd64_init_abi appends default unwinders, that aren't
1224 compatible with the SEH one.
1225 */
1226 frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1227
1228 amd64_init_abi (info, gdbarch,
1229 amd64_target_description (X86_XSTATE_SSE_MASK));
1230
1231 windows_init_abi (info, gdbarch);
1232
1233 /* On Windows, "long"s are only 32bit. */
1234 set_gdbarch_long_bit (gdbarch, 32);
1235
1236 /* Function calls. */
1237 set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
1238 set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
1239 set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
1240 set_gdbarch_skip_trampoline_code (gdbarch,
1241 amd64_windows_skip_trampoline_code);
1242
1243 set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1244
1245 set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1246 }
1247
1248 void
1249 _initialize_amd64_windows_tdep (void)
1250 {
1251 gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1252 amd64_windows_init_abi);
1253 }
gdbarch
Definition: gdbarch.c:127
amd64_windows_skip_prologue
static CORE_ADDR amd64_windows_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: amd64-windows-tdep.c:1130
amd64_windows_frame_this_id
static void amd64_windows_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: amd64-windows-tdep.c:1105
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
AMD64_R8_REGNUM
Definition: amd64-tdep.h:42
set_gdbarch_skip_main_prologue
void set_gdbarch_skip_main_prologue(struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype skip_main_prologue)
Definition: gdbarch.c:2796
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
amd64_regnum
amd64_regnum
Definition: amd64-tdep.h:32
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
amd64_windows_frame_prev_register
static struct value * amd64_windows_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: amd64-windows-tdep.c:1057
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
SECT_OFF_TEXT
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:686
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
X86_XSTATE_SSE_MASK
#define X86_XSTATE_SSE_MASK
Definition: x86-xstate.h:42
value_from_contents_and_address
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3599
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
windows-tdep.h
AMD64_RBX_REGNUM
Definition: amd64-tdep.h:35
amd64_init_abi
void amd64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, const target_desc *default_tdesc)
Definition: amd64-tdep.c:3037
AMD64_RIP_REGNUM
Definition: amd64-tdep.h:50
frame_unwind_got_memory
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:233
set_gdbarch_skip_trampoline_code
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3316
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
amd64_windows_adjust_args_passed_by_pointer
static CORE_ADDR amd64_windows_adjust_args_passed_by_pointer(struct value **args, int nargs, CORE_ADDR sp)
Definition: amd64-windows-tdep.c:107
TYPE_CODE_INT
Definition: gdbtypes.h:111
memset
void * memset(T *s, int c, size_t n)=delete
amd64_windows_frame_cache::start_rva
CORE_ADDR start_rva
Definition: amd64-windows-tdep.c:376
return_value_convention
return_value_convention
Definition: defs.h:247
amd64_windows_frame_cache::prev_reg_addr
CORE_ADDR prev_reg_addr[16]
Definition: amd64-windows-tdep.c:386
TYPE_CODE_DECFLOAT
Definition: gdbtypes.h:173
frame_info
Definition: frame.c:85
x86-xstate.h
amd64_skip_main_prologue
static CORE_ADDR amd64_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: amd64-windows-tdep.c:343
AMD64_R9_REGNUM
Definition: amd64-tdep.h:43
skip_prologue_using_sal
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3854
AMD64_R11_REGNUM
Definition: amd64-tdep.h:45
AMD64_RCX_REGNUM
Definition: amd64-tdep.h:36
amd64_windows_frame_unwind
static const struct frame_unwind amd64_windows_frame_unwind
Definition: amd64-windows-tdep.c:1117
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
amd64_windows_passed_by_pointer
static int amd64_windows_passed_by_pointer(struct type *type)
Definition: amd64-windows-tdep.c:88
AMD64_RAX_REGNUM
Definition: amd64-tdep.h:34
frame_unwind_append_unwinder
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:79
FRAME_OBSTACK_ZALLOC
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:678
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
frame_unwind_got_constant
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:246
NORMAL_FRAME
Definition: frame.h:244
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
regcache_raw_read_part
enum register_status regcache_raw_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:943
amd64_windows_skip_trampoline_code
static CORE_ADDR amd64_windows_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
Definition: amd64-windows-tdep.c:1170
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
AMD64_R12_REGNUM
Definition: amd64-tdep.h:46
amd64_windows_dummy_call_integer_regs
static int amd64_windows_dummy_call_integer_regs[]
Definition: amd64-windows-tdep.c:37
pc_in_range
static int pc_in_range(CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
Definition: amd64-windows-tdep.c:426
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
amd64_windows_store_arg_in_reg
static void amd64_windows_store_arg_in_reg(struct regcache *regcache, struct value *arg, int regno)
Definition: amd64-windows-tdep.c:138
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
osabi.h
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
amd64_windows_frame_decode_epilogue
static int amd64_windows_frame_decode_epilogue(struct frame_info *this_frame, struct amd64_windows_frame_cache *cache)
Definition: amd64-windows-tdep.c:438
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
struct_return
struct_return
Definition: arm-tdep.h:88
frame.h
TYPE_CODE_FLT
Definition: gdbtypes.h:116
AMD64_R10_REGNUM
Definition: amd64-tdep.h:44
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
TYPE_CODE_UNION
Definition: gdbtypes.h:107
AMD64_RSP_REGNUM
Definition: amd64-tdep.h:41
set_gdbarch_auto_wide_charset
void set_gdbarch_auto_wide_charset(struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype auto_wide_charset)
Definition: gdbarch.c:4714
type
Definition: gdbtypes.h:749
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
frame-unwind.h
default_frame_sniffer
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:174
amd64_windows_passed_by_integer_register
static int amd64_windows_passed_by_integer_register(struct type *type)
Definition: amd64-windows-tdep.c:49
gdbarch_register_name
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2282
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
amd64_windows_push_arguments
static CORE_ADDR amd64_windows_push_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp, int struct_return)
Definition: amd64-windows-tdep.c:158
AMD64_RSI_REGNUM
Definition: amd64-tdep.h:38
amd64-tdep.h
amd64_windows_w2gdb_regnum
static enum amd64_regnum amd64_windows_w2gdb_regnum[]
Definition: amd64-windows-tdep.c:402
regnum
int regnum
Definition: aarch64-tdep.c:77
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
find_pc_section
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1395
amd64_windows_auto_wide_charset
static const char * amd64_windows_auto_wide_charset(void)
Definition: amd64-windows-tdep.c:1207
gdbarch_register_osabi
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:143
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
TYPE_CODE_REF
Definition: gdbtypes.h:156
AMD64_RDI_REGNUM
Definition: amd64-tdep.h:39
reg
Definition: regdef.h:22
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
amd64_windows_frame_cache
static struct amd64_windows_frame_cache * amd64_windows_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: amd64-windows-tdep.c:1012
value
Definition: value.c:169
AMD64_R13_REGNUM
Definition: amd64-tdep.h:47
amd64_windows_passed_by_xmm_register
static int amd64_windows_passed_by_xmm_register(struct type *type)
Definition: amd64-windows-tdep.c:77
objfile
Definition: objfiles.h:286
regcache_raw_write_part
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:957
TYPE_CODE_PTR
Definition: gdbtypes.h:84
AMD64_RBP_REGNUM
Definition: amd64-tdep.h:40
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
AMD64_RDX_REGNUM
Definition: amd64-tdep.h:37
amd64_windows_frame_cache::prev_rip_addr
CORE_ADDR prev_rip_addr
Definition: amd64-windows-tdep.c:392
RETURN_VALUE_ABI_RETURNS_ADDRESS
Definition: defs.h:264
amd64_windows_frame_cache
Definition: amd64-windows-tdep.c:370
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
gdbcore.h
amd64_windows_frame_cache::prev_rsp_addr
CORE_ADDR prev_rsp_addr
Definition: amd64-windows-tdep.c:395
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
frame_unwind_got_register
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:223
windows_init_abi
void windows_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: windows-tdep.c:469
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
offset
int offset
Definition: agent.c:65
amd64_windows_init_abi
static void amd64_windows_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: amd64-windows-tdep.c:1213
get_frame_register
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1165
obj_section::objfile
struct objfile * objfile
Definition: objfiles.h:129
AMD64_R14_REGNUM
Definition: amd64-tdep.h:48
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
amd64_windows_return_value
static enum return_value_convention amd64_windows_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: amd64-windows-tdep.c:290
value.h
frame_unwind
Definition: frame-unwind.h:144
AMD64_XMM0_REGNUM
Definition: amd64-tdep.h:63
amd64_windows_frame_cache::pc
CORE_ADDR pc
Definition: amd64-windows-tdep.c:380
amd64_windows_frame_cache::sp
CORE_ADDR sp
Definition: amd64-windows-tdep.c:383
amd64_windows_frame_cache::end_rva
CORE_ADDR end_rva
Definition: amd64-windows-tdep.c:377
_initialize_amd64_windows_tdep
void _initialize_amd64_windows_tdep(void)
Definition: amd64-windows-tdep.c:1249
gdbtypes.h
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
default_frame_unwind_stop_reason
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:184
regcache
Definition: regcache.h:232
gdbarch_info
Definition: gdbarch.h:1626
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
set_gdbarch_long_bit
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1606
set_gdbarch_return_value
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2738
amd64_windows_push_dummy_call
static CORE_ADDR amd64_windows_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: amd64-windows-tdep.c:245
amd64_windows_frame_cache::image_base
CORE_ADDR image_base
Definition: amd64-windows-tdep.c:373
amd64_windows_frame_decode_insns
static void amd64_windows_frame_decode_insns(struct frame_info *this_frame, struct amd64_windows_frame_cache *cache, CORE_ADDR unwind_info)
Definition: amd64-windows-tdep.c:618
amd64_windows_frame_cache::prev_xmm_addr
CORE_ADDR prev_xmm_addr[16]
Definition: amd64-windows-tdep.c:387
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
regcache_raw_read_unsigned
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:612
set_gdbarch_push_dummy_call
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2381
frame_debug
unsigned int frame_debug
Definition: frame.c:274
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
QUIT
#define QUIT
Definition: defs.h:179
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
set_gdbarch_skip_prologue
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2772
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
amd64_windows_find_unwind_info
static int amd64_windows_find_unwind_info(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR *unwind_info, CORE_ADDR *image_base, CORE_ADDR *start_rva, CORE_ADDR *end_rva)
Definition: amd64-windows-tdep.c:934
amd64_target_description
const struct target_desc * amd64_target_description(uint64_t xcr0)
Definition: amd64-tdep.c:3246
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
AMD64_R15_REGNUM
Definition: amd64-tdep.h:49
regcache_cooked_write
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:873
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
amd64_windows_frame_cache::prev_sp
CORE_ADDR prev_sp
Definition: amd64-windows-tdep.c:398
GDB_OSABI_CYGWIN
Definition: defs.h:524