[RISC-V] Require --single-hart to build without the A extension

Without A there is no atomic memory operation to emit, so Interlocked and
CmpXchg lower to a plain read/modify/write. Whether that is sufficient depends
on the target running on one hart and never being preempted. Neither the ISA
nor the ABI says anything about that: a soft-float lp64 image is perfectly
normal on rv64imac hardware with threads, and would lose atomicity silently.

So it has to be asserted rather than inferred. Add --single-hart to ilc and
reject an ISA without A unless it is passed. The flag names the property it
claims, and the failure is at compile time rather than at run time.

Signed-off-by: Maxim Menshikov <maksim.menshikov@nethermind.io>

Author: maximmenshikov

src/coreclr/tools/Common/InstructionSetHelpers.cs

@@ -96,10 +96,11 @@ public static InstructionSetSupport ConfigureInstructionSetSupport(string instru
             }
             else if (targetArchitecture == TargetArchitecture.RiscV64)
             {
-                // The rv64gc baseline: D implies F, so "d", "c" and "a" cover
-                // the G+C extensions. Reduced-ISA targets (e.g. zkVM guests)
-                // opt out with --instruction-set=-a,-c,-d,-f. The lp64 (soft-float)
-                // ABI target has no F/D by definition.
+                // The rv64gc baseline: D implies F, so "d", "c" and "a" cover the G+C
+                // extensions. The lp64 (soft-float) ABI target has no F/D by definition;
+                // it still defaults to C and A, and a reduced-ISA target drops those with
+                // --instruction-set=-a,-c. Dropping A also requires ilc's --single-hart,
+                // because Interlocked is not atomic without it.
                 instructionSetSupportBuilder.AddSupportedInstructionSet("base");
                 if (targetAbi != TargetAbi.NativeAotRiscV64SoftFloat)
                 {

src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs

@@ -118,6 +118,8 @@ internal sealed class ILCompilerRootCommand : RootCommand
             new("--parallelism") { CustomParser = MakeParallelism, DefaultValueFactory = MakeParallelism, Description = "Maximum number of threads to use during compilation" };
         public Option<string> InstructionSet { get; } =
             new("--instruction-set") { Description = "Instruction set to allow or disallow" };
+        public Option<bool> SingleHart { get; } =
+            new("--single-hart") { Description = "RISC-V: the target runs on one hart and is never preempted. Required to build without the A extension, because Interlocked then lowers to a non-atomic read/modify/write" };
         public Option<int> MaxVectorTBitWidth { get; } =
             new("--max-vectort-bitwidth") { Description = "Maximum width, in bits, that Vector<T> is allowed to be" };
         public Option<string> Guard { get; } =
@@ -243,6 +245,7 @@ public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
             Options.Add(RuntimeKnobs);
             Options.Add(Parallelism);
             Options.Add(InstructionSet);
+            Options.Add(SingleHart);
             Options.Add(MaxVectorTBitWidth);
             Options.Add(Guard);
             Options.Add(Dehydrate);

src/coreclr/tools/aot/ILCompiler/Program.cs

@@ -112,6 +112,18 @@ public int Run()
                 isReadyToRun: false,
                 targetAbi: targetAbi);
 
+            if (targetArchitecture == TargetArchitecture.RiscV64 &&
+                !instructionSetSupport.IsInstructionSetSupported(InstructionSet.RiscV64_A) &&
+                !Get(_command.SingleHart))
+            {
+                // Without A there is no atomic memory operation to emit, so Interlocked and
+                // CmpXchg lower to a plain read/modify/write. Whether that is sufficient is a
+                // property of the execution environment, not of the ISA or the ABI, so it has
+                // to be asserted rather than inferred.
+                throw new CommandLineException(
+                    "Building without the A extension requires --single-hart: Interlocked operations are not atomic without it.");
+            }
+
             string systemModuleName = Get(_command.SystemModuleName);
             string reflectionData = Get(_command.ReflectionData);
             bool supportsReflection = reflectionData != "none" && systemModuleName == Helpers.DefaultSystemModule;