/// <summary>
/// Resolves a binary arithmetic operation.
/// </summary>
/// <param name="kind">The arithmetic kind.</param>
/// <param name="type">The operation type.</param>
/// <param name="fastMath">True, to use a fast-math operation.</param>
/// <returns>The resolved arithmetic operation.</returns>
public static string GetArithmeticOperation(
BinaryArithmeticKind kind,
ArithmeticBasicValueType type,
bool fastMath)
{
var key = (kind, type);
if (fastMath &&
BinaryArithmeticOperationsFastMath.TryGetValue(key, out string operation) ||
BinaryArithmeticOperations.TryGetValue(key, out operation))
{
return(operation);
}
throw new NotSupportedIntrinsicException(kind.ToString());
}
/// <summary>
/// Resolves an unary arithmetic operation.
/// </summary>
/// <param name="kind">The arithmetic kind.</param>
/// <param name="basicValueType">The arithmetic basic value type.</param>
/// <param name="isFunction">
/// True, if the resolved operation is a function call.
/// </param>
/// <returns>The resolved arithmetic operation.</returns>
public static string GetArithmeticOperation(
UnaryArithmeticKind kind,
ArithmeticBasicValueType basicValueType,
out bool isFunction)
{
if (!UnaryCategoryLookup.TryGetValue(basicValueType, out var category) ||
!UnaryArithmeticOperations.TryGetValue(
(kind, category),
out var operation))
{
throw new NotSupportedIntrinsicException(kind.ToString());
}
isFunction = operation.Item2;
return(operation.Item1);
}
/// <summary>
/// Resolves a compare operation.
/// </summary>
/// <param name="kind">The compare kind.</param>
/// <param name="flags">The compare flags.</param>
/// <param name="type">The type to compare.</param>
/// <returns>The resolved compare operation.</returns>
public static string GetCompareOperation(
CompareKind kind,
CompareFlags flags,
ArithmeticBasicValueType type)
{
var unorderedFloatComparison = type.IsFloat() && flags.HasFlag(CompareFlags.UnsignedOrUnordered);
if (unorderedFloatComparison)
{
if (CompareUnorderedFloatOperations.TryGetValue((kind, type), out string operation))
{
return(operation);
}
}
else
{
if (CompareOperations.TryGetValue((kind, type), out string operation))
{
return(operation);
}
}
throw new NotSupportedIntrinsicException(kind.ToString());
}
/// <summary>
/// Constructs a new primitive variable.
/// </summary>
/// <param name="id">The current variable id.</param>
/// <param name="basicValueType">The basic value type.</param>
internal PrimitiveVariable(int id, ArithmeticBasicValueType basicValueType)
: base(id)
{
BasicValueType = basicValueType;
}
/// <summary> /// Allocates the given type. /// </summary> /// <param name="basicValueType">The type to allocate.</param> /// <returns>The allocated variable.</returns> public Variable AllocateType(ArithmeticBasicValueType basicValueType) => new PrimitiveVariable(idCounter++, basicValueType);
/// <summary> /// Returns the native PrintF format for the given basic value type. /// </summary> /// <param name="valueType">The basic value type.</param> /// <returns>The resolved PrintF format.</returns> public static string GetPrintFFormat(ArithmeticBasicValueType valueType) => PrintFFormats[(int)valueType];
/// <summary>
/// Resolves a convert operation.
/// </summary>
/// <param name="source">The source type to convert from.</param>
/// <param name="target">The target type to convert to.</param>
/// <returns>The resolved convert operation.</returns>
public static string GetConvertOperation(
ArithmeticBasicValueType source,
ArithmeticBasicValueType target) =>
ConvertOperations.TryGetValue((source, target), out string operation)
/// <summary> /// Resolves a LEA operation. /// </summary> /// <param name="pointerType">The pointer type.</param> /// <returns>The resolved LEA operation.</returns> public static string GetLEAMulOperation(ArithmeticBasicValueType pointerType) => LEAMulOperations[pointerType];
/// <summary>
/// Resolves the given basic-value type to an atomic OpenCL type name.
/// </summary>
/// <param name="basicValueType">The basic-value type to resolve.</param>
/// <returns>The resolved atomic OpenCL type name.</returns>
public string GetAtomicType(ArithmeticBasicValueType basicValueType) =>
basicValueType == ArithmeticBasicValueType.Float16 && !Capabilities.Float16
? throw CLCapabilityContext.GetNotSupportedFloat16Exception()
: basicValueType == ArithmeticBasicValueType.Float64 && !Capabilities.Float64
? throw CLCapabilityContext.GetNotSupportedFloat64Exception()
: AtomicTypeMapping[(int)basicValueType];
public static string GetAtomicOperationSuffix(AtomicKind kind, ArithmeticBasicValueType type) =>
public static string GetConvertOperation(ArithmeticBasicValueType source, ArithmeticBasicValueType target) =>
public static string GetCompareOperation(CompareKind kind, ArithmeticBasicValueType type) =>
/// <summary> /// Resolves the given basic-value type to an atomic OpenCL type name. /// </summary> /// <param name="basicValueType">The basic-value type to resolve.</param> /// <returns>The resolved atomic OpenCL type name.</returns> public static string GetAtomicType(ArithmeticBasicValueType basicValueType) => AtomicTypeMapping[(int)basicValueType];
/// <summary>
/// Appends a cast to the given arithmetic basic value type.
/// </summary>
/// <param name="type">The target type.</param>
public void AppendCast(ArithmeticBasicValueType type)
{
var typeExpression = CLTypeGenerator.GetBasicValueType(type);
AppendCast(typeExpression);
}
