GDB (xrefs)
/tmp/gdb-7.10/gdb/amd64-windows-tdep.c
Go to the documentation of this file.
1 /* Copyright (C) 2009-2015 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 "gdbtypes.h"
22 #include "gdbcore.h"
23 #include "regcache.h"
24 #include "windows-tdep.h"
25 #include "frame.h"
26 #include "objfiles.h"
27 #include "frame-unwind.h"
28 #include "coff/internal.h"
29 #include "coff/i386.h"
30 #include "coff/pe.h"
31 #include "libcoff.h"
32 #include "value.h"
33 
34 /* The registers used to pass integer arguments during a function call. */
36 {
37  AMD64_RCX_REGNUM, /* %rcx */
38  AMD64_RDX_REGNUM, /* %rdx */
39  AMD64_R8_REGNUM, /* %r8 */
40  AMD64_R9_REGNUM /* %r9 */
41 };
42 
43 /* Return nonzero if an argument of type TYPE should be passed
44  via one of the integer registers. */
45 
46 static int
48 {
49  switch (TYPE_CODE (type))
50  {
51  case TYPE_CODE_INT:
52  case TYPE_CODE_ENUM:
53  case TYPE_CODE_BOOL:
54  case TYPE_CODE_RANGE:
55  case TYPE_CODE_CHAR:
56  case TYPE_CODE_PTR:
57  case TYPE_CODE_REF:
58  case TYPE_CODE_STRUCT:
59  case TYPE_CODE_UNION:
60  return (TYPE_LENGTH (type) == 1
61  || TYPE_LENGTH (type) == 2
62  || TYPE_LENGTH (type) == 4
63  || TYPE_LENGTH (type) == 8);
64 
65  default:
66  return 0;
67  }
68 }
69 
70 /* Return nonzero if an argument of type TYPE should be passed
71  via one of the XMM registers. */
72 
73 static int
75 {
76  return ((TYPE_CODE (type) == TYPE_CODE_FLT
77  || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
78  && (TYPE_LENGTH (type) == 4 || TYPE_LENGTH (type) == 8));
79 }
80 
81 /* Return non-zero iff an argument of the given TYPE should be passed
82  by pointer. */
83 
84 static int
86 {
88  return 0;
89 
91  return 0;
92 
93  return 1;
94 }
95 
96 /* For each argument that should be passed by pointer, reserve some
97  stack space, store a copy of the argument on the stack, and replace
98  the argument by its address. Return the new Stack Pointer value.
99 
100  NARGS is the number of arguments. ARGS is the array containing
101  the value of each argument. SP is value of the Stack Pointer. */
102 
103 static CORE_ADDR
105  int nargs, CORE_ADDR sp)
106 {
107  int i;
108 
109  for (i = 0; i < nargs; i++)
111  {
112  struct type *type = value_type (args[i]);
113  const gdb_byte *valbuf = value_contents (args[i]);
114  const int len = TYPE_LENGTH (type);
115 
116  /* Store a copy of that argument on the stack, aligned to
117  a 16 bytes boundary, and then use the copy's address as
118  the argument. */
119 
120  sp -= len;
121  sp &= ~0xf;
122  write_memory (sp, valbuf, len);
123 
124  args[i]
125  = value_addr (value_from_contents_and_address (type, valbuf, sp));
126  }
127 
128  return sp;
129 }
130 
131 /* Store the value of ARG in register REGNO (right-justified).
132  REGCACHE is the register cache. */
133 
134 static void
135 amd64_windows_store_arg_in_reg (struct regcache *regcache,
136  struct value *arg, int regno)
137 {
138  struct type *type = value_type (arg);
139  const gdb_byte *valbuf = value_contents (arg);
140  gdb_byte buf[8];
141 
142  gdb_assert (TYPE_LENGTH (type) <= 8);
143  memset (buf, 0, sizeof buf);
144  memcpy (buf, valbuf, min (TYPE_LENGTH (type), 8));
145  regcache_cooked_write (regcache, regno, buf);
146 }
147 
148 /* Push the arguments for an inferior function call, and return
149  the updated value of the SP (Stack Pointer).
150 
151  All arguments are identical to the arguments used in
152  amd64_windows_push_dummy_call. */
153 
154 static CORE_ADDR
155 amd64_windows_push_arguments (struct regcache *regcache, int nargs,
156  struct value **args, CORE_ADDR sp,
157  int struct_return)
158 {
159  int reg_idx = 0;
160  int i;
161  struct value **stack_args = alloca (nargs * sizeof (struct value *));
162  int num_stack_args = 0;
163  int num_elements = 0;
164  int element = 0;
165 
166  /* First, handle the arguments passed by pointer.
167 
168  These arguments are replaced by pointers to a copy we are making
169  in inferior memory. So use a copy of the ARGS table, to avoid
170  modifying the original one. */
171  {
172  struct value **args1 = alloca (nargs * sizeof (struct value *));
173 
174  memcpy (args1, args, nargs * sizeof (struct value *));
175  sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);
176  args = args1;
177  }
178 
179  /* Reserve a register for the "hidden" argument. */
180  if (struct_return)
181  reg_idx++;
182 
183  for (i = 0; i < nargs; i++)
184  {
185  struct type *type = value_type (args[i]);
186  int len = TYPE_LENGTH (type);
187  int on_stack_p = 1;
188 
189  if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs))
190  {
192  {
194  (regcache, args[i],
195  amd64_windows_dummy_call_integer_regs[reg_idx]);
196  on_stack_p = 0;
197  reg_idx++;
198  }
199  else if (amd64_windows_passed_by_xmm_register (type))
200  {
202  (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx);
203  /* In case of varargs, these parameters must also be
204  passed via the integer registers. */
206  (regcache, args[i],
207  amd64_windows_dummy_call_integer_regs[reg_idx]);
208  on_stack_p = 0;
209  reg_idx++;
210  }
211  }
212 
213  if (on_stack_p)
214  {
215  num_elements += ((len + 7) / 8);
216  stack_args[num_stack_args++] = args[i];
217  }
218  }
219 
220  /* Allocate space for the arguments on the stack, keeping it
221  aligned on a 16 byte boundary. */
222  sp -= num_elements * 8;
223  sp &= ~0xf;
224 
225  /* Write out the arguments to the stack. */
226  for (i = 0; i < num_stack_args; i++)
227  {
228  struct type *type = value_type (stack_args[i]);
229  const gdb_byte *valbuf = value_contents (stack_args[i]);
230 
231  write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type));
232  element += ((TYPE_LENGTH (type) + 7) / 8);
233  }
234 
235  return sp;
236 }
237 
238 /* Implement the "push_dummy_call" gdbarch method. */
239 
240 static CORE_ADDR
242  (struct gdbarch *gdbarch, struct value *function,
243  struct regcache *regcache, CORE_ADDR bp_addr,
244  int nargs, struct value **args,
245  CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
246 {
247  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
248  gdb_byte buf[8];
249 
250  /* Pass arguments. */
251  sp = amd64_windows_push_arguments (regcache, nargs, args, sp,
252  struct_return);
253 
254  /* Pass "hidden" argument". */
255  if (struct_return)
256  {
257  /* The "hidden" argument is passed throught the first argument
258  register. */
259  const int arg_regnum = amd64_windows_dummy_call_integer_regs[0];
260 
261  store_unsigned_integer (buf, 8, byte_order, struct_addr);
262  regcache_cooked_write (regcache, arg_regnum, buf);
263  }
264 
265  /* Reserve some memory on the stack for the integer-parameter
266  registers, as required by the ABI. */
267  sp -= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs) * 8;
268 
269  /* Store return address. */
270  sp -= 8;
271  store_unsigned_integer (buf, 8, byte_order, bp_addr);
272  write_memory (sp, buf, 8);
273 
274  /* Update the stack pointer... */
275  store_unsigned_integer (buf, 8, byte_order, sp);
276  regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);
277 
278  /* ...and fake a frame pointer. */
279  regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);
280 
281  return sp + 16;
282 }
283 
284 /* Implement the "return_value" gdbarch method for amd64-windows. */
285 
286 static enum return_value_convention
287 amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
288  struct type *type, struct regcache *regcache,
289  gdb_byte *readbuf, const gdb_byte *writebuf)
290 {
291  int len = TYPE_LENGTH (type);
292  int regnum = -1;
293 
294  /* See if our value is returned through a register. If it is, then
295  store the associated register number in REGNUM. */
296  switch (TYPE_CODE (type))
297  {
298  case TYPE_CODE_FLT:
299  case TYPE_CODE_DECFLOAT:
300  /* __m128, __m128i, __m128d, floats, and doubles are returned
301  via XMM0. */
302  if (len == 4 || len == 8 || len == 16)
303  regnum = AMD64_XMM0_REGNUM;
304  break;
305  default:
306  /* All other values that are 1, 2, 4 or 8 bytes long are returned
307  via RAX. */
308  if (len == 1 || len == 2 || len == 4 || len == 8)
309  regnum = AMD64_RAX_REGNUM;
310  break;
311  }
312 
313  if (regnum < 0)
314  {
315  /* RAX contains the address where the return value has been stored. */
316  if (readbuf)
317  {
318  ULONGEST addr;
319 
320  regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
321  read_memory (addr, readbuf, TYPE_LENGTH (type));
322  }
324  }
325  else
326  {
327  /* Extract the return value from the register where it was stored. */
328  if (readbuf)
329  regcache_raw_read_part (regcache, regnum, 0, len, readbuf);
330  if (writebuf)
331  regcache_raw_write_part (regcache, regnum, 0, len, writebuf);
333  }
334 }
335 
336 /* Check that the code pointed to by PC corresponds to a call to
337  __main, skip it if so. Return PC otherwise. */
338 
339 static CORE_ADDR
340 amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
341 {
342  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
343  gdb_byte op;
344 
345  target_read_memory (pc, &op, 1);
346  if (op == 0xe8)
347  {
348  gdb_byte buf[4];
349 
350  if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
351  {
352  struct bound_minimal_symbol s;
353  CORE_ADDR call_dest;
354 
355  call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
356  s = lookup_minimal_symbol_by_pc (call_dest);
357  if (s.minsym != NULL
358  && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
359  && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
360  pc += 5;
361  }
362  }
363 
364  return pc;
365 }
366 
368 {
369  /* ImageBase for the module. */
371 
372  /* Function start and end rva. */
375 
376  /* Next instruction to be executed. */
378 
379  /* Current sp. */
381 
382  /* Address of saved integer and xmm registers. */
385 
386  /* These two next fields are set only for machine info frames. */
387 
388  /* Likewise for RIP. */
390 
391  /* Likewise for RSP. */
393 
394  /* Address of the previous frame. */
396 };
397 
398 /* Convert a Windows register number to gdb. */
399 static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =
400 {
417 };
418 
419 /* Return TRUE iff PC is the the range of the function corresponding to
420  CACHE. */
421 
422 static int
424 {
425  return (pc >= cache->image_base + cache->start_rva
426  && pc < cache->image_base + cache->end_rva);
427 }
428 
429 /* Try to recognize and decode an epilogue sequence.
430 
431  Return -1 if we fail to read the instructions for any reason.
432  Return 1 if an epilogue sequence was recognized, 0 otherwise. */
433 
434 static int
436  struct amd64_windows_frame_cache *cache)
437 {
438  /* According to MSDN an epilogue "must consist of either an add RSP,constant
439  or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
440  register pops and a return or a jmp".
441 
442  Furthermore, according to RtlVirtualUnwind, the complete list of
443  epilog marker is:
444  - ret [c3]
445  - ret n [c2 imm16]
446  - rep ret [f3 c3]
447  - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
448  - jmp qword ptr imm32 - not handled
449  - rex.w jmp reg [4X ff eY]
450  */
451 
452  CORE_ADDR pc = cache->pc;
453  CORE_ADDR cur_sp = cache->sp;
454  struct gdbarch *gdbarch = get_frame_arch (this_frame);
455  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
456  gdb_byte op;
457  gdb_byte rex;
458 
459  /* We don't care about the instruction deallocating the frame:
460  if it hasn't been executed, the pc is still in the body,
461  if it has been executed, the following epilog decoding will work. */
462 
463  /* First decode:
464  - pop reg [41 58-5f] or [58-5f]. */
465 
466  while (1)
467  {
468  /* Read opcode. */
469  if (target_read_memory (pc, &op, 1) != 0)
470  return -1;
471 
472  if (op >= 0x40 && op <= 0x4f)
473  {
474  /* REX prefix. */
475  rex = op;
476 
477  /* Read opcode. */
478  if (target_read_memory (pc + 1, &op, 1) != 0)
479  return -1;
480  }
481  else
482  rex = 0;
483 
484  if (op >= 0x58 && op <= 0x5f)
485  {
486  /* pop reg */
487  gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);
488 
489  cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
490  cur_sp += 8;
491  }
492  else
493  break;
494 
495  /* Allow the user to break this loop. This shouldn't happen as the
496  number of consecutive pop should be small. */
497  QUIT;
498  }
499 
500  /* Then decode the marker. */
501 
502  /* Read opcode. */
503  if (target_read_memory (pc, &op, 1) != 0)
504  return -1;
505 
506  switch (op)
507  {
508  case 0xc3:
509  /* Ret. */
510  cache->prev_rip_addr = cur_sp;
511  cache->prev_sp = cur_sp + 8;
512  return 1;
513 
514  case 0xeb:
515  {
516  /* jmp rel8 */
517  gdb_byte rel8;
518  CORE_ADDR npc;
519 
520  if (target_read_memory (pc + 1, &rel8, 1) != 0)
521  return -1;
522  npc = pc + 2 + (signed char) rel8;
523 
524  /* If the jump is within the function, then this is not a marker,
525  otherwise this is a tail-call. */
526  return !pc_in_range (npc, cache);
527  }
528 
529  case 0xec:
530  {
531  /* jmp rel32 */
532  gdb_byte rel32[4];
533  CORE_ADDR npc;
534 
535  if (target_read_memory (pc + 1, rel32, 4) != 0)
536  return -1;
537  npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
538 
539  /* If the jump is within the function, then this is not a marker,
540  otherwise this is a tail-call. */
541  return !pc_in_range (npc, cache);
542  }
543 
544  case 0xc2:
545  {
546  /* ret n */
547  gdb_byte imm16[2];
548 
549  if (target_read_memory (pc + 1, imm16, 2) != 0)
550  return -1;
551  cache->prev_rip_addr = cur_sp;
552  cache->prev_sp = cur_sp
553  + extract_unsigned_integer (imm16, 4, byte_order);
554  return 1;
555  }
556 
557  case 0xf3:
558  {
559  /* rep; ret */
560  gdb_byte op1;
561 
562  if (target_read_memory (pc + 2, &op1, 1) != 0)
563  return -1;
564  if (op1 != 0xc3)
565  return 0;
566 
567  cache->prev_rip_addr = cur_sp;
568  cache->prev_sp = cur_sp + 8;
569  return 1;
570  }
571 
572  case 0x40:
573  case 0x41:
574  case 0x42:
575  case 0x43:
576  case 0x44:
577  case 0x45:
578  case 0x46:
579  case 0x47:
580  case 0x48:
581  case 0x49:
582  case 0x4a:
583  case 0x4b:
584  case 0x4c:
585  case 0x4d:
586  case 0x4e:
587  case 0x4f:
588  /* Got a REX prefix, read next byte. */
589  rex = op;
590  if (target_read_memory (pc + 1, &op, 1) != 0)
591  return -1;
592 
593  if (op == 0xff)
594  {
595  /* rex jmp reg */
596  gdb_byte op1;
597  unsigned int reg;
598  gdb_byte buf[8];
599 
600  if (target_read_memory (pc + 2, &op1, 1) != 0)
601  return -1;
602  return (op1 & 0xf8) == 0xe0;
603  }
604  else
605  return 0;
606 
607  default:
608  /* Not REX, so unknown. */
609  return 0;
610  }
611 }
612 
613 /* Decode and execute unwind insns at UNWIND_INFO. */
614 
615 static void
617  struct amd64_windows_frame_cache *cache,
618  CORE_ADDR unwind_info)
619 {
620  CORE_ADDR save_addr = 0;
621  CORE_ADDR cur_sp = cache->sp;
622  struct gdbarch *gdbarch = get_frame_arch (this_frame);
623  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
624  int first = 1;
625 
626  /* There are at least 3 possibilities to share an unwind info entry:
627  1. Two different runtime_function entries (in .pdata) can point to the
628  same unwind info entry. There is no such indication while unwinding,
629  so we don't really care about that case. We suppose this scheme is
630  used to save memory when the unwind entries are exactly the same.
631  2. Chained unwind_info entries, with no unwind codes (no prologue).
632  There is a major difference with the previous case: the pc range for
633  the function is different (in case 1, the pc range comes from the
634  runtime_function entry; in case 2, the pc range for the chained entry
635  comes from the first unwind entry). Case 1 cannot be used instead as
636  the pc is not in the prologue. This case is officially documented.
637  (There might be unwind code in the first unwind entry to handle
638  additional unwinding). GCC (at least until gcc 5.0) doesn't chain
639  entries.
640  3. Undocumented unwind info redirection. Hard to know the exact purpose,
641  so it is considered as a memory optimization of case 2.
642  */
643 
644  if (unwind_info & 1)
645  {
646  /* Unofficially documented unwind info redirection, when UNWIND_INFO
647  address is odd (http://www.codemachine.com/article_x64deepdive.html).
648  */
649  struct external_pex64_runtime_function d;
650  CORE_ADDR sa, ea;
651 
652  if (target_read_memory (cache->image_base + (unwind_info & ~1),
653  (gdb_byte *) &d, sizeof (d)) != 0)
654  return;
655 
656  cache->start_rva
657  = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
658  cache->end_rva
659  = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
660  unwind_info
661  = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
662  }
663 
664  while (1)
665  {
666  struct external_pex64_unwind_info ex_ui;
667  /* There are at most 256 16-bit unwind insns. */
668  gdb_byte insns[2 * 256];
669  gdb_byte *p;
670  gdb_byte *end_insns;
671  unsigned char codes_count;
672  unsigned char frame_reg;
673  unsigned char frame_off;
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)
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)
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)
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)
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)
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  struct obj_section *sec;
1019  pe_data_type *pe;
1020  IMAGE_DATA_DIRECTORY *dir;
1021  CORE_ADDR image_base;
1022  CORE_ADDR pc;
1023  struct objfile *objfile;
1024  unsigned long lo, hi;
1025  CORE_ADDR unwind_info = 0;
1026 
1027  if (*this_cache)
1028  return *this_cache;
1029 
1031  *this_cache = cache;
1032 
1033  /* Get current PC and SP. */
1034  pc = get_frame_pc (this_frame);
1035  get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
1036  cache->sp = extract_unsigned_integer (buf, 8, byte_order);
1037  cache->pc = pc;
1038 
1039  if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1040  &cache->image_base,
1041  &cache->start_rva,
1042  &cache->end_rva))
1043  return cache;
1044 
1045  if (unwind_info == 0)
1046  {
1047  /* Assume a leaf function. */
1048  cache->prev_sp = cache->sp + 8;
1049  cache->prev_rip_addr = cache->sp;
1050  }
1051  else
1052  {
1053  /* Decode unwind insns to compute saved addresses. */
1054  amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1055  }
1056  return cache;
1057 }
1058 
1059 /* Implement the "prev_register" method of struct frame_unwind
1060  using the standard Windows x64 SEH info. */
1061 
1062 static struct value *
1064  void **this_cache, int regnum)
1065 {
1066  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1067  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1068  struct amd64_windows_frame_cache *cache =
1069  amd64_windows_frame_cache (this_frame, this_cache);
1070  struct value *val;
1071  CORE_ADDR prev;
1072 
1073  if (frame_debug)
1075  "amd64_windows_frame_prev_register %s for sp=%s\n",
1076  gdbarch_register_name (gdbarch, regnum),
1077  paddress (gdbarch, cache->prev_sp));
1078 
1079  if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1080  prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1081  else if (regnum == AMD64_RSP_REGNUM)
1082  {
1083  prev = cache->prev_rsp_addr;
1084  if (prev == 0)
1085  return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1086  }
1087  else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1088  prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1089  else if (regnum == AMD64_RIP_REGNUM)
1090  prev = cache->prev_rip_addr;
1091  else
1092  prev = 0;
1093 
1094  if (prev && frame_debug)
1095  fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, prev));
1096 
1097  if (prev)
1098  {
1099  /* Register was saved. */
1100  return frame_unwind_got_memory (this_frame, regnum, prev);
1101  }
1102  else
1103  {
1104  /* Register is either volatile or not modified. */
1105  return frame_unwind_got_register (this_frame, regnum, regnum);
1106  }
1107 }
1108 
1109 /* Implement the "this_id" method of struct frame_unwind using
1110  the standard Windows x64 SEH info. */
1111 
1112 static void
1113 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1114  struct frame_id *this_id)
1115 {
1116  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1117  struct amd64_windows_frame_cache *cache =
1118  amd64_windows_frame_cache (this_frame, this_cache);
1119 
1120  *this_id = frame_id_build (cache->prev_sp,
1121  cache->image_base + cache->start_rva);
1122 }
1123 
1124 /* Windows x64 SEH unwinder. */
1125 
1126 static const struct frame_unwind amd64_windows_frame_unwind =
1127 {
1128  NORMAL_FRAME,
1132  NULL,
1134 };
1135 
1136 /* Implement the "skip_prologue" gdbarch method. */
1137 
1138 static CORE_ADDR
1139 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1140 {
1141  CORE_ADDR func_addr;
1142  CORE_ADDR unwind_info = 0;
1143  CORE_ADDR image_base, start_rva, end_rva;
1144  struct external_pex64_unwind_info ex_ui;
1145 
1146  /* Use prologue size from unwind info. */
1147  if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1148  &image_base, &start_rva, &end_rva) == 0)
1149  {
1150  if (unwind_info == 0)
1151  {
1152  /* Leaf function. */
1153  return pc;
1154  }
1155  else if (target_read_memory (image_base + unwind_info,
1156  (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1157  && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1158  return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1159  }
1160 
1161  /* See if we can determine the end of the prologue via the symbol
1162  table. If so, then return either the PC, or the PC after
1163  the prologue, whichever is greater. */
1164  if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1165  {
1166  CORE_ADDR post_prologue_pc
1167  = skip_prologue_using_sal (gdbarch, func_addr);
1168 
1169  if (post_prologue_pc != 0)
1170  return max (pc, post_prologue_pc);
1171  }
1172 
1173  return pc;
1174 }
1175 
1176 /* Check Win64 DLL jmp trampolines and find jump destination. */
1177 
1178 static CORE_ADDR
1180 {
1181  CORE_ADDR destination = 0;
1182  struct gdbarch *gdbarch = get_frame_arch (frame);
1183  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1184 
1185  /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1186  if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1187  {
1188  /* Get opcode offset and see if we can find a reference in our data. */
1190  = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1191 
1192  /* Get address of function pointer at end of pc. */
1193  CORE_ADDR indirect_addr = pc + offset + 6;
1194 
1195  struct minimal_symbol *indsym
1196  = (indirect_addr
1197  ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1198  : NULL);
1199  const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
1200 
1201  if (symname)
1202  {
1203  if (startswith (symname, "__imp_")
1204  || startswith (symname, "_imp_"))
1205  destination
1206  = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1207  }
1208  }
1209 
1210  return destination;
1211 }
1212 
1213 /* Implement the "auto_wide_charset" gdbarch method. */
1214 
1215 static const char *
1217 {
1218  return "UTF-16";
1219 }
1220 
1221 static void
1222 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1223 {
1224  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1225 
1226  /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1227  preferred over the SEH one. The reasons are:
1228  - binaries without SEH but with dwarf2 debug info are correcly handled
1229  (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1230  info).
1231  - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1232  handled if the dwarf2 unwinder is used).
1233 
1234  The call to amd64_init_abi appends default unwinders, that aren't
1235  compatible with the SEH one.
1236  */
1237  frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1238 
1239  amd64_init_abi (info, gdbarch);
1240 
1241  windows_init_abi (info, gdbarch);
1242 
1243  /* On Windows, "long"s are only 32bit. */
1244  set_gdbarch_long_bit (gdbarch, 32);
1245 
1246  /* Function calls. */
1252 
1254 
1256 }
1257 
1258 /* -Wmissing-prototypes */
1260 
1261 void
1263 {
1264  gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1266 }
static CORE_ADDR amd64_windows_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void amd64_windows_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
void set_gdbarch_skip_main_prologue(struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype skip_main_prologue)
Definition: gdbarch.c:2614
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
amd64_regnum
Definition: amd64-tdep.h:32
struct value * value_addr(struct value *arg1)
Definition: valops.c:1472
static struct value * amd64_windows_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3529
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
static CORE_ADDR amd64_windows_adjust_args_passed_by_pointer(struct value **args, int nargs, CORE_ADDR sp)
return_value_convention
Definition: defs.h:206
static CORE_ADDR amd64_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3882
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static int amd64_windows_passed_by_pointer(struct type *type)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
enum register_status regcache_raw_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:995
static CORE_ADDR amd64_windows_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
static int amd64_windows_dummy_call_integer_regs[]
void initialize_file_ftype(void)
Definition: defs.h:281
static int pc_in_range(CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
static void amd64_windows_store_arg_in_reg(struct regcache *regcache, struct value *arg, int regno)
static int amd64_windows_frame_decode_epilogue(struct frame_info *this_frame, struct amd64_windows_frame_cache *cache)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
void set_gdbarch_auto_wide_charset(struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype auto_wide_charset)
Definition: gdbarch.c:4441
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static int amd64_windows_passed_by_integer_register(struct type *type)
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
#define min(a, b)
Definition: defs.h:106
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
static CORE_ADDR amd64_windows_push_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp, int struct_return)
int regnum
Definition: aarch64-tdep.c:69
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
static const char * amd64_windows_auto_wide_charset(void)
struct ui_file * gdb_stdlog
Definition: main.c:73
Definition: regdef.h:22
static struct amd64_windows_frame_cache * amd64_windows_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: value.c:172
static int amd64_windows_passed_by_xmm_register(struct type *type)
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1006
bfd_byte gdb_byte
Definition: common-types.h:38
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
#define max(a, b)
Definition: defs.h:109
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
void amd64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: amd64-tdep.c:2937
void windows_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: windows-tdep.c:491
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct minimal_symbol * minsym
Definition: minsyms.h:32
int offset
Definition: agent.c:65
static void amd64_windows_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1085
struct objfile * objfile
Definition: objfiles.h:124
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)
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
initialize_file_ftype _initialize_amd64_windows_tdep
struct type * value_type(const struct value *value)
Definition: value.c:1021
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1517
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
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)
static void amd64_windows_frame_decode_insns(struct frame_info *this_frame, struct amd64_windows_frame_cache *cache, CORE_ADDR unwind_info)
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
unsigned int frame_debug
Definition: frame.c:265
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
struct section_offsets * section_offsets
Definition: objfiles.h:362
#define QUIT
Definition: defs.h:160
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2590
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)
enum bfd_endian byte_order
Definition: gdbarch.c:128
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:148
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
const ULONGEST const LONGEST len
Definition: target.h:309