private static async Task <DfirRoot> GenerateDfirAsync( ICompositionHost host, Envoy documentEnvoy, ProgressToken progressToken, CompileCancellationToken compileCancellationToken) { ExtendedQualifiedName topLevelDocumentName = documentEnvoy.CreateExtendedQualifiedName(); TargetCompiler targetCompiler = documentEnvoy.QueryInheritedService <ITargetCompilerServices>().First().Compiler; AnyMocCompiler compiler = host.GetSharedExportedValue <AnyMocCompiler>(); IReadOnlySymbolTable symbolTable = documentEnvoy.ComputeSymbolTable(); // A specAndQName is used by the compiler to identify the document for which we're asking for DFIR. var specAndQName = new SpecAndQName(targetCompiler.CreateDefaultBuildSpec(topLevelDocumentName, symbolTable), topLevelDocumentName); try { DfirRoot sourceDfirRoot = await compiler.GetTargetDfirAsync(specAndQName, compileCancellationToken, progressToken); if (sourceDfirRoot == null) { await ShowErrorMessageBoxAsync(host, WaitForCompileErrorMessageBoxText); } return(sourceDfirRoot); } catch { await ShowErrorMessageBoxAsync(host, DfirGenerationErrorMessageBoxText); return(null); } }
/// <inheritdoc /> public override async Task <Tuple <CompileCacheEntry, CompileSignature> > BackEndCompileAsyncCore( SpecAndQName specAndQName, DfirRoot targetDfir, CompileCancellationToken cancellationToken, ProgressToken progressToken, CompileThreadState compileThreadState) { CompileSignature topSignature = new CompileSignature( targetDfir.Name, Enumerable.Empty <CompileSignatureParameter>(), // GenerateParameters(targetDfir), targetDfir.GetDeclaringType(), targetDfir.Reentrancy, true, true, ThreadAffinity.Standard, false, true, ExecutionPriority.Normal, CallingConvention.StdCall); BuildSpec htmlVIBuildSpec = specAndQName.BuildSpec; foreach (var dependency in targetDfir.Dependencies.OfType <CompileInvalidationDfirDependency>().ToList()) { var compileSignature = await Compiler.GetCompileSignatureAsync(dependency.SpecAndQName, cancellationToken, progressToken, compileThreadState); if (compileSignature != null) { targetDfir.AddDependency( targetDfir, new CompileSignatureDependency(dependency.SpecAndQName, compileSignature)); } } IBuiltPackage builtPackage = null; if (!RebarFeatureToggles.IsLLVMCompilerEnabled) { Function compiledFunction = CompileFunctionForBytecodeInterpreter(targetDfir, cancellationToken); builtPackage = new FunctionBuiltPackage(specAndQName, Compiler.TargetName, compiledFunction); } else { Module compiledFunctionModule = CompileFunctionForLLVM(targetDfir, cancellationToken); builtPackage = new LLVM.FunctionBuiltPackage(specAndQName, Compiler.TargetName, compiledFunctionModule); } BuiltPackageToken token = Compiler.AddToBuiltPackagesCache(builtPackage); CompileCacheEntry entry = await Compiler.CreateStandardCompileCacheEntryFromDfirRootAsync( CompileState.Complete, targetDfir, new Dictionary <ExtendedQualifiedName, CompileSignature>(), token, cancellationToken, progressToken, compileThreadState, false); return(new Tuple <CompileCacheEntry, CompileSignature>(entry, topSignature)); }
public FunctionBuiltPackage( SpecAndQName identity, QualifiedName targetIdentity, Module module) { RuntimeEntityIdentity = identity; TargetIdentity = targetIdentity; Module = module; }
public FunctionBuiltPackage( SpecAndQName identity, QualifiedName targetIdentity, Function function) { RuntimeEntityIdentity = identity; TargetIdentity = targetIdentity; Function = function; }
/// <summary> /// Returns a dictionary that maps subVI names of method calls in the source <see cref="DfirRoot"/> to /// the corresponding <see cref="DfirRoot"/> objects. /// </summary> /// <param name="sourceDfirRoot">The parent document that does the method call</param> /// <param name="nameDictionary">The dictionary to fill out with names to dfir maps.</param> /// <param name="compileCancellationToken">The cancellation token</param> /// <param name="progressToken">The progress token</param> /// <param name="host">The composition host</param> /// <returns>The task to wait on</returns> private static async Task GetSubDfirRootsAsync( DfirRoot sourceDfirRoot, IDictionary <ExtendedQualifiedName, DfirRoot> nameDictionary, CompileCancellationToken compileCancellationToken, ProgressToken progressToken, ICompositionHost host) { if (sourceDfirRoot == null) { return; } // Maintain a queue of VIs to visit, and visit each one. var rootsToProcess = new Queue <DfirRoot>(); // Add the top-level VI to the queue so it is visited first. rootsToProcess.Enqueue(sourceDfirRoot); while (rootsToProcess.Count > 0) { DfirRoot root = rootsToProcess.Dequeue(); foreach (MethodCall node in root.BlockDiagram.GetAllNodes().OfType <MethodCall>()) { var specAndQName = new SpecAndQName(node.TargetBuildSpec, node.TargetName); var compiler = host.GetSharedExportedValue <AnyMocCompiler>(); DfirRoot subDfirRoot; try { subDfirRoot = await compiler.GetTargetDfirAsync(specAndQName, compileCancellationToken, progressToken); RemoveDebugPoints(subDfirRoot, compileCancellationToken); } catch { await ShowErrorMessageBoxAsync(host, DfirGenerationErrorMessageBoxText); return; } if (subDfirRoot == null) { continue; } if (nameDictionary.ContainsKey(node.TargetName)) { // If the subVI has already been visited, then don't enqueue it to be visited again. continue; } // The subVI has not been visited. Add the subVI to the queue of VIs to visit. nameDictionary[node.TargetName] = subDfirRoot; rootsToProcess.Enqueue(subDfirRoot); } } }
public FunctionMocReflector( IReflectableModel source, ReflectionCancellationToken reflectionCancellationToken, IScheduledActivityManager scheduledActivityManager, IMessageDescriptorTranslator additionalErrorTexts, Envoy buildSpecSource, SpecAndQName specAndQName, DfirModelMap map) : base(source, reflectionCancellationToken, scheduledActivityManager, additionalErrorTexts, buildSpecSource, specAndQName) { _map = map; }
public override MocTransformManager GenerateMocTransformManager(SpecAndQName specAndQName, DfirRoot sourceDfir, CompileCancellationToken cancellationToken) { TerminalTypeUnificationResults unificationResults = new TerminalTypeUnificationResults(); LifetimeVariableAssociation lifetimeVariableAssociation = new LifetimeVariableAssociation(); List <IDfirTransformBase> semanticAnalysisTransforms = new List <IDfirTransformBase>() { new CreateNodeFacadesTransform(), new MergeVariablesAcrossWiresTransform(lifetimeVariableAssociation, unificationResults), new FinalizeAutoBorrowsTransform(), new MarkConsumedVariablesTransform(lifetimeVariableAssociation), new ValidateVariableUsagesTransform(unificationResults), new ReflectVariablesToTerminalsTransform(), }; if (RebarFeatureToggles.IsRebarTargetEnabled) { semanticAnalysisTransforms.Add(new RebarSupportedTargetTransform()); } semanticAnalysisTransforms.Add(new StandardTypeReflectionTransform()); ReflectErrorsTransform.AddErrorReflection(semanticAnalysisTransforms, CompilePhase.SemanticAnalysis); if (!RebarFeatureToggles.IsRebarTargetEnabled) { semanticAnalysisTransforms.Add(new EmptyTargetDfirTransform()); } List <IDfirTransformBase> toTargetDfirTransforms = new List <IDfirTransformBase>() { new AutoBorrowTransform(lifetimeVariableAssociation), new InsertTerminateLifetimeTransform(lifetimeVariableAssociation), new InsertDropTransform(lifetimeVariableAssociation), }; return(new StandardMocTransformManager( specAndQName, sourceDfir, semanticAnalysisTransforms, toTargetDfirTransforms, _host.GetSharedExportedValue <ScheduledActivityManager>())); }
/// <summary> /// Base constructor of <see cref="ApplicationComponentMocReflector"/> /// </summary> /// <param name="source">An interface allowing the reflector to talk to the source model</param> /// <param name="reflectionCancellationToken">A token to poll for whether to do reflection or not</param> /// <param name="scheduledActivityManager">The activity used to flip over into the UI thread as needed to do reflections</param> /// <param name="additionalErrorTexts">Supplies third-party message descriptions for this MoC</param> /// <param name="buildSpecSource">Source of the BuildSpec for which to reflect messages</param> /// <param name="specAndQName">The <see cref="SpecAndQName"/> for which to reflect messages</param> internal ApplicationComponentMocReflector(IReflectableModel source, ReflectionCancellationToken reflectionCancellationToken, IScheduledActivityManager scheduledActivityManager, IMessageDescriptorTranslator additionalErrorTexts, Envoy buildSpecSource, SpecAndQName specAndQName) : base(source, reflectionCancellationToken, scheduledActivityManager, additionalErrorTexts, buildSpecSource, specAndQName) { }
public override MocReflector CreateMocReflector(ICompilableModel source, ReflectionCancellationToken reflectionCancellationToken, Envoy buildSpecSource, SpecAndQName specAndQName) { return(new ApplicationComponentMocReflector( source, reflectionCancellationToken, ScheduledActivityManager, AdditionalErrorTexts, buildSpecSource, specAndQName)); }
/// <inheritdoc /> public Task <CompileInformation> GetCompileInformation(SpecAndQName itemSpecAndQName, CompileCancellationToken cancellationToken, ProgressToken progressToken, CompileThreadState compileThreadState) { return(Compiler.CompileAsTopLevel(itemSpecAndQName, cancellationToken, progressToken, compileThreadState)); }
/// <inheritdoc /> protected override IBuiltPackage CreateExecutionBuiltPackage(SpecAndQName specAndQName, string absoluteDirectoryForComponent, IEnumerable <IFileBuilder> builders, ComponentBuildResult componentBuildResult) { throw new NotImplementedException(); }