gdb/amd64-windows-tdep.c

   1 /* Copyright (C) 2009-2016 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 = XALLOCAVEC (struct value *, nargs);
 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 = XALLOCAVEC (struct value *, nargs);
 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           pc += rex ? 2 : 1;
 492         }
 493       else
 494         break;
 495
 496       /* Allow the user to break this loop.  This shouldn't happen as the
 497          number of consecutive pop should be small.  */
 498       QUIT;
 499     }
 500
 501   /* Then decode the marker.  */
 502
 503   /* Read opcode.  */
 504   if (target_read_memory (pc, &op, 1) != 0)
 505     return -1;
 506
 507   switch (op)
 508     {
 509     case 0xc3:
 510       /* Ret.  */
 511       cache->prev_rip_addr = cur_sp;
 512       cache->prev_sp = cur_sp + 8;
 513       return 1;
 514
 515     case 0xeb:
 516       {
 517         /* jmp rel8  */
 518         gdb_byte rel8;
 519         CORE_ADDR npc;
 520
 521         if (target_read_memory (pc + 1, &rel8, 1) != 0)
 522           return -1;
 523         npc = pc + 2 + (signed char) rel8;
 524
 525         /* If the jump is within the function, then this is not a marker,
 526            otherwise this is a tail-call.  */
 527         return !pc_in_range (npc, cache);
 528       }
 529
 530     case 0xec:
 531       {
 532         /* jmp rel32  */
 533         gdb_byte rel32[4];
 534         CORE_ADDR npc;
 535
 536         if (target_read_memory (pc + 1, rel32, 4) != 0)
 537           return -1;
 538         npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
 539
 540         /* If the jump is within the function, then this is not a marker,
 541            otherwise this is a tail-call.  */
 542         return !pc_in_range (npc, cache);
 543       }
 544
 545     case 0xc2:
 546       {
 547         /* ret n  */
 548         gdb_byte imm16[2];
 549
 550         if (target_read_memory (pc + 1, imm16, 2) != 0)
 551           return -1;
 552         cache->prev_rip_addr = cur_sp;
 553         cache->prev_sp = cur_sp
 554           + extract_unsigned_integer (imm16, 4, byte_order);
 555         return 1;
 556       }
 557
 558     case 0xf3:
 559       {
 560         /* rep; ret  */
 561         gdb_byte op1;
 562
 563         if (target_read_memory (pc + 2, &op1, 1) != 0)
 564           return -1;
 565         if (op1 != 0xc3)
 566           return 0;
 567
 568         cache->prev_rip_addr = cur_sp;
 569         cache->prev_sp = cur_sp + 8;
 570         return 1;
 571       }
 572
 573     case 0x40:
 574     case 0x41:
 575     case 0x42:
 576     case 0x43:
 577     case 0x44:
 578     case 0x45:
 579     case 0x46:
 580     case 0x47:
 581     case 0x48:
 582     case 0x49:
 583     case 0x4a:
 584     case 0x4b:
 585     case 0x4c:
 586     case 0x4d:
 587     case 0x4e:
 588     case 0x4f:
 589       /* Got a REX prefix, read next byte.  */
 590       rex = op;
 591       if (target_read_memory (pc + 1, &op, 1) != 0)
 592         return -1;
 593
 594       if (op == 0xff)
 595         {
 596           /* rex jmp reg  */
 597           gdb_byte op1;
 598
 599           if (target_read_memory (pc + 2, &op1, 1) != 0)
 600             return -1;
 601           return (op1 & 0xf8) == 0xe0;
 602         }
 603       else
 604         return 0;
 605
 606     default:
 607       /* Not REX, so unknown.  */
 608       return 0;
 609     }
 610 }
 611
 612 /* Decode and execute unwind insns at UNWIND_INFO.  */
 613
 614 static void
 615 amd64_windows_frame_decode_insns (struct frame_info *this_frame,
 616                                   struct amd64_windows_frame_cache *cache,
 617                                   CORE_ADDR unwind_info)
 618 {
 619   CORE_ADDR save_addr = 0;
 620   CORE_ADDR cur_sp = cache->sp;
 621   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 622   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 623   int first = 1;
 624
 625   /* There are at least 3 possibilities to share an unwind info entry:
 626      1. Two different runtime_function entries (in .pdata) can point to the
 627         same unwind info entry.  There is no such indication while unwinding,
 628         so we don't really care about that case.  We suppose this scheme is
 629         used to save memory when the unwind entries are exactly the same.
 630      2. Chained unwind_info entries, with no unwind codes (no prologue).
 631         There is a major difference with the previous case: the pc range for
 632         the function is different (in case 1, the pc range comes from the
 633         runtime_function entry; in case 2, the pc range for the chained entry
 634         comes from the first unwind entry).  Case 1 cannot be used instead as
 635         the pc is not in the prologue.  This case is officially documented.
 636         (There might be unwind code in the first unwind entry to handle
 637         additional unwinding).  GCC (at least until gcc 5.0) doesn't chain
 638         entries.
 639      3. Undocumented unwind info redirection.  Hard to know the exact purpose,
 640         so it is considered as a memory optimization of case 2.
 641   */
 642
 643   if (unwind_info & 1)
 644     {
 645       /* Unofficially documented unwind info redirection, when UNWIND_INFO
 646          address is odd (http://www.codemachine.com/article_x64deepdive.html).
 647       */
 648       struct external_pex64_runtime_function d;
 649
 650       if (target_read_memory (cache->image_base + (unwind_info & ~1),
 651                               (gdb_byte *) &d, sizeof (d)) != 0)
 652         return;
 653
 654       cache->start_rva
 655         = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 656       cache->end_rva
 657         = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 658       unwind_info
 659         = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 660     }
 661
 662   while (1)
 663     {
 664       struct external_pex64_unwind_info ex_ui;
 665       /* There are at most 256 16-bit unwind insns.  */
 666       gdb_byte insns[2 * 256];
 667       gdb_byte *p;
 668       gdb_byte *end_insns;
 669       unsigned char codes_count;
 670       unsigned char frame_reg;
 671       CORE_ADDR start;
 672
 673       /* Read and decode header.  */
 674       if (target_read_memory (cache->image_base + unwind_info,
 675                               (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
 676         return;
 677
 678       if (frame_debug)
 679         fprintf_unfiltered
 680           (gdb_stdlog,
 681            "amd64_windows_frame_decodes_insn: "
 682            "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
 683            paddress (gdbarch, unwind_info),
 684            ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
 685            ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);
 686
 687       /* Check version.  */
 688       if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
 689           && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
 690         return;
 691
 692       start = cache->image_base + cache->start_rva;
 693       if (first
 694           && !(cache->pc >= start && cache->pc < start + ex_ui.SizeOfPrologue))
 695         {
 696           /* We want to detect if the PC points to an epilogue.  This needs
 697              to be checked only once, and an epilogue can be anywhere but in
 698              the prologue.  If so, the epilogue detection+decoding function is
 699              sufficient.  Otherwise, the unwinder will consider that the PC
 700              is in the body of the function and will need to decode unwind
 701              info.  */
 702           if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
 703             return;
 704
 705           /* Not in an epilog.  Clear possible side effects.  */
 706           memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
 707         }
 708
 709       codes_count = ex_ui.CountOfCodes;
 710       frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
 711
 712       if (frame_reg != 0)
 713         {
 714           /* According to msdn:
 715              If an FP reg is used, then any unwind code taking an offset must
 716              only be used after the FP reg is established in the prolog.  */
 717           gdb_byte buf[8];
 718           int frreg = amd64_windows_w2gdb_regnum[frame_reg];
 719
 720           get_frame_register (this_frame, frreg, buf);
 721           save_addr = extract_unsigned_integer (buf, 8, byte_order);
 722
 723           if (frame_debug)
 724             fprintf_unfiltered (gdb_stdlog, "   frame_reg=%s, val=%s\n",
 725                                 gdbarch_register_name (gdbarch, frreg),
 726                                 paddress (gdbarch, save_addr));
 727         }
 728
 729       /* Read opcodes.  */
 730       if (codes_count != 0
 731           && target_read_memory (cache->image_base + unwind_info
 732                                  + sizeof (ex_ui),
 733                                  insns, codes_count * 2) != 0)
 734         return;
 735
 736       end_insns = &insns[codes_count * 2];
 737       p = insns;
 738
 739       /* Skip opcodes 6 of version 2.  This opcode is not documented.  */
 740       if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
 741         {
 742           for (; p < end_insns; p += 2)
 743             if (PEX64_UNWCODE_CODE (p[1]) != 6)
 744               break;
 745         }
 746
 747       for (; p < end_insns; p += 2)
 748         {
 749           int reg;
 750
 751           /* Virtually execute the operation if the pc is after the
 752              corresponding instruction (that does matter in case of break
 753              within the prologue).  Note that for chained info (!first), the
 754              prologue has been fully executed.  */
 755           if (cache->pc >= start + p[0] || cache->pc < start)
 756             {
 757               if (frame_debug)
 758                 fprintf_unfiltered
 759                   (gdb_stdlog, "   op #%u: off=0x%02x, insn=0x%02x\n",
 760                    (unsigned) (p - insns), p[0], p[1]);
 761
 762               /* If there is no frame registers defined, the current value of
 763                  rsp is used instead.  */
 764               if (frame_reg == 0)
 765                 save_addr = cur_sp;
 766
 767               reg = -1;
 768
 769               switch (PEX64_UNWCODE_CODE (p[1]))
 770                 {
 771                 case UWOP_PUSH_NONVOL:
 772                   /* Push pre-decrements RSP.  */
 773                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 774                   cache->prev_reg_addr[reg] = cur_sp;
 775                   cur_sp += 8;
 776                   break;
 777                 case UWOP_ALLOC_LARGE:
 778                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
 779                     cur_sp +=
 780                       8 * extract_unsigned_integer (p + 2, 2, byte_order);
 781                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 782                     cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
 783                   else
 784                     return;
 785                   break;
 786                 case UWOP_ALLOC_SMALL:
 787                   cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
 788                   break;
 789                 case UWOP_SET_FPREG:
 790                   cur_sp = save_addr
 791                     - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
 792                   break;
 793                 case UWOP_SAVE_NONVOL:
 794                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 795                   cache->prev_reg_addr[reg] = save_addr
 796                     + 8 * extract_unsigned_integer (p + 2, 2, byte_order);
 797                   break;
 798                 case UWOP_SAVE_NONVOL_FAR:
 799                   reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
 800                   cache->prev_reg_addr[reg] = save_addr
 801                     + 8 * extract_unsigned_integer (p + 2, 4, byte_order);
 802                   break;
 803                 case UWOP_SAVE_XMM128:
 804                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
 805                     save_addr
 806                     - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
 807                   break;
 808                 case UWOP_SAVE_XMM128_FAR:
 809                   cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
 810                     save_addr
 811                     - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
 812                   break;
 813                 case UWOP_PUSH_MACHFRAME:
 814                   if (PEX64_UNWCODE_INFO (p[1]) == 0)
 815                     {
 816                       cache->prev_rip_addr = cur_sp + 0;
 817                       cache->prev_rsp_addr = cur_sp + 24;
 818                       cur_sp += 40;
 819                     }
 820                   else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 821                     {
 822                       cache->prev_rip_addr = cur_sp + 8;
 823                       cache->prev_rsp_addr = cur_sp + 32;
 824                       cur_sp += 48;
 825                     }
 826                   else
 827                     return;
 828                   break;
 829                 default:
 830                   return;
 831                 }
 832
 833               /* Display address where the register was saved.  */
 834               if (frame_debug && reg >= 0)
 835                 fprintf_unfiltered
 836                   (gdb_stdlog, "     [reg %s at %s]\n",
 837                    gdbarch_register_name (gdbarch, reg),
 838                    paddress (gdbarch, cache->prev_reg_addr[reg]));
 839             }
 840
 841           /* Adjust with the length of the opcode.  */
 842           switch (PEX64_UNWCODE_CODE (p[1]))
 843             {
 844             case UWOP_PUSH_NONVOL:
 845             case UWOP_ALLOC_SMALL:
 846             case UWOP_SET_FPREG:
 847             case UWOP_PUSH_MACHFRAME:
 848               break;
 849             case UWOP_ALLOC_LARGE:
 850               if (PEX64_UNWCODE_INFO (p[1]) == 0)
 851                 p += 2;
 852               else if (PEX64_UNWCODE_INFO (p[1]) == 1)
 853                 p += 4;
 854               else
 855                 return;
 856               break;
 857             case UWOP_SAVE_NONVOL:
 858             case UWOP_SAVE_XMM128:
 859               p += 2;
 860               break;
 861             case UWOP_SAVE_NONVOL_FAR:
 862             case UWOP_SAVE_XMM128_FAR:
 863               p += 4;
 864               break;
 865             default:
 866               return;
 867             }
 868         }
 869       if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
 870         {
 871           /* End of unwind info.  */
 872           break;
 873         }
 874       else
 875         {
 876           /* Read the chained unwind info.  */
 877           struct external_pex64_runtime_function d;
 878           CORE_ADDR chain_vma;
 879
 880           /* Not anymore the first entry.  */
 881           first = 0;
 882
 883           /* Stay aligned on word boundary.  */
 884           chain_vma = cache->image_base + unwind_info
 885             + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2;
 886
 887           if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
 888             return;
 889
 890           /* Decode begin/end.  This may be different from .pdata index, as
 891              an unwind info may be shared by several functions (in particular
 892              if many functions have the same prolog and handler.  */
 893           cache->start_rva =
 894             extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 895           cache->end_rva =
 896             extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 897           unwind_info =
 898             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 899
 900           if (frame_debug)
 901             fprintf_unfiltered
 902               (gdb_stdlog,
 903                "amd64_windows_frame_decodes_insn (next in chain):"
 904                " unwind_data=%s, start_rva=%s, end_rva=%s\n",
 905                paddress (gdbarch, unwind_info),
 906                paddress (gdbarch, cache->start_rva),
 907                paddress (gdbarch, cache->end_rva));
 908         }
 909
 910       /* Allow the user to break this loop.  */
 911       QUIT;
 912     }
 913   /* PC is saved by the call.  */
 914   if (cache->prev_rip_addr == 0)
 915     cache->prev_rip_addr = cur_sp;
 916   cache->prev_sp = cur_sp + 8;
 917
 918   if (frame_debug)
 919     fprintf_unfiltered (gdb_stdlog, "   prev_sp: %s, prev_pc @%s\n",
 920                         paddress (gdbarch, cache->prev_sp),
 921                         paddress (gdbarch, cache->prev_rip_addr));
 922 }
 923
 924 /* Find SEH unwind info for PC, returning 0 on success.
 925
 926    UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
 927    to the base address of the corresponding image, and START_RVA
 928    to the rva of the function containing PC.  */
 929
 930 static int
 931 amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
 932                                 CORE_ADDR *unwind_info,
 933                                 CORE_ADDR *image_base,
 934                                 CORE_ADDR *start_rva,
 935                                 CORE_ADDR *end_rva)
 936 {
 937   struct obj_section *sec;
 938   pe_data_type *pe;
 939   IMAGE_DATA_DIRECTORY *dir;
 940   struct objfile *objfile;
 941   unsigned long lo, hi;
 942   CORE_ADDR base;
 943   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 944
 945   /* Get the corresponding exception directory.  */
 946   sec = find_pc_section (pc);
 947   if (sec == NULL)
 948     return -1;
 949   objfile = sec->objfile;
 950   pe = pe_data (sec->objfile->obfd);
 951   dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
 952
 953   base = pe->pe_opthdr.ImageBase
 954     + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 955   *image_base = base;
 956
 957   /* Find the entry.
 958
 959      Note: This does not handle dynamically added entries (for JIT
 960      engines).  For this, we would need to ask the kernel directly,
 961      which means getting some info from the native layer.  For the
 962      rest of the code, however, it's probably faster to search
 963      the entry ourselves.  */
 964   lo = 0;
 965   hi = dir->Size / sizeof (struct external_pex64_runtime_function);
 966   *unwind_info = 0;
 967   while (lo <= hi)
 968     {
 969       unsigned long mid = lo + (hi - lo) / 2;
 970       struct external_pex64_runtime_function d;
 971       CORE_ADDR sa, ea;
 972
 973       if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
 974                               (gdb_byte *) &d, sizeof (d)) != 0)
 975         return -1;
 976
 977       sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
 978       ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
 979       if (pc < base + sa)
 980         hi = mid - 1;
 981       else if (pc >= base + ea)
 982         lo = mid + 1;
 983       else if (pc >= base + sa && pc < base + ea)
 984         {
 985           /* Got it.  */
 986           *start_rva = sa;
 987           *end_rva = ea;
 988           *unwind_info =
 989             extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
 990           break;
 991         }
 992       else
 993         break;
 994     }
 995
 996   if (frame_debug)
 997     fprintf_unfiltered
 998       (gdb_stdlog,
 999        "amd64_windows_find_unwind_data:  image_base=%s, unwind_data=%s\n",
1000        paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
1001
1002   return 0;
1003 }
1004
1005 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1006    for THIS_FRAME.  */
1007
1008 static struct amd64_windows_frame_cache *
1009 amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
1010 {
1011   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1012   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1013   struct amd64_windows_frame_cache *cache;
1014   gdb_byte buf[8];
1015   CORE_ADDR pc;
1016   CORE_ADDR unwind_info = 0;
1017
1018   if (*this_cache)
1019     return (struct amd64_windows_frame_cache *) *this_cache;
1020
1021   cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
1022   *this_cache = cache;
1023
1024   /* Get current PC and SP.  */
1025   pc = get_frame_pc (this_frame);
1026   get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
1027   cache->sp = extract_unsigned_integer (buf, 8, byte_order);
1028   cache->pc = pc;
1029
1030   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1031                                       &cache->image_base,
1032                                       &cache->start_rva,
1033                                       &cache->end_rva))
1034     return cache;
1035
1036   if (unwind_info == 0)
1037     {
1038       /* Assume a leaf function.  */
1039       cache->prev_sp = cache->sp + 8;
1040       cache->prev_rip_addr = cache->sp;
1041     }
1042   else
1043     {
1044       /* Decode unwind insns to compute saved addresses.  */
1045       amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1046     }
1047   return cache;
1048 }
1049
1050 /* Implement the "prev_register" method of struct frame_unwind
1051    using the standard Windows x64 SEH info.  */
1052
1053 static struct value *
1054 amd64_windows_frame_prev_register (struct frame_info *this_frame,
1055                                    void **this_cache, int regnum)
1056 {
1057   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1058   struct amd64_windows_frame_cache *cache =
1059     amd64_windows_frame_cache (this_frame, this_cache);
1060   CORE_ADDR prev;
1061
1062   if (frame_debug)
1063     fprintf_unfiltered (gdb_stdlog,
1064                         "amd64_windows_frame_prev_register %s for sp=%s\n",
1065                         gdbarch_register_name (gdbarch, regnum),
1066                         paddress (gdbarch, cache->prev_sp));
1067
1068   if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1069       prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1070   else if (regnum == AMD64_RSP_REGNUM)
1071     {
1072       prev = cache->prev_rsp_addr;
1073       if (prev == 0)
1074         return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1075     }
1076   else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1077     prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1078   else if (regnum == AMD64_RIP_REGNUM)
1079     prev = cache->prev_rip_addr;
1080   else
1081     prev = 0;
1082
1083   if (prev && frame_debug)
1084     fprintf_unfiltered (gdb_stdlog, "  -> at %s\n", paddress (gdbarch, prev));
1085
1086   if (prev)
1087     {
1088       /* Register was saved.  */
1089       return frame_unwind_got_memory (this_frame, regnum, prev);
1090     }
1091   else
1092     {
1093       /* Register is either volatile or not modified.  */
1094       return frame_unwind_got_register (this_frame, regnum, regnum);
1095     }
1096 }
1097
1098 /* Implement the "this_id" method of struct frame_unwind using
1099    the standard Windows x64 SEH info.  */
1100
1101 static void
1102 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1103                    struct frame_id *this_id)
1104 {
1105   struct amd64_windows_frame_cache *cache =
1106     amd64_windows_frame_cache (this_frame, this_cache);
1107
1108   *this_id = frame_id_build (cache->prev_sp,
1109                              cache->image_base + cache->start_rva);
1110 }
1111
1112 /* Windows x64 SEH unwinder.  */
1113
1114 static const struct frame_unwind amd64_windows_frame_unwind =
1115 {
1116   NORMAL_FRAME,
1117   default_frame_unwind_stop_reason,
1118   &amd64_windows_frame_this_id,
1119   &amd64_windows_frame_prev_register,
1120   NULL,
1121   default_frame_sniffer
1122 };
1123
1124 /* Implement the "skip_prologue" gdbarch method.  */
1125
1126 static CORE_ADDR
1127 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1128 {
1129   CORE_ADDR func_addr;
1130   CORE_ADDR unwind_info = 0;
1131   CORE_ADDR image_base, start_rva, end_rva;
1132   struct external_pex64_unwind_info ex_ui;
1133
1134   /* Use prologue size from unwind info.  */
1135   if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1136                                       &image_base, &start_rva, &end_rva) == 0)
1137     {
1138       if (unwind_info == 0)
1139         {
1140           /* Leaf function.  */
1141           return pc;
1142         }
1143       else if (target_read_memory (image_base + unwind_info,
1144                                    (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1145                && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1146         return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1147     }
1148
1149   /* See if we can determine the end of the prologue via the symbol
1150      table.  If so, then return either the PC, or the PC after
1151      the prologue, whichever is greater.  */
1152   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1153     {
1154       CORE_ADDR post_prologue_pc
1155         = skip_prologue_using_sal (gdbarch, func_addr);
1156
1157       if (post_prologue_pc != 0)
1158         return max (pc, post_prologue_pc);
1159     }
1160
1161   return pc;
1162 }
1163
1164 /* Check Win64 DLL jmp trampolines and find jump destination.  */
1165
1166 static CORE_ADDR
1167 amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1168 {
1169   CORE_ADDR destination = 0;
1170   struct gdbarch *gdbarch = get_frame_arch (frame);
1171   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1172
1173   /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)).  */
1174   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1175     {
1176       /* Get opcode offset and see if we can find a reference in our data.  */
1177       ULONGEST offset
1178         = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1179
1180       /* Get address of function pointer at end of pc.  */
1181       CORE_ADDR indirect_addr = pc + offset + 6;
1182
1183       struct minimal_symbol *indsym
1184         = (indirect_addr
1185            ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1186            : NULL);
1187       const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
1188
1189       if (symname)
1190         {
1191           if (startswith (symname, "__imp_")
1192               || startswith (symname, "_imp_"))
1193             destination
1194               = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1195         }
1196     }
1197
1198   return destination;
1199 }
1200
1201 /* Implement the "auto_wide_charset" gdbarch method.  */
1202
1203 static const char *
1204 amd64_windows_auto_wide_charset (void)
1205 {
1206   return "UTF-16";
1207 }
1208
1209 static void
1210 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1211 {
1212   /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1213      preferred over the SEH one.  The reasons are:
1214      - binaries without SEH but with dwarf2 debug info are correcly handled
1215        (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1216        info).
1217      - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1218        handled if the dwarf2 unwinder is used).
1219
1220     The call to amd64_init_abi appends default unwinders, that aren't
1221     compatible with the SEH one.
1222   */
1223   frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1224
1225   amd64_init_abi (info, gdbarch);
1226
1227   windows_init_abi (info, gdbarch);
1228
1229   /* On Windows, "long"s are only 32bit.  */
1230   set_gdbarch_long_bit (gdbarch, 32);
1231
1232   /* Function calls.  */
1233   set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
1234   set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
1235   set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
1236   set_gdbarch_skip_trampoline_code (gdbarch,
1237                                     amd64_windows_skip_trampoline_code);
1238
1239   set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1240
1241   set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1242 }
1243
1244 /* -Wmissing-prototypes */
1245 extern initialize_file_ftype _initialize_amd64_windows_tdep;
1246
1247 void
1248 _initialize_amd64_windows_tdep (void)
1249 {
1250   gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1251                           amd64_windows_init_abi);
1252 }