msvcrt: File read buffer tests.
[wine] / dlls / dbghelp / stack.c
1 /*
2  * Stack walking
3  *
4  * Copyright 1995 Alexandre Julliard
5  * Copyright 1996 Eric Youngdale
6  * Copyright 1999 Ove Kåven
7  * Copyright 2004 Eric Pouech
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <assert.h>
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "dbghelp_private.h"
33 #include "winreg.h"
34 #include "winternl.h"
35 #include "wine/winbase16.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
39
40 enum st_mode {stm_start, stm_32bit, stm_16bit, stm_done};
41
42 static const char* wine_dbgstr_addr(const ADDRESS* addr)
43 {
44     if (!addr) return "(null)";
45     switch (addr->Mode)
46     {
47     case AddrModeFlat:
48         return wine_dbg_sprintf("flat<%08lx>", addr->Offset);
49     case AddrMode1616:
50         return wine_dbg_sprintf("1616<%04x:%04lx>", addr->Segment, addr->Offset);
51     case AddrMode1632:
52         return wine_dbg_sprintf("1632<%04x:%08lx>", addr->Segment, addr->Offset);
53     case AddrModeReal:
54         return wine_dbg_sprintf("real<%04x:%04lx>", addr->Segment, addr->Offset);
55     default:
56         return "unknown";
57     }
58 }
59
60 static BOOL CALLBACK read_mem(HANDLE hProcess, DWORD addr, void* buffer,
61                               DWORD size, LPDWORD nread)
62 {
63     return ReadProcessMemory(hProcess, (void*)addr, buffer, size, nread);
64 }
65
66 static BOOL CALLBACK read_mem64(HANDLE hProcess, DWORD64 addr, void* buffer,
67                                 DWORD size, LPDWORD nread)
68 {
69     return ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, nread);
70 }
71
72 /* indexes in Reserved array */
73 #define __CurrentMode     0
74 #define __CurrentSwitch   1
75 #define __NextSwitch      2
76
77 #define curr_mode   (frame->Reserved[__CurrentMode])
78 #define curr_switch (frame->Reserved[__CurrentSwitch])
79 #define next_switch (frame->Reserved[__NextSwitch])
80
81 struct stack_walk_callback
82 {
83     HANDLE      hProcess;
84     HANDLE      hThread;
85     BOOL        is32;
86     union
87     {
88         struct
89         {
90             PREAD_PROCESS_MEMORY_ROUTINE        f_read_mem;
91             PTRANSLATE_ADDRESS_ROUTINE          f_xlat_adr;
92             PFUNCTION_TABLE_ACCESS_ROUTINE      f_tabl_acs;
93             PGET_MODULE_BASE_ROUTINE            f_modl_bas;
94         } s32;
95         struct
96         {
97             PREAD_PROCESS_MEMORY_ROUTINE64      f_read_mem;
98             PTRANSLATE_ADDRESS_ROUTINE64        f_xlat_adr;
99             PFUNCTION_TABLE_ACCESS_ROUTINE64    f_tabl_acs;
100             PGET_MODULE_BASE_ROUTINE64          f_modl_bas;
101         } s64;
102     } u;
103 };
104
105 static inline void addr_32to64(const ADDRESS* addr32, ADDRESS64* addr64)
106 {
107     addr64->Offset = (ULONG64)addr32->Offset;
108     addr64->Segment = addr32->Segment;
109     addr64->Mode = addr32->Mode;
110 }
111
112 static inline void addr_64to32(const ADDRESS64* addr64, ADDRESS* addr32)
113 {
114     addr32->Offset = (ULONG)addr64->Offset;
115     addr32->Segment = addr64->Segment;
116     addr32->Mode = addr64->Mode;
117 }
118
119 static inline BOOL sw_read_mem(struct stack_walk_callback* cb, DWORD addr, void* ptr, DWORD sz)
120 {
121     if (cb->is32)
122         return cb->u.s32.f_read_mem(cb->hProcess, addr, ptr, sz, NULL);
123     else
124         return cb->u.s64.f_read_mem(cb->hProcess, addr, ptr, sz, NULL);
125 }
126
127 static inline DWORD sw_xlat_addr(struct stack_walk_callback* cb, ADDRESS* addr)
128 {
129     if (addr->Mode == AddrModeFlat) return addr->Offset;
130     if (cb->is32) return cb->u.s32.f_xlat_adr(cb->hProcess, cb->hThread, addr);
131     if (cb->u.s64.f_xlat_adr)
132     {
133         ADDRESS64       addr64;
134
135         addr_32to64(addr, &addr64);
136         return cb->u.s64.f_xlat_adr(cb->hProcess, cb->hThread, &addr64);
137     }
138     return addr_to_linear(cb->hProcess, cb->hThread, addr);
139 }
140
141 static inline void* sw_tabl_acs(struct stack_walk_callback* cb, DWORD addr)
142 {
143     if (cb->is32)
144         return cb->u.s32.f_tabl_acs(cb->hProcess, addr);
145     else
146         return cb->u.s64.f_tabl_acs(cb->hProcess, addr);
147 }
148
149 static inline DWORD sw_modl_bas(struct stack_walk_callback* cb, DWORD addr)
150 {
151     if (cb->is32)
152         return cb->u.s32.f_modl_bas(cb->hProcess, addr);
153     else
154         return cb->u.s64.f_modl_bas(cb->hProcess, addr);
155 }
156
157 static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
158 {
159     STACK32FRAME        frame32;
160     STACK16FRAME        frame16;
161     char                ch;
162     ADDRESS             tmp;
163     DWORD               p;
164     WORD                val;
165     BOOL                do_switch;
166
167     /* sanity check */
168     if (curr_mode >= stm_done) return FALSE;
169
170     TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx\n",
171           wine_dbgstr_addr(&frame->AddrPC), 
172           wine_dbgstr_addr(&frame->AddrFrame),
173           wine_dbgstr_addr(&frame->AddrReturn),
174           wine_dbgstr_addr(&frame->AddrStack), 
175           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
176           curr_switch, next_switch);
177
178     if (curr_mode == stm_start)
179     {
180         THREAD_BASIC_INFORMATION info;
181
182         if ((frame->AddrPC.Mode == AddrModeFlat) &&
183             (frame->AddrFrame.Mode != AddrModeFlat))
184         {
185             WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
186             goto done_err;
187         }
188
189         /* Init done */
190         curr_mode = (frame->AddrPC.Mode == AddrModeFlat) ? 
191             stm_32bit : stm_16bit;
192
193         /* cur_switch holds address of WOW32Reserved field in TEB in debuggee
194          * address space
195          */
196         if (NtQueryInformationThread(cb->hThread, ThreadBasicInformation, &info,
197                                      sizeof(info), NULL) == STATUS_SUCCESS)
198         {
199             curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved);
200             if (!sw_read_mem(cb, curr_switch, &next_switch, sizeof(next_switch)))
201             {
202                 WARN("Can't read TEB:WOW32Reserved\n");
203                 goto done_err;
204             }
205             if (curr_mode == stm_16bit)
206             {
207                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
208                 {
209                     WARN("Bad stack frame 0x%08lx\n", next_switch);
210                     goto done_err;
211                 }
212                 curr_switch = (DWORD)frame32.frame16;
213                 tmp.Mode    = AddrMode1616;
214                 tmp.Segment = SELECTOROF(curr_switch);
215                 tmp.Offset  = OFFSETOF(curr_switch);
216                 if (!sw_read_mem(cb, sw_xlat_addr(cb, &tmp), &ch, sizeof(ch)))
217                     curr_switch = 0xFFFFFFFF;
218             }
219             else
220             {
221                 tmp.Mode    = AddrMode1616;
222                 tmp.Segment = SELECTOROF(next_switch);
223                 tmp.Offset  = OFFSETOF(next_switch);
224                 p = sw_xlat_addr(cb, &tmp);
225                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
226                 {
227                     WARN("Bad stack frame 0x%08lx\n", p);
228                     goto done_err;
229                 }
230                 curr_switch = (DWORD)frame16.frame32;
231
232                 if (!sw_read_mem(cb, curr_switch, &ch, sizeof(ch)))
233                     curr_switch = 0xFFFFFFFF;
234             }
235         }
236         else
237             /* FIXME: this will allow to work when we're not attached to a live target, 
238              * but the 16 <=> 32 switch facility won't be available.
239              */
240             curr_switch = 0;
241         frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
242         /* don't set up AddrStack on first call. Either the caller has set it up, or
243          * we will get it in the next frame
244          */
245         memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
246     }
247     else
248     {
249         if (frame->AddrFrame.Offset == 0) goto done_err;
250         if (frame->AddrFrame.Mode == AddrModeFlat)
251         {
252             assert(curr_mode == stm_32bit);
253             do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
254         }
255         else
256         {
257             assert(curr_mode == stm_16bit);
258             do_switch = curr_switch && 
259                 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
260                 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
261         }
262            
263         if (do_switch)
264         {
265             if (curr_mode == stm_16bit)
266             {
267                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
268                 {
269                     WARN("Bad stack frame 0x%08lx\n", next_switch);
270                     goto done_err;
271                 }
272
273                 frame->AddrPC.Mode        = AddrModeFlat;
274                 frame->AddrPC.Segment     = 0;
275                 frame->AddrPC.Offset      = frame32.retaddr;
276                 frame->AddrFrame.Mode     = AddrModeFlat;
277                 frame->AddrFrame.Segment  = 0;
278                 frame->AddrFrame.Offset   = frame32.ebp;
279
280                 frame->AddrStack.Mode     = AddrModeFlat;
281                 frame->AddrStack.Segment  = 0;
282                 frame->AddrReturn.Mode    = AddrModeFlat;
283                 frame->AddrReturn.Segment = 0;
284
285                 next_switch = curr_switch;
286                 tmp.Mode    = AddrMode1616;
287                 tmp.Segment = SELECTOROF(next_switch);
288                 tmp.Offset  = OFFSETOF(next_switch);
289                 p = sw_xlat_addr(cb, &tmp);
290
291                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
292                 {
293                     WARN("Bad stack frame 0x%08lx\n", p);
294                     goto done_err;
295                 }
296                 curr_switch = (DWORD)frame16.frame32;
297                 curr_mode = stm_32bit;
298                 if (!sw_read_mem(cb, curr_switch, &ch, sizeof(ch)))
299                     curr_switch = 0;
300             }
301             else
302             {
303                 tmp.Mode    = AddrMode1616;
304                 tmp.Segment = SELECTOROF(next_switch);
305                 tmp.Offset  = OFFSETOF(next_switch);
306                 p = sw_xlat_addr(cb, &tmp);
307
308                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
309                 {
310                     WARN("Bad stack frame 0x%08lx\n", p);
311                     goto done_err;
312                 }
313
314                 TRACE("Got a 16 bit stack switch:"
315                       "\n\tframe32: %08lx"
316                       "\n\tedx:%08lx ecx:%08lx ebp:%08lx"
317                       "\n\tds:%04x es:%04x fs:%04x gs:%04x"
318                       "\n\tcall_from_ip:%08lx module_cs:%04lx relay=%08lx"
319                       "\n\tentry_ip:%04x entry_point:%08lx"
320                       "\n\tbp:%04x ip:%04x cs:%04x\n",
321                       (unsigned long)frame16.frame32,
322                       frame16.edx, frame16.ecx, frame16.ebp,
323                       frame16.ds, frame16.es, frame16.fs, frame16.gs,
324                       frame16.callfrom_ip, frame16.module_cs, frame16.relay,
325                       frame16.entry_ip, frame16.entry_point,
326                       frame16.bp, frame16.ip, frame16.cs);
327
328                       
329                 frame->AddrPC.Mode       = AddrMode1616;
330                 frame->AddrPC.Segment    = frame16.cs;
331                 frame->AddrPC.Offset     = frame16.ip;
332
333                 frame->AddrFrame.Mode    = AddrMode1616;
334                 frame->AddrFrame.Segment = SELECTOROF(next_switch);
335                 frame->AddrFrame.Offset  = frame16.bp;
336
337                 frame->AddrStack.Mode    = AddrMode1616;
338                 frame->AddrStack.Segment = SELECTOROF(next_switch);
339
340                 frame->AddrReturn.Mode    = AddrMode1616;
341                 frame->AddrReturn.Segment = frame16.cs;
342
343                 next_switch = curr_switch;
344                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
345                 {
346                     WARN("Bad stack frame 0x%08lx\n", next_switch);
347                     goto done_err;
348                 }
349                 curr_switch = (DWORD)frame32.frame16;
350                 tmp.Mode    = AddrMode1616;
351                 tmp.Segment = SELECTOROF(curr_switch);
352                 tmp.Offset  = OFFSETOF(curr_switch);
353
354                 if (!sw_read_mem(cb, sw_xlat_addr(cb, &tmp), &ch, sizeof(ch)))
355                     curr_switch = 0;
356                 curr_mode = stm_16bit;
357             }
358         }
359         else
360         {
361             frame->AddrPC = frame->AddrReturn;
362             if (curr_mode == stm_16bit)
363             {
364                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
365                 /* "pop up" previous BP value */
366                 if (!sw_read_mem(cb, sw_xlat_addr(cb, &frame->AddrFrame),
367                                  &val, sizeof(WORD)))
368                     goto done_err;
369                 frame->AddrFrame.Offset = val;
370             }
371             else
372             {
373                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD);
374                 /* "pop up" previous EBP value */
375                 if (!sw_read_mem(cb, frame->AddrFrame.Offset, 
376                                  &frame->AddrFrame.Offset, sizeof(DWORD)))
377                     goto done_err;
378             }
379         }
380     }
381
382     if (curr_mode == stm_16bit)
383     {
384         int     i;
385
386         p = sw_xlat_addr(cb, &frame->AddrFrame);
387         if (!sw_read_mem(cb, p + sizeof(WORD), &val, sizeof(WORD)))
388             goto done_err;
389         frame->AddrReturn.Offset = val;
390         /* get potential cs if a far call was used */
391         if (!sw_read_mem(cb, p + 2 * sizeof(WORD), &val, sizeof(WORD)))
392             goto done_err;
393         if (frame->AddrFrame.Offset & 1)
394             frame->AddrReturn.Segment = val; /* far call assumed */
395         else
396         {
397             /* not explicitly marked as far call, 
398              * but check whether it could be anyway
399              */
400             if ((val & 7) == 7 && val != frame->AddrReturn.Segment)
401             {
402                 LDT_ENTRY       le;
403
404                 if (GetThreadSelectorEntry(cb->hThread, val, &le) &&
405                     (le.HighWord.Bits.Type & 0x08)) /* code segment */
406                 {
407                     /* it is very uncommon to push a code segment cs as
408                      * a parameter, so this should work in most cases 
409                      */
410                     frame->AddrReturn.Segment = val;
411                 }
412             }
413         }
414         frame->AddrFrame.Offset &= ~1;
415         /* we "pop" parameters as 16 bit entities... of course, this won't
416          * work if the parameter is in fact bigger than 16bit, but
417          * there's no way to know that here
418          */
419         for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
420         {
421             sw_read_mem(cb, p + (2 + i) * sizeof(WORD), &val, sizeof(val));
422             frame->Params[i] = val;
423         }
424     }
425     else
426     {
427         if (!sw_read_mem(cb, frame->AddrFrame.Offset + sizeof(DWORD),
428                          &frame->AddrReturn.Offset, sizeof(DWORD)))
429         {
430             WARN("Cannot read new frame offset %08lx\n", frame->AddrFrame.Offset + sizeof(DWORD));
431             goto done_err;
432         }
433         sw_read_mem(cb, frame->AddrFrame.Offset + 2 * sizeof(DWORD), 
434                     frame->Params, sizeof(frame->Params));
435     }
436
437     frame->Far = TRUE;
438     frame->Virtual = TRUE;
439     p = sw_xlat_addr(cb, &frame->AddrPC);
440     if (p && sw_modl_bas(cb, p))
441         frame->FuncTableEntry = sw_tabl_acs(cb, p);
442     else
443         frame->FuncTableEntry = NULL;
444
445     TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx FuncTable=%p\n",
446           wine_dbgstr_addr(&frame->AddrPC), 
447           wine_dbgstr_addr(&frame->AddrFrame),
448           wine_dbgstr_addr(&frame->AddrReturn),
449           wine_dbgstr_addr(&frame->AddrStack), 
450           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
451           curr_switch, next_switch, frame->FuncTableEntry);
452
453     return TRUE;
454 done_err:
455     curr_mode = stm_done;
456     return FALSE;
457 }
458
459 /***********************************************************************
460  *              StackWalk (DBGHELP.@)
461  */
462 BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
463                       LPSTACKFRAME frame, LPVOID ctx,
464                       PREAD_PROCESS_MEMORY_ROUTINE f_read_mem,
465                       PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
466                       PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
467                       PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr)
468 {
469     struct stack_walk_callback  swcb;
470
471     TRACE("(%ld, %p, %p, %p, %p, %p, %p, %p, %p)\n",
472           MachineType, hProcess, hThread, frame, ctx,
473           f_read_mem, FunctionTableAccessRoutine,
474           GetModuleBaseRoutine, f_xlat_adr);
475
476     if (MachineType != IMAGE_FILE_MACHINE_I386)
477     {
478         SetLastError(ERROR_INVALID_PARAMETER);
479         return FALSE;
480     }
481
482     swcb.hProcess = hProcess;
483     swcb.hThread = hThread;
484     swcb.is32 = TRUE;
485     /* sigh... MS isn't even consistent in the func prototypes */
486     swcb.u.s32.f_read_mem = (f_read_mem) ? f_read_mem : read_mem;
487     swcb.u.s32.f_xlat_adr = (f_xlat_adr) ? f_xlat_adr : addr_to_linear;
488     swcb.u.s32.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess;
489     swcb.u.s32.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase;
490
491     return stack_walk(&swcb, frame);
492 }
493
494
495 /***********************************************************************
496  *              StackWalk64 (DBGHELP.@)
497  */
498 BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
499                         LPSTACKFRAME64 frame64, LPVOID ctx,
500                         PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem,
501                         PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
502                         PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
503                         PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr)
504 {
505     struct stack_walk_callback  swcb;
506     STACKFRAME                  frame32;
507     BOOL                        ret;
508
509     TRACE("(%ld, %p, %p, %p, %p, %p, %p, %p, %p)\n",
510           MachineType, hProcess, hThread, frame64, ctx,
511           f_read_mem, FunctionTableAccessRoutine,
512           GetModuleBaseRoutine, f_xlat_adr);
513
514     if (MachineType != IMAGE_FILE_MACHINE_I386)
515     {
516         SetLastError(ERROR_INVALID_PARAMETER);
517         return FALSE;
518     }
519
520     addr_64to32(&frame64->AddrPC,     &frame32.AddrPC);
521     addr_64to32(&frame64->AddrReturn, &frame32.AddrReturn);
522     addr_64to32(&frame64->AddrFrame,  &frame32.AddrFrame);
523     addr_64to32(&frame64->AddrStack,  &frame32.AddrStack);
524     addr_64to32(&frame64->AddrBStore, &frame32.AddrBStore);
525     frame32.FuncTableEntry = frame64->FuncTableEntry; /* FIXME */
526     frame32.Far = frame64->Far;
527     frame32.Virtual = frame64->Virtual;
528     frame32.Reserved[0] = (ULONG)frame64->Reserved[0];
529     frame32.Reserved[1] = (ULONG)frame64->Reserved[1];
530     frame32.Reserved[2] = (ULONG)frame64->Reserved[2];
531     /* we don't handle KdHelp */
532
533     swcb.hProcess = hProcess;
534     swcb.hThread = hThread;
535     swcb.is32 = FALSE;
536     /* sigh... MS isn't even consistent in the func prototypes */
537     swcb.u.s64.f_read_mem = (f_read_mem) ? f_read_mem : read_mem64;
538     swcb.u.s64.f_xlat_adr = f_xlat_adr;
539     swcb.u.s64.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess64;
540     swcb.u.s64.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase64;
541
542     ret = stack_walk(&swcb, &frame32);
543
544     addr_32to64(&frame32.AddrPC,     &frame64->AddrPC);
545     addr_32to64(&frame32.AddrReturn, &frame64->AddrReturn);
546     addr_32to64(&frame32.AddrFrame,  &frame64->AddrFrame);
547     addr_32to64(&frame32.AddrStack,  &frame64->AddrStack);
548     addr_32to64(&frame32.AddrBStore, &frame64->AddrBStore);
549     frame64->FuncTableEntry = frame32.FuncTableEntry; /* FIXME */
550     frame64->Params[0] = (ULONG)frame32.Params[0];
551     frame64->Params[1] = (ULONG)frame32.Params[1];
552     frame64->Params[2] = (ULONG)frame32.Params[2];
553     frame64->Params[3] = (ULONG)frame32.Params[3];
554     frame64->Far = frame32.Far;
555     frame64->Virtual = frame32.Virtual;
556     frame64->Reserved[0] = (ULONG)frame32.Reserved[0];
557     frame64->Reserved[1] = (ULONG)frame32.Reserved[1];
558     frame64->Reserved[2] = (ULONG)frame32.Reserved[2];
559     /* we don't handle KdHelp */
560     frame64->KdHelp.Thread = 0xC000FADE;
561     frame64->KdHelp.ThCallbackStack = 0x10;
562     frame64->KdHelp.ThCallbackBStore = 0;
563     frame64->KdHelp.NextCallback = 0;
564     frame64->KdHelp.FramePointer = 0;
565     frame64->KdHelp.KiCallUserMode = 0xD000DAFE;
566     frame64->KdHelp.KeUserCallbackDispatcher = 0xE000F000;
567     frame64->KdHelp.SystemRangeStart = 0xC0000000;
568     frame64->KdHelp.Reserved[0] /* KiUserExceptionDispatcher */ = 0xE0005000;
569
570     return ret;
571 }
572
573 /******************************************************************
574  *              SymRegisterFunctionEntryCallback (DBGHELP.@)
575  *
576  *
577  */
578 BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE hProc,
579                                              PSYMBOL_FUNCENTRY_CALLBACK cb, PVOID user)
580 {
581     FIXME("(%p %p %p): stub!\n", hProc, cb, user);
582     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
583     return FALSE;
584 }
585
586 /******************************************************************
587  *              SymRegisterFunctionEntryCallback64 (DBGHELP.@)
588  *
589  *
590  */
591 BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE hProc,
592                                                PSYMBOL_FUNCENTRY_CALLBACK64 cb,
593                                                ULONG64 user)
594 {
595     FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user));
596     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
597     return FALSE;
598 }