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