Merge pull request #621 from LeeLeahy2/read-map-file

Read_Map_File: Parse more symbols

Author: nseidle

Firmware/Tools/Read_Map_File.c

@@ -53,10 +53,18 @@ typedef struct _SYMBOL_TYPE
     char * name;
 } SYMBOL_TYPE;
 
+typedef struct _PARSE_TABLE_ENTRY
+{
+    const char * string;
+    size_t stringLength;
+    void (* routine)(char * line);
+} PARSE_TABLE_ENTRY;
+
 //----------------------------------------
 // Constants
 //----------------------------------------
 
+#define C_PLUS_PLUS_HEADER      "_Z"
 #define HALF_READ_BUFFER_SIZE   65536
 #define STDIN                   0
 
@@ -68,15 +76,26 @@ typedef struct _SYMBOL_TYPE
 
 int exitStatus;
 size_t fileLength;
+char line[HALF_READ_BUFFER_SIZE];
+int lineNumber;
+int mapFile;
 char readBuffer[HALF_READ_BUFFER_SIZE * 2];
 size_t readBufferBytes;
 bool readBufferEndOfFile;
 size_t readBufferHead;
 size_t readBufferTail;
+char symbolBuffer[HALF_READ_BUFFER_SIZE];
 int symbolEntries;
 SYMBOL_TYPE * symbolListHead;
 SYMBOL_TYPE * symbolListTail;
 
+//----------------------------------------
+// Macros
+//----------------------------------------
+
+#define PARSE_ENTRY(string, routine) \
+    {string, sizeof(string) - 1, routine}
+
 //----------------------------------------
 // Support routines
 //----------------------------------------
@@ -149,7 +168,7 @@ char * skipOverText(char * buffer)
 // File read routines
 //----------------------------------------
 
-int readFromFile(int mapFile)
+int readFromFile()
 {
     ssize_t bytesRead;
 
@@ -176,7 +195,7 @@ int readFromFile(int mapFile)
     return exitStatus;
 }
 
-ssize_t readLineFromFile(int mapFile, char * buffer, size_t maxLineLength)
+ssize_t readLineFromFile(char * buffer, size_t maxLineLength)
 {
     char * bufferEnd;
     char * bufferStart;
@@ -192,7 +211,7 @@ ssize_t readLineFromFile(int mapFile, char * buffer, size_t maxLineLength)
         if ((!readBufferEndOfFile)
             && (readBufferBytes <= HALF_READ_BUFFER_SIZE))
         {
-            status = readFromFile(mapFile);
+            status = readFromFile();
             if (status)
                 return -1;
         }
@@ -228,13 +247,267 @@ ssize_t readLineFromFile(int mapFile, char * buffer, size_t maxLineLength)
 // Map file parsing routines
 //----------------------------------------
 
-int parseMapFile(int mapFile)
+void symbolAdd(const char * symbol, uint64_t baseAddress, uint64_t length)
+{
+    SYMBOL_TYPE * entry;
+
+    entry = malloc(sizeof(SYMBOL_TYPE) + 7 + strlen(symbol) + 1);
+    if (entry)
+    {
+        // Build the symbol entry
+        entry->nextSymbol = nullptr;
+        entry->address = baseAddress;
+        entry->length = length;
+        entry->name = &((char *)entry)[sizeof(SYMBOL_TYPE)];
+        strcpy(entry->name, symbol);
+
+        // Add the symbol to the list
+        if (!symbolListHead)
+        {
+            // This is the first entry in the list
+            symbolListHead = entry;
+            symbolListTail = entry;
+        }
+        else
+        {
+            // Add this entry of the end of the list
+            symbolListTail->nextSymbol = entry;
+            symbolListTail = entry;
+        }
+        symbolEntries += 1;
+//        printf("0x%08lx-0x%08lx: %s\n",
+//               baseAddress, baseAddress + length - 1, symbol);
+    }
+}
+
+char * symbolGetName(char * buffer)
+{
+    int c;
+    size_t headerLength;
+    char * symbolName;
+
+    // Determine if this is a c symbol
+    headerLength = sizeof(C_PLUS_PLUS_HEADER) - 1;
+    c = strncmp(buffer, C_PLUS_PLUS_HEADER, headerLength);
+
+    // Remove the c++ header from the symbol
+    if (!c)
+    {
+        buffer += headerLength;
+        if (*buffer == 'N')
+            buffer++;
+        if (*buffer == 'K')
+            buffer++;
+
+        // Remove the value
+        while ((*buffer >= '0') && (*buffer <= '9'))
+            buffer++;
+    }
+
+    // Get the symbol name
+    symbolName = &symbolBuffer[0];
+    while (*buffer && (*buffer != ' ') && (*buffer != '\t'))
+        *symbolName++ = *buffer++;
+    *symbolName = 0;
+
+    // Remove the last character of a c++ symbol
+    if ((!c) && (symbolBuffer[0]))
+        *--symbolName = 0;
+
+    // Return the next position in the buffer
+    return buffer;
+}
+
+void parseIram1(char * buffer)
+{
+    uint64_t baseAddress;
+    uint64_t length;
+
+    /* There are 4 different forms of iram1 lines:
+
+ .iram1.30      0x0000000040084f00       0x5c /home/.../libheap.a(heap_caps.c.obj)
+                0x0000000040084f00                heap_caps_malloc_prefer
+
+ .iram1.4       0x00000000400851b0       0x21 /home/.../libesp_hw_support.a(cpu_util.c.obj)
+                0x00000000400851b0                esp_cpu_reset
+ *fill*         0x00000000400851d1        0x3
+
+ .iram1.34      0x0000000040084f5c       0x36 /home/.../libheap.a(heap_caps.c.obj)
+                                         0x3e (size before relaxing)
+                0x0000000040084f5c                heap_caps_free
+
+ .iram1.5       0x00000000400851d4       0x31 /home/.../libesp_hw_support.a(cpu_util.c.obj)
+                                         0x35 (size before relaxing)
+                0x00000000400851d4                esp_cpu_set_watchpoint
+ *fill*         0x0000000040085205        0x3
+        */
+
+    do
+    {
+        // Skip the rest of the iram1 stuff
+        buffer = skipOverText(buffer);
+
+        // Remove the white space
+        buffer = removeWhiteSpace(buffer);
+
+        // Get the symbol address
+        if (sscanf(buffer, "0x%016lx", &baseAddress) != 1)
+            break;
+
+        // Validate the symbol address
+        if (baseAddress < 0x40000000)
+            break;
+
+        // Get the symbol length
+        buffer = skipOverText(buffer);
+        buffer = removeWhiteSpace(buffer);
+        if (sscanf(buffer, "0x%lx", &length) != 1)
+            break;
+
+        // Read a line from the map file
+        if (readLineFromFile(line, sizeof(line)) <= 0)
+            break;
+        lineNumber += 1;
+        buffer = &line[16];
+
+        // Locate the symbol value
+        buffer += 16;
+        if (*buffer != '0')
+        {
+            // Read a line from the map file
+            if (readLineFromFile(line, sizeof(line)) <= 0)
+                break;
+            lineNumber += 1;
+            buffer = &line[16];
+        }
+
+        // Get the symbol name
+        buffer = skipOverText(buffer);
+        buffer = removeWhiteSpace(buffer);
+        buffer = symbolGetName(buffer);
+        symbolAdd(symbolBuffer, baseAddress, length);
+    } while (0);
+}
+
+void parseTextLine(char * buffer)
 {
     uint64_t baseAddress;
-    char * buffer;
     uint64_t length;
-    static char line[HALF_READ_BUFFER_SIZE];
+    size_t lineOffset;
+    int offset;
+    char * symbol;
+    int value;
+
+    /* There are 6 different forms of iram1 lines:
+ .text.i2cRead  0x0000000040132094       0xfc /tmp/.../core.a(esp32-hal-i2c.c.o)
+                                        0x107 (size before relaxing)
+                0x0000000040132094                i2cRead
+
+ .text.i2cRead  0x0000000040132094       0xff /tmp/.../core.a(esp32-hal-i2c.c.o)
+                                        0x107 (size before relaxing)
+                0x0000000040132094                i2cRead
+ *fill*         0x0000000040132193        0x1
+
+ .text._Z21createMessageListBaseR6String
+                0x00000000400dc990      0x150 /tmp/.../RTK_Surveyor.ino.cpp.o
+                0x00000000400dc990                _Z21createMessageListBaseR6String
+
+ .text._Z17ntripClientUpdatev
+                0x00000000400dfe24      0x462 /tmp/.../RTK_Surveyor.ino.cpp.o
+                0x00000000400dfe24                _Z17ntripClientUpdatev
+ *fill*         0x00000000400e0286        0x2
+
+ .text._Z12printUnknownh
+                0x00000000400e1058       0x18 /tmp/.../RTK_Surveyor.ino.cpp.o
+                                         0x20 (size before relaxing)
+                0x00000000400e1058                _Z12printUnknownh
+
+ .text._Z12printUnknowni
+                0x00000000400e1070       0x13 /tmp/.../RTK_Surveyor.ino.cpp.o
+                                         0x1a (size before relaxing)
+                0x00000000400e1070                _Z12printUnknowni
+ *fill*         0x00000000400e1083        0x1
+    */
+
+    do
+    {
+        // Get the symbol name
+        buffer = symbolGetName(buffer);
+
+        // Remove the white space
+        buffer = removeWhiteSpace(buffer);
+
+        // Read the symbol address and length from next line if necessary
+        if (!*buffer)
+        {
+            // Read a line from the map file
+            if (readLineFromFile(line, sizeof(line)) <= 0)
+                break;
+            lineNumber += 1;
+            buffer = line;
+        }
+
+        // Remove the white space
+        buffer = removeWhiteSpace(buffer);
+
+        // Get the symbol address
+        if (sscanf(buffer, "0x%016lx", &baseAddress) != 1)
+            break;
+
+        // Remove the white space
+        buffer = skipOverText(buffer);
+        buffer = removeWhiteSpace(buffer);
+
+        // Get the symbol length
+        if (sscanf(buffer, "0x%lx", &length) == 1)
+        {
+            // Routines are in flash which starts at 0x40000000
+            if (baseAddress >= 0x40000000)
+                    symbolAdd(symbolBuffer, baseAddress, length);
+        }
+    } while (0);
+}
+
+// Define the search text and routine to process the line when found
+const PARSE_TABLE_ENTRY parseTable[] =
+{
+    PARSE_ENTRY(" .iram1.",  parseIram1),
+    PARSE_ENTRY(" .text.", parseTextLine),
+};
+const int parseTableEntries = sizeof(parseTable) / sizeof(parseTable[0]);
+
+// Parse the map file to locate the symbols and their addresses and lengths
+int parseMapFile()
+{
+    const PARSE_TABLE_ENTRY * entry;
+    int index;
     ssize_t lineLength;
+
+    do
+    {
+        // Read a line from the map file
+        lineLength = readLineFromFile(line, sizeof(line));
+        if (lineLength <= 0)
+            break;
+        lineNumber += 1;
+
+        // Locate the matching text in the map file
+        for (index = 0; index < parseTableEntries; index++)
+        {
+            // Locate the routine names
+            entry = &parseTable[index];
+            if (strncmp(line, entry->string, entry->stringLength) == 0)
+            {
+                parseTable[index].routine(&line[entry->stringLength]);
+                break;
+            }
+        }
+    } while (readBufferBytes);
+
+/*
+    uint64_t baseAddress;
+    char * buffer;
+    uint64_t length;
     static size_t lineNumber;
     size_t lineOffset;
     int offset;
@@ -245,10 +518,11 @@ int parseMapFile(int mapFile)
     int value;
 
     textLength = strlen(text);
+
     do
     {
         // Read a line from the map file
-        lineLength = readLineFromFile(mapFile, line, sizeof(line));
+        lineLength = readLineFromFile(line, sizeof(line));
         if (lineLength <= 0)
             break;
         lineNumber += 1;
@@ -284,7 +558,7 @@ int parseMapFile(int mapFile)
             if (!*buffer)
             {
                 // Read a line from the map file
-                lineLength = readLineFromFile(mapFile, line, sizeof(line));
+                lineLength = readLineFromFile(line, sizeof(line));
                 if (lineLength <= 0)
                     break;
                 lineNumber += 1;
@@ -341,6 +615,8 @@ int parseMapFile(int mapFile)
             }
         }
     } while (readBufferBytes);
+*/
+
     return exitStatus;
 }
 
@@ -469,7 +745,6 @@ int processBacktrace()
 int main(int argc, char ** argv)
 {
     char * filename;
-    int mapFile;
     int status;
 
     do
@@ -493,7 +768,7 @@ int main(int argc, char ** argv)
         }
 
         // Parse the map file
-        status = parseMapFile(mapFile);
+        status = parseMapFile();
     } while (0);
 
     if (!status)