dlls/diasymreader/writer.c

   1 /*
   2  * Copyright 2022 Esme Povirk
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <time.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27 #include "rpc.h"
  28
  29 #include "wine/mscvpdb.h"
  30 #include "wine/debug.h"
  31 #include "wine/heap.h"
  32
  33 #include "diasymreader_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(diasymreader);
  36
  37 typedef struct SymWriter {
  38     ISymUnmanagedWriter5 iface;
  39     IPdbWriter IPdbWriter_iface;
  40     LONG ref;
  41     CRITICAL_SECTION lock;
  42     GUID pdb_guid;
  43     DWORD pdb_timestamp;
  44     DWORD pdb_age;
  45     WCHAR pdb_filename[MAX_PATH];
  46 } SymWriter;
  47
  48 typedef struct SymDocumentWriter {
  49     ISymUnmanagedDocumentWriter iface;
  50     LONG ref;
  51 } SymDocumentWriter;
  52
  53 static inline SymWriter *impl_from_ISymUnmanagedWriter5(ISymUnmanagedWriter5 *iface)
  54 {
  55     return CONTAINING_RECORD(iface, SymWriter, iface);
  56 }
  57
  58 static inline SymWriter *impl_from_IPdbWriter(IPdbWriter *iface)
  59 {
  60     return CONTAINING_RECORD(iface, SymWriter, IPdbWriter_iface);
  61 }
  62
  63 static inline SymDocumentWriter *impl_from_ISymUnmanagedDocumentWriter(ISymUnmanagedDocumentWriter *iface)
  64 {
  65     return CONTAINING_RECORD(iface, SymDocumentWriter, iface);
  66 }
  67
  68 static HRESULT WINAPI SymDocumentWriter_QueryInterface(ISymUnmanagedDocumentWriter *iface, REFIID iid,
  69     void **ppv)
  70 {
  71     SymDocumentWriter *This = impl_from_ISymUnmanagedDocumentWriter(iface);
  72
  73     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  74
  75     if (IsEqualIID(&IID_IUnknown, iid) ||
  76         IsEqualIID(&IID_ISymUnmanagedDocumentWriter, iid))
  77     {
  78         *ppv = &This->iface;
  79     }
  80     else
  81     {
  82         WARN("unknown interface %s\n", debugstr_guid(iid));
  83         *ppv = NULL;
  84         return E_NOINTERFACE;
  85     }
  86
  87     IUnknown_AddRef((IUnknown*)*ppv);
  88     return S_OK;
  89 }
  90
  91 static ULONG WINAPI SymDocumentWriter_AddRef(ISymUnmanagedDocumentWriter *iface)
  92 {
  93     SymDocumentWriter *This = impl_from_ISymUnmanagedDocumentWriter(iface);
  94     ULONG ref = InterlockedIncrement(&This->ref);
  95
  96     TRACE("(%p) refcount=%lu\n", iface, ref);
  97
  98     return ref;
  99 }
 100
 101 static ULONG WINAPI SymDocumentWriter_Release(ISymUnmanagedDocumentWriter *iface)
 102 {
 103     SymDocumentWriter *This = impl_from_ISymUnmanagedDocumentWriter(iface);
 104     ULONG ref = InterlockedDecrement(&This->ref);
 105
 106     TRACE("(%p) refcount=%lu\n", iface, ref);
 107
 108     if (ref == 0)
 109     {
 110         heap_free(This);
 111     }
 112
 113     return ref;
 114 }
 115
 116 static HRESULT WINAPI SymDocumentWriter_SetSource(ISymUnmanagedDocumentWriter *iface, ULONG32 sourceSize,
 117     BYTE source[])
 118 {
 119     FIXME("(%p,%u,%p)\n", iface, sourceSize, source);
 120     return S_OK;
 121 }
 122
 123 static HRESULT WINAPI SymDocumentWriter_SetChecksum(ISymUnmanagedDocumentWriter *iface, GUID algorithmID,
 124     ULONG32 checkSumSize, BYTE checkSum[])
 125 {
 126     FIXME("(%p,%s,%u,%p)\n", iface, debugstr_guid(&algorithmID), checkSumSize, checkSum);
 127     return S_OK;
 128 }
 129
 130 static const ISymUnmanagedDocumentWriterVtbl SymDocumentWriter_Vtbl = {
 131     SymDocumentWriter_QueryInterface,
 132     SymDocumentWriter_AddRef,
 133     SymDocumentWriter_Release,
 134     SymDocumentWriter_SetSource,
 135     SymDocumentWriter_SetChecksum
 136 };
 137
 138 static HRESULT WINAPI SymWriter_QueryInterface(ISymUnmanagedWriter5 *iface, REFIID iid,
 139     void **ppv)
 140 {
 141     SymWriter *This = impl_from_ISymUnmanagedWriter5(iface);
 142
 143     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 144
 145     if (IsEqualIID(&IID_IUnknown, iid) ||
 146         IsEqualIID(&IID_ISymUnmanagedWriter, iid) ||
 147         IsEqualIID(&IID_ISymUnmanagedWriter2, iid) ||
 148         IsEqualIID(&IID_ISymUnmanagedWriter3, iid) ||
 149         IsEqualIID(&IID_ISymUnmanagedWriter4, iid) ||
 150         IsEqualIID(&IID_ISymUnmanagedWriter5, iid))
 151     {
 152         *ppv = &This->iface;
 153     }
 154     else if (IsEqualIID(&IID_IPdbWriter, iid))
 155     {
 156         *ppv = &This->IPdbWriter_iface;
 157     }
 158     else
 159     {
 160         WARN("unknown interface %s\n", debugstr_guid(iid));
 161         *ppv = NULL;
 162         return E_NOINTERFACE;
 163     }
 164
 165     IUnknown_AddRef((IUnknown*)*ppv);
 166     return S_OK;
 167 }
 168
 169 static ULONG WINAPI SymWriter_AddRef(ISymUnmanagedWriter5 *iface)
 170 {
 171     SymWriter *This = impl_from_ISymUnmanagedWriter5(iface);
 172     ULONG ref = InterlockedIncrement(&This->ref);
 173
 174     TRACE("(%p) refcount=%lu\n", iface, ref);
 175
 176     return ref;
 177 }
 178
 179 static ULONG WINAPI SymWriter_Release(ISymUnmanagedWriter5 *iface)
 180 {
 181     SymWriter *This = impl_from_ISymUnmanagedWriter5(iface);
 182     ULONG ref = InterlockedDecrement(&This->ref);
 183
 184     TRACE("(%p) refcount=%lu\n", iface, ref);
 185
 186     if (ref == 0)
 187     {
 188         This->lock.DebugInfo->Spare[0] = 0;
 189         DeleteCriticalSection(&This->lock);
 190         heap_free(This);
 191     }
 192
 193     return ref;
 194 }
 195
 196 static HRESULT WINAPI SymWriter_DefineDocument(ISymUnmanagedWriter5 *iface, const WCHAR *url,
 197     const GUID *language, const GUID *languageVendor, const GUID *documentType,
 198     ISymUnmanagedDocumentWriter** pRetVal)
 199 {
 200     SymDocumentWriter *result;
 201
 202     FIXME("(%p,%s,%s,%s,%s,%p)\n", iface, debugstr_w(url), debugstr_guid(language),
 203         debugstr_guid(languageVendor), debugstr_guid(documentType), pRetVal);
 204
 205     if (!pRetVal)
 206         return E_POINTER;
 207
 208     result = heap_alloc(sizeof(*result));
 209     if (!result)
 210         return E_OUTOFMEMORY;
 211
 212     result->iface.lpVtbl = &SymDocumentWriter_Vtbl;
 213     result->ref = 1;
 214     *pRetVal = &result->iface;
 215
 216     return S_OK;
 217 }
 218
 219 static HRESULT WINAPI SymWriter_SetUserEntryPoint(ISymUnmanagedWriter5 *iface, mdMethodDef entryMethod)
 220 {
 221     FIXME("(%p,0x%x)\n", iface, entryMethod);
 222     return S_OK;
 223 }
 224
 225 static HRESULT WINAPI SymWriter_OpenMethod(ISymUnmanagedWriter5 *iface, mdMethodDef method)
 226 {
 227     FIXME("(%p,0x%x)\n", iface, method);
 228     return S_OK;
 229 }
 230
 231 static HRESULT WINAPI SymWriter_CloseMethod(ISymUnmanagedWriter5 *iface)
 232 {
 233     FIXME("(%p)\n", iface);
 234     return S_OK;
 235 }
 236
 237 static HRESULT WINAPI SymWriter_OpenScope(ISymUnmanagedWriter5 *iface, ULONG32 startOffset,
 238     ULONG32 *pRetVal)
 239 {
 240     FIXME("(%p,%u,%p)\n", iface, startOffset, pRetVal);
 241     *pRetVal = 0xdeadbeef;
 242     return S_OK;
 243 }
 244
 245 static HRESULT WINAPI SymWriter_CloseScope(ISymUnmanagedWriter5 *iface, ULONG32 endOffset)
 246 {
 247     FIXME("(%p,%u)\n", iface, endOffset);
 248     return S_OK;
 249 }
 250
 251 static HRESULT WINAPI SymWriter_SetScopeRange(ISymUnmanagedWriter5 *iface, ULONG32 scopeID, ULONG32 startOffset,
 252     ULONG32 endOffset)
 253 {
 254     FIXME("(%p,%u,%u,%u)\n", iface, scopeID, startOffset, endOffset);
 255     return S_OK;
 256 }
 257
 258 static HRESULT WINAPI SymWriter_DefineLocalVariable(ISymUnmanagedWriter5 *iface, const WCHAR *name,
 259     ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind,
 260     ULONG32 addr1, ULONG32 addr2, ULONG32 addr3, ULONG32 startOffset, ULONG32 endOffset)
 261 {
 262     FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, cSig, addrKind);
 263     return S_OK;
 264 }
 265
 266 static HRESULT WINAPI SymWriter_DefineParameter(ISymUnmanagedWriter5 *iface, const WCHAR *name,
 267     ULONG32 attributes, ULONG32 sequence, ULONG32 addrKind,
 268     ULONG32 addr1, ULONG32 addr2, ULONG32 addr3)
 269 {
 270     FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, sequence, addrKind);
 271     return S_OK;
 272 }
 273
 274 static HRESULT WINAPI SymWriter_DefineField(ISymUnmanagedWriter5 *iface, mdTypeDef parent,
 275     const WCHAR *name, ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind,
 276     ULONG32 addr1, ULONG32 addr2, ULONG32 addr3)
 277 {
 278     FIXME("(%p,0x%x,%s,0x%x,%u,%u)\n", iface, parent, debugstr_w(name), attributes, cSig, addrKind);
 279     return S_OK;
 280 }
 281
 282 static HRESULT WINAPI SymWriter_DefineGlobalVariable(ISymUnmanagedWriter5 *iface, const WCHAR *name,
 283     ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind,
 284     ULONG32 addr1, ULONG32 addr2, ULONG32 addr3)
 285 {
 286     FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, cSig, addrKind);
 287     return S_OK;
 288 }
 289
 290 static HRESULT WINAPI SymWriter_Close(ISymUnmanagedWriter5 *iface)
 291 {
 292     FIXME("(%p)\n", iface);
 293     return S_OK;
 294 }
 295
 296 static HRESULT WINAPI SymWriter_SetSymAttributes(ISymUnmanagedWriter5 *iface, mdToken parent,
 297     const WCHAR *name, ULONG32 cData, unsigned char data[])
 298 {
 299     FIXME("(%p,0x%x,%s,%u)\n", iface, parent, debugstr_w(name), cData);
 300     return S_OK;
 301 }
 302
 303 static HRESULT WINAPI SymWriter_OpenNamespace(ISymUnmanagedWriter5 *iface, const WCHAR *name)
 304 {
 305     FIXME("(%p,%s)\n", iface, debugstr_w(name));
 306     return S_OK;
 307 }
 308
 309 static HRESULT WINAPI SymWriter_CloseNamespace(ISymUnmanagedWriter5 *iface)
 310 {
 311     FIXME("(%p)\n", iface);
 312     return S_OK;
 313 }
 314
 315 static HRESULT WINAPI SymWriter_UsingNamespace(ISymUnmanagedWriter5 *iface, const WCHAR *fullName)
 316 {
 317     FIXME("(%p,%s)\n", iface, debugstr_w(fullName));
 318     return S_OK;
 319 }
 320
 321 static HRESULT WINAPI SymWriter_SetMethodSourceRange(ISymUnmanagedWriter5 *iface, ISymUnmanagedDocumentWriter *startDoc,
 322     ULONG32 startLine, ULONG32 startColumn, ISymUnmanagedDocumentWriter *endDoc, ULONG32 endLine, ULONG32 endColumn)
 323 {
 324     FIXME("(%p,%p,%u,%u,%p,%u,%u)\n", iface, startDoc, startLine, startColumn, endDoc, endLine, endColumn);
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI SymWriter_Initialize(ISymUnmanagedWriter5 *iface, IUnknown *emitter, const WCHAR *filename,
 329     IStream *pIStream, BOOL fFullBuild)
 330 {
 331     SymWriter *This = impl_from_ISymUnmanagedWriter5(iface);
 332
 333     FIXME("(%p,%p,%s,%p,%u)\n", iface, emitter, debugstr_w(filename), pIStream, fFullBuild);
 334
 335     EnterCriticalSection(&This->lock);
 336
 337     if (filename)
 338         wcsncpy_s(This->pdb_filename, MAX_PATH, filename, _TRUNCATE);
 339
 340     This->pdb_timestamp = _time32(NULL);
 341
 342     LeaveCriticalSection(&This->lock);
 343
 344     return S_OK;
 345 }
 346
 347 static HRESULT WINAPI SymWriter_GetDebugInfo(ISymUnmanagedWriter5 *iface, IMAGE_DEBUG_DIRECTORY *pIDD, DWORD cData,
 348     DWORD *pcData, BYTE data[])
 349 {
 350     SymWriter *This = impl_from_ISymUnmanagedWriter5(iface);
 351     DWORD name_length, data_size;
 352     OMFSignatureRSDS *rsds_data = (OMFSignatureRSDS*)data;
 353
 354     TRACE("(%p,%p,%lu,%p,%p)\n", iface, pIDD, cData, pcData, data);
 355
 356     EnterCriticalSection(&This->lock);
 357
 358     name_length = WideCharToMultiByte(CP_UTF8, 0, This->pdb_filename, -1, NULL, 0, NULL, NULL);
 359     data_size = FIELD_OFFSET(OMFSignatureRSDS, name) + name_length;
 360     if (pcData)
 361         *pcData = data_size;
 362
 363     if (pIDD)
 364     {
 365         pIDD->Characteristics = 0;
 366         pIDD->MajorVersion = 0;
 367         pIDD->MinorVersion = 0;
 368         pIDD->Type = IMAGE_DEBUG_TYPE_CODEVIEW;
 369         pIDD->SizeOfData = data_size;
 370     }
 371
 372     if (data)
 373     {
 374         if (data_size > cData)
 375         {
 376             LeaveCriticalSection(&This->lock);
 377             return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 378         }
 379
 380         memcpy(rsds_data->Signature, "RSDS", 4);
 381         rsds_data->guid = This->pdb_guid;
 382         rsds_data->age = This->pdb_age;
 383         WideCharToMultiByte(CP_UTF8, 0, This->pdb_filename, -1, rsds_data->name, name_length, NULL, NULL);
 384     }
 385
 386     LeaveCriticalSection(&This->lock);
 387
 388     return S_OK;
 389 }
 390
 391 static HRESULT WINAPI SymWriter_DefineSequencePoints(ISymUnmanagedWriter5 *iface, ISymUnmanagedDocumentWriter *document,
 392     ULONG32 spCount, ULONG32 offsets[], ULONG32 lines[], ULONG32 columns[], ULONG32 endLines[], ULONG32 endColumns[])
 393 {
 394     FIXME("(%p,%p,%u)\n", iface, document, spCount);
 395     return S_OK;
 396 }
 397
 398 static HRESULT WINAPI SymWriter_RemapToken(ISymUnmanagedWriter5 *iface, mdToken oldToken, mdToken newToken)
 399 {
 400     FIXME("(%p,0x%x,0x%x)\n", iface, oldToken, newToken);
 401     return S_OK;
 402 }
 403
 404 static HRESULT WINAPI SymWriter_Initialize2(ISymUnmanagedWriter5 *iface, IUnknown *emitter, const WCHAR *tempFilename,
 405     IStream *pIStream, BOOL fFullBuild, const WCHAR *finalFilename)
 406 {
 407     FIXME("(%p,%p,%s,%p,%u,%s)\n", iface, emitter, debugstr_w(tempFilename), pIStream, fFullBuild, debugstr_w(finalFilename));
 408     return S_OK;
 409 }
 410
 411 static HRESULT WINAPI SymWriter_DefineConstant(ISymUnmanagedWriter5 *iface, const WCHAR *name, VARIANT value, ULONG32 cSig,
 412     unsigned char signature[])
 413 {
 414     FIXME("(%p,%s,%s,%u,%p)\n", iface, debugstr_w(name), debugstr_variant(&value), cSig, signature);
 415     return S_OK;
 416 }
 417
 418 static HRESULT WINAPI SymWriter_Abort(ISymUnmanagedWriter5 *iface)
 419 {
 420     FIXME("(%p)\n", iface);
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI SymWriter_DefineLocalVariable2(ISymUnmanagedWriter5 *iface, const WCHAR *name, ULONG32 attributes,
 425     mdSignature sigToken, ULONG32 addrKind, ULONG32 addr1, ULONG32 addr2, ULONG32 addr3,
 426     ULONG32 startOffset, ULONG32 endOffset)
 427 {
 428     FIXME("(%p,%s,0x%x,0x%x,%u)\n", iface, debugstr_w(name), attributes, sigToken, addrKind);
 429     return S_OK;
 430 }
 431
 432 static HRESULT WINAPI SymWriter_DefineGlobalVariable2(ISymUnmanagedWriter5 *iface, const WCHAR *name, ULONG32 attributes,
 433     mdSignature sigToken, ULONG32 addrKind, ULONG32 addr1, ULONG32 addr2, ULONG32 addr3)
 434 {
 435     FIXME("(%p,%s,0x%x,0x%x,%u)\n", iface, debugstr_w(name), attributes, sigToken, addrKind);
 436     return S_OK;
 437 }
 438
 439 static HRESULT WINAPI SymWriter_DefineConstant2(ISymUnmanagedWriter5 *iface, const WCHAR *name, VARIANT value, mdSignature sigToken)
 440 {
 441     FIXME("(%p,%s,%s,0x%x)\n", iface, debugstr_w(name), debugstr_variant(&value), sigToken);
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI SymWriter_OpenMethod2(ISymUnmanagedWriter5 *iface, mdMethodDef method, ULONG32 isect, ULONG32 offset)
 446 {
 447     FIXME("(%p,0x%x,%u,%u)\n", iface, method, isect, offset);
 448     return S_OK;
 449 }
 450
 451 static HRESULT WINAPI SymWriter_Commit(ISymUnmanagedWriter5 *iface)
 452 {
 453     FIXME("(%p)\n", iface);
 454     return S_OK;
 455 }
 456
 457 static HRESULT WINAPI SymWriter_GetDebugInfoWithPadding(ISymUnmanagedWriter5 *iface, IMAGE_DEBUG_DIRECTORY *pIDD, DWORD cbData,
 458     DWORD* pcData, BYTE data[])
 459 {
 460     FIXME("(%p,%p,%lu,%p,%p)\n", iface, pIDD, cbData, pcData, data);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI SymWriter_OpenMapTokensToSourceSpans(ISymUnmanagedWriter5 *iface)
 465 {
 466     FIXME("(%p)\n", iface);
 467     return S_OK;
 468 }
 469
 470 static HRESULT WINAPI SymWriter_CloseMapTokensToSourceSpans(ISymUnmanagedWriter5 *iface)
 471 {
 472     FIXME("(%p)\n", iface);
 473     return S_OK;
 474 }
 475
 476 static HRESULT WINAPI SymWriter_MapTokenToSourceSpan(ISymUnmanagedWriter5 *iface, mdToken token, ISymUnmanagedDocumentWriter* document,
 477                                  ULONG32 line, ULONG32 column, ULONG32 endLine, ULONG32 endColumn)
 478 {
 479     FIXME("(%p,%x,%p,%u,%u,%u,%u)\n", iface, token, document, line, column, endLine, endColumn);
 480     return S_OK;
 481 }
 482
 483
 484 static const ISymUnmanagedWriter5Vtbl SymWriter_Vtbl = {
 485     SymWriter_QueryInterface,
 486     SymWriter_AddRef,
 487     SymWriter_Release,
 488     SymWriter_DefineDocument,
 489     SymWriter_SetUserEntryPoint,
 490     SymWriter_OpenMethod,
 491     SymWriter_CloseMethod,
 492     SymWriter_OpenScope,
 493     SymWriter_CloseScope,
 494     SymWriter_SetScopeRange,
 495     SymWriter_DefineLocalVariable,
 496     SymWriter_DefineParameter,
 497     SymWriter_DefineField,
 498     SymWriter_DefineGlobalVariable,
 499     SymWriter_Close,
 500     SymWriter_SetSymAttributes,
 501     SymWriter_OpenNamespace,
 502     SymWriter_CloseNamespace,
 503     SymWriter_UsingNamespace,
 504     SymWriter_SetMethodSourceRange,
 505     SymWriter_Initialize,
 506     SymWriter_GetDebugInfo,
 507     SymWriter_DefineSequencePoints,
 508     SymWriter_RemapToken,
 509     SymWriter_Initialize2,
 510     SymWriter_DefineConstant,
 511     SymWriter_Abort,
 512     SymWriter_DefineLocalVariable2,
 513     SymWriter_DefineGlobalVariable2,
 514     SymWriter_DefineConstant2,
 515     SymWriter_OpenMethod2,
 516     SymWriter_Commit,
 517     SymWriter_GetDebugInfoWithPadding,
 518     SymWriter_OpenMapTokensToSourceSpans,
 519     SymWriter_CloseMapTokensToSourceSpans,
 520     SymWriter_MapTokenToSourceSpan
 521 };
 522
 523 static HRESULT WINAPI SymWriter_PdbWriter_QueryInterface(IPdbWriter *iface, REFIID iid, void **ppv)
 524 {
 525     SymWriter *This = impl_from_IPdbWriter(iface);
 526     return ISymUnmanagedWriter5_QueryInterface(&This->iface, iid, ppv);
 527 }
 528
 529 static ULONG WINAPI SymWriter_PdbWriter_AddRef(IPdbWriter *iface)
 530 {
 531     SymWriter *This = impl_from_IPdbWriter(iface);
 532     return ISymUnmanagedWriter5_AddRef(&This->iface);
 533 }
 534
 535 static ULONG WINAPI SymWriter_PdbWriter_Release(IPdbWriter *iface)
 536 {
 537     SymWriter *This = impl_from_IPdbWriter(iface);
 538     return ISymUnmanagedWriter5_Release(&This->iface);
 539 }
 540
 541 static HRESULT WINAPI SymWriter_SetPath(IPdbWriter *iface, const WCHAR *fullpath, IStream *stream, BOOL fullbuild)
 542 {
 543     FIXME("(%p,%s,%p,%u)\n", iface, debugstr_w(fullpath), stream, fullbuild);
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI SymWriter_OpenMod(IPdbWriter *iface, const WCHAR *modulename, const WCHAR *fullpath)
 548 {
 549     FIXME("(%p,%s,%s)\n", iface, debugstr_w(modulename), debugstr_w(fullpath));
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI SymWriter_CloseMod(IPdbWriter *iface)
 554 {
 555     FIXME("(%p)\n", iface);
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI SymWriter_GetPath(IPdbWriter *iface, DWORD ccData, DWORD *pccData, WCHAR *path)
 560 {
 561     FIXME("(%p,%lu,%p,%p)\n", iface, ccData, pccData, path);
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI SymWriter_GetSignatureAge(IPdbWriter *iface, DWORD *timestamp, DWORD *age)
 566 {
 567     SymWriter *This = impl_from_IPdbWriter(iface);
 568
 569     TRACE("(%p,%p,%p)\n", This, timestamp, age);
 570
 571     EnterCriticalSection(&This->lock);
 572
 573     if (timestamp)
 574         *timestamp = This->pdb_timestamp;
 575     if (age)
 576         *age = This->pdb_age;
 577
 578     LeaveCriticalSection(&This->lock);
 579
 580     return S_OK;
 581 }
 582
 583 static const IPdbWriterVtbl SymWriter_PdbWriter_Vtbl = {
 584     SymWriter_PdbWriter_QueryInterface,
 585     SymWriter_PdbWriter_AddRef,
 586     SymWriter_PdbWriter_Release,
 587     SymWriter_SetPath,
 588     SymWriter_OpenMod,
 589     SymWriter_CloseMod,
 590     SymWriter_GetPath,
 591     SymWriter_GetSignatureAge
 592 };
 593
 594 HRESULT SymWriter_CreateInstance(REFIID iid, void **ppv)
 595 {
 596     SymWriter *This;
 597     HRESULT hr;
 598
 599     This = heap_alloc(sizeof(*This));
 600     if (!This)
 601         return E_OUTOFMEMORY;
 602
 603     This->iface.lpVtbl = &SymWriter_Vtbl;
 604     This->IPdbWriter_iface.lpVtbl = &SymWriter_PdbWriter_Vtbl;
 605     This->ref = 1;
 606     InitializeCriticalSection(&This->lock);
 607     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SymWriter.lock");
 608     UuidCreate(&This->pdb_guid);
 609     This->pdb_age = 1;
 610     This->pdb_filename[0] = 0;
 611
 612     hr = IUnknown_QueryInterface(&This->iface, iid, ppv);
 613
 614     ISymUnmanagedWriter5_Release(&This->iface);
 615
 616     return hr;
 617 }