1 /*
2 - Info:
3 - http://stackoverflow.com/questions/32251638/dbghelp-get-full-symbol-signature-function-name-parameters-types
4 - http://www.debuginfo.com/articles/dbghelptypeinfo.html
5 - TODO:
6 - Dump usage
7 - Test for dbghelp + symsrv and warn if not working
8 - Resolve forwarders
9
10 */
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <windows.h>
14
15 #ifdef __REACTOS__
16 #include <dbghelp.h>
17 #include <cvconst.h>
18
19 // dirty hacks!
20 #define sprintf_s(dst, size, format, ...) sprintf(dst, format, __VA_ARGS__)
21 #define vsprintf_s(dst, size, format, ap) vsprintf(dst, format, ap)
22 #define fopen_s(pfile, name, mode) ((*pfile = fopen(name, mode)), (*pfile != 0) ? 0 : -1)
23 #define strcpy_s(dst, size, src) strncpy(dst, src, size)
24 #define strcat_s(dst, size, src) strncat(dst, src, size)
25
26 #else
27 #ifdef _MSC_VER
28 #pragma warning(disable:4091)
29 #endif
30 #define _NO_CVCONST_H
31 #include <dbghelp.h>
32
33 // This is from cvconst.h, but win sdk lacks this file
34 enum BasicType {
35 btNoType = 0,
36 btVoid = 1,
37 btChar = 2,
38 btWChar = 3,
39 btInt = 6,
40 btUInt = 7,
41 btFloat = 8,
42 btBCD = 9,
43 btBool = 10,
44 btLong = 13,
45 btULong = 14,
46 btCurrency = 25,
47 btDate = 26,
48 btVariant = 27,
49 btComplex = 28,
50 btBit = 29,
51 btBSTR = 30,
52 btHresult = 31
53 };
54
55 typedef enum CV_call_e {
56 CV_CALL_NEAR_C = 0x00,
57 CV_CALL_NEAR_FAST = 0x04,
58 CV_CALL_NEAR_STD = 0x07,
59 CV_CALL_NEAR_SYS = 0x09,
60 CV_CALL_THISCALL = 0x0b,
61 CV_CALL_CLRCALL = 0x16
62 } CV_call_e;
63
64 #endif // __REACTOS__
65
66
67 typedef enum _PARAM_TYPES
68 {
69 TYPE_NONE,
70 TYPE_LONG,
71 TYPE_DOUBLE,
72 TYPE_PTR,
73 TYPE_STR,
74 TYPE_WSTR
75 } PARAM_TYPES, *PPARAM_TYPES;
76
77 const char*
78 gapszTypeStrings[] =
79 {
80 "???",
81 "long",
82 "double",
83 "ptr",
84 "str",
85 "wstr"
86 };
87
88 #define MAX_PARAMETERS 64
89 typedef struct _EXPORT
90 {
91 PSTR pszName;
92 PSTR pszSymbol;
93 PSTR pszForwarder;
94 ULONG ulRva;
95 DWORD dwCallingConvention;
96 ULONG fForwarder : 1;
97 ULONG fNoName : 1;
98 ULONG fData : 1;
99 ULONG cParameters;
100 PARAM_TYPES aeParameters[MAX_PARAMETERS];
101 } EXPORT, *PEXPORT;
102
103 typedef struct _EXPORT_DATA
104 {
105 ULONG cNumberOfExports;
106 EXPORT aExports[1];
107 } EXPORT_DATA, *PEXPORT_DATA;
108
109 HANDLE ghProcess;
110
111 void
error(_In_ const char * pszFormat,...)112 error(
113 _In_ const char* pszFormat,
114 ...)
115 {
116 CHAR szBuffer[512];
117 SIZE_T cchBuffer;
118 DWORD dwLastError;
119 va_list argptr;
120
121 /* Get last error */
122 dwLastError = GetLastError();
123
124 va_start(argptr, pszFormat);
125 cchBuffer = vsprintf_s(szBuffer, sizeof(szBuffer), pszFormat, argptr);
126 va_end(argptr);
127
128 /* Strip trailing newlines */
129 _Analysis_assume_(cchBuffer < sizeof(szBuffer));
130 while ((cchBuffer >= 1) &&
131 ((szBuffer[cchBuffer - 1] == '\r') ||
132 (szBuffer[cchBuffer - 1] == '\n')))
133 {
134 szBuffer[cchBuffer - 1] = '\0';
135 cchBuffer--;
136 }
137
138 /* Check if we have an error */
139 if (dwLastError != ERROR_SUCCESS)
140 {
141 /* Append error code */
142 cchBuffer += sprintf_s(szBuffer + cchBuffer,
143 sizeof(szBuffer) - cchBuffer,
144 " [error %lu: ", dwLastError);
145
146 /* Format the last error code */
147 cchBuffer += FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
148 NULL,
149 dwLastError,
150 0,
151 szBuffer + cchBuffer,
152 (DWORD)(sizeof(szBuffer) - cchBuffer),
153 NULL);
154
155 /* Strip trailing newlines */
156 _Analysis_assume_(cchBuffer < sizeof(szBuffer));
157 while ((cchBuffer >= 1) &&
158 ((szBuffer[cchBuffer - 1] == '\r') ||
159 (szBuffer[cchBuffer - 1] == '\n')))
160 {
161 szBuffer[cchBuffer - 1] = '\0';
162 cchBuffer--;
163 }
164
165 fprintf(stderr, "%s]\n", szBuffer);
166 }
167 else
168 {
169 fprintf(stderr, "%s\n", szBuffer);
170 }
171 }
172
173 BOOL
InitDbgHelp(VOID)174 InitDbgHelp(
175 VOID)
176 {
177 static const char *pszMsSymbolServer = "srv**symbols*http://msdl.microsoft.com/download/symbols";
178 DWORD Options;
179
180 /* Save current process ;-) */
181 ghProcess = GetCurrentProcess();
182
183 /* Initialize dbghelp */
184 if (!SymInitialize(ghProcess, 0, FALSE))
185 {
186 error("SymInitialize() failed.");
187 return FALSE;
188 }
189
190 /* Set options */
191 Options = SymGetOptions();
192 Options |= SYMOPT_ALLOW_ABSOLUTE_SYMBOLS | SYMOPT_INCLUDE_32BIT_MODULES | SYMOPT_DEBUG;// | SYMOPT_NO_PROMPTS;
193 Options &= ~SYMOPT_DEFERRED_LOADS;
194 SymSetOptions(Options);
195
196 /* Test if we can reach the MS symbol server */
197 if (!SymSrvIsStore(ghProcess, pszMsSymbolServer))
198 {
199 error("Failed to connect to symbol server.");
200 return FALSE;
201 }
202
203 /* Set MS symbol server as symbol search path */
204 SymSetSearchPath(ghProcess, pszMsSymbolServer);
205
206 return TRUE;
207 }
208
209 HMODULE
LoadModuleWithSymbolsFullPath(_In_ PSTR pszFullModuleFileName)210 LoadModuleWithSymbolsFullPath(
211 _In_ PSTR pszFullModuleFileName)
212 {
213 HMODULE hmod;
214 DWORD64 dwModuleBase;
215
216 /* Load the DLL */
217 hmod = LoadLibraryExA(pszFullModuleFileName,
218 NULL,
219 LOAD_IGNORE_CODE_AUTHZ_LEVEL |
220 DONT_RESOLVE_DLL_REFERENCES |
221 LOAD_WITH_ALTERED_SEARCH_PATH);
222 if (hmod == NULL)
223 {
224 return NULL;
225 }
226
227 /* Load symbols for this module */
228 dwModuleBase = SymLoadModule64(ghProcess,
229 NULL,
230 pszFullModuleFileName,
231 NULL,
232 (DWORD_PTR)hmod,
233 0);
234 if (dwModuleBase == 0)
235 {
236 /* ERROR_SUCCESS means, we have symbols already */
237 if (GetLastError() != ERROR_SUCCESS)
238 {
239 return NULL;
240 }
241 }
242 else
243 {
244 printf("Successfully loaded symbols for '%s'\n",
245 pszFullModuleFileName);
246 }
247
248 return hmod;
249 }
250
251 HMODULE
LoadModuleWithSymbols(_In_ PSTR pszModuleName)252 LoadModuleWithSymbols(
253 _In_ PSTR pszModuleName)
254 {
255 CHAR szFullFileName[MAX_PATH];
256 HMODULE hmod;
257
258 /* Check if the file name has a path */
259 if (strchr(pszModuleName, '\\') != NULL)
260 {
261 /* Try as it is */
262 hmod = LoadModuleWithSymbolsFullPath(pszModuleName);
263 if (hmod != NULL)
264 {
265 return hmod;
266 }
267 }
268
269 /* Try current directory */
270 GetCurrentDirectoryA(MAX_PATH, szFullFileName);
271 strcat_s(szFullFileName, sizeof(szFullFileName), "\\");
272 strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
273 hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
274 if (hmod != NULL)
275 {
276 return hmod;
277 }
278
279 /* Try system32 */
280 strcpy_s(szFullFileName, sizeof(szFullFileName), "%systemroot%\\system32\\");
281 strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
282 hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
283 if (hmod != NULL)
284 {
285 return hmod;
286 }
287
288 #ifdef _WIN64
289 /* Try SysWOW64 */
290 strcpy_s(szFullFileName, sizeof(szFullFileName), "%systemroot%\\SysWOW64\\");
291 strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
292 hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
293 if (hmod != NULL)
294 {
295 return hmod;
296 }
297 #endif // _WIN64
298
299 return NULL;
300 }
301
302 HRESULT
GetExportsFromFile(_In_ HMODULE hmod,_Out_ PEXPORT_DATA * ppExportData)303 GetExportsFromFile(
304 _In_ HMODULE hmod,
305 _Out_ PEXPORT_DATA* ppExportData)
306 {
307 PBYTE pjImageBase;
308 PIMAGE_EXPORT_DIRECTORY pExportDir;
309 ULONG i, cjExportSize, cFunctions, cjTableSize;
310 PEXPORT_DATA pExportData;
311 PULONG pulAddressTable, pulNameTable;
312 PUSHORT pusOrdinalTable;
313
314 pjImageBase = (PBYTE)hmod;
315
316 /* Get the export directory */
317 pExportDir = ImageDirectoryEntryToData(pjImageBase,
318 TRUE,
319 IMAGE_DIRECTORY_ENTRY_EXPORT,
320 &cjExportSize);
321 if (pExportDir == NULL)
322 {
323 fprintf(stderr, "Failed to get export directory\n");
324 return E_FAIL;
325 }
326
327 cFunctions = pExportDir->NumberOfFunctions;
328 cjTableSize = FIELD_OFFSET(EXPORT_DATA, aExports[cFunctions]);
329
330 pExportData = malloc(cjTableSize);
331 if (pExportData == NULL)
332 {
333 error("Failed to allocate %u bytes of memory for export table\n", cjTableSize);
334 return E_OUTOFMEMORY;
335 }
336
337 RtlZeroMemory(pExportData, cjTableSize);
338
339 pulAddressTable = (PULONG)(pjImageBase + pExportDir->AddressOfFunctions);
340
341 pExportData->cNumberOfExports = cFunctions;
342
343 /* Loop through the function table */
344 for (i = 0; i < cFunctions; i++)
345 {
346 PVOID pvFunction = (pjImageBase + pulAddressTable[i]);
347
348 /* Check if this is a forwarder */
349 if ((ULONG_PTR)((PUCHAR)pvFunction - (PUCHAR)pExportDir) < cjExportSize)
350 {
351 pExportData->aExports[i].pszForwarder = _strdup(pvFunction);
352 }
353 else
354 {
355 pExportData->aExports[i].ulRva = pulAddressTable[i];
356 }
357 }
358
359 pulNameTable = (PULONG)(pjImageBase + pExportDir->AddressOfNames);
360 pusOrdinalTable = (PUSHORT)(pjImageBase + pExportDir->AddressOfNameOrdinals);
361
362 /* Loop through the name table */
363 for (i = 0; i < pExportDir->NumberOfNames; i++)
364 {
365 ULONG iIndex = pusOrdinalTable[i];
366 PSTR pszName = (PSTR)(pjImageBase + pulNameTable[i]);
367
368 pExportData->aExports[iIndex].pszName = _strdup(pszName);
369 }
370
371 *ppExportData = pExportData;
372 return S_OK;
373 }
374
375 BOOL
376 CALLBACK
EnumParametersCallback(_In_ PSYMBOL_INFO pSymInfo,_In_ ULONG SymbolSize,_In_ PVOID UserContext)377 EnumParametersCallback(
378 _In_ PSYMBOL_INFO pSymInfo,
379 _In_ ULONG SymbolSize,
380 _In_ PVOID UserContext)
381 {
382 PEXPORT pExport = (PEXPORT)UserContext;
383 enum SymTagEnum eSymTag;
384 enum BasicType eBaseType;
385 DWORD dwTypeIndex;
386 ULONG64 ullLength;
387
388 /* If it's not a parameter, skip it */
389 if (!(pSymInfo->Flags & SYMFLAG_PARAMETER))
390 {
391 return TRUE;
392 }
393
394 /* Count this parameter */
395 pExport->cParameters++;
396
397 /* Get the type for the parameter */
398 if (SymGetTypeInfo(ghProcess,
399 pSymInfo->ModBase,
400 pSymInfo->TypeIndex,
401 TI_GET_SYMTAG,
402 &eSymTag))
403 {
404 switch (eSymTag)
405 {
406 case SymTagUDT:
407 case SymTagBaseType:
408
409 /* Try to get the size */
410 if (SymGetTypeInfo(ghProcess,
411 pSymInfo->ModBase,
412 pSymInfo->TypeIndex,
413 TI_GET_LENGTH,
414 &ullLength))
415 {
416 if (ullLength > 8)
417 {
418 /* That is probably not possible */
419 __debugbreak();
420 }
421
422 if (ullLength > 4)
423 {
424 /* 'double' type */
425 pExport->aeParameters[pExport->cParameters - 1] = TYPE_DOUBLE;
426 break;
427 }
428 }
429
430 /* Default to 'long' type */
431 pExport->aeParameters[pExport->cParameters - 1] = TYPE_LONG;
432 break;
433
434 case SymTagEnum:
435 /* 'long' type */
436 pExport->aeParameters[pExport->cParameters - 1] = TYPE_LONG;
437 break;
438
439 case SymTagPointerType:
440 /* 'ptr' type */
441 pExport->aeParameters[pExport->cParameters - 1] = TYPE_PTR;
442
443 /* Try to get the underlying type */
444 if (SymGetTypeInfo(ghProcess,
445 pSymInfo->ModBase,
446 pSymInfo->TypeIndex,
447 TI_GET_TYPEID,
448 &dwTypeIndex))
449 {
450 /* Try to get the base type */
451 if (SymGetTypeInfo(ghProcess,
452 pSymInfo->ModBase,
453 dwTypeIndex,
454 TI_GET_BASETYPE,
455 &eBaseType))
456 {
457 /* Check for string types */
458 if (eBaseType == btChar)
459 {
460 /* 'str' type */
461 pExport->aeParameters[pExport->cParameters - 1] = TYPE_STR;
462 }
463 else if (eBaseType == btWChar)
464 {
465 /* 'wstr' type */
466 pExport->aeParameters[pExport->cParameters - 1] = TYPE_WSTR;
467 }
468 }
469 }
470 break;
471
472 default:
473 printf("Unhandled eSymTag: %u\n", eSymTag);
474 return FALSE;
475 }
476 }
477 else
478 {
479 printf("Could not get type info. Fallig back to ptr\n");
480 pExport->aeParameters[pExport->cParameters - 1] = TYPE_PTR;
481 }
482
483 return TRUE;
484 }
485
486 ULONG64
GetFunctionFromForwarder(_In_ PCSTR pszForwarder)487 GetFunctionFromForwarder(
488 _In_ PCSTR pszForwarder)
489 {
490 CHAR szDllName[MAX_SYM_NAME];
491 PCH pchDot, pszName;
492 ULONG64 ullFunction;
493 HMODULE hmod;
494
495 /* Copy the forwarder name */
496 strcpy_s(szDllName, sizeof(szDllName), pszForwarder);
497
498 /* Find the '.' */
499 pchDot = strchr(szDllName, '.');
500 if (pchDot == NULL)
501 {
502 error("Invalid name for forwarder '%s'!", pszForwarder);
503 return 0;
504 }
505
506 /* Terminate DLL name */
507 *pchDot = '\0';
508
509 /* Load the DLL */
510 hmod = LoadModuleWithSymbols(szDllName);
511 if (hmod == NULL)
512 {
513 error("Failed to load module for forwarder '%s'!", pszForwarder);
514 return 0;
515 }
516
517 /* Get the function name and check for ordinal */
518 pszName = pchDot + 1;
519 if (pszName[0] == '#')
520 {
521 ULONG iOrdinal = strtoul(pszName + 1, NULL, 10);
522 if ((iOrdinal == 0) || (iOrdinal > 0xFFFF))
523 {
524 error("Got invalid ordinal %u for ''", iOrdinal, pszForwarder);
525 return 0;
526 }
527
528 pszName = (PSTR)(ULONG_PTR)iOrdinal;
529 }
530
531 /* Get the function address */
532 ullFunction = (ULONG_PTR)GetProcAddress(hmod, pszName);
533 if (ullFunction == 0)
534 {
535 error("Failed to resolve '%s' in '%s'.", pchDot + 1, szDllName);
536 return 0;
537 }
538
539 return ullFunction;
540 }
541
542 HRESULT
ParseImageSymbols(_In_ HMODULE hmod,_Inout_ PEXPORT_DATA pExportData)543 ParseImageSymbols(
544 _In_ HMODULE hmod,
545 _Inout_ PEXPORT_DATA pExportData)
546 {
547 DWORD64 dwModuleBase;
548 ULONG i;
549 IMAGEHLP_STACK_FRAME StackFrame;
550 SYMBOL_INFO_PACKAGE sym;
551
552 dwModuleBase = (DWORD_PTR)hmod;
553
554 /* Loop through all exports */
555 for (i = 0; i < pExportData->cNumberOfExports; i++)
556 {
557 PEXPORT pExport = &pExportData->aExports[i];
558 ULONG64 ullFunction = dwModuleBase + pExportData->aExports[i].ulRva;
559 ULONG64 ullDisplacement;
560
561 /* Check if this is a forwarder */
562 if (pExport->pszForwarder != NULL)
563 {
564 /* Load the module and get the function address */
565 ullFunction = GetFunctionFromForwarder(pExport->pszForwarder);
566 if (ullFunction == 0)
567 {
568 printf("Failed to get function for forwarder '%s'. Skipping.\n", pExport->pszForwarder);
569 continue;
570 }
571 }
572
573 RtlZeroMemory(&sym, sizeof(sym));
574 sym.si.SizeOfStruct = sizeof(SYMBOL_INFO);
575 sym.si.MaxNameLen = MAX_SYM_NAME;
576
577 /* Try to find the symbol */
578 if (!SymFromAddr(ghProcess, ullFunction, &ullDisplacement, &sym.si))
579 {
580 error("Error: SymFromAddr() failed.");
581 continue;
582 }
583
584 /* Get the symbol name */
585 pExport->pszSymbol = _strdup(sym.si.Name);
586
587 /* Check if it is a function */
588 if (sym.si.Tag == SymTagFunction)
589 {
590 /* Get the calling convention */
591 if (!SymGetTypeInfo(ghProcess,
592 dwModuleBase,
593 sym.si.TypeIndex,
594 TI_GET_CALLING_CONVENTION,
595 &pExport->dwCallingConvention))
596 {
597 /* Fall back to __stdcall */
598 pExport->dwCallingConvention = CV_CALL_NEAR_STD;
599 }
600
601 /* Set the context to the function address */
602 RtlZeroMemory(&StackFrame, sizeof(StackFrame));
603 StackFrame.InstructionOffset = ullFunction;
604 if (!SymSetContext(ghProcess, &StackFrame, NULL))
605 {
606 error("SymSetContext failed for i = %u.", i);
607 continue;
608 }
609
610 /* Enumerate all symbols for this function */
611 if (!SymEnumSymbols(ghProcess,
612 0, // use SymSetContext
613 NULL,
614 EnumParametersCallback,
615 pExport))
616 {
617 error("SymEnumSymbols failed for i = %u.", i);
618 continue;
619 }
620 }
621 else if (sym.si.Tag == SymTagPublicSymbol)
622 {
623 pExport->dwCallingConvention = CV_CALL_NEAR_STD;
624 }
625 else if (sym.si.Tag == SymTagData)
626 {
627 pExport->fData = TRUE;
628 }
629 }
630
631 return S_OK;
632 }
633
634 const CHAR*
GetCallingConvention(_In_ PEXPORT pExport)635 GetCallingConvention(
636 _In_ PEXPORT pExport)
637 {
638 if (pExport->fData)
639 {
640 return "extern";
641 }
642
643 #ifndef _M_AMD64
644 switch (pExport->dwCallingConvention)
645 {
646 case CV_CALL_NEAR_C:
647 return "cdecl";
648 case CV_CALL_NEAR_FAST:
649 return "fastcall";
650 case CV_CALL_NEAR_STD:
651 return "stdcall";
652 case CV_CALL_NEAR_SYS:
653 return "syscall";
654 case CV_CALL_THISCALL:
655 return "thiscall";
656 default:
657 __debugbreak();
658 }
659 #endif
660 return "stdcall";
661 }
662
663 HRESULT
CreateSpecFile(_In_ PCSTR pszSpecFile,_In_ PEXPORT_DATA pExportData)664 CreateSpecFile(
665 _In_ PCSTR pszSpecFile,
666 _In_ PEXPORT_DATA pExportData)
667 {
668 FILE *file;
669 ULONG i, p;
670 PEXPORT pExport;
671
672 /* Create the spec file */
673 if (fopen_s(&file, pszSpecFile, "w") != 0)
674 {
675 error("Failed to open spec file: '%s'\n", pszSpecFile);
676 return E_FAIL;
677 }
678
679 /* Loop all exports */
680 for (i = 0; i < pExportData->cNumberOfExports; i++)
681 {
682 pExport = &pExportData->aExports[i];
683
684 fprintf(file, "%lu %s ", i + 1, GetCallingConvention(pExport));
685 //if (pExport->fNoName)
686 if (pExport->pszName == NULL)
687 {
688 fprintf(file, "-noname ");
689 }
690
691 if (pExport->pszName != NULL)
692 {
693 fprintf(file, "%s", pExport->pszName);
694 }
695 else if (pExport->pszSymbol != NULL)
696 {
697 fprintf(file, "%s", pExport->pszSymbol);
698 }
699 else
700 {
701 fprintf(file, "NamelessExport_%lu", i);
702 }
703
704 if (!pExport->fData)
705 {
706 fprintf(file, "(");
707 for (p = 0; p < pExport->cParameters; p++)
708 {
709 fprintf(file, "%s", gapszTypeStrings[pExport->aeParameters[p]]);
710 if ((p + 1) < pExport->cParameters)
711 {
712 fprintf(file, " ");
713 }
714 }
715 fprintf(file, ")");
716 }
717
718 if (pExport->pszForwarder != NULL)
719 {
720 fprintf(file, " %s", pExport->pszForwarder);
721 }
722
723 fprintf(file, "\n");
724 }
725
726 fclose(file);
727
728 return S_OK;
729 }
730
main(int argc,char * argv[])731 int main(int argc, char* argv[])
732 {
733 HRESULT hr;
734 CHAR szSpecFile[MAX_PATH];
735 PSTR pszSpecFile;
736 PEXPORT_DATA pExportData;
737 HMODULE hmod;
738
739 /* Check parameters */
740 if ((argc < 2) || !strcmp(argv[1], "/?"))
741 {
742 printf("syntax: createspec <image file> [<spec file>]\n");
743 return 0;
744 }
745
746 /* Check if we have a spec file name */
747 if (argc > 2)
748 {
749 pszSpecFile = argv[2];
750 }
751 else
752 {
753 /* Create spec file name from image file name */
754 PSTR pszStart = strrchr(argv[1], '\\');
755 if (pszStart == 0)
756 pszStart = argv[1];
757
758 strcpy_s(szSpecFile, sizeof(szSpecFile), pszStart);
759 strcat_s(szSpecFile, sizeof(szSpecFile), ".spec");
760 pszSpecFile = szSpecFile;
761 }
762
763 /* Initialize dbghelp.dll */
764 if (!InitDbgHelp())
765 {
766 error("Failed to init dbghelp!\n"
767 "Make sure you have dbghelp.dll and symsrv.dll in the same folder.\n");
768 return E_FAIL;
769 }
770
771 /* Load the file including symbols */
772 printf("Loading symbols for '%s', please wait...\n", argv[1]);
773 hmod = LoadModuleWithSymbols(argv[1]);
774 if (hmod == NULL)
775 {
776 error("Failed to load module '%s'!", argv[1]);
777 return E_FAIL;
778 }
779
780 /* Get the exports */
781 hr = GetExportsFromFile(hmod, &pExportData);
782 if (!SUCCEEDED(hr))
783 {
784 error("Failed to get exports: %lx\n", hr);
785 return hr;
786 }
787
788 /* Get additional info from symbols */
789 hr = ParseImageSymbols(hmod, pExportData);
790 if (!SUCCEEDED(hr))
791 {
792 error("Failed to get symbol information: hr=%lx\n", hr);
793 }
794
795 /* Write the spec file */
796 hr = CreateSpecFile(pszSpecFile, pExportData);
797
798 printf("Spec file '%s' was successfully written.\n", szSpecFile);
799
800 return hr;
801 }
802