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