Move SuperPMI and ilasm/ildasm off PAL file APIs

src/coreclr/ilasm/asmparse.h

@@ -7,6 +7,7 @@
 #define asmparse_h
 
 #include <stdio.h>		// for FILE
+#include "minipal.h"
 
 #include "assembler.h"	// for ErrorReporter Labels
 //class Assembler;
@@ -95,9 +96,9 @@ class MappedFileStream : public ReadStream {
 public:
     MappedFileStream(_In_ __nullterminated WCHAR* wFileName)
         : m_fileNameUtf8(NULL)
-        , m_hFile(INVALID_HANDLE_VALUE)
+        , m_hFile(VMToOSInterface::InvalidFileHandle)
         , m_FileSize(0)
-        , m_hMapFile(NULL)
+        , m_hMapFile(VMToOSInterface::InvalidMemoryMapHandle)
     {
         m_pStart = open(wFileName);
         m_pCurr = m_pStart;
@@ -112,17 +113,17 @@ class MappedFileStream : public ReadStream {
     }
     ~MappedFileStream()
     {
-        if (m_hFile != INVALID_HANDLE_VALUE)
+        if (m_hFile != VMToOSInterface::InvalidFileHandle)
         {
             if (m_pStart)
-                UnmapViewOfFile((void*)m_pStart);
-            if (m_hMapFile)
-                CloseHandle(m_hMapFile);
-            CloseHandle(m_hFile);
+                VMToOSInterface::UnmapMemory((void*)m_pStart, m_FileSize);
+            if (m_hMapFile != VMToOSInterface::InvalidMemoryMapHandle)
+                VMToOSInterface::CloseMemoryMapping(m_hMapFile);
+            VMToOSInterface::CloseFile(m_hFile);
 
             m_pStart = NULL;
-            m_hMapFile = NULL;
-            m_hFile = INVALID_HANDLE_VALUE;
+            m_hMapFile = VMToOSInterface::InvalidMemoryMapHandle;
+            m_hFile = VMToOSInterface::InvalidFileHandle;
             m_FileSize = 0;
         }
 
@@ -173,35 +174,32 @@ class MappedFileStream : public ReadStream {
 private:
     char* map_file()
     {
-        DWORD dwFileSizeLow;
+        uint64_t fileSize;
 
-        dwFileSizeLow = GetFileSize( m_hFile, NULL);
-        if (dwFileSizeLow == INVALID_FILE_SIZE)
+        if (!VMToOSInterface::GetFileSize(m_hFile, &fileSize) || fileSize == 0 || fileSize > UINT32_MAX)
             return NULL;
-        m_FileSize = dwFileSizeLow;
+        m_FileSize = (DWORD)fileSize;
 
-        // No difference between A and W in this case: last param (LPCTSTR) is NULL
-        m_hMapFile = CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-        if (m_hMapFile == NULL)
+        m_hMapFile = VMToOSInterface::CreateMemoryMapping(m_hFile, 0, VMToOSInterface::MemoryProtection::ReadOnly);
+        if (m_hMapFile == VMToOSInterface::InvalidMemoryMapHandle)
             return NULL;
 
-        return (char*)(HMODULE) MapViewOfFile(m_hMapFile, FILE_MAP_READ, 0, 0, 0);
+        return (char*)VMToOSInterface::MapMemory(m_hMapFile, 0, nullptr, m_FileSize, VMToOSInterface::MemoryProtection::ReadOnly, true);
     }
     char* open(const WCHAR* moduleName)
     {
         _ASSERTE(moduleName);
         if (!moduleName)
             return NULL;
 
-        m_hFile = WszCreateFile(moduleName, GENERIC_READ, FILE_SHARE_READ,
-                             0, OPEN_EXISTING, 0, 0);
-        return (m_hFile == INVALID_HANDLE_VALUE) ? NULL : map_file();
+        m_hFile = VMToOSInterface::OpenFile(reinterpret_cast<const char16_t*>(moduleName), /* executable */ false);
+        return (m_hFile == VMToOSInterface::InvalidFileHandle) ? NULL : map_file();
     }
 
     char*	m_fileNameUtf8; // FileName (for error reporting)
-    HANDLE  m_hFile;                 // File we are reading from
+    VMToOSInterface::MemoryMapHandle m_hFile;   // File we are reading from
     DWORD   m_FileSize;
-    HANDLE  m_hMapFile;
+    VMToOSInterface::MemoryMapHandle m_hMapFile;
     char*   m_pStart;
     char*   m_pEnd;
     char*   m_pCurr;
@@ -299,8 +297,6 @@ class AsmParse : public ErrorReporter
     BinStr* MakeTypeArray(CorElementType kind, BinStr* elemType, BinStr* bounds);
 
     char* fillBuff(_In_opt_z_ char* curPos);   // refill the input buffer
-    HANDLE hstdout;
-    HANDLE hstderr;
 
 private:
     friend void yyerror(_In_ __nullterminated const char* str);

src/coreclr/ilasm/grammar_after.cpp

@@ -1003,6 +1003,30 @@ int yylex()
 #endif
                                 )
                                 {
+#ifdef TARGET_UNIX
+                                    for(const WCHAR* wzDir = parser->wzIncludePath; (wzDir != NULL) && (*wzDir != 0); )
+                                    {
+                                        const WCHAR* wzEnd = u16_strchr(wzDir, W(':'));
+                                        COUNT_T dirLen = (wzEnd != NULL) ? (COUNT_T)(wzEnd - wzDir) : (COUNT_T)u16_strlen(wzDir);
+                                        if(dirLen != 0)
+                                        {
+                                            PathString wzCandidate;
+                                            wzCandidate.Set(wzDir, dirLen);
+                                            wzCandidate.Append(W("/"));
+                                            wzCandidate.Append(wzFile);
+                                            MAKE_UTF8PTR_FROMWIDE(candidateUtf8, wzCandidate.GetUnicode());
+                                            FILE* pCandidate = fopen(candidateUtf8, "rb");
+                                            if(pCandidate != NULL)
+                                            {
+                                                fclose(pCandidate);
+                                                delete [] wzFile;
+                                                wzFile = wzCandidate.GetCopyOfUnicodeString();
+                                                break;
+                                            }
+                                        }
+                                        wzDir = (wzEnd != NULL) ? wzEnd + 1 : NULL;
+                                    }
+#else
                                     PathString wzFullName;
 
                                     WCHAR* pwz;
@@ -1014,7 +1038,7 @@ int yylex()
 
                                         wzFile = wzFullName.GetCopyOfUnicodeString();
                                     }
-
+#endif
                                 }
                                 if(PASM->m_fReportProgress)
                                 {
@@ -1607,9 +1631,6 @@ AsmParse::AsmParse(ReadStream* aIn, Assembler *aAssem)
     wzIncludePath = NULL;
     penv = NULL;
 
-    hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
-    hstderr = GetStdHandle(STD_ERROR_HANDLE);
-
     success = true;
     _ASSERTE(parser == 0);          // Should only be one parser instance at a time
 

src/coreclr/ilasm/main.cpp

@@ -11,6 +11,10 @@
 #include "clrversion.h"
 
 #include "strsafe.h"
+#ifdef TARGET_UNIX
+#include <limits.h>
+#include <unistd.h>
+#endif
 #define ASSERTE_ALL_BUILDS(expr) _ASSERTE_ALL_BUILDS((expr))
 
 WCHAR* EqualOrColon(_In_ __nullterminated WCHAR* szArg)
@@ -99,11 +103,22 @@ void MakeProperSourceFileName(_In_ __nullterminated WCHAR* wzOrigName,
 
 char* FullFileName(_In_ __nullterminated WCHAR* wzFileName, unsigned uCodePage)
 {
+#ifdef TARGET_UNIX
+    char szFileName[MAX_FILENAME_LENGTH*3];
+    WideCharToMultiByte(uCodePage,0,wzFileName,-1,szFileName,MAX_FILENAME_LENGTH*3-1,NULL,NULL);
+    char szCwd[PATH_MAX];
+    char szFullPath[PATH_MAX + MAX_FILENAME_LENGTH*3];
+    if((szFileName[0] != '/') && (getcwd(szCwd, sizeof(szCwd)) != NULL))
+        sprintf_s(szFullPath, sizeof(szFullPath), "%s/%s", szCwd, szFileName);
+    else
+        strcpy_s(szFullPath, sizeof(szFullPath), szFileName);
+#else
     static WCHAR wzFullPath[MAX_FILENAME_LENGTH];
     WCHAR* pwz;
     GetFullPathName(wzFileName,MAX_FILENAME_LENGTH,wzFullPath,&pwz);
     char szFullPath[MAX_FILENAME_LENGTH*3];
     WideCharToMultiByte(uCodePage,0,wzFullPath,-1,szFullPath,MAX_FILENAME_LENGTH*3-1,NULL,NULL);
+#endif
     char* sz = new char[strlen(szFullPath)+1];
     if(sz) strcpy_s(sz,strlen(szFullPath)+1,szFullPath);
     return sz;

src/coreclr/ildasm/ceeload.cpp

@@ -17,9 +17,9 @@
 /*************************************************************************************/
 PELoader::PELoader()
 {
-    m_hFile = NULL;
+    m_hFile = VMToOSInterface::InvalidFileHandle;
     m_hMod = NULL;
-    m_hMapFile = NULL;
+    m_hMapFile = VMToOSInterface::InvalidMemoryMapHandle;
     m_pNT64 = NULL;
     m_bIsPE32 = FALSE;
     m_FileSize = m_FileSizeAligned = 0;
@@ -33,89 +33,54 @@ PELoader::~PELoader()
     // If we have an hFile then we opened this file ourselves!
     // If we do not then this file was loaded by the OS and the OS will
     // close it for us.
-    if (m_hFile)
+    if (m_hFile != VMToOSInterface::InvalidFileHandle)
         this->close();
 }
 
 /*************************************************************************************/
 /*************************************************************************************/
 void PELoader::close()
 {
-
-    // _ASSERTE(m_hFile != NULL);
-    if (m_hFile)
+    if (m_hFile != VMToOSInterface::InvalidFileHandle)
     {
         if (m_hMod)
-            UnmapViewOfFile((void*)m_hMod);
-        if (m_hMapFile)
-            CloseHandle(m_hMapFile);
-        CloseHandle(m_hFile);
+            VMToOSInterface::UnmapMemory((void*)m_hMod, m_FileSize);
+        if (m_hMapFile != VMToOSInterface::InvalidMemoryMapHandle)
+            VMToOSInterface::CloseMemoryMapping(m_hMapFile);
+        VMToOSInterface::CloseFile(m_hFile);
 
         m_hMod = NULL;
-        m_hMapFile = NULL;
-        m_hFile = NULL;
+        m_hMapFile = VMToOSInterface::InvalidMemoryMapHandle;
+        m_hFile = VMToOSInterface::InvalidFileHandle;
         m_FileSize = m_FileSizeAligned = 0;
     }
 }
 
-
-BOOL PELoader::open(LPCSTR moduleName)
-{
-    HMODULE newhMod = NULL;
-    DWORD dwFileSizeLow;
-
-    _ASSERTE(moduleName);
-    if (!moduleName)
-        return FALSE;
-
-
-    m_hFile = CreateFileA(moduleName, GENERIC_READ, FILE_SHARE_READ,
-                         0, OPEN_EXISTING, 0, 0);
-    if (m_hFile == INVALID_HANDLE_VALUE)
-        return FALSE;
-
-    dwFileSizeLow = GetFileSize( m_hFile, NULL);
-    if (dwFileSizeLow == INVALID_FILE_SIZE)
-        return FALSE;
-    m_FileSize = dwFileSizeLow;
-
-    m_hMapFile = CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-    if (m_hMapFile == NULL)
-        return FALSE;
-
-    newhMod = (HMODULE) MapViewOfFile(m_hMapFile, FILE_MAP_READ, 0, 0, 0);
-    if (newhMod == NULL)
-        return FALSE;
-   return open(newhMod);
-}
-
 BOOL PELoader::open(const WCHAR* moduleName)
 {
-    HMODULE newhMod = NULL;
-    DWORD dwFileSizeLow;
+    uint64_t fileSize;
+    void* view;
 
     _ASSERTE(moduleName);
     if (!moduleName)
         return FALSE;
 
-    m_hFile = WszCreateFile(moduleName, GENERIC_READ, FILE_SHARE_READ,
-                         0, OPEN_EXISTING, 0, 0);
-    if (m_hFile == INVALID_HANDLE_VALUE)
+    m_hFile = VMToOSInterface::OpenFile(reinterpret_cast<const char16_t*>(moduleName), /* executable */ false);
+    if (m_hFile == VMToOSInterface::InvalidFileHandle)
         return FALSE;
 
-    dwFileSizeLow = GetFileSize( m_hFile, NULL);
-    if (dwFileSizeLow == INVALID_FILE_SIZE)
+    if (!VMToOSInterface::GetFileSize(m_hFile, &fileSize) || fileSize == 0 || fileSize > UINT32_MAX)
         return FALSE;
-    m_FileSize = dwFileSizeLow;
+    m_FileSize = (size_t)fileSize;
 
-    m_hMapFile = CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-    if (m_hMapFile == NULL)
+    m_hMapFile = VMToOSInterface::CreateMemoryMapping(m_hFile, 0, VMToOSInterface::MemoryProtection::ReadOnly);
+    if (m_hMapFile == VMToOSInterface::InvalidMemoryMapHandle)
         return FALSE;
 
-    newhMod = (HMODULE) MapViewOfFile(m_hMapFile, FILE_MAP_READ, 0, 0, 0);
-    if (newhMod == NULL)
+    view = VMToOSInterface::MapMemory(m_hMapFile, 0, nullptr, m_FileSize, VMToOSInterface::MemoryProtection::ReadOnly, true);
+    if (view == nullptr)
         return FALSE;
-   return open(newhMod);
+   return open((HMODULE)view);
 }
 
 

src/coreclr/ildasm/ceeload.h

@@ -9,6 +9,8 @@
 #ifndef CEELoad_H
 #define CEELoad_H
 
+#include "minipal.h"
+
 class PELoader;
 
 //
@@ -35,8 +37,8 @@ class PELoader {
   protected:
 
     HMODULE m_hMod;
-    HANDLE m_hFile;
-    HANDLE m_hMapFile;
+    VMToOSInterface::MemoryMapHandle m_hFile;
+    VMToOSInterface::MemoryMapHandle m_hMapFile;
     BOOL   m_bIsPE32;
     size_t m_FileSize;
     size_t m_FileSizeAligned;
@@ -54,7 +56,6 @@ class PELoader {
 
     PELoader();
     ~PELoader();
-    BOOL open(const char* moduleNameIn);
     BOOL open(const WCHAR* moduleNameIn);
     BOOL open(HMODULE hMod);
     BOOL getCOMHeader(IMAGE_COR20_HEADER **ppCorHeader);
@@ -69,7 +70,7 @@ class PELoader {
     inline DWORD Signature() { return m_pNT32->Signature; };
     inline BYTE*  base() { return (BYTE*) m_hMod; };
     inline HMODULE getHModule() { return  m_hMod; };
-    inline HANDLE getHFile()	{ return  m_hFile; } ;
+    inline size_t getFileSize() { return  m_FileSize; };
 };
 
 #endif // CEELoad_H

src/coreclr/ildasm/dasm.cpp

@@ -5820,7 +5820,7 @@ void DumpStatistics(IMAGE_COR20_HEADER *CORHeader, void* GUICookie)
     TableSeenReset();
     metaSize = 0;
 
-    sprintf_s(szString,SZSTRING_SIZE,"// File size            : %d", fileSize = SafeGetFileSize(g_pPELoader->getHFile(), NULL));
+    sprintf_s(szString,SZSTRING_SIZE,"// File size            : %d", fileSize = (int)g_pPELoader->getFileSize());
     printLine(GUICookie,szStr);
 
     if (g_pPELoader->IsPE32())

src/coreclr/ildasm/dis.cpp

@@ -39,8 +39,6 @@ extern unsigned g_uConsoleCP;
 
 extern BOOL                 g_fThisIsInstanceMethod;
 extern unsigned             g_uCodePage;
-extern HANDLE               hConsoleOut;
-extern HANDLE               hConsoleErr;
 // globals for source file info
 ULONG_PTR ulWasFileToken = 0xFFFFFFFF;
 GUID guidWasLang={0}, guidWasLangVendor={0},guidWasDoc={0};
@@ -131,10 +129,6 @@ char* AnsiToUtf(_In_ __nullterminated const char* sz) { return UnicodeToUtf(Ansi
 static void UnicodeToConsoleOrMsgBox(_In_ __nullterminated const WCHAR* wz)
 {
     {
-        //DWORD dw;
-        //char* sz = UnicodeToAnsi(wz);
-        //WriteFile(hConsoleOut,(CONST VOID *)sz, (ULONG32)strlen(sz),&dw,NULL);
-        //WriteFile(hConsoleOut,(CONST VOID *)"\r\n", 2,&dw,NULL);
         printf("%s\n",UnicodeToAnsi(wz));
     }
 }
@@ -156,12 +150,8 @@ static void ToGUIOrFile(_In_ __nullterminated const char* sz, void* GUICookie)
 void printError(void* GUICookie, _In_ __nullterminated const char* string)
 {
     {
-        //DWORD dw;
         const char* sz = ERRORMSG(string);
         if(GUICookie) printLine(GUICookie, sz);
-        //sz = UnicodeToAnsi(UtfToUnicode(string));
-        //WriteFile(hConsoleErr,(CONST VOID *)sz, (ULONG32)strlen(sz),&dw,NULL);
-        //WriteFile(hConsoleErr,(CONST VOID *)"\r\n", 2,&dw,NULL);
         fprintf(stderr,"%s\n",UnicodeToAnsi(UtfToUnicode(string)));
     }
 }