?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 886173 - Preserve playbackRate across pause/play. r=cpearce
[gecko.git] / tools / codesighs / msmap2tsv.c
blobf9cbb8bfdba623f225ddbc7d9331d977cdc505bb
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <time.h>
11 #include <ctype.h>
12
13 #include "msmap.h"
14
15 #if defined(_WIN32)
16 #include <windows.h>
17 #include <imagehlp.h>
18
19 #define F_DEMANGLE 1
20 #define DEMANGLE_STATE_NORMAL 0
21 #define DEMANGLE_STATE_QDECODE 1
22 #define DEMANGLE_STATE_PROLOGUE_1 2
23 #define DEMANGLE_STATE_HAVE_TYPE 3
24 #define DEMANGLE_STATE_DEC_LENGTH 4
25 #define DEMANGLE_STATE_HEX_LENGTH 5
26 #define DEMANGLE_STATE_PROLOGUE_SECONDARY 6
27 #define DEMANGLE_STATE_DOLLAR_1 7
28 #define DEMANGLE_STATE_DOLLAR_2 8
29 #define DEMANGLE_STATE_START 9
30 #define DEMANGLE_STATE_STOP 10
31 #define DEMANGLE_SAFE_CHAR(eval) (isprint(eval) ? eval : ' ')
32
33 #else
34 #define F_DEMANGLE 0
35 #endif /* WIN32 */
36
37 #define STRINGIFY(s_) STRINGIFY2(s_)
38 #define STRINGIFY2(s_) #s_
39 #define SYMBOL_BUF_CHARS 511
40
41 #define ERROR_REPORT(num, val, msg) fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg));
42 #define CLEANUP(ptr) do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0)
43
44
45 typedef struct __struct_SymDB_Size
46 /*
47 ** The size of the symbol.
48 ** The size is nested withing a symbols structures to produce a fast
49 ** lookup path.
50 ** The objects are listed in case the client of the symdb needs to
51 ** match the object name in the scenario where multiple symbol
52 ** sizes are present.
53 **
54 ** mSize The size of the symbol in these objects.
55 ** mObjects A list of objects containing said symbol.
56 ** mObjectCount Number of objects.
57 */
58 {
59 unsigned mSize;
60 char** mObjects;
61 unsigned mObjectCount;
62 }
63 SymDB_Size;
64
65
66 typedef struct __struct_SymDB_Section
67 /*
68 ** Each section for a symbol has a list of sizes.
69 ** Should there be exactly one size for the symbol, then that
70 ** is the size that should be accepted.
71 ** If there is more than one size, then a match on the object
72 ** should be attempted, held withing each size.
73 **
74 ** mName The section name.
75 ** mSizes The varoius sizes of the symbol in this section.
76 ** mSizeCount The number of available sizes.
77 */
78 {
79 char* mName;
80 SymDB_Size* mSizes;
81 unsigned mSizeCount;
82 }
83 SymDB_Section;
84
85
86 typedef struct __struct_SymDB_Symbol
87 /*
88 ** Each symbol has at least one section.
89 ** The section indicates what type of symbol a client may be looking for.
90 ** If there is no match on the section, then the client should not trust
91 ** the symbdb.
92 **
93 ** mName The mangled name of the symbol.
94 ** mSections Various sections this symbol belongs to.
95 ** mSectionCount The number of sections.
96 */
97 {
98 char* mName;
99 SymDB_Section* mSections;
100 unsigned mSectionCount;
101 }
102 SymDB_Symbol;
103
104
105 #define SYMDB_SYMBOL_GROWBY 0x1000 /* how many sybols to allocate at a time */
106
107
108 typedef struct __struct_SymDB_Container
109 /*
110 ** The symbol DB container object.
111 ** The goal of the symbol DB is to have exactly one SymDB_Symbol for each
112 ** mangled name, no matter how ever many identical mangled names there
113 ** are in the input.
114 ** The input is already expected to be well sorted, futher this leads to
115 ** the ability to binary search for symbol name matches.
116 **
117 ** mSymbols The symbols.
118 ** mSymbolCount The number of symbols in the DB.
119 ** mSymbolCapacity The number of symbols we can hold (before realloc).
120 */
121 {
122 SymDB_Symbol* mSymbols;
123 unsigned mSymbolCount;
124 unsigned mSymbolCapacity;
125 }
126 SymDB_Container;
127
128
129 typedef struct __struct_Options
130 /*
131 ** Options to control how we perform.
132 **
133 ** mProgramName Used in help text.
134 ** mInput File to read for input.
135 ** Default is stdin.
136 ** mInputName Name of the file.
137 ** mOutput Output file, append.
138 ** Default is stdout.
139 ** mOutputName Name of the file.
140 ** mHelp Whether or not help should be shown.
141 ** mMatchModules Array of strings which the module name should match.
142 ** mMatchModuleCount Number of items in array.
143 ** mSymDBName Symbol DB filename.
144 ** mBatchMode Batch mode.
145 ** When in batch mode, the input file contains a list of
146 ** map files to process.
147 ** Normally the input file is a single map file itself.
148 */
149 {
150 const char* mProgramName;
151 FILE* mInput;
152 char* mInputName;
153 FILE* mOutput;
154 char* mOutputName;
155 int mHelp;
156 char** mMatchModules;
157 unsigned mMatchModuleCount;
158 char* mSymDBName;
159 SymDB_Container* mSymDB;
160 int mBatchMode;
161 }
162 Options;
163
164
165 typedef struct __struct_Switch
166 /*
167 ** Command line options.
168 */
169 {
170 const char* mLongName;
171 const char* mShortName;
172 int mHasValue;
173 const char* mValue;
174 const char* mDescription;
175 }
176 Switch;
177
178 #define DESC_NEWLINE "\n\t\t"
179
180 static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."};
181 static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."};
182 static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."};
183 static Switch gMatchModuleSwitch = {"--match-module", "-mm", 1, NULL, "Specify a valid module name." DESC_NEWLINE "Multiple specifications allowed." DESC_NEWLINE "If a module name does not match one of the names specified then no output will occur."};
184 static Switch gSymDBSwitch = {"--symdb", "-sdb", 1, NULL, "Specify a symbol tsv db input file." DESC_NEWLINE "Such a symdb is produced using the tool msdump2symdb." DESC_NEWLINE "This allows better symbol size approximations." DESC_NEWLINE "The symdb file must be pre-sorted."};
185 static Switch gBatchModeSwitch = {"--batch", "-b", 0, NULL, "Runs in batch mode." DESC_NEWLINE "The input file contains a list of map files." DESC_NEWLINE "Normally the input file is a map file itself." DESC_NEWLINE "This eliminates reprocessing the symdb for multiple map files."};
186
187 static Switch* gSwitches[] = {
188 &gInputSwitch,
189 &gOutputSwitch,
190 &gMatchModuleSwitch,
191 &gSymDBSwitch,
192 &gBatchModeSwitch,
193 &gHelpSwitch
194 };
195
196
197 typedef struct __struct_MSMap_ReadState
198 /*
199 ** Keep track of what state we are while reading input.
200 ** This gives the input context in which we absorb the datum.
201 */
202 {
203 int mHasModule;
204
205 int mHasTimestamp;
206
207 int mHasPreferredLoadAddress;
208
209 int mHasSegmentData;
210 int mSegmentDataSkippedLine;
211
212 int mHasPublicSymbolData;
213 int mHasPublicSymbolDataSkippedLines;
214
215 int mHasEntryPoint;
216
217 int mFoundStaticSymbols;
218 }
219 MSMap_ReadState;
220
221
222 char* skipWhite(char* inScan)
223 /*
224 ** Skip whitespace.
225 */
226 {
227 char* retval = inScan;
228
229 while(isspace(*retval))
230 {
231 retval++;
232 }
233
234 return retval;
235 }
236
237 void trimWhite(char* inString)
238 /*
239 ** Remove any whitespace from the end of the string.
240 */
241 {
242 int len = strlen(inString);
243
244 while(len)
245 {
246 len--;
247
248 if(isspace(*(inString + len)))
249 {
250 *(inString + len) = '\0';
251 }
252 else
253 {
254 break;
255 }
256 }
257 }
258
259
260 char* lastWord(char* inString)
261 /*
262 ** Finds and returns the last word in a string.
263 ** It is assumed no whitespace is at the end of the string.
264 */
265 {
266 int mod = 0;
267 int len = strlen(inString);
268
269 while(len)
270 {
271 len--;
272 if(isspace(*(inString + len)))
273 {
274 mod = 1;
275 break;
276 }
277 }
278
279 return inString + len + mod;
280 }
281
282
283 MSMap_Segment* getSymbolSection(MSMap_Module* inModule, MSMap_Symbol* inoutSymbol)
284 /*
285 ** Perform a lookup for the section of the symbol.
286 ** The function could cache the value.
287 */
288 {
289 MSMap_Segment* retval = NULL;
290
291 if(NULL != inoutSymbol->mSection)
292 {
293 /*
294 ** Use cached value.
295 */
296 retval = inoutSymbol->mSection;
297 }
298 else
299 {
300 unsigned secLoop = 0;
301
302 /*
303 ** Go through sections in module to find the match for the symbol.
304 */
305 for(secLoop = 0; secLoop < inModule->mSegmentCount; secLoop++)
306 {
307 if(inoutSymbol->mPrefix == inModule->mSegments[secLoop].mPrefix)
308 {
309 if(inoutSymbol->mOffset >= inModule->mSegments[secLoop].mOffset)
310 {
311 if(inoutSymbol->mOffset < (inModule->mSegments[secLoop].mOffset + inModule->mSegments[secLoop].mLength))
312 {
313 /*
314 ** We have the section.
315 */
316 retval = &inModule->mSegments[secLoop];
317 break;
318 }
319 }
320 }
321 }
322
323 /*
324 ** Cache the value for next time.
325 */
326 inoutSymbol->mSection = retval;
327 }
328
329 return retval;
330 }
331
332
333 int readSymDB(const char* inDBName, SymDB_Container** outDB)
334 /*
335 ** Intialize the symbol DB.
336 ** Only call if the symbol DB should be initialized.
337 */
338 {
339 int retval = 0;
340
341 /*
342 ** Initialize out arguments.
343 */
344 if(NULL != outDB)
345 {
346 *outDB = NULL;
347 }
348
349 if(NULL != outDB && NULL != inDBName)
350 {
351 FILE* symDB = NULL;
352
353 symDB = fopen(inDBName, "r");
354 if(NULL != symDB)
355 {
356 *outDB = (SymDB_Container*)calloc(1, sizeof(SymDB_Container));
357 if(NULL != *outDB)
358 {
359 char lineBuf[0x400];
360 char* symbol = NULL;
361 char* section = NULL;
362 char* object = NULL;
363 char* length = NULL;
364 unsigned lengthNum = 0;
365 char* endLength = NULL;
366
367 /*
368 ** Read the file line by line.
369 */
370 while(0 == retval && NULL != fgets(lineBuf, sizeof(lineBuf), symDB))
371 {
372 trimWhite(lineBuf);
373
374 /*
375 ** Each line has four arguments. tab separated values (tsv).
376 ** Symbol
377 ** Section
378 ** Length
379 ** Object
380 */
381
382 symbol = skipWhite(lineBuf);
383 if(NULL == symbol)
384 {
385 retval = __LINE__;
386 ERROR_REPORT(retval, inDBName, "File does not appear to be a symbol DB.");
387 break;
388 }
389
390 section = strchr(symbol, '\t');
391 if(NULL == section)
392 {
393 retval = __LINE__;
394 ERROR_REPORT(retval, inDBName, "File does not appear to be a symbol DB.");
395 break;
396 }
397 *section = '\0';
398 section++;
399
400 length = strchr(section, '\t');
401 if(NULL == length)
402 {
403 retval = __LINE__;
404 ERROR_REPORT(retval, inDBName, "File does not appear to be a symbol DB.");
405 break;
406 }
407 *length = '\0';
408 length++;
409
410 object = strchr(length, '\t');
411 if(NULL == object)
412 {
413 retval = __LINE__;
414 ERROR_REPORT(retval, inDBName, "File does not appear to be a symbol DB.");
415 break;
416 }
417 *object = '\0';
418 object++;
419
420 /*
421 ** Convert the length into a number.
422 */
423 errno = 0;
424 lengthNum = strtoul(length, &endLength, 16);
425 if(0 == errno && endLength != length)
426 {
427 SymDB_Symbol* dbSymbol = NULL;
428 SymDB_Section* dbSection = NULL;
429 SymDB_Size* dbSize = NULL;
430 char* dbObject = NULL;
431 void* moved = NULL;
432
433 /*
434 ** Are we looking at the same symbol as last line?
435 ** This assumes the symdb is pre sorted!!!
436 */
437 if(0 != (*outDB)->mSymbolCount)
438 {
439 unsigned index = (*outDB)->mSymbolCount - 1;
440
441 if(0 == strcmp((*outDB)->mSymbols[index].mName, symbol))
442 {
443 dbSymbol = &(*outDB)->mSymbols[index];
444 }
445 }
446
447 /*
448 ** May need to create symbol.
449 */
450 if(NULL == dbSymbol)
451 {
452 /*
453 ** Could be time to grow the symbol pool.
454 */
455 if((*outDB)->mSymbolCount >= (*outDB)->mSymbolCapacity)
456 {
457 moved = realloc((*outDB)->mSymbols, sizeof(SymDB_Symbol) * ((*outDB)->mSymbolCapacity + SYMDB_SYMBOL_GROWBY));
458 if(NULL != moved)
459 {
460 (*outDB)->mSymbols = (SymDB_Symbol*)moved;
461 memset(&(*outDB)->mSymbols[(*outDB)->mSymbolCapacity], 0, sizeof(SymDB_Symbol) * SYMDB_SYMBOL_GROWBY);
462 (*outDB)->mSymbolCapacity += SYMDB_SYMBOL_GROWBY;
463 }
464 else
465 {
466 retval = __LINE__;
467 ERROR_REPORT(retval, inDBName, "Unable to grow symbol DB symbol array.");
468 break;
469 }
470 }
471
472 if((*outDB)->mSymbolCount < (*outDB)->mSymbolCapacity)
473 {
474 dbSymbol = &(*outDB)->mSymbols[(*outDB)->mSymbolCount];
475 (*outDB)->mSymbolCount++;
476
477 dbSymbol->mName = strdup(symbol);
478 if(NULL == dbSymbol->mName)
479 {
480 retval = __LINE__;
481 ERROR_REPORT(retval, symbol, "Unable to duplicate string.");
482 break;
483 }
484 }
485 else
486 {
487 retval = __LINE__;
488 ERROR_REPORT(retval, symbol, "Unable to grow symbol DB for symbol.");
489 break;
490 }
491 }
492
493 /*
494 ** Assume we have the symbol.
495 **
496 ** Is this the same section as the last section in the symbol?
497 ** This assumes the symdb was presorted!!!!
498 */
499 if(0 != dbSymbol->mSectionCount)
500 {
501 unsigned index = dbSymbol->mSectionCount - 1;
502
503 if(0 == strcmp(dbSymbol->mSections[index].mName, section))
504 {
505 dbSection = &dbSymbol->mSections[index];
506 }
507 }
508
509 /*
510 ** May need to create the section.
511 */
512 if(NULL == dbSection)
513 {
514 moved = realloc(dbSymbol->mSections, sizeof(SymDB_Section) * (dbSymbol->mSectionCount + 1));
515 if(NULL != moved)
516 {
517 dbSymbol->mSections = (SymDB_Section*)moved;
518 dbSection = &dbSymbol->mSections[dbSymbol->mSectionCount];
519 dbSymbol->mSectionCount++;
520
521 memset(dbSection, 0, sizeof(SymDB_Section));
522
523 dbSection->mName = strdup(section);
524 if(NULL == dbSection->mName)
525 {
526 retval = __LINE__;
527 ERROR_REPORT(retval, section, "Unable to duplicate string.");
528 break;
529 }
530 }
531 else
532 {
533 retval = __LINE__;
534 ERROR_REPORT(retval, section, "Unable to grow symbol sections for symbol DB.");
535 break;
536 }
537 }
538
539 /*
540 ** Assume we have the section.
541 **
542 ** Is this the same size as the last size?
543 ** This assumes the symdb was presorted!!!
544 */
545 if(0 != dbSection->mSizeCount)
546 {
547 unsigned index = dbSection->mSizeCount - 1;
548
549 if(dbSection->mSizes[index].mSize == lengthNum)
550 {
551 dbSize = &dbSection->mSizes[index];
552 }
553 }
554
555 /*
556 ** May need to create the size in question.
557 */
558 if(NULL == dbSize)
559 {
560 moved = realloc(dbSection->mSizes, sizeof(SymDB_Size) * (dbSection->mSizeCount + 1));
561 if(NULL != moved)
562 {
563 dbSection->mSizes = (SymDB_Size*)moved;
564 dbSize = &dbSection->mSizes[dbSection->mSizeCount];
565 dbSection->mSizeCount++;
566
567 memset(dbSize, 0, sizeof(SymDB_Size));
568
569 dbSize->mSize = lengthNum;
570 }
571 else
572 {
573 retval = __LINE__;
574 ERROR_REPORT(retval, length, "Unable to grow symbol section sizes for symbol DB.");
575 break;
576 }
577 }
578
579 /*
580 ** Assume we have the size.
581 **
582 ** We assume a one to one correllation between size and object.
583 ** Always try to add the new object name.
584 ** As the symdb is assumed to be sorted, the object names should also be in order.
585 */
586 moved = realloc(dbSize->mObjects, sizeof(char*) * (dbSize->mObjectCount + 1));
587 if(NULL != moved)
588 {
589 dbObject = strdup(object);
590
591 dbSize->mObjects = (char**)moved;
592 dbSize->mObjects[dbSize->mObjectCount] = dbObject;
593 dbSize->mObjectCount++;
594
595 if(NULL == dbObject)
596 {
597 retval = __LINE__;
598 ERROR_REPORT(retval, object, "Unable to duplicate string.");
599 break;
600 }
601 }
602 else
603 {
604 retval = __LINE__;
605 ERROR_REPORT(retval, object, "Unable to grow symbol section size objects for symbol DB.");
606 break;
607 }
608 }
609 else
610 {
611 retval = __LINE__;
612 ERROR_REPORT(retval, length, "Unable to convert symbol DB length into a number.");
613 break;
614 }
615 }
616
617 if(0 == retval && 0 != ferror(symDB))
618 {
619 retval = __LINE__;
620 ERROR_REPORT(retval, inDBName, "Unable to read file.");
621 }
622 }
623 else
624 {
625 retval = __LINE__;
626 ERROR_REPORT(retval, inDBName, "Unable to allocate symbol DB.");
627 }
628
629 fclose(symDB);
630 symDB = NULL;
631 }
632 else
633 {
634 retval = __LINE__;
635 ERROR_REPORT(retval, inDBName, "Unable to open symbol DB.");
636 }
637 }
638 else
639 {
640 retval = __LINE__;
641 ERROR_REPORT(retval, "(NULL)", "Invalid arguments.");
642 }
643
644 return retval;
645 }
646
647
648 void cleanSymDB(SymDB_Container** inDB)
649 /*
650 ** Free it all up.
651 */
652 {
653 if(NULL != inDB && NULL != *inDB)
654 {
655 unsigned symLoop = 0;
656 unsigned secLoop = 0;
657 unsigned sizLoop = 0;
658 unsigned objLoop = 0;
659
660 for(symLoop = 0; symLoop < (*inDB)->mSymbolCount; symLoop++)
661 {
662 for(secLoop = 0; secLoop < (*inDB)->mSymbols[symLoop].mSectionCount; secLoop++)
663 {
664 for(sizLoop = 0; sizLoop < (*inDB)->mSymbols[symLoop].mSections[secLoop].mSizeCount; sizLoop++)
665 {
666 for(objLoop = 0; objLoop < (*inDB)->mSymbols[symLoop].mSections[secLoop].mSizes[sizLoop].mObjectCount; objLoop++)
667 {
668 CLEANUP((*inDB)->mSymbols[symLoop].mSections[secLoop].mSizes[sizLoop].mObjects[objLoop]);
669 }
670 CLEANUP((*inDB)->mSymbols[symLoop].mSections[secLoop].mSizes[sizLoop].mObjects);
671 }
672 CLEANUP((*inDB)->mSymbols[symLoop].mSections[secLoop].mName);
673 CLEANUP((*inDB)->mSymbols[symLoop].mSections[secLoop].mSizes);
674 }
675 CLEANUP((*inDB)->mSymbols[symLoop].mName);
676 CLEANUP((*inDB)->mSymbols[symLoop].mSections);
677 }
678 CLEANUP((*inDB)->mSymbols);
679 CLEANUP(*inDB);
680 }
681 }
682
683
684 int symDBLookup(const void* inKey, const void* inItem)
685 /*
686 ** bsearch utility routine to find the symbol in the symdb.
687 */
688 {
689 int retval = 0;
690 const char* key = (const char*)inKey;
691 const SymDB_Symbol* symbol = (const SymDB_Symbol*)inItem;
692
693 retval = strcmp(key, symbol->mName);
694
695 return retval;
696 }
697
698
699 int fillSymbolSizeFromDB(Options* inOptions, MSMap_Module* inModule, MSMap_Symbol* inoutSymbol, const char* inMangledName)
700 /*
701 ** If we have a symbol DB, attempt to determine the real size of the symbol
702 ** up front.
703 ** This helps us later in the game to avoid performing size guesses by
704 ** offset.
705 */
706 {
707 int retval = 0;
708
709 /*
710 ** May need to initialize symdb.
711 */
712 if(NULL == inOptions->mSymDB && NULL != inOptions->mSymDBName)
713 {
714 retval = readSymDB(inOptions->mSymDBName, &inOptions->mSymDB);
715 }
716
717 /*
718 ** Optional
719 */
720 if(0 == retval && NULL != inOptions->mSymDB)
721 {
722 void* match = NULL;
723
724 /*
725 ** Find the symbol.
726 */
727 match = bsearch(inMangledName, inOptions->mSymDB->mSymbols, inOptions->mSymDB->mSymbolCount, sizeof(SymDB_Symbol), symDBLookup);
728 if(NULL != match)
729 {
730 SymDB_Symbol* symbol = (SymDB_Symbol*)match;
731 unsigned symDBSize = 0;
732 MSMap_Segment* mapSection = NULL;
733
734 /*
735 ** We found the symbol.
736 **
737 ** See if it has the section in question.
738 */
739 mapSection = getSymbolSection(inModule, inoutSymbol);
740 if(NULL != mapSection)
741 {
742 unsigned secLoop = 0;
743
744 for(secLoop = 0; secLoop < symbol->mSectionCount; secLoop++)
745 {
746 if(0 == strcmp(mapSection->mSegment, symbol->mSections[secLoop].mName))
747 {
748 SymDB_Section* section = &symbol->mSections[secLoop];
749
750 /*
751 ** We have a section match.
752 ** Should there be a single size for the symbol,
753 ** then we just default to that.
754 ** If more than one size, we have to do an
755 ** object match search.
756 ** Should there be no object match, we do nothign.
757 */
758 if(1 == section->mSizeCount)
759 {
760 symDBSize = section->mSizes[0].mSize;
761 }
762 else
763 {
764 char* mapObject = NULL;
765
766 /*
767 ** Figure out the map object file name.
768 ** Skip any colon.
769 ** If it doesn't have a .obj in it, not worth continuing.
770 */
771 mapObject = strrchr(inoutSymbol->mObject, ':');
772 if(NULL == mapObject)
773 {
774 mapObject = inoutSymbol->mObject;
775 }
776 else
777 {
778 mapObject++; /* colon */
779 }
780
781 if(NULL != strstr(mapObject, ".obj"))
782 {
783 unsigned sizLoop = 0;
784 unsigned objLoop = 0;
785 SymDB_Size* size = NULL;
786
787 for(sizLoop = 0; sizLoop < section->mSizeCount; sizLoop++)
788 {
789 size = &section->mSizes[sizLoop];
790
791 for(objLoop = 0; objLoop < size->mObjectCount; objLoop++)
792 {
793 if(NULL != strstr(size->mObjects[objLoop], mapObject))
794 {
795 /*
796 ** As we matched the object, in a particular section,
797 ** we'll go with this as the number.
798 */
799 symDBSize = size->mSize;
800 break;
801 }
802 }
803
804 /*
805 ** If the object loop broke early, we break too.
806 */
807 if(objLoop < size->mObjectCount)
808 {
809 break;
810 }
811 }
812 }
813 }
814
815 break;
816 }
817 }
818 }
819
820 /*
821 ** Put the size in.
822 */
823 inoutSymbol->mSymDBSize = symDBSize;
824 }
825 }
826
827 return retval;
828 }
829
830
831 char* symdup(const char* inSymbol)
832 /*
833 ** Attempts to demangle the symbol if appropriate.
834 ** Otherwise acts like strdup.
835 */
836 {
837 char* retval = NULL;
838
839 #if F_DEMANGLE
840 {
841 int isImport = 0;
842
843 if(0 == strncmp("__imp_", inSymbol, 6))
844 {
845 isImport = __LINE__;
846 inSymbol += 6;
847 }
848
849 if('?' == inSymbol[0])
850 {
851 char demangleBuf[0x200];
852 DWORD demangleRes = 0;
853
854 demangleRes = UnDecorateSymbolName(inSymbol, demangleBuf, sizeof(demangleBuf), UNDNAME_COMPLETE);
855 if(0 != demangleRes)
856 {
857 if (strcmp(demangleBuf, "`string'") == 0)
858 {
859
860 /* attempt manual demangling of string prefix.. */
861
862 /* first make sure we have enough space for the
863 updated string - the demangled string will
864 always be shorter than strlen(inSymbol) and the
865 prologue will always be longer than the
866 "string: " that we tack on the front of the string
867 */
868 char *curresult = retval = malloc(strlen(inSymbol) + 11);
869 const char *curchar = inSymbol;
870
871 int state = DEMANGLE_STATE_START;
872
873 /* the hex state is for stuff like ?$EA which
874 really means hex value 0x40 */
875 char hex_state = 0;
876 char string_is_unicode = 0;
877
878 /* sometimes we get a null-termination before the
879 final @ sign - in that case, remember that
880 we've seen the whole string */
881 int have_null_char = 0;
882
883 /* stick our user-readable prefix on */
884 strcpy(curresult, "string: \"");
885 curresult += 9;
886
887 while (*curchar) {
888
889 // process current state
890 switch (state) {
891
892 /* the Prologue states are divided up so
893 that someday we can try to decode
894 the random letters in between the '@'
895 signs. Also, some strings only have 2
896 prologue '@' signs, so we have to
897 figure out how to distinguish between
898 them at some point. */
899 case DEMANGLE_STATE_START:
900 if (*curchar == '@')
901 state = DEMANGLE_STATE_PROLOGUE_1;
902 /* ignore all other states */
903 break;
904
905 case DEMANGLE_STATE_PROLOGUE_1:
906 switch (*curchar) {
907 case '0':
908 string_is_unicode=0;
909 state = DEMANGLE_STATE_HAVE_TYPE;
910 break;
911 case '1':
912 string_is_unicode=1;
913 state = DEMANGLE_STATE_HAVE_TYPE;
914 break;
915
916 /* ignore all other characters */
917 }
918 break;
919
920 case DEMANGLE_STATE_HAVE_TYPE:
921 if (*curchar >= '0' && *curchar <= '9') {
922 state = DEMANGLE_STATE_DEC_LENGTH;
923 } else if (*curchar >= 'A' && *curchar <= 'Z') {
924 state = DEMANGLE_STATE_HEX_LENGTH;
925 }
926 case DEMANGLE_STATE_DEC_LENGTH:
927 /* decimal lengths don't have the 2nd
928 field
929 */
930 if (*curchar == '@')
931 state = DEMANGLE_STATE_NORMAL;
932 break;
933
934 case DEMANGLE_STATE_HEX_LENGTH:
935 /* hex lengths have a 2nd field
936 (though I have no idea what it is for)
937 */
938 if (*curchar == '@')
939 state = DEMANGLE_STATE_PROLOGUE_SECONDARY;
940 break;
941
942 case DEMANGLE_STATE_PROLOGUE_SECONDARY:
943 if (*curchar == '@')
944 state = DEMANGLE_STATE_NORMAL;
945 break;
946
947 case DEMANGLE_STATE_NORMAL:
948 switch (*curchar) {
949 case '?':
950 state = DEMANGLE_STATE_QDECODE;
951 break;
952 case '@':
953 state = DEMANGLE_STATE_STOP;
954 break;
955 default:
956 *curresult++ = DEMANGLE_SAFE_CHAR(*curchar);
957 state = DEMANGLE_STATE_NORMAL;
958 break;
959 }
960 break;
961
962 /* found a '?' */
963 case DEMANGLE_STATE_QDECODE:
964 state = DEMANGLE_STATE_NORMAL;
965
966 /* there are certain shortcuts, like
967 "?3" means ":"
968 */
969 switch (*curchar) {
970 case '1':
971 *curresult++ = '/';
972 break;
973 case '2':
974 *curresult++ = '\\';
975 break;
976 case '3':
977 *curresult++ = ':';
978 break;
979 case '4':
980 *curresult++ = '.';
981 break;
982 case '5':
983 *curresult++ = ' ';
984 break;
985 case '6':
986 *curresult++ = '\\';
987 *curresult++ = 'n';
988 break;
989 case '8':
990 *curresult++ = '\'';
991 break;
992 case '9':
993 *curresult++ = '-';
994 break;
995
996 /* any other arbitrary ASCII value can
997 be stored by prefixing it with ?$
998 */
999 case '$':
1000 state = DEMANGLE_STATE_DOLLAR_1;
1001 }
1002 break;
1003
1004 case DEMANGLE_STATE_DOLLAR_1:
1005 /* first digit of ?$ notation. All digits
1006 are hex, represented starting with the
1007 capital leter 'A' such that 'A' means 0x0,
1008 'B' means 0x1, 'K' means 0xA
1009 */
1010 hex_state = (*curchar - 'A') * 0x10;
1011 state = DEMANGLE_STATE_DOLLAR_2;
1012 break;
1013
1014 case DEMANGLE_STATE_DOLLAR_2:
1015 /* same mechanism as above */
1016 hex_state += (*curchar - 'A');
1017 if (hex_state) {
1018 *curresult++ = DEMANGLE_SAFE_CHAR(hex_state);
1019 have_null_char = 0;
1020 }
1021 else {
1022 have_null_char = 1;
1023 }
1024
1025 state = DEMANGLE_STATE_NORMAL;
1026 break;
1027
1028 case DEMANGLE_STATE_STOP:
1029 break;
1030 }
1031
1032 curchar++;
1033 }
1034
1035 /* add the appropriate termination depending
1036 if we completed the string or not */
1037 if (!have_null_char)
1038 strcpy(curresult, "...\"");
1039 else
1040 strcpy(curresult, "\"");
1041 } else {
1042 retval = strdup(demangleBuf);
1043 }
1044 }
1045 else
1046 {
1047 /*
1048 ** fall back to normal.
1049 */
1050 retval = strdup(inSymbol);
1051 }
1052 }
1053 else if('_' == inSymbol[0])
1054 {
1055 retval = strdup(inSymbol + 1);
1056 }
1057 else
1058 {
1059 retval = strdup(inSymbol);
1060 }
1061
1062 /*
1063 ** May need to rewrite the symbol if an import.
1064 */
1065 if(NULL != retval && isImport)
1066 {
1067 const char importPrefix[] = "__declspec(dllimport) ";
1068 char importBuf[0x200];
1069 int printRes = 0;
1070
1071 printRes = _snprintf(importBuf, sizeof(importBuf), "%s%s", importPrefix, retval);
1072 free(retval);
1073 retval = NULL;
1074
1075 if(printRes > 0)
1076 {
1077 retval = strdup(importBuf);
1078 }
1079 }
1080 }
1081 #else /* F_DEMANGLE */
1082 retval = strdup(inSymbol);
1083 #endif /* F_DEMANGLE */
1084
1085 return retval;
1086 }
1087
1088
1089 int readmap(Options* inOptions, MSMap_Module* inModule)
1090 /*
1091 ** Read the input line by line, adding it to the module.
1092 */
1093 {
1094 int retval = 0;
1095 char lineBuffer[0x400];
1096 char* current = NULL;
1097 MSMap_ReadState fsm;
1098 int len = 0;
1099 int forceContinue = 0;
1100
1101 memset(&fsm, 0, sizeof(fsm));
1102
1103 /*
1104 ** Read the map file line by line.
1105 ** We keep a simple state machine to determine what we're looking at.
1106 */
1107 while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput))
1108 {
1109 if(forceContinue)
1110 {
1111 /*
1112 ** Used to skip anticipated blank lines.
1113 */
1114 forceContinue--;
1115 continue;
1116 }
1117
1118 current = skipWhite(lineBuffer);
1119 trimWhite(current);
1120
1121 len = strlen(current);
1122
1123 if(fsm.mHasModule)
1124 {
1125 if(fsm.mHasTimestamp)
1126 {
1127 if(fsm.mHasPreferredLoadAddress)
1128 {
1129 if(fsm.mHasSegmentData)
1130 {
1131 if(fsm.mHasPublicSymbolData)
1132 {
1133 if(fsm.mHasEntryPoint)
1134 {
1135 if(fsm.mFoundStaticSymbols)
1136 {
1137 /*
1138 ** A blank line means we've reached the end of all static symbols.
1139 */
1140 if(len)
1141 {
1142 /*
1143 ** We're adding a new symbol.
1144 ** Make sure we have room for it.
1145 */
1146 if(inModule->mSymbolCapacity == inModule->mSymbolCount)
1147 {
1148 void* moved = NULL;
1149
1150 moved = realloc(inModule->mSymbols, sizeof(MSMap_Symbol) * (inModule->mSymbolCapacity + MSMAP_SYMBOL_GROWBY));
1151 if(NULL != moved)
1152 {
1153 inModule->mSymbolCapacity += MSMAP_SYMBOL_GROWBY;
1154 inModule->mSymbols = (MSMap_Symbol*)moved;
1155 }
1156 else
1157 {
1158 retval = __LINE__;
1159 ERROR_REPORT(retval, inModule->mModule, "Unable to grow symbols.");
1160 }
1161 }
1162
1163 if(0 == retval && inModule->mSymbolCapacity > inModule->mSymbolCount)
1164 {
1165 MSMap_Symbol* theSymbol = NULL;
1166 unsigned index = 0;
1167 int scanRes = 0;
1168 char symbolBuf[SYMBOL_BUF_CHARS + 1];
1169
1170 index = inModule->mSymbolCount;
1171 inModule->mSymbolCount++;
1172 theSymbol = (inModule->mSymbols + index);
1173
1174 memset(theSymbol, 0, sizeof(MSMap_Symbol));
1175 theSymbol->mScope = STATIC;
1176
1177 scanRes = sscanf(current, "%x:%x %" STRINGIFY(SYMBOL_BUF_CHARS) "s %x", (unsigned*)&(theSymbol->mPrefix), (unsigned*)&(theSymbol->mOffset), symbolBuf, (unsigned*)&(theSymbol->mRVABase));
1178 if(4 == scanRes)
1179 {
1180 theSymbol->mSymbol = symdup(symbolBuf);
1181
1182 if(0 == retval)
1183 {
1184 if(NULL != theSymbol->mSymbol)
1185 {
1186 char *last = lastWord(current);
1187
1188 theSymbol->mObject = strdup(last);
1189 if(NULL == theSymbol->mObject)
1190 {
1191 retval = __LINE__;
1192 ERROR_REPORT(retval, last, "Unable to copy object name.");
1193 }
1194 }
1195 else
1196 {
1197 retval = __LINE__;
1198 ERROR_REPORT(retval, symbolBuf, "Unable to copy symbol name.");
1199 }
1200 }
1201 }
1202 else
1203 {
1204 retval = __LINE__;
1205 ERROR_REPORT(retval, inModule->mModule, "Unable to scan static symbols.");
1206 }
1207 }
1208 }
1209 else
1210 {
1211 /*
1212 ** All done.
1213 */
1214 break;
1215 }
1216 }
1217 else
1218 {
1219 /*
1220 ** Static symbols are optional.
1221 ** If no static symbols we're done.
1222 ** Otherwise, set the flag such that it will work more.
1223 */
1224 if(0 == strcmp(current, "Static symbols"))
1225 {
1226 fsm.mFoundStaticSymbols = __LINE__;
1227 forceContinue = 1;
1228 }
1229 else
1230 {
1231 /*
1232 ** All done.
1233 */
1234 break;
1235 }
1236 }
1237 }
1238 else
1239 {
1240 int scanRes = 0;
1241
1242 scanRes = sscanf(current, "entry point at %x:%x", (unsigned*)&(inModule->mEntryPrefix), (unsigned*)&(inModule->mEntryOffset));
1243 if(2 == scanRes)
1244 {
1245 fsm.mHasEntryPoint = __LINE__;
1246 forceContinue = 1;
1247 }
1248 else
1249 {
1250 retval = __LINE__;
1251 ERROR_REPORT(retval, current, "Unable to obtain entry point.");
1252 }
1253 }
1254 }
1255 else
1256 {
1257 /*
1258 ** Skip the N lines of public symbol data (column headers).
1259 */
1260 if(2 <= fsm.mHasPublicSymbolDataSkippedLines)
1261 {
1262 /*
1263 ** A blank line indicates end of public symbols.
1264 */
1265 if(len)
1266 {
1267 /*
1268 ** We're adding a new symbol.
1269 ** Make sure we have room for it.
1270 */
1271 if(inModule->mSymbolCapacity == inModule->mSymbolCount)
1272 {
1273 void* moved = NULL;
1274
1275 moved = realloc(inModule->mSymbols, sizeof(MSMap_Symbol) * (inModule->mSymbolCapacity + MSMAP_SYMBOL_GROWBY));
1276 if(NULL != moved)
1277 {
1278 inModule->mSymbolCapacity += MSMAP_SYMBOL_GROWBY;
1279 inModule->mSymbols = (MSMap_Symbol*)moved;
1280 }
1281 else
1282 {
1283 retval = __LINE__;
1284 ERROR_REPORT(retval, inModule->mModule, "Unable to grow symbols.");
1285 }
1286 }
1287
1288 if(0 == retval && inModule->mSymbolCapacity > inModule->mSymbolCount)
1289 {
1290 MSMap_Symbol* theSymbol = NULL;
1291 unsigned index = 0;
1292 int scanRes = 0;
1293 char symbolBuf[SYMBOL_BUF_CHARS + 1];
1294
1295 index = inModule->mSymbolCount;
1296 inModule->mSymbolCount++;
1297 theSymbol = (inModule->mSymbols + index);
1298
1299 memset(theSymbol, 0, sizeof(MSMap_Symbol));
1300 theSymbol->mScope = PUBLIC;
1301
1302 scanRes = sscanf(current, "%x:%x %" STRINGIFY(SYMBOL_BUF_CHARS) "s %x", (unsigned*)&(theSymbol->mPrefix), (unsigned*)&(theSymbol->mOffset), symbolBuf, (unsigned *)&(theSymbol->mRVABase));
1303 if(4 == scanRes)
1304 {
1305 theSymbol->mSymbol = symdup(symbolBuf);
1306
1307 if(NULL != theSymbol->mSymbol)
1308 {
1309 char *last = lastWord(current);
1310
1311 theSymbol->mObject = strdup(last);
1312 if(NULL != theSymbol->mObject)
1313 {
1314 /*
1315 ** Finally, attempt to lookup the actual size of the symbol
1316 ** if there is a symbol DB available.
1317 */
1318 retval = fillSymbolSizeFromDB(inOptions, inModule, theSymbol, symbolBuf);
1319 }
1320 else
1321 {
1322 retval = __LINE__;
1323 ERROR_REPORT(retval, last, "Unable to copy object name.");
1324 }
1325 }
1326 else
1327 {
1328 retval = __LINE__;
1329 ERROR_REPORT(retval, symbolBuf, "Unable to copy symbol name.");
1330 }
1331 }
1332 else
1333 {
1334 retval = __LINE__;
1335 ERROR_REPORT(retval, inModule->mModule, "Unable to scan public symbols.");
1336 }
1337 }
1338 }
1339 else
1340 {
1341 fsm.mHasPublicSymbolData = __LINE__;
1342 }
1343 }
1344 else
1345 {
1346 fsm.mHasPublicSymbolDataSkippedLines++;
1347 }
1348 }
1349 }
1350 else
1351 {
1352 /*
1353 ** Skip the first line of segment data (column headers).
1354 ** Mark that we've begun grabbing segement data.
1355 */
1356 if(fsm.mSegmentDataSkippedLine)
1357 {
1358 /*
1359 ** A blank line means end of the segment data.
1360 */
1361 if(len)
1362 {
1363 /*
1364 ** We're adding a new segment.
1365 ** Make sure we have room for it.
1366 */
1367 if(inModule->mSegmentCapacity == inModule->mSegmentCount)
1368 {
1369 void* moved = NULL;
1370
1371 moved = realloc(inModule->mSegments, sizeof(MSMap_Segment) * (inModule->mSegmentCapacity + MSMAP_SEGMENT_GROWBY));
1372 if(NULL != moved)
1373 {
1374 inModule->mSegmentCapacity += MSMAP_SEGMENT_GROWBY;
1375 inModule->mSegments = (MSMap_Segment*)moved;
1376 }
1377 else
1378 {
1379 retval = __LINE__;
1380 ERROR_REPORT(retval, inModule->mModule, "Unable to grow segments.");
1381 }
1382 }
1383
1384 if(0 == retval && inModule->mSegmentCapacity > inModule->mSegmentCount)
1385 {
1386 MSMap_Segment* theSegment = NULL;
1387 unsigned index = 0;
1388 #define CLASS_BUF_CHARS 15
1389 char classBuf[CLASS_BUF_CHARS + 1];
1390 #define NAME_BUF_CHARS 31
1391 char nameBuf[NAME_BUF_CHARS + 1];
1392 int scanRes = 0;
1393
1394 index = inModule->mSegmentCount;
1395 inModule->mSegmentCount++;
1396 theSegment = (inModule->mSegments + index);
1397
1398 memset(theSegment, 0, sizeof(MSMap_Segment));
1399
1400 scanRes = sscanf(current, "%x:%x %xH %" STRINGIFY(NAME_BUF_CHARS) "s %" STRINGIFY(CLASS_BUF_CHARS) "s", (unsigned*)&(theSegment->mPrefix), (unsigned*)&(theSegment->mOffset), (unsigned*)&(theSegment->mLength), nameBuf, classBuf);
1401 if(5 == scanRes)
1402 {
1403 if('.' == nameBuf[0])
1404 {
1405 theSegment->mSegment = strdup(&nameBuf[1]);
1406 }
1407 else
1408 {
1409 theSegment->mSegment = strdup(nameBuf);
1410 }
1411
1412 if(NULL != theSegment->mSegment)
1413 {
1414 if(0 == strcmp("DATA", classBuf))
1415 {
1416 theSegment->mClass = DATA;
1417 }
1418 else if(0 == strcmp("CODE", classBuf))
1419 {
1420 theSegment->mClass = CODE;
1421 }
1422 else
1423 {
1424 retval = __LINE__;
1425 ERROR_REPORT(retval, classBuf, "Unrecognized segment class.");
1426 }
1427 }
1428 else
1429 {
1430 retval = __LINE__;
1431 ERROR_REPORT(retval, nameBuf, "Unable to copy segment name.");
1432 }
1433 }
1434 else
1435 {
1436 retval = __LINE__;
1437 ERROR_REPORT(retval, inModule->mModule, "Unable to scan segments.");
1438 }
1439 }
1440 }
1441 else
1442 {
1443 fsm.mHasSegmentData = __LINE__;
1444 }
1445 }
1446 else
1447 {
1448 fsm.mSegmentDataSkippedLine = __LINE__;
1449 }
1450 }
1451 }
1452 else
1453 {
1454 int scanRes = 0;
1455
1456 /*
1457 ** The PLA has a particular format.
1458 */
1459 scanRes = sscanf(current, "Preferred load address is %x", (unsigned*)&(inModule->mPreferredLoadAddress));
1460 if(1 == scanRes)
1461 {
1462 fsm.mHasPreferredLoadAddress = __LINE__;
1463 forceContinue = 1;
1464 }
1465 else
1466 {
1467 retval = __LINE__;
1468 ERROR_REPORT(retval, current, "Unable to obtain preferred load address.");
1469 }
1470 }
1471 }
1472 else
1473 {
1474 int scanRes = 0;
1475
1476 /*
1477 ** The timestamp has a particular format.
1478 */
1479 scanRes = sscanf(current, "Timestamp is %x", (unsigned*)&(inModule->mTimestamp));
1480 if(1 == scanRes)
1481 {
1482 fsm.mHasTimestamp = __LINE__;
1483 forceContinue = 1;
1484 }
1485 else
1486 {
1487 retval = __LINE__;
1488 ERROR_REPORT(retval, current, "Unable to obtain timestamp.");
1489 }
1490 }
1491 }
1492 else
1493 {
1494 /*
1495 ** The module is on a line by itself.
1496 */
1497 inModule->mModule = strdup(current);
1498 if(NULL != inModule->mModule)
1499 {
1500 fsm.mHasModule = __LINE__;
1501 forceContinue = 1;
1502
1503 if(0 != inOptions->mMatchModuleCount)
1504 {
1505 unsigned matchLoop = 0;
1506
1507 /*
1508 ** If this module name doesn't match, then bail.
1509 ** Compare in a case sensitive manner, exact match only.
1510 */
1511 for(matchLoop = 0; matchLoop < inOptions->mMatchModuleCount; matchLoop++)
1512 {
1513 if(0 == strcmp(inModule->mModule, inOptions->mMatchModules[matchLoop]))
1514 {
1515 break;
1516 }
1517 }
1518
1519 if(matchLoop == inOptions->mMatchModuleCount)
1520 {
1521 /*
1522 ** A match did not occur, bail out of read loop.
1523 ** No error, however.
1524 */
1525 break;
1526 }
1527 }
1528 }
1529 else
1530 {
1531 retval = __LINE__;
1532 ERROR_REPORT(retval, current, "Unable to obtain module.");
1533 }
1534 }
1535 }
1536
1537 if(0 == retval && 0 != ferror(inOptions->mInput))
1538 {
1539 retval = __LINE__;
1540 ERROR_REPORT(retval, inOptions->mInputName, "Unable to read file.");
1541 }
1542
1543 return retval;
1544 }
1545
1546
1547 static int qsortRVABase(const void* in1, const void* in2)
1548 /*
1549 ** qsort callback to sort the symbols by their RVABase.
1550 */
1551 {
1552 MSMap_Symbol* sym1 = (MSMap_Symbol*)in1;
1553 MSMap_Symbol* sym2 = (MSMap_Symbol*)in2;
1554 int retval = 0;
1555
1556 if(sym1->mRVABase < sym2->mRVABase)
1557 {
1558 retval = -1;
1559 }
1560 else if(sym1->mRVABase > sym2->mRVABase)
1561 {
1562 retval = 1;
1563 }
1564
1565 return retval;
1566 }
1567
1568
1569 static int tsvout(Options* inOptions, unsigned inSize, MSMap_SegmentClass inClass, MSMap_SymbolScope inScope, const char* inModule, const char* inSegment, const char* inObject, const char* inSymbol)
1570 /*
1571 ** Output a line of map information separated by tabs.
1572 ** Some items (const char*), if not present, will receive a default value.
1573 */
1574 {
1575 int retval = 0;
1576
1577 /*
1578 ** No need to output on no size.
1579 ** This can happen with zero sized segments,
1580 ** or an imported symbol which has multiple names (one will count).
1581 */
1582 if(0 != inSize)
1583 {
1584 char objectBuf[0x100];
1585 const char* symScope = NULL;
1586 const char* segClass = NULL;
1587 const char* undefined = "UNDEF";
1588
1589 /*
1590 ** Fill in unspecified values.
1591 */
1592 if(NULL == inObject)
1593 {
1594 sprintf(objectBuf, "%s:%s:%s", undefined, inModule, inSegment);
1595 inObject = objectBuf;
1596 }
1597 if(NULL == inSymbol)
1598 {
1599 inSymbol = inObject;
1600 }
1601
1602 /*
1603 ** Convert some enumerations to text.
1604 */
1605 switch(inClass)
1606 {
1607 case CODE:
1608 segClass = "CODE";
1609 break;
1610 case DATA:
1611 segClass = "DATA";
1612 break;
1613 default:
1614 retval = __LINE__;
1615 ERROR_REPORT(retval, "", "Unable to determine class for output.");
1616 break;
1617 }
1618
1619 switch(inScope)
1620 {
1621 case PUBLIC:
1622 symScope = "PUBLIC";
1623 break;
1624 case STATIC:
1625 symScope = "STATIC";
1626 break;
1627 case UNDEFINED:
1628 symScope = undefined;
1629 break;
1630 default:
1631 retval = __LINE__;
1632 ERROR_REPORT(retval, "", "Unable to determine scope for symbol.");
1633 break;
1634 }
1635
1636 if(0 == retval)
1637 {
1638 int printRes = 0;
1639
1640 printRes = fprintf(inOptions->mOutput,
1641 "%.8X\t%s\t%s\t%s\t%s\t%s\t%s\n",
1642 inSize,
1643 segClass,
1644 symScope,
1645 inModule,
1646 inSegment,
1647 inObject,
1648 inSymbol
1649 );
1650
1651 if(0 > printRes)
1652 {
1653 retval = __LINE__;
1654 ERROR_REPORT(retval, inOptions->mOutputName, "Unable to output tsv data.");
1655 }
1656 }
1657 }
1658
1659 return retval;
1660 }
1661
1662
1663 void cleanModule(MSMap_Module* inModule)
1664 {
1665 unsigned loop = 0;
1666
1667 for(loop = 0; loop < inModule->mSymbolCount; loop++)
1668 {
1669 CLEANUP(inModule->mSymbols[loop].mObject);
1670 CLEANUP(inModule->mSymbols[loop].mSymbol);
1671 }
1672 CLEANUP(inModule->mSymbols);
1673
1674 for(loop = 0; loop < inModule->mSegmentCount; loop++)
1675 {
1676 CLEANUP(inModule->mSegments[loop].mSegment);
1677 }
1678 CLEANUP(inModule->mSegments);
1679
1680 CLEANUP(inModule->mModule);
1681
1682 memset(inModule, 0, sizeof(MSMap_Module));
1683 }
1684
1685
1686 int map2tsv(Options* inOptions)
1687 /*
1688 ** Read all input.
1689 ** Output tab separated value data.
1690 */
1691 {
1692 int retval = 0;
1693 MSMap_Module module;
1694
1695 memset(&module, 0, sizeof(module));
1696
1697 /*
1698 ** Read in the map file.
1699 */
1700 retval = readmap(inOptions, &module);
1701 if(0 == retval)
1702 {
1703 unsigned symLoop = 0;
1704 MSMap_Symbol* symbol = NULL;
1705 unsigned secLoop = 0;
1706 MSMap_Segment* section = NULL;
1707 unsigned size = 0;
1708 unsigned dbSize = 0;
1709 unsigned offsetSize = 0;
1710 unsigned endOffset = 0;
1711
1712 /*
1713 ** Quick sort the symbols via RVABase.
1714 */
1715 qsort(module.mSymbols, module.mSymbolCount, sizeof(MSMap_Symbol), qsortRVABase);
1716
1717 /*
1718 ** Go through all the symbols (in order by sort).
1719 ** Output their sizes.
1720 */
1721 for(symLoop = 0; 0 == retval && symLoop < module.mSymbolCount; symLoop++)
1722 {
1723 symbol = &module.mSymbols[symLoop];
1724 section = getSymbolSection(&module, symbol);
1725 if (!section)
1726 continue;
1727
1728 /*
1729 ** Use the symbol DB size if available.
1730 */
1731 dbSize = symbol->mSymDBSize;
1732
1733 /*
1734 ** Guess using offsets.
1735 ** Is there a next symbol available? If so, its start offset is the end of this symbol.
1736 ** Otherwise, our section offset + length is the end of this symbol.
1737 **
1738 ** The trick is, the DB size can not go beyond the offset size, for sanity.
1739 */
1740
1741 /*
1742 ** Try next symbol, but only if in same section.
1743 ** If still not, use the end of the segment.
1744 ** This implies we were the last symbol in the segment.
1745 */
1746 if((symLoop + 1) < module.mSymbolCount)
1747 {
1748 MSMap_Symbol* nextSymbol = NULL;
1749 MSMap_Segment* nextSection = NULL;
1750
1751 nextSymbol = &module.mSymbols[symLoop + 1];
1752 nextSection = getSymbolSection(&module, nextSymbol);
1753
1754 if(section == nextSection)
1755 {
1756 endOffset = nextSymbol->mOffset;
1757 }
1758 else
1759 {
1760 endOffset = section->mOffset + section->mLength;
1761 }
1762 }
1763 else
1764 {
1765 endOffset = section->mOffset + section->mLength;
1766 }
1767
1768 /*
1769 ** Can now guess at size.
1770 */
1771 offsetSize = endOffset - symbol->mOffset;
1772
1773 /*
1774 ** Now, determine which size to use.
1775 ** This is really a sanity check as well.
1776 */
1777 size = offsetSize;
1778 if(0 != dbSize)
1779 {
1780 if(dbSize < offsetSize)
1781 {
1782 size = dbSize;
1783 }
1784 }
1785
1786 /*
1787 ** Output the symbol with the size.
1788 */
1789 retval = tsvout(inOptions,
1790 size,
1791 section->mClass,
1792 symbol->mScope,
1793 module.mModule,
1794 section->mSegment,
1795 symbol->mObject,
1796 symbol->mSymbol
1797 );
1798
1799 /*
1800 ** Make sure we mark this amount of space as used in the section.
1801 */
1802 section->mUsed += size;
1803 }
1804
1805 /*
1806 ** Go through the sections, and those whose length is longer than the
1807 ** amount of space used, output dummy filler values.
1808 */
1809 for(secLoop = 0; 0 == retval && secLoop < module.mSegmentCount; secLoop++)
1810 {
1811 section = &module.mSegments[secLoop];
1812
1813 if(section && section->mUsed < section->mLength)
1814 {
1815 retval = tsvout(inOptions,
1816 section->mLength - section->mUsed,
1817 section->mClass,
1818 UNDEFINED,
1819 module.mModule,
1820 section->mSegment,
1821 NULL,
1822 NULL
1823 );
1824 }
1825 }
1826 }
1827
1828 /*
1829 ** Cleanup.
1830 */
1831 cleanModule(&module);
1832
1833 return retval;
1834 }
1835
1836
1837 int initOptions(Options* outOptions, int inArgc, char** inArgv)
1838 /*
1839 ** returns int 0 if successful.
1840 */
1841 {
1842 int retval = 0;
1843 int loop = 0;
1844 int switchLoop = 0;
1845 int match = 0;
1846 const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
1847 Switch* current = NULL;
1848
1849 /*
1850 ** Set any defaults.
1851 */
1852 memset(outOptions, 0, sizeof(Options));
1853 outOptions->mProgramName = inArgv[0];
1854 outOptions->mInput = stdin;
1855 outOptions->mInputName = strdup("stdin");
1856 outOptions->mOutput = stdout;
1857 outOptions->mOutputName = strdup("stdout");
1858
1859 if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName)
1860 {
1861 retval = __LINE__;
1862 ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup.");
1863 }
1864
1865 /*
1866 ** Go through and attempt to do the right thing.
1867 */
1868 for(loop = 1; loop < inArgc && 0 == retval; loop++)
1869 {
1870 match = 0;
1871 current = NULL;
1872
1873 for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++)
1874 {
1875 if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop]))
1876 {
1877 match = __LINE__;
1878 }
1879 else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop]))
1880 {
1881 match = __LINE__;
1882 }
1883
1884 if(match)
1885 {
1886 if(gSwitches[switchLoop]->mHasValue)
1887 {
1888 /*
1889 ** Attempt to absorb next option to fullfill value.
1890 */
1891 if(loop + 1 < inArgc)
1892 {
1893 loop++;
1894
1895 current = gSwitches[switchLoop];
1896 current->mValue = inArgv[loop];
1897 }
1898 }
1899 else
1900 {
1901 current = gSwitches[switchLoop];
1902 }
1903
1904 break;
1905 }
1906 }
1907
1908 if(0 == match)
1909 {
1910 outOptions->mHelp = __LINE__;
1911 retval = __LINE__;
1912 ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch.");
1913 }
1914 else if(NULL == current)
1915 {
1916 outOptions->mHelp = __LINE__;
1917 retval = __LINE__;
1918 ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value.");
1919 }
1920 else
1921 {
1922 /*
1923 ** Do something based on address/swtich.
1924 */
1925 if(current == &gInputSwitch)
1926 {
1927 CLEANUP(outOptions->mInputName);
1928 if(NULL != outOptions->mInput && stdin != outOptions->mInput)
1929 {
1930 fclose(outOptions->mInput);
1931 outOptions->mInput = NULL;
1932 }
1933
1934 outOptions->mInput = fopen(current->mValue, "r");
1935 if(NULL == outOptions->mInput)
1936 {
1937 retval = __LINE__;
1938 ERROR_REPORT(retval, current->mValue, "Unable to open input file.");
1939 }
1940 else
1941 {
1942 outOptions->mInputName = strdup(current->mValue);
1943 if(NULL == outOptions->mInputName)
1944 {
1945 retval = __LINE__;
1946 ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
1947 }
1948 }
1949 }
1950 else if(current == &gOutputSwitch)
1951 {
1952 CLEANUP(outOptions->mOutputName);
1953 if(NULL != outOptions->mOutput && stdout != outOptions->mOutput)
1954 {
1955 fclose(outOptions->mOutput);
1956 outOptions->mOutput = NULL;
1957 }
1958
1959 outOptions->mOutput = fopen(current->mValue, "a");
1960 if(NULL == outOptions->mOutput)
1961 {
1962 retval = __LINE__;
1963 ERROR_REPORT(retval, current->mValue, "Unable to open output file.");
1964 }
1965 else
1966 {
1967 outOptions->mOutputName = strdup(current->mValue);
1968 if(NULL == outOptions->mOutputName)
1969 {
1970 retval = __LINE__;
1971 ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
1972 }
1973 }
1974 }
1975 else if(current == &gHelpSwitch)
1976 {
1977 outOptions->mHelp = __LINE__;
1978 }
1979 else if(current == &gMatchModuleSwitch)
1980 {
1981 void* moved = NULL;
1982
1983 /*
1984 ** Add the value to the list of allowed module names.
1985 */
1986 moved = realloc(outOptions->mMatchModules, sizeof(char*) * (outOptions->mMatchModuleCount + 1));
1987 if(NULL != moved)
1988 {
1989 outOptions->mMatchModules = (char**)moved;
1990 outOptions->mMatchModules[outOptions->mMatchModuleCount] = strdup(current->mValue);
1991 if(NULL != outOptions->mMatchModules[outOptions->mMatchModuleCount])
1992 {
1993 outOptions->mMatchModuleCount++;
1994 }
1995 else
1996 {
1997 retval = __LINE__;
1998 ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
1999 }
2000 }
2001 else
2002 {
2003 retval = __LINE__;
2004 ERROR_REPORT(retval, current->mValue, "Unable to allocate space for string.");
2005 }
2006 }
2007 else if(current == &gSymDBSwitch)
2008 {
2009 CLEANUP(outOptions->mSymDBName);
2010 outOptions->mSymDBName = strdup(current->mValue);
2011 if(NULL == outOptions->mSymDBName)
2012 {
2013 retval = __LINE__;
2014 ERROR_REPORT(retval, current->mValue, "Unable to duplicate symbol db name.");
2015 }
2016 }
2017 else if(current == &gBatchModeSwitch)
2018 {
2019 outOptions->mBatchMode = __LINE__;
2020 }
2021 else
2022 {
2023 retval = __LINE__;
2024 ERROR_REPORT(retval, current->mLongName, "No handler for command line switch.");
2025 }
2026 }
2027 }
2028
2029 return retval;
2030 }
2031
2032
2033 void cleanOptions(Options* inOptions)
2034 /*
2035 ** Clean up any open handles, et. al.
2036 */
2037 {
2038 CLEANUP(inOptions->mInputName);
2039 if(NULL != inOptions->mInput && stdin != inOptions->mInput)
2040 {
2041 fclose(inOptions->mInput);
2042 }
2043 CLEANUP(inOptions->mOutputName);
2044 if(NULL != inOptions->mOutput && stdout != inOptions->mOutput)
2045 {
2046 fclose(inOptions->mOutput);
2047 }
2048 while(0 != inOptions->mMatchModuleCount)
2049 {
2050 inOptions->mMatchModuleCount--;
2051 CLEANUP(inOptions->mMatchModules[inOptions->mMatchModuleCount]);
2052 }
2053 CLEANUP(inOptions->mMatchModules);
2054
2055 cleanSymDB(&inOptions->mSymDB);
2056
2057 memset(inOptions, 0, sizeof(Options));
2058 }
2059
2060
2061 void showHelp(Options* inOptions)
2062 /*
2063 ** Show some simple help text on usage.
2064 */
2065 {
2066 int loop = 0;
2067 const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
2068 const char* valueText = NULL;
2069
2070 printf("usage:\t%s [arguments]\n", inOptions->mProgramName);
2071 printf("\n");
2072 printf("arguments:\n");
2073
2074 for(loop = 0; loop < switchCount; loop++)
2075 {
2076 if(gSwitches[loop]->mHasValue)
2077 {
2078 valueText = " <value>";
2079 }
2080 else
2081 {
2082 valueText = "";
2083 }
2084
2085 printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText);
2086 printf("\t %s%s", gSwitches[loop]->mShortName, valueText);
2087 printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription);
2088 }
2089
2090 printf("This tool normalizes MS linker .map files for use by other tools.\n");
2091 }
2092
2093
2094 int batchMode(Options* inOptions)
2095 /*
2096 ** Batch mode means that the input file is actually a list of map files.
2097 ** We simply swap out our input file names while we do this.
2098 */
2099 {
2100 int retval = 0;
2101 char lineBuf[0x400];
2102 FILE* realInput = NULL;
2103 char* realInputName = NULL;
2104 FILE* mapFile = NULL;
2105 int finalRes = 0;
2106
2107 realInput = inOptions->mInput;
2108 realInputName = inOptions->mInputName;
2109
2110 while(0 == retval && NULL != fgets(lineBuf, sizeof(lineBuf), realInput))
2111 {
2112 trimWhite(lineBuf);
2113
2114 /*
2115 ** Skip/allow blank lines.
2116 */
2117 if('\0' == lineBuf[0])
2118 {
2119 continue;
2120 }
2121
2122 /*
2123 ** Override what we believe to be the input for this line.
2124 */
2125 inOptions->mInputName = lineBuf;
2126 inOptions->mInput = fopen(lineBuf, "r");
2127 if(NULL != inOptions->mInput)
2128 {
2129 int mapRes = 0;
2130
2131 /*
2132 ** Do it.
2133 */
2134 mapRes = map2tsv(inOptions);
2135
2136 /*
2137 ** We report the first error that we encounter, but we continue.
2138 ** This is batch mode after all.
2139 */
2140 if(0 == finalRes)
2141 {
2142 finalRes = mapRes;
2143 }
2144
2145 /*
2146 ** Close the input file.
2147 */
2148 fclose(inOptions->mInput);
2149 }
2150 else
2151 {
2152 retval = __LINE__;
2153 ERROR_REPORT(retval, lineBuf, "Unable to open map file.");
2154 break;
2155 }
2156 }
2157
2158 if(0 == retval && 0 != ferror(realInput))
2159 {
2160 retval = __LINE__;
2161 ERROR_REPORT(retval, realInputName, "Unable to read file.");
2162 }
2163
2164 /*
2165 ** Restore what we've swapped.
2166 */
2167 inOptions->mInput = realInput;
2168 inOptions->mInputName = realInputName;
2169
2170 /*
2171 ** Report first map file error if there were no other operational
2172 ** problems.
2173 */
2174 if(0 == retval)
2175 {
2176 retval = finalRes;
2177 }
2178
2179 return retval;
2180 }
2181
2182
2183 int main(int inArgc, char** inArgv)
2184 {
2185 int retval = 0;
2186 Options options;
2187
2188 retval = initOptions(&options, inArgc, inArgv);
2189 if(options.mHelp)
2190 {
2191 showHelp(&options);
2192 }
2193 else if(0 == retval)
2194 {
2195 if(options.mBatchMode)
2196 {
2197 retval = batchMode(&options);
2198 }
2199 else
2200 {
2201 retval = map2tsv(&options);
2202 }
2203 }
2204
2205 cleanOptions(&options);
2206 return retval;
2207 }
2208