public OpId(NumericSystem NumSystem, OpKind OpKind, NumericKind NumKind, Genericity Generic, OpFusion Fusion, string OpTitle) { this.NumSystem = NumSystem; this.OpKind = OpKind; this.NumKind = NumKind; this.OperandType = PrimalKinds.kind <T>(); this.Generic = Generic; this.Fusion = Fusion; this.OpTitle = ifEmpty(OpTitle, OpId.DefineOpTitle(this)); this.OpUri = OpId.BuildOpUri(this); }
protected void VerifyOp <K>(OpKind opKind, UnaryOp <K> subject, UnaryOp <K> baseline, bool nonzero = false, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int?line = null) where K : struct { var kind = PrimalKinds.kind <K>(); var opid = opKind.PrimalGOpId <K>(); var src = RandArray <K>(nonzero); var timing = stopwatch(); for (var i = 0; i < src.Length; i++) { Claim.eq(baseline(src[i]), subject(src[i]), caller, file, line); } }
public static OpArity Arity(this OpKind op) { var attributions = (from a in typeof(OpKind).DeclaredFieldAttributions <ArityAttribute>() select(a.Key.Name, a.Value.Arity)).ToDictionary(); if (attributions.ContainsKey(op.ToString())) { return(attributions[op.ToString()]); } else { return(OpArity.None); } }
protected void VerifyOp <K>(OpKind opKind, BinaryOp <K> baseline, BinaryOp <K> op, bool nonzero = false, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int?line = null) where K : struct { var kind = PrimalKinds.kind <K>(); var lhs = RandArray <K>(); var rhs = RandArray <K>(nonzero); var len = length(lhs, rhs); var timing = stopwatch(); for (var i = 0; i < len; i++) { Claim.numeq(baseline(lhs[i], rhs[i]), op(lhs[i], rhs[i]), caller, file, line); } }
// String returns a human readable representation of an OpKind. It is not // intended for machine processing. public static @string String(this OpKind k) => func((_, panic, __) => { if (k == Delete) { return("delete"); } else if (k == Insert) { return("insert"); } else if (k == Equal) { return("equal"); } else { panic("unknown operation kind"); } });
internal BaseOpSymb( OpKind opKind, int arity, Func <Node, List <Flag>, bool> validator, Func <TermIndex, Term[], Term[]> upApprox, Func <TermIndex, Term[], Term[]> downApprox, Func <Executer, Bindable[], Term> evaluator, Func <TermIndex, Term[], IEnumerable <Tuple <RelKind, Term, Term> > > appConstrainer = null) { Contract.Requires(validator != null && upApprox != null && downApprox != null); Contract.Requires(evaluator != null); OpKind = opKind; Validator = validator; UpwardApprox = upApprox; DownwardApprox = downApprox; Evaluator = evaluator; AppConstrainer = appConstrainer == null ? EmptyConstrainer : appConstrainer; this.arity = arity; }
public static MetricSpec <T> Define <T>(OpKind OpKind, NumericSystem NumSystem, NumericKind NumKind, OpVariance Variance, ByteSize OperandSize) where T : struct => new MetricSpec <T>(OpKind, NumSystem, NumKind, Variance, OperandSize);
//------------------------------------------------------------ // コンストラクタ。 public PostfixExpression(OpKind opKind, IExpression expr) { mOpKind = opKind; mFirstExpr = expr; }
public static MetricSpec Define(OpKind OpKind, NumericSystem NumSystem, NumericKind NumKind, PrimalKind OperandType, OpVariance Variance, ByteSize OperandSize) => new MetricSpec(OpKind, NumSystem, NumKind, OperandType, Variance, OperandSize);
public static MetricComparisonSpec DefineComparison <T>(this MetricKind Baseline, MetricKind Bench, OpKind Operator) where T : struct => MetricComparisonSpec.Define(Baseline, Bench, PrimalKinds.kind <T>(), Operator);
//------------------------------------------------------------ // コンストラクタ。 public UnaryOpExpression(OpKind aOpKind, IExpression aExpr) { mOpKind = aOpKind; mExpr = aExpr; }
public static IOpSig Define(NumericKind numKind, OpKind op, ParamSig operand, ParamSig ret) => new UnaryOpSig(numKind, op, operand, ret);
public static MetricComparisonSpec DefineComparison(this MetricKind Baseline, MetricKind Bench, PrimalKind Primitive, OpKind Operator) => MetricComparisonSpec.Define(Baseline, Bench, Primitive, Operator);
//------------------------------------------------------------ // コンストラクタ。 public UnaryOpExpression(Token aOpToken, OpKind aOpKind, IExpression aExpr) { mOpToken = aOpToken; mOpKind = aOpKind; mExpr = aExpr; }
public static bool IsImmediate(this OpKind opKind) => opKind >= OpKind.Immediate8 && opKind <= OpKind.Immediate32to64;
public OpType(OpKind op) { Primitive = PrimalKinds.kind <T>(); this.Op = op; }
public OpMetricAttribute(MetricKind Metric, OpKind Op) { this.Metric = Metric; this.Op = Op; }
public UnaryOpSig(NumericKind NumKind, OpKind Op, ParamSig Operand, ParamSig Return) : base(NumKind, Op, Return) { this.Operand = Operand; }
public OpSig(NumericKind NumKind, OpKind Op, ParamSig Return) { this.NumKind = NumKind; this.Op = Op; this.Return = Return; }
public static IOpSig Define(NumericKind numKind, OpKind op, ParamSig lhs, ParamSig rhs, ParamSig ret) => new BinaryOpSig(numKind, op, lhs, rhs, ret);
//------------------------------------------------------------ // コンストラクタ public BinaryOpExpression(OpKind aOpKind, IExpression aFirst, IExpression aSecond) { mOpKind = aOpKind; mFirst = aFirst; mSecond = aSecond; }
public MetricComparisonSpec(MetricKind Baseline, MetricKind Bench, PrimalKind Primitive, OpKind Operator) { this.BaseKind = Baseline; this.BenchKind = Bench; this.Primitive = Primitive; this.Operator = Operator; }
//------------------------------------------------------------ // コンストラクタ public AssignmentExpression(OpKind aOpKind, IExpression aLeftExpr, IExpression aRightExpr) { mOpKind = aOpKind; mLeftExpr = aLeftExpr; mRightExpr = aRightExpr; }
public static MetricId Define(MetricKind Classifier, PrimalKind Primitive, OpKind Operator) => new MetricId(Classifier, Primitive, Operator);
private static void Emit(OpKind kind, int immediate = 0, int len1 = 0, int len2 = 0) { prototypes.Add(new Opcode(kind, immediate, len1, len2)); }
public static MetricId Identify(this MetricKind metric, PrimalKind primitive, OpKind op) => MetricId.Define(metric, primitive, op);
static void ReadOpKind(DecoderTestCase tc, int operand, string value, out OpKind opKind, ref Register opRegister) { var parts = value.Split(opKindSeps); switch (parts[0]) { case OpKind_Register: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opRegister = ToRegister(parts[1]); opKind = OpKind.Register; break; case OpKind_NearBranch16: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.NearBranch16; tc.NearBranch = ToUInt16(parts[1]); break; case OpKind_NearBranch32: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.NearBranch32; tc.NearBranch = ToUInt32(parts[1]); break; case OpKind_NearBranch64: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.NearBranch64; tc.NearBranch = ToUInt64(parts[1]); break; case OpKind_FarBranch16: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.FarBranch16; tc.FarBranchSelector = ToUInt16(parts[1]); tc.FarBranch = ToUInt16(parts[2]); break; case OpKind_FarBranch32: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.FarBranch32; tc.FarBranchSelector = ToUInt16(parts[1]); tc.FarBranch = ToUInt32(parts[2]); break; case OpKind_Immediate8: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate8; tc.Immediate = ToUInt8(parts[1]); break; case OpKind_Immediate16: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate16; tc.Immediate = ToUInt16(parts[1]); break; case OpKind_Immediate32: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate32; tc.Immediate = ToUInt32(parts[1]); break; case OpKind_Immediate64: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate64; tc.Immediate = ToUInt64(parts[1]); break; case OpKind_Immediate8to16: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate8to16; tc.Immediate = ToUInt16(parts[1]); break; case OpKind_Immediate8to32: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate8to32; tc.Immediate = ToUInt32(parts[1]); break; case OpKind_Immediate8to64: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate8to64; tc.Immediate = ToUInt64(parts[1]); break; case OpKind_Immediate32to64: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate32to64; tc.Immediate = ToUInt64(parts[1]); break; case OpKind_Immediate8_2nd: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.Immediate8_2nd; tc.Immediate_2nd = ToUInt8(parts[1]); break; case OpKind_MemorySegSI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegSI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemorySegESI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegESI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemorySegRSI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegRSI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemorySegDI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegDI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemorySegEDI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegEDI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemorySegRDI: if (parts.Length != 3) { throw new InvalidOperationException($"Operand {operand}: expected 3 values, actual = {parts.Length}"); } opKind = OpKind.MemorySegRDI; tc.MemorySegment = ToRegister(parts[1]); tc.MemorySize = ToMemorySize(parts[2]); break; case OpKind_MemoryESDI: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.MemoryESDI; tc.MemorySize = ToMemorySize(parts[1]); break; case OpKind_MemoryESEDI: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.MemoryESEDI; tc.MemorySize = ToMemorySize(parts[1]); break; case OpKind_MemoryESRDI: if (parts.Length != 2) { throw new InvalidOperationException($"Operand {operand}: expected 2 values, actual = {parts.Length}"); } opKind = OpKind.MemoryESRDI; tc.MemorySize = ToMemorySize(parts[1]); break; case OpKind_Memory64: if (parts.Length != 4) { throw new InvalidOperationException($"Operand {operand}: expected 4 values, actual = {parts.Length}"); } opKind = OpKind.Memory64; tc.MemorySegment = ToRegister(parts[1]); tc.MemoryAddress64 = ToUInt64(parts[2]); tc.MemorySize = ToMemorySize(parts[3]); break; case OpKind_Memory: if (parts.Length != 8) { throw new InvalidOperationException($"Operand {operand}: expected 8 values, actual = {parts.Length}"); } opKind = OpKind.Memory; tc.MemorySegment = ToRegister(parts[1]); tc.MemoryBase = ToRegister(parts[2]); tc.MemoryIndex = ToRegister(parts[3]); tc.MemoryIndexScale = ToInt32(parts[4]); tc.MemoryDisplacement = ToUInt32(parts[5]); tc.MemoryDisplSize = ToInt32(parts[6]); tc.MemorySize = ToMemorySize(parts[7]); break; default: throw new InvalidOperationException($"Invalid opkind: '{parts[0]}'"); } }
public static MetricId Identify <T>(this MetricKind metric, OpKind op) where T : struct => MetricId.Define(metric, PrimalKinds.kind <T>(), op);
public Line(OpKind Kind = default, @string Content = default) { this.Kind = Kind; this.Content = Content; }
public static void Deconstruct(this MetricId metric, out MetricKind Classifier, out PrimalKind Primitive, out OpKind Operator) { Classifier = metric.Classifier; Primitive = metric.Primitive; Operator = metric.Operator; }