Native AOT: Implicit F# quotations throw PlatformNotSupportedException in RuntimeHelpers.InitializeArray

Aperta
  • Qualcosa non va?
#20,942 0 commenti 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 2 giorni

Nessuno ha ancora preso questa issue.

Valutazione

Difficoltà
4/5
Tempo stimato
3-5 giorni
Idoneità per principianti
45/100
Tipo di issue
Bug
Chiarezza
Abbastanza chiara
Stato di attività
Attiva
Stack tecnologico
fsharp
Ambito
compilers

Direzione di ricerca

Start with the attached reproduction project and compare the generated IL for the failing List.average quotation with the working List.sum case. Read the linked Native AOT limitation for RuntimeHelpers.InitializeArray and investigate whether the fix belongs in F# quotation code generation or Native AOT handling. Done means both expressions preserve their values and quotation behavior under Native AOT without the exception.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

Bug Needs-Triage

Description

Implicit F# quotations involving certain expressions, such as List.average, throw System.PlatformNotSupportedException in RuntimeHelpers.InitializeArray when compiled with Native AOT.

The same expressions execute successfully under the JIT, and direct evaluation without implicit quotation also works under Native AOT.

Repro steps

The issue reproduces with .NET 10 on Linux x64.

Environment:

  • .NET SDK: 10.0.403
  • FSharp.Core: 10.1.403
  • Native AOT compiler/runtime pack: 10.0.14
  • Target framework: net10.0
  • Runtime identifier: linux-x64

The attached reproduction project contains the complete source and project file.

The relevant F# code is:

open Microsoft.FSharp.Quotations
open Microsoft.FSharp.Quotations.Patterns

type Holder() =
    member _.Capture([<ReflectedDefinition(true)>] expr: Expr<float>) =
        match expr with
        | WithValue(value, _, _) -> unbox<float> value
        | _ -> -1.0

The reproduction compares direct evaluation with implicit quotation:

run "direct-average" (fun () ->
    List.average [1.0; 2.0; 3.0])

run "quoted-average" (fun () ->
    holder.Capture(List.average [1.0; 2.0; 3.0]))

Run the attached project using the JIT:

dotnet run -c Release

Then publish and run with Native AOT:

dotnet publish -c Release -r linux-x64 -p:PublishAot=true
./bin/Release/net10.0/linux-x64/publish/MinimalAot

The reproduction catches exceptions and reports them in its output.

Expected behavior

Both expressions should evaluate to 2.0 without throwing an exception.

Implicit quotation should preserve the evaluated value and the corresponding expression tree under Native AOT, as it does under the JIT.

Actual behavior

Under Native AOT:

direct-average|OK|2
quoted-average|ERR|System.PlatformNotSupportedException: Operation is not supported on this platform.

The stack trace identifies:

System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(
    System.Array,
    System.RuntimeFieldHandle
)

The same reproduction does not encounter this exception under the JIT.

Investigation

The F# compiler generates IL to evaluate the original expression and reconstruct its quotation using serialized expression data.

The quotation deserialization includes an IL sequence resembling:

ldc.i4 <size>
newarr System.Byte
dup
ldtoken <RVA-field>
call RuntimeHelpers.InitializeArray
call Expr.Deserialize40

This sequence also appears in expressions that execute successfully under Native AOT, including the tested List.sum case.

Therefore, the local instruction sequence alone does not explain the failure.

Two experimental IL transformations were tested:

  1. Spilling the evaluated value: Store the computed result in a local variable before quotation reconstruction, then reload it after deserialization.
  2. Hoisting array initialization: Move the newarr, dup, ldtoken, and InitializeArray sequence into a private static helper method returning byte[].

Both transformations eliminated the original PlatformNotSupportedException.

In a broader test corpus containing 30 quotation expressions, the original generated IL produced 29 expected results and one PlatformNotSupportedException. After the array-initialization sequence was moved into a private helper, all 30 expressions produced their expected results without runtime errors.

These results suggest that the failure depends on the surrounding generated IL and its interaction with Native AOT's intrinsic recognition, rather than on List.average itself.

A nonempty evaluation stack alone does not explain the behavior, since other expressions with nonempty stacks execute successfully.

The exact condition that prevents intrinsic expansion has not yet been identified.

Known workarounds

The experimental IL transformations described above eliminate the exception in the tested cases.

However, they require post-compilation IL rewriting and have not been validated as general-purpose workarounds.

After eliminating the InitializeArray exception, separate quotation metadata-resolution errors may occur under Native AOT. Those are distinct from the issue reported here.

Possible resolution

Two potential approaches are worth investigating:

  • F# compiler: Adjust quotation code generation so that serialized byte-array initialization consistently uses an IL structure recognized by Native AOT.
  • Native AOT compiler: Improve recognition or handling of valid IL patterns involving RuntimeHelpers.InitializeArray.

Any change should preserve quotation evaluation semantics, including captured values and expression reconstruction.

It is not yet clear whether the appropriate fix belongs in the F# compiler, the Native AOT compiler, or both.

Related issues

The attached reproduction includes the original F# source, project file, and relevant IL excerpts comparing List.sum and List.average.

FSharp-NativeAOT-ImplicitQuotation-Issue-Repro.zip

Lingua principale
F#
Stelle
4.3k
Fork
883
Merge medio
3g 4h
PR unite (30g)
88

Preparare l'ambiente

Apri in Codespaces

Avvia il container di sviluppo del progetto nel browser, con il tuo account GitHub.

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di dotnet/fsharp

Tutte le issue di dotnet/fsharp

Issue simili

Altre issue su Compilers

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.