gdb/amd64-windows-tdep.c

   1 /* Copyright (C) 2009-2014 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.  */
  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 };
  42
  43 /* Return nonzero if an argument of type TYPE should be passed
  44    via one of the integer registers.  */
  45
  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);
  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
  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 }
  80
  81 /* Return non-zero iff an argument of the given TYPE should be passed
  82    by pointer.  */
  83
  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;
  89
  90   if (amd64_windows_passed_by_xmm_register (type))
  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
 104 amd64_windows_adjust_args_passed_by_pointer (struct value **args,
 105                                              int nargs, CORE_ADDR sp)
 106 {
 107   int i;
 108
 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);
 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         {
 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         }
 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
 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];
 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         }
 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 }
 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               && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
 359               && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
 360             pc += 5;
 361         }
 362     }
 363
 364   return pc;
 365 }
 366
 367 struct amd64_windows_frame_cache
 368 {
 369   /* ImageBase for the module.  */
 370   CORE_ADDR image_base;
 371
 372   /* Function start and end rva.  */
 373   CORE_ADDR start_rva;
 374   CORE_ADDR end_rva;
 375
 376   /* Next instruction to be executed.  */
 377   CORE_ADDR pc;
 378
 379   /* Current sp.  */
 380   CORE_ADDR sp;
 381
 382   /* Address of saved integer and xmm registers.  */
 383   CORE_ADDR prev_reg_addr[16];
 384   CORE_ADDR prev_xmm_addr[16];
 385
 386   /* These two next fields are set only for machine info frames.  */
 387
 388   /* Likewise for RIP.  */
 389   CORE_ADDR prev_rip_addr;
 390
 391   /* Likewise for RSP.  */
 392   CORE_ADDR prev_rsp_addr;
 393
 394   /* Address of the previous frame.  */
 395   CORE_ADDR prev_sp;
 396 };
 397
 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 };
 418
 419 /* Return TRUE iff PC is the the range of the function corresponding to
 420    CACHE.  */
 421
 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 }
 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
 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".
 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
 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;
 625
 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;
 636
 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;
 641
 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);
 650
 651       /* Check version.  */
 652       if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
 653           && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
 654         return;
 655
 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;
 667
 668           /* Not in an epilog.  Clear possible side effects.  */
 669           memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
 670         }
 671
 672       codes_count = ex_ui.CountOfCodes;
 673       frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
 674
 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];
 682
 683           get_frame_register (this_frame, frreg, buf);
 684           save_addr = extract_unsigned_integer (buf, 8, byte_order);
 685
 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         }
 691
 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;
 698
 699       end_insns = &insns[codes_count * 2];
 700       p = insns;
 701
 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         }
 709
 710       for (; p < end_insns; p += 2)
 711         {
 712           int reg;
 713
 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]);
 718
 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;
 726
 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             }
 791
 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;
 827
 828           chain_vma = cache->image_base + unwind_info
 829             + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2 + 8;
 830
 831           if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
 832             return;
 833
 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);
 840         }
 841
 842       /* Allow the user to break this loop.  */
 843       QUIT;
 844     }
 845   /* PC is saved by the call.  */
 846   if (cache->prev_rip_addr == 0)
 847     cache->prev_rip_addr = cur_sp;
 848   cache->prev_sp = cur_sp + 8;
 849
 850   if (frame_debug)
 851     fprintf_unfiltered (gdb_stdlog, "   prev_sp: %s, prev_pc @%s\n",
 852                         paddress (gdbarch, cache->prev_sp),
 853                         paddress (gdbarch, cache->prev_rip_addr));
 854 }
 855
 856 /* Find SEH unwind info for PC, returning 0 on success.
 857
 858    UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
 859    to the base address of the corresponding image, and START_RVA
 860    to the rva of the function containing PC.  */
 861
 862 static int
 863 amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
 864                                 CORE_ADDR *unwind_info,
 865                                 CORE_ADDR *image_base,
 866                                 CORE_ADDR *start_rva,
 867                                 CORE_ADDR *end_rva)
 868 {
 869   struct obj_section *sec;
 870   pe_data_type *pe;
 871   IMAGE_DATA_DIRECTORY *dir;
 872   struct objfile *objfile;
 873   unsigned long lo, hi;
 874   CORE_ADDR base;
 875   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 876
 877   /* Get the corresponding exception directory.  */
 878   sec = find_pc_section (pc);
 879   if (sec == NULL)
 880     return -1;
 881   objfile = sec->objfile;
 882   pe = pe_data (sec->objfile->obfd);
 883   dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
 884
 885   base = pe->pe_opthdr.ImageBase
 886     + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 887   *image_base = base;
 888
 889   /* Find the entry.
 890
 891      Note: This does not handle dynamically added entries (for JIT
 892      engines).  For this, we would need to ask the kernel directly,
 893      which means getting some info from the native layer.  For the
 894      rest of the code, however, it's probably faster to search
 895      the entry ourselves.  */
 896   lo = 0;
 897   hi = dir->Size / sizeof (struct external_pex64_runtime_function);
 898   *unwind_info = 0;
 899   while (lo <= hi)
 900     {
 901       unsigned long mid = lo + (hi - lo) / 2;
 902       struct external_pex64_runtime_function d;
 903       CORE_ADDR sa, ea;
 904
 905       if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
 906                               (gdb_byte *) &d, sizeof (d)) != 0)
 907         return -1;
 908
 909       sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 910       ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 911       if (pc < base + sa)
 912         hi = mid - 1;
 913       else if (pc >= base + ea)
 914         lo = mid + 1;
 915       else if (pc >= base + sa && pc < base + ea)
 916         {
 917           /* Got it.  */
 918           *start_rva = sa;
 919           *end_rva = ea;
 920           *unwind_info =
 921             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 922           break;
 923         }
 924       else
 925         break;
 926     }
 927
 928   if (frame_debug)
 929     fprintf_unfiltered
 930       (gdb_stdlog,
 931        "amd64_windows_find_unwind_data:  image_base=%s, unwind_data=%s\n",
 932        paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
 933
 934   if (*unwind_info & 1)
 935     {
 936       /* Unofficially documented unwind info redirection, when UNWIND_INFO
 937          address is odd (http://www.codemachine.com/article_x64deepdive.html).
 938       */
 939       struct external_pex64_runtime_function d;
 940       CORE_ADDR sa, ea;
 941
 942       if (target_read_memory (base + (*unwind_info & ~1),
 943                               (gdb_byte *) &d, sizeof (d)) != 0)
 944         return -1;
 945
 946       *start_rva =
 947         extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 948       *end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 949       *unwind_info =
 950         extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 951
 952     }
 953   return 0;
 954 }
 955
 956 /* Fill THIS_CACHE using the native amd64-windows unwinding data
 957    for THIS_FRAME.  */
 958
 959 static struct amd64_windows_frame_cache *
 960 amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
 961 {
 962   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 963   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 964   struct amd64_windows_frame_cache *cache;
 965   gdb_byte buf[8];
 966   struct obj_section *sec;
 967   pe_data_type *pe;
 968   IMAGE_DATA_DIRECTORY *dir;
 969   CORE_ADDR image_base;
 970   CORE_ADDR pc;
 971   struct objfile *objfile;
 972   unsigned long lo, hi;
 973   CORE_ADDR unwind_info = 0;
 974
 975   if (*this_cache)
 976     return *this_cache;
 977
 978   cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
 979   *this_cache = cache;
 980
 981   /* Get current PC and SP.  */
 982   pc = get_frame_pc (this_frame);
 983   get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
 984   cache->sp = extract_unsigned_integer (buf, 8, byte_order);
 985   cache->pc = pc;
 986
 987   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
 988                                       &cache->image_base,
 989                                       &cache->start_rva,
 990                                       &cache->end_rva))
 991     return cache;
 992
 993   if (unwind_info == 0)
 994     {
 995       /* Assume a leaf function.  */
 996       cache->prev_sp = cache->sp + 8;
 997       cache->prev_rip_addr = cache->sp;
 998     }
 999   else
1000     {
1001       /* Decode unwind insns to compute saved addresses.  */
1002       amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1003     }
1004   return cache;
1005 }
1006
1007 /* Implement the "prev_register" method of struct frame_unwind
1008    using the standard Windows x64 SEH info.  */
1009
1010 static struct value *
1011 amd64_windows_frame_prev_register (struct frame_info *this_frame,
1012                                    void **this_cache, int regnum)
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     amd64_windows_frame_cache (this_frame, this_cache);
1018   struct value *val;
1019   CORE_ADDR prev;
1020
1021   if (frame_debug)
1022     fprintf_unfiltered (gdb_stdlog,
1023                         "amd64_windows_frame_prev_register %s for sp=%s\n",
1024                         gdbarch_register_name (gdbarch, regnum),
1025                         paddress (gdbarch, cache->prev_sp));
1026
1027   if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1028       prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1029   else if (regnum == AMD64_RSP_REGNUM)
1030     {
1031       prev = cache->prev_rsp_addr;
1032       if (prev == 0)
1033         return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1034     }
1035   else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1036     prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1037   else if (regnum == AMD64_RIP_REGNUM)
1038     prev = cache->prev_rip_addr;
1039   else
1040     prev = 0;
1041
1042   if (prev && frame_debug)
1043     fprintf_unfiltered (gdb_stdlog, "  -> at %s\n", paddress (gdbarch, prev));
1044
1045   if (prev)
1046     {
1047       /* Register was saved.  */
1048       return frame_unwind_got_memory (this_frame, regnum, prev);
1049     }
1050   else
1051     {
1052       /* Register is either volatile or not modified.  */
1053       return frame_unwind_got_register (this_frame, regnum, regnum);
1054     }
1055 }
1056
1057 /* Implement the "this_id" method of struct frame_unwind using
1058    the standard Windows x64 SEH info.  */
1059
1060 static void
1061 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1062                    struct frame_id *this_id)
1063 {
1064   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1065   struct amd64_windows_frame_cache *cache =
1066     amd64_windows_frame_cache (this_frame, this_cache);
1067
1068   *this_id = frame_id_build (cache->prev_sp,
1069                              cache->image_base + cache->start_rva);
1070 }
1071
1072 /* Windows x64 SEH unwinder.  */
1073
1074 static const struct frame_unwind amd64_windows_frame_unwind =
1075 {
1076   NORMAL_FRAME,
1077   default_frame_unwind_stop_reason,
1078   &amd64_windows_frame_this_id,
1079   &amd64_windows_frame_prev_register,
1080   NULL,
1081   default_frame_sniffer
1082 };
1083
1084 /* Implement the "skip_prologue" gdbarch method.  */
1085
1086 static CORE_ADDR
1087 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1088 {
1089   CORE_ADDR func_addr;
1090   CORE_ADDR unwind_info = 0;
1091   CORE_ADDR image_base, start_rva, end_rva;
1092   struct external_pex64_unwind_info ex_ui;
1093
1094   /* Use prologue size from unwind info.  */
1095   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1096                                       &image_base, &start_rva, &end_rva) == 0)
1097     {
1098       if (unwind_info == 0)
1099         {
1100           /* Leaf function.  */
1101           return pc;
1102         }
1103       else if (target_read_memory (image_base + unwind_info,
1104                                    (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1105                && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1106         return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1107     }
1108
1109   /* See if we can determine the end of the prologue via the symbol
1110      table.  If so, then return either the PC, or the PC after
1111      the prologue, whichever is greater.  */
1112   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1113     {
1114       CORE_ADDR post_prologue_pc
1115         = skip_prologue_using_sal (gdbarch, func_addr);
1116
1117       if (post_prologue_pc != 0)
1118         return max (pc, post_prologue_pc);
1119     }
1120
1121   return pc;
1122 }
1123
1124 /* Check Win64 DLL jmp trampolines and find jump destination.  */
1125
1126 static CORE_ADDR
1127 amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1128 {
1129   CORE_ADDR destination = 0;
1130   struct gdbarch *gdbarch = get_frame_arch (frame);
1131   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1132
1133   /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)).  */
1134   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1135     {
1136       /* Get opcode offset and see if we can find a reference in our data.  */
1137       ULONGEST offset
1138         = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1139
1140       /* Get address of function pointer at end of pc.  */
1141       CORE_ADDR indirect_addr = pc + offset + 6;
1142
1143       struct minimal_symbol *indsym
1144         = (indirect_addr
1145            ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1146            : NULL);
1147       const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : NULL;
1148
1149       if (symname)
1150         {
1151           if (strncmp (symname, "__imp_", 6) == 0
1152               || strncmp (symname, "_imp_", 5) == 0)
1153             destination
1154               = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1155         }
1156     }
1157
1158   return destination;
1159 }
1160
1161 /* Implement the "auto_wide_charset" gdbarch method.  */
1162
1163 static const char *
1164 amd64_windows_auto_wide_charset (void)
1165 {
1166   return "UTF-16";
1167 }
1168
1169 static void
1170 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1171 {
1172   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1173
1174   /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1175      preferred over the SEH one.  The reasons are:
1176      - binaries without SEH but with dwarf2 debug info are correcly handled
1177        (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1178        info).
1179      - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1180        handled if the dwarf2 unwinder is used).
1181
1182     The call to amd64_init_abi appends default unwinders, that aren't
1183     compatible with the SEH one.
1184   */
1185   frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1186
1187   amd64_init_abi (info, gdbarch);
1188
1189   windows_init_abi (info, gdbarch);
1190
1191   /* On Windows, "long"s are only 32bit.  */
1192   set_gdbarch_long_bit (gdbarch, 32);
1193
1194   /* Function calls.  */
1195   set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
1196   set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
1197   set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
1198   set_gdbarch_skip_trampoline_code (gdbarch,
1199                                     amd64_windows_skip_trampoline_code);
1200
1201   set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1202
1203   set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1204 }
1205
1206 /* -Wmissing-prototypes */
1207 extern initialize_file_ftype _initialize_amd64_windows_tdep;
1208
1209 void
1210 _initialize_amd64_windows_tdep (void)
1211 {
1212   gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1213                           amd64_windows_init_abi);
1214 }