Start to use STL and stdio in superpmi

src/coreclr/tools/superpmi/superpmi-shared/logging.cpp

@@ -53,7 +53,7 @@ void Logger::Shutdown()
 // Opens a log file at the given path and enables file-based logging, if the given path is valid.
 //
 /* static */
-void Logger::OpenLogFile(char* logFilePath)
+void Logger::OpenLogFile(const char* logFilePath)
 {
     if (s_logFile == INVALID_HANDLE_VALUE && logFilePath != nullptr)
     {

src/coreclr/tools/superpmi/superpmi-shared/logging.h

@@ -73,7 +73,7 @@ class Logger
     static void Initialize();
     static void Shutdown();
 
-    static void OpenLogFile(char* logFilePath);
+    static void OpenLogFile(const char* logFilePath);
     static void CloseLogFile();
 
     static UINT32 ParseLogLevelString(const char* specifierStr);

src/coreclr/tools/superpmi/superpmi-shared/spmiutil.cpp

@@ -9,6 +9,8 @@
 #include "logging.h"
 #include "spmiutil.h"
 
+#include <sstream>
+#include <iomanip>
 #include <minipal/debugger.h>
 #include <minipal/random.h>
 
@@ -99,86 +101,103 @@ WCHAR* GetEnvironmentVariableWithDefaultW(const WCHAR* envVarName, const WCHAR*
     return retString;
 }
 
-#ifdef TARGET_UNIX
-// For some reason, the PAL doesn't have GetCommandLineA(). So write it.
-LPSTR GetCommandLineA()
+const char* GetEnvWithDefault(const char* envVarName, const char* defaultValue)
 {
-    LPSTR  pCmdLine  = nullptr;
-    LPWSTR pwCmdLine = GetCommandLineW();
+    // getenv isn't thread safe, but it's simple and sufficient since we are development-only tool
+    char* env = getenv(envVarName);
+    return env ? env : defaultValue;
+}
 
-    if (pwCmdLine != nullptr)
+std::string GetProcessCommandLine()
+{
+#ifdef TARGET_WINDOWS
+    return ::GetCommandLineA();
+#else
+    FILE* fp = fopen("/proc/self/cmdline", "r");
+    if (fp != NULL)
     {
-        // Convert to ASCII
+        std::string result;
+        char*       cmdLine = nullptr;
+        size_t      size    = 0;
 
-        int n = WideCharToMultiByte(CP_ACP, 0, pwCmdLine, -1, nullptr, 0, nullptr, nullptr);
-        if (n == 0)
+        while (getdelim(&cmdLine, &size, '\0', fp) != -1)
         {
-            LogError("MultiByteToWideChar failed %d", GetLastError());
-            return nullptr;
-        }
+            // /proc/self/cmdline uses \0 as delimeter, convert it to space
+            if (!result.empty())
+                result += ' ';
 
-        pCmdLine = new char[n];
+            result += cmdLine;
 
-        int n2 = WideCharToMultiByte(CP_ACP, 0, pwCmdLine, -1, pCmdLine, n, nullptr, nullptr);
-        if ((n2 == 0) || (n2 != n))
-        {
-            LogError("MultiByteToWideChar failed %d", GetLastError());
-            return nullptr;
+            free(cmdLine);
+            cmdLine = nullptr;
+            size    = 0;
         }
+
+        fclose(fp);
+        return result;
     }
 
-    return pCmdLine;
+    return "";
+#endif
 }
-#endif // TARGET_UNIX
 
-bool LoadRealJitLib(HMODULE& jitLib, WCHAR* jitLibPath)
+bool LoadRealJitLib(HMODULE& jitLib, const std::string& jitLibPath)
 {
     // Load Library
     if (jitLib == NULL)
     {
-        if (jitLibPath == nullptr)
+        if (jitLibPath.empty())
         {
             LogError("LoadRealJitLib - No real jit path");
             return false;
         }
-        jitLib = ::LoadLibraryExW(jitLibPath, NULL, 0);
+#ifdef TARGET_WINDOWS
+        jitLib = ::LoadLibraryExA(jitLibPath.c_str(), NULL, 0);
         if (jitLib == NULL)
         {
-            LogError("LoadRealJitLib - LoadLibrary failed to load '%ws' (0x%08x)", jitLibPath, ::GetLastError());
+            LogError("LoadRealJitLib - LoadLibrary failed to load '%s' (%d)", jitLibPath.c_str(), ::GetLastError());
             return false;
         }
+#else
+        jitLib = ::dlopen(jitLibPath.c_str(), RTLD_LAZY);
+        // The simulated DllMain of JIT doesn't do any meaningful initialization. Skip it.
+        if (jitLib == NULL)
+        {
+            LogError("LoadRealJitLib - dlopen failed to load '%s' (%s)", jitLibPath.c_str(), ::dlerror());
+            return false;
+        }
+#endif
     }
     return true;
 }
 
-void ReplaceIllegalCharacters(WCHAR* fileName)
+void ReplaceIllegalCharacters(std::string& fileName)
 {
-    WCHAR* quote = nullptr;
-
     // Perform the following transforms:
     //  - Convert non-ASCII to ASCII for simplicity
     //  - Remove any illegal or annoying characters from the file name by
     // converting them to underscores.
     //  - Replace any quotes in the file name with spaces.
-    for (quote = fileName; *quote != '\0'; quote++)
+
+    for (char& quote : fileName)
     {
-        WCHAR ch = *quote;
+        char ch = quote;
         if ((ch <= 32) || (ch >= 127)) // Only allow textual ASCII characters
         {
-            *quote = W('_');
+            quote = '_';
         }
         else
         {
             switch (ch)
             {
-                case W('('): case W(')'): case W('='): case W('<'):
-                case W('>'): case W(':'): case W('/'): case W('\\'):
-                case W('|'): case W('?'): case W('!'): case W('*'):
-                case W('.'): case W(','):
-                    *quote = W('_');
+                case '(': case ')': case '=': case '<':
+                case '>': case ':': case '/': case '\\':
+                case '|': case '?': case '!': case '*':
+                case '.': case ',':
+                    quote = '_';
                     break;
-                case W('"'):
-                    *quote = W(' ');
+                case '"':
+                    quote = ' ';
                     break;
                 default:
                     break;
@@ -187,67 +206,34 @@ void ReplaceIllegalCharacters(WCHAR* fileName)
     }
 }
 
-// All lengths in this function exclude the terminal NULL.
-WCHAR* GetResultFileName(const WCHAR* folderPath, const WCHAR* fileName, const WCHAR* extension)
+std::string GetResultFileName(const std::string& folderPath,
+                              const std::string& fileName,
+                              const std::string& extension)
 {
-    const size_t extensionLength    = u16_strlen(extension);
-    const size_t fileNameLength     = u16_strlen(fileName);
-    const size_t randomStringLength = 8;
-    const size_t maxPathLength      = MAX_PATH - 50;
-
-    // See how long the folder part is, and start building the file path with the folder part.
+    // Append a random string to improve uniqueness.
     //
-    WCHAR* fullPath = new WCHAR[MAX_PATH];
-    fullPath[0] = W('\0');
-    const size_t folderPathLength = GetFullPathNameW(folderPath, MAX_PATH, (LPWSTR)fullPath, NULL);
+    uint32_t randomNumber = 0;
+    minipal_get_non_cryptographically_secure_random_bytes((uint8_t*)&randomNumber, sizeof(randomNumber));
+    std::stringstream ss;
+    ss << std::hex << std::setw(8) << std::setfill('0') << randomNumber;
+    std::string suffix = ss.str() + extension;
 
-    if (folderPathLength == 0)
+    // Limit the total file name length to MAX_PATH - 50
+    int usableLength = MAX_PATH - 50 - (int)folderPath.size() - (int)suffix.size();
+    if (usableLength < 0)
     {
-        LogError("GetResultFileName - can't resolve folder path '%ws'", folderPath);
-        return nullptr;
+        LogError("GetResultFileName - folder path '%s' length + minimal file name exceeds limit %d", folderPath.c_str(), MAX_PATH - 50);
+        return "";
     }
 
-    // Account for the folder, directory separator and extension.
-    //
-    size_t fullPathLength = folderPathLength + 1 + extensionLength;
-
-    // If we won't have room for a minimal file name part, bail.
-    //
-    if ((fullPathLength + randomStringLength) > maxPathLength)
+    std::string copy = fileName;
+    if ((int)copy.size() > usableLength)
     {
-        LogError("GetResultFileName - folder path '%ws' length + minimal file name exceeds limit %d", fullPath, maxPathLength);
-        return nullptr;
+        copy = copy.substr(0, usableLength);
     }
 
-    // Now figure out the file name part.
-    //
-    const size_t maxFileNameLength = maxPathLength - fullPathLength;
-    size_t usableFileNameLength = min(fileNameLength, maxFileNameLength - randomStringLength);
-    fullPathLength += usableFileNameLength + randomStringLength;
-
-    // Append the file name part
-    //
-    wcsncat_s(fullPath, fullPathLength + 1, DIRECTORY_SEPARATOR_STR_W, 1);
-    wcsncat_s(fullPath, fullPathLength + 1, fileName, usableFileNameLength);
-
-    // Clean up anything in the file part that can't be in a file name.
-    //
-    ReplaceIllegalCharacters(fullPath + folderPathLength + 1);
-
-    // Append a random string to improve uniqueness.
-    //
-    unsigned int randomNumber = 0;
-    minipal_get_non_cryptographically_secure_random_bytes((uint8_t*)&randomNumber, sizeof(randomNumber));
-
-    WCHAR randomString[randomStringLength + 1];
-    FormatInteger(randomString, randomStringLength + 1, "%08X", randomNumber);
-    wcsncat_s(fullPath, fullPathLength + 1, randomString, randomStringLength);
-
-    // Append extension
-    //
-    wcsncat_s(fullPath, fullPathLength + 1, extension, extensionLength);
-
-    return fullPath;
+    ReplaceIllegalCharacters(copy);
+    return folderPath + DIRECTORY_SEPARATOR_CHAR_A + copy + suffix;
 }
 
 #ifdef TARGET_AMD64

src/coreclr/tools/superpmi/superpmi-shared/spmiutil.h

@@ -8,6 +8,12 @@
 #define _SPMIUtil
 
 #include "methodcontext.h"
+#ifdef TARGET_WINDOWS
+#define GET_PROC_ADDRESS ::GetProcAddress
+#else
+#include <dlfcn.h>
+#define GET_PROC_ADDRESS ::dlsym
+#endif
 
 bool BreakOnDebugBreakorAV();
 void SetBreakOnDebugBreakOrAV(bool value);
@@ -21,13 +27,15 @@ char* GetEnvironmentVariableWithDefaultA(const char* envVarName, const char* def
 
 WCHAR* GetEnvironmentVariableWithDefaultW(const WCHAR* envVarName, const WCHAR* defaultValue = nullptr);
 
-#ifdef TARGET_UNIX
-LPSTR GetCommandLineA();
-#endif // TARGET_UNIX
+const char* GetEnvWithDefault(const char* envVarName, const char* defaultValue = nullptr);
 
-bool LoadRealJitLib(HMODULE& realJit, WCHAR* realJitPath);
+std::string GetProcessCommandLine();
 
-WCHAR* GetResultFileName(const WCHAR* folderPath, const WCHAR* fileName, const WCHAR* extension);
+bool LoadRealJitLib(HMODULE& realJit, const std::string& realJitPath);
+
+std::string GetResultFileName(const std::string& folderPath,
+                              const std::string& fileName,
+                              const std::string& extension);
 
 // SuperPMI stores handles as unsigned 64-bit integers, no matter the platform the collection happens on
 // (32 or 64 bit). Handles are defined as pointers. We need to be careful when converting from a handle

src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitcompiler.cpp

@@ -68,7 +68,7 @@ CorJitResult interceptor_ICJC::compileMethod(ICorJitInfo*                comp,
     auto* mc = new MethodContext();
     interceptor_ICJI our_ICorJitInfo(this, comp, mc);
 
-    mc->cr->recProcessName(GetCommandLineA());
+    mc->cr->recProcessName(GetProcessCommandLine().c_str());
 
     mc->recCompileMethod(info, flags, currentOs);