Code generation progress

Author: grendello

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

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+
+namespace Xamarin.Android.Tasks.LLVMIR;
+
+/// <summary>
+/// Function calling convention, see https://llvm.org/docs/LangRef.html#callingconv for more detailed docs.
+/// Not all conventions are included in this enumeration, only those we may potentially need.
+/// </summary>
+enum LlvmIrCallingConvention
+{
+	/// <summary>
+	/// Outputs no keyword, making function use whatever is the compiler's default calling convention.
+	/// </summary>
+	Default,
+
+	/// <summary>
+	/// The C calling convention (`ccc`)
+	/// </summary>
+	Ccc,
+
+	/// <summary>
+	/// The fast calling convention (`fastcc`). This calling convention attempts to make calls as fast
+	/// as possible (e.g. by passing things in registers).
+	/// </summary>
+	Fastcc,
+
+	/// <summary>
+	/// Tail callable calling convention (`tailcc`). This calling convention ensures that calls in tail
+	/// position will always be tail call optimized. This calling convention is equivalent to fastcc,
+	/// except for an additional guarantee that tail calls will be produced whenever possible.
+	/// </summary>
+	Tailcc,
+}

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

@@ -21,6 +21,7 @@ sealed class SavedParameterState : ILlvmIrSavedFunctionParameterState
 			public bool? ReadNone;
 			public bool? SignExt;
 			public bool? ZeroExt;
+			public bool? WriteOnly;
 			public bool? IsCplusPlusReference;
 			public bool IsVarArgs;
 
@@ -40,6 +41,7 @@ public SavedParameterState (LlvmIrFunctionParameter owner, SavedParameterState?
 				ReadNone = previousState.ReadNone;
 				SignExt = previousState.SignExt;
 				ZeroExt = previousState.ZeroExt;
+				WriteOnly = previousState.WriteOnly;
 				IsCplusPlusReference = previousState.IsCplusPlusReference;
 				IsVarArgs = previousState.IsVarArgs;
 			}
@@ -131,6 +133,14 @@ public bool? ZeroExt {
 			set => state.ZeroExt = value;
 		}
 
+		/// <summary>
+		/// <c>writeonly</c> attribute, see <see href="https://github.com/llvm/llvm-project/blob/5729e63ac7b47c6ad40f904fedafad3c07cf71ea/llvm/docs/LangRef.rst#L1436"/>
+		/// </summary>
+		public bool? WriteOnly {
+			get => state.WriteOnly;
+			set => state.WriteOnly = value;
+		}
+
 		/// <summary>
 		/// This serves a purely documentational purpose, when generating comments about types.  It describes a parameter that is a C++ reference, something we can't
 		/// reflect on the managed side.
@@ -411,6 +421,7 @@ public SavedFunctionState (LlvmIrFunction owner, ILlvmIrSavedFunctionSignatureSt
 		public LlvmIrLinkage Linkage                         { get; set; } = LlvmIrLinkage.Default;
 		public LlvmIrRuntimePreemption RuntimePreemption     { get; set; } = LlvmIrRuntimePreemption.Default;
 		public LlvmIrVisibility Visibility                   { get; set; } = LlvmIrVisibility.Default;
+		public LlvmIrCallingConvention CallingConvention     { get; set; } = LlvmIrCallingConvention.Default;
 		public LlvmIrFunctionBody Body                       { get; }
 		public string? Comment                               { get; set; }
 		public bool ReturnsValue                             => Signature.ReturnType != typeof(void);

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

@@ -46,5 +46,12 @@ partial class LlvmIrGenerator
 			{ LlvmIrWritability.Constant, "constant" },
 			{ LlvmIrWritability.Writable, "global" },
 		};
+
+		// https://llvm.org/docs/LangRef.html#callingconv
+		static readonly Dictionary<LlvmIrCallingConvention, string> llvmCallingConvention = new () {
+			{ LlvmIrCallingConvention.Ccc, "ccc" },
+			{ LlvmIrCallingConvention.Fastcc, "fastcc" },
+			{ LlvmIrCallingConvention.Tailcc, "tailcc" },
+		};
 	}
 }

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

@@ -28,12 +28,14 @@ sealed class GeneratorWriteContext
 		public readonly LlvmIrModuleTarget Target;
 		public readonly LlvmIrMetadataManager MetadataManager;
 		public readonly LlvmIrTypeCache TypeCache;
+		public readonly LlvmIrGenerator Generator;
 		public string CurrentIndent { get; private set; } = String.Empty;
 		public bool InVariableGroup { get; set; }
 		public LlvmIrVariableNumberFormat NumberFormat { get; set; } = LlvmIrVariableNumberFormat.Default;
 
-		public GeneratorWriteContext (TextWriter writer, LlvmIrModule module, LlvmIrModuleTarget target, LlvmIrMetadataManager metadataManager, LlvmIrTypeCache cache)
+		public GeneratorWriteContext (LlvmIrGenerator generator, TextWriter writer, LlvmIrModule module, LlvmIrModuleTarget target, LlvmIrMetadataManager metadataManager, LlvmIrTypeCache cache)
 		{
+			Generator = generator;
 			Output = writer;
 			Module = module;
 			Target = target;
@@ -163,7 +165,7 @@ public void Generate (TextWriter writer, LlvmIrModule module)
 			LlvmIrMetadataManager metadataManager = module.GetMetadataManagerCopy ();
 			target.AddTargetSpecificMetadata (metadataManager);
 
-			var context = new GeneratorWriteContext (writer, module, target, metadataManager, module.TypeCache);
+			var context = new GeneratorWriteContext (this, writer, module, target, metadataManager, module.TypeCache);
 			if (!String.IsNullOrEmpty (FilePath)) {
 				WriteCommentLine (context, $" ModuleID = '{FileName}'");
 				context.Output.WriteLine ($"source_filename = \"{FileName}\"");
@@ -670,7 +672,7 @@ string ToHex (BasicType basicTypeDesc, Type type, object? value)
 			return $"{(basicTypeDesc.IsUnsigned ? prefixUnsigned : prefixSigned)}0x{hex}";
 		}
 
-		void WriteValue (GeneratorWriteContext context, Type type, object? value)
+		public void WriteValue (GeneratorWriteContext context, Type type, object? value)
 		{
 			if (value is LlvmIrVariable variableRef) {
 				context.Output.Write (variableRef.Reference);
@@ -1226,6 +1228,11 @@ void WriteFunctionLeadingDecorations (GeneratorWriteContext context, LlvmIrFunct
 				context.Output.Write (llvmVisibility[func.Visibility]);
 				context.Output.Write (' ');
 			}
+
+			if (func.CallingConvention != LlvmIrCallingConvention.Default) {
+				context.Output.Write (llvmCallingConvention[func.CallingConvention]);
+				context.Output.Write (' ');
+			}
 		}
 
 		void WriteFunctionDeclarationTrailingDecorations (GeneratorWriteContext context, LlvmIrFunction func)
@@ -1251,6 +1258,10 @@ void WriteFunctionTrailingDecorations (GeneratorWriteContext context, LlvmIrFunc
 
 		public static void WriteReturnAttributes (GeneratorWriteContext context, LlvmIrFunctionSignature.ReturnTypeAttributes returnAttrs)
 		{
+			if (AttributeIsSet (returnAttrs.InReg)) {
+				context.Output.Write ("inreg");
+			}
+
 			if (AttributeIsSet (returnAttrs.NoUndef)) {
 				context.Output.Write ("noundef ");
 			}
@@ -1349,6 +1360,10 @@ public static void WriteParameterAttributes (GeneratorWriteContext context, Llvm
 				attributes.Add ("zeroext");
 			}
 
+			if (AttributeIsSet (parameter.WriteOnly)) {
+				attributes.Add ("writeonly");
+			}
+
 			if (parameter.Align.HasValue) {
 				attributes.Add ($"align({ValueOrPointerSize (parameter.Align.Value)})");
 			}

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

@@ -624,4 +624,109 @@ public Unreachable ()
 			: base ("unreachable")
 		{}
 	}
+
+	public class Switch<T> : LlvmIrInstruction where T: struct
+	{
+		// Since we can't use System.Numerics.IBinaryInteger<T>, this is the poor man's verification that T is acceptable for us
+		static readonly HashSet<Type> acceptedTypes = new () {
+			typeof (byte),
+			typeof (sbyte),
+			typeof (short),
+			typeof (ushort),
+			typeof (int),
+			typeof (uint),
+			typeof (long),
+			typeof (ulong),
+		};
+
+		readonly LlvmIrVariable value;
+		readonly LlvmIrFunctionLabelItem defaultDest;
+		readonly string? automaticLabelPrefix;
+		ulong automaticLabelCounter = 0;
+		List<(T constant, LlvmIrFunctionLabelItem label, string? comment)>? items;
+
+		public Switch (LlvmIrVariable value, LlvmIrFunctionLabelItem defaultDest, string? automaticLabelPrefix = null)
+			: base ("switch")
+		{
+			if (!acceptedTypes.Contains (typeof(T))) {
+				throw new NotSupportedException ($"Type '{typeof(T)}' is unsupported, only integer types are accepted");
+			}
+
+			if (value.Type != typeof (T)) {
+				throw new ArgumentException ($"Must refer to value of type '{typeof(T)}'", nameof (value));
+			}
+
+			this.value = value;
+			this.defaultDest = defaultDest;
+			this.automaticLabelPrefix = automaticLabelPrefix;
+
+			if (!String.IsNullOrEmpty (automaticLabelPrefix)) {
+				items = new ();
+			}
+		}
+
+		protected override void WriteBody (GeneratorWriteContext context)
+		{
+			string irType = LlvmIrGenerator.MapToIRType (value.Type, context.TypeCache, out _, out bool isPointer);
+
+			context.Output.Write (irType);
+			context.Output.Write (' ');
+
+			WriteValue (context, value.Type, value, isPointer);
+
+			context.Output.Write (", label %");
+			context.Output.Write (defaultDest.Name);
+			context.Output.WriteLine (" [");
+			context.IncreaseIndent ();
+
+			foreach ((T constant, LlvmIrFunctionLabelItem label, string? comment) in items) {
+				context.Output.Write (context.CurrentIndent);
+				context.Output.Write (irType);
+				context.Output.Write (' ');
+				context.Generator.WriteValue (context, value.Type, constant);
+				context.Output.Write (", label %");
+				context.Output.Write (label.Name);
+				if (!String.IsNullOrEmpty (comment)) {
+					context.Generator.WriteCommentLine (context, comment);
+				} else {
+					context.Output.WriteLine ();
+				}
+			}
+
+			context.DecreaseIndent ();
+			context.Output.Write (context.CurrentIndent);
+			context.Output.Write (']');
+		}
+
+		public LlvmIrFunctionLabelItem Add (T val, LlvmIrFunctionLabelItem? dest = null, string? comment = null)
+		{
+			var label = MakeLabel (dest);
+			items.Add ((val, label, comment));
+			return label;
+		}
+
+		void EnsureValidity (LlvmIrFunctionLabelItem? dest)
+		{
+			if (dest != null) {
+				return;
+			}
+
+			if (String.IsNullOrEmpty (automaticLabelPrefix)) {
+				throw new InvalidOperationException ($"Internal error: automatic label management requested, but prefix not defined");
+			}
+		}
+
+		LlvmIrFunctionLabelItem MakeLabel (LlvmIrFunctionLabelItem? maybeDest)
+		{
+			EnsureValidity (maybeDest);
+			if (maybeDest != null) {
+				return maybeDest;
+			}
+
+			var ret = new LlvmIrFunctionLabelItem (automaticLabelCounter == 0 ? automaticLabelPrefix : $"{automaticLabelPrefix}{automaticLabelCounter}");
+			automaticLabelCounter++;
+
+			return ret;
+		}
+	}
 }