Add some more tracing capabilities

Author: grendello

src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrFunctionBody.cs

@@ -301,4 +301,12 @@ public LlvmIrInstructions.Store Store (LlvmIrVariable to, LlvmIrMetadataItem? tb
 		Add (ret);
 		return ret;
 	}
+
+	public LlvmIrInstructions.Unreachable Unreachable ()
+	{
+		var ret = new LlvmIrInstructions.Unreachable ();
+
+		Add (ret);
+		return ret;
+	}
 }

src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrInstructions.cs

@@ -575,4 +575,11 @@ protected override void WriteBody (GeneratorWriteContext context)
 			WriteAlignment (context, size, isPointer);
 		}
 	}
+
+	public class Unreachable : LlvmIrInstruction
+	{
+		public Unreachable ()
+			: base ("unreachable")
+		{}
+	}
 }

src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrModule.cs

@@ -40,6 +40,9 @@ partial class LlvmIrModule
 
 		List<LlvmIrGlobalVariable>? globalVariables;
 
+		LlvmIrFunction? puts;
+		LlvmIrFunction? abort;
+
 		public LlvmIrModule ()
 		{
 			metadataManager = new LlvmIrMetadataManager ();
@@ -125,6 +128,119 @@ public void Add (LlvmIrFunction func)
 			functions.Add (func, func);
 		}
 
+		public LlvmIrInstructions.Call CreatePuts (string text, LlvmIrVariable result)
+		{
+			EnsurePuts ();
+			RegisterString (text);
+			return new LlvmIrInstructions.Call (puts, result, new List<object?> { text });
+		}
+
+		/// <summary>
+		/// Generate code to call the `puts(3)` C library function to print a simple string to standard output.
+		/// </summary>
+		public LlvmIrInstructions.Call AddPuts (LlvmIrFunction function, string text, LlvmIrVariable result)
+		{
+			EnsurePuts ();
+			RegisterString (text);
+			return function.Body.Call (puts, result, new List<object?> { text });
+		}
+
+		void EnsurePuts ()
+		{
+			if (puts != null) {
+				return;
+			}
+
+			var puts_params = new List<LlvmIrFunctionParameter> {
+				new (typeof(string), "s"),
+			};
+
+			var puts_sig = new LlvmIrFunctionSignature (
+				name: "puts",
+				returnType: typeof(int),
+				parameters: puts_params
+			);
+			puts_sig.ReturnAttributes.NoUndef = true;
+
+			puts = DeclareExternalFunction (puts_sig, MakePutsAttributeSet ());
+		}
+
+		LlvmIrFunctionAttributeSet MakePutsAttributeSet ()
+		{
+			var ret = new LlvmIrFunctionAttributeSet {
+				new NofreeFunctionAttribute (),
+				new NounwindFunctionAttribute (),
+			};
+
+			ret.DoNotAddTargetSpecificAttributes = true;
+			return AddAttributeSet (ret);
+		}
+
+		public LlvmIrInstructions.Call CreateAbort ()
+		{
+			EnsureAbort ();
+			return new LlvmIrInstructions.Call (abort);
+		}
+
+		public LlvmIrInstructions.Call AddAbort (LlvmIrFunction function)
+		{
+			EnsureAbort ();
+			LlvmIrInstructions.Call ret = function.Body.Call (abort);
+			function.Body.Unreachable ();
+
+			return ret;
+		}
+
+		void EnsureAbort ()
+		{
+			if (abort != null) {
+				return;
+			}
+
+			var abort_sig = new LlvmIrFunctionSignature (name: "abort", returnType: typeof(void));
+			abort = DeclareExternalFunction (abort_sig, MakeAbortAttributeSet ());
+		}
+
+		LlvmIrFunctionAttributeSet MakeAbortAttributeSet ()
+		{
+			var ret = new LlvmIrFunctionAttributeSet {
+				new NoreturnFunctionAttribute (),
+				new NounwindFunctionAttribute (),
+				new NoTrappingMathFunctionAttribute (true),
+				new StackProtectorBufferSizeFunctionAttribute (8),
+			};
+
+			return AddAttributeSet (ret);
+		}
+
+		public void AddIfThenElse (LlvmIrFunction function, LlvmIrVariable result, LlvmIrIcmpCond condition, LlvmIrVariable conditionVariable, object? conditionComparand, ICollection<LlvmIrInstruction> codeIfThen, ICollection<LlvmIrInstruction>? codeIfElse = null)
+		{
+			function.Body.Icmp (condition, conditionVariable, conditionComparand, result);
+
+			var labelIfThen = new LlvmIrFunctionLabelItem ();
+			LlvmIrFunctionLabelItem? labelIfElse = codeIfElse != null ? new LlvmIrFunctionLabelItem () : null;
+			var labelIfDone = new LlvmIrFunctionLabelItem ();
+
+			function.Body.Br (result, labelIfThen, labelIfElse == null ? labelIfDone : labelIfElse);
+			function.Body.Add (labelIfThen);
+
+			AddInstructions (codeIfThen);
+
+			if (codeIfElse != null) {
+				function.Body.Add (labelIfElse);
+				AddInstructions (codeIfElse);
+			}
+
+			function.Body.Add (labelIfDone);
+
+			void AddInstructions (ICollection<LlvmIrInstruction> instructions)
+			{
+				foreach (LlvmIrInstruction ins in instructions) {
+					function.Body.Add (ins);
+				}
+			}
+		}
+
 		/// <summary>
 		/// A shortcut way to add a global variable without first having to create an instance of <see cref="LlvmIrGlobalVariable"/> first. This overload
 		/// requires the <paramref name="value"/> parameter to not be <c>null</c>.
@@ -509,6 +625,11 @@ public LlvmIrFunction DeclareExternalFunction (LlvmIrFunction func)
 			return func;
 		}
 
+		public LlvmIrFunction DeclareExternalFunction (LlvmIrFunctionSignature sig, LlvmIrFunctionAttributeSet? attrSet = null)
+		{
+			return DeclareExternalFunction (new LlvmIrFunction (sig, attrSet));
+		}
+
 		/// <summary>
 		/// Since LLVM IR is strongly typed, it requires each structure to be properly declared before it is
 		/// used throughout the code.  This method uses reflection to scan the managed type <typeparamref name="T"/>

src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsNativeAssemblyGenerator.Tracing.cs

@@ -336,9 +336,9 @@ void DoWriteAsprintfCall (LlvmIrFunction func, List<object?> variadicArgs, Aspri
 		LlvmIrLocalVariable asprintf_failed = func.CreateLocalVariable (typeof(bool), "asprintf_failed");
 		func.Body.Icmp (LlvmIrIcmpCond.SignedLessThan, asprintf_failed, (int)0, asprintf_failed);
 
-		var asprintfIfThenLabel = new LlvmIrFunctionLabelItem ("if.then");
-		var asprintfIfElseLabel = new LlvmIrFunctionLabelItem ("if.else");
-		var ifElseDoneLabel = new LlvmIrFunctionLabelItem ("if.done");
+		var asprintfIfThenLabel = new LlvmIrFunctionLabelItem ();
+		var asprintfIfElseLabel = new LlvmIrFunctionLabelItem ();
+		var ifElseDoneLabel = new LlvmIrFunctionLabelItem ();
 
 		func.Body.Br (asprintf_failed, asprintfIfThenLabel, asprintfIfElseLabel);
 

src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsNativeAssemblyGenerator.cs

@@ -817,6 +817,24 @@ LlvmIrFunctionAttributeSet MakeMarshalMethodAttributeSet (LlvmIrModule module)
 
 			LlvmIrFunctionAttributeSet attrSet = MakeXamarinAppInitAttributeSet (module);
 			var xamarin_app_init = new LlvmIrFunction (init_signature, attrSet);
+
+			// If `fn` is nullptr, print a message and abort...
+			//
+			// We must allocate result variables for both the null comparison and puts call here and with names, because
+			// labels and local unnamed variables must be numbered sequentially otherwise and the `AddIfThenElse` call will
+			// allocate up to 3 labels which would have been **defined** after these labels, but **used** before them - and
+			// thus the numbering sequence would be out of order and the .ll file wouldn't build.
+			var fnNullResult = xamarin_app_init.CreateLocalVariable (typeof(bool), "fnIsNull");
+			LlvmIrVariable putsResult = xamarin_app_init.CreateLocalVariable (typeof(int), "putsResult");
+			var ifThenInstructions = new List<LlvmIrInstruction> {
+				module.CreatePuts ("get_function_pointer MUST be specified\n", putsResult),
+				module.CreateAbort (),
+				new LlvmIrInstructions.Unreachable (),
+			};
+
+			module.AddIfThenElse (xamarin_app_init, fnNullResult, LlvmIrIcmpCond.Equal, init_params[1], null, ifThenInstructions);
+
+			// ...otherwise store the pointer and return
 			xamarin_app_init.Body.Store (init_params[1], getFunctionPtrVariable, module.TbaaAnyPointer);
 			xamarin_app_init.Body.Ret (typeof(void));