Portable PDB support for ilasm

src/coreclr/src/ilasm/CMakeLists.txt

@@ -4,6 +4,7 @@ add_definitions(-DUNICODE)
 add_definitions(-D_UNICODE)
 add_definitions(-D_FEATURE_NO_HOST)
 add_definitions(-D__ILASM__)
+add_definitions(-DFEATURE_METADATA_EMIT_PORTABLE_PDB)
 
 add_definitions(-DFEATURE_CORECLR)
 
@@ -18,6 +19,7 @@ set(ILASM_SOURCES
   main.cpp
   assembler.cpp
   prebuilt/asmparse.cpp
+  portable_pdb.cpp
 )
 
 set(ILASM_HEADERS
@@ -32,6 +34,7 @@ set(ILASM_HEADERS
   method.hpp
   nvpair.h
   typar.hpp
+  portable_pdb.h
 )
 
 if(CLR_CMAKE_TARGET_WIN32)
@@ -72,11 +75,11 @@ set(ILASM_LINK_LIBRARIES
   utilcodestaticnohost
   mscorpe
   ${START_LIBRARY_GROUP} # Start group of libraries that have circular references
-  mdhotdata_full
-  mdcompiler_wks
-  mdruntime_wks
-  mdruntimerw_wks
-  mdstaticapi
+  mdhotdata_ppdb
+  mdcompiler_ppdb
+  mdruntime_ppdb
+  mdruntimerw_ppdb
+  mdstaticapi_ppdb
   ${END_LIBRARY_GROUP} # End group of libraries that have circular references
   ceefgen
   corguids

src/coreclr/src/ilasm/assem.cpp

@@ -157,6 +157,9 @@ Assembler::Assembler()
 
     dummyClass = new Class(NULL);
     indexKeywords(&indxKeywords);
+
+    m_pdbFormat = CLASSIC;
+    m_pPortablePdbWriter = NULL;
 }
 
 
@@ -218,7 +221,11 @@ Assembler::~Assembler()
         m_pEmitter->Release();
         m_pEmitter = NULL;
     }
-
+    if (m_pPortablePdbWriter != NULL)
+    {
+        delete m_pPortablePdbWriter;
+        m_pPortablePdbWriter = NULL;
+    }
     if (m_pDisp != NULL)
     {
         m_pDisp->Release();
@@ -227,7 +234,7 @@ Assembler::~Assembler()
 }
 
 
-BOOL Assembler::Init()
+BOOL Assembler::Init(BOOL generatePdb, PdbFormat pdbFormat)
 {
     if (m_pCeeFileGen != NULL) {
         if (m_pCeeFile)
@@ -246,6 +253,9 @@ BOOL Assembler::Init()
     if (FAILED(m_pCeeFileGen->GetSectionCreate (m_pCeeFile, ".sdata", sdReadWrite, &m_pGlobalDataSection))) return FALSE;
     if (FAILED(m_pCeeFileGen->GetSectionCreate (m_pCeeFile, ".tls", sdReadWrite, &m_pTLSSection))) return FALSE;
 
+    m_fGeneratePDB = generatePdb;
+    m_pdbFormat = pdbFormat;
+
     return TRUE;
 }
 
@@ -468,6 +478,8 @@ BOOL Assembler::AddMethod(Method *pMethod)
 
 BOOL Assembler::EmitMethodBody(Method* pMethod, BinStr* pbsOut)
 {
+    HRESULT hr = S_OK;
+
     if(pMethod)
     {
         BinStr* pbsBody = pMethod->m_pbsBody;
@@ -483,7 +495,6 @@ BOOL Assembler::EmitMethodBody(Method* pMethod, BinStr* pbsOut)
                 VarDescr* pVD;
                 BinStr*   pbsSig = new BinStr();
                 unsigned cnt;
-                HRESULT hr;
                 DWORD   cSig;
                 const COR_SIGNATURE* mySig;
 
@@ -514,57 +525,67 @@ BOOL Assembler::EmitMethodBody(Method* pMethod, BinStr* pbsOut)
                 pFH->SetLocalVarSigTok(pMethod->m_LocalsSig);
             }
             //--------------------------------------------------------------------------------
-            if(m_fGeneratePDB && (m_pSymWriter != NULL))
+            if(m_fGeneratePDB)
             {
-                m_pSymWriter->OpenMethod(pMethod->m_Tok);
-                ULONG N = pMethod->m_LinePCList.COUNT();
-                if(pMethod->m_fEntryPoint) m_pSymWriter->SetUserEntryPoint(pMethod->m_Tok);
-                if(N)
+                if (m_pSymWriter != NULL)
                 {
-                    LinePC  *pLPC;
-                    ULONG32  *offsets=new ULONG32[N], *lines = new ULONG32[N], *columns = new ULONG32[N];
-                    ULONG32  *endlines=new ULONG32[N], *endcolumns=new ULONG32[N];
-                    if(offsets && lines && columns && endlines && endcolumns)
+                    m_pSymWriter->OpenMethod(pMethod->m_Tok);
+                    ULONG N = pMethod->m_LinePCList.COUNT();
+                    if(pMethod->m_fEntryPoint) m_pSymWriter->SetUserEntryPoint(pMethod->m_Tok);
+                    if(N)
                     {
-                        DocWriter* pDW;
-                        unsigned j=0;
-                        while((pDW = m_DocWriterList.PEEK(j++)))
+                        LinePC  *pLPC;
+                        ULONG32  *offsets=new ULONG32[N], *lines = new ULONG32[N], *columns = new ULONG32[N];
+                        ULONG32  *endlines=new ULONG32[N], *endcolumns=new ULONG32[N];
+                        if(offsets && lines && columns && endlines && endcolumns)
                         {
-                            if((m_pSymDocument = pDW->pWriter))
+                            DocWriter* pDW;
+                            unsigned j=0;
+                            while((pDW = m_DocWriterList.PEEK(j++)))
                             {
-                                int i, n;
-                                for(i=0, n=0; (pLPC = pMethod->m_LinePCList.PEEK(i)); i++)
+                                if((m_pSymDocument = pDW->pWriter))
                                 {
-                                    if(pLPC->pWriter == m_pSymDocument)
+                                    int i, n;
+                                    for(i=0, n=0; (pLPC = pMethod->m_LinePCList.PEEK(i)); i++)
                                     {
-                                        offsets[n] = pLPC->PC;
-                                        lines[n] = pLPC->Line;
-                                        columns[n] = pLPC->Column;
-                                        endlines[n] = pLPC->LineEnd;
-                                        endcolumns[n] = pLPC->ColumnEnd;
-                                        n++;
+                                        if(pLPC->pWriter == m_pSymDocument)
+                                        {
+                                            offsets[n] = pLPC->PC;
+                                            lines[n] = pLPC->Line;
+                                            columns[n] = pLPC->Column;
+                                            endlines[n] = pLPC->LineEnd;
+                                            endcolumns[n] = pLPC->ColumnEnd;
+                                            n++;
+                                        }
                                     }
-                                }
-                                if(n) m_pSymWriter->DefineSequencePoints(m_pSymDocument,n,
-                                                                   offsets,lines,columns,endlines,endcolumns);
-                            } // end if(pSymDocument)
-                        } // end while(pDW = next doc.writer)
-                        pMethod->m_LinePCList.RESET(true);
-                    }
-                    else report->error("\nOutOfMemory!\n");
-                    delete [] offsets;
-                    delete [] lines;
-                    delete [] columns;
-                    delete [] endlines;
-                    delete [] endcolumns;
-                }//enf if(N)
-                HRESULT hrr;
-                if(pMethod->m_ulLines[1])
-                    hrr = m_pSymWriter->SetMethodSourceRange(m_pSymDocument,pMethod->m_ulLines[0], pMethod->m_ulColumns[0],
-                                                       m_pSymDocument,pMethod->m_ulLines[1], pMethod->m_ulColumns[1]);
-                EmitScope(&(pMethod->m_MainScope)); // recursively emits all nested scopes
-
-                m_pSymWriter->CloseMethod();
+                                    if(n) m_pSymWriter->DefineSequencePoints(m_pSymDocument,n,
+                                                                       offsets,lines,columns,endlines,endcolumns);
+                                } // end if(pSymDocument)
+                            } // end while(pDW = next doc.writer)
+                            pMethod->m_LinePCList.RESET(true);
+                        }
+                        else report->error("\nOutOfMemory!\n");
+                        delete [] offsets;
+                        delete [] lines;
+                        delete [] columns;
+                        delete [] endlines;
+                        delete [] endcolumns;
+                    }//enf if(N)
+                    HRESULT hrr;
+                    if(pMethod->m_ulLines[1])
+                        hrr = m_pSymWriter->SetMethodSourceRange(m_pSymDocument,pMethod->m_ulLines[0], pMethod->m_ulColumns[0],
+                                                           m_pSymDocument,pMethod->m_ulLines[1], pMethod->m_ulColumns[1]);
+                    EmitScope(&(pMethod->m_MainScope)); // recursively emits all nested scopes
+
+                    m_pSymWriter->CloseMethod();
+                }
+                else if (IsPortablePdb())
+                {
+                    if (FAILED(m_pPortablePdbWriter->DefineSequencePoints(pMethod)))
+                        return FALSE;
+                    if (FAILED(m_pPortablePdbWriter->DefineLocalScope(pMethod)))
+                        return FALSE;
+                }
             } // end if(fIncludeDebugInfo)
             //-----------------------------------------------------
 

src/coreclr/src/ilasm/assembler.cpp

@@ -1418,6 +1418,20 @@ void Assembler::EmitOpcode(Instr* instr)
                 pLPC->ColumnEnd = instr->column_end;
                 pLPC->PC = m_CurPC;
                 pLPC->pWriter = instr->pWriter;
+
+                pLPC->pOwnerDocument = instr->pOwnerDocument;
+                if (0xfeefee == instr->linenum &&
+                    0xfeefee == instr->linenum_end &&
+                    0 == instr->column &&
+                    0 == instr->column_end)
+                {
+                    pLPC->IsHidden = TRUE;
+                }
+                else
+                {
+                    pLPC->IsHidden = FALSE;
+                }
+
                 m_pCurMethod->m_LinePCList.PUSH(pLPC);
             }
             else report->error("\nOut of memory!\n");
@@ -2375,40 +2389,51 @@ void Assembler::SetSourceFileName(__in __nullterminated char* szName)
             }
             if(m_fGeneratePDB)
             {
-                DocWriter* pDW;
-                unsigned i=0;
-                while((pDW = m_DocWriterList.PEEK(i++)) != NULL)
-                {
-                    if(!strcmp(szName,pDW->Name)) break;
-                }
-                if(pDW)
+                if (IsPortablePdb())
                 {
-                     m_pSymDocument = pDW->pWriter;
-                     delete [] szName;
+                    if (FAILED(m_pPortablePdbWriter->DefineDocument(szName, &m_guidLang)))
+                    {
+                        report->error("Failed to define a document: '%s'", szName);
+                    }
+                    delete[] szName;
                 }
-                else if(m_pSymWriter)
+                else
                 {
-                    HRESULT hr;
-                    WszMultiByteToWideChar(g_uCodePage,0,szName,-1,wzUniBuf,dwUniBuf);
-                    if(FAILED(hr=m_pSymWriter->DefineDocument(wzUniBuf,&m_guidLang,
-                        &m_guidLangVendor,&m_guidDoc,&m_pSymDocument)))
+                    DocWriter* pDW;
+                    unsigned i = 0;
+                    while ((pDW = m_DocWriterList.PEEK(i++)) != NULL)
                     {
-                        m_pSymDocument = NULL;
-                        report->error("Failed to define a document writer");
+                        if (!strcmp(szName, pDW->Name)) break;
                     }
-                    if((pDW = new DocWriter()) != NULL)
+                    if (pDW)
                     {
-                        pDW->Name = szName;
-                        pDW->pWriter = m_pSymDocument;
-                        m_DocWriterList.PUSH(pDW);
+                        m_pSymDocument = pDW->pWriter;
+                        delete[] szName;
                     }
-                    else
+                    else if (m_pSymWriter)
                     {
-                        report->error("Out of memory");
-                        delete [] szName;
+                        HRESULT hr;
+                        WszMultiByteToWideChar(g_uCodePage, 0, szName, -1, wzUniBuf, dwUniBuf);
+                        if (FAILED(hr = m_pSymWriter->DefineDocument(wzUniBuf, &m_guidLang,
+                            &m_guidLangVendor, &m_guidDoc, &m_pSymDocument)))
+                        {
+                            m_pSymDocument = NULL;
+                            report->error("Failed to define a document writer");
+                        }
+                        if ((pDW = new DocWriter()) != NULL)
+                        {
+                            pDW->Name = szName;
+                            pDW->pWriter = m_pSymDocument;
+                            m_DocWriterList.PUSH(pDW);
+                        }
+                        else
+                        {
+                            report->error("Out of memory");
+                            delete[] szName;
+                        }
                     }
+                    else delete[] szName;
                 }
-                else delete [] szName;
             }
             else delete [] szName;
         }
@@ -2428,6 +2453,39 @@ void Assembler::SetSourceFileName(BinStr* pbsName)
     }
 }
 
+// Portable PDB paraphernalia
+void Assembler::SetPdbFileName(__in __nullterminated char* szName)
+{
+    if (szName)
+    {
+        if (*szName)
+        {
+            strcpy_s(m_szPdbFileName, MAX_FILENAME_LENGTH * 3 + 1, szName);
+            WszMultiByteToWideChar(g_uCodePage, 0, szName, -1, m_wzPdbFileName, MAX_FILENAME_LENGTH);
+        }
+    }
+}
+HRESULT Assembler::SavePdbFile()
+{
+    HRESULT hr = S_OK;
+    mdMethodDef entryPoint;
+
+    if (m_pdbFormat == PORTABLE)
+    {
+        if (FAILED(hr = (m_pPortablePdbWriter == NULL ? E_FAIL : S_OK))) goto exit;
+        if (FAILED(hr = (m_pPortablePdbWriter->GetEmitter() == NULL ? E_FAIL : S_OK))) goto exit;
+        if (FAILED(hr = m_pCeeFileGen->GetEntryPoint(m_pCeeFile, &entryPoint))) goto exit;
+        if (FAILED(hr = m_pPortablePdbWriter->BuildPdbStream(m_pEmitter, entryPoint))) goto exit;
+        if (FAILED(hr = m_pPortablePdbWriter->GetEmitter()->Save(m_wzPdbFileName, NULL))) goto exit;
+    }
+exit:
+    return hr;
+}
+BOOL Assembler::IsPortablePdb()
+{
+    return (m_pdbFormat == PORTABLE) && (m_pPortablePdbWriter != NULL);
+}
+
 void Assembler::RecordTypeConstraints(GenericParamConstraintList* pGPCList, int numTyPars, TyParDescr* tyPars)
 {
     if (numTyPars > 0)