Implement MethodImplOptions.AggressiveInlining flag - fixes #1637

src/absil/il.fs

@@ -1072,6 +1072,7 @@ type ILMethodBody =
     { IsZeroInit: bool;
       MaxStack: int32;
       NoInlining: bool;
+      AggressiveInlining: bool;
       Locals: ILLocals;
       Code:  ILCode;
       SourceMarker: ILSourceMarker option }
@@ -1371,6 +1372,7 @@ type ILMethodDef =
       IsPreserveSig: bool;
       IsMustRun: bool;
       IsNoInline: bool;
+      IsAggressiveInline : bool
       GenericParams: ILGenericParameterDefs;
       CustomAttrs: ILAttributes; }
     member x.ParameterTypes = typesOfILParams x.Parameters
@@ -2276,6 +2278,7 @@ let mkILMethodBody (zeroinit,locals,maxstack,code,tag) : ILMethodBody =
   { IsZeroInit=zeroinit
     MaxStack=maxstack
     NoInlining=false
+    AggressiveInlining=false
     Locals= locals 
     Code= code
     SourceMarker=tag }
@@ -2311,6 +2314,7 @@ let mkILCtor (access,args,impl) =
       IsUnmanagedExport=false;
       IsSynchronized=false;
       IsNoInline=false;
+      IsAggressiveInline=false
       IsMustRun=false;
       IsPreserveSig=false;
       CustomAttrs = emptyILCustomAttrs; }
@@ -2364,6 +2368,7 @@ let mkILStaticMethod (genparams,nm,access,args,ret,impl) =
       IsUnmanagedExport=false;
       IsSynchronized=false;
       IsNoInline=false;
+      IsAggressiveInline=false;
       IsMustRun=false;
       IsPreserveSig=false; }
 
@@ -2393,6 +2398,7 @@ let mkILClassCtor impl =
       IsUnmanagedExport=false; 
       IsSynchronized=false;
       IsNoInline=false;
+      IsAggressiveInline=false
       IsMustRun=false;
       IsPreserveSig=false;  } 
 
@@ -2433,6 +2439,7 @@ let mkILGenericVirtualMethod (nm,access,genparams,actual_args,actual_ret,impl) =
     IsUnmanagedExport=false; 
     IsSynchronized=false;
     IsNoInline=false;
+    IsAggressiveInline=false
     IsMustRun=false;
     IsPreserveSig=false; }
 
@@ -2462,6 +2469,7 @@ let mkILGenericNonVirtualMethod (nm,access,genparams, actual_args,actual_ret, im
     IsUnmanagedExport=false; 
     IsSynchronized=false;
     IsNoInline=false;
+    IsAggressiveInline=false
     IsMustRun=false;
     IsPreserveSig=false; }
 

src/absil/il.fsi

@@ -803,9 +803,10 @@ type ILLocals = list<ILLocal>
 [<RequireQualifiedAccess; NoComparison; NoEquality>]
 type ILMethodBody = 
     { IsZeroInit: bool;
-      /// strictly speakin should be a uint16 
+      /// strictly speaking should be a uint16 
       MaxStack: int32; 
       NoInlining: bool;
+      AggressiveInlining: bool;
       Locals: ILLocals;
       Code: ILCode;
       SourceMarker: ILSourceMarker option }
@@ -1052,6 +1053,7 @@ type ILMethodDef =
       /// .NET 2.0 feature: SafeHandle finalizer must be run.
       IsMustRun: bool; 
       IsNoInline: bool;
+      IsAggressiveInline: bool;
 
       GenericParams: ILGenericParameterDefs;
       CustomAttrs: ILAttributes; }

src/absil/ilprint.fs

@@ -846,10 +846,11 @@ let goutput_mdef env os md =
   output_string os " ";
   (goutput_params menv) os md.Parameters;
   output_string os " ";
-  if md.IsSynchronized then output_string os "synchronized ";
-  if md.IsMustRun then output_string os "/* mustrun */ ";
-  if md.IsPreserveSig then output_string os "preservesig ";
-  if md.IsNoInline then output_string os "noinlining ";
+  if md.IsSynchronized then output_string os "synchronized "
+  if md.IsMustRun then output_string os "/* mustrun */ "
+  if md.IsPreserveSig then output_string os "preservesig "
+  if md.IsNoInline then output_string os "noinlining "
+  if md.IsAggressiveInline then output_string os "aggressiveinlining "
   (goutput_mbody is_entrypoint menv) os md;
   output_string os "\n"
 

src/absil/ilread.fs

@@ -2301,6 +2301,7 @@ and seekReadMethod ctxt numtypars (idx:int) =
      let internalcall = (implflags &&& 0x1000) <> 0x0
      let synchronized = (implflags &&& 0x0020) <> 0x0
      let noinline = (implflags &&& 0x0008) <> 0x0
+     let aggressiveinline = (implflags &&& 0x0100) <> 0x0
      let mustrun = (implflags &&& 0x0040) <> 0x0
      let cctor = (nm = ".cctor")
      let ctor = (nm = ".ctor")
@@ -2338,6 +2339,7 @@ and seekReadMethod ctxt numtypars (idx:int) =
        IsUnmanagedExport=export
        IsSynchronized=synchronized
        IsNoInline=noinline
+       IsAggressiveInline=aggressiveinline
        IsMustRun=mustrun
        IsPreserveSig=preservesig
        IsManaged = not unmanaged
@@ -2358,7 +2360,7 @@ and seekReadMethod ctxt numtypars (idx:int) =
            //if codeRVA <> 0x0 then dprintn "non-IL or abstract method with non-zero RVA"
            mkMethBodyLazyAux (notlazy MethodBody.Abstract)  
          else 
-           seekReadMethodRVA ctxt (idx,nm,internalcall,noinline,numtypars) codeRVA   
+           seekReadMethodRVA ctxt (idx,nm,internalcall,noinline,aggressiveinline,numtypars) codeRVA   
      }
 
 
@@ -2877,9 +2879,9 @@ and seekReadTopCode ctxt numtypars (sz:int) start seqpoints =
    instrs,rawToLabel, lab2pc, raw2nextLab
 
 #if FX_NO_PDB_READER
-and seekReadMethodRVA ctxt (_idx,nm,_internalcall,noinline,numtypars) rva = 
+and seekReadMethodRVA ctxt (_idx,nm,_internalcall,noinline,aggressiveinline,numtypars) rva = 
 #else
-and seekReadMethodRVA ctxt (idx,nm,_internalcall,noinline,numtypars) rva = 
+and seekReadMethodRVA ctxt (idx,nm,_internalcall,noinline,aggressiveinline,numtypars) rva = 
 #endif
   mkMethBodyLazyAux 
    (lazy
@@ -2965,6 +2967,7 @@ and seekReadMethodRVA ctxt (idx,nm,_internalcall,noinline,numtypars) rva =
              { IsZeroInit=false
                MaxStack= 8
                NoInlining=noinline
+               AggressiveInlining=aggressiveinline
                Locals=List.empty
                SourceMarker=methRangePdbInfo 
                Code=code }
@@ -3090,6 +3093,7 @@ and seekReadMethodRVA ctxt (idx,nm,_internalcall,noinline,numtypars) rva =
              { IsZeroInit=initlocals
                MaxStack= maxstack
                NoInlining=noinline
+               AggressiveInlining=aggressiveinline
                Locals = locals
                Code=code
                SourceMarker=methRangePdbInfo}

src/absil/ilreflect.fs

@@ -1466,6 +1466,7 @@ let convMethodImplFlags mdef =
     ||| flagsIf mdef.IsPreserveSig MethodImplAttributes.PreserveSig
     ||| flagsIf mdef.IsSynchronized MethodImplAttributes.Synchronized
     ||| flagsIf (match mdef.mdBody.Contents with MethodBody.IL b -> b.NoInlining | _ -> false) MethodImplAttributes.NoInlining
+    ||| flagsIf (match mdef.mdBody.Contents with MethodBody.IL b -> b.AggressiveInlining | _ -> false) MethodImplAttributes.AggressiveInlining
 
 //----------------------------------------------------------------------------
 // buildMethodPass2

src/absil/ilwrite.fs

@@ -2537,6 +2537,7 @@ let GenMethodDefAsRow cenv env midx (md: ILMethodDef) =
           | _ -> false) then 0x1000 else 0x0) ||| // RTSpecialName 
         (if md.IsReqSecObj then 0x8000 else 0x0) |||
         (if md.HasSecurity || not md.SecurityDecls.AsList.IsEmpty then 0x4000 else 0x0)
+
     let implflags = 
         (match  md.mdCodeKind with 
          | MethodCodeKind.Native -> 0x0001
@@ -2548,7 +2549,8 @@ let GenMethodDefAsRow cenv env midx (md: ILMethodDef) =
         (if md.IsPreserveSig then 0x0080 else 0x0000) |||
         (if md.IsSynchronized then 0x0020 else 0x0000) |||
         (if md.IsMustRun then 0x0040 else 0x0000) |||
-        (if (md.IsNoInline || (match md.mdBody.Contents with MethodBody.IL il -> il.NoInlining | _ -> false)) then 0x0008 else 0x0000)
+        (if (md.IsNoInline || (match md.mdBody.Contents with MethodBody.IL il -> il.NoInlining | _ -> false)) then 0x0008 else 0x0000) |||
+        (if (md.IsAggressiveInline || (match md.mdBody.Contents with MethodBody.IL il -> il.AggressiveInlining | _ -> false)) then 0x0100 else 0x0000)
 
     if md.IsEntryPoint then 
         if cenv.entrypoint <> None then failwith "duplicate entrypoint"

src/fsharp/IlxGen.fs

@@ -5061,13 +5061,16 @@ and ComputeMethodImplAttribs cenv (_v:Val) attrs =
     // 0x80 - hasPreserveSigImplFlag
     // 0x20 - synchronize
     // (See ECMA 335, Partition II, section 23.1.11 - Flags for methods [MethodImplAttributes]) 
-    let attrs = attrs 
-                    |> List.filter (IsMatchingFSharpAttribute cenv.g cenv.g.attrib_MethodImplAttribute >> not) 
-                        |> List.filter (IsMatchingFSharpAttributeOpt cenv.g cenv.g.attrib_PreserveSigAttribute >> not)
+    let attrs = 
+        attrs 
+        |> List.filter (IsMatchingFSharpAttribute cenv.g cenv.g.attrib_MethodImplAttribute >> not) 
+        |> List.filter (IsMatchingFSharpAttributeOpt cenv.g cenv.g.attrib_PreserveSigAttribute >> not)
+
     let hasPreserveSigImplFlag = ((implflags &&& 0x80) <> 0x0) || hasPreserveSigAttr
     let hasSynchronizedImplFlag = (implflags &&& 0x20) <> 0x0
     let hasNoInliningImplFlag = (implflags &&& 0x08) <> 0x0
-    hasPreserveSigImplFlag, hasSynchronizedImplFlag, hasNoInliningImplFlag, attrs
+    let hasAggressiveInliningImplFlag = (implflags &&& 0x0100) <> 0x0
+    hasPreserveSigImplFlag, hasSynchronizedImplFlag, hasNoInliningImplFlag, hasAggressiveInliningImplFlag, attrs
 
 and GenMethodForBinding 
         cenv cgbuf eenv 
@@ -5152,7 +5155,7 @@ and GenMethodForBinding
         | _ -> [],None
 
     // check if the hasPreserveSigNamedArg and hasSynchronizedImplFlag implementation flags have been specified
-    let hasPreserveSigImplFlag, hasSynchronizedImplFlag, hasNoInliningFlag, attrs = ComputeMethodImplAttribs cenv v attrs
+    let hasPreserveSigImplFlag, hasSynchronizedImplFlag, hasNoInliningFlag, hasAggressiveInliningImplFlag, attrs = ComputeMethodImplAttribs cenv v attrs
 
     let securityAttributes,attrs = attrs |> List.partition (fun a -> IsSecurityAttribute cenv.g cenv.amap cenv.casApplied a m)
 
@@ -5183,6 +5186,7 @@ and GenMethodForBinding
                 IsSynchronized = hasSynchronizedImplFlag
                 IsEntryPoint = isExplicitEntryPoint
                 IsNoInline = hasNoInliningFlag
+                IsAggressiveInline = hasAggressiveInliningImplFlag
                 HasSecurity = mdef.HasSecurity || (securityAttributes.Length > 0)
                 SecurityDecls = secDecls }
 
@@ -6012,7 +6016,7 @@ and GenAbstractBinding cenv eenv tref (vref:ValRef) =
     let m = vref.Range
     let memberInfo = Option.get vref.MemberInfo
     let attribs = vref.Attribs
-    let hasPreserveSigImplFlag,hasSynchronizedImplFlag,hasNoInliningFlag,attribs = ComputeMethodImplAttribs cenv vref.Deref attribs
+    let hasPreserveSigImplFlag,hasSynchronizedImplFlag,hasNoInliningFlag,hasAggressiveInliningImplFlag,attribs = ComputeMethodImplAttribs cenv vref.Deref attribs
     if memberInfo.MemberFlags.IsDispatchSlot && not memberInfo.IsImplemented then 
         let ilAttrs = 
             [ yield! GenAttrs cenv eenv attribs 
@@ -6033,6 +6037,7 @@ and GenAbstractBinding cenv eenv tref (vref:ValRef) =
             IsPreserveSig=hasPreserveSigImplFlag
             IsSynchronized=hasSynchronizedImplFlag
             IsNoInline=hasNoInliningFlag
+            IsAggressiveInline=hasAggressiveInliningImplFlag
             mdKind=match mdef.mdKind with 
                     | MethodKind.Virtual vinfo -> 
                         MethodKind.Virtual {vinfo with IsFinal=memberInfo.MemberFlags.IsFinal

src/fsharp/TastPickle.fs

@@ -1724,7 +1724,8 @@ and p_mustinline x st =
             | ValInline.PseudoVal -> 0
             | ValInline.Always  -> 1
             | ValInline.Optional -> 2
-            | ValInline.Never -> 3) st
+            | ValInline.Never -> 3
+            | ValInline.Aggressive -> 4) st
 
 and p_basethis x st = 
     p_byte (match x with 

src/fsharp/TypeChecker.fs

@@ -1421,8 +1421,12 @@ let MakeAndPublishVal cenv env (altActualParent,inSig,declKind,vrec,(ValScheme(i
                 | _ -> 0x0
             // MethodImplOptions.NoInlining = 0x8
             let NO_INLINING = 0x8
+            // MethodImplOptions.AggressiveInlining = 0x0100
+            let AGGRESSIVE_INLINING = 0x0100
             if (implflags &&& NO_INLINING) <> 0x0 then
                 ValInline.Never
+            elif (implflags &&& AGGRESSIVE_INLINING) <> 0x0 then
+                ValInline.Aggressive
             else
                 inlineFlag
 

src/fsharp/symbols/Symbols.fs

@@ -1159,6 +1159,7 @@ and FSharpInlineAnnotation =
    | AlwaysInline 
    | OptionalInline 
    | NeverInline 
+   | AggressiveInline 
 
 and FSharpMemberOrValData = 
     | E of EventInfo
@@ -1367,6 +1368,7 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
         | ValInline.Always -> FSharpInlineAnnotation.AlwaysInline
         | ValInline.Optional -> FSharpInlineAnnotation.OptionalInline
         | ValInline.Never -> FSharpInlineAnnotation.NeverInline
+        | ValInline.Aggressive -> FSharpInlineAnnotation.AggressiveInline
 
     member __.IsMutable = 
         if isUnresolved() then false else 

src/fsharp/symbols/Symbols.fsi

@@ -694,14 +694,16 @@ and [<RequireQualifiedAccess>] FSharpInlineAnnotation =
 #else
 and [<RequireQualifiedAccess>] internal FSharpInlineAnnotation = 
 #endif
-   /// Indictes the value is inlined and compiled code for the function does not exist
+   /// Indicates the value is inlined and compiled code for the function does not exist
    | PseudoValue
-   /// Indictes the value is inlined but compiled code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined 
+   /// Indicates the value is inlined but compiled code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined 
    | AlwaysInline 
-   /// Indictes the value is optionally inlined 
+   /// Indicates the value is optionally inlined 
    | OptionalInline 
-   /// Indictes the value is never inlined 
-   | NeverInline 
+   /// Indicates the value is never inlined 
+   | NeverInline   
+   /// Indicates the value is aggressively inlined by the .NET runtime
+   | AggressiveInline 
 
 /// A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members.
 #if COMPILER_PUBLIC_API

src/fsharp/tast.fs

@@ -62,6 +62,8 @@ type ValInline =
     | PseudoVal
     /// Indicates the value is inlined but the .NET IL code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined 
     | Always
+    /// Indicates the value will be inlined be inlined by the .NET runtime
+    | Aggressive
     /// Indicates the value may optionally be inlined by the optimizer
     | Optional
     /// Indicates the value must never be inlined by the optimizer
@@ -71,7 +73,7 @@ type ValInline =
     member x.MustInline = 
         match x with 
         | ValInline.PseudoVal | ValInline.Always -> true 
-        | ValInline.Optional | ValInline.Never -> false
+        | ValInline.Optional | ValInline.Aggressive | ValInline.Never -> false
 
 /// A flag associated with values that indicates whether the recursive scope of the value is currently being processed, and 
 /// if the value has been generalized or not as yet.
@@ -123,6 +125,7 @@ type ValFlags(flags:int64) =
                      (match inlineInfo with
                                         | ValInline.PseudoVal ->             0b0000000000000000000L
                                         | ValInline.Always ->                0b0000000000000010000L
+                                        | ValInline.Aggressive ->            0b0100L
                                         | ValInline.Optional ->              0b0000000000000100000L
                                         | ValInline.Never ->                 0b0000000000000110000L) |||
                      (match isMutable with