public ReadyToRunHelperKey(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { Id = id; Target = target; SignatureContext = signatureContext; }
public override ICompilation ToCompilation() { ModuleTokenResolver moduleTokenResolver = new ModuleTokenResolver(_compilationGroup, _context); SignatureContext signatureContext = new SignatureContext(_inputModule, moduleTokenResolver); CopiedCorHeaderNode corHeaderNode = new CopiedCorHeaderNode(_inputModule); AttributePresenceFilterNode attributePresenceFilterNode = null; // Core library attributes are checked FAR more often than other dlls // attributes, so produce a highly efficient table for determining if they are // present. Other assemblies *MAY* benefit from this feature, but it doesn't show // as useful at this time. if (_inputModule == _inputModule.Context.SystemModule) { attributePresenceFilterNode = new AttributePresenceFilterNode(_inputModule); } // Produce a ResourceData where the IBC PROFILE_DATA entry has been filtered out ResourceData win32Resources = new ResourceData(_inputModule, (object type, object name, ushort language) => { if (!(type is string) || !(name is string)) { return(true); } if (language != 0) { return(true); } string typeString = (string)type; string nameString = (string)name; if ((typeString == "IBC") && (nameString == "PROFILE_DATA")) { return(false); } return(true); }); ReadyToRunCodegenNodeFactory factory = new ReadyToRunCodegenNodeFactory( _context, _compilationGroup, _nameMangler, moduleTokenResolver, signatureContext, corHeaderNode, win32Resources, attributePresenceFilterNode); IComparer <DependencyNodeCore <NodeFactory> > comparer = new SortableDependencyNode.ObjectNodeComparer(new CompilerComparer()); DependencyAnalyzerBase <NodeFactory> graph = CreateDependencyGraph(factory, comparer); List <CorJitFlag> corJitFlags = new List <CorJitFlag> { CorJitFlag.CORJIT_FLAG_DEBUG_INFO }; switch (_optimizationMode) { case OptimizationMode.None: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_DEBUG_CODE); break; case OptimizationMode.PreferSize: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SIZE_OPT); break; case OptimizationMode.PreferSpeed: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SPEED_OPT); break; default: // Not setting a flag results in BLENDED_CODE. break; } if (_ibcTuning) { corJitFlags.Add(CorJitFlag.CORJIT_FLAG_BBINSTR); } corJitFlags.Add(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD); var jitConfig = new JitConfigProvider(corJitFlags, _ryujitOptions, _jitPath); return(new ReadyToRunCodegenCompilation( graph, factory, _compilationRoots, _ilProvider, _logger, new DependencyAnalysis.ReadyToRun.DevirtualizationManager(_compilationGroup), jitConfig, _inputFilePath, new ModuleDesc[] { _inputModule }, _resilient, _parallelism)); }
private ISymbolNode CreateFieldHandleHelper(FieldDesc field, SignatureContext signatureContext) { return(new PrecodeHelperImport( _codegenNodeFactory, new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle, field, signatureContext))); }
public ISortableSymbolNode MethodGenericDictionary(MethodDesc method, ModuleToken methodToken, SignatureContext signatureContext) { if (!_genericDictionaryCache.TryGetValue(method, out ISortableSymbolNode genericDictionary)) { genericDictionary = new PrecodeHelperMethodImport( _codegenNodeFactory, method, _codegenNodeFactory.MethodSignature( ReadyToRunFixupKind.READYTORUN_FIXUP_MethodDictionary, method, constrainedType: null, methodToken: methodToken, signatureContext: signatureContext, isUnboxingStub: false, isInstantiatingStub: true)); _genericDictionaryCache.Add(method, genericDictionary); } return(genericDictionary); }
public ISymbolNode GenericLookupHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunHelperId helperId, object helperArgument, TypeDesc constrainedType, GenericContext methodContext, SignatureContext signatureContext) { switch (helperId) { case ReadyToRunHelperId.TypeHandle: return(GenericLookupTypeHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_TypeHandle, helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.MethodHandle: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle, (MethodWithToken)helperArgument, constrainedType, methodContext, signatureContext)); case ReadyToRunHelperId.MethodEntry: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry, (MethodWithToken)helperArgument, constrainedType, methodContext, signatureContext)); case ReadyToRunHelperId.MethodDictionary: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle, (MethodWithToken)helperArgument, constrainedType, methodContext, signatureContext)); case ReadyToRunHelperId.TypeDictionary: return(GenericLookupTypeHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_TypeDictionary, (TypeDesc)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.VirtualDispatchCell: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry, (MethodWithToken)helperArgument, constrainedType, methodContext, signatureContext)); case ReadyToRunHelperId.FieldHandle: return(GenericLookupFieldHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle, (FieldDesc)helperArgument, methodContext, signatureContext)); default: throw new NotImplementedException(helperId.ToString()); } }
protected override JObject Process(string method, JArray _params) { switch (method) { case "getbalance": if (Program.Wallet == null) { throw new RpcException(-400, "Access denied."); } else { UInt256 assetId = UInt256.Parse(_params[0].AsString()); IEnumerable <Coin> coins = Program.Wallet.GetCoins().Where(p => !p.State.HasFlag(CoinState.Spent) && p.Output.AssetId.Equals(assetId)); JObject json = new JObject(); json["balance"] = coins.Sum(p => p.Output.Value).ToString(); json["confirmed"] = coins.Where(p => p.State.HasFlag(CoinState.Confirmed)).Sum(p => p.Output.Value).ToString(); return(json); } case "sendtoaddress": if (Program.Wallet == null) { throw new RpcException(-400, "Access denied"); } else { UInt256 assetId = UInt256.Parse(_params[0].AsString()); UInt160 scriptHash = Wallet.ToScriptHash(_params[1].AsString()); Fixed8 value = Fixed8.Parse(_params[2].AsString()); Fixed8 fee = _params.Count >= 4 ? Fixed8.Parse(_params[3].AsString()) : Fixed8.Zero; if (value <= Fixed8.Zero) { throw new RpcException(-32602, "Invalid params"); } ContractTransaction tx = Program.Wallet.MakeTransaction(new ContractTransaction { Outputs = new[] { new TransactionOutput { AssetId = assetId, Value = value, ScriptHash = scriptHash } } }, fee: fee); if (tx == null) { throw new RpcException(-300, "Insufficient funds"); } SignatureContext context = new SignatureContext(tx); Program.Wallet.Sign(context); if (context.Completed) { tx.Scripts = context.GetScripts(); Program.Wallet.SaveTransaction(tx); LocalNode.Relay(tx); return(tx.ToJson()); } else { return(context.ToJson()); } } default: return(base.Process(method, _params)); } }
public ISymbolNode InterfaceDispatchCell(MethodDesc method, ModuleToken methodToken, SignatureContext signatureContext, bool isUnboxingStub, string callSite) { MethodAndCallSite cellKey = new MethodAndCallSite(method, callSite); if (!_interfaceDispatchCells.TryGetValue(cellKey, out ISymbolNode dispatchCell)) { dispatchCell = new DelayLoadHelperMethodImport( _codegenNodeFactory, _codegenNodeFactory.DispatchImports, ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_MethodCall | ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_FLAG_VSD, new MethodWithToken(method, methodToken), useInstantiatingStub: false, _codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry, method, null, methodToken, isUnboxingStub, isInstantiatingStub: false, signatureContext), signatureContext, callSite); _interfaceDispatchCells.Add(cellKey, dispatchCell); } return(dispatchCell); }
public ISymbolNode FieldBaseOffset(TypeDesc typeDesc, SignatureContext signatureContext) { return(_fieldBaseOffsetCache.GetOrAdd(new TypeAndSignatureContext(typeDesc, signatureContext))); }
public ISymbolNode InterfaceDispatchCell(MethodWithToken method, SignatureContext signatureContext, bool isUnboxingStub, string callSite) { MethodAndCallSite cellKey = new MethodAndCallSite(method, isUnboxingStub, callSite, signatureContext); return(_interfaceDispatchCells.GetOrAdd(cellKey)); }
public TypeAndSignatureContext(TypeDesc typeDesc, SignatureContext signatureContext) { Type = typeDesc; SignatureContext = signatureContext; }
private void CreateNodeCaches() { _importStrings = new NodeCache <ModuleTokenAndSignatureContext, ISymbolNode>(key => { return(new StringImport(_codegenNodeFactory.StringImports, key.ModuleToken, key.SignatureContext)); }); _r2rHelpers = new NodeCache <ReadyToRunHelperKey, ISymbolNode>(CreateReadyToRunHelper); _fieldAddressCache = new NodeCache <FieldAndSignatureContext, ISymbolNode>(key => { return(new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ILCompiler.ReadyToRunHelper.DelayLoad_Helper, new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldAddress, key.Field, key.SignatureContext) )); }); _fieldOffsetCache = new NodeCache <FieldAndSignatureContext, ISymbolNode>(key => { return(new PrecodeHelperImport( _codegenNodeFactory, new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldOffset, key.Field, key.SignatureContext) )); }); _fieldBaseOffsetCache = new NodeCache <TypeAndSignatureContext, ISymbolNode>(key => { return(new PrecodeHelperImport( _codegenNodeFactory, _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldBaseOffset, key.Type, key.SignatureContext) )); }); _interfaceDispatchCells = new NodeCache <MethodAndCallSite, ISymbolNode>(cellKey => { return(new DelayLoadHelperMethodImport( _codegenNodeFactory, _codegenNodeFactory.DispatchImports, ILCompiler.ReadyToRunHelper.DelayLoad_MethodCall, cellKey.Method, useVirtualCall: true, useInstantiatingStub: false, _codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry, cellKey.Method, cellKey.IsUnboxingStub, isInstantiatingStub: false, cellKey.SignatureContext), cellKey.SignatureContext, cellKey.CallSite)); }); _delegateCtors = new NodeCache <TypeAndMethod, ISymbolNode>(ctorKey => { SignatureContext signatureContext = ctorKey.SignatureContext; IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint( ctorKey.Method, isUnboxingStub: false, isInstantiatingStub: false, isPrecodeImportRequired: false, signatureContext: signatureContext); return(new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ILCompiler.ReadyToRunHelper.DelayLoad_Helper, new DelegateCtorSignature(ctorKey.Type, targetMethodNode, ctorKey.Method.Token, signatureContext))); }); _genericLookupHelpers = new NodeCache <GenericLookupKey, ISymbolNode>(key => { return(new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ILCompiler.ReadyToRunHelper.DelayLoad_Helper, new GenericLookupSignature( key.LookupKind, key.FixupKind, key.TypeArgument, key.MethodArgument, key.FieldArgument, key.MethodContext, key.SignatureContext))); }); _indirectPInvokeTargetNodes = new NodeCache <IndirectPInvokeTargetKey, ISymbolNode>(key => { return(new PrecodeHelperImport( _codegenNodeFactory, _codegenNodeFactory.MethodSignature( ReadyToRunFixupKind.READYTORUN_FIXUP_IndirectPInvokeTarget, key.MethodWithToken, signatureContext: key.SignatureContext, isUnboxingStub: false, isInstantiatingStub: false))); }); }
public ISymbolNode FieldOffset(FieldDesc fieldDesc, SignatureContext signatureContext) { return(_fieldOffsetCache.GetOrAdd(new FieldAndSignatureContext(fieldDesc, signatureContext))); }
public FieldAndSignatureContext(FieldDesc fieldDesc, SignatureContext signatureContext) { Field = fieldDesc; SignatureContext = signatureContext; }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { return(_r2rHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target, signatureContext))); }
public DynamicHelperCellKey(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext) { Method = method; IsUnboxingStub = isUnboxingStub; IsInstantiatingStub = isInstantiatingStub; SignatureContext = signatureContext; }
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method, SignatureContext signatureContext) { TypeAndMethod ctorKey = new TypeAndMethod( delegateType, method, isUnboxingStub: false, isInstantiatingStub: false, isPrecodeImportRequired: false, signatureContext); return(_delegateCtors.GetOrAdd(ctorKey)); }
public ISymbolNode DynamicHelperCell(MethodWithToken methodWithToken, bool isInstantiatingStub, SignatureContext signatureContext) { DynamicHelperCellKey key = new DynamicHelperCellKey(methodWithToken, isUnboxingStub: false, isInstantiatingStub, signatureContext); return(_dynamicHelperCellCache.GetOrAdd(key)); }
public MethodAndCallSite(MethodWithToken method, bool isUnboxingStub, string callSite, SignatureContext signatureContext) { CallSite = callSite; IsUnboxingStub = isUnboxingStub; Method = method; SignatureContext = signatureContext; }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { if (!_r2rHelpers.TryGetValue(id, out Dictionary <object, ISymbolNode> helperNodeMap)) { helperNodeMap = new Dictionary <object, ISymbolNode>(); _r2rHelpers.Add(id, helperNodeMap); } if (helperNodeMap.TryGetValue(target, out ISymbolNode helperNode)) { return(helperNode); } switch (id) { case ReadyToRunHelperId.NewHelper: helperNode = CreateNewHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.NewArr1: helperNode = CreateNewArrayHelper((ArrayType)target, signatureContext); break; case ReadyToRunHelperId.GetGCStaticBase: helperNode = CreateGCStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetNonGCStaticBase: helperNode = CreateNonGCStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetThreadStaticBase: helperNode = CreateThreadGcStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetThreadNonGcStaticBase: helperNode = CreateThreadNonGcStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.IsInstanceOf: helperNode = CreateIsInstanceOfHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.CastClass: helperNode = CreateCastClassHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.TypeHandle: helperNode = CreateTypeHandleHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.MethodHandle: helperNode = CreateMethodHandleHelper((MethodWithToken)target, signatureContext); break; case ReadyToRunHelperId.FieldHandle: helperNode = CreateFieldHandleHelper((FieldDesc)target, signatureContext); break; case ReadyToRunHelperId.VirtualCall: helperNode = CreateVirtualCallHelper((MethodWithToken)target, signatureContext); break; case ReadyToRunHelperId.DelegateCtor: helperNode = CreateDelegateCtorHelper((DelegateCreationInfo)target, signatureContext); break; case ReadyToRunHelperId.CctorTrigger: helperNode = CreateCctorTrigger((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.TypeDictionary: helperNode = CreateTypeDictionary((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.MethodDictionary: helperNode = CreateMethodDictionary((MethodWithToken)target, signatureContext); break; default: throw new NotImplementedException(id.ToString()); } helperNodeMap.Add(target, helperNode); return(helperNode); }
public IndirectPInvokeTargetKey(MethodWithToken methodWithToken, SignatureContext signatureContext) { MethodWithToken = methodWithToken; SignatureContext = signatureContext; }
public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId helperId, object entity, SignatureContext signatureContext) { return(ReadyToRunHelper(helperId, entity, signatureContext)); }
public ISymbolNode GetIndirectPInvokeTargetNode(MethodWithToken methodWithToken, SignatureContext signatureContext) { return(_indirectPInvokeTargetNodes.GetOrAdd(new IndirectPInvokeTargetKey(methodWithToken, signatureContext))); }
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodDesc targetMethod, ModuleToken methodToken, SignatureContext signatureContext) { TypeAndMethod ctorKey = new TypeAndMethod(delegateType, targetMethod, methodToken: methodToken, isUnboxingStub: false, isInstantiatingStub: false); if (!_delegateCtors.TryGetValue(ctorKey, out ISymbolNode ctorNode)) { IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint( targetMethod, constrainedType: null, originalMethod: null, methodToken: methodToken, isUnboxingStub: false, isInstantiatingStub: false, signatureContext: signatureContext); ctorNode = new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_Helper, new DelegateCtorSignature(delegateType, targetMethodNode, methodToken, signatureContext)); _delegateCtors.Add(ctorKey, ctorNode); } return(ctorNode); }
private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken targetMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext) { Debug.Assert(CompilationModuleGroup.ContainsMethodBody(targetMethod.Method, false)); MethodDesc localMethod = targetMethod.Method.GetCanonMethodTarget(CanonicalFormKind.Specific); TypeAndMethod localMethodKey = new TypeAndMethod(localMethod.OwningType, new MethodWithToken(localMethod, default(ModuleToken), constrainedType: null), isUnboxingStub: false, isInstantiatingStub: false, isPrecodeImportRequired: false, signatureContext); return(_localMethodCache.GetOrAdd(localMethodKey)); }
public override ICompilation ToCompilation() { ModuleTokenResolver moduleTokenResolver = new ModuleTokenResolver(_compilationGroup, _context); SignatureContext signatureContext = new SignatureContext(_inputModule, moduleTokenResolver); CopiedCorHeaderNode corHeaderNode = new CopiedCorHeaderNode(_inputModule); // Produce a ResourceData where the IBC PROFILE_DATA entry has been filtered out ResourceData win32Resources = new ResourceData(_inputModule, (object type, object name, ushort language) => { if (!(type is string) || !(name is string)) { return(true); } if (language != 0) { return(true); } string typeString = (string)type; string nameString = (string)name; if ((typeString == "IBC") && (nameString == "PROFILE_DATA")) { return(false); } return(true); }); ReadyToRunCodegenNodeFactory factory = new ReadyToRunCodegenNodeFactory( _context, _compilationGroup, _nameMangler, moduleTokenResolver, signatureContext, corHeaderNode, win32Resources); DependencyAnalyzerBase <NodeFactory> graph = CreateDependencyGraph(factory); List <CorJitFlag> corJitFlags = new List <CorJitFlag> { CorJitFlag.CORJIT_FLAG_DEBUG_INFO }; switch (_optimizationMode) { case OptimizationMode.None: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_DEBUG_CODE); break; case OptimizationMode.PreferSize: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SIZE_OPT); break; case OptimizationMode.PreferSpeed: corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SPEED_OPT); break; default: // Not setting a flag results in BLENDED_CODE. break; } if (_ibcTuning) { corJitFlags.Add(CorJitFlag.CORJIT_FLAG_BBINSTR); } corJitFlags.Add(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD); var jitConfig = new JitConfigProvider(corJitFlags, _ryujitOptions); return(new ReadyToRunCodegenCompilation( graph, factory, _compilationRoots, _ilProvider, _logger, new DependencyAnalysis.ReadyToRun.DevirtualizationManager(_compilationGroup), jitConfig, _inputFilePath, new ModuleDesc[] { _inputModule }, _resilient)); }
public TypeFixupKey(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext) { FixupKind = fixupKind; TypeDesc = typeDesc; SignatureContext = signatureContext; }
private ISymbolNode CreateTypeHandleHelper(TypeDesc type, SignatureContext signatureContext) { return(new PrecodeHelperImport( _codegenNodeFactory, _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_TypeHandle, type, signatureContext))); }
public TypeFixupSignature TypeSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext) { TypeFixupKey fixupKey = new TypeFixupKey(fixupKind, typeDesc, signatureContext); return(_typeSignatures.GetOrAdd(fixupKey)); }
private ISymbolNode CreateDelegateCtorHelper(DelegateCreationInfo info, SignatureContext signatureContext) { return(info.Constructor); }
public ISymbolNode StringLiteral(ModuleToken moduleToken, SignatureContext signatureContext) { return(_importStrings.GetOrAdd(new ModuleTokenAndSignatureContext(moduleToken, signatureContext))); }