gdb/amd64-windows-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Copyright (C) 2009-2015 Free Software Foundation, Inc.

  3.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  34. /* The registers used to pass integer arguments during a function call.  */
  35. ‌static int amd64_windows_dummy_call_integer_regs[] =
  36. {
  37.   AMD64_RCX_REGNUM,          /* %rcx */
  38.   AMD64_RDX_REGNUM,          /* %rdx */
  39.   AMD64_R8_REGNUM,           /* %r8 */
  40.   AMD64_R9_REGNUM            /* %r9 */
  41. };

  43. /* Return nonzero if an argument of type TYPE should be passed
  44.    via one of the integer registers.  */

  46. static int
  47. ‌amd64_windows_passed_by_integer_register (struct type *type)
  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);

  65.       default:
  66.         return 0;
  67.     }
  68. }

  70. /* Return nonzero if an argument of type TYPE should be passed
  71.    via one of the XMM registers.  */

  73. static int
  74. ‌amd64_windows_passed_by_xmm_register (struct type *type)
  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. }

  81. /* Return non-zero iff an argument of the given TYPE should be passed
  82.    by pointer.  */

  84. static int
  85. ‌amd64_windows_passed_by_pointer (struct type *type)
  86. {
  87.   if (amd64_windows_passed_by_integer_register (type))
  88.     return 0;

  90.   if (amd64_windows_passed_by_xmm_register (type))
  91.     return 0;

  93.   return 1;
  94. }

  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.

  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.  */

  103. static CORE_ADDR
  104. ‌amd64_windows_adjust_args_passed_by_pointer (struct value **args,
  105.                                              int nargs, CORE_ADDR sp)
  106. {
  107.   int i;

  109.   for (i = 0; i < nargs; i++)
  110.     if (amd64_windows_passed_by_pointer (value_type (args[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);

  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.  */

  120.         sp -= len;
  121.         sp &= ~0xf;
  122.         write_memory (sp, valbuf, len);

  124.         args[i]
  125.           = value_addr (value_from_contents_and_address (type, valbuf, sp));
  126.       }

  128.   return sp;
  129. }

  131. /* Store the value of ARG in register REGNO (right-justified).
  132.    REGCACHE is the register cache.  */

  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];

  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. }

  148. /* Push the arguments for an inferior function call, and return
  149.    the updated value of the SP (Stack Pointer).

  151.    All arguments are identical to the arguments used in
  152.    amd64_windows_push_dummy_call.  */

  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;

  166.   /* First, handle the arguments passed by pointer.

  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 *));

  174.     memcpy (args1, args, nargs * sizeof (struct value *));
  175.     sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);
  176.     args = args1;
  177.   }

  179.   /* Reserve a register for the "hidden" argument.  */
  180.   if (struct_return)
  181.     reg_idx++;

  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;

  189.       if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs))
  190.         {
  191.           if (amd64_windows_passed_by_integer_register (type))
  192.             {
  193.               amd64_windows_store_arg_in_reg
  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.             {
  201.               amd64_windows_store_arg_in_reg
  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.  */
  205.               amd64_windows_store_arg_in_reg
  206.                 (regcache, args[i],
  207.                  amd64_windows_dummy_call_integer_regs[reg_idx]);
  208.               on_stack_p = 0;
  209.               reg_idx++;
  210.             }
  211.         }

  213.       if (on_stack_p)
  214.         {
  215.           num_elements += ((len + 7) / 8);
  216.           stack_args[num_stack_args++] = args[i];
  217.         }
  218.     }

  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;

  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]);

  231.       write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type));
  232.       element += ((TYPE_LENGTH (type) + 7) / 8);
  233.     }

  235.   return sp;
  236. }

  238. /* Implement the "push_dummy_call" gdbarch method.  */

  240. static CORE_ADDR
  241. ‌amd64_windows_push_dummy_call
  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];

  250.   /* Pass arguments.  */
  251.   sp = amd64_windows_push_arguments (regcache, nargs, args, sp,
  252.                                      struct_return);

  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];

  261.       store_unsigned_integer (buf, 8, byte_order, struct_addr);
  262.       regcache_cooked_write (regcache, arg_regnum, buf);
  263.     }

  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;

  269.   /* Store return address.  */
  270.   sp -= 8;
  271.   store_unsigned_integer (buf, 8, byte_order, bp_addr);
  272.   write_memory (sp, buf, 8);

  274.   /* Update the stack pointer...  */
  275.   store_unsigned_integer (buf, 8, byte_order, sp);
  276.   regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);

  278.   /* ...and fake a frame pointer.  */
  279.   regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);

  281.   return sp + 16;
  282. }

  284. /* Implement the "return_value" gdbarch method for amd64-windows.  */

  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;

  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.     }

  313.   if (regnum < 0)
  314.     {
  315.       /* RAX contains the address where the return value has been stored.  */
  316.       if (readbuf)
  317.         {
  318.           ULONGEST addr;

  320.           regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
  321.           read_memory (addr, readbuf, TYPE_LENGTH (type));
  322.         }
  323.       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
  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);
  332.       return RETURN_VALUE_REGISTER_CONVENTION;
  333.     }
  334. }

  336. /* Check that the code pointed to by PC corresponds to a call to
  337.    __main, skip it if so.  Return PC otherwise.  */

  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;

  345.   target_read_memory (pc, &op, 1);
  346.   if (op == 0xe8)
  347.     {
  348.       gdb_byte buf[4];

  350.       if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
  351.          {
  352.            struct bound_minimal_symbol s;
  353.            CORE_ADDR call_dest;

  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.     }

  364.   return pc;
  365. }

  367. ‌struct amd64_windows_frame_cache
  368. {
  369.   /* ImageBase for the module.  */
  370.   CORE_ADDR image_base;

  372.   /* Function start and end rva.  */
  373.   CORE_ADDR start_rva;
  374.   CORE_ADDR end_rva;

  376.   /* Next instruction to be executed.  */
  377.   CORE_ADDR pc;

  379.   /* Current sp.  */
  380.   CORE_ADDR sp;

  382.   /* Address of saved integer and xmm registers.  */
  383.   CORE_ADDR prev_reg_addr[16];
  384.   CORE_ADDR prev_xmm_addr[16];

  386.   /* These two next fields are set only for machine info frames.  */

  388.   /* Likewise for RIP.  */
  389.   CORE_ADDR prev_rip_addr;

  391.   /* Likewise for RSP.  */
  392.   CORE_ADDR prev_rsp_addr;

  394.   /* Address of the previous frame.  */
  395.   CORE_ADDR prev_sp;
  396. };

  398. /* Convert a Windows register number to gdb.  */
  399. ‌static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =
  400. {
  401.   AMD64_RAX_REGNUM,
  402.   AMD64_RCX_REGNUM,
  403.   AMD64_RDX_REGNUM,
  404.   AMD64_RBX_REGNUM,
  405.   AMD64_RSP_REGNUM,
  406.   AMD64_RBP_REGNUM,
  407.   AMD64_RSI_REGNUM,
  408.   AMD64_RDI_REGNUM,
  409.   AMD64_R8_REGNUM,
  410.   AMD64_R9_REGNUM,
  411.   AMD64_R10_REGNUM,
  412.   AMD64_R11_REGNUM,
  413.   AMD64_R12_REGNUM,
  414.   AMD64_R13_REGNUM,
  415.   AMD64_R14_REGNUM,
  416.   AMD64_R15_REGNUM
  417. };

  419. /* Return TRUE iff PC is the the range of the function corresponding to
  420.    CACHE.  */

  422. static int
  423. ‌pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
  424. {
  425.   return (pc >= cache->image_base + cache->start_rva
  426.           && pc < cache->image_base + cache->end_rva);
  427. }

  429. /* Try to recognize and decode an epilogue sequence.

  431.    Return -1 if we fail to read the instructions for any reason.
  432.    Return 1 if an epilogue sequence was recognized, 0 otherwise.  */

  434. static int
  435. ‌amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
  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".

  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.   */

  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;

  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.  */

  463.   /* First decode:
  464.      -  pop reg                 [41 58-5f] or [58-5f].  */

  466.   while (1)
  467.     {
  468.       /* Read opcode. */
  469.       if (target_read_memory (pc, &op, 1) != 0)
  470.         return -1;

  472.       if (op >= 0x40 && op <= 0x4f)
  473.         {
  474.           /* REX prefix.  */
  475.           rex = op;

  477.           /* Read opcode. */
  478.           if (target_read_memory (pc + 1, &op, 1) != 0)
  479.             return -1;
  480.         }
  481.       else
  482.         rex = 0;

  484.       if (op >= 0x58 && op <= 0x5f)
  485.         {
  486.           /* pop reg  */
  487.           gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);

  489.           cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
  490.           cur_sp += 8;
  491.         }
  492.       else
  493.         break;

  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.     }

  500.   /* Then decode the marker.  */

  502.   /* Read opcode.  */
  503.   if (target_read_memory (pc, &op, 1) != 0)
  504.     return -1;

  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;

  514.     case 0xeb:
  515.       {
  516.         /* jmp rel8  */
  517.         gdb_byte rel8;
  518.         CORE_ADDR npc;

  520.         if (target_read_memory (pc + 1, &rel8, 1) != 0)
  521.           return -1;
  522.         npc = pc + 2 + (signed char) rel8;

  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.       }

  529.     case 0xec:
  530.       {
  531.         /* jmp rel32  */
  532.         gdb_byte rel32[4];
  533.         CORE_ADDR npc;

  535.         if (target_read_memory (pc + 1, rel32, 4) != 0)
  536.           return -1;
  537.         npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);

  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.       }

  544.     case 0xc2:
  545.       {
  546.         /* ret n  */
  547.         gdb_byte imm16[2];

  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.       }

  557.     case 0xf3:
  558.       {
  559.         /* rep; ret  */
  560.         gdb_byte op1;

  562.         if (target_read_memory (pc + 2, &op1, 1) != 0)
  563.           return -1;
  564.         if (op1 != 0xc3)
  565.           return 0;

  567.         cache->prev_rip_addr = cur_sp;
  568.         cache->prev_sp = cur_sp + 8;
  569.         return 1;
  570.       }

  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;

  593.       if (op == 0xff)
  594.         {
  595.           /* rex jmp reg  */
  596.           gdb_byte op1;
  597.           unsigned int reg;
  598.           gdb_byte buf[8];

  600.           if (target_read_memory (pc + 2, &op1, 1) != 0)
  601.             return -1;
  602.           return (op1 & 0xf8) == 0xe0;
  603.         }
  604.       else
  605.         return 0;

  607.     default:
  608.       /* Not REX, so unknown.  */
  609.       return 0;
  610.     }
  611. }

  613. /* Decode and execute unwind insns at UNWIND_INFO.  */

  615. static void
  616. ‌amd64_windows_frame_decode_insns (struct frame_info *this_frame,
  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 j;

  626.   for (j = 0; ; j++)
  627.     {
  628.       struct external_pex64_unwind_info ex_ui;
  629.       /* There are at most 256 16-bit unwind insns.  */
  630.       gdb_byte insns[2 * 256];
  631.       gdb_byte *p;
  632.       gdb_byte *end_insns;
  633.       unsigned char codes_count;
  634.       unsigned char frame_reg;
  635.       unsigned char frame_off;

  637.       /* Read and decode header.  */
  638.       if (target_read_memory (cache->image_base + unwind_info,
  639.                               (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
  640.         return;

  642.       if (frame_debug)
  643.         fprintf_unfiltered
  644.           (gdb_stdlog,
  645.            "amd64_windows_frame_decodes_insn: "
  646.            "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
  647.            paddress (gdbarch, unwind_info),
  648.            ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
  649.            ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);

  651.       /* Check version.  */
  652.       if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
  653.           && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
  654.         return;

  656.       if (j == 0
  657.           && (cache->pc >=
  658.               cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue))
  659.         {
  660.           /* Not in the prologue.  We want to detect if the PC points to an
  661.              epilogue. If so, the epilogue detection+decoding function is
  662.              sufficient.  Otherwise, the unwinder will consider that the PC
  663.              is in the body of the function and will need to decode unwind
  664.              info.  */
  665.           if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
  666.             return;

  668.           /* Not in an epilog.  Clear possible side effects.  */
  669.           memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
  670.         }

  672.       codes_count = ex_ui.CountOfCodes;
  673.       frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);

  675.       if (frame_reg != 0)
  676.         {
  677.           /* According to msdn:
  678.              If an FP reg is used, then any unwind code taking an offset must
  679.              only be used after the FP reg is established in the prolog.  */
  680.           gdb_byte buf[8];
  681.           int frreg = amd64_windows_w2gdb_regnum[frame_reg];

  683.           get_frame_register (this_frame, frreg, buf);
  684.           save_addr = extract_unsigned_integer (buf, 8, byte_order);

  686.           if (frame_debug)
  687.             fprintf_unfiltered (gdb_stdlog, "   frame_reg=%s, val=%s\n",
  688.                                 gdbarch_register_name (gdbarch, frreg),
  689.                                 paddress (gdbarch, save_addr));
  690.         }

  692.       /* Read opcodes.  */
  693.       if (codes_count != 0
  694.           && target_read_memory (cache->image_base + unwind_info
  695.                                  + sizeof (ex_ui),
  696.                                  insns, codes_count * 2) != 0)
  697.         return;

  699.       end_insns = &insns[codes_count * 2];
  700.       p = insns;

  702.       /* Skip opcodes 6 of version 2.  This opcode is not documented.  */
  703.       if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
  704.         {
  705.           for (; p < end_insns; p += 2)
  706.             if (PEX64_UNWCODE_CODE (p[1]) != 6)
  707.               break;
  708.         }

  710.       for (; p < end_insns; p += 2)
  711.         {
  712.           int reg;

  714.           if (frame_debug)
  715.             fprintf_unfiltered
  716.               (gdb_stdlog, "   op #%u: off=0x%02x, insn=0x%02x\n",
  717.                (unsigned) (p - insns), p[0], p[1]);

  719.           /* Virtually execute the operation.  */
  720.           if (cache->pc >= cache->image_base + cache->start_rva + p[0])
  721.             {
  722.               /* If there is no frame registers defined, the current value of
  723.                  rsp is used instead.  */
  724.               if (frame_reg == 0)
  725.                 save_addr = cur_sp;

  727.               switch (PEX64_UNWCODE_CODE (p[1]))
  728.                 {
  729.                 case UWOP_PUSH_NONVOL:
  730.                   /* Push pre-decrements RSP.  */
  731.                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
  732.                   cache->prev_reg_addr[reg] = cur_sp;
  733.                   cur_sp += 8;
  734.                   break;
  735.                 case UWOP_ALLOC_LARGE:
  736.                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
  737.                     cur_sp +=
  738.                       8 * extract_unsigned_integer (p + 2, 2, byte_order);
  739.                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
  740.                     cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
  741.                   else
  742.                     return;
  743.                   break;
  744.                 case UWOP_ALLOC_SMALL:
  745.                   cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
  746.                   break;
  747.                 case UWOP_SET_FPREG:
  748.                   cur_sp = save_addr
  749.                     - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
  750.                   break;
  751.                 case UWOP_SAVE_NONVOL:
  752.                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
  753.                   cache->prev_reg_addr[reg] = save_addr
  754.                     - 8 * extract_unsigned_integer (p + 2, 2, byte_order);
  755.                   break;
  756.                 case UWOP_SAVE_NONVOL_FAR:
  757.                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
  758.                   cache->prev_reg_addr[reg] = save_addr
  759.                     - 8 * extract_unsigned_integer (p + 2, 4, byte_order);
  760.                   break;
  761.                 case UWOP_SAVE_XMM128:
  762.                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
  763.                     save_addr
  764.                     - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
  765.                   break;
  766.                 case UWOP_SAVE_XMM128_FAR:
  767.                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
  768.                     save_addr
  769.                     - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
  770.                   break;
  771.                 case UWOP_PUSH_MACHFRAME:
  772.                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
  773.                     {
  774.                       cache->prev_rip_addr = cur_sp + 0;
  775.                       cache->prev_rsp_addr = cur_sp + 24;
  776.                       cur_sp += 40;
  777.                     }
  778.                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
  779.                     {
  780.                       cache->prev_rip_addr = cur_sp + 8;
  781.                       cache->prev_rsp_addr = cur_sp + 32;
  782.                       cur_sp += 48;
  783.                     }
  784.                   else
  785.                     return;
  786.                   break;
  787.                 default:
  788.                   return;
  789.                 }
  790.             }

  792.           /* Adjust with the length of the opcode.  */
  793.           switch (PEX64_UNWCODE_CODE (p[1]))
  794.             {
  795.             case UWOP_PUSH_NONVOL:
  796.             case UWOP_ALLOC_SMALL:
  797.             case UWOP_SET_FPREG:
  798.             case UWOP_PUSH_MACHFRAME:
  799.               break;
  800.             case UWOP_ALLOC_LARGE:
  801.               if (PEX64_UNWCODE_INFO (p[1]) == 0)
  802.                 p += 2;
  803.               else if (PEX64_UNWCODE_INFO (p[1]) == 1)
  804.                 p += 4;
  805.               else
  806.                 return;
  807.               break;
  808.             case UWOP_SAVE_NONVOL:
  809.             case UWOP_SAVE_XMM128:
  810.               p += 2;
  811.               break;
  812.             case UWOP_SAVE_NONVOL_FAR:
  813.             case UWOP_SAVE_XMM128_FAR:
  814.               p += 4;
  815.               break;
  816.             default:
  817.               return;
  818.             }
  819.         }
  820.       if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
  821.         break;
  822.       else
  823.         {
  824.           /* Read the chained unwind info.  */
  825.           struct external_pex64_runtime_function d;
  826.           CORE_ADDR chain_vma;

  828.           chain_vma = cache->image_base + unwind_info
  829.             + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2;

  831.           if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
  832.             return;

  834.           cache->start_rva =
  835.             extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
  836.           cache->end_rva =
  837.             extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
  838.           unwind_info =
  839.             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);

  841.           if (frame_debug)
  842.             fprintf_unfiltered
  843.               (gdb_stdlog,
  844.                "amd64_windows_frame_decodes_insn (next in chain):"
  845.                " unwind_data=%s, start_rva=%s, end_rva=%s\n",
  846.                paddress (gdbarch, unwind_info),
  847.                paddress (gdbarch, cache->start_rva),
  848.                paddress (gdbarch, cache->end_rva));
  849.         }

  851.       /* Allow the user to break this loop.  */
  852.       QUIT;
  853.     }
  854.   /* PC is saved by the call.  */
  855.   if (cache->prev_rip_addr == 0)
  856.     cache->prev_rip_addr = cur_sp;
  857.   cache->prev_sp = cur_sp + 8;

  859.   if (frame_debug)
  860.     fprintf_unfiltered (gdb_stdlog, "   prev_sp: %s, prev_pc @%s\n",
  861.                         paddress (gdbarch, cache->prev_sp),
  862.                         paddress (gdbarch, cache->prev_rip_addr));
  863. }

  865. /* Find SEH unwind info for PC, returning 0 on success.

  867.    UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
  868.    to the base address of the corresponding image, and START_RVA
  869.    to the rva of the function containing PC.  */

  871. static int
  872. ‌amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
  873.                                 CORE_ADDR *unwind_info,
  874.                                 CORE_ADDR *image_base,
  875.                                 CORE_ADDR *start_rva,
  876.                                 CORE_ADDR *end_rva)
  877. {
  878.   struct obj_section *sec;
  879.   pe_data_type *pe;
  880.   IMAGE_DATA_DIRECTORY *dir;
  881.   struct objfile *objfile;
  882.   unsigned long lo, hi;
  883.   CORE_ADDR base;
  884.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  886.   /* Get the corresponding exception directory.  */
  887.   sec = find_pc_section (pc);
  888.   if (sec == NULL)
  889.     return -1;
  890.   objfile = sec->objfile;
  891.   pe = pe_data (sec->objfile->obfd);
  892.   dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];

  894.   base = pe->pe_opthdr.ImageBase
  895.     + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
  896.   *image_base = base;

  898.   /* Find the entry.

  900.      Note: This does not handle dynamically added entries (for JIT
  901.      engines).  For this, we would need to ask the kernel directly,
  902.      which means getting some info from the native layer.  For the
  903.      rest of the code, however, it's probably faster to search
  904.      the entry ourselves.  */
  905.   lo = 0;
  906.   hi = dir->Size / sizeof (struct external_pex64_runtime_function);
  907.   *unwind_info = 0;
  908.   while (lo <= hi)
  909.     {
  910.       unsigned long mid = lo + (hi - lo) / 2;
  911.       struct external_pex64_runtime_function d;
  912.       CORE_ADDR sa, ea;

  914.       if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
  915.                               (gdb_byte *) &d, sizeof (d)) != 0)
  916.         return -1;

  918.       sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
  919.       ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
  920.       if (pc < base + sa)
  921.         hi = mid - 1;
  922.       else if (pc >= base + ea)
  923.         lo = mid + 1;
  924.       else if (pc >= base + sa && pc < base + ea)
  925.         {
  926.           /* Got it.  */
  927.           *start_rva = sa;
  928.           *end_rva = ea;
  929.           *unwind_info =
  930.             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
  931.           break;
  932.         }
  933.       else
  934.         break;
  935.     }

  937.   if (frame_debug)
  938.     fprintf_unfiltered
  939.       (gdb_stdlog,
  940.        "amd64_windows_find_unwind_data:  image_base=%s, unwind_data=%s\n",
  941.        paddress (gdbarch, base), paddress (gdbarch, *unwind_info));

  943.   if (*unwind_info & 1)
  944.     {
  945.       /* Unofficially documented unwind info redirection, when UNWIND_INFO
  946.          address is odd (http://www.codemachine.com/article_x64deepdive.html).
  947.       */
  948.       struct external_pex64_runtime_function d;
  949.       CORE_ADDR sa, ea;

  951.       if (target_read_memory (base + (*unwind_info & ~1),
  952.                               (gdb_byte *) &d, sizeof (d)) != 0)
  953.         return -1;

  955.       *start_rva =
  956.         extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
  957.       *end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
  958.       *unwind_info =
  959.         extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);

  961.     }
  962.   return 0;
  963. }

  965. /* Fill THIS_CACHE using the native amd64-windows unwinding data
  966.    for THIS_FRAME.  */

  968. static struct amd64_windows_frame_cache *
  969. ‌amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
  970. {
  971.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  972.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  973.   struct amd64_windows_frame_cache *cache;
  974.   gdb_byte buf[8];
  975.   struct obj_section *sec;
  976.   pe_data_type *pe;
  977.   IMAGE_DATA_DIRECTORY *dir;
  978.   CORE_ADDR image_base;
  979.   CORE_ADDR pc;
  980.   struct objfile *objfile;
  981.   unsigned long lo, hi;
  982.   CORE_ADDR unwind_info = 0;

  984.   if (*this_cache)
  985.     return *this_cache;

  987.   cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
  988.   *this_cache = cache;

  990.   /* Get current PC and SP.  */
  991.   pc = get_frame_pc (this_frame);
  992.   get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
  993.   cache->sp = extract_unsigned_integer (buf, 8, byte_order);
  994.   cache->pc = pc;

  996.   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
  997.                                       &cache->image_base,
  998.                                       &cache->start_rva,
  999.                                       &cache->end_rva))
  1000.     return cache;

  1002.   if (unwind_info == 0)
  1003.     {
  1004.       /* Assume a leaf function.  */
  1005.       cache->prev_sp = cache->sp + 8;
  1006.       cache->prev_rip_addr = cache->sp;
  1007.     }
  1008.   else
  1009.     {
  1010.       /* Decode unwind insns to compute saved addresses.  */
  1011.       amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
  1012.     }
  1013.   return cache;
  1014. }

  1016. /* Implement the "prev_register" method of struct frame_unwind
  1017.    using the standard Windows x64 SEH info.  */

  1019. static struct value *
  1020. ‌amd64_windows_frame_prev_register (struct frame_info *this_frame,
  1021.                                    void **this_cache, int regnum)
  1022. {
  1023.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  1024.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  1025.   struct amd64_windows_frame_cache *cache =
  1026.     amd64_windows_frame_cache (this_frame, this_cache);
  1027.   struct value *val;
  1028.   CORE_ADDR prev;

  1030.   if (frame_debug)
  1031.     fprintf_unfiltered (gdb_stdlog,
  1032.                         "amd64_windows_frame_prev_register %s for sp=%s\n",
  1033.                         gdbarch_register_name (gdbarch, regnum),
  1034.                         paddress (gdbarch, cache->prev_sp));

  1036.   if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
  1037.       prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
  1038.   else if (regnum == AMD64_RSP_REGNUM)
  1039.     {
  1040.       prev = cache->prev_rsp_addr;
  1041.       if (prev == 0)
  1042.         return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
  1043.     }
  1044.   else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
  1045.     prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
  1046.   else if (regnum == AMD64_RIP_REGNUM)
  1047.     prev = cache->prev_rip_addr;
  1048.   else
  1049.     prev = 0;

  1051.   if (prev && frame_debug)
  1052.     fprintf_unfiltered (gdb_stdlog, "  -> at %s\n", paddress (gdbarch, prev));

  1054.   if (prev)
  1055.     {
  1056.       /* Register was saved.  */
  1057.       return frame_unwind_got_memory (this_frame, regnum, prev);
  1058.     }
  1059.   else
  1060.     {
  1061.       /* Register is either volatile or not modified.  */
  1062.       return frame_unwind_got_register (this_frame, regnum, regnum);
  1063.     }
  1064. }

  1066. /* Implement the "this_id" method of struct frame_unwind using
  1067.    the standard Windows x64 SEH info.  */

  1069. static void
  1070. ‌amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
  1071.                    struct frame_id *this_id)
  1072. {
  1073.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  1074.   struct amd64_windows_frame_cache *cache =
  1075.     amd64_windows_frame_cache (this_frame, this_cache);

  1077.   *this_id = frame_id_build (cache->prev_sp,
  1078.                              cache->image_base + cache->start_rva);
  1079. }

  1081. /* Windows x64 SEH unwinder.  */

  1083. ‌static const struct frame_unwind amd64_windows_frame_unwind =
  1084. {
  1085.   NORMAL_FRAME,
  1086.   default_frame_unwind_stop_reason,
  1087.   &amd64_windows_frame_this_id,
  1088.   &amd64_windows_frame_prev_register,
  1089.   NULL,
  1090.   default_frame_sniffer
  1091. };

  1093. /* Implement the "skip_prologue" gdbarch method.  */

  1095. static CORE_ADDR
  1096. ‌amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
  1097. {
  1098.   CORE_ADDR func_addr;
  1099.   CORE_ADDR unwind_info = 0;
  1100.   CORE_ADDR image_base, start_rva, end_rva;
  1101.   struct external_pex64_unwind_info ex_ui;

  1103.   /* Use prologue size from unwind info.  */
  1104.   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
  1105.                                       &image_base, &start_rva, &end_rva) == 0)
  1106.     {
  1107.       if (unwind_info == 0)
  1108.         {
  1109.           /* Leaf function.  */
  1110.           return pc;
  1111.         }
  1112.       else if (target_read_memory (image_base + unwind_info,
  1113.                                    (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
  1114.                && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
  1115.         return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
  1116.     }

  1118.   /* See if we can determine the end of the prologue via the symbol
  1119.      table.  If so, then return either the PC, or the PC after
  1120.      the prologue, whichever is greater.  */
  1121.   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
  1122.     {
  1123.       CORE_ADDR post_prologue_pc
  1124.         = skip_prologue_using_sal (gdbarch, func_addr);

  1126.       if (post_prologue_pc != 0)
  1127.         return max (pc, post_prologue_pc);
  1128.     }

  1130.   return pc;
  1131. }

  1133. /* Check Win64 DLL jmp trampolines and find jump destination.  */

  1135. static CORE_ADDR
  1136. ‌amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
  1137. {
  1138.   CORE_ADDR destination = 0;
  1139.   struct gdbarch *gdbarch = get_frame_arch (frame);
  1140.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  1142.   /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)).  */
  1143.   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
  1144.     {
  1145.       /* Get opcode offset and see if we can find a reference in our data.  */
  1146.       ULONGEST offset
  1147.         = read_memory_unsigned_integer (pc + 2, 4, byte_order);

  1149.       /* Get address of function pointer at end of pc.  */
  1150.       CORE_ADDR indirect_addr = pc + offset + 6;

  1152.       struct minimal_symbol *indsym
  1153.         = (indirect_addr
  1154.            ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
  1155.            : NULL);
  1156.       const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;

  1158.       if (symname)
  1159.         {
  1160.           if (strncmp (symname, "__imp_", 6) == 0
  1161.               || strncmp (symname, "_imp_", 5) == 0)
  1162.             destination
  1163.               = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
  1164.         }
  1165.     }

  1167.   return destination;
  1168. }

  1170. /* Implement the "auto_wide_charset" gdbarch method.  */

  1172. static const char *
  1173. ‌amd64_windows_auto_wide_charset (void)
  1174. {
  1175.   return "UTF-16";
  1176. }

  1178. static void
  1179. ‌amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
  1180. {
  1181.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  1183.   /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
  1184.      preferred over the SEH one.  The reasons are:
  1185.      - binaries without SEH but with dwarf2 debug info are correcly handled
  1186.        (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
  1187.        info).
  1188.      - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
  1189.        handled if the dwarf2 unwinder is used).

  1191.     The call to amd64_init_abi appends default unwinders, that aren't
  1192.     compatible with the SEH one.
  1193.   */
  1194.   frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);

  1196.   amd64_init_abi (info, gdbarch);

  1198.   windows_init_abi (info, gdbarch);

  1200.   /* On Windows, "long"s are only 32bit.  */
  1201.   set_gdbarch_long_bit (gdbarch, 32);

  1203.   /* Function calls.  */
  1204.   set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
  1205.   set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
  1206.   set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
  1207.   set_gdbarch_skip_trampoline_code (gdbarch,
  1208.                                     amd64_windows_skip_trampoline_code);

  1210.   set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);

  1212.   set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
  1213. }

  1215. /* -Wmissing-prototypes */
  1216. extern initialize_file_ftype _initialize_amd64_windows_tdep;

  1218. void
  1219. ‌_initialize_amd64_windows_tdep (void)
  1220. {
  1221.   gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
  1222.                           amd64_windows_init_abi);
  1223. }