private static bool IsLeftToRightReassociable( IntrinsicPrototype prototype, out IntrinsicPrototype rightPrototype) { string op; string rightOp; bool isChecked; if (ArithmeticIntrinsics.TryParseArithmeticIntrinsicName(prototype.Name, out op, out isChecked) && !isChecked && intArithLeftToRight.TryGetValue(op, out rightOp) && prototype.ParameterTypes.All(x => x.IsIntegerType())) { rightPrototype = ArithmeticIntrinsics.CreatePrototype( rightOp, isChecked, prototype.ResultType, prototype.ParameterTypes); return(true); } else { rightPrototype = null; return(false); } }
private static bool IsAssociative(IntrinsicPrototype prototype) { string op; bool isChecked; if (ArithmeticIntrinsics.TryParseArithmeticIntrinsicName(prototype.Name, out op, out isChecked) && !isChecked && assocIntArith.Contains(op)) { return(prototype.ParameterTypes.All(x => x.IsIntegerType())); } else { return(false); } }
/// <summary> /// The default constant instruction evaluation function. /// </summary> /// <param name="prototype"> /// The prorotype of the instruction to evaluate. /// </param> /// <param name="arguments"> /// A list of arguments to the instruction, all of which /// must be constants. /// </param> /// <returns> /// <c>null</c> if the instruction cannot be evaluated; otherwise, the constant /// to which the instruction evaluates. /// </returns> public static Constant EvaluateDefault( InstructionPrototype prototype, IReadOnlyList <Constant> arguments) { if (prototype is CopyPrototype || prototype is ReinterpretCastPrototype) { return(arguments[0]); } else if (prototype is ConstantPrototype) { var constProto = (ConstantPrototype)prototype; if (constProto.Value is DefaultConstant) { // Try to specialize 'default' constants. var intSpec = constProto.ResultType.GetIntegerSpecOrNull(); if (intSpec != null) { return(new IntegerConstant(0, intSpec)); } } return(constProto.Value); } else if (prototype is IntrinsicPrototype) { string arithOp; Constant result; if (ArithmeticIntrinsics.TryParseArithmeticIntrinsicName( ((IntrinsicPrototype)prototype).Name, out arithOp) && ArithmeticIntrinsics.TryEvaluate( arithOp, prototype.ResultType, arguments, out result)) { return(result); } } return(null); }