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               && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
 359               && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
 360             pc += 5;
 361         }
 362     }
 363
 364   return pc;
 365 }
 366
 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;
 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           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         }
 850
 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;
 858
 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 }
 864
 865 /* Find SEH unwind info for PC, returning 0 on success.
 866
 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.  */
 870
 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);
 885
 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];
 893
 894   base = pe->pe_opthdr.ImageBase
 895     + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 896   *image_base = base;
 897
 898   /* Find the entry.
 899
 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;
 913
 914       if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
 915                               (gdb_byte *) &d, sizeof (d)) != 0)
 916         return -1;
 917
 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     }
 936
 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));
 942
 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;
 950
 951       if (target_read_memory (base + (*unwind_info & ~1),
 952                               (gdb_byte *) &d, sizeof (d)) != 0)
 953         return -1;
 954
 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);
 960
 961     }
 962   return 0;
 963 }
 964
 965 /* Fill THIS_CACHE using the native amd64-windows unwinding data
 966    for THIS_FRAME.  */
 967
 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;
 983
 984   if (*this_cache)
 985     return *this_cache;
 986
 987   cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
 988   *this_cache = cache;
 989
 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;
 995
 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;
1001
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 }
1015
1016 /* Implement the "prev_register" method of struct frame_unwind
1017    using the standard Windows x64 SEH info.  */
1018
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;
1029
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));
1035
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;
1050
1051   if (prev && frame_debug)
1052     fprintf_unfiltered (gdb_stdlog, "  -> at %s\n", paddress (gdbarch, prev));
1053
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 }
1065
1066 /* Implement the "this_id" method of struct frame_unwind using
1067    the standard Windows x64 SEH info.  */
1068
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);
1076
1077   *this_id = frame_id_build (cache->prev_sp,
1078                              cache->image_base + cache->start_rva);
1079 }
1080
1081 /* Windows x64 SEH unwinder.  */
1082
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 };
1092
1093 /* Implement the "skip_prologue" gdbarch method.  */
1094
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;
1102
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     }
1117
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);
1125
1126       if (post_prologue_pc != 0)
1127         return max (pc, post_prologue_pc);
1128     }
1129
1130   return pc;
1131 }
1132
1133 /* Check Win64 DLL jmp trampolines and find jump destination.  */
1134
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);
1141
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);
1148
1149       /* Get address of function pointer at end of pc.  */
1150       CORE_ADDR indirect_addr = pc + offset + 6;
1151
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;
1157
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     }
1166
1167   return destination;
1168 }
1169
1170 /* Implement the "auto_wide_charset" gdbarch method.  */
1171
1172 static const char *
1173 amd64_windows_auto_wide_charset (void)
1174 {
1175   return "UTF-16";
1176 }
1177
1178 static void
1179 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1180 {
1181   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1182
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).
1190
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);
1195
1196   amd64_init_abi (info, gdbarch);
1197
1198   windows_init_abi (info, gdbarch);
1199
1200   /* On Windows, "long"s are only 32bit.  */
1201   set_gdbarch_long_bit (gdbarch, 32);
1202
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);
1209
1210   set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1211
1212   set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1213 }
1214
1215 /* -Wmissing-prototypes */
1216 extern initialize_file_ftype _initialize_amd64_windows_tdep;
1217
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 }