[AOT] Fix for a compatibility issue between AOT and LLVM 14 (#6946)

* [AOT] Fix for a compatibility issue between AOT and LLVM 14

Context: https://releases.llvm.org/14.0.0/tools/lld/docs/ReleaseNotes.html#elf-improvements
Context: 16bbf6f

After switching to LLVM 14 we noticed that all `arm64` apps which use
AOT, crash with the following assertion from the Mono runtime:

    * Assertion at /__w/1/s/src/mono/mono/mini/tramp-arm64.c:53, condition `((ins >> 24) & 0x1f) == 0x10' not met

After investigation, it turns out that one of the LLVM 14 changes for
the `aarch64` architecture in the `lld` linker was an optimization which
modifies generated code in the following fashion (`-` is the "good"
code, `+` is the "bad" one):

   -   13a44: 30 01 00 b0          adrp    x16, 0x38000 <.text+0x148>
   -   13a48: 10 e2 3e 91          add     x16, x16, #4024         // =4024
   +   13a44: 1f 20 03 d5          nop
   +   13a48: 90 ab 12 10          adr     x16, #152944

Mono AOT generates a pair of instructions, `adrp` and `add` and, at the
runtime, it expects to find the exact code that was generated (runtime
disassembles the binary code and looks for specific patterns), but
instead it finds a `nop` and an `adr` instructions, which eventually
triggers the above assertion.

Code is modified in the way described above by the `lld` linker, according to this change
in LLVM 14:

     The AArch64 port now supports adrp+ldr and adrp+add optimizations. --no-relax can suppress the optimization.

Until Mono runtime code is fixed, we can work around this issue by
passing the `--no-relax` flag to the native linker.

* lld in the NDK doesn't support `--no-relax`

Author: grendello

src/Xamarin.Android.Build.Tasks/Tasks/GetAotArguments.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using Java.Interop.Tools.Diagnostics;
 using Microsoft.Android.Build.Tasks;
 using Microsoft.Build.Framework;
@@ -252,7 +253,7 @@ protected void GetAotOptions (NdkTools ndk, AndroidTargetArch arch, int level, s
 		string GetLdFlags(NdkTools ndk, AndroidTargetArch arch, int level, string toolPrefix)
 		{
 			var toolchainPath = toolPrefix.Substring (0, toolPrefix.LastIndexOf (Path.DirectorySeparatorChar));
-			var ldFlags = string.Empty;
+			var ldFlags = new StringBuilder ();
 			if (EnableLLVM) {
 				string androidLibPath = string.Empty;
 				try {
@@ -291,19 +292,31 @@ string GetLdFlags(NdkTools ndk, AndroidTargetArch arch, int level, string toolPr
 				libs.Add (Path.Combine (androidLibPath, "libc.so"));
 				libs.Add (Path.Combine (androidLibPath, "libm.so"));
 
-				ldFlags = $"\\\"{string.Join ("\\\";\\\"", libs)}\\\"";
-			}
+				ldFlags.Append ($"\\\"{string.Join ("\\\";\\\"", libs)}\\\"");
+			} else {
+				if (ldFlags.Length > 0) {
+					ldFlags.Append (' ');
+				}
 
-			if (!StripLibraries) {
-				return ldFlags;
+				//
+				// This flag is needed for Mono AOT to work correctly with the LLVM 14 `lld` linker due to the following change:
+				//
+				//   The AArch64 port now supports adrp+ldr and adrp+add optimizations. --no-relax can suppress the optimization.
+				//
+				// Without the flag, `lld` will modify AOT-generated code in a way that the Mono runtime doesn't support. Until
+				// the runtime issue is fixed, we need to pass this flag then.
+				//
+				ldFlags.Append ("--no-relax");
 			}
 
-			const string StripFlag = "-s";
-			if (ldFlags.Length == 0) {
-				return StripFlag;
+			if (StripLibraries) {
+				if (ldFlags.Length > 0) {
+					ldFlags.Append (' ');
+				}
+				ldFlags.Append ("-s");
 			}
 
-			return $"{ldFlags} {StripFlag}";
+			return ldFlags.ToString ();
 		}
 
 		static string GetNdkToolchainLibraryDir (NdkTools ndk, string binDir, string archDir = null)