gdb/amd64-windows-tdep.c

   1 /* Copyright (C) 2009-2013 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         return;
 654
 655       if (j == 0
 656           && (cache->pc >=
 657               cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue))
 658         {
 659           /* Not in the prologue.  We want to detect if the PC points to an
 660              epilogue. If so, the epilogue detection+decoding function is
 661              sufficient.  Otherwise, the unwinder will consider that the PC
 662              is in the body of the function and will need to decode unwind
 663              info.  */
 664           if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
 665             return;
 666
 667           /* Not in an epilog.  Clear possible side effects.  */
 668           memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
 669         }
 670
 671       codes_count = ex_ui.CountOfCodes;
 672       frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
 673
 674       if (frame_reg != 0)
 675         {
 676           /* According to msdn:
 677              If an FP reg is used, then any unwind code taking an offset must
 678              only be used after the FP reg is established in the prolog.  */
 679           gdb_byte buf[8];
 680           int frreg = amd64_windows_w2gdb_regnum[frame_reg];
 681
 682           get_frame_register (this_frame, frreg, buf);
 683           save_addr = extract_unsigned_integer (buf, 8, byte_order);
 684
 685           if (frame_debug)
 686             fprintf_unfiltered (gdb_stdlog, "   frame_reg=%s, val=%s\n",
 687                                 gdbarch_register_name (gdbarch, frreg),
 688                                 paddress (gdbarch, save_addr));
 689         }
 690
 691       /* Read opcodes.  */
 692       if (codes_count != 0
 693           && target_read_memory (cache->image_base + unwind_info
 694                                  + sizeof (ex_ui),
 695                                  insns, codes_count * 2) != 0)
 696         return;
 697
 698       end_insns = &insns[codes_count * 2];
 699       for (p = insns; p < end_insns; p += 2)
 700         {
 701           int reg;
 702
 703           if (frame_debug)
 704             fprintf_unfiltered
 705               (gdb_stdlog, "   op #%u: off=0x%02x, insn=0x%02x\n",
 706                (unsigned) (p - insns), p[0], p[1]);
 707
 708           /* Virtually execute the operation.  */
 709           if (cache->pc >= cache->image_base + cache->start_rva + p[0])
 710             {
 711               /* If there is no frame registers defined, the current value of
 712                  rsp is used instead.  */
 713               if (frame_reg == 0)
 714                 save_addr = cur_sp;
 715
 716               switch (PEX64_UNWCODE_CODE (p[1]))
 717                 {
 718                 case UWOP_PUSH_NONVOL:
 719                   /* Push pre-decrements RSP.  */
 720                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 721                   cache->prev_reg_addr[reg] = cur_sp;
 722                   cur_sp += 8;
 723                   break;
 724                 case UWOP_ALLOC_LARGE:
 725                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
 726                     cur_sp +=
 727                       8 * extract_unsigned_integer (p + 2, 2, byte_order);
 728                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 729                     cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
 730                   else
 731                     return;
 732                   break;
 733                 case UWOP_ALLOC_SMALL:
 734                   cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
 735                   break;
 736                 case UWOP_SET_FPREG:
 737                   cur_sp = save_addr
 738                     - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
 739                   break;
 740                 case UWOP_SAVE_NONVOL:
 741                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 742                   cache->prev_reg_addr[reg] = save_addr
 743                     - 8 * extract_unsigned_integer (p + 2, 2, byte_order);
 744                   break;
 745                 case UWOP_SAVE_NONVOL_FAR:
 746                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 747                   cache->prev_reg_addr[reg] = save_addr
 748                     - 8 * extract_unsigned_integer (p + 2, 4, byte_order);
 749                   break;
 750                 case UWOP_SAVE_XMM128:
 751                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
 752                     save_addr
 753                     - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
 754                   break;
 755                 case UWOP_SAVE_XMM128_FAR:
 756                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
 757                     save_addr
 758                     - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
 759                   break;
 760                 case UWOP_PUSH_MACHFRAME:
 761                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
 762                     {
 763                       cache->prev_rip_addr = cur_sp + 0;
 764                       cache->prev_rsp_addr = cur_sp + 24;
 765                       cur_sp += 40;
 766                     }
 767                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 768                     {
 769                       cache->prev_rip_addr = cur_sp + 8;
 770                       cache->prev_rsp_addr = cur_sp + 32;
 771                       cur_sp += 48;
 772                     }
 773                   else
 774                     return;
 775                   break;
 776                 default:
 777                   return;
 778                 }
 779             }
 780
 781           /* Adjust with the length of the opcode.  */
 782           switch (PEX64_UNWCODE_CODE (p[1]))
 783             {
 784             case UWOP_PUSH_NONVOL:
 785             case UWOP_ALLOC_SMALL:
 786             case UWOP_SET_FPREG:
 787             case UWOP_PUSH_MACHFRAME:
 788               break;
 789             case UWOP_ALLOC_LARGE:
 790               if (PEX64_UNWCODE_INFO (p[1]) == 0)
 791                 p += 2;
 792               else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 793                 p += 4;
 794               else
 795                 return;
 796               break;
 797             case UWOP_SAVE_NONVOL:
 798             case UWOP_SAVE_XMM128:
 799               p += 2;
 800               break;
 801             case UWOP_SAVE_NONVOL_FAR:
 802             case UWOP_SAVE_XMM128_FAR:
 803               p += 4;
 804               break;
 805             default:
 806               return;
 807             }
 808         }
 809       if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
 810         break;
 811       else
 812         {
 813           /* Read the chained unwind info.  */
 814           struct external_pex64_runtime_function d;
 815           CORE_ADDR chain_vma;
 816
 817           chain_vma = cache->image_base + unwind_info
 818             + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2 + 8;
 819
 820           if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
 821             return;
 822
 823           cache->start_rva =
 824             extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 825           cache->end_rva =
 826             extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 827           unwind_info =
 828             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 829         }
 830
 831       /* Allow the user to break this loop.  */
 832       QUIT;
 833     }
 834   /* PC is saved by the call.  */
 835   if (cache->prev_rip_addr == 0)
 836     cache->prev_rip_addr = cur_sp;
 837   cache->prev_sp = cur_sp + 8;
 838
 839   if (frame_debug)
 840     fprintf_unfiltered (gdb_stdlog, "   prev_sp: %s, prev_pc @%s\n",
 841                         paddress (gdbarch, cache->prev_sp),
 842                         paddress (gdbarch, cache->prev_rip_addr));
 843 }
 844
 845 /* Find SEH unwind info for PC, returning 0 on success.
 846
 847    UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
 848    to the base address of the corresponding image, and START_RVA
 849    to the rva of the function containing PC.  */
 850
 851 static int
 852 amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
 853                                 CORE_ADDR *unwind_info,
 854                                 CORE_ADDR *image_base,
 855                                 CORE_ADDR *start_rva,
 856                                 CORE_ADDR *end_rva)
 857 {
 858   struct obj_section *sec;
 859   pe_data_type *pe;
 860   IMAGE_DATA_DIRECTORY *dir;
 861   struct objfile *objfile;
 862   unsigned long lo, hi;
 863   CORE_ADDR base;
 864   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 865
 866   /* Get the corresponding exception directory.  */
 867   sec = find_pc_section (pc);
 868   if (sec == NULL)
 869     return -1;
 870   objfile = sec->objfile;
 871   pe = pe_data (sec->objfile->obfd);
 872   dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
 873
 874   base = pe->pe_opthdr.ImageBase
 875     + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 876   *image_base = base;
 877
 878   /* Find the entry.
 879
 880      Note: This does not handle dynamically added entries (for JIT
 881      engines).  For this, we would need to ask the kernel directly,
 882      which means getting some info from the native layer.  For the
 883      rest of the code, however, it's probably faster to search
 884      the entry ourselves.  */
 885   lo = 0;
 886   hi = dir->Size / sizeof (struct external_pex64_runtime_function);
 887   *unwind_info = 0;
 888   while (lo <= hi)
 889     {
 890       unsigned long mid = lo + (hi - lo) / 2;
 891       struct external_pex64_runtime_function d;
 892       CORE_ADDR sa, ea;
 893
 894       if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
 895                               (gdb_byte *) &d, sizeof (d)) != 0)
 896         return -1;
 897
 898       sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 899       ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 900       if (pc < base + sa)
 901         hi = mid - 1;
 902       else if (pc >= base + ea)
 903         lo = mid + 1;
 904       else if (pc >= base + sa && pc < base + ea)
 905         {
 906           /* Got it.  */
 907           *start_rva = sa;
 908           *end_rva = ea;
 909           *unwind_info =
 910             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 911           break;
 912         }
 913       else
 914         break;
 915     }
 916
 917   if (frame_debug)
 918     fprintf_unfiltered
 919       (gdb_stdlog,
 920        "amd64_windows_find_unwind_data:  image_base=%s, unwind_data=%s\n",
 921        paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
 922
 923   if (*unwind_info & 1)
 924     {
 925       /* Unofficially documented unwind info redirection, when UNWIND_INFO
 926          address is odd (http://www.codemachine.com/article_x64deepdive.html).
 927       */
 928       struct external_pex64_runtime_function d;
 929       CORE_ADDR sa, ea;
 930
 931       if (target_read_memory (base + (*unwind_info & ~1),
 932                               (gdb_byte *) &d, sizeof (d)) != 0)
 933         return -1;
 934
 935       *start_rva =
 936         extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 937       *end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 938       *unwind_info =
 939         extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 940
 941     }
 942   return 0;
 943 }
 944
 945 /* Fill THIS_CACHE using the native amd64-windows unwinding data
 946    for THIS_FRAME.  */
 947
 948 static struct amd64_windows_frame_cache *
 949 amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
 950 {
 951   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 952   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 953   struct amd64_windows_frame_cache *cache;
 954   gdb_byte buf[8];
 955   struct obj_section *sec;
 956   pe_data_type *pe;
 957   IMAGE_DATA_DIRECTORY *dir;
 958   CORE_ADDR image_base;
 959   CORE_ADDR pc;
 960   struct objfile *objfile;
 961   unsigned long lo, hi;
 962   CORE_ADDR unwind_info = 0;
 963
 964   if (*this_cache)
 965     return *this_cache;
 966
 967   cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
 968   *this_cache = cache;
 969
 970   /* Get current PC and SP.  */
 971   pc = get_frame_pc (this_frame);
 972   get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
 973   cache->sp = extract_unsigned_integer (buf, 8, byte_order);
 974   cache->pc = pc;
 975
 976   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
 977                                       &cache->image_base,
 978                                       &cache->start_rva,
 979                                       &cache->end_rva))
 980     return cache;
 981
 982   if (unwind_info == 0)
 983     {
 984       /* Assume a leaf function.  */
 985       cache->prev_sp = cache->sp + 8;
 986       cache->prev_rip_addr = cache->sp;
 987     }
 988   else
 989     {
 990       /* Decode unwind insns to compute saved addresses.  */
 991       amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
 992     }
 993   return cache;
 994 }
 995
 996 /* Implement the "prev_register" method of struct frame_unwind
 997    using the standard Windows x64 SEH info.  */
 998
 999 static struct value *
1000 amd64_windows_frame_prev_register (struct frame_info *this_frame,
1001                                    void **this_cache, int regnum)
1002 {
1003   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1004   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1005   struct amd64_windows_frame_cache *cache =
1006     amd64_windows_frame_cache (this_frame, this_cache);
1007   struct value *val;
1008   CORE_ADDR prev;
1009
1010   if (frame_debug)
1011     fprintf_unfiltered (gdb_stdlog,
1012                         "amd64_windows_frame_prev_register %s for sp=%s\n",
1013                         gdbarch_register_name (gdbarch, regnum),
1014                         paddress (gdbarch, cache->prev_sp));
1015
1016   if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1017       prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1018   else if (regnum == AMD64_RSP_REGNUM)
1019     {
1020       prev = cache->prev_rsp_addr;
1021       if (prev == 0)
1022         return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1023     }
1024   else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1025     prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1026   else if (regnum == AMD64_RIP_REGNUM)
1027     prev = cache->prev_rip_addr;
1028   else
1029     prev = 0;
1030
1031   if (prev && frame_debug)
1032     fprintf_unfiltered (gdb_stdlog, "  -> at %s\n", paddress (gdbarch, prev));
1033
1034   if (prev)
1035     {
1036       /* Register was saved.  */
1037       return frame_unwind_got_memory (this_frame, regnum, prev);
1038     }
1039   else
1040     {
1041       /* Register is either volatile or not modified.  */
1042       return frame_unwind_got_register (this_frame, regnum, regnum);
1043     }
1044 }
1045
1046 /* Implement the "this_id" method of struct frame_unwind using
1047    the standard Windows x64 SEH info.  */
1048
1049 static void
1050 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1051                    struct frame_id *this_id)
1052 {
1053   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1054   struct amd64_windows_frame_cache *cache =
1055     amd64_windows_frame_cache (this_frame, this_cache);
1056
1057   *this_id = frame_id_build (cache->prev_sp,
1058                              cache->image_base + cache->start_rva);
1059 }
1060
1061 /* Windows x64 SEH unwinder.  */
1062
1063 static const struct frame_unwind amd64_windows_frame_unwind =
1064 {
1065   NORMAL_FRAME,
1066   default_frame_unwind_stop_reason,
1067   &amd64_windows_frame_this_id,
1068   &amd64_windows_frame_prev_register,
1069   NULL,
1070   default_frame_sniffer
1071 };
1072
1073 /* Implement the "skip_prologue" gdbarch method.  */
1074
1075 static CORE_ADDR
1076 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1077 {
1078   CORE_ADDR func_addr;
1079   CORE_ADDR unwind_info = 0;
1080   CORE_ADDR image_base, start_rva, end_rva;
1081   struct external_pex64_unwind_info ex_ui;
1082
1083   /* Use prologue size from unwind info.  */
1084   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1085                                       &image_base, &start_rva, &end_rva) == 0)
1086     {
1087       if (unwind_info == 0)
1088         {
1089           /* Leaf function.  */
1090           return pc;
1091         }
1092       else if (target_read_memory (image_base + unwind_info,
1093                                    (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1094                && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1095         return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1096     }
1097
1098   /* See if we can determine the end of the prologue via the symbol
1099      table.  If so, then return either the PC, or the PC after
1100      the prologue, whichever is greater.  */
1101   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1102     {
1103       CORE_ADDR post_prologue_pc
1104         = skip_prologue_using_sal (gdbarch, func_addr);
1105
1106       if (post_prologue_pc != 0)
1107         return max (pc, post_prologue_pc);
1108     }
1109
1110   return pc;
1111 }
1112
1113 /* Check Win64 DLL jmp trampolines and find jump destination.  */
1114
1115 static CORE_ADDR
1116 amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1117 {
1118   CORE_ADDR destination = 0;
1119   struct gdbarch *gdbarch = get_frame_arch (frame);
1120   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1121
1122   /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)).  */
1123   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1124     {
1125       /* Get opcode offset and see if we can find a reference in our data.  */
1126       ULONGEST offset
1127         = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1128
1129       /* Get address of function pointer at end of pc.  */
1130       CORE_ADDR indirect_addr = pc + offset + 6;
1131
1132       struct minimal_symbol *indsym
1133         = (indirect_addr
1134            ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1135            : NULL);
1136       const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : NULL;
1137
1138       if (symname)
1139         {
1140           if (strncmp (symname, "__imp_", 6) == 0
1141               || strncmp (symname, "_imp_", 5) == 0)
1142             destination
1143               = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1144         }
1145     }
1146
1147   return destination;
1148 }
1149
1150 /* Implement the "auto_wide_charset" gdbarch method.  */
1151
1152 static const char *
1153 amd64_windows_auto_wide_charset (void)
1154 {
1155   return "UTF-16";
1156 }
1157
1158 static void
1159 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1160 {
1161   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1162
1163   /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1164      preferred over the SEH one.  The reasons are:
1165      - binaries without SEH but with dwarf2 debug info are correcly handled
1166        (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1167        info).
1168      - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1169        handled if the dwarf2 unwinder is used).
1170
1171     The call to amd64_init_abi appends default unwinders, that aren't
1172     compatible with the SEH one.
1173   */
1174   frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1175
1176   amd64_init_abi (info, gdbarch);
1177
1178   windows_init_abi (info, gdbarch);
1179
1180   /* On Windows, "long"s are only 32bit.  */
1181   set_gdbarch_long_bit (gdbarch, 32);
1182
1183   /* Function calls.  */
1184   set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
1185   set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
1186   set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
1187   set_gdbarch_skip_trampoline_code (gdbarch,
1188                                     amd64_windows_skip_trampoline_code);
1189
1190   set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1191
1192   set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1193 }
1194
1195 /* -Wmissing-prototypes */
1196 extern initialize_file_ftype _initialize_amd64_windows_tdep;
1197
1198 void
1199 _initialize_amd64_windows_tdep (void)
1200 {
1201   gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1202                           amd64_windows_init_abi);
1203 }