unittests for mapfile reading

Author: partouf

Diff for: lib/map-file-delphi.js

@@ -0,0 +1,145 @@
+// Copyright (c) 2017, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+"use strict";
+
+const MapFileReader = require("./map-file").MapFileReader;
+
+class MapFileReaderDelphi extends MapFileReader {
+    /**
+     * constructor
+     * @param {string} mapFilename 
+     */
+    constructor(mapFilename) {
+        super(mapFilename);
+        
+        this.regexDelphiCodeSegmentOffset = /^\s([0-9a-f]*):([0-9a-f]*)\s*([0-9a-f]*)H\s*(\.[a-z$]*)\s*([a-z]*)$/i;
+        this.regexDelphiCodeSegment = /^\s([0-9a-f]*):([0-9a-f]*)\s*([0-9a-f]*)\s*C=CODE\s*S=.text\s*G=.*M=([\w\d.]*)\s.*/i;
+        this.regexDelphiICodeSegment = /^\s([0-9a-f]*):([0-9a-f]*)\s*([0-9a-f]*)\s*C=ICODE\s*S=.itext\s*G=.*M=([\w\d.]*)\s.*/i;
+        this.regexDelphiNames = /^\s([0-9a-f]*):([0-9a-f]*)\s*([a-z0-9_@$.<>{}]*)$/i;
+        this.regexDelphiLineNumbersStart = /Line numbers for (.*)\(.*\) segment \.text/i;
+        this.regexDelphiLineNumber = /^([0-9]*)\s([0-9a-f]*):([0-9a-f]*)/i;
+        this.regexDelphiLineNumbersStartIText = /Line numbers for (.*)\(.*\) segment \.itext/i;
+    }
+
+    /**
+     * Tries to match the given line to code segment information
+     *  Matches in order:
+     *   1. segment offset info
+     *   2. code segment delphi map
+     *   3. icode segment delphi map
+     *   4. code segment vs map
+     * @param {string} line 
+     */
+    tryReadingCodeSegmentInfo(line) {
+        let codesegmentObject = false;
+
+        let matches = line.match(this.regexDelphiCodeSegmentOffset);
+        if (matches && !matches[4].includes('$') && (parseInt(matches[2], 16) >= this.preferredLoadAddress)) {
+            const addressWithOffset = parseInt(matches[2], 16);
+            this.segmentOffsets.push({
+                segment: matches[1],
+                addressInt: addressWithOffset,
+                address: addressWithOffset.toString(16),
+                segmentLength: parseInt(matches[3], 16)
+            });
+        } else {
+            matches = line.match(this.regexDelphiCodeSegment);
+            if (matches) {
+                codesegmentObject = this.addressToObject(matches[1], matches[2]);
+                codesegmentObject.id = this.segments.length + 1;
+                codesegmentObject.segmentLength = parseInt(matches[3], 16);
+                codesegmentObject.unitName = matches[4];
+
+                this.segments.push(codesegmentObject);
+            } else {
+                matches = line.match(this.regexDelphiICodeSegment);
+                if (matches) {
+                    codesegmentObject = this.addressToObject(matches[1], matches[2]);
+                    codesegmentObject.id = this.isegments.length + 1;
+                    codesegmentObject.segmentLength = parseInt(matches[3], 16);
+                    codesegmentObject.unitName = matches[4];
+
+                    this.isegments.push(codesegmentObject);
+                }
+            }
+        }
+    }
+
+    /**
+     * Try to match information about the address where a symbol is
+     * @param {string} line 
+     */
+    tryReadingNamedAddress(line) {
+        let symbolObject = false;
+
+        const matches = line.match(this.regexDelphiNames);
+        if (matches) {
+            if (!this.getSymbolInfoByName(matches[3])) {
+                symbolObject = this.addressToObject(matches[1], matches[2]);
+                symbolObject.displayName = matches[3];
+
+                this.namedAddresses.push(symbolObject);
+            }
+        }
+    }
+
+    /**
+     * 
+     * @param {string} line 
+     */
+    isStartOfLineNumbers(line) {
+        const matches = line.match(this.regexDelphiLineNumbersStart);
+        if (matches) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Retreives line number references from supplied Map line
+     * @param {string} line 
+     * @returns {boolean}
+     */
+    tryReadingLineNumbers(line) {
+        let hasLineNumbers = false;
+
+        const references = line.split("    ");    // 4 spaces
+        for (let refIdx = 0; refIdx < references.length; refIdx++) {
+            const matches = references[refIdx].match(this.regexDelphiLineNumber);
+            if (matches) {
+                const lineObject = this.addressToObject(matches[2], matches[3]);
+                lineObject.lineNumber = parseInt(matches[1], 10);
+
+                this.lineNumbers.push(lineObject);
+
+                hasLineNumbers = true;
+            }
+        }
+
+        return hasLineNumbers;
+    }
+}
+
+exports.MapFileReader = MapFileReaderDelphi;