Merge pull request #624 from dsyme/integrate-779

Integrate visualfsharp/master --> fsharp/master

Author: dsyme

src/absil/il.fs

@@ -1643,13 +1643,13 @@ type ILAssemblyManifest =
       AssemblyLongevity: ILAssemblyLongevity; 
       DisableJitOptimizations: bool;
       JitTracking: bool;
+      IgnoreSymbolStoreSequencePoints: bool;
       Retargetable: bool;
 
       /// Records the types impemented by other modules. 
       ExportedTypes: ILExportedTypesAndForwarders;
       /// Records whether the entrypoint resides in another module. 
       EntrypointElsewhere: ILModuleRef option; 
-               
     } 
 
 type ILModuleDef = 
@@ -3059,9 +3059,10 @@ let mkILSimpleModule assname modname dll subsystemVersion useHighEntropyVA tdefs
                Locale=locale
                CustomAttrs=emptyILCustomAttrs;
                AssemblyLongevity=ILAssemblyLongevity.Unspecified;
-               DisableJitOptimizations= 0 <> (flags &&& 0x4000);
-               JitTracking=0 <> (flags &&& 0x8000); // always turn these on
-               Retargetable= 0 <> (flags &&& 0x100);
+               DisableJitOptimizations = 0 <> (flags &&& 0x4000);
+               JitTracking = (0 <> (flags &&& 0x8000)); // always turn these on
+               IgnoreSymbolStoreSequencePoints = (0 <> (flags &&& 0x2000));
+               Retargetable = (0 <> (flags &&& 0x100));
                ExportedTypes=exportedTypes;
                EntrypointElsewhere=None
              };
@@ -3544,13 +3545,14 @@ type ILGlobals with
 
     member this.mkDebuggableAttributeV2(jitTracking, ignoreSymbolStoreSequencePoints, jitOptimizerDisabled, enableEnC) =
         let tref = mkSystemDiagnosticsDebuggableTypeRef this
+        let debuggingMode = (if jitTracking then 1 else 0) |||
+                            (if jitOptimizerDisabled then 256 else 0) |||  
+                            (if ignoreSymbolStoreSequencePoints then 2 else 0) |||
+                            (if enableEnC then 4 else 0)
         mkILCustomAttribute this 
           (tref,[mkILNonGenericValueTy (tref_DebuggableAttribute_DebuggingModes this)],
            (* See System.Diagnostics.DebuggableAttribute.DebuggingModes *)
-           [ILAttribElem.Int32( (if jitTracking then 1 else 0) |||
-                                (if jitOptimizerDisabled then 256 else 0) |||  
-                                (if ignoreSymbolStoreSequencePoints then 2 else 0) |||
-                                (if enableEnC then 4 else 0))],[])
+           [ILAttribElem.Int32( debuggingMode )],[])
 
     member this.mkCompilerGeneratedAttribute () = mkILCustomAttribute this (tref_CompilerGeneratedAttribute this, [], [], [])
 

src/absil/il.fsi

@@ -1392,6 +1392,7 @@ type ILAssemblyManifest =
       AssemblyLongevity: ILAssemblyLongevity; 
       DisableJitOptimizations: bool;
       JitTracking: bool;
+      IgnoreSymbolStoreSequencePoints: bool;
       Retargetable: bool;
       /// Records the types impemented by this asssembly in auxiliary 
       /// modules. 

src/absil/ilread.fs

@@ -1586,8 +1586,9 @@ and seekReadAssemblyManifest ctxt idx =
       EntrypointElsewhere=(if fst ctxt.entryPointToken = TableNames.File then Some (seekReadFile ctxt (snd ctxt.entryPointToken)) else None)
       Retargetable = 0 <> (flags &&& 0x100)
       DisableJitOptimizations = 0 <> (flags &&& 0x4000)
-      JitTracking = 0 <> (flags &&& 0x8000) } 
-     
+      JitTracking = 0 <> (flags &&& 0x8000) 
+      IgnoreSymbolStoreSequencePoints = 0 <> (flags &&& 0x2000) } 
+
 and seekReadAssemblyRef ctxt idx = ctxt.seekReadAssemblyRef idx
 and seekReadAssemblyRefUncached ctxtH idx = 
     let ctxt = getHole ctxtH

src/absil/ilwrite.fs

@@ -2862,17 +2862,16 @@ and GetManifsetAsAssemblyRow cenv m =
           UShort (match m.Version with None -> 0us | Some (_,_,_,w) -> w)
           ULong 
             ( (match m.AssemblyLongevity with 
-              | ILAssemblyLongevity.Unspecified -> 0x0000
-              | ILAssemblyLongevity.Library -> 0x0002 
+              | ILAssemblyLongevity.Unspecified ->       0x0000
+              | ILAssemblyLongevity.Library ->           0x0002 
               | ILAssemblyLongevity.PlatformAppDomain -> 0x0004
-              | ILAssemblyLongevity.PlatformProcess -> 0x0006
-              | ILAssemblyLongevity.PlatformSystem -> 0x0008) |||
+              | ILAssemblyLongevity.PlatformProcess ->   0x0006
+              | ILAssemblyLongevity.PlatformSystem ->    0x0008) |||
               (if m.Retargetable then 0x100 else 0x0) |||
               // Setting these causes peverify errors. Hence both ilread and ilwrite ignore them and refuse to set them.
               // Any debugging customattributes will automatically propagate
-              // REVIEW: No longer appears to be the case...
-              (if m.JitTracking then 0x8000 else 0x0) ||| 
-              (if m.DisableJitOptimizations then 0x4000 else 0x0) ||| 
+              // REVIEW: No longer appears to be the case
+              (if m.JitTracking then                     0x8000 else 0x0) ||| 
               (match m.PublicKey with None -> 0x0000 | Some _ -> 0x0001) ||| 0x0000)
           (match m.PublicKey with None -> Blob 0 | Some x -> Blob (GetBytesAsBlobIdx cenv x))
           StringE (GetStringHeapIdx cenv m.Name)

src/absil/ilwritepdb.fs

@@ -275,7 +275,7 @@ let generatePortablePdb fixupSPs showTimes (info:PdbData) =
 
     let mutable lastLocalVariableHandle = Unchecked.defaultof<LocalVariableHandle>
     metadata.SetCapacity(TableIndex.MethodDebugInformation, info.Methods.Length)
-    info.Methods |> Array.iteri (fun _i minfo ->
+    info.Methods |> Array.iter (fun minfo ->
         let docHandle, sequencePointBlob =
             let sps =
                 match minfo.SequencePoints with
@@ -284,107 +284,122 @@ let generatePortablePdb fixupSPs showTimes (info:PdbData) =
                     match minfo.Range with
                     | None -> Array.empty<PdbSequencePoint>
                     | Some (_,_) -> minfo.SequencePoints
- 
-            let getDocumentHandle d = 
-                if docs.Length = 0 || d < 0 || d > docs.Length then 
+
+            let getDocumentHandle d =
+                if docs.Length = 0 || d < 0 || d > docs.Length then
                     Unchecked.defaultof<DocumentHandle>
                 else 
                     match documentIndex.TryGetValue(docs.[d].File) with
                     | false, _ -> Unchecked.defaultof<DocumentHandle>
                     | true, f  -> f
 
-            // Return a document that the entire method body is declared within.
-            // If part of the method body is in another document returns nil handle.
-            let tryGetSingleDocumentIndex =
-                let mutable singleDocumentIndex = 0
-                for i in 0 .. sps.Length - 1 do
-                    let index = sps.[i].Document
-                    if index <> singleDocumentIndex then 
-                        singleDocumentIndex <- index
-                singleDocumentIndex
-
-            // Filter out feefee (Hidden) sequence points
-            let sps = sps |> Array.filter(fun sp -> sp.Line <> 0xfeefee && sp.EndLine <> 0xfeefee)
-
             if sps.Length = 0 then
                 Unchecked.defaultof<DocumentHandle>, Unchecked.defaultof<BlobHandle>
             else
-                let mutable previousNonHiddenStartLine = -1
-                let mutable previousNonHiddenStartColumn = -1
-                let mutable previousDocumentIndex = -1
-                let mutable singleDocumentIndex = tryGetSingleDocumentIndex
-                let mutable currentDocumentIndex = previousDocumentIndex
+                // Return a document that the entire method body is declared within.
+                // If part of the method body is in another document returns nil handle.
+                let tryGetSingleDocumentIndex =
+                    let mutable singleDocumentIndex = sps.[0].Document
+                    for i in 1 .. sps.Length - 1 do
+                        if sps.[i].Document <> singleDocumentIndex then
+                            singleDocumentIndex <- -1
+                    singleDocumentIndex
 
                 let builder = new BlobBuilder()
+
                 builder.WriteCompressedInteger(minfo.LocalSignatureToken)
 
-                for i in 0 .. (sps.Length - 1) do
-                    if previousDocumentIndex <> currentDocumentIndex then
-                        // optional document in header or document record:
-                        if previousDocumentIndex <> -1   then
-                            // optional document in header or document record
-                            builder.WriteCompressedInteger(0)
-                        builder.WriteCompressedInteger(currentDocumentIndex)
-                        previousDocumentIndex <- currentDocumentIndex
-
-                    // delta IL offset:
-                    if i > 0 then 
-                        builder.WriteCompressedInteger(sps.[i].Offset - sps.[i - 1].Offset)
-                    else
-                        builder.WriteCompressedInteger(sps.[i].Offset)
+                // Initial document:  When sp's spread over more than one document we put the initial document here.
+                let singleDocumentIndex = tryGetSingleDocumentIndex
 
-                    let deltaLines = sps.[i].EndLine - sps.[i].Line
-                    let deltaColumns = sps.[i].EndColumn - sps.[i].Column
-                    builder.WriteCompressedInteger(deltaLines)
+                if singleDocumentIndex = -1 then
+                    builder.WriteCompressedInteger( MetadataTokens.GetRowNumber(DocumentHandle.op_Implicit(getDocumentHandle (sps.[0].Document))) )
 
-                    if deltaLines = 0 then 
-                        builder.WriteCompressedInteger(deltaColumns)
-                    else
-                        builder.WriteCompressedSignedInteger(deltaColumns)
+                let mutable previousNonHiddenStartLine = -1
+                let mutable previousNonHiddenStartColumn = 0
 
-                    // delta Start Lines & Columns:
-                    if previousNonHiddenStartLine < 0 then
-                        builder.WriteCompressedInteger(sps.[i].Line)
-                        builder.WriteCompressedInteger(sps.[i].Column)
-                    else
-                        builder.WriteCompressedSignedInteger(sps.[i].Line - previousNonHiddenStartLine)
-                        builder.WriteCompressedSignedInteger(sps.[i].Column - previousNonHiddenStartColumn)
+                for i in 0 .. (sps.Length - 1) do
 
-                    previousNonHiddenStartLine <- sps.[i].Line
-                    previousNonHiddenStartColumn <- sps.[i].Column
+                    if singleDocumentIndex <> -1 && sps.[i].Document <> singleDocumentIndex then
+                        builder.WriteCompressedInteger( 0 )
+                        builder.WriteCompressedInteger( MetadataTokens.GetRowNumber(DocumentHandle.op_Implicit(getDocumentHandle (sps.[i].Document))) )
+                    else
+                        // Sequence-point-record
+                        let offsetDelta =
+                            if i > 0 then sps.[i].Offset - sps.[i - 1].Offset                           // delta from previous offset
+                            else sps.[i].Offset                                                         // delta IL offset
+
+                        if i < 1 || offsetDelta <> 0 then                                               // ILOffset must not be 0
+                            builder.WriteCompressedInteger(offsetDelta)
+
+                            if sps.[i].Line = 0xfeefee && sps.[i].EndLine = 0xfeefee then               // Hidden-sequence-point-record
+                                builder.WriteCompressedInteger(0)
+                                builder.WriteCompressedInteger(0)
+                            else                                                                        // Non-hidden-sequence-point-record
+                                let deltaLines = sps.[i].EndLine - sps.[i].Line                         // lines
+                                builder.WriteCompressedInteger(deltaLines)
+
+                                let deltaColumns = sps.[i].EndColumn - sps.[i].Column                   // Columns
+                                if deltaLines = 0 then
+                                    builder.WriteCompressedInteger(deltaColumns)
+                                else
+                                    builder.WriteCompressedSignedInteger(deltaColumns)
+
+                                if previousNonHiddenStartLine < 0 then                                  // delta Start Line & Column:
+                                    builder.WriteCompressedInteger(sps.[i].Line)
+                                    builder.WriteCompressedInteger(sps.[i].Column)
+                                else
+                                    builder.WriteCompressedSignedInteger(sps.[i].Line - previousNonHiddenStartLine)
+                                    builder.WriteCompressedSignedInteger(sps.[i].Column - previousNonHiddenStartColumn)
+
+                                previousNonHiddenStartLine <- sps.[i].Line
+                                previousNonHiddenStartColumn <- sps.[i].Column
 
                 getDocumentHandle singleDocumentIndex, metadata.GetOrAddBlob(builder)
 
+        metadata.AddMethodDebugInformation(docHandle, sequencePointBlob) |> ignore
+
         // Write the scopes
         let nextHandle handle = MetadataTokens.LocalVariableHandle(MetadataTokens.GetRowNumber(LocalVariableHandle.op_Implicit(handle)) + 1)
-        let rec writePdbScope scope =   
-            if scope.Children.Length = 0 then
-                metadata.AddLocalScope(MetadataTokens.MethodDefinitionHandle(minfo.MethToken), 
-                                       Unchecked.defaultof<ImportScopeHandle>, 
-                                       nextHandle lastLocalVariableHandle, 
-                                       Unchecked.defaultof<LocalConstantHandle>, 
-                                       0, 
-                                       scope.EndOffset - scope.StartOffset) |>ignore
-            else
-                metadata.AddLocalScope(MetadataTokens.MethodDefinitionHandle(minfo.MethToken), 
-                                       Unchecked.defaultof<ImportScopeHandle>, 
-                                       nextHandle lastLocalVariableHandle, 
-                                       Unchecked.defaultof<LocalConstantHandle>, 
-                                       scope.StartOffset, 
-                                       scope.EndOffset - scope.StartOffset) |>ignore
-
-                for localVariable in scope.Locals do
-                    lastLocalVariableHandle <- metadata.AddLocalVariable(LocalVariableAttributes.None, localVariable.Index, metadata.GetOrAddString(localVariable.Name))
-
-                scope.Children |> Array.iter (writePdbScope)
-
-        writePdbScope minfo.RootScope
-        metadata.AddMethodDebugInformation(docHandle, sequencePointBlob) |> ignore)
+        let writeMethodScope scope =
+            let scopeSorter (scope1:PdbMethodScope) (scope2:PdbMethodScope) =
+                if scope1.StartOffset > scope2.StartOffset then 1
+                elif scope1.StartOffset < scope2.StartOffset then -1
+                elif (scope1.EndOffset - scope1.StartOffset) > (scope2.EndOffset - scope2.StartOffset) then -1
+                elif (scope1.EndOffset - scope1.StartOffset) < (scope2.EndOffset - scope2.StartOffset) then 1
+                else 0
+
+            let collectScopes scope =
+                let list = new List<PdbMethodScope>()
+                let rec toList scope =
+                    list.Add scope
+                    scope.Children |> Seq.iter(fun s -> toList s)
+                toList scope
+                list.ToArray() |> Array.sortWith<PdbMethodScope> scopeSorter
+
+            collectScopes scope |> Seq.iter(fun s ->
+                                    if s.Children.Length = 0 then
+                                        metadata.AddLocalScope(MetadataTokens.MethodDefinitionHandle(minfo.MethToken),
+                                                               Unchecked.defaultof<ImportScopeHandle>,
+                                                               nextHandle lastLocalVariableHandle,
+                                                               Unchecked.defaultof<LocalConstantHandle>,
+                                                               0, s.EndOffset - s.StartOffset ) |>ignore
+                                    else
+                                        metadata.AddLocalScope(MetadataTokens.MethodDefinitionHandle(minfo.MethToken),
+                                                               Unchecked.defaultof<ImportScopeHandle>,
+                                                               nextHandle lastLocalVariableHandle,
+                                                               Unchecked.defaultof<LocalConstantHandle>,
+                                                               s.StartOffset, s.EndOffset - s.StartOffset) |>ignore
+
+                                    for localVariable in s.Locals do
+                                        lastLocalVariableHandle <- metadata.AddLocalVariable(LocalVariableAttributes.None, localVariable.Index, metadata.GetOrAddString(localVariable.Name))
+                                    )
+        writeMethodScope minfo.RootScope )
 
     let entryPoint =
-        match info.EntryPoint with 
+        match info.EntryPoint with
         | None -> MetadataTokens.MethodDefinitionHandle(0)
-        | Some x -> MetadataTokens.MethodDefinitionHandle(x) 
+        | Some x -> MetadataTokens.MethodDefinitionHandle(x)
 
     let serializer = PortablePdbBuilder(metadata, externalRowCounts, entryPoint, null)
     let blobBuilder = new BlobBuilder()