/// <summary>
/// Applies an intrinsic implementation transformation.
/// </summary>
protected override bool PerformTransformation(
Method.Builder builder,
IntrinsicImplementationProvider <TDelegate> .
IRSpecializationPhase specializationPhase)
{
// Check whether we are currently processing an intrinsic method
var scope = builder.CreateScope();
bool applied = false;
// Analyze intrinsic nodes
foreach (Value value in scope.Values)
{
if (value is MethodCall methodCall)
{
applied |= specializationPhase.RegisterIntrinsic(methodCall.Target);
}
else
{
applied |= specializationPhase.RegisterIntrinsic(value);
}
}
return(applied);
}
/// <summary>
/// Constructs a new generic backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="backendType">The backend type.</param>
/// <param name="backendFlags">The backend flags.</param>
/// <param name="abi">The current ABI.</param>
/// <param name="argumentMapperProvider">The provider for argument mappers.</param>
protected Backend(
Context context,
BackendType backendType,
BackendFlags backendFlags,
ABI abi,
Func <ABI, ArgumentMapper> argumentMapperProvider)
: base(context, backendType, backendFlags, abi, argumentMapperProvider)
{
intrinsicProvider = context.IntrinsicManager.CreateProvider <TDelegate>(this);
}
/// <summary>
/// Constructs a new intrinsic resolver.
/// </summary>
/// <param name="implementationProvider">
/// The implementation provider to use.
/// </param>
public IntrinsicResolver(
IntrinsicImplementationProvider <TDelegate> implementationProvider)
{
provider = implementationProvider
?? throw new ArgumentNullException(nameof(implementationProvider));
}
/// <summary cref="UnorderedTransformation{TIntermediate}.FinishProcessing(TIntermediate)"/>
protected override void FinishProcessing(IntrinsicImplementationProvider <TDelegate> .IRSpecializationPhase intermediate) =>
intermediate.Dispose();
