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