| // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| part of ssa; |
| |
| class SsaFunctionCompiler implements FunctionCompiler { |
| SsaCodeGeneratorTask generator; |
| SsaBuilderTask builder; |
| SsaOptimizerTask optimizer; |
| |
| SsaFunctionCompiler(JavaScriptBackend backend, bool generateSourceMap) |
| : generator = new SsaCodeGeneratorTask(backend), |
| builder = new SsaBuilderTask(backend, generateSourceMap), |
| optimizer = new SsaOptimizerTask(backend); |
| |
| /// Generates JavaScript code for `work.element`. |
| /// Using the ssa builder, optimizer and codegenerator. |
| js.Fun compile(CodegenWorkItem work) { |
| HGraph graph = builder.build(work); |
| optimizer.optimize(work, graph); |
| return generator.generateCode(work, graph); |
| } |
| |
| Iterable<CompilerTask> get tasks { |
| return <CompilerTask>[builder, optimizer, generator]; |
| } |
| } |
| |
| /// A synthetic local variable only used with the SSA graph. |
| /// |
| /// For instance used for holding return value of function or the exception of a |
| /// try-catch statement. |
| class SyntheticLocal extends Local { |
| final String name; |
| final ExecutableElement executableContext; |
| |
| SyntheticLocal(this.name, this.executableContext); |
| } |
| |
| class SsaBuilderTask extends CompilerTask { |
| final CodeEmitterTask emitter; |
| final JavaScriptBackend backend; |
| final bool generateSourceMap; |
| |
| String get name => 'SSA builder'; |
| |
| SsaBuilderTask(JavaScriptBackend backend, this.generateSourceMap) |
| : emitter = backend.emitter, |
| backend = backend, |
| super(backend.compiler); |
| |
| HGraph build(CodegenWorkItem work) { |
| return measure(() { |
| Element element = work.element.implementation; |
| return compiler.withCurrentElement(element, () { |
| HInstruction.idCounter = 0; |
| SsaBuilder builder = |
| new SsaBuilder( |
| backend, work, emitter.nativeEmitter, generateSourceMap); |
| HGraph graph; |
| ElementKind kind = element.kind; |
| if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) { |
| graph = compileConstructor(builder, work); |
| } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY || |
| kind == ElementKind.FUNCTION || |
| kind == ElementKind.GETTER || |
| kind == ElementKind.SETTER) { |
| graph = builder.buildMethod(element); |
| } else if (kind == ElementKind.FIELD) { |
| if (element.isInstanceMember) { |
| assert(compiler.enableTypeAssertions); |
| graph = builder.buildCheckedSetter(element); |
| } else { |
| graph = builder.buildLazyInitializer(element); |
| } |
| } else { |
| compiler.internalError(element, 'Unexpected element kind $kind.'); |
| } |
| assert(graph.isValid()); |
| if (!identical(kind, ElementKind.FIELD)) { |
| FunctionElement function = element; |
| FunctionSignature signature = function.functionSignature; |
| signature.forEachOptionalParameter((ParameterElement parameter) { |
| // This ensures the default value will be computed. |
| ConstantValue constant = |
| backend.constants.getConstantForVariable(parameter).value; |
| CodegenRegistry registry = work.registry; |
| registry.registerCompileTimeConstant(constant); |
| }); |
| } |
| if (compiler.tracer.isEnabled) { |
| String name; |
| if (element.isClassMember) { |
| String className = element.enclosingClass.name; |
| String memberName = element.name; |
| name = "$className.$memberName"; |
| if (element.isGenerativeConstructorBody) { |
| name = "$name (body)"; |
| } |
| } else { |
| name = "${element.name}"; |
| } |
| compiler.tracer.traceCompilation( |
| name, work.compilationContext); |
| compiler.tracer.traceGraph('builder', graph); |
| } |
| return graph; |
| }); |
| }); |
| } |
| |
| HGraph compileConstructor(SsaBuilder builder, CodegenWorkItem work) { |
| return builder.buildFactory(work.element); |
| } |
| } |
| |
| /** |
| * Keeps track of locals (including parameters and phis) when building. The |
| * 'this' reference is treated as parameter and hence handled by this class, |
| * too. |
| */ |
| class LocalsHandler { |
| /** |
| * The values of locals that can be directly accessed (without redirections |
| * to boxes or closure-fields). |
| * |
| * [directLocals] is iterated, so it is "insertion ordered" to make the |
| * iteration order a function only of insertions and not a function of |
| * e.g. Element hash codes. I'd prefer to use a SortedMap but some elements |
| * don't have source locations for [Elements.compareByPosition]. |
| */ |
| Map<Local, HInstruction> directLocals = |
| new Map<Local, HInstruction>(); |
| Map<Local, CapturedVariable> redirectionMapping = |
| new Map<Local, CapturedVariable>(); |
| SsaBuilder builder; |
| ClosureClassMap closureData; |
| Map<TypeVariableType, TypeVariableLocal> typeVariableLocals = |
| new Map<TypeVariableType, TypeVariableLocal>(); |
| final ExecutableElement executableContext; |
| |
| /// The class that defines the current type environment or null if no type |
| /// variables are in scope. |
| ClassElement get contextClass => executableContext.contextClass; |
| |
| LocalsHandler(this.builder, this.executableContext); |
| |
| /// Substituted type variables occurring in [type] into the context of |
| /// [contextClass]. |
| DartType substInContext(DartType type) { |
| if (contextClass != null) { |
| ClassElement typeContext = Types.getClassContext(type); |
| if (typeContext != null) { |
| type = type.substByContext( |
| contextClass.asInstanceOf(typeContext)); |
| } |
| } |
| return type; |
| } |
| |
| get typesTask => builder.compiler.typesTask; |
| |
| /** |
| * Creates a new [LocalsHandler] based on [other]. We only need to |
| * copy the [directLocals], since the other fields can be shared |
| * throughout the AST visit. |
| */ |
| LocalsHandler.from(LocalsHandler other) |
| : directLocals = new Map<Local, HInstruction>.from(other.directLocals), |
| redirectionMapping = other.redirectionMapping, |
| executableContext = other.executableContext, |
| builder = other.builder, |
| closureData = other.closureData; |
| |
| /** |
| * Redirects accesses from element [from] to element [to]. The [to] element |
| * must be a boxed variable or a variable that is stored in a closure-field. |
| */ |
| void redirectElement(Local from, CapturedVariable to) { |
| assert(redirectionMapping[from] == null); |
| redirectionMapping[from] = to; |
| assert(isStoredInClosureField(from) || isBoxed(from)); |
| } |
| |
| HInstruction createBox() { |
| // TODO(floitsch): Clean up this hack. Should we create a box-object by |
| // just creating an empty object literal? |
| JavaScriptBackend backend = builder.backend; |
| HInstruction box = new HForeign(js.js.parseForeignJS('{}'), |
| backend.nonNullType, |
| <HInstruction>[]); |
| builder.add(box); |
| return box; |
| } |
| |
| /** |
| * If the scope (function or loop) [node] has captured variables then this |
| * method creates a box and sets up the redirections. |
| */ |
| void enterScope(ast.Node node, Element element) { |
| // See if any variable in the top-scope of the function is captured. If yes |
| // we need to create a box-object. |
| ClosureScope scopeData = closureData.capturingScopes[node]; |
| if (scopeData == null) return; |
| HInstruction box; |
| // The scope has captured variables. |
| if (element != null && element.isGenerativeConstructorBody) { |
| // The box is passed as a parameter to a generative |
| // constructor body. |
| JavaScriptBackend backend = builder.backend; |
| box = builder.addParameter(scopeData.boxElement, backend.nonNullType); |
| } else { |
| box = createBox(); |
| } |
| // Add the box to the known locals. |
| directLocals[scopeData.boxElement] = box; |
| // Make sure that accesses to the boxed locals go into the box. We also |
| // need to make sure that parameters are copied into the box if necessary. |
| scopeData.forEachCapturedVariable( |
| (LocalVariableElement from, BoxFieldElement to) { |
| // The [from] can only be a parameter for function-scopes and not |
| // loop scopes. |
| if (from.isParameter && !element.isGenerativeConstructorBody) { |
| // Now that the redirection is set up, the update to the local will |
| // write the parameter value into the box. |
| // Store the captured parameter in the box. Get the current value |
| // before we put the redirection in place. |
| // We don't need to update the local for a generative |
| // constructor body, because it receives a box that already |
| // contains the updates as the last parameter. |
| HInstruction instruction = readLocal(from); |
| redirectElement(from, to); |
| updateLocal(from, instruction); |
| } else { |
| redirectElement(from, to); |
| } |
| }); |
| } |
| |
| /** |
| * Replaces the current box with a new box and copies over the given list |
| * of elements from the old box into the new box. |
| */ |
| void updateCaptureBox(BoxLocal boxElement, |
| List<LocalVariableElement> toBeCopiedElements) { |
| // Create a new box and copy over the values from the old box into the |
| // new one. |
| HInstruction oldBox = readLocal(boxElement); |
| HInstruction newBox = createBox(); |
| for (LocalVariableElement boxedVariable in toBeCopiedElements) { |
| // [readLocal] uses the [boxElement] to find its box. By replacing it |
| // behind its back we can still get to the old values. |
| updateLocal(boxElement, oldBox); |
| HInstruction oldValue = readLocal(boxedVariable); |
| updateLocal(boxElement, newBox); |
| updateLocal(boxedVariable, oldValue); |
| } |
| updateLocal(boxElement, newBox); |
| } |
| |
| /** |
| * Documentation wanted -- johnniwinther |
| * |
| * Invariant: [function] must be an implementation element. |
| */ |
| void startFunction(Element element, ast.Node node) { |
| assert(invariant(element, element.isImplementation)); |
| Compiler compiler = builder.compiler; |
| closureData = compiler.closureToClassMapper.computeClosureToClassMapping( |
| element, node, builder.elements); |
| |
| if (element is FunctionElement) { |
| FunctionElement functionElement = element; |
| FunctionSignature params = functionElement.functionSignature; |
| ClosureScope scopeData = closureData.capturingScopes[node]; |
| params.orderedForEachParameter((ParameterElement parameterElement) { |
| if (element.isGenerativeConstructorBody) { |
| if (scopeData != null && |
| scopeData.isCapturedVariable(parameterElement)) { |
| // The parameter will be a field in the box passed as the |
| // last parameter. So no need to have it. |
| return; |
| } |
| } |
| HInstruction parameter = builder.addParameter( |
| parameterElement, |
| TypeMaskFactory.inferredTypeForElement(parameterElement, compiler)); |
| builder.parameters[parameterElement] = parameter; |
| directLocals[parameterElement] = parameter; |
| }); |
| } |
| |
| enterScope(node, element); |
| |
| // If the freeVariableMapping is not empty, then this function was a |
| // nested closure that captures variables. Redirect the captured |
| // variables to fields in the closure. |
| closureData.forEachFreeVariable((Local from, CapturedVariable to) { |
| redirectElement(from, to); |
| }); |
| JavaScriptBackend backend = compiler.backend; |
| if (closureData.isClosure) { |
| // Inside closure redirect references to itself to [:this:]. |
| HThis thisInstruction = new HThis(closureData.thisLocal, |
| backend.nonNullType); |
| builder.graph.thisInstruction = thisInstruction; |
| builder.graph.entry.addAtEntry(thisInstruction); |
| updateLocal(closureData.closureElement, thisInstruction); |
| } else if (element.isInstanceMember) { |
| // Once closures have been mapped to classes their instance members might |
| // not have any thisElement if the closure was created inside a static |
| // context. |
| HThis thisInstruction = new HThis( |
| closureData.thisLocal, builder.getTypeOfThis()); |
| builder.graph.thisInstruction = thisInstruction; |
| builder.graph.entry.addAtEntry(thisInstruction); |
| directLocals[closureData.thisLocal] = thisInstruction; |
| } |
| |
| // If this method is an intercepted method, add the extra |
| // parameter to it, that is the actual receiver for intercepted |
| // classes, or the same as [:this:] for non-intercepted classes. |
| ClassElement cls = element.enclosingClass; |
| |
| // When the class extends a native class, the instance is pre-constructed |
| // and passed to the generative constructor factory function as a parameter. |
| // Instead of allocating and initializing the object, the constructor |
| // 'upgrades' the native subclass object by initializing the Dart fields. |
| bool isNativeUpgradeFactory = element.isGenerativeConstructor |
| && Elements.isNativeOrExtendsNative(cls); |
| if (backend.isInterceptedMethod(element)) { |
| bool isInterceptorClass = backend.isInterceptorClass(cls.declaration); |
| String name = isInterceptorClass ? 'receiver' : '_'; |
| SyntheticLocal parameter = new SyntheticLocal(name, executableContext); |
| HParameterValue value = |
| new HParameterValue(parameter, builder.getTypeOfThis()); |
| builder.graph.explicitReceiverParameter = value; |
| builder.graph.entry.addAfter( |
| directLocals[closureData.thisLocal], value); |
| if (isInterceptorClass) { |
| // Only use the extra parameter in intercepted classes. |
| directLocals[closureData.thisLocal] = value; |
| } |
| } else if (isNativeUpgradeFactory) { |
| SyntheticLocal parameter = |
| new SyntheticLocal('receiver', executableContext); |
| // Unlike `this`, receiver is nullable since direct calls to generative |
| // constructor call the constructor with `null`. |
| ClassWorld classWorld = compiler.world; |
| HParameterValue value = |
| new HParameterValue(parameter, new TypeMask.exact(cls, classWorld)); |
| builder.graph.explicitReceiverParameter = value; |
| builder.graph.entry.addAtEntry(value); |
| } |
| } |
| |
| /** |
| * Returns true if the local can be accessed directly. Boxed variables or |
| * captured variables that are stored in the closure-field return [:false:]. |
| */ |
| bool isAccessedDirectly(Local local) { |
| assert(local != null); |
| return !redirectionMapping.containsKey(local) |
| && !closureData.usedVariablesInTry.contains(local); |
| } |
| |
| bool isStoredInClosureField(Local local) { |
| assert(local != null); |
| if (isAccessedDirectly(local)) return false; |
| CapturedVariable redirectTarget = redirectionMapping[local]; |
| if (redirectTarget == null) return false; |
| return redirectTarget is ClosureFieldElement; |
| } |
| |
| bool isBoxed(Local local) { |
| if (isAccessedDirectly(local)) return false; |
| if (isStoredInClosureField(local)) return false; |
| return redirectionMapping.containsKey(local); |
| } |
| |
| bool isUsedInTry(Local local) { |
| return closureData.usedVariablesInTry.contains(local); |
| } |
| |
| /** |
| * Returns an [HInstruction] for the given element. If the element is |
| * boxed or stored in a closure then the method generates code to retrieve |
| * the value. |
| */ |
| HInstruction readLocal(Local local) { |
| if (isAccessedDirectly(local)) { |
| if (directLocals[local] == null) { |
| if (local is TypeVariableElement) { |
| builder.compiler.internalError(builder.compiler.currentElement, |
| "Runtime type information not available for $local."); |
| } else { |
| builder.compiler.internalError(local, |
| "Cannot find value $local."); |
| } |
| } |
| return directLocals[local]; |
| } else if (isStoredInClosureField(local)) { |
| ClosureFieldElement redirect = redirectionMapping[local]; |
| HInstruction receiver = readLocal(closureData.closureElement); |
| TypeMask type = local is BoxLocal |
| ? builder.backend.nonNullType |
| : builder.getTypeOfCapturedVariable(redirect); |
| HInstruction fieldGet = new HFieldGet(redirect, receiver, type); |
| builder.add(fieldGet); |
| return fieldGet; |
| } else if (isBoxed(local)) { |
| BoxFieldElement redirect = redirectionMapping[local]; |
| // In the function that declares the captured variable the box is |
| // accessed as direct local. Inside the nested closure the box is |
| // accessed through a closure-field. |
| // Calling [readLocal] makes sure we generate the correct code to get |
| // the box. |
| HInstruction box = readLocal(redirect.box); |
| HInstruction lookup = new HFieldGet( |
| redirect, box, builder.getTypeOfCapturedVariable(redirect)); |
| builder.add(lookup); |
| return lookup; |
| } else { |
| assert(isUsedInTry(local)); |
| HLocalValue localValue = getLocal(local); |
| HInstruction instruction = new HLocalGet( |
| local, localValue, builder.backend.dynamicType); |
| builder.add(instruction); |
| return instruction; |
| } |
| } |
| |
| HInstruction readThis() { |
| HInstruction res = readLocal(closureData.thisLocal); |
| if (res.instructionType == null) { |
| res.instructionType = builder.getTypeOfThis(); |
| } |
| return res; |
| } |
| |
| HLocalValue getLocal(Local local) { |
| // If the element is a parameter, we already have a |
| // HParameterValue for it. We cannot create another one because |
| // it could then have another name than the real parameter. And |
| // the other one would not know it is just a copy of the real |
| // parameter. |
| if (local is ParameterElement) return builder.parameters[local]; |
| |
| return builder.activationVariables.putIfAbsent(local, () { |
| JavaScriptBackend backend = builder.backend; |
| HLocalValue localValue = new HLocalValue(local, backend.nonNullType); |
| builder.graph.entry.addAtExit(localValue); |
| return localValue; |
| }); |
| } |
| |
| Local getTypeVariableAsLocal(TypeVariableType type) { |
| return typeVariableLocals.putIfAbsent(type, () { |
| return new TypeVariableLocal(type, executableContext); |
| }); |
| } |
| |
| /** |
| * Sets the [element] to [value]. If the element is boxed or stored in a |
| * closure then the method generates code to set the value. |
| */ |
| void updateLocal(Local local, HInstruction value) { |
| assert(!isStoredInClosureField(local)); |
| if (isAccessedDirectly(local)) { |
| directLocals[local] = value; |
| } else if (isBoxed(local)) { |
| BoxFieldElement redirect = redirectionMapping[local]; |
| // The box itself could be captured, or be local. A local variable that |
| // is captured will be boxed, but the box itself will be a local. |
| // Inside the closure the box is stored in a closure-field and cannot |
| // be accessed directly. |
| HInstruction box = readLocal(redirect.box); |
| builder.add(new HFieldSet(redirect, box, value)); |
| } else { |
| assert(isUsedInTry(local)); |
| HLocalValue localValue = getLocal(local); |
| builder.add(new HLocalSet(local, localValue, value)); |
| } |
| } |
| |
| /** |
| * This function, startLoop, must be called before visiting any children of |
| * the loop. In particular it needs to be called before executing the |
| * initializers. |
| * |
| * The [LocalsHandler] will make the boxes and updates at the right moment. |
| * The builder just needs to call [enterLoopBody] and [enterLoopUpdates] |
| * (for [ast.For] loops) at the correct places. For phi-handling |
| * [beginLoopHeader] and [endLoop] must also be called. |
| * |
| * The correct place for the box depends on the given loop. In most cases |
| * the box will be created when entering the loop-body: while, do-while, and |
| * for-in (assuming the call to [:next:] is inside the body) can always be |
| * constructed this way. |
| * |
| * Things are slightly more complicated for [ast.For] loops. If no declared |
| * loop variable is boxed then the loop-body approach works here too. If a |
| * loop-variable is boxed we need to introduce a new box for the |
| * loop-variable before we enter the initializer so that the initializer |
| * writes the values into the box. In any case we need to create the box |
| * before the condition since the condition could box the variable. |
| * Since the first box is created outside the actual loop we have a second |
| * location where a box is created: just before the updates. This is |
| * necessary since updates are considered to be part of the next iteration |
| * (and can again capture variables). |
| * |
| * For example the following Dart code prints 1 3 -- 3 4. |
| * |
| * var fs = []; |
| * for (var i = 0; i < 3; (f() { fs.add(f); print(i); i++; })()) { |
| * i++; |
| * } |
| * print("--"); |
| * for (var i = 0; i < 2; i++) fs[i](); |
| * |
| * We solve this by emitting the following code (only for [ast.For] loops): |
| * <Create box> <== move the first box creation outside the loop. |
| * <initializer>; |
| * loop-entry: |
| * if (!<condition>) goto loop-exit; |
| * <body> |
| * <update box> // create a new box and copy the captured loop-variables. |
| * <updates> |
| * goto loop-entry; |
| * loop-exit: |
| */ |
| void startLoop(ast.Node node) { |
| ClosureScope scopeData = closureData.capturingScopes[node]; |
| if (scopeData == null) return; |
| if (scopeData.hasBoxedLoopVariables()) { |
| // If there are boxed loop variables then we set up the box and |
| // redirections already now. This way the initializer can write its |
| // values into the box. |
| // For other loops the box will be created when entering the body. |
| enterScope(node, null); |
| } |
| } |
| |
| /** |
| * Create phis at the loop entry for local variables (ready for the values |
| * from the back edge). Populate the phis with the current values. |
| */ |
| void beginLoopHeader(HBasicBlock loopEntry) { |
| // Create a copy because we modify the map while iterating over it. |
| Map<Local, HInstruction> savedDirectLocals = |
| new Map<Local, HInstruction>.from(directLocals); |
| |
| JavaScriptBackend backend = builder.backend; |
| // Create phis for all elements in the definitions environment. |
| savedDirectLocals.forEach((Local local, |
| HInstruction instruction) { |
| if (isAccessedDirectly(local)) { |
| // We know 'this' cannot be modified. |
| if (local != closureData.thisLocal) { |
| HPhi phi = new HPhi.singleInput( |
| local, instruction, backend.dynamicType); |
| loopEntry.addPhi(phi); |
| directLocals[local] = phi; |
| } else { |
| directLocals[local] = instruction; |
| } |
| } |
| }); |
| } |
| |
| void enterLoopBody(ast.Node node) { |
| ClosureScope scopeData = closureData.capturingScopes[node]; |
| if (scopeData == null) return; |
| // If there are no declared boxed loop variables then we did not create the |
| // box before the initializer and we have to create the box now. |
| if (!scopeData.hasBoxedLoopVariables()) { |
| enterScope(node, null); |
| } |
| } |
| |
| void enterLoopUpdates(ast.Node node) { |
| // If there are declared boxed loop variables then the updates might have |
| // access to the box and we must switch to a new box before executing the |
| // updates. |
| // In all other cases a new box will be created when entering the body of |
| // the next iteration. |
| ClosureScope scopeData = closureData.capturingScopes[node]; |
| if (scopeData == null) return; |
| if (scopeData.hasBoxedLoopVariables()) { |
| updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables); |
| } |
| } |
| |
| /** |
| * Goes through the phis created in beginLoopHeader entry and adds the |
| * input from the back edge (from the current value of directLocals) to them. |
| */ |
| void endLoop(HBasicBlock loopEntry) { |
| // If the loop has an aborting body, we don't update the loop |
| // phis. |
| if (loopEntry.predecessors.length == 1) return; |
| loopEntry.forEachPhi((HPhi phi) { |
| Local element = phi.sourceElement; |
| HInstruction postLoopDefinition = directLocals[element]; |
| phi.addInput(postLoopDefinition); |
| }); |
| } |
| |
| /** |
| * Merge [otherLocals] into this locals handler, creating phi-nodes when |
| * there is a conflict. |
| * If a phi node is necessary, it will use this handler's instruction as the |
| * first input, and the otherLocals instruction as the second. |
| */ |
| void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) { |
| // If an element is in one map but not the other we can safely |
| // ignore it. It means that a variable was declared in the |
| // block. Since variable declarations are scoped the declared |
| // variable cannot be alive outside the block. Note: this is only |
| // true for nodes where we do joins. |
| Map<Local, HInstruction> joinedLocals = |
| new Map<Local, HInstruction>(); |
| JavaScriptBackend backend = builder.backend; |
| otherLocals.directLocals.forEach((Local local, |
| HInstruction instruction) { |
| // We know 'this' cannot be modified. |
| if (local == closureData.thisLocal) { |
| assert(directLocals[local] == instruction); |
| joinedLocals[local] = instruction; |
| } else { |
| HInstruction mine = directLocals[local]; |
| if (mine == null) return; |
| if (identical(instruction, mine)) { |
| joinedLocals[local] = instruction; |
| } else { |
| HInstruction phi = new HPhi.manyInputs( |
| local, <HInstruction>[mine, instruction], backend.dynamicType); |
| joinBlock.addPhi(phi); |
| joinedLocals[local] = phi; |
| } |
| } |
| }); |
| directLocals = joinedLocals; |
| } |
| |
| /** |
| * When control flow merges, this method can be used to merge several |
| * localsHandlers into a new one using phis. The new localsHandler is |
| * returned. Unless it is also in the list, the current localsHandler is not |
| * used for its values, only for its declared variables. This is a way to |
| * exclude local values from the result when they are no longer in scope. |
| */ |
| LocalsHandler mergeMultiple(List<LocalsHandler> localsHandlers, |
| HBasicBlock joinBlock) { |
| assert(localsHandlers.length > 0); |
| if (localsHandlers.length == 1) return localsHandlers[0]; |
| Map<Local, HInstruction> joinedLocals = |
| new Map<Local, HInstruction>(); |
| HInstruction thisValue = null; |
| JavaScriptBackend backend = builder.backend; |
| directLocals.forEach((Local local, HInstruction instruction) { |
| if (local != closureData.thisLocal) { |
| HPhi phi = new HPhi.noInputs(local, backend.dynamicType); |
| joinedLocals[local] = phi; |
| joinBlock.addPhi(phi); |
| } else { |
| // We know that "this" never changes, if it's there. |
| // Save it for later. While merging, there is no phi for "this", |
| // so we don't have to special case it in the merge loop. |
| thisValue = instruction; |
| } |
| }); |
| for (LocalsHandler handler in localsHandlers) { |
| handler.directLocals.forEach((Local local, |
| HInstruction instruction) { |
| HPhi phi = joinedLocals[local]; |
| if (phi != null) { |
| phi.addInput(instruction); |
| } |
| }); |
| } |
| if (thisValue != null) { |
| // If there was a "this" for the scope, add it to the new locals. |
| joinedLocals[closureData.thisLocal] = thisValue; |
| } |
| |
| // Remove locals that are not in all handlers. |
| directLocals = new Map<Local, HInstruction>(); |
| joinedLocals.forEach((Local local, |
| HInstruction instruction) { |
| if (local != closureData.thisLocal |
| && instruction.inputs.length != localsHandlers.length) { |
| joinBlock.removePhi(instruction); |
| } else { |
| directLocals[local] = instruction; |
| } |
| }); |
| return this; |
| } |
| } |
| |
| |
| // Represents a single break/continue instruction. |
| class JumpHandlerEntry { |
| final HJump jumpInstruction; |
| final LocalsHandler locals; |
| bool isBreak() => jumpInstruction is HBreak; |
| bool isContinue() => jumpInstruction is HContinue; |
| JumpHandlerEntry(this.jumpInstruction, this.locals); |
| } |
| |
| |
| abstract class JumpHandler { |
| factory JumpHandler(SsaBuilder builder, JumpTarget target) { |
| return new TargetJumpHandler(builder, target); |
| } |
| void generateBreak([LabelDefinition label]); |
| void generateContinue([LabelDefinition label]); |
| void forEachBreak(void action(HBreak instruction, LocalsHandler locals)); |
| void forEachContinue(void action(HContinue instruction, |
| LocalsHandler locals)); |
| bool hasAnyContinue(); |
| bool hasAnyBreak(); |
| void close(); |
| final JumpTarget target; |
| List<LabelDefinition> labels(); |
| } |
| |
| // Insert break handler used to avoid null checks when a target isn't |
| // used as the target of a break, and therefore doesn't need a break |
| // handler associated with it. |
| class NullJumpHandler implements JumpHandler { |
| final Compiler compiler; |
| |
| NullJumpHandler(this.compiler); |
| |
| void generateBreak([LabelDefinition label]) { |
| compiler.internalError(CURRENT_ELEMENT_SPANNABLE, |
| 'NullJumpHandler.generateBreak should not be called.'); |
| } |
| |
| void generateContinue([LabelDefinition label]) { |
| compiler.internalError(CURRENT_ELEMENT_SPANNABLE, |
| 'NullJumpHandler.generateContinue should not be called.'); |
| } |
| |
| void forEachBreak(Function ignored) { } |
| void forEachContinue(Function ignored) { } |
| void close() { } |
| bool hasAnyContinue() => false; |
| bool hasAnyBreak() => false; |
| |
| List<LabelDefinition> labels() => const <LabelDefinition>[]; |
| JumpTarget get target => null; |
| } |
| |
| // Records breaks until a target block is available. |
| // Breaks are always forward jumps. |
| // Continues in loops are implemented as breaks of the body. |
| // Continues in switches is currently not handled. |
| class TargetJumpHandler implements JumpHandler { |
| final SsaBuilder builder; |
| final JumpTarget target; |
| final List<JumpHandlerEntry> jumps; |
| |
| TargetJumpHandler(SsaBuilder builder, this.target) |
| : this.builder = builder, |
| jumps = <JumpHandlerEntry>[] { |
| assert(builder.jumpTargets[target] == null); |
| builder.jumpTargets[target] = this; |
| } |
| |
| void generateBreak([LabelDefinition label]) { |
| HInstruction breakInstruction; |
| if (label == null) { |
| breakInstruction = new HBreak(target); |
| } else { |
| breakInstruction = new HBreak.toLabel(label); |
| } |
| LocalsHandler locals = new LocalsHandler.from(builder.localsHandler); |
| builder.close(breakInstruction); |
| jumps.add(new JumpHandlerEntry(breakInstruction, locals)); |
| } |
| |
| void generateContinue([LabelDefinition label]) { |
| HInstruction continueInstruction; |
| if (label == null) { |
| continueInstruction = new HContinue(target); |
| } else { |
| continueInstruction = new HContinue.toLabel(label); |
| // Switch case continue statements must be handled by the |
| // [SwitchCaseJumpHandler]. |
| assert(label.target.statement is! ast.SwitchCase); |
| } |
| LocalsHandler locals = new LocalsHandler.from(builder.localsHandler); |
| builder.close(continueInstruction); |
| jumps.add(new JumpHandlerEntry(continueInstruction, locals)); |
| } |
| |
| void forEachBreak(Function action) { |
| for (JumpHandlerEntry entry in jumps) { |
| if (entry.isBreak()) action(entry.jumpInstruction, entry.locals); |
| } |
| } |
| |
| void forEachContinue(Function action) { |
| for (JumpHandlerEntry entry in jumps) { |
| if (entry.isContinue()) action(entry.jumpInstruction, entry.locals); |
| } |
| } |
| |
| bool hasAnyContinue() { |
| for (JumpHandlerEntry entry in jumps) { |
| if (entry.isContinue()) return true; |
| } |
| return false; |
| } |
| |
| bool hasAnyBreak() { |
| for (JumpHandlerEntry entry in jumps) { |
| if (entry.isBreak()) return true; |
| } |
| return false; |
| } |
| |
| void close() { |
| // The mapping from TargetElement to JumpHandler is no longer needed. |
| builder.jumpTargets.remove(target); |
| } |
| |
| List<LabelDefinition> labels() { |
| List<LabelDefinition> result = null; |
| for (LabelDefinition element in target.labels) { |
| if (result == null) result = <LabelDefinition>[]; |
| result.add(element); |
| } |
| return (result == null) ? const <LabelDefinition>[] : result; |
| } |
| } |
| |
| /// Special [JumpHandler] implementation used to handle continue statements |
| /// targeting switch cases. |
| class SwitchCaseJumpHandler extends TargetJumpHandler { |
| /// Map from switch case targets to indices used to encode the flow of the |
| /// switch case loop. |
| final Map<JumpTarget, int> targetIndexMap = new Map<JumpTarget, int>(); |
| |
| SwitchCaseJumpHandler(SsaBuilder builder, |
| JumpTarget target, |
| ast.SwitchStatement node) |
| : super(builder, target) { |
| // The switch case indices must match those computed in |
| // [SsaFromAstMixin.buildSwitchCaseConstants]. |
| // Switch indices are 1-based so we can bypass the synthetic loop when no |
| // cases match simply by branching on the index (which defaults to null). |
| int switchIndex = 1; |
| for (ast.SwitchCase switchCase in node.cases) { |
| for (ast.Node labelOrCase in switchCase.labelsAndCases) { |
| ast.Node label = labelOrCase.asLabel(); |
| if (label != null) { |
| LabelDefinition labelElement = |
| builder.elements.getLabelDefinition(label); |
| if (labelElement != null && labelElement.isContinueTarget) { |
| JumpTarget continueTarget = labelElement.target; |
| targetIndexMap[continueTarget] = switchIndex; |
| assert(builder.jumpTargets[continueTarget] == null); |
| builder.jumpTargets[continueTarget] = this; |
| } |
| } |
| } |
| switchIndex++; |
| } |
| } |
| |
| void generateBreak([LabelDefinition label]) { |
| if (label == null) { |
| // Creates a special break instruction for the synthetic loop generated |
| // for a switch statement with continue statements. See |
| // [SsaFromAstMixin.buildComplexSwitchStatement] for detail. |
| |
| HInstruction breakInstruction = |
| new HBreak(target, breakSwitchContinueLoop: true); |
| LocalsHandler locals = new LocalsHandler.from(builder.localsHandler); |
| builder.close(breakInstruction); |
| jumps.add(new JumpHandlerEntry(breakInstruction, locals)); |
| } else { |
| super.generateBreak(label); |
| } |
| } |
| |
| bool isContinueToSwitchCase(LabelDefinition label) { |
| return label != null && targetIndexMap.containsKey(label.target); |
| } |
| |
| void generateContinue([LabelDefinition label]) { |
| if (isContinueToSwitchCase(label)) { |
| // Creates the special instructions 'label = i; continue l;' used in |
| // switch statements with continue statements. See |
| // [SsaFromAstMixin.buildComplexSwitchStatement] for detail. |
| |
| assert(label != null); |
| HInstruction value = builder.graph.addConstantInt( |
| targetIndexMap[label.target], |
| builder.compiler); |
| builder.localsHandler.updateLocal(target, value); |
| |
| assert(label.target.labels.contains(label)); |
| HInstruction continueInstruction = new HContinue(target); |
| LocalsHandler locals = new LocalsHandler.from(builder.localsHandler); |
| builder.close(continueInstruction); |
| jumps.add(new JumpHandlerEntry(continueInstruction, locals)); |
| } else { |
| super.generateContinue(label); |
| } |
| } |
| |
| void close() { |
| // The mapping from TargetElement to JumpHandler is no longer needed. |
| for (JumpTarget target in targetIndexMap.keys) { |
| builder.jumpTargets.remove(target); |
| } |
| super.close(); |
| } |
| } |
| |
| /** |
| * This class builds SSA nodes for functions represented in AST. |
| */ |
| class SsaBuilder extends ResolvedVisitor { |
| final Compiler compiler; |
| final JavaScriptBackend backend; |
| final ConstantSystem constantSystem; |
| final CodegenWorkItem work; |
| final RuntimeTypes rti; |
| final bool generateSourceMap; |
| bool inLazyInitializerExpression = false; |
| |
| /* This field is used by the native handler. */ |
| final NativeEmitter nativeEmitter; |
| |
| final HGraph graph = new HGraph(); |
| |
| /** |
| * The current block to add instructions to. Might be null, if we are |
| * visiting dead code, but see [isReachable]. |
| */ |
| HBasicBlock _current; |
| |
| HBasicBlock get current => _current; |
| |
| void set current(c) { |
| isReachable = c != null; |
| _current = c; |
| } |
| |
| /** |
| * The most recently opened block. Has the same value as [current] while |
| * the block is open, but unlike [current], it isn't cleared when the |
| * current block is closed. |
| */ |
| HBasicBlock lastOpenedBlock; |
| |
| /** |
| * Indicates whether the current block is dead (because it has a throw or a |
| * return further up). If this is false, then [current] may be null. If the |
| * block is dead then it may also be aborted, but for simplicity we only |
| * abort on statement boundaries, not in the middle of expressions. See |
| * isAborted. |
| */ |
| bool isReachable = true; |
| |
| /** |
| * True if we are visiting the expression of a throw statement; we assume this |
| * is a slow path. |
| */ |
| bool inExpressionOfThrow = false; |
| |
| /** |
| * The loop nesting is consulted when inlining a function invocation in |
| * [tryInlineMethod]. The inlining heuristics take this information into |
| * account. |
| */ |
| int loopNesting = 0; |
| |
| /** |
| * This stack contains declaration elements of the functions being built |
| * or inlined by this builder. |
| */ |
| final List<Element> sourceElementStack = <Element>[]; |
| |
| LocalsHandler localsHandler; |
| |
| HInstruction rethrowableException; |
| |
| HParameterValue lastAddedParameter; |
| |
| Map<ParameterElement, HInstruction> parameters = |
| <ParameterElement, HInstruction>{}; |
| |
| Map<JumpTarget, JumpHandler> jumpTargets = <JumpTarget, JumpHandler>{}; |
| |
| /** |
| * Variables stored in the current activation. These variables are |
| * being updated in try/catch blocks, and should be |
| * accessed indirectly through [HLocalGet] and [HLocalSet]. |
| */ |
| Map<Local, HLocalValue> activationVariables = |
| <Local, HLocalValue>{}; |
| |
| // We build the Ssa graph by simulating a stack machine. |
| List<HInstruction> stack = <HInstruction>[]; |
| |
| SsaBuilder(JavaScriptBackend backend, |
| CodegenWorkItem work, |
| this.nativeEmitter, |
| this.generateSourceMap) |
| : this.compiler = backend.compiler, |
| this.backend = backend, |
| this.constantSystem = backend.constantSystem, |
| this.work = work, |
| this.rti = backend.rti, |
| super(work.resolutionTree) { |
| localsHandler = new LocalsHandler(this, work.element); |
| sourceElementStack.add(work.element); |
| } |
| |
| CodegenRegistry get registry => work.registry; |
| |
| /// Returns the current source element. |
| /// |
| /// The returned element is a declaration element. |
| // TODO(johnniwinther): Check that all usages of sourceElement agree on |
| // implementation/declaration distinction. |
| Element get sourceElement => sourceElementStack.last; |
| |
| bool get _checkOrTrustTypes => |
| compiler.enableTypeAssertions || compiler.trustTypeAnnotations; |
| |
| HBasicBlock addNewBlock() { |
| HBasicBlock block = graph.addNewBlock(); |
| // If adding a new block during building of an expression, it is due to |
| // conditional expressions or short-circuit logical operators. |
| return block; |
| } |
| |
| void open(HBasicBlock block) { |
| block.open(); |
| current = block; |
| lastOpenedBlock = block; |
| } |
| |
| HBasicBlock close(HControlFlow end) { |
| HBasicBlock result = current; |
| current.close(end); |
| current = null; |
| return result; |
| } |
| |
| HBasicBlock closeAndGotoExit(HControlFlow end) { |
| HBasicBlock result = current; |
| current.close(end); |
| current = null; |
| result.addSuccessor(graph.exit); |
| return result; |
| } |
| |
| void goto(HBasicBlock from, HBasicBlock to) { |
| from.close(new HGoto()); |
| from.addSuccessor(to); |
| } |
| |
| bool isAborted() { |
| return current == null; |
| } |
| |
| /** |
| * Creates a new block, transitions to it from any current block, and |
| * opens the new block. |
| */ |
| HBasicBlock openNewBlock() { |
| HBasicBlock newBlock = addNewBlock(); |
| if (!isAborted()) goto(current, newBlock); |
| open(newBlock); |
| return newBlock; |
| } |
| |
| void add(HInstruction instruction) { |
| current.add(instruction); |
| } |
| |
| void addWithPosition(HInstruction instruction, ast.Node node) { |
| add(attachPosition(instruction, node)); |
| } |
| |
| SourceFile currentSourceFile() { |
| return sourceElement.implementation.compilationUnit.script.file; |
| } |
| |
| void checkValidSourceFileLocation( |
| SourceFileLocation location, SourceFile sourceFile, int offset) { |
| if (!location.isValid()) { |
| throw MessageKind.INVALID_SOURCE_FILE_LOCATION.message( |
| {'offset': offset, |
| 'fileName': sourceFile.filename, |
| 'length': sourceFile.length}); |
| } |
| } |
| |
| /** |
| * Returns a complete argument list for a call of [function]. |
| */ |
| List<HInstruction> completeSendArgumentsList( |
| FunctionElement function, |
| Selector selector, |
| List<HInstruction> providedArguments, |
| ast.Node currentNode) { |
| assert(invariant(function, function.isImplementation)); |
| assert(providedArguments != null); |
| |
| bool isInstanceMember = function.isInstanceMember; |
| // For static calls, [providedArguments] is complete, default arguments |
| // have been included if necessary, see [makeStaticArgumentList]. |
| if (!isInstanceMember |
| || currentNode == null // In erroneous code, currentNode can be null. |
| || providedArgumentsKnownToBeComplete(currentNode) |
| || function.isGenerativeConstructorBody |
| || selector.isGetter) { |
| // For these cases, the provided argument list is known to be complete. |
| return providedArguments; |
| } else { |
| return completeDynamicSendArgumentsList( |
| selector, function, providedArguments); |
| } |
| } |
| |
| /** |
| * Returns a complete argument list for a dynamic call of [function]. The |
| * initial argument list [providedArguments], created by |
| * [addDynamicSendArgumentsToList], does not include values for default |
| * arguments used in the call. The reason is that the target function (which |
| * defines the defaults) is not known. |
| * |
| * However, inlining can only be performed when the target function can be |
| * resolved statically. The defaults can therefore be included at this point. |
| * |
| * The [providedArguments] list contains first all positional arguments, then |
| * the provided named arguments (the named arguments that are defined in the |
| * [selector]) in a specific order (see [addDynamicSendArgumentsToList]). |
| */ |
| List<HInstruction> completeDynamicSendArgumentsList( |
| Selector selector, |
| FunctionElement function, |
| List<HInstruction> providedArguments) { |
| assert(selector.applies(function, compiler.world)); |
| FunctionSignature signature = function.functionSignature; |
| List<HInstruction> compiledArguments = new List<HInstruction>( |
| signature.parameterCount + 1); // Plus one for receiver. |
| |
| compiledArguments[0] = providedArguments[0]; // Receiver. |
| int index = 1; |
| for (; index <= signature.requiredParameterCount; index++) { |
| compiledArguments[index] = providedArguments[index]; |
| } |
| if (!signature.optionalParametersAreNamed) { |
| signature.forEachOptionalParameter((element) { |
| if (index < providedArguments.length) { |
| compiledArguments[index] = providedArguments[index]; |
| } else { |
| compiledArguments[index] = |
| handleConstantForOptionalParameter(element); |
| } |
| index++; |
| }); |
| } else { |
| /* Example: |
| * void foo(a, {b, d, c}) |
| * foo(0, d = 1, b = 2) |
| * |
| * providedArguments = [0, 2, 1] |
| * selectorArgumentNames = [b, d] |
| * signature.orderedOptionalParameters = [b, c, d] |
| * |
| * For each parameter name in the signature, if the argument name matches |
| * we use the next provided argument, otherwise we get the default. |
| */ |
| List<String> selectorArgumentNames = selector.getOrderedNamedArguments(); |
| int namedArgumentIndex = 0; |
| int firstProvidedNamedArgument = index; |
| signature.orderedOptionalParameters.forEach((element) { |
| if (namedArgumentIndex < selectorArgumentNames.length && |
| element.name == selectorArgumentNames[namedArgumentIndex]) { |
| // The named argument was provided in the function invocation. |
| compiledArguments[index] = providedArguments[ |
| firstProvidedNamedArgument + namedArgumentIndex++]; |
| } else { |
| compiledArguments[index] = |
| handleConstantForOptionalParameter(element); |
| } |
| index++; |
| }); |
| } |
| return compiledArguments; |
| } |
| |
| /** |
| * Try to inline [element] within the currect context of the builder. The |
| * insertion point is the state of the builder. |
| */ |
| bool tryInlineMethod(Element element, |
| Selector selector, |
| List<HInstruction> providedArguments, |
| ast.Node currentNode) { |
| // TODO(johnniwinther): Register this on the [registry]. Currently the |
| // [CodegenRegistry] calls the enqueuer, but [element] should _not_ be |
| // enqueued. |
| backend.registerStaticUse(element, compiler.enqueuer.codegen); |
| |
| // Ensure that [element] is an implementation element. |
| element = element.implementation; |
| |
| if (compiler.elementHasCompileTimeError(element)) return false; |
| |
| FunctionElement function = element; |
| bool insideLoop = loopNesting > 0 || graph.calledInLoop; |
| |
| // Bail out early if the inlining decision is in the cache and we can't |
| // inline (no need to check the hard constraints). |
| bool cachedCanBeInlined = |
| backend.inlineCache.canInline(function, insideLoop: insideLoop); |
| if (cachedCanBeInlined == false) return false; |
| |
| bool meetsHardConstraints() { |
| // Don't inline from one output unit to another. If something is deferred |
| // it is to save space in the loading code. |
| if (!compiler.deferredLoadTask |
| .inSameOutputUnit(element,compiler.currentElement)) { |
| return false; |
| } |
| if (compiler.disableInlining) return false; |
| |
| assert(selector != null |
| || Elements.isStaticOrTopLevel(element) |
| || element.isGenerativeConstructorBody); |
| if (selector != null && !selector.applies(function, compiler.world)) { |
| return false; |
| } |
| |
| // Don't inline operator== methods if the parameter can be null. |
| if (element.name == '==') { |
| if (element.enclosingClass != compiler.objectClass |
| && providedArguments[1].canBeNull()) { |
| return false; |
| } |
| } |
| |
| // Generative constructors of native classes should not be called directly |
| // and have an extra argument that causes problems with inlining. |
| if (element.isGenerativeConstructor |
| && Elements.isNativeOrExtendsNative(element.enclosingClass)) { |
| return false; |
| } |
| |
| // A generative constructor body is not seen by global analysis, |
| // so we should not query for its type. |
| if (!element.isGenerativeConstructorBody) { |
| // Don't inline if the return type was inferred to be non-null empty. |
| // This means that the function always throws an exception. |
| TypeMask returnType = |
| compiler.typesTask.getGuaranteedReturnTypeOfElement(element); |
| if (returnType != null |
| && returnType.isEmpty |
| && !returnType.isNullable) { |
| isReachable = false; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool reductiveHeuristic() { |
| // The call is on a path which is executed rarely, so inline only if it |
| // does not make the program larger. |
| if (isCalledOnce(element)) { |
| return InlineWeeder.canBeInlined(function.node, -1, false); |
| } |
| // TODO(sra): Measure if inlining would 'reduce' the size. One desirable |
| // case we miss my doing nothing is inlining very simple constructors |
| // where all fields are initialized with values from the arguments at this |
| // call site. The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but |
| // that usually means the factory constructor is left unused and not |
| // emitted. |
| return false; |
| } |
| |
| bool heuristicSayGoodToGo() { |
| // Don't inline recursively |
| if (inliningStack.any((entry) => entry.function == function)) { |
| return false; |
| } |
| |
| if (element.isSynthesized) return true; |
| |
| if (inExpressionOfThrow || inLazyInitializerExpression) { |
| return reductiveHeuristic(); |
| } |
| |
| if (cachedCanBeInlined == true) return cachedCanBeInlined; |
| |
| if (backend.functionsToAlwaysInline.contains(function)) { |
| // Inline this function regardless of it's size. |
| assert(InlineWeeder.canBeInlined(function.node, -1, false, |
| allowLoops: true)); |
| return true; |
| } |
| |
| int numParameters = function.functionSignature.parameterCount; |
| int maxInliningNodes; |
| bool useMaxInliningNodes = true; |
| if (insideLoop) { |
| maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP + |
| InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters; |
| } else { |
| maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP + |
| InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters; |
| } |
| |
| // If a method is called only once, and all the methods in the |
| // inlining stack are called only once as well, we know we will |
| // save on output size by inlining this method. |
| if (isCalledOnce(element)) { |
| useMaxInliningNodes = false; |
| } |
| bool canInline; |
| ast.FunctionExpression functionNode = function.node; |
| canInline = InlineWeeder.canBeInlined( |
| functionNode, maxInliningNodes, useMaxInliningNodes); |
| if (canInline) { |
| backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop); |
| } else { |
| backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop); |
| } |
| return canInline; |
| } |
| |
| void doInlining() { |
| // Add an explicit null check on the receiver before doing the |
| // inlining. We use [element] to get the same name in the |
| // NoSuchMethodError message as if we had called it. |
| if (element.isInstanceMember |
| && !element.isGenerativeConstructorBody |
| && (selector.mask == null || selector.mask.isNullable)) { |
| addWithPosition( |
| new HFieldGet(null, providedArguments[0], backend.dynamicType, |
| isAssignable: false), |
| currentNode); |
| } |
| List<HInstruction> compiledArguments = completeSendArgumentsList( |
| function, selector, providedArguments, currentNode); |
| enterInlinedMethod(function, currentNode, compiledArguments); |
| inlinedFrom(function, () { |
| if (!isReachable) { |
| emitReturn(graph.addConstantNull(compiler), null); |
| } else { |
| doInline(function); |
| } |
| }); |
| leaveInlinedMethod(); |
| } |
| |
| if (meetsHardConstraints() && heuristicSayGoodToGo()) { |
| doInlining(); |
| registry.registerInlining( |
| element, |
| compiler.currentElement); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool get allInlinedFunctionsCalledOnce { |
| return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce; |
| } |
| |
| bool isCalledOnce(Element element) { |
| if (!allInlinedFunctionsCalledOnce) return false; |
| TypesInferrer inferrer = compiler.typesTask.typesInferrer; |
| return inferrer.isCalledOnce(element); |
| } |
| |
| inlinedFrom(Element element, f()) { |
| assert(element is FunctionElement || element is VariableElement); |
| return compiler.withCurrentElement(element, () { |
| // The [sourceElementStack] contains declaration elements. |
| sourceElementStack.add(element.declaration); |
| var result = f(); |
| sourceElementStack.removeLast(); |
| return result; |
| }); |
| } |
| |
| HInstruction handleConstantForOptionalParameter(Element parameter) { |
| ConstantExpression constant = |
| backend.constants.getConstantForVariable(parameter); |
| assert(invariant(parameter, constant != null, |
| message: 'No constant computed for $parameter')); |
| return graph.addConstant(constant.value, compiler); |
| } |
| |
| Element get currentNonClosureClass { |
| ClassElement cls = sourceElement.enclosingClass; |
| if (cls != null && cls.isClosure) { |
| var closureClass = cls; |
| return closureClass.methodElement.enclosingClass; |
| } else { |
| return cls; |
| } |
| } |
| |
| /** |
| * Returns whether this builder is building code for [element]. |
| */ |
| bool isBuildingFor(Element element) { |
| return work.element == element; |
| } |
| |
| /// A stack of [DartType]s the have been seen during inlining of factory |
| /// constructors. These types are preserved in [HInvokeStatic]s and |
| /// [HForeignNews] inside the inline code and registered during code |
| /// generation for these nodes. |
| // TODO(karlklose): consider removing this and keeping the (substituted) |
| // types of the type variables in an environment (like the [LocalsHandler]). |
| final List<DartType> currentInlinedInstantiations = <DartType>[]; |
| |
| final List<AstInliningState> inliningStack = <AstInliningState>[]; |
| |
| Local returnLocal; |
| DartType returnType; |
| |
| bool inTryStatement = false; |
| |
| ConstantValue getConstantForNode(ast.Node node) { |
| ConstantExpression constant = |
| backend.constants.getConstantForNode(node, elements); |
| assert(invariant(node, constant != null, |
| message: 'No constant computed for $node')); |
| return constant.value; |
| } |
| |
| HInstruction addConstant(ast.Node node) { |
| return graph.addConstant(getConstantForNode(node), compiler); |
| } |
| |
| bool isLazilyInitialized(VariableElement element) { |
| ConstantExpression initialValue = |
| backend.constants.getConstantForVariable(element); |
| return initialValue == null; |
| } |
| |
| TypeMask cachedTypeOfThis; |
| |
| TypeMask getTypeOfThis() { |
| TypeMask result = cachedTypeOfThis; |
| if (result == null) { |
| ThisLocal local = localsHandler.closureData.thisLocal; |
| ClassElement cls = local.enclosingClass; |
| ClassWorld classWorld = compiler.world; |
| if (classWorld.isUsedAsMixin(cls)) { |
| // If the enclosing class is used as a mixin, [:this:] can be |
| // of the class that mixins the enclosing class. These two |
| // classes do not have a subclass relationship, so, for |
| // simplicity, we mark the type as an interface type. |
| result = new TypeMask.nonNullSubtype(cls.declaration, compiler.world); |
| } else { |
| result = new TypeMask.nonNullSubclass(cls.declaration, compiler.world); |
| } |
| cachedTypeOfThis = result; |
| } |
| return result; |
| } |
| |
| Map<Element, TypeMask> cachedTypesOfCapturedVariables = |
| new Map<Element, TypeMask>(); |
| |
| TypeMask getTypeOfCapturedVariable(Element element) { |
| assert(element.isField); |
| return cachedTypesOfCapturedVariables.putIfAbsent(element, () { |
| return TypeMaskFactory.inferredTypeForElement(element, compiler); |
| }); |
| } |
| |
| /** |
| * Documentation wanted -- johnniwinther |
| * |
| * Invariant: [functionElement] must be an implementation element. |
| */ |
| HGraph buildMethod(FunctionElement functionElement) { |
| assert(invariant(functionElement, functionElement.isImplementation)); |
| graph.calledInLoop = compiler.world.isCalledInLoop(functionElement); |
| ast.FunctionExpression function = functionElement.node; |
| assert(function != null); |
| assert(!function.modifiers.isExternal); |
| assert(elements.getFunctionDefinition(function) != null); |
| openFunction(functionElement, function); |
| String name = functionElement.name; |
| // If [functionElement] is `operator==` we explicitely add a null check at |
| // the beginning of the method. This is to avoid having call sites do the |
| // null check. |
| if (name == '==') { |
| if (!backend.operatorEqHandlesNullArgument(functionElement)) { |
| handleIf( |
| function, |
| () { |
| HParameterValue parameter = parameters.values.first; |
| push(new HIdentity( |
| parameter, graph.addConstantNull(compiler), null, |
| backend.boolType)); |
| }, |
| () { |
| closeAndGotoExit(new HReturn( |
| graph.addConstantBool(false, compiler))); |
| }, |
| null); |
| } |
| } |
| function.body.accept(this); |
| return closeFunction(); |
| } |
| |
| HGraph buildCheckedSetter(VariableElement field) { |
| openFunction(field, field.node); |
| HInstruction thisInstruction = localsHandler.readThis(); |
| // Use dynamic type because the type computed by the inferrer is |
| // narrowed to the type annotation. |
| HInstruction parameter = new HParameterValue(field, backend.dynamicType); |
| // Add the parameter as the last instruction of the entry block. |
| // If the method is intercepted, we want the actual receiver |
| // to be the first parameter. |
| graph.entry.addBefore(graph.entry.last, parameter); |
| HInstruction value = potentiallyCheckOrTrustType(parameter, field.type); |
| add(new HFieldSet(field, thisInstruction, value)); |
| return closeFunction(); |
| } |
| |
| HGraph buildLazyInitializer(VariableElement variable) { |
| inLazyInitializerExpression = true; |
| ast.Node node = variable.node; |
| openFunction(variable, node); |
| assert(invariant(variable, variable.initializer != null, |
| message: "Non-constant variable $variable has no initializer.")); |
| visit(variable.initializer); |
| HInstruction value = pop(); |
| value = potentiallyCheckOrTrustType(value, variable.type); |
| closeAndGotoExit(new HReturn(value)); |
| return closeFunction(); |
| } |
| |
| /** |
| * Returns the constructor body associated with the given constructor or |
| * creates a new constructor body, if none can be found. |
| * |
| * Returns [:null:] if the constructor does not have a body. |
| */ |
| ConstructorBodyElement getConstructorBody(FunctionElement constructor) { |
| assert(constructor.isGenerativeConstructor); |
| assert(invariant(constructor, constructor.isImplementation)); |
| if (constructor.isSynthesized) return null; |
| ast.FunctionExpression node = constructor.node; |
| // If we know the body doesn't have any code, we don't generate it. |
| if (!node.hasBody()) return null; |
| if (node.hasEmptyBody()) return null; |
| ClassElement classElement = constructor.enclosingClass; |
| ConstructorBodyElement bodyElement; |
| classElement.forEachBackendMember((Element backendMember) { |
| if (backendMember.isGenerativeConstructorBody) { |
| ConstructorBodyElement body = backendMember; |
| if (body.constructor == constructor) { |
| // TODO(kasperl): Find a way of stopping the iteration |
| // through the backend members. |
| bodyElement = backendMember; |
| } |
| } |
| }); |
| if (bodyElement == null) { |
| bodyElement = new ConstructorBodyElementX(constructor); |
| classElement.addBackendMember(bodyElement); |
| |
| if (constructor.isPatch) { |
| // Create origin body element for patched constructors. |
| ConstructorBodyElementX patch = bodyElement; |
| ConstructorBodyElementX origin = |
| new ConstructorBodyElementX(constructor.origin); |
| origin.applyPatch(patch); |
| classElement.origin.addBackendMember(bodyElement.origin); |
| } |
| } |
| assert(bodyElement.isGenerativeConstructorBody); |
| return bodyElement; |
| } |
| |
| HParameterValue addParameter(Entity parameter, TypeMask type) { |
| assert(inliningStack.isEmpty); |
| HParameterValue result = new HParameterValue(parameter, type); |
| if (lastAddedParameter == null) { |
| graph.entry.addBefore(graph.entry.first, result); |
| } else { |
| graph.entry.addAfter(lastAddedParameter, result); |
| } |
| lastAddedParameter = result; |
| return result; |
| } |
| |
| /** |
| * This method sets up the local state of the builder for inlining [function]. |
| * The arguments of the function are inserted into the [localsHandler]. |
| * |
| * When inlining a function, [:return:] statements are not emitted as |
| * [HReturn] instructions. Instead, the value of a synthetic element is |
| * updated in the [localsHandler]. This function creates such an element and |
| * stores it in the [returnLocal] field. |
| */ |
| void setupStateForInlining(FunctionElement function, |
| List<HInstruction> compiledArguments) { |
| localsHandler = new LocalsHandler(this, function); |
| localsHandler.closureData = |
| compiler.closureToClassMapper.computeClosureToClassMapping( |
| function, function.node, elements); |
| returnLocal = new SyntheticLocal("result", function); |
| localsHandler.updateLocal(returnLocal, |
| graph.addConstantNull(compiler)); |
| |
| inTryStatement = false; // TODO(lry): why? Document. |
| |
| int argumentIndex = 0; |
| if (function.isInstanceMember) { |
| localsHandler.updateLocal(localsHandler.closureData.thisLocal, |
| compiledArguments[argumentIndex++]); |
| } |
| |
| FunctionSignature signature = function.functionSignature; |
| signature.orderedForEachParameter((ParameterElement parameter) { |
| HInstruction argument = compiledArguments[argumentIndex++]; |
| localsHandler.updateLocal(parameter, argument); |
| }); |
| |
| ClassElement enclosing = function.enclosingClass; |
| if ((function.isConstructor || function.isGenerativeConstructorBody) |
| && backend.classNeedsRti(enclosing)) { |
| enclosing.typeVariables.forEach((TypeVariableType typeVariable) { |
| HInstruction argument = compiledArguments[argumentIndex++]; |
| localsHandler.updateLocal( |
| localsHandler.getTypeVariableAsLocal(typeVariable), argument); |
| }); |
| } |
| assert(argumentIndex == compiledArguments.length); |
| |
| elements = function.resolvedAst.elements; |
| assert(elements != null); |
| returnType = signature.type.returnType; |
| stack = <HInstruction>[]; |
| |
| insertTraceCall(function); |
| } |
| |
| void restoreState(AstInliningState state) { |
| localsHandler = state.oldLocalsHandler; |
| returnLocal = state.oldReturnLocal; |
| inTryStatement = state.inTryStatement; |
| elements = state.oldElements; |
| returnType = state.oldReturnType; |
| assert(stack.isEmpty); |
| stack = state.oldStack; |
| } |
| |
| /** |
| * Run this builder on the body of the [function] to be inlined. |
| */ |
| void visitInlinedFunction(FunctionElement function) { |
| potentiallyCheckInlinedParameterTypes(function); |
| if (function.isGenerativeConstructor) { |
| buildFactory(function); |
| } else { |
| ast.FunctionExpression functionNode = function.node; |
| functionNode.body.accept(this); |
| } |
| } |
| |
| |
| addInlinedInstantiation(DartType type) { |
| if (type != null) { |
| currentInlinedInstantiations.add(type); |
| } |
| } |
| |
| removeInlinedInstantiation(DartType type) { |
| if (type != null) { |
| currentInlinedInstantiations.removeLast(); |
| } |
| } |
| |
| bool providedArgumentsKnownToBeComplete(ast.Node currentNode) { |
| /* When inlining the iterator methods generated for a [:for-in:] loop, the |
| * [currentNode] is the [ForIn] tree. The compiler-generated iterator |
| * invocations are known to have fully specified argument lists, no default |
| * arguments are used. See invocations of [pushInvokeDynamic] in |
| * [visitForIn]. |
| */ |
| return currentNode.asForIn() != null; |
| } |
| |
| /** |
| * In checked mode, generate type tests for the parameters of the inlined |
| * function. |
| */ |
| void potentiallyCheckInlinedParameterTypes(FunctionElement function) { |
| if (!_checkOrTrustTypes) return; |
| |
| FunctionSignature signature = function.functionSignature; |
| signature.orderedForEachParameter((ParameterElement parameter) { |
| HInstruction argument = localsHandler.readLocal(parameter); |
| potentiallyCheckOrTrustType(argument, parameter.type); |
| }); |
| } |
| |
| /** |
| * Documentation wanted -- johnniwinther |
| * |
| * Invariant: [constructors] must contain only implementation elements. |
| */ |
| void inlineSuperOrRedirect(FunctionElement callee, |
| List<HInstruction> compiledArguments, |
| List<FunctionElement> constructors, |
| Map<Element, HInstruction> fieldValues, |
| FunctionElement caller) { |
| callee = callee.implementation; |
| compiler.withCurrentElement(callee, () { |
| constructors.add(callee); |
| ClassElement enclosingClass = callee.enclosingClass; |
| if (backend.classNeedsRti(enclosingClass)) { |
| // If [enclosingClass] needs RTI, we have to give a value to its |
| // type parameters. |
| ClassElement currentClass = caller.enclosingClass; |
| // For a super constructor call, the type is the supertype of |
| // [currentClass]. For a redirecting constructor, the type is |
| // the current type. [InterfaceType.asInstanceOf] takes care |
| // of both. |
| InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass); |
| type = localsHandler.substInContext(type); |
| List<DartType> arguments = type.typeArguments; |
| List<DartType> typeVariables = enclosingClass.typeVariables; |
| if (!type.isRaw) { |
| assert(arguments.length == typeVariables.length); |
| Iterator<DartType> variables = typeVariables.iterator; |
| type.typeArguments.forEach((DartType argument) { |
| variables.moveNext(); |
| TypeVariableType typeVariable = variables.current; |
| localsHandler.updateLocal( |
| localsHandler.getTypeVariableAsLocal(typeVariable), |
| analyzeTypeArgument(argument)); |
| }); |
| } else { |
| // If the supertype is a raw type, we need to set to null the |
| // type variables. |
| for (TypeVariableType variable in typeVariables) { |
| localsHandler.updateLocal( |
| localsHandler.getTypeVariableAsLocal(variable), |
| graph.addConstantNull(compiler)); |
| } |
| } |
| } |
| |
| // For redirecting constructors, the fields have already been |
| // initialized by the caller. |
| if (callee.enclosingClass != caller.enclosingClass) { |
| inlinedFrom(callee, () { |
| buildFieldInitializers(callee.enclosingElement.implementation, |
| fieldValues); |
| }); |
| } |
| |
| int index = 0; |
| FunctionSignature params = callee.functionSignature; |
| params.orderedForEachParameter((ParameterElement parameter) { |
| HInstruction argument = compiledArguments[index++]; |
| // Because we are inlining the initializer, we must update |
| // what was given as parameter. This will be used in case |
| // there is a parameter check expression in the initializer. |
| parameters[parameter] = argument; |
| localsHandler.updateLocal(parameter, argument); |
| // Don't forget to update the field, if the parameter is of the |
| // form [:this.x:]. |
| if (parameter.isInitializingFormal) { |
| InitializingFormalElement fieldParameterElement = parameter; |
| fieldValues[fieldParameterElement.fieldElement] = argument; |
| } |
| }); |
| |
| // Build the initializers in the context of the new constructor. |
| TreeElements oldElements = elements; |
| ResolvedAst resolvedAst = callee.resolvedAst; |
| elements = resolvedAst.elements; |
| ClosureClassMap oldClosureData = localsHandler.closureData; |
| ast.Node node = resolvedAst.node; |
| ClosureClassMap newClosureData = |
| compiler.closureToClassMapper.computeClosureToClassMapping( |
| callee, node, elements); |
| localsHandler.closureData = newClosureData; |
| localsHandler.enterScope(node, callee); |
| buildInitializers(callee, constructors, fieldValues); |
| localsHandler.closureData = oldClosureData; |
| elements = oldElements; |
| }); |
| } |
| |
| /** |
| * Run through the initializers and inline all field initializers. Recursively |
| * inlines super initializers. |
| * |
| * The constructors of the inlined initializers is added to [constructors] |
| * with sub constructors having a lower index than super constructors. |
| * |
| * Invariant: The [constructor] and elements in [constructors] must all be |
| * implementation elements. |
| */ |
| void buildInitializers(ConstructorElement constructor, |
| List<FunctionElement> constructors, |
| Map<Element, HInstruction> fieldValues) { |
| assert(invariant(constructor, constructor.isImplementation)); |
| if (constructor.isSynthesized) { |
| List<HInstruction> arguments = <HInstruction>[]; |
| HInstruction compileArgument(ParameterElement parameter) { |
| return localsHandler.readLocal(parameter); |
| } |
| |
| Element target = constructor.definingConstructor.implementation; |
| bool match = Selector.addForwardingElementArgumentsToList( |
| constructor, |
| arguments, |
| target, |
| compileArgument, |
| handleConstantForOptionalParameter, |
| compiler.world); |
| if (!match) { |
| if (compiler.elementHasCompileTimeError(constructor)) { |
| return; |
| } |
| // If this fails, the selector we constructed for the call to a |
| // forwarding constructor in a mixin application did not match the |
| // constructor (which, for example, may happen when the libraries are |
| // not compatible for private names, see issue 20394). |
| compiler.internalError(constructor, |
| 'forwarding constructor call does not match'); |
| } |
| inlineSuperOrRedirect( |
| target, |
| arguments, |
| constructors, |
| fieldValues, |
| constructor); |
| return; |
| } |
| ast.FunctionExpression functionNode = constructor.node; |
| |
| bool foundSuperOrRedirect = false; |
| if (functionNode.initializers != null) { |
| Link<ast.Node> initializers = functionNode.initializers.nodes; |
| for (Link<ast.Node> link = initializers; !link.isEmpty; link = link.tail) { |
| assert(link.head is ast.Send); |
| if (link.head is !ast.SendSet) { |
| // A super initializer or constructor redirection. |
| foundSuperOrRedirect = true; |
| ast.Send call = link.head; |
| assert(ast.Initializers.isSuperConstructorCall(call) || |
| ast.Initializers.isConstructorRedirect(call)); |
| FunctionElement target = elements[call].implementation; |
| Selector selector = elements.getSelector(call); |
| Link<ast.Node> arguments = call.arguments; |
| List<HInstruction> compiledArguments; |
| inlinedFrom(constructor, () { |
| compiledArguments = |
| makeStaticArgumentList(selector, arguments, target); |
| }); |
| inlineSuperOrRedirect(target, |
| compiledArguments, |
| constructors, |
| fieldValues, |
| constructor); |
| } else { |
| // A field initializer. |
| ast.SendSet init = link.head; |
| Link<ast.Node> arguments = init.arguments; |
| assert(!arguments.isEmpty && arguments.tail.isEmpty); |
| inlinedFrom(constructor, () { |
| visit(arguments.head); |
| }); |
| fieldValues[elements[init]] = pop(); |
| } |
| } |
| } |
| |
| if (!foundSuperOrRedirect) { |
| // No super initializer found. Try to find the default constructor if |
| // the class is not Object. |
| ClassElement enclosingClass = constructor.enclosingClass; |
| ClassElement superClass = enclosingClass.superclass; |
| if (!enclosingClass.isObject) { |
| assert(superClass != null); |
| assert(superClass.resolutionState == STATE_DONE); |
| Selector selector = |
| new Selector.callDefaultConstructor(enclosingClass.library); |
| // TODO(johnniwinther): Should we find injected constructors as well? |
| FunctionElement target = superClass.lookupConstructor(selector); |
| if (target == null) { |
| compiler.internalError(superClass, |
| "No default constructor available."); |
| } |
| List<HInstruction> arguments = |
| selector.makeArgumentsList2(const Link<ast.Node>(), |
| target.implementation, |
| null, |
| handleConstantForOptionalParameter); |
| inlineSuperOrRedirect(target, |
| arguments, |
| constructors, |
| fieldValues, |
| constructor); |
| } |
| } |
| } |
| |
| /** |
| * Run through the fields of [cls] and add their potential |
| * initializers. |
| * |
| * Invariant: [classElement] must be an implementation element. |
| */ |
| void buildFieldInitializers(ClassElement classElement, |
| Map<Element, HInstruction> fieldValues) { |
| assert(invariant(classElement, classElement.isImplementation)); |
| classElement.forEachInstanceField( |
| (ClassElement enclosingClass, VariableElement member) { |
| if (compiler.elementHasCompileTimeError(member)) return; |
| compiler.withCurrentElement(member, () { |
| TreeElements definitions = member.treeElements; |
| ast.Node node = member.node; |
| ast.Expression initializer = member.initializer; |
| if (initializer == null) { |
| // Unassigned fields of native classes are not initialized to |
| // prevent overwriting pre-initialized native properties. |
| if (!Elements.isNativeOrExtendsNative(classElement)) { |
| fieldValues[member] = graph.addConstantNull(compiler); |
| } |
| } else { |
| ast.Node right = initializer; |
| TreeElements savedElements = elements; |
| elements = definitions; |
| // In case the field initializer uses closures, run the |
| // closure to class mapper. |
| compiler.closureToClassMapper.computeClosureToClassMapping( |
| member, node, elements); |
| inlinedFrom(member, () => right.accept(this)); |
| elements = savedElements; |
| fieldValues[member] = pop(); |
| } |
| }); |
| }); |
| } |
| |
| /** |
| * Build the factory function corresponding to the constructor |
| * [functionElement]: |
| * - Initialize fields with the values of the field initializers of the |
| * current constructor and super constructors or constructors redirected |
| * to, starting from the current constructor. |
| * - Call the constructor bodies, starting from the constructor(s) in the |
| * super class(es). |
| */ |
| HGraph buildFactory(FunctionElement functionElement) { |
| functionElement = functionElement.implementation; |
| ClassElement classElement = |
| functionElement.enclosingClass.implementation; |
| bool isNativeUpgradeFactory = |
| Elements.isNativeOrExtendsNative(classElement); |
| ast.FunctionExpression function = functionElement.node; |
| // Note that constructors (like any other static function) do not need |
| // to deal with optional arguments. It is the callers job to provide all |
| // arguments as if they were positional. |
| |
| if (inliningStack.isEmpty) { |
| // The initializer list could contain closures. |
| openFunction(functionElement, function); |
| } |
| |
| Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>(); |
| |
| // Compile the possible initialization code for local fields and |
| // super fields. |
| buildFieldInitializers(classElement, fieldValues); |
| |
| // Compile field-parameters such as [:this.x:]. |
| FunctionSignature params = functionElement.functionSignature; |
| params.orderedForEachParameter((ParameterElement parameter) { |
| if (parameter.isInitializingFormal) { |
| // If the [element] is a field-parameter then |
| // initialize the field element with its value. |
| InitializingFormalElement fieldParameter = parameter; |
| HInstruction parameterValue = |
| localsHandler.readLocal(fieldParameter); |
| fieldValues[fieldParameter.fieldElement] = parameterValue; |
| } |
| }); |
| |
| // Analyze the constructor and all referenced constructors and collect |
| // initializers and constructor bodies. |
| List<FunctionElement> constructors = <FunctionElement>[functionElement]; |
| buildInitializers(functionElement, constructors, fieldValues); |
| |
| // Call the JavaScript constructor with the fields as argument. |
| List<HInstruction> constructorArguments = <HInstruction>[]; |
| List<Element> fields = <Element>[]; |
| |
| classElement.forEachInstanceField( |
| (ClassElement enclosingClass, VariableElement member) { |
| HInstruction value = fieldValues[member]; |
| if (value == null) { |
| // Uninitialized native fields are pre-initialized by the native |
| // implementation. |
| assert(invariant( |
| member, isNativeUpgradeFactory || compiler.compilationFailed)); |
| } else { |
| fields.add(member); |
| DartType type = localsHandler.substInContext(member.type); |
| constructorArguments.add(potentiallyCheckOrTrustType(value, type)); |
| } |
| }, |
| includeSuperAndInjectedMembers: true); |
| |
| InterfaceType type = classElement.thisType; |
| TypeMask ssaType = |
| new TypeMask.nonNullExact(classElement.declaration, compiler.world); |
| List<DartType> instantiatedTypes; |
| addInlinedInstantiation(type); |
| if (!currentInlinedInstantiations.isEmpty) { |
| instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations); |
| } |
| |
| HInstruction newObject; |
| if (!isNativeUpgradeFactory) { |
| newObject = new HForeignNew(classElement, |
| ssaType, |
| constructorArguments, |
| instantiatedTypes); |
| add(newObject); |
| } else { |
| // Bulk assign to the initialized fields. |
| newObject = graph.explicitReceiverParameter; |
| // Null guard ensures an error if we are being called from an explicit |
| // 'new' of the constructor instead of via an upgrade. It is optimized out |
| // if there are field initializers. |
| add(new HFieldGet( |
| null, newObject, backend.dynamicType, isAssignable: false)); |
| for (int i = 0; i < fields.length; i++) { |
| add(new HFieldSet(fields[i], newObject, constructorArguments[i])); |
| } |
| } |
| removeInlinedInstantiation(type); |
| // Create the runtime type information, if needed. |
| if (backend.classNeedsRti(classElement)) { |
| // Read the values of the type arguments and create a list to set on the |
| // newly create object. We can identify the case where the new list |
| // would be of the form: |
| // [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)] |
| // and k is the number of type arguments of this. If this is the case, |
| // we can simply copy the list from this. |
| |
| // These locals are modified by [isIndexedTypeArgumentGet]. |
| HThis source; // The source of the type arguments. |
| bool allIndexed = true; |
| int expectedIndex = 0; |
| ClassElement contextClass; // The class of `this`. |
| int remainingTypeVariables; // The number of 'remaining type variables' |
| // of `this`. |
| |
| /// Helper to identify instructions that read a type variable without |
| /// substitution (that is, directly use the index). These instructions |
| /// are of the form: |
| /// HInvokeStatic(getTypeArgumentByIndex, this, index) |
| /// |
| /// Return `true` if [instruction] is of that form and the index is the |
| /// next index in the sequence (held in [expectedIndex]). |
| bool isIndexedTypeArgumentGet(HInstruction instruction) { |
| if (instruction is! HInvokeStatic) return false; |
| HInvokeStatic invoke = instruction; |
| if (invoke.element != backend.getGetTypeArgumentByIndex()) { |
| return false; |
| } |
| HConstant index = invoke.inputs[1]; |
| HInstruction newSource = invoke.inputs[0]; |
| if (newSource is! HThis) { |
| return false; |
| } |
| if (source == null) { |
| // This is the first match. Extract the context class for the type |
| // variables and get the list of type variables to keep track of how |
| // many arguments we need to process. |
| source = newSource; |
| contextClass = source.sourceElement.enclosingClass; |
| remainingTypeVariables = contextClass.typeVariables.length; |
| } else { |
| assert(source == newSource); |
| } |
| // If there are no more type variables, then there are more type |
| // arguments for the new object than the source has, and it can't be |
| // a copy. Otherwise remove one argument. |
| if (remainingTypeVariables == 0) return false; |
| remainingTypeVariables--; |
| // Check that the index is the one we expect. |
| IntConstantValue constant = index.constant; |
| return constant.primitiveValue == expectedIndex++; |
| } |
| |
| List<HInstruction> typeArguments = <HInstruction>[]; |
| classElement.typeVariables.forEach((TypeVariableType typeVariable) { |
| HInstruction argument = localsHandler.readLocal( |
| localsHandler.getTypeVariableAsLocal(typeVariable)); |
| if (allIndexed && !isIndexedTypeArgumentGet(argument)) { |
| allIndexed = false; |
| } |
| typeArguments.add(argument); |
| }); |
| |
| if (source != null && allIndexed && remainingTypeVariables == 0) { |
| copyRuntimeTypeInfo(source, newObject); |
| } else { |
| newObject = |
| callSetRuntimeTypeInfo(classElement, typeArguments, newObject); |
| } |
| } |
| |
| // Generate calls to the constructor bodies. |
| HInstruction interceptor = null; |
| for (int index = constructors.length - 1; index >= 0; index--) { |
| FunctionElement constructor = constructors[index]; |
| assert(invariant(functionElement, constructor.isImplementation)); |
| ConstructorBodyElement body = getConstructorBody(constructor); |
| if (body == null) continue; |
| |
| List bodyCallInputs = <HInstruction>[]; |
| if (isNativeUpgradeFactory) { |
| if (interceptor == null) { |
| ConstantValue constant = |
| new InterceptorConstantValue(classElement.thisType); |
| interceptor = graph.addConstant(constant, compiler); |
| } |
| bodyCallInputs.add(interceptor); |
| } |
| bodyCallInputs.add(newObject); |
| ResolvedAst resolvedAst = constructor.resolvedAst; |
| TreeElements elements = resolvedAst.elements; |
| ast.Node node = resolvedAst.node; |
| ClosureClassMap parameterClosureData = |
| compiler.closureToClassMapper.getMappingForNestedFunction(node); |
| |
| FunctionSignature functionSignature = body.functionSignature; |
| // Provide the parameters to the generative constructor body. |
| functionSignature.orderedForEachParameter((ParameterElement parameter) { |
| // If [parameter] is boxed, it will be a field in the box passed as the |
| // last parameter. So no need to directly pass it. |
| if (!localsHandler.isBoxed(parameter)) { |
| bodyCallInputs.add(localsHandler.readLocal(parameter)); |
| } |
| }); |
| |
| ClassElement currentClass = constructor.enclosingClass; |
| if (backend.classNeedsRti(currentClass)) { |
| // If [currentClass] needs RTI, we add the type variables as |
| // parameters of the generative constructor body. |
| currentClass.typeVariables.forEach((TypeVariableType argument) { |
| // TODO(johnniwinther): Substitute [argument] with |
| // `localsHandler.substInContext(argument)`. |
| bodyCallInputs.add(localsHandler.readLocal( |
| localsHandler.getTypeVariableAsLocal(argument))); |
| }); |
| } |
| |
| // If there are locals that escape (ie mutated in closures), we |
| // pass the box to the constructor. |
| ClosureScope scopeData = parameterClosureData.capturingScopes[node]; |
| if (scopeData != null) { |
| bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement)); |
| } |
| |
| if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining. |
| tryInlineMethod(body, null, bodyCallInputs, function)) { |
| pop(); |
| } else { |
| HInvokeConstructorBody invoke = new HInvokeConstructorBody( |
| body.declaration, bodyCallInputs, backend.nonNullType); |
| invoke.sideEffects = |
| compiler.world.getSideEffectsOfElement(constructor); |
| add(invoke); |
| } |
| } |
| if (inliningStack.isEmpty) { |
| closeAndGotoExit(new HReturn(newObject)); |
| return closeFunction(); |
| } else { |
| localsHandler.updateLocal(returnLocal, newObject); |
| return null; |
| } |
| } |
| |
| /** |
| * Documentation wanted -- johnniwinther |
| * |
| * Invariant: [functionElement] must be the implementation element. |
| */ |
| void openFunction(Element element, ast.Node node) { |
| assert(invariant(element, element.isImplementation)); |
| HBasicBlock block = graph.addNewBlock(); |
| open(graph.entry); |
| |
| localsHandler.startFunction(element, node); |
| close(new HGoto()).addSuccessor(block); |
| |
| open(block); |
| |
| // Add the type parameters of the class as parameters of this method. This |
| // must be done before adding the normal parameters, because their types |
| // may contain references to type variables. |
| var enclosing = element.enclosingElement; |
| if ((element.isConstructor || element.isGenerativeConstructorBody) |
| && backend.classNeedsRti(enclosing)) { |
| enclosing.typeVariables.forEach((TypeVariableType typeVariable) { |
| HParameterValue param = addParameter( |
| typeVariable.element, backend.nonNullType); |
| localsHandler.directLocals[ |
| localsHandler.getTypeVariableAsLocal(typeVariable)] = param; |
| }); |
| } |
| |
| if (element is FunctionElement) { |
| FunctionElement functionElement = element; |
| FunctionSignature signature = functionElement.functionSignature; |
| |
| // Put the type checks in the first successor of the entry, |
| // because that is where the type guards will also be inserted. |
| // This way we ensure that a type guard will dominate the type |
| // check. |
| ClosureScope scopeData = |
| localsHandler.closureData.capturingScopes[node]; |
| signature.orderedForEachParameter((ParameterElement parameterElement) { |
| if (element.isGenerativeConstructorBody) { |
| if (scopeData != null && |
| scopeData.isCapturedVariable(parameterElement)) { |
| // The parameter will be a field in the box passed as the |
| // last parameter. So no need to have it. |
| return; |
| } |
| } |
| HInstruction newParameter = |
| localsHandler.directLocals[parameterElement]; |
| if (!element.isConstructor || |
| !(element as ConstructorElement).isRedirectingFactory) { |
| // Redirection factories must not check their argument types. |
| // Example: |
| // |
| // class A { |
| // A(String foo) = A.b; |
| // A(int foo) { print(foo); } |
| // } |
| // main() { |
| // new A(499); // valid even in checked mode. |
| // new A("foo"); // invalid in checked mode. |
| // |
| // Only the final target is allowed to check for the argument types. |
| newParameter = |
| potentiallyCheckOrTrustType(newParameter, parameterElement.type); |
| } |
| localsHandler.directLocals[parameterElement] = newParameter; |
| }); |
| |
| returnType = signature.type.returnType; |
| } else { |
| // Otherwise it is a lazy initializer which does not have parameters. |
| assert(element is VariableElement); |
| } |
| |
| insertTraceCall(element); |
| } |
| |
| insertTraceCall(Element element) { |
| if (JavaScriptBackend.TRACE_CALLS) { |
| if (element == backend.traceHelper) return; |
| n(e) => e == null ? '' : e.name; |
| String name = "${n(element.library)}:${n(element.enclosingClass)}." |
| "${n(element)}"; |
| HConstant nameConstant = addConstantString(name); |
| add(new HInvokeStatic(backend.traceHelper, |
| <HInstruction>[nameConstant], |
| backend.dynamicType)); |
| } |
| } |
| |
| /// Check that [type] is valid in the context of `localsHandler.contextClass`. |
| /// This should only be called in assertions. |
| bool assertTypeInContext(DartType type, [Spannable spannable]) { |
| return invariant(spannable == null ? CURRENT_ELEMENT_SPANNABLE : spannable, |
| () { |
| ClassElement contextClass = Types.getClassContext(type); |
| return contextClass == null || |
| contextClass == localsHandler.contextClass; |
| }, |
| message: "Type '$type' is not valid context of " |
| "${localsHandler.contextClass}."); |
| } |
| |
| /// Build a [HTypeConversion] for convertion [original] to type [type]. |
| /// |
| /// Invariant: [type] must be valid in the context. |
| /// See [LocalsHandler.substInContext]. |
| HInstruction buildTypeConversion(HInstruction original, |
| DartType type, |
| int kind) { |
| if (type == null) return original; |
| type = type.unalias(compiler); |
| assert(assertTypeInContext(type, original)); |
| if (type.isInterfaceType && !type.treatAsRaw) { |
| TypeMask subtype = new TypeMask.subtype(type.element, compiler.world); |
| HInstruction representations = buildTypeArgumentRepresentations(type); |
| add(representations); |
| return new HTypeConversion.withTypeRepresentation(type, kind, subtype, |
| original, representations); |
| } else if (type.isTypeVariable) { |
| TypeMask subtype = original.instructionType; |
| HInstruction typeVariable = addTypeVariableReference(type); |
| return new HTypeConversion.withTypeRepresentation(type, kind, subtype, |
| original, typeVariable); |
| } else if (type.isFunctionType) { |
| String name = kind == HTypeConversion.CAST_TYPE_CHECK |
| ? '_asCheck' : '_assertCheck'; |
| |
| List arguments = [buildFunctionType(type), original]; |
| pushInvokeDynamic( |
| null, |
| new Selector.call(name, backend.jsHelperLibrary, 1), |
| arguments); |
| |
| return new HTypeConversion(type, kind, original.instructionType, pop()); |
| } else { |
| return original.convertType(compiler, type, kind); |
| } |
| } |
| |
| HInstruction _trustType(HInstruction original, DartType type) { |
| assert(compiler.trustTypeAnnotations); |
| assert(type != null); |
| type = localsHandler.substInContext(type); |
| type = type.unalias(compiler); |
| if (type.isDynamic) return original; |
| if (!type.isInterfaceType) return original; |
| // The type element is either a class or the void element. |
| Element element = type.element; |
| if (element == compiler.objectClass) return original; |
| TypeMask mask = new TypeMask.subtype(element, compiler.world); |
| return new HTypeKnown.pinned(mask, original); |
| } |
| |
| HInstruction _checkType(HInstruction original, DartType type, int kind) { |
| assert(compiler.enableTypeAssertions); |
| assert(type != null); |
| type = localsHandler.substInContext(type); |
| HInstruction other = buildTypeConversion(original, type, kind); |
| registry.registerIsCheck(type); |
| return other; |
| } |
| |
| HInstruction potentiallyCheckOrTrustType(HInstruction original, DartType type, |
| { int kind: HTypeConversion.CHECKED_MODE_CHECK }) { |
| if (type == null) return original; |
| HInstruction checkedOrTrusted = original; |
| if (compiler.trustTypeAnnotations) { |
| checkedOrTrusted = _trustType(original, type); |
| } else if (compiler.enableTypeAssertions) { |
| checkedOrTrusted = _checkType(original, type, kind); |
| } |
| if (checkedOrTrusted == original) return original; |
| add(checkedOrTrusted); |
| return checkedOrTrusted; |
| } |
| |
| void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype, |
| String message) { |
| HInstruction subtypeInstruction = |
| analyzeTypeArgument(localsHandler.substInContext(subtype)); |
| HInstruction supertypeInstruction = |
| analyzeTypeArgument(localsHandler.substInContext(supertype)); |
| HInstruction messageInstruction = |
| graph.addConstantString(new ast.DartString.literal(message), compiler); |
| Element element = backend.getAssertIsSubtype(); |
| var inputs = <HInstruction>[subtypeInstruction, supertypeInstruction, |
| messageInstruction]; |
| HInstruction assertIsSubtype = new HInvokeStatic( |
| element, inputs, subtypeInstruction.instructionType); |
| registry.registerTypeVariableBoundsSubtypeCheck(subtype, supertype); |
| add(assertIsSubtype); |
| } |
| |
| HGraph closeFunction() { |
| // TODO(kasperl): Make this goto an implicit return. |
| if (!isAborted()) closeAndGotoExit(new HGoto()); |
| graph.finalize(); |
| return graph; |
| } |
| |
| void push(HInstruction instruction) { |
| add(instruction); |
| stack.add(instruction); |
| } |
| |
| void pushWithPosition(HInstruction instruction, ast.Node node) { |
| push(attachPosition(instruction, node)); |
| } |
| |
| HInstruction pop() { |
| return stack.removeLast(); |
| } |
| |
| void dup() { |
| stack.add(stack.last); |
| } |
| |
| HInstruction popBoolified() { |
| HInstruction value = pop(); |
| if (_checkOrTrustTypes) { |
| return potentiallyCheckOrTrustType( |
| value, |
| compiler.boolClass.rawType, |
| kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK); |
| } |
| HInstruction result = new HBoolify(value, backend.boolType); |
| add(result); |
| return result; |
| } |
| |
| HInstruction attachPosition(HInstruction target, ast.Node node) { |
| if (generateSourceMap && node != null) { |
| target.sourcePosition = sourceFileLocationForBeginToken(node); |
| } |
| return target; |
| } |
| |
| SourceFileLocation sourceFileLocationForBeginToken(ast.Node node) => |
| sourceFileLocationForToken(node, node.getBeginToken()); |
| |
| SourceFileLocation sourceFileLocationForEndToken(ast.Node node) => |
| sourceFileLocationForToken(node, node.getEndToken()); |
| |
| SourceFileLocation sourceFileLocationForToken(ast.Node node, Token token) { |
| SourceFile sourceFile = currentSourceFile(); |
| SourceFileLocation location = |
| new TokenSourceFileLocation(sourceFile, token, sourceElement.name); |
| checkValidSourceFileLocation(location, sourceFile, token.charOffset); |
| return location; |
| } |
| |
| void visit(ast.Node node) { |
| if (node != null) node.accept(this); |
| } |
| |
| visitBlock(ast.Block node) { |
| assert(!isAborted()); |
| if (!isReachable) return; // This can only happen when inlining. |
| for (Link<ast.Node> link = node.statements.nodes; |
| !link.isEmpty; |
| link = link.tail) { |
| visit(link.head); |
| if (!isReachable) { |
| // The block has been aborted by a return or a throw. |
| if (!stack.isEmpty) { |
| compiler.internalError(node, 'Non-empty instruction stack.'); |
| } |
| return; |
| } |
| } |
| assert(!current.isClosed()); |
| if (!stack.isEmpty) { |
| compiler.internalError(node, 'Non-empty instruction stack.'); |
| } |
| } |
| |
| visitClassNode(ast.ClassNode node) { |
| compiler.internalError(node, |
| 'SsaBuilder.visitClassNode should not be called.'); |
| } |
| |
| visitThrowExpression(ast.Expression expression) { |
| bool old = inExpressionOfThrow; |
| try { |
| inExpressionOfThrow = true; |
| visit(expression); |
| } finally { |
| inExpressionOfThrow = old; |
| } |
| } |
| |
| visitExpressionStatement(ast.ExpressionStatement node) { |
| if (!isReachable) return; |
| ast.Throw throwExpression = node.expression.asThrow(); |
| if (throwExpression != null && inliningStack.isEmpty) { |
| visitThrowExpression(throwExpression.expression); |
| handleInTryStatement(); |
| closeAndGotoExit(new HThrow(pop())); |
| } else { |
| visit(node.expression); |
| pop(); |
| } |
| } |
| |
| /** |
| * Creates a new loop-header block. The previous [current] block |
| * is closed with an [HGoto] and replaced by the newly created block. |
| * Also notifies the locals handler that we're entering a loop. |
| */ |
| JumpHandler beginLoopHeader(ast.Node node) { |
| assert(!isAborted()); |
| HBasicBlock previousBlock = close(new HGoto()); |
| |
| JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: true); |
| HBasicBlock loopEntry = graph.addNewLoopHeaderBlock( |
| jumpHandler.target, |
| jumpHandler.labels()); |
| previousBlock.addSuccessor(loopEntry); |
| open(loopEntry); |
| |
| localsHandler.beginLoopHeader(loopEntry); |
| return jumpHandler; |
| } |
| |
| /** |
| * Ends the loop: |
| * - creates a new block and adds it as successor to the [branchExitBlock] and |
| * any blocks that end in break. |
| * - opens the new block (setting as [current]). |
| * - notifies the locals handler that we're exiting a loop. |
| * [savedLocals] are the locals from the end of the loop condition. |
| * [branchExitBlock] is the exit (branching) block of the condition. Generally |
| * this is not the top of the loop, since this would lead to critical edges. |
| * It is null for degenerate do-while loops that have |
| * no back edge because they abort (throw/return/break in the body and have |
| * no continues). |
| */ |
| void endLoop(HBasicBlock loopEntry, |
| HBasicBlock branchExitBlock, |
| JumpHandler jumpHandler, |
| LocalsHandler savedLocals) { |
| HBasicBlock loopExitBlock = addNewBlock(); |
| |
| List<LocalsHandler> breakHandlers = <LocalsHandler>[]; |
| // Collect data for the successors and the phis at each break. |
| jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) { |
| breakInstruction.block.addSuccessor(loopExitBlock); |
| breakHandlers.add(locals); |
| }); |
| |
| // The exit block is a successor of the loop condition if it is reached. |
| // We don't add the successor in the case of a while/for loop that aborts |
| // because the caller of endLoop will be wiring up a special empty else |
| // block instead. |
| if (branchExitBlock != null) { |
| branchExitBlock.addSuccessor(loopExitBlock); |
| } |
| // Update the phis at the loop entry with the current values of locals. |
| localsHandler.endLoop(loopEntry); |
| |
| // Start generating code for the exit block. |
| open(loopExitBlock); |
| |
| // Create a new localsHandler for the loopExitBlock with the correct phis. |
| if (!breakHandlers.isEmpty) { |
| if (branchExitBlock != null) { |
| // Add the values of the locals at the end of the condition block to |
| // the phis. These are the values that flow to the exit if the |
| // condition fails. |
| breakHandlers.add(savedLocals); |
| } |
| localsHandler = savedLocals.mergeMultiple(breakHandlers, loopExitBlock); |
| } else { |
| localsHandler = savedLocals; |
| } |
| } |
| |
| HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) { |
| if (statements == null) return null; |
| return new HSubGraphBlockInformation(statements); |
| } |
| |
| HSubExpressionBlockInformation wrapExpressionGraph(SubExpression expression) { |
| if (expression == null) return null; |
| return new HSubExpressionBlockInformation(expression); |
| } |
| |
| // For while loops, initializer and update are null. |
| // The condition function must return a boolean result. |
| // None of the functions must leave anything on the stack. |
| void handleLoop(ast.Node loop, |
| void initialize(), |
| HInstruction condition(), |
| void update(), |
| void body()) { |
| // Generate: |
| // <initializer> |
| // loop-entry: |
| // if (!<condition>) goto loop-exit; |
| // <body> |
| // <updates> |
| // goto loop-entry; |
| // loop-exit: |
| |
| localsHandler.startLoop(loop); |
| |
| // The initializer. |
| SubExpression initializerGraph = null; |
| HBasicBlock startBlock; |
| if (initialize != null) { |
| HBasicBlock initializerBlock = openNewBlock(); |
| startBlock = initializerBlock; |
| initialize(); |
| assert(!isAborted()); |
| initializerGraph = |
| new SubExpression(initializerBlock, current); |
| } |
| |
| loopNesting++; |
| JumpHandler jumpHandler = beginLoopHeader(loop); |
| HLoopInformation loopInfo = current.loopInformation; |
| HBasicBlock conditionBlock = current; |
| if (startBlock == null) startBlock = conditionBlock; |
| |
| HInstruction conditionInstruction = condition(); |
| HBasicBlock conditionEndBlock = |
| close(new HLoopBranch(conditionInstruction)); |
| SubExpression conditionExpression = |
| new SubExpression(conditionBlock, conditionEndBlock); |
| |
| // Save the values of the local variables at the end of the condition |
| // block. These are the values that will flow to the loop exit if the |
| // condition fails. |
| LocalsHandler savedLocals = new LocalsHandler.from(localsHandler); |
| |
| // The body. |
| HBasicBlock beginBodyBlock = addNewBlock(); |
| conditionEndBlock.addSuccessor(beginBodyBlock); |
| open(beginBodyBlock); |
| |
| localsHandler.enterLoopBody(loop); |
| body(); |
| |
| SubGraph bodyGraph = new SubGraph(beginBodyBlock, lastOpenedBlock); |
| HBasicBlock bodyBlock = current; |
| if (current != null) close(new HGoto()); |
| |
| SubExpression updateGraph; |
| |
| bool loopIsDegenerate = !jumpHandler.hasAnyContinue() && bodyBlock == null; |
| if (!loopIsDegenerate) { |
| // Update. |
| // We create an update block, even when we are in a while loop. There the |
| // update block is the jump-target for continue statements. We could avoid |
| // the creation if there is no continue, but for now we always create it. |
| HBasicBlock updateBlock = addNewBlock(); |
| |
| List<LocalsHandler> continueHandlers = <LocalsHandler>[]; |
| jumpHandler.forEachContinue((HContinue instruction, |
| LocalsHandler locals) { |
| instruction.block.addSuccessor(updateBlock); |
| continueHandlers.add(locals); |
| }); |
| |
| |
| if (bodyBlock != null) { |
| continueHandlers.add(localsHandler); |
| bodyBlock.addSuccessor(updateBlock); |
| } |
| |
| open(updateBlock); |
| localsHandler = |
| continueHandlers[0].mergeMultiple(continueHandlers, updateBlock); |
| |
| HLabeledBlockInformation labelInfo; |
| List<LabelDefinition> labels = jumpHandler.labels(); |
| JumpTarget target = elements.getTargetDefinition(loop); |
| if (!labels.isEmpty) { |
| beginBodyBlock.setBlockFlow( |
| new HLabeledBlockInformation( |
| new HSubGraphBlockInformation(bodyGraph), |
| jumpHandler.labels(), |
| isContinue: true), |
| updateBlock); |
| } else if (target != null && target.isContinueTarget) { |
| beginBodyBlock.setBlockFlow( |
| new HLabeledBlockInformation.implicit( |
| new HSubGraphBlockInformation(bodyGraph), |
| target, |
| isContinue: true), |
| updateBlock); |
| } |
| |
| localsHandler.enterLoopUpdates(loop); |
| |
| update(); |
| |
| HBasicBlock updateEndBlock = close(new HGoto()); |
| // The back-edge completing the cycle. |
| updateEndBlock.addSuccessor(conditionBlock); |
| updateGraph = new SubExpression(updateBlock, updateEndBlock); |
| |
| // Avoid a critical edge from the condition to the loop-exit body. |
| HBasicBlock conditionExitBlock = addNewBlock(); |
| open(conditionExitBlock); |
| close(new HGoto()); |
| conditionEndBlock.addSuccessor(conditionExitBlock); |
| |
| endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals); |
| |
| conditionBlock.postProcessLoopHeader(); |
| HLoopBlockInformation info = |
| new HLoopBlockInformation( |
| HLoopBlockInformation.loopType(loop), |
| wrapExpressionGraph(initializerGraph), |
| wrapExpressionGraph(conditionExpression), |
| wrapStatementGraph(bodyGraph), |
| wrapExpressionGraph(updateGraph), |
| conditionBlock.loopInformation.target, |
| conditionBlock.loopInformation.labels, |
| sourceFileLocationForBeginToken(loop), |
| sourceFileLocationForEndToken(loop)); |
| |
| startBlock.setBlockFlow(info, current); |
| loopInfo.loopBlockInformation = info; |
| } else { |
| // The body of the for/while loop always aborts, so there is no back edge. |
| // We turn the code into: |
| // if (condition) { |
| // body; |
| // } else { |
| // // We always create an empty else block to avoid critical edges. |
| // } |
| // |
| // If there is any break in the body, we attach a synthetic |
| // label to the if. |
| HBasicBlock elseBlock = addNewBlock(); |
| open(elseBlock); |
| close(new HGoto()); |
| // Pass the elseBlock as the branchBlock, because that's the block we go |
| // to just before leaving the 'loop'. |
| endLoop(conditionBlock, elseBlock, jumpHandler, savedLocals); |
| |
| SubGraph elseGraph = new SubGraph(elseBlock, elseBlock); |
| // Remove the loop information attached to the header. |
| conditionBlock.loopInformation = null; |
| |
| // Remove the [HLoopBranch] instruction and replace it with |
| // [HIf]. |
| HInstruction condition = conditionEndBlock.last.inputs[0]; |
| conditionEndBlock.addAtExit(new HIf(condition)); |
| conditionEndBlock.addSuccessor(elseBlock); |
| conditionEndBlock.remove(conditionEndBlock.last); |
| HIfBlockInformation info = |
| new HIfBlockInformation( |
| wrapExpressionGraph(conditionExpression), |
| wrapStatementGraph(bodyGraph), |
| wrapStatementGraph(elseGraph)); |
| |
| conditionEndBlock.setBlockFlow(info, current); |
| HIf ifBlock = conditionEndBlock.last; |
| ifBlock.blockInformation = conditionEndBlock.blockFlow; |
| |
| // If the body has any break, attach a synthesized label to the |
| // if block. |
| if (jumpHandler.hasAnyBreak()) { |
| JumpTarget target = elements.getTargetDefinition(loop); |
| LabelDefinition label = target.addLabel(null, 'loop'); |
| label.setBreakTarget(); |
| SubGraph labelGraph = new SubGraph(conditionBlock, current); |
| HLabeledBlockInformation labelInfo = new HLabeledBlockInformation( |
| new HSubGraphBlockInformation(labelGraph), |
| <LabelDefinition>[label]); |
| |
| conditionBlock.setBlockFlow(labelInfo, current); |
| |
| jumpHandler.forEachBreak((HBreak breakInstruction, _) { |
| HBasicBlock block = breakInstruction.block; |
| block.addAtExit(new HBreak.toLabel(label)); |
| block.remove(breakInstruction); |
| }); |
| } |
| } |
| jumpHandler.close(); |
| loopNesting--; |
| } |
| |
| visitFor(ast.For node) { |
| assert(isReachable); |
| assert(node.body != null); |
| void buildInitializer() { |
| ast.Node initializer = node.initializer; |
| if (initializer == null) return; |
| visit(initializer); |
| if (initializer.asExpression() != null) { |
| pop(); |
| } |
| } |
| HInstruction buildCondition() { |
| if (node.condition == null) { |
| return graph.addConstantBool(true, compiler); |
| } |
| visit(node.condition); |
| return popBoolified(); |
| } |
| void buildUpdate() { |
| for (ast.Expression expression in node.update) { |
| visit(expression); |
| assert(!isAborted()); |
| // The result of the update instruction isn't used, and can just |
| // be dropped. |
| HInstruction updateInstruction = pop(); |
| } |
| } |
| void buildBody() { |
| visit(node.body); |
| } |
| handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody); |
| } |
| |
| visitWhile(ast.While node) { |
| assert(isReachable); |
| HInstruction buildCondition() { |
| visit(node.condition); |
| return popBoolified(); |
| } |
| handleLoop(node, |
| () {}, |
| buildCondition, |
| () {}, |
| () { visit(node.body); }); |
| } |
| |
| visitDoWhile(ast.DoWhile node) { |
| assert(isReachable); |
| LocalsHandler savedLocals = new LocalsHandler.from(localsHandler); |
| localsHandler.startLoop(node); |
| loopNesting++; |
| JumpHandler jumpHandler = beginLoopHeader(node); |
| HLoopInformation loopInfo = current.loopInformation; |
| HBasicBlock loopEntryBlock = current; |
| HBasicBlock bodyEntryBlock = current; |
| JumpTarget target = elements.getTargetDefinition(node); |
| bool hasContinues = target != null && target.isContinueTarget; |
| if (hasContinues) { |
| // Add extra block to hang labels on. |
| // It doesn't currently work if they are on the same block as the |
| // HLoopInfo. The handling of HLabeledBlockInformation will visit a |
| // SubGraph that starts at the same block again, so the HLoopInfo is |
| // either handled twice, or it's handled after the labeled block info, |
| // both of which generate the wrong code. |
| // Using a separate block is just a simple workaround. |
| bodyEntryBlock = openNewBlock(); |
| } |
| localsHandler.enterLoopBody(node); |
| visit(node.body); |
| |
| // If there are no continues we could avoid the creation of the condition |
| // block. This could also lead to a block having multiple entries and exits. |
| HBasicBlock bodyExitBlock; |
| bool isAbortingBody = false; |
| if (current != null) { |
| bodyExitBlock = close(new HGoto()); |
| } else { |
| isAbortingBody = true; |
| bodyExitBlock = lastOpenedBlock; |
| } |
| |
| SubExpression conditionExpression; |
| bool loopIsDegenerate = isAbortingBody && !hasContinues; |
| if (!loopIsDegenerate) { |
| HBasicBlock conditionBlock = addNewBlock(); |
| |
| List<LocalsHandler> continueHandlers = <LocalsHandler>[]; |
| jumpHandler.forEachContinue((HContinue instruction, |
| LocalsHandler locals) { |
| instruction.block.addSuccessor(conditionBlock); |
| continueHandlers.add(locals); |
| }); |
| |
| if (!isAbortingBody) { |
| bodyExitBlock.addSuccessor(conditionBlock); |
| } |
| |
| if (!continueHandlers.isEmpty) { |
| if (!isAbortingBody) continueHandlers.add(localsHandler); |
| localsHandler = |
| savedLocals.mergeMultiple(continueHandlers, conditionBlock); |
| SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock); |
| List<LabelDefinition> labels = jumpHandler.labels(); |
| HSubGraphBlockInformation bodyInfo = |
| new HSubGraphBlockInformation(bodyGraph); |
| HLabeledBlockInformation info; |
| if (!labels.isEmpty) { |
| info = new HLabeledBlockInformation(bodyInfo, labels, |
| isContinue: true); |
| } else { |
| info = new HLabeledBlockInformation.implicit(bodyInfo, target, |
| isContinue: true); |
| } |
| bodyEntryBlock.setBlockFlow(info, conditionBlock); |
| } |
| open(conditionBlock); |
| |
| visit(node.condition); |
| assert(!isAborted()); |
| HInstruction conditionInstruction = popBoolified(); |
| HBasicBlock conditionEndBlock = close( |
| new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP)); |
| |
| HBasicBlock avoidCriticalEdge = addNewBlock(); |
| conditionEndBlock.addSuccessor(avoidCriticalEdge); |
| open(avoidCriticalEdge); |
| close(new HGoto()); |
| avoidCriticalEdge.addSuccessor(loopEntryBlock); // The back-edge. |
| |
| conditionExpression = |
| new SubExpression(conditionBlock, conditionEndBlock); |
| |
| // Avoid a critical edge from the condition to the loop-exit body. |
| HBasicBlock conditionExitBlock = addNewBlock(); |
| open(conditionExitBlock); |
| close(new HGoto()); |
| conditionEndBlock.addSuccessor(conditionExitBlock); |
| |
| endLoop(loopEntryBlock, conditionExitBlock, jumpHandler, localsHandler); |
| |
| loopEntryBlock.postProcessLoopHeader(); |
| SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock); |
| HLoopBlockInformation loopBlockInfo = |
| new HLoopBlockInformation( |
| HLoopBlockInformation.DO_WHILE_LOOP, |
| null, |
| wrapExpressionGraph(conditionExpression), |
| wrapStatementGraph(bodyGraph), |
| null, |
| loopEntryBlock.loopInformation.target, |
| loopEntryBlock.loopInformation.labels, |
| sourceFileLocationForBeginToken(node), |
| sourceFileLocationForEndToken(node)); |
| loopEntryBlock.setBlockFlow(loopBlockInfo, current); |
| loopInfo.loopBlockInformation = loopBlockInfo; |
| } else { |
| // Since the loop has no back edge, we remove the loop information on the |
| // header. |
| loopEntryBlock.loopInformation = null; |
| |
| if (jumpHandler.hasAnyBreak()) { |
| // Null branchBlock because the body of the do-while loop always aborts, |
| // so we never get to the condition. |
| endLoop(loopEntryBlock, null, jumpHandler, localsHandler); |
| |
| // Since the body of the loop has a break, we attach a synthesized label |
| // to the body. |
| SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock); |
| JumpTarget target = elements.getTargetDefinition(node); |
| LabelDefinition label = target.addLabel(null, 'loop'); |
| label.setBreakTarget(); |
| HLabeledBlockInformation info = new HLabeledBlockInformation( |
| new HSubGraphBlockInformation(bodyGraph), <LabelDefinition>[label]); |
| loopEntryBlock.setBlockFlow(info, current); |
| jumpHandler.forEachBreak((HBreak breakInstruction, _) { |
| HBasicBlock block = breakInstruction.block; |
| block.addAtExit(new HBreak.toLabel(label)); |
| block.remove(breakInstruction); |
| }); |
| } |
| } |
| jumpHandler.close(); |
| loopNesting--; |
| } |
| |
| visitFunctionExpression(ast.FunctionExpression node) { |
| ClosureClassMap nestedClosureData = |
| compiler.closureToClassMapper.getMappingForNestedFunction(node); |
| assert(nestedClosureData != null); |
| assert(nestedClosureData.closureClassElement != null); |
| ClosureClassElement closureClassElement = |
| nestedClosureData.closureClassElement; |
| FunctionElement callElement = nestedClosureData.callElement; |
| // TODO(ahe): This should be registered in codegen, not here. |
| // TODO(johnniwinther): Is [registerStaticUse] equivalent to |
| // [addToWorkList]? |
| registry.registerStaticUse(callElement); |
| // TODO(ahe): This should be registered in codegen, not here. |
| registry.registerInstantiatedClass(closureClassElement); |
| |
| List<HInstruction> capturedVariables = <HInstruction>[]; |
| closureClassElement.closureFields.forEach((ClosureFieldElement field) { |
| Local capturedLocal = |
| nestedClosureData.getLocalVariableForClosureField(field); |
| assert(capturedLocal != null); |
| capturedVariables.add(localsHandler.readLocal(capturedLocal)); |
| }); |
| |
| TypeMask type = |
| new TypeMask.nonNullExact(compiler.functionClass, compiler.world); |
| push(new HForeignNew(closureClassElement, type, capturedVariables)); |
| |
| Element methodElement = nestedClosureData.closureElement; |
| if (compiler.backend.methodNeedsRti(methodElement)) { |
| registry.registerClosureWithFreeTypeVariables(methodElement); |
| } |
| } |
| |
| visitFunctionDeclaration(ast.FunctionDeclaration node) { |
| assert(isReachable); |
| visit(node.function); |
| LocalFunctionElement localFunction = |
| elements.getFunctionDefinition(node.function); |
| localsHandler.updateLocal(localFunction, pop()); |
| } |
| |
| visitIdentifier(ast.Identifier node) { |
| if (node.isThis()) { |
| stack.add(localsHandler.readThis()); |
| } else { |
| compiler.internalError(node, |
| "SsaFromAstMixin.visitIdentifier on non-this."); |
| } |
| } |
| |
| visitIf(ast.If node) { |
| assert(isReachable); |
| handleIf(node, |
| () => visit(node.condition), |
| () => visit(node.thenPart), |
| node.elsePart != null ? () => visit(node.elsePart) : null); |
| } |
| |
| void handleIf(ast.Node diagnosticNode, |
| void visitCondition(), void visitThen(), void visitElse()) { |
| SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode); |
| branchBuilder.handleIf(visitCondition, visitThen, visitElse); |
| } |
| |
| void visitLogicalAndOr(ast.Send node, ast.Operator op) { |
| SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node); |
| branchBuilder.handleLogicalAndOrWithLeftNode( |
| node.receiver, |
| () { visit(node.argumentsNode); }, |
| isAnd: ("&&" == op.source)); |
| } |
| |
| void visitLogicalNot(ast.Send node) { |
| assert(node.argumentsNode is ast.Prefix); |
| visit(node.receiver); |
| HNot not = new HNot(popBoolified(), backend.boolType); |
| pushWithPosition(not, node); |
| } |
| |
| void visitUnary(ast.Send node, ast.Operator op) { |
| assert(node.argumentsNode is ast.Prefix); |
| visit(node.receiver); |
| assert(!identical(op.token.kind, PLUS_TOKEN)); |
| HInstruction operand = pop(); |
| |
| // See if we can constant-fold right away. This avoids rewrites later on. |
| if (operand is HConstant) { |
| UnaryOperation operation = constantSystem.lookupUnary(op.source); |
| HConstant constant = operand; |
| ConstantValue folded = operation.fold(constant.constant); |
| if (folded != null) { |
| stack.add(graph.addConstant(folded, compiler)); |
| return; |
| } |
| } |
| |
| pushInvokeDynamic(node, elements.getSelector(node), [operand]); |
| } |
| |
| void visitBinary(HInstruction left, |
| ast.Operator op, |
| HInstruction right, |
| Selector selector, |
| ast.Send send) { |
| switch (op.source) { |
| case "===": |
| pushWithPosition( |
| new HIdentity(left, right, null, backend.boolType), op); |
| return; |
| case "!==": |
| HIdentity eq = new HIdentity(left, right, null, backend.boolType); |
| add(eq); |
| pushWithPosition(new HNot(eq, backend.boolType), op); |
| return; |
| } |
| |
| pushInvokeDynamic(send, selector, [left, right], location: op); |
| if (op.source == '!=') { |
| pushWithPosition(new HNot(popBoolified(), backend.boolType), op); |
| } |
| } |
| |
| HInstruction generateInstanceSendReceiver(ast.Send send) { |
| assert(Elements.isInstanceSend(send, elements)); |
| if (send.receiver == null) { |
| return localsHandler.readThis(); |
| } |
| visit(send.receiver); |
| return pop(); |
| } |
| |
| String noSuchMethodTargetSymbolString(ErroneousElement error, |
| [String prefix]) { |
| String result = error.name; |
| if (prefix == "set") return "$result="; |
| return result; |
| } |
| |
| /** |
| * Returns a set of interceptor classes that contain the given |
| * [selector]. |
| */ |
| void generateInstanceGetterWithCompiledReceiver(ast.Send send, |
| Selector selector, |
| HInstruction receiver) { |
| assert(Elements.isInstanceSend(send, elements)); |
| assert(selector.isGetter); |
| pushInvokeDynamic(send, selector, [receiver]); |
| } |
| |
| /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that |
| /// resolves to a deferred library. |
| void generateIsDeferredLoadedCheckIfNeeded(ast.Send node) { |
| DeferredLoadTask deferredTask = compiler.deferredLoadTask; |
| PrefixElement prefixElement = |
| deferredTask.deferredPrefixElement(node, elements); |
| if (prefixElement != null) { |
| String loadId = |
| deferredTask.importDeferName[prefixElement.deferredImport]; |
| HInstruction loadIdConstant = addConstantString(loadId); |
| String uri = prefixElement.deferredImport.uri.dartString.slowToString(); |
| HInstruction uriConstant = addConstantString(uri); |
| Element helper = backend.getCheckDeferredIsLoaded(); |
| pushInvokeStatic(node, helper, [loadIdConstant, uriConstant]); |
| pop(); |
| } |
| } |
| |
| void generateGetter(ast.Send send, Element element) { |
| if (element != null && element.isForeign(backend)) { |
| visitForeignGetter(send); |
| } else if (Elements.isStaticOrTopLevelField(element)) { |
| ConstantExpression constant; |
| if (element.isField && !element.isAssignable) { |
| // A static final or const. Get its constant value and inline it if |
| // the value can be compiled eagerly. |
| constant = backend.constants.getConstantForVariable(element); |
| } |
| if (constant != null) { |
| ConstantValue value = constant.value; |
| HConstant instruction; |
| // Constants that are referred via a deferred prefix should be referred |
| // by reference. |
| PrefixElement prefix = compiler.deferredLoadTask |
| .deferredPrefixElement(send, elements); |
| if (prefix != null) { |
| instruction = graph.addDeferredConstant(value, prefix, compiler); |
| } else { |
| instruction = graph.addConstant(value, compiler); |
| } |
| stack.add(instruction); |
| // The inferrer may have found a better type than the constant |
| // handler in the case of lists, because the constant handler |
| // does not look at elements in the list. |
| TypeMask type = |
| TypeMaskFactory.inferredTypeForElement(element, compiler); |
| if (!type.containsAll(compiler.world) && |
| !instruction.isConstantNull()) { |
| // TODO(13429): The inferrer should know that an element |
| // cannot be null. |
| instruction.instructionType = type.nonNullable(); |
| } |
| } else if (element.isField && isLazilyInitialized(element)) { |
| HInstruction instruction = new HLazyStatic( |
| element, |
| TypeMaskFactory.inferredTypeForElement(element, compiler)); |
| push(instruction); |
| } else { |
| if (element.isGetter) { |
| pushInvokeStatic(send, element, <HInstruction>[]); |
| } else { |
| // TODO(5346): Try to avoid the need for calling [declaration] before |
| // creating an [HStatic]. |
| HInstruction instruction = new HStatic( |
| element.declaration, |
| TypeMaskFactory.inferredTypeForElement(element, compiler)); |
| push(instruction); |
| } |
| } |
| } else if (Elements.isInstanceSend(send, elements)) { |
| HInstruction receiver = generateInstanceSendReceiver(send); |
| generateInstanceGetterWithCompiledReceiver( |
| send, elements.getSelector(send), receiver); |
| } else if (Elements.isStaticOrTopLevelFunction(element)) { |
| // TODO(5346): Try to avoid the need for calling [declaration] before |
| // creating an [HStatic]. |
| push(new HStatic(element.declaration, backend.nonNullType)); |
| // TODO(ahe): This should be registered in codegen. |
| registry.registerGetOfStaticFunction(element.declaration); |
| } else if (Elements.isErroneous(element)) { |
| if (element is ErroneousElement) { |
| // An erroneous element indicates an unresolved static getter. |
| generateThrowNoSuchMethod( |
| send, |
| noSuchMethodTargetSymbolString(element, 'get'), |
| argumentNodes: const Link<ast.Node>()); |
| } else { |
| // TODO(ahe): Do something like the above, that is, emit a runtime |
| // error. |
| stack.add(graph.addConstantNull(compiler)); |
| } |
| } else { |
| LocalElement local = element; |
| stack.add(localsHandler.readLocal(local)); |
| } |
| } |
| |
| void generateInstanceSetterWithCompiledReceiver(ast.Send send, |
| HInstruction receiver, |
| HInstruction value, |
| {Selector selector, |
| ast.Node location}) { |
| assert(send == null || Elements.isInstanceSend(send, elements)); |
| if (selector == null) { |
| assert(send != null); |
| selector = elements.getSelector(send); |
| } |
| if (location == null) { |
| assert(send != null); |
| location = send; |
| } |
| assert(selector.isSetter); |
| pushInvokeDynamic(location, selector, [receiver, value]); |
| pop(); |
| stack.add(value); |
| } |
| |
| void generateNonInstanceSetter(ast.SendSet send, |
| Element element, |
| HInstruction value, |
| {ast.Node location}) { |
| assert(send == null || !Elements.isInstanceSend(send, elements)); |
| if (location == null) { |
| assert(send != null); |
| location = send; |
| } |
| if (Elements.isStaticOrTopLevelField(element)) { |
| if (element.isSetter) { |
| pushInvokeStatic(location, element, <HInstruction>[value]); |
| pop(); |
| } else { |
| VariableElement field = element; |
| value = potentiallyCheckOrTrustType(value, field.type); |
| addWithPosition(new HStaticStore(element, value), location); |
| } |
| stack.add(value); |
| } else if (Elements.isErroneous(element)) { |
| if (element is ErroneousElement) { |
| List<HInstruction> arguments = |
| send == null ? const <HInstruction>[] : <HInstruction>[value]; |
| // An erroneous element indicates an unresolved static setter. |
| generateThrowNoSuchMethod( |
| location, noSuchMethodTargetSymbolString(element, 'set'), |
| argumentValues: arguments); |
| } else { |
| // TODO(ahe): Do something like [generateWrongArgumentCountError]. |
| stack.add(graph.addConstantNull(compiler)); |
| } |
| } else { |
| stack.add(value); |
| LocalElement local = element; |
| // If the value does not already have a name, give it here. |
| if (value.sourceElement == null) { |
| value.sourceElement = local; |
| } |
| HInstruction checkedOrTrusted = |
| potentiallyCheckOrTrustType(value, local.type); |
| if (!identical(checkedOrTrusted, value)) { |
| pop(); |
| stack.add(checkedOrTrusted); |
| } |
| |
| localsHandler.updateLocal(local, checkedOrTrusted); |
| } |
| } |
| |
| HInstruction invokeInterceptor(HInstruction receiver) { |
| HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType); |
| add(interceptor); |
| return interceptor; |
| } |
| |
| HForeign createForeign(js.Template code, |
| TypeMask type, |
| List<HInstruction> inputs) { |
| return new HForeign(code, type, inputs); |
| } |
| |
| HLiteralList buildLiteralList(List<HInstruction> inputs) { |
| return new HLiteralList(inputs, backend.extendableArrayType); |
| } |
| |
| // TODO(karlklose): change construction of the representations to be GVN'able |
| // (dartbug.com/7182). |
| HInstruction buildTypeArgumentRepresentations(DartType type) { |
| // Compute the representation of the type arguments, including access |
| // to the runtime type information for type variables as instructions. |
| if (type.isTypeVariable) { |
| return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]); |
| } else { |
| assert(type.element.isClass); |
| InterfaceType interface = type; |
| List<HInstruction> inputs = <HInstruction>[]; |
| bool first = true; |
| List<String> templates = <String>[]; |
| for (DartType argument in interface.typeArguments) { |
| templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) { |
| HInstruction runtimeType = addTypeVariableReference(variable); |
| inputs.add(runtimeType); |
| })); |
| } |
| String template = '[${templates.join(', ')}]'; |
| // TODO(sra): This is a fresh template each time. We can't let the |
| // template manager build them. |
| js.Template code = js.js.uncachedExpressionTemplate(template); |
| HInstruction representation = |
| createForeign(code, backend.readableArrayType, inputs); |
| return representation; |
| } |
| } |
| |
| visitOperatorSend(ast.Send node) { |
| ast.Operator op = node.selector; |
| if ("[]" == op.source) { |
| visitDynamicSend(node); |
| } else if ("&&" == op.source || |
| "||" == op.source) { |
| visitLogicalAndOr(node, op); |
| } else if ("!" == op.source) { |
| visitLogicalNot(node); |
| } else if (node.argumentsNode is ast.Prefix) { |
| visitUnary(node, op); |
| } else if ("is" == op.source) { |
| visitIsSend(node); |
| } else if ("as" == op.source) { |
| visit(node.receiver); |
| HInstruction expression = pop(); |
| DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast); |
| if (type.isMalformed) { |
| ErroneousElement element = type.element; |
| generateTypeError(node, element.message); |
| } else { |
| HInstruction converted = buildTypeConversion( |
| expression, |
| localsHandler.substInContext(type), |
| HTypeConversion.CAST_TYPE_CHECK); |
| if (converted != expression) add(converted); |
| stack.add(converted); |
| } |
| } else { |
| visit(node.receiver); |
| visit(node.argumentsNode); |
| var right = pop(); |
| var left = pop(); |
| visitBinary(left, op, right, elements.getSelector(node), node); |
| } |
| } |
| |
| void visitIsSend(ast.Send node) { |
| visit(node.receiver); |
| HInstruction expression = pop(); |
| bool isNot = node.isIsNotCheck; |
| DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast); |
| HInstruction instruction = buildIsNode(node, type, expression); |
| if (isNot) { |
| add(instruction); |
| instruction = new HNot(instruction, backend.boolType); |
| } |
| push(instruction); |
| } |
| |
| HInstruction buildIsNode(ast.Node node, |
| DartType type, |
| HInstruction expression) { |
| type = localsHandler.substInContext(type).unalias(compiler); |
| if (type.isFunctionType) { |
| List arguments = [buildFunctionType(type), expression]; |
| pushInvokeDynamic( |
| node, new Selector.call('_isTest', backend.jsHelperLibrary, 1), |
| arguments); |
| return new HIs.compound(type, expression, pop(), backend.boolType); |
| } else if (type.isTypeVariable) { |
| HInstruction runtimeType = addTypeVariableReference(type); |
| Element helper = backend.getCheckSubtypeOfRuntimeType(); |
| List<HInstruction> inputs = <HInstruction>[expression, runtimeType]; |
| pushInvokeStatic(null, helper, inputs, backend.boolType); |
| HInstruction call = pop(); |
| return new HIs.variable(type, expression, call, backend.boolType); |
| } else if (RuntimeTypes.hasTypeArguments(type)) { |
| ClassElement element = type.element; |
| Element helper = backend.getCheckSubtype(); |
| HInstruction representations = |
| buildTypeArgumentRepresentations(type); |
| add(representations); |
| String operator = backend.namer.operatorIs(element); |
| HInstruction isFieldName = addConstantString(operator); |
| HInstruction asFieldName = compiler.world.hasAnyStrictSubtype(element) |
| ? addConstantString(backend.namer.substitutionName(element)) |
| : graph.addConstantNull(compiler); |
| List<HInstruction> inputs = <HInstruction>[expression, |
| isFieldName, |
| representations, |
| asFieldName]; |
| pushInvokeStatic(node, helper, inputs, backend.boolType); |
| HInstruction call = pop(); |
| return new HIs.compound(type, expression, call, backend.boolType); |
| } else if (type.isMalformed) { |
| ErroneousElement element = type.element; |
| generateTypeError(node, element.message); |
| HInstruction call = pop(); |
| return new HIs.compound(type, expression, call, backend.boolType); |
| } else { |
| if (backend.hasDirectCheckFor(type)) { |
| return new HIs.direct(type, expression, backend.boolType); |
| } |
| // The interceptor is not always needed. It is removed by optimization |
| // when the receiver type or tested type permit. |
| return new HIs.raw( |
| type, expression, invokeInterceptor(expression), backend.boolType); |
| } |
| } |
| |
| HInstruction buildFunctionType(FunctionType type) { |
| type.accept(new TypeBuilder(compiler.world), this); |
| return pop(); |
| } |
| |
| void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) { |
| Selector selector = elements.getSelector(node); |
| if (selector.namedArgumentCount == 0) { |
| addGenericSendArgumentsToList(node.arguments, list); |
| } else { |
| // Visit positional arguments and add them to the list. |
| Link<ast.Node> arguments = node.arguments; |
| int positionalArgumentCount = selector.positionalArgumentCount; |
| for (int i = 0; |
| i < positionalArgumentCount; |
| arguments = arguments.tail, i++) { |
| visit(arguments.head); |
| list.add(pop()); |
| } |
| |
| // Visit named arguments and add them into a temporary map. |
| Map<String, HInstruction> instructions = |
| new Map<String, HInstruction>(); |
| List<String> namedArguments = selector.namedArguments; |
| int nameIndex = 0; |
| for (; !arguments.isEmpty; arguments = arguments.tail) { |
| visit(arguments.head); |
| instructions[namedArguments[nameIndex++]] = pop(); |
| } |
| |
| // Iterate through the named arguments to add them to the list |
| // of instructions, in an order that can be shared with |
| // selectors with the same named arguments. |
| List<String> orderedNames = selector.getOrderedNamedArguments(); |
| for (String name in orderedNames) { |
| list.add(instructions[name]); |
| } |
| } |
| } |
| |
| /** |
| * Returns a list with the evaluated [arguments] in the normalized order. |
| * |
| * Precondition: `this.applies(element, world)`. |
| * Invariant: [element] must be an implementation element. |
| */ |
| List<HInstruction> makeStaticArgumentList(Selector selector, |
| Link<ast.Node> arguments, |
| FunctionElement element) { |
| assert(invariant(element, element.isImplementation)); |
| |
| HInstruction compileArgument(ast.Node argument) { |
| visit(argument); |
| return pop(); |
| } |
| |
| return selector.makeArgumentsList2(arguments, |
| element, |
| compileArgument, |
| handleConstantForOptionalParameter); |
| } |
| |
| void addGenericSendArgumentsToList(Link<ast.Node> link, List<HInstruction> list) { |
| for (; !link.isEmpty; link = link.tail) { |
| visit(link.head); |
| list.add(pop()); |
| } |
| } |
| |
| visitDynamicSend(ast.Send node) { |
| Selector selector = elements.getSelector(node); |
| |
| List<HInstruction> inputs = <HInstruction>[]; |
| HInstruction receiver = generateInstanceSendReceiver(node); |
| inputs.add(receiver); |
| addDynamicSendArgumentsToList(node, inputs); |
| |
| pushInvokeDynamic(node, selector, inputs); |
| if (selector.isSetter || selector.isIndexSet) { |
| pop(); |
| stack.add(inputs.last); |
| } |
| } |
| |
| visitClosureSend(ast.Send node) { |
| Selector selector = elements.getSelector(node); |
| assert(node.receiver == null); |
| Element element = elements[node]; |
| HInstruction closureTarget; |
| if (element == null) { |
| visit(node.selector); |
| closureTarget = pop(); |
| } else { |
| LocalElement local = element; |
| closureTarget = localsHandler.readLocal(local); |
| } |
| var inputs = <HInstruction>[]; |
| inputs.add(closureTarget); |
| addDynamicSendArgumentsToList(node, inputs); |
| Selector closureSelector = new Selector.callClosureFrom(selector); |
| pushWithPosition( |
| new HInvokeClosure(closureSelector, inputs, backend.dynamicType), |
| node); |
| } |
| |
| void handleForeignJs(ast.Send node) { |
| Link<ast.Node> link = node.arguments; |
| // If the invoke is on foreign code, don't visit the first |
| // argument, which is the type, and the second argument, |
| // which is the foreign code. |
| if (link.isEmpty || link.tail.isEmpty) { |
| compiler.internalError(node.argumentsNode, |
| 'At least two arguments expected.'); |
| } |
| native.NativeBehavior nativeBehavior = |
| compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node); |
| |
| List<HInstruction> inputs = <HInstruction>[]; |
| addGenericSendArgumentsToList(link.tail.tail, inputs); |
| |
| TypeMask ssaType = |
| TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler); |
| |
| if (nativeBehavior.codeTemplate.isExpression) { |
| push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs, |
| effects: nativeBehavior.sideEffects, |
| nativeBehavior: nativeBehavior)); |
| } else { |
| push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs, |
| isStatement: true, |
| effects: nativeBehavior.sideEffects, |
| nativeBehavior: nativeBehavior, |
| canThrow: true)); |
| } |
| } |
| |
| void handleJsStringConcat(ast.Send node) { |
| List<HInstruction> inputs = <HInstruction>[]; |
| addGenericSendArgumentsToList(node.arguments, inputs); |
| if (inputs.length != 2) { |
| compiler.internalError(node.argumentsNode, 'Two arguments expected.'); |
| } |
| push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType)); |
| } |
| |
| void handleForeignJsCurrentIsolateContext(ast.Send node) { |
| if (!node.arguments.isEmpty) { |
| compiler.internalError(node, |
| 'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.'); |
| } |
| |
| if (!compiler.hasIsolateSupport) { |
| // If the isolate library is not used, we just generate code |
| // to fetch the current isolate. |
| String name = backend.namer.currentIsolate; |
| push(new HForeign(js.js.parseForeignJS(name), |
| backend.dynamicType, |
| <HInstruction>[])); |
| } else { |
| // Call a helper method from the isolate library. The isolate |
| // library uses its own isolate structure, that encapsulates |
| // Leg's isolate. |
| Element element = backend.isolateHelperLibrary.find('_currentIsolate'); |
| if (element == null) { |
| compiler.internalError(node, |
| 'Isolate library and compiler mismatch.'); |
| } |
| pushInvokeStatic(null, element, [], backend.dynamicType); |
| } |
| } |
| |
| void handleForeingJsGetFlag(ast.Send node) { |
| List<ast.Node> arguments = node.arguments.toList(); |
| ast.Node argument; |
| switch (arguments.length) { |
| case 0: |
| compiler.reportError( |
| node, MessageKind.GENERIC, |
| {'text': 'Error: Expected one argument to JS_GET_FLAG.'}); |
| return; |
| case 1: |
| argument = arguments[0]; |
| break; |
| default: |
| for (int i = 1; i < arguments.length; i++) { |
| compiler.reportError( |
| arguments[i], MessageKind.GENERIC, |
| {'text': 'Error: Extra argument to JS_GET_FLAG.'}); |
| } |
| return; |
| } |
| ast.LiteralString string = argument.asLiteralString(); |
| if (string == null) { |
| compiler.reportError( |
| argument, MessageKind.GENERIC, |
| {'text': 'Error: Expected a literal string.'}); |
| } |
| String name = string.dartString.slowToString(); |
| bool value = false; |
| if (name == 'MUST_RETAIN_METADATA') { |
| value = backend.mustRetainMetadata; |
| } else { |
| compiler.reportError( |
| node, MessageKind.GENERIC, |
| {'text': 'Error: Unknown internal flag "$name".'}); |
| } |
| stack.add(graph.addConstantBool(value, compiler)); |
| } |
| |
| void handleForeignJsGetName(ast.Send node) { |
| List<ast.Node> arguments = node.arguments.toList(); |
| ast.Node argument; |
| switch (arguments.length) { |
| case 0: |
| compiler.reportError( |
| node, MessageKind.GENERIC, |
| {'text': 'Error: Expected one argument to JS_GET_NAME.'}); |
| return; |
| case 1: |
| argument = arguments[0]; |
| break; |
| default: |
| for (int i = 1; i < arguments.length; i++) { |
| compiler.reportError( |
| arguments[i], MessageKind.GENERIC, |
| {'text': 'Error: Extra argument to JS_GET_NAME.'}); |
| } |
| return; |
| } |
| ast.LiteralString string = argument.asLiteralString(); |
| if (string == null) { |
| compiler.reportError( |
| argument, MessageKind.GENERIC, |
| {'text': 'Error: Expected a literal string.'}); |
| } |
| stack.add( |
| addConstantString( |
| backend.namer.getNameForJsGetName( |
| argument, string.dartString.slowToString()))); |
| } |
| |
| void handleForeignJsEmbeddedGlobal(ast.Send node) { |
| List<ast.Node> arguments = node.arguments.toList(); |
| ast.Node globalNameNode; |
| switch (arguments.length) { |
| case 0: |
| case 1: |
| compiler.reportError( |
| node, MessageKind.GENERIC, |
| {'text': 'Error: Expected two arguments to JS_EMBEDDED_GLOBAL.'}); |
| return; |
| case 2: |
| // The type has been extracted earlier. We are only interested in the |
| // name in this function. |
| globalNameNode = arguments[1]; |
| break; |
| default: |
| for (int i = 2; i < arguments.length; i++) { |
| compiler.reportError( |
| arguments[i], MessageKind.GENERIC, |
| {'text': 'Error: Extra argument to JS_EMBEDDED_GLOBAL.'}); |
| } |
| return; |
| } |
| visit(arguments[1]); |
| HInstruction globalNameHNode = pop(); |
| if (!globalNameHNode.isConstantString()) { |
| compiler.reportError( |
| arguments[1], MessageKind.GENERIC, |
| {'text': 'Error: Expected String as second argument ' |
| 'to JS_EMBEDDED_GLOBAL.'}); |
| return; |
| } |
| HConstant hConstant = globalNameHNode; |
| StringConstantValue constant = hConstant.constant; |
| String globalName = constant.primitiveValue.slowToString(); |
| js.Template expr = js.js.expressionTemplateYielding( |
| backend.emitter.generateEmbeddedGlobalAccess(globalName)); |
| native.NativeBehavior nativeBehavior = |
| compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node); |
| TypeMask ssaType = |
| TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler); |
| push(new HForeign(expr, ssaType, const [])); |
| } |
| |
| void handleJsInterceptorConstant(ast.Send node) { |
| // Single argument must be a TypeConstant which is converted into a |
| // InterceptorConstant. |
| if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) { |
| ast.Node argument = node.arguments.head; |
| visit(argument); |
| HInstruction argumentInstruction = pop(); |
| if (argumentInstruction is HConstant) { |
| ConstantValue argumentConstant = argumentInstruction.constant; |
| if (argumentConstant is TypeConstantValue) { |
| ConstantValue constant = |
| new InterceptorConstantValue(argumentConstant.representedType); |
| HInstruction instruction = graph.addConstant(constant, compiler); |
| stack.add(instruction); |
| return; |
| } |
| } |
| } |
| compiler.reportError(node, |
| MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT); |
| stack.add(graph.addConstantNull(compiler)); |
| } |
| |
| void handleForeignJsCallInIsolate(ast.Send node) { |
| Link<ast.Node> link = node.arguments; |
| if (!compiler.hasIsolateSupport) { |
| // If the isolate library is not used, we just invoke the |
| // closure. |
| visit(link.tail.head); |
| Selector selector = new Selector.callClosure(0); |
| push(new HInvokeClosure(selector, |
| <HInstruction>[pop()], |
| backend.dynamicType)); |
| } else { |
| // Call a helper method from the isolate library. |
| Element element = backend.isolateHelperLibrary.find('_callInIsolate'); |
| if (element == null) { |
| compiler.internalError(node, |
| 'Isolate library and compiler mismatch.'); |
| } |
| List<HInstruction> inputs = <HInstruction>[]; |
| addGenericSendArgumentsToList(link, inputs); |
| pushInvokeStatic(node, element, inputs, backend.dynamicType); |
| } |
| } |
| |
| FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) { |
| if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) { |
| compiler.internalError(node.argumentsNode, |
| '"$name" requires exactly one argument.'); |
| } |
| ast.Node closure = node.arguments.head; |
| Element element = elements[closure]; |
| if (!Elements.isStaticOrTopLevelFunction(element)) { |
| compiler.internalError(closure, |
| '"$name" requires a static or top-level method.'); |
| } |
| FunctionElement function = element; |
| // TODO(johnniwinther): Try to eliminate the need to distinguish declaration |
| // and implementation signatures. Currently it is need because the |
| // signatures have different elements for parameters. |
| FunctionElement implementation = function.implementation; |
| FunctionSignature params = implementation.functionSignature; |
| if (params.optionalParameterCount != 0) { |
| compiler.internalError(closure, |
| '"$name" does not handle closure with optional parameters.'); |
| } |
| |
| registry.registerStaticUse(element); |
| push(new HForeign(js.js.expressionTemplateYielding( |
| backend.emitter.staticFunctionAccess(element)), |
| backend.dynamicType, |
| <HInstruction>[])); |
| return params; |
| } |
| |
| void handleForeignDartClosureToJs(ast.Send node, String name) { |
| // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take |
| // care to wrap the closure in another closure that saves the current |
| // isolate. |
| handleForeignRawFunctionRef(node, name); |
| } |
| |
| void handleForeignSetCurrentIsolate(ast.Send node) { |
| if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) { |
| compiler.internalError(node.argumentsNode, |
| 'Exactly one argument required.'); |
| } |
| visit(node.arguments.head); |
| String isolateName = backend.namer.currentIsolate; |
| SideEffects sideEffects = new SideEffects.empty(); |
| sideEffects.setAllSideEffects(); |
| push(new HForeign(js.js.parseForeignJS("$isolateName = #"), |
| backend.dynamicType, |
| <HInstruction>[pop()], |
| effects: sideEffects)); |
| } |
| |
| void handleForeignCreateIsolate(ast.Send node) { |
| if (!node.arguments.isEmpty) { |
| compiler.internalError(node.argumentsNode, 'Too many arguments.'); |
| } |
| String constructorName = backend.namer.isolateName; |
| push(new HForeign(js.js.parseForeignJS("new $constructorName()"), |
| backend.dynamicType, |
| <HInstruction>[])); |
| } |
| |
| void handleForeignDartObjectJsConstructorFunction(ast.Send node) { |
| if (!node.arguments.isEmpty) { |
| compiler.internalError(node.argumentsNode, 'Too many arguments.'); |
| } |
| push(new HForeign(js.js.expressionTemplateYielding( |
| backend.emitter.typeAccess(compiler.objectClass)), |
| backend.dynamicType, |
| <HInstruction>[])); |
| } |
| |
| void handleForeignJsCurrentIsolate(ast.Send node) { |
| if (!node.arguments.isEmpty) { |
| compiler.internalError(node.argumentsNode, 'Too many arguments.'); |
| } |
| push(new HForeign(js.js.parseForeignJS(backend.namer.currentIsolate), |
| backend.dynamicType, |
| <HInstruction>[])); |
| } |
| |
| visitForeignSend(ast.Send node) { |
| Selector selector = elements.getSelector(node); |
| String name = selector.name; |
| if (name == 'JS') { |
| handleForeignJs(node); |
| } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') { |
| handleForeignJsCurrentIsolateContext(node); |
| } else if (name == 'JS_CALL_IN_ISOLATE') { |
| handleForeignJsCallInIsolate(node); |
| } else if (name == 'DART_CLOSURE_TO_JS') { |
| handleForeignDartClosureToJs(node, 'DART_CLOSURE_TO_JS'); |
| } else if (name == 'RAW_DART_FUNCTION_REF') { |
| handleForeignRawFunctionRef(node, 'RAW_DART_FUNCTION_REF'); |
| } else if (name == 'JS_SET_CURRENT_ISOLATE') { |
| handleForeignSetCurrentIsolate(node); |
| } else if (name == 'JS_CREATE_ISOLATE') { |
| handleForeignCreateIsolate(node); |
| } else if (name == 'JS_OPERATOR_IS_PREFIX') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.operatorIsPrefix)); |
| } else if (name == 'JS_OBJECT_CLASS_NAME') { |
| // TODO(floitsch): this should be a JS_NAME. |
| String name = backend.namer.getRuntimeTypeName(compiler.objectClass); |
| stack.add(addConstantString(name)); |
| } else if (name == 'JS_NULL_CLASS_NAME') { |
| // TODO(floitsch): this should be a JS_NAME. |
| String name = backend.namer.getRuntimeTypeName(compiler.nullClass); |
| stack.add(addConstantString(name)); |
| } else if (name == 'JS_FUNCTION_CLASS_NAME') { |
| // TODO(floitsch): this should be a JS_NAME. |
| String name = backend.namer.getRuntimeTypeName(compiler.functionClass); |
| stack.add(addConstantString(name)); |
| } else if (name == 'JS_OPERATOR_AS_PREFIX') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.operatorAsPrefix)); |
| } else if (name == 'JS_SIGNATURE_NAME') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.operatorSignature)); |
| } else if (name == 'JS_TYPEDEF_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.typedefTag)); |
| } else if (name == 'JS_FUNCTION_TYPE_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.functionTypeTag)); |
| } else if (name == 'JS_FUNCTION_TYPE_VOID_RETURN_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.functionTypeVoidReturnTag)); |
| } else if (name == 'JS_FUNCTION_TYPE_RETURN_TYPE_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString(backend.namer.functionTypeReturnTypeTag)); |
| } else if (name == |
| 'JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString( |
| backend.namer.functionTypeRequiredParametersTag)); |
| } else if (name == |
| 'JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString( |
| backend.namer.functionTypeOptionalParametersTag)); |
| } else if (name == |
| 'JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG') { |
| // TODO(floitsch): this should be a JS_NAME. |
| stack.add(addConstantString( |
| backend.namer.functionTypeNamedParametersTag)); |
| } else if (name == 'JS_DART_OBJECT_CONSTRUCTOR') { |
| handleForeignDartObjectJsConstructorFunction(node); |
| } else if (name == 'JS_IS_INDEXABLE_FIELD_NAME') { |
| // TODO(floitsch): this should be a JS_NAME. |
| Element element = backend.findHelper('JavaScriptIndexingBehavior'); |
| stack.add(addConstantString(backend.namer.operatorIs(element))); |
| } else if (name == 'JS_CURRENT_ISOLATE') { |
| handleForeignJsCurrentIsolate(node); |
| } else if (name == 'JS_GET_NAME') { |
| handleForeignJsGetName(node); |
| } else if (name == 'JS_EMBEDDED_GLOBAL') { |
| handleForeignJsEmbeddedGlobal(node); |
| } else if (name == 'JS_GET_FLAG') { |
| handleForeingJsGetFlag(node); |
| } else if (name == 'JS_EFFECT') { |
| stack.add(graph.addConstantNull(compiler)); |
| } else if (name == 'JS_INTERCEPTOR_CONSTANT') { |
| handleJsInterceptorConstant(node); |
| } else if (name == 'JS_STRING_CONCAT') { |
| handleJsStringConcat(node); |
| } else { |
| throw "Unknown foreign: ${selector}"; |
| } |
| } |
| |
| visitForeignGetter(ast.Send node) { |
| Element element = elements[node]; |
| // Until now we only handle these as getters. |
| invariant(node, element.isDeferredLoaderGetter); |
| FunctionElement deferredLoader = element; |
| Element loadFunction = compiler.loadLibraryFunction; |
| PrefixElement prefixElement = deferredLoader.enclosingElement; |
| String loadId = compiler.deferredLoadTask |
| .importDeferName[prefixElement.deferredImport]; |
| var inputs = [graph.addConstantString( |
| new ast.DartString.literal(loadId), compiler)]; |
| push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType, |
| targetCanThrow: false)); |
| } |
| |
| generateSuperNoSuchMethodSend(ast.Send node, |
| Selector selector, |
| List<HInstruction> arguments) { |
| String name = selector.name; |
| |
| ClassElement cls = currentNonClosureClass; |
| Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD); |
| if (compiler.enabledInvokeOn |
| && element.enclosingElement.declaration != compiler.objectClass) { |
| // Register the call as dynamic if [noSuchMethod] on the super |
| // class is _not_ the default implementation from [Object], in |
| // case the [noSuchMethod] implementation calls |
| // [JSInvocationMirror._invokeOn]. |
| registry.registerSelectorUse(selector.asUntyped); |
| } |
| String publicName = name; |
| if (selector.isSetter) publicName += '='; |
| |
| ConstantValue nameConstant = constantSystem.createString( |
| new ast.DartString.literal(publicName)); |
| |
| String internalName = backend.namer.invocationName(selector); |
| ConstantValue internalNameConstant = |
| constantSystem.createString(new ast.DartString.literal(internalName)); |
| |
| Element createInvocationMirror = backend.getCreateInvocationMirror(); |
| var argumentsInstruction = buildLiteralList(arguments); |
| add(argumentsInstruction); |
| |
| var argumentNames = new List<HInstruction>(); |
| for (String argumentName in selector.namedArguments) { |
| ConstantValue argumentNameConstant = |
| constantSystem.createString(new ast.DartString.literal(argumentName)); |
| argumentNames.add(graph.addConstant(argumentNameConstant, compiler)); |
| } |
| var argumentNamesInstruction = buildLiteralList(argumentNames); |
| add(argumentNamesInstruction); |
| |
| ConstantValue kindConstant = |
| constantSystem.createInt(selector.invocationMirrorKind); |
| |
| pushInvokeStatic(null, |
| createInvocationMirror, |
| [graph.addConstant(nameConstant, compiler), |
| graph.addConstant(internalNameConstant, compiler), |
| graph.addConstant(kindConstant, compiler), |
| argumentsInstruction, |
| argumentNamesInstruction], |
| backend.dynamicType); |
| |
| var inputs = <HInstruction>[pop()]; |
| push(buildInvokeSuper(compiler.noSuchMethodSelector, element, inputs)); |
| } |
| |
| visitSuperSend(ast.Send node) { |
| Selector selector = elements.getSelector(node); |
| Element element = elements[node]; |
| if (Elements.isUnresolved(element)) { |
| List<HInstruction> arguments = <HInstruction>[]; |
| if (!node.isPropertyAccess) { |
| addGenericSendArgumentsToList(node.arguments, arguments); |
| } |
| return generateSuperNoSuchMethodSend(node, selector, arguments); |
| } |
| List<HInstruction> inputs = <HInstruction>[]; |
| if (node.isPropertyAccess) { |
| push(buildInvokeSuper(selector, element, inputs)); |
| } else if (element.isFunction || element.isGenerativeConstructor) { |
| if (selector.applies(element, compiler.world)) { |
| // TODO(5347): Try to avoid the need for calling [implementation] before |
| // calling [makeStaticArgumentList]. |
| FunctionElement function = element.implementation; |
| assert(selector.applies(function, compiler.world)); |
| inputs = makeStaticArgumentList(selector, |
| node.arguments, |
| function); |
| push(buildInvokeSuper(selector, element, inputs)); |
| } else if (element.isGenerativeConstructor) { |
| generateWrongArgumentCountError(node, element, node.arguments); |
| } else { |
| addGenericSendArgumentsToList(node.arguments, inputs); |
| generateSuperNoSuchMethodSend(node, selector, inputs); |
| } |
| } else { |
| HInstruction target = buildInvokeSuper(selector, element, inputs); |
| add(target); |
| inputs = <HInstruction>[target]; |
| addDynamicSendArgumentsToList(node, inputs); |
| Selector closureSelector = new Selector.callClosureFrom(selector); |
| push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType)); |
| } |
| } |
| |
| bool needsSubstitutionForTypeVariableAccess(ClassElement cls) { |
| ClassWorld classWorld = compiler.world; |
| if (classWorld.isUsedAsMixin(cls)) return true; |
| |
| Iterable<ClassElement> subclasses = compiler.world.strictSubclassesOf(cls); |
| return subclasses.any((ClassElement subclass) { |
| return !rti.isTrivialSubstitution(subclass, cls); |
| }); |
| } |
| |
| /** |
| * Generate code to extract the type arguments from the object, substitute |
| * them as an instance of the type we are testing against (if necessary), and |
| * extract the type argument by the index of the variable in the list of type |
| * variables for that class. |
| */ |
| HInstruction readTypeVariable(ClassElement cls, |
| TypeVariableElement variable) { |
| assert(sourceElement.isInstanceMember); |
| |
| HInstruction target = localsHandler.readThis(); |
| HConstant index = graph.addConstantInt( |
| RuntimeTypes.getTypeVariableIndex(variable), |
| compiler); |
| |
| if (needsSubstitutionForTypeVariableAccess(cls)) { |
| // TODO(ahe): Creating a string here is unfortunate. It is slow (due to |
| // string concatenation in the implementation), and may prevent |
| // segmentation of '$'. |
| String substitutionNameString = backend.namer.getNameForRti(cls); |
| HInstruction substitutionName = graph.addConstantString( |
| new ast.LiteralDartString(substitutionNameString), compiler); |
| pushInvokeStatic(null, |
| backend.getGetRuntimeTypeArgument(), |
| [target, substitutionName, index], |
| backend.dynamicType); |
| } else { |
| pushInvokeStatic(null, backend.getGetTypeArgumentByIndex(), |
| [target, index], |
| backend.dynamicType); |
| } |
| return pop(); |
| } |
| |
| // TODO(karlklose): this is needed to avoid a bug where the resolved type is |
| // not stored on a type annotation in the closure translator. Remove when |
| // fixed. |
| bool hasDirectLocal(Local local) { |
| return !localsHandler.isAccessedDirectly(local) || |
| localsHandler.directLocals[local] != null; |
| } |
| |
| /** |
| * Helper to create an instruction that gets the value of a type variable. |
| */ |
| HInstruction addTypeVariableReference(TypeVariableType type) { |
| assert(assertTypeInContext(type)); |
| Element member = sourceElement; |
| bool isClosure = member.enclosingElement.isClosure; |
| if (isClosure) { |
| ClosureClassElement closureClass = member.enclosingElement; |
| member = closureClass.methodElement; |
| member = member.outermostEnclosingMemberOrTopLevel; |
| } |
| bool isInConstructorContext = member.isConstructor || |
| member.isGenerativeConstructorBody; |
| Local typeVariableLocal = localsHandler.getTypeVariableAsLocal(type); |
| if (isClosure) { |
| if (member.isFactoryConstructor || |
| (isInConstructorContext && hasDirectLocal(typeVariableLocal))) { |
| // The type variable is used from a closure in a factory constructor. |
| // The value of the type argument is stored as a local on the closure |
| // itself. |
| return localsHandler.readLocal(typeVariableLocal); |
| } else if (member.isFunction || |
| member.isGetter || |
| member.isSetter || |
| isInConstructorContext) { |
| // The type variable is stored on the "enclosing object" and needs to be |
| // accessed using the this-reference in the closure. |
| return readTypeVariable(member.enclosingClass, type.element); |
| } else { |
| assert(member.isField); |
| // The type variable is stored in a parameter of the method. |
| return localsHandler.readLocal(typeVariableLocal); |
| } |
| } else if (isInConstructorContext || |
| // When [member] is a field, we can be either |
| // generating a checked setter or inlining its |
| // initializer in a constructor. An initializer is |
| // never built standalone, so [isBuildingFor] will |
| // always return true when seeing one. |
| (member.isField && !isBuildingFor(member))) { |
| // The type variable is stored in a parameter of the method. |
| return localsHandler.readLocal(typeVariableLocal); |
| } else if (member.isInstanceMember) { |
| // The type variable is stored on the object. |
| return readTypeVariable(member.enclosingClass, |
| type.element); |
| } else { |
| compiler.internalError(type.element, |
| 'Unexpected type variable in static context.'); |
| return null; |
| } |
| } |
| |
| HInstruction analyzeTypeArgument(DartType argument) { |
| assert(assertTypeInContext(argument)); |
| if (argument.treatAsDynamic) { |
| // Represent [dynamic] as [null]. |
| return graph.addConstantNull(compiler); |
| } |
| |
| if (argument.isTypeVariable) { |
| return addTypeVariableReference(argument); |
| } |
| |
| List<HInstruction> inputs = <HInstruction>[]; |
| |
| String template = rti.getTypeRepresentationWithHashes(argument, (variable) { |
| inputs.add(addTypeVariableReference(variable)); |
| }); |
| |
| js.Template code = js.js.uncachedExpressionTemplate(template); |
| HInstruction result = createForeign(code, backend.stringType, inputs); |
| add(result); |
| return result; |
| } |
| |
| HInstruction handleListConstructor(InterfaceType type, |
| ast.Node currentNode, |
| HInstruction newObject) { |
| if (!backend.classNeedsRti(type.element) || type.treatAsRaw) { |
| return newObject; |
| } |
| List<HInstruction> inputs = <HInstruction>[]; |
| type = localsHandler.substInContext(type); |
| type.typeArguments.forEach((DartType argument) { |
| inputs.add(analyzeTypeArgument(argument)); |
| }); |
| // TODO(15489): Register at codegen. |
| registry.registerInstantiatedType(type); |
| return callSetRuntimeTypeInfo(type.element, inputs, newObject); |
| } |
| |
| void copyRuntimeTypeInfo(HInstruction source, HInstruction target) { |
| Element copyHelper = backend.getCopyTypeArguments(); |
| pushInvokeStatic(null, copyHelper, [source, target]); |
| pop(); |
| } |
| |
| HInstruction callSetRuntimeTypeInfo(ClassElement element, |
| List<HInstruction> rtiInputs, |
| HInstruction newObject) { |
| if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) { |
| return newObject; |
| } |
| |
| HInstruction typeInfo = buildLiteralList(rtiInputs); |
| add(typeInfo); |
| |
| // Set the runtime type information on the object. |
| Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo(); |
| pushInvokeStatic( |
| null, |
| typeInfoSetterElement, |
| <HInstruction>[newObject, typeInfo], |
| backend.dynamicType); |
| |
| // The new object will now be referenced through the |
| // `setRuntimeTypeInfo` call. We therefore set the type of that |
| // instruction to be of the object's type. |
| assert(stack.last is HInvokeStatic || stack.last == newObject); |
| stack.last.instructionType = newObject.instructionType; |
| return pop(); |
| } |
| |
| handleNewSend(ast.NewExpression node) { |
| ast.Send send = node.send; |
| generateIsDeferredLoadedCheckIfNeeded(send); |
| |
| bool isFixedList = false; |
| bool isFixedListConstructorCall = |
| Elements.isFixedListConstructorCall(elements[send], send, compiler); |
| bool isGrowableListConstructorCall = |
| Elements.isGrowableListConstructorCall(elements[send], send, compiler); |
| |
| TypeMask computeType(element) { |
| Element originalElement = elements[send]; |
| if (isFixedListConstructorCall |
| || Elements.isFilledListConstructorCall( |
| originalElement, send, compiler)) { |
| isFixedList = true; |
| TypeMask inferred = |
| TypeMaskFactory.inferredForNode(sourceElement, send, compiler); |
| return inferred.containsAll(compiler.world) |
| ? backend.fixedArrayType |
| : inferred; |
| } else if (isGrowableListConstructorCall) { |
| TypeMask inferred = |
| TypeMaskFactory.inferredForNode(sourceElement, send, compiler); |
| return inferred.containsAll(compiler.world) |
| ? backend.extendableArrayType |
| : inferred; |
| } else if (Elements.isConstructorOfTypedArraySubclass( |
| originalElement, compiler)) { |
| isFixedList = true; |
| TypeMask inferred = |
| TypeMaskFactory.inferredForNode(sourceElement, send, compiler); |
| ClassElement cls = element.enclosingClass; |
| assert(cls.thisType.element.isNative); |
| return inferred.containsAll(compiler.world) |
| ? new TypeMask.nonNullExact(cls.thisType.element, compiler.world) |
| : inferred; |
| } else if (element.isGenerativeConstructor) { |
| ClassElement cls = element.enclosingClass; |
| return new TypeMask.nonNullExact(cls.thisType.element, compiler.world); |
| } else { |
| return TypeMaskFactory.inferredReturnTypeForElement( |
| originalElement, compiler); |
| } |
| } |
| |
| Element constructor = elements[send]; |
| Selector selector = elements.getSelector(send); |
| ConstructorElement constructorDeclaration = constructor; |
| ConstructorElement constructorImplementation = constructor.implementation; |
| constructor = constructorImplementation.effectiveTarget; |
| |
| final bool isSymbolConstructor = |
| constructorDeclaration == compiler.symbolConstructor; |
| final bool isJSArrayTypedConstructor = |
| constructorDeclaration == backend.jsArrayTypedConstructor; |
| |
| if (isSymbolConstructor) { |
| constructor = compiler.symbolValidatedConstructor; |
| assert(invariant(send, constructor != null, |
| message: 'Constructor Symbol.validated is missing')); |
| selector = compiler.symbolValidatedConstructorSelector; |
| assert(invariant(send, selector != null, |
| message: 'Constructor Symbol.validated is missing')); |
| } |
| |
| bool isRedirected = constructorDeclaration.isRedirectingFactory; |
| InterfaceType type = elements.getType(node); |
| InterfaceType expectedType = |
| constructorDeclaration.computeEffectiveTargetType(type); |
| expectedType = localsHandler.substInContext(expectedType); |
| |
| if (compiler.elementHasCompileTimeError(constructor)) { |
| // TODO(ahe): Do something like [generateWrongArgumentCountError]. |
| stack.add(graph.addConstantNull(compiler)); |
| return; |
| } |
| if (checkTypeVariableBounds(node, type)) return; |
| |
| var inputs = <HInstruction>[]; |
| if (constructor.isGenerativeConstructor && |
| Elements.isNativeOrExtendsNative(constructor.enclosingClass)) { |
| // Native class generative constructors take a pre-constructed object. |
| inputs.add(graph.addConstantNull(compiler)); |
| } |
| // TODO(5347): Try to avoid the need for calling [implementation] before |
| // calling [makeStaticArgumentList]. |
| if (!selector.applies(constructor.implementation, compiler.world)) { |
| generateWrongArgumentCountError(send, constructor, send.arguments); |
| return; |
| } |
| inputs.addAll(makeStaticArgumentList(selector, |
| send.arguments, |
| constructor.implementation)); |
| |
| TypeMask elementType = computeType(constructor); |
| if (isFixedListConstructorCall) { |
| if (!inputs[0].isNumber(compiler)) { |
| HTypeConversion conversion = new HTypeConversion( |
| null, HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType, |
| inputs[0], null); |
| add(conversion); |
| inputs[0] = conversion; |
| } |
| js.Template code = js.js.parseForeignJS('Array(#)'); |
| var behavior = new native.NativeBehavior(); |
| behavior.typesReturned.add(expectedType); |
| // The allocation can throw only if the given length is a double |
| // or negative. |
| bool canThrow = true; |
| if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) { |
| var constant = inputs[0]; |
| if (constant.constant.primitiveValue >= 0) canThrow = false; |
| } |
| HForeign foreign = new HForeign( |
| code, elementType, inputs, nativeBehavior: behavior, |
| canThrow: canThrow); |
| push(foreign); |
| TypesInferrer inferrer = compiler.typesTask.typesInferrer; |
| if (inferrer.isFixedArrayCheckedForGrowable(send)) { |
| js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array'); |
| // We set the instruction as [canThrow] to avoid it being dead code. |
| // We need a finer grained side effect. |
| add(new HForeign( |
| code, backend.nullType, [stack.last], canThrow: true)); |
| } |
| } else if (isGrowableListConstructorCall) { |
| push(buildLiteralList(<HInstruction>[])); |
| stack.last.instructionType = elementType; |
| } else { |
| ClassElement cls = constructor.enclosingClass; |
| if (cls.isAbstract && constructor.isGenerativeConstructor) { |
| generateAbstractClassInstantiationError(send, cls.name); |
| return; |
| } |
| potentiallyAddTypeArguments(inputs, cls, expectedType); |
| |
| addInlinedInstantiation(expectedType); |
| pushInvokeStatic(node, constructor, inputs, elementType); |
| removeInlinedInstantiation(expectedType); |
| } |
| HInstruction newInstance = stack.last; |
| if (isFixedList) { |
| // Overwrite the element type, in case the allocation site has |
| // been inlined. |
| newInstance.instructionType = elementType; |
| JavaScriptItemCompilationContext context = work.compilationContext; |
| context.allocatedFixedLists.add(newInstance); |
| } |
| |
| // The List constructor forwards to a Dart static method that does |
| // not know about the type argument. Therefore we special case |
| // this constructor to have the setRuntimeTypeInfo called where |
| // the 'new' is done. |
| if (backend.classNeedsRti(compiler.listClass) && |
| (isFixedListConstructorCall || isGrowableListConstructorCall || |
| isJSArrayTypedConstructor)) { |
| newInstance = handleListConstructor(type, send, pop()); |
| stack.add(newInstance); |
| } |
| |
| // Finally, if we called a redirecting factory constructor, check the type. |
| if (isRedirected) { |
| HInstruction checked = potentiallyCheckOrTrustType(newInstance, type); |
| if (checked != newInstance) { |
| pop(); |
| stack.add(checked); |
| } |
| } |
| } |
| |
| void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls, |
| InterfaceType expectedType) { |
| if (!backend.classNeedsRti(cls)) return; |
| assert(expectedType.typeArguments.isEmpty || |
| cls.typeVariables.length == expectedType.typeArguments.length); |
| expectedType.typeArguments.forEach((DartType argument) { |
| inputs.add(analyzeTypeArgument(argument)); |
| }); |
| } |
| |
| /// In checked mode checks the [type] of [node] to be well-bounded. The method |
| /// returns [:true:] if an error can be statically determined. |
| bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) { |
| if (!compiler.enableTypeAssertions) return false; |
| |
| Map<DartType, Set<DartType>> seenChecksMap = |
| new Map<DartType, Set<DartType>>(); |
| bool definitelyFails = false; |
| |
| addTypeVariableBoundCheck(GenericType instance, |
| DartType typeArgument, |
| TypeVariableType typeVariable, |
| DartType bound) { |
| if (definitelyFails) return; |
| |
| int subtypeRelation = compiler.types.computeSubtypeRelation(typeArgument, bound); |
| if (subtypeRelation == Types.IS_SUBTYPE) return; |
| |
| String message = |
| "Can't create an instance of malbounded type '$type': " |
| "'${typeArgument}' is not a subtype of bound '${bound}' for " |
| "type variable '${typeVariable}' of type " |
| "${type == instance |
| ? "'${type.element.thisType}'" |
| : "'${instance.element.thisType}' on the supertype " |
| "'${instance}' of '${type}'" |
| }."; |
| if (subtypeRelation == Types.NOT_SUBTYPE) { |
| generateTypeError(node, message); |
| definitelyFails = true; |
| return; |
| } else if (subtypeRelation == Types.MAYBE_SUBTYPE) { |
| Set<DartType> seenChecks = |
| seenChecksMap.putIfAbsent(typeArgument, () => new Set<DartType>()); |
| if (!seenChecks.contains(bound)) { |
| seenChecks.add(bound); |
| assertIsSubtype(node, typeArgument, bound, message); |
| } |
| } |
| } |
| |
| compiler.types.checkTypeVariableBounds(type, addTypeVariableBoundCheck); |
| if (definitelyFails) { |
| return true; |
| } |
| for (InterfaceType supertype in type.element.allSupertypes) { |
| DartType instance = type.asInstanceOf(supertype.element); |
| compiler.types.checkTypeVariableBounds(instance, |
| addTypeVariableBoundCheck); |
| if (definitelyFails) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| visitAssert(node) { |
| if (!compiler.enableUserAssertions) { |
| stack.add(graph.addConstantNull(compiler)); |
| return; |
| } |
| // TODO(johnniwinther): Don't handle assert like a regular static call. |
| // It breaks the selector name check since the assert helper method cannot |
| // be called `assert` and therefore does not match the selector like a |
| // regular method. |
| visitStaticSend(node); |
| } |
| |
| visitStaticSend(ast.Send node) { |
| Selector selector = elements.getSelector(node); |
| Element element = elements[node]; |
| if (elements.isAssert(node)) { |
| element = backend.assertMethod; |
| } |
| if (element.isForeign(backend) && element.isFunction) { |
| visitForeignSend(node); |
| return; |
| } |
| if (element.isErroneous) { |
| if (element is ErroneousElement) { |
| // An erroneous element indicates that the funciton could not be |
| // resolved (a warning has been issued). |
| generateThrowNoSuchMethod(node, |
| noSuchMethodTargetSymbolString(element), |
| argumentNodes: node.arguments); |
| } else { |
| // TODO(ahe): Do something like [generateWrongArgumentCountError]. |
| stack.add(graph.addConstantNull(compiler)); |
| } |
| return; |
| } |
| invariant(element, !element.isGenerativeConstructor); |
| generateIsDeferredLoadedCheckIfNeeded(node); |
| if (element.isFunction) { |
| // TODO(5347): Try to avoid the need for calling [implementation] before |
| // calling [makeStaticArgumentList]. |
| if (!selector.applies(element.implementation, compiler.world)) { |
| generateWrongArgumentCountError(node, element, node.arguments); |
| return; |
| } |
| |
| List<HInstruction> inputs = |
| makeStaticArgumentList(selector, |
| node.arguments, |
| element.implementation); |
| |
| if (element == compiler.identicalFunction) { |
| pushWithPosition( |
| new HIdentity(inputs[0], inputs[1], null, backend.boolType), node); |
| return; |
| } |
| |
| pushInvokeStatic(node, element, inputs); |
| } else { |
| generateGetter(node, element); |
| List<HInstruction> inputs = <HInstruction>[pop()]; |
| addDynamicSendArgumentsToList(node, inputs); |
| Selector closureSelector = new Selector.callClosureFrom(selector); |
| pushWithPosition( |
| new HInvokeClosure(closureSelector, inputs, backend.dynamicType), |
| node); |
| } |
| } |
| |
| HConstant addConstantString(String string) { |
| ast.DartString dartString = new ast.DartString.literal(string); |
| ConstantValue constant = constantSystem.createString(dartString); |
| return graph.addConstant(constant, compiler); |
| } |
| |
| visitTypePrefixSend(ast.Send node) { |
| compiler.internalError(node, "visitTypePrefixSend should not be called."); |
| } |
| |
| visitTypeLiteralSend(ast.Send node) { |
| DartType type = elements.getTypeLiteralType(node); |
| if (type.isInterfaceType || type.isTypedef || type.isDynamic) { |
| // TODO(karlklose): add type representation |
| if (node.isCall) { |
| // The node itself is not a constant but we register the selector (the |
| // identifier that refers to the class/typedef) as a constant. |
| stack.add(addConstant(node.selector)); |
| } else { |
| stack.add(addConstant(node)); |
| } |
| } else if (type.isTypeVariable) { |
| type = localsHandler.substInContext(type); |
| HInstruction value = analyzeTypeArgument(type); |
| pushInvokeStatic(node, |
| backend.getRuntimeTypeToString(), |
| [value], |
| backend.stringType); |
| pushInvokeStatic(node, |
| backend.getCreateRuntimeType(), |
| [pop()]); |
| } else { |
| internalError('unexpected type kind ${type.kind}', node: node); |
| } |
| if (node.isCall) { |
| // This send is of the form 'e(...)', where e is resolved to a type |
| // reference. We create a regular closure call on the result of the type |
| // reference instead of creating a NoSuchMethodError to avoid pulling it |
| // in if it is not used (e.g., in a try/catch). |
| HInstruction target = pop(); |
| Selector selector = elements.getSelector(node); |
| List<HInstruction> inputs = <HInstruction>[target]; |
| addDynamicSendArgumentsToList(node, inputs); |
| Selector closureSelector = new Selector.callClosureFrom(selector); |
| push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType)); |
| } |
| } |
| |
| visitGetterSend(ast.Send node) { |
| generateIsDeferredLoadedCheckIfNeeded(node); |
| generateGetter(node, elements[node]); |
| } |
| |
| // TODO(antonm): migrate rest of SsaFromAstMixin to internalError. |
| internalError(String reason, {ast.Node node}) { |
| compiler.internalError(node, reason); |
| } |
| |
| void generateError(ast.Node node, String message, Element helper) { |
| HInstruction errorMessage = addConstantString(message); |
| pushInvokeStatic(node, helper, [errorMessage]); |
| } |
| |
| void generateRuntimeError(ast.Node node, String message) { |
| generateError(node, message, backend.getThrowRuntimeError()); |
| } |
| |
| void generateTypeError(ast.Node node, String message) { |
| generateError(node, message, backend.getThrowTypeError()); |
| } |
| |
| void generateAbstractClassInstantiationError(ast.Node node, String message) { |
| generateError(node, |
| message, |
| backend.getThrowAbstractClassInstantiationError()); |
| } |
| |
| void generateThrowNoSuchMethod(ast.Node diagnosticNode, |
| String methodName, |
| {Link<ast.Node> argumentNodes, |
| List<HInstruction> argumentValues, |
| List<String> existingArguments}) { |
| Element helper = backend.getThrowNoSuchMethod(); |
| ConstantValue receiverConstant = |
| constantSystem.createString(new ast.DartString.empty()); |
| HInstruction receiver = graph.addConstant(receiverConstant, compiler); |
| ast.DartString dartString = new ast.DartString.literal(methodName); |
| ConstantValue nameConstant = constantSystem.createString(dartString); |
| HInstruction name = graph.addConstant(nameConstant, compiler); |
| if (argumentValues == null) { |
| argumentValues = <HInstruction>[]; |
| argumentNodes.forEach((argumentNode) { |
| visit(argumentNode); |
| HInstruction value = pop(); |
| argumentValues.add(value); |
| }); |
| } |
| HInstruction arguments = buildLiteralList(argumentValues); |
| add(arguments); |
| HInstruction existingNamesList; |
| if (existingArguments != null) { |
| List<HInstruction> existingNames = <HInstruction>[]; |
| for (String name in existingArguments) { |
| HInstruction nameConstant = |
| graph.addConstantString(new ast.DartString.literal(name), compiler); |
| existingNames.add(nameConstant); |
| } |
| existingNamesList = buildLiteralList(existingNames); |
| add(existingNamesList); |
| } else { |
| existingNamesList = graph.addConstantNull(compiler); |
| } |
| pushInvokeStatic(diagnosticNode, |
| helper, |
| [receiver, name, arguments, existingNamesList]); |
| } |
| |
| /** |
| * Generate code to throw a [NoSuchMethodError] exception for calling a |
| * method with a wrong number of arguments or mismatching named optional |
| * arguments. |
| */ |
| void generateWrongArgumentCountError(ast.Node diagnosticNode, |
| FunctionElement function, |
| Link<ast.Node> argumentNodes) { |
| List<String> existingArguments = <String>[]; |
| FunctionSignature signature = function.functionSignature; |
| signature.forEachParameter((Element parameter) { |
| existingArguments.add(parameter.name); |
| }); |
| generateThrowNoSuchMethod(diagnosticNode, |
| function.name, |
| argumentNodes: argumentNodes, |
| existingArguments: existingArguments); |
| } |
| |
| visitNewExpression(ast.NewExpression node) { |
| Element element = elements[node.send]; |
| final bool isSymbolConstructor = element == compiler.symbolConstructor; |
| if (!Elements.isErroneous(element)) { |
| ConstructorElement function = element; |
| element = function.effectiveTarget; |
| } |
| if (Elements.isErroneous(element)) { |
| if (element is !ErroneousElement) { |
| // TODO(ahe): Do something like [generateWrongArgumentCountError]. |
| stack.add(graph.addConstantNull(compiler)); |
| return; |
| } |
| ErroneousElement error = element; |
| if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) { |
| generateThrowNoSuchMethod( |
| node.send, |
| noSuchMethodTargetSymbolString(error, 'constructor'), |
| argumentNodes: node.send.arguments); |
| } else { |
| Message message = error.messageKind.message(error.messageArguments); |
| generateRuntimeError(node.send, message.toString()); |
| } |
| } else if (node.isConst) { |
| stack.add(addConstant(node)); |
| if (isSymbolConstructor) { |
| ConstructedConstantValue symbol = getConstantForNode(node); |
| StringConstantValue stringConstant = symbol.fields.single; |
| String nameString = stringConstant.toDartString().slowToString(); |
| registry.registerConstSymbol(nameString); |
| } |
| } else { |
| handleNewSend(node); |
| } |
| } |
| |
| void pushInvokeDynamic(ast.Node node, |
| Selector selector, |
| List<HInstruction> arguments, |
| {ast.Node location}) { |
| if (location == null) location = node; |
| |
| // We prefer to not inline certain operations on indexables, |
| // because the constant folder will handle them better and turn |
| // them into simpler instructions that allow further |
| // optimizations. |
| bool isOptimizableOperationOnIndexable(Selector selector, Element element) { |
| bool isLength = selector.isGetter |
| && selector.name == "length"; |
| if (isLength || selector.isIndex) { |
| TypeMask type = new TypeMask.nonNullExact( |
| element.enclosingClass.declaration, compiler.world); |
| return type.satisfies(backend.jsIndexableClass, compiler.world); |
| } else if (selector.isIndexSet) { |
| TypeMask type = new TypeMask.nonNullExact( |
| element.enclosingClass.declaration, compiler.world); |
| return type.satisfies(backend.jsMutableIndexableClass, compiler.world); |
| } else { |
| return false; |
| } |
| } |
| |
| bool isOptimizableOperation(Selector selector, Element element) { |
| ClassElement cls = element.enclosingClass; |
| if (isOptimizableOperationOnIndexable(selector, element)) return true; |
| if (!backend.interceptedClasses.contains(cls)) return false; |
| if (selector.isOperator) return true; |
| if (selector.isSetter) return true; |
| if (selector.isIndex) return true; |
| if (selector.isIndexSet) return true; |
| if (element == backend.jsArrayAdd |
| || element == backend.jsArrayRemoveLast |
| || element == backend.jsStringSplit) { |
| return true; |
| } |
| return false; |
| } |
| |
| Element element = compiler.world.locateSingleElement(selector); |
| if (element != null |
| && !element.isField |
| && !(element.isGetter && selector.isCall) |
| && !(element.isFunction && selector.isGetter) |
| && !isOptimizableOperation(selector, element)) { |
| if (tryInlineMethod(element, selector, arguments, node)) { |
| return; |
| } |
| } |
| |
| HInstruction receiver = arguments[0]; |
| List<HInstruction> inputs = <HInstruction>[]; |
| bool isIntercepted = backend.isInterceptedSelector(selector); |
| if (isIntercepted) { |
| inputs.add(invokeInterceptor(receiver)); |
| } |
| inputs.addAll(arguments); |
| TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler); |
| if (selector.isGetter) { |
| pushWithPosition( |
| new HInvokeDynamicGetter(selector, null, inputs, type), |
| location); |
| } else if (selector.isSetter) { |
| pushWithPosition( |
| new HInvokeDynamicSetter(selector, null, inputs, type), |
| location); |
| } else { |
| pushWithPosition( |
| new HInvokeDynamicMethod(selector, inputs, type, isIntercepted), |
| location); |
| } |
| } |
| |
| void pushInvokeStatic(ast.Node location, |
| Element element, |
| List<HInstruction> arguments, |
| [TypeMask type]) { |
| if (tryInlineMethod(element, null, arguments, location)) { |
| return; |
| } |
| |
| if (type == null) { |
| type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler); |
| } |
| bool targetCanThrow = !compiler.world.getCannotThrow(element); |
| // TODO(5346): Try to avoid the need for calling [declaration] before |
| // creating an [HInvokeStatic]. |
| HInvokeStatic instruction = new HInvokeStatic( |
| element.declaration, arguments, type, targetCanThrow: targetCanThrow); |
| if (!currentInlinedInstantiations.isEmpty) { |
| instruction.instantiatedTypes = new List<DartType>.from( |
| currentInlinedInstantiations); |
| } |
| instruction.sideEffects = compiler.world.getSideEffectsOfElement(element); |
| if (location == null) { |
| push(instruction); |
| } else { |
| pushWithPosition(instruction, location); |
| } |
| } |
| |
| HInstruction buildInvokeSuper(Selector selector, |
| Element element, |
| List<HInstruction> arguments) { |
| HInstruction receiver = localsHandler.readThis(); |
| // TODO(5346): Try to avoid the need for calling [declaration] before |
| // creating an [HStatic]. |
| List<HInstruction> inputs = <HInstruction>[]; |
| if (backend.isInterceptedSelector(selector) && |
| // Fields don't need an interceptor; consider generating HFieldGet/Set |
| // instead. |
| element.kind != ElementKind.FIELD) { |
| inputs.add(invokeInterceptor(receiver)); |
| } |
| inputs.add(receiver); |
| inputs.addAll(arguments); |
| TypeMask type; |
| if (!element.isGetter && selector.isGetter) { |
| type = TypeMaskFactory.inferredTypeForElement(element, compiler); |
| } else { |
| type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler); |
| } |
| HInstruction instruction = new HInvokeSuper( |
| element, |
| currentNonClosureClass, |
| selector, |
| inputs, |
| type, |
| isSetter: selector.isSetter || selector.isIndexSet); |
| instruction.sideEffects = compiler.world.getSideEffectsOfSelector(selector); |
| return instruction; |
| } |
| |
| void handleComplexOperatorSend(ast.SendSet node, |
| HInstruction receiver, |
| Link<ast.Node> arguments) { |
| HInstruction rhs; |
| if (node.isPrefix || node.isPostfix) { |
| rhs = graph.addConstantInt(1, compiler); |
| } else { |
| visit(arguments.head); |
| assert(arguments.tail.isEmpty); |
| rhs = pop(); |
| } |
| visitBinary(receiver, node.assignmentOperator, rhs, |
| elements.getOperatorSelectorInComplexSendSet(node), node); |
| } |
| |
| visitSendSet(ast.SendSet node) { |
| generateIsDeferredLoadedCheckIfNeeded(node); |
| Element element = elements[node]; |
| if (!Elements.isUnresolved(element) && element.impliesType) { |
| ast.Identifier selector = node.selector; |
| generateThrowNoSuchMethod(node, selector.source, |
| argumentNodes: node.arguments); |
| return; |
| } |
| ast.Operator op = node.assignmentOperator; |
| if (node.isSuperCall) { |
| HInstruction result; |
| List<HInstruction> setterInputs = <HInstruction>[]; |
| if (identical(node.assignmentOperator.source, '=')) { |
| addDynamicSendArgumentsToList(node, setterInputs); |
| result = setterInputs.last; |
| } else { |
| Element getter = elements[node.selector]; |
| List<HInstruction> getterInputs = <HInstruction>[]; |
| Link<ast.Node> arguments = node.arguments; |
| if (node.isIndex) { |
| // If node is of the from [:super.foo[0] += 2:], the send has |
| // two arguments: the index and the left hand side. We get |
| // the index and add it as input of the getter and the |
| // setter. |
| visit(arguments.head); |
| arguments = arguments.tail; |
| HInstruction index = pop(); |
| getterInputs.add(index); |
| setterInputs.add(index); |
| } |
| HInstruction getterInstruction; |
| Selector getterSelector = |
| elements.getGetterSelectorInComplexSendSet(node); |
| if (Elements.isUnresolved(getter)) { |
| generateSuperNoSuchMethodSend( |
| node, |
| getterSelector, |
| getterInputs); |
| getterInstruction = pop(); |
| } else { |
| getterInstruction = buildInvokeSuper( |
| getterSelector, getter, getterInputs); |
| add(getterInstruction); |
| } |
| handleComplexOperatorSend(node, getterInstruction, arguments); |
| setterInputs.add(pop()); |
| |
| if (node.isPostfix) { |
| result = getterInstruction; |
| } else { |
| result = setterInputs.last; |
| } |
| } |
| Selector setterSelector = elements.getSelector(node); |
| if (Elements.isUnresolved(element) |
| || !setterSelector.applies(element, compiler.world)) { |
| generateSuperNoSuchMethodSend( |
| node, setterSelector, setterInputs); |
| pop(); |
| } else { |
| add(buildInvokeSuper(setterSelector, element, setterInputs)); |
| } |
| stack.add(result); |
| } else if (node.isIndex) { |
| if ("=" == op.source) { |
| visitDynamicSend(node); |
| } else { |
| visit(node.receiver); |
| HInstruction receiver = pop(); |
| Link<ast.Node> arguments = node.arguments; |
| HInstruction index; |
| if (node.isIndex) { |
| visit(arguments.head); |
| arguments = arguments.tail; |
| index = pop(); |
| } |
| |
| pushInvokeDynamic( |
| node, |
| elements.getGetterSelectorInComplexSendSet(node), |
| [receiver, index]); |
| HInstruction getterInstruction = pop(); |
| |
| handleComplexOperatorSend(node, getterInstruction, arguments); |
| HInstruction value = pop(); |
| |
| pushInvokeDynamic( |
| node, elements.getSelector(node), [receiver, index, value]); |
| pop(); |
| |
| if (node.isPostfix) { |
| stack.add(getterInstruction); |
| } else { |
| stack.add(value); |
| } |
| } |
| } else if ("=" == op.source) { |
| Link<ast.Node> link = node.arguments; |
| assert(!link.isEmpty && link.tail.isEmpty); |
| if (Elements.isInstanceSend(node, elements)) { |
| HInstruction receiver = generateInstanceSendReceiver(node); |
| visit(link.head); |
| generateInstanceSetterWithCompiledReceiver(node, receiver, pop()); |
| } else { |
| visit(link.head); |
| generateNonInstanceSetter(node, element, pop()); |
| } |
| } else if (identical(op.source, "is")) { |
| compiler.internalError(op, "is-operator as SendSet."); |
| } else { |
| assert("++" == op.source || "--" == op.source || |
| node.assignmentOperator.source.endsWith("=")); |
| |
| // [receiver] is only used if the node is an instance send. |
| HInstruction receiver = null; |
| Element getter = elements[node.selector]; |
| |
| if (!Elements.isUnresolved(getter) && getter.impliesType) { |
| ast.Identifier selector = node.selector; |
| generateThrowNoSuchMethod(node, selector.source, |
| argumentNodes: node.arguments); |
| return; |
| } else if (Elements.isInstanceSend(node, elements)) { |
| receiver = generateInstanceSendReceiver(node); |
| generateInstanceGetterWithCompiledReceiver( |
| node, elements.getGetterSelectorInComplexSendSet(node), receiver); |
| } else { |
| generateGetter(node, getter); |
| } |
| HInstruction getterInstruction = pop(); |
| handleComplexOperatorSend(node, getterInstruction, node.arguments); |
| HInstruction value = pop(); |
| assert(value != null); |
| if (Elements.isInstanceSend(node, elements)) { |
| assert(receiver != null); |
| generateInstanceSetterWithCompiledReceiver(node, receiver, value); |
| } else { |
| assert(receiver == null); |
| generateNonInstanceSetter(node, element, value); |
| } |
| if (node.isPostfix) { |
| pop(); |
| stack.add(getterInstruction); |
| } |
| } |
| } |
| |
| void visitLiteralInt(ast.LiteralInt node) { |
| stack.add(graph.addConstantInt(node.value, compiler)); |
| } |
| |
| void visitLiteralDouble(ast.LiteralDouble node) { |
| stack.add(graph.addConstantDouble(node.value, compiler)); |
| } |
| |
| void visitLiteralBool(ast.LiteralBool node) { |
| stack.add(graph.addConstantBool(node.value, compiler)); |
| } |
| |
| void visitLiteralString(ast.LiteralString node) { |
| stack.add(graph.addConstantString(node.dartString, compiler)); |
| } |
| |
| void visitLiteralSymbol(ast.LiteralSymbol node) { |
| stack.add(addConstant(node)); |
| registry.registerConstSymbol(node.slowNameString); |
| } |
| |
| void visitStringJuxtaposition(ast.StringJuxtaposition node) { |
| if (!node.isInterpolation) { |
| // This is a simple string with no interpolations. |
| stack.add(graph.addConstantString(node.dartString, compiler)); |
| return; |
| } |
| StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node); |
| stringBuilder.visit(node); |
| stack.add(stringBuilder.result); |
| } |
| |
| void visitLiteralNull(ast.LiteralNull node) { |
| stack.add(graph.addConstantNull(compiler)); |
| } |
| |
| visitNodeList(ast.NodeList node) { |
| for (Link<ast.Node> link = node.nodes; !link.isEmpty; link = link.tail) { |
| if (isAborted()) { |
| compiler.reportWarning(link.head, |
| MessageKind.GENERIC, {'text': 'dead code'}); |
| } else { |
| visit(link.head); |
| } |
| } |
| } |
| |
| void visitParenthesizedExpression(ast.ParenthesizedExpression node) { |
| visit(node.expression); |
| } |
| |
| visitOperator(ast.Operator node) { |
| // Operators are intercepted in their surrounding Send nodes. |
| compiler.internalError(node, |
| 'SsaBuilder.visitOperator should not be called.'); |
| } |
| |
| visitCascade(ast.Cascade node) { |
| visit(node.expression); |
| // Remove the result and reveal the duplicated receiver on the stack. |
| pop(); |
| } |
| |
| visitCascadeReceiver(ast.CascadeReceiver node) { |
| visit(node.expression); |
| dup(); |
| } |
| |
| void handleInTryStatement() { |
| if (!inTryStatement) return; |
| HBasicBlock block = close(new HExitTry()); |
| HBasicBlock newBlock = graph.addNewBlock(); |
| block.addSuccessor(newBlock); |
| open(newBlock); |
| } |
| |
| visitRethrow(ast.Rethrow node) { |
| HInstruction exception = rethrowableException; |
| if (exception == null) { |
| exception = graph.addConstantNull(compiler); |
| compiler.internalError(node, |
| 'rethrowableException should not be null.'); |
| } |
| handleInTryStatement(); |
| closeAndGotoExit(new HThrow(exception, isRethrow: true)); |
| } |
| |
| visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) { |
| ConstructorElement targetConstructor = |
| elements.getRedirectingTargetConstructor(node).implementation; |
| ConstructorElement redirectingConstructor = sourceElement.implementation; |
| List<HInstruction> inputs = <HInstruction>[]; |
| FunctionSignature targetSignature = targetConstructor.functionSignature; |
| FunctionSignature redirectingSignature = |
| redirectingConstructor.functionSignature; |
| redirectingSignature.forEachRequiredParameter((ParameterElement element) { |
| inputs.add(localsHandler.readLocal(element)); |
| }); |
| List<Element> targetOptionals = |
| targetSignature.orderedOptionalParameters; |
| List<Element> redirectingOptionals = |
| redirectingSignature.orderedOptionalParameters; |
| int i = 0; |
| for (; i < redirectingOptionals.length; i++) { |
| ParameterElement parameter = redirectingOptionals[i]; |
| inputs.add(localsHandler.readLocal(parameter)); |
| } |
| for (; i < targetOptionals.length; i++) { |
| inputs.add(handleConstantForOptionalParameter(targetOptionals[i])); |
| } |
| ClassElement targetClass = targetConstructor.enclosingClass; |
| if (backend.classNeedsRti(targetClass)) { |
| ClassElement cls = redirectingConstructor.enclosingClass; |
| InterfaceType targetType = |
| redirectingConstructor.computeEffectiveTargetType(cls.thisType); |
| targetType = localsHandler.substInContext(targetType); |
| targetType.typeArguments.forEach((DartType argument) { |
| inputs.add(analyzeTypeArgument(argument)); |
| }); |
| } |
| pushInvokeStatic(node, targetConstructor, inputs); |
| HInstruction value = pop(); |
| emitReturn(value, node); |
| } |
| |
| visitReturn(ast.Return node) { |
| if (identical(node.beginToken.stringValue, 'native')) { |
| native.handleSsaNative(this, node.expression); |
| return; |
| } |
| HInstruction value; |
| if (node.expression == null) { |
| value = graph.addConstantNull(compiler); |
| } else { |
| visit(node.expression); |
| value = pop(); |
| value = potentiallyCheckOrTrustType(value, returnType); |
| } |
| |
| handleInTryStatement(); |
| emitReturn(value, node); |
| } |
| |
| visitThrow(ast.Throw node) { |
| visitThrowExpression(node.expression); |
| if (isReachable) { |
| handleInTryStatement(); |
| push(new HThrowExpression(pop())); |
| isReachable = false; |
| } |
| } |
| |
| visitYield(ast.Yield node) { |
| // Dummy implementation. |
| visit(node.expression); |
| pop(); |
| } |
| |
| visitAwait(ast.Await node) { |
| // Dummy implementation. |
| visit(node.expression); |
| } |
| |
| visitTypeAnnotation(ast.TypeAnnotation node) { |
| compiler.internalError(node, |
| 'Visiting type annotation in SSA builder.'); |
| } |
| |
| visitVariableDefinitions(ast.VariableDefinitions node) { |
| assert(isReachable); |
| for (Link<ast.Node> link = node.definitions.nodes; |
| !link.isEmpty; |
| link = link.tail) { |
| ast.Node definition = link.head; |
| if (definition is ast.Identifier) { |
| HInstruction initialValue = graph.addConstantNull(compiler); |
| LocalElement local = elements[definition]; |
| localsHandler.updateLocal(local, initialValue); |
| } else { |
| assert(definition is ast.SendSet); |
| visitSendSet(definition); |
| pop(); // Discard value. |
| } |
| } |
| } |
| |
| HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) { |
| InterfaceType type = localsHandler.substInContext(elements.getType(node)); |
| if (!backend.classNeedsRti(type.element) || type.treatAsRaw) { |
| return object; |
| } |
| List<HInstruction> arguments = <HInstruction>[]; |
| for (DartType argument in type.typeArguments) { |
| arguments.add(analyzeTypeArgument(argument)); |
| } |
| // TODO(15489): Register at codegen. |
| registry.registerInstantiatedType(type); |
| return callSetRuntimeTypeInfo(type.element, arguments, object); |
| } |
| |
| visitLiteralList(ast.LiteralList node) { |
| HInstruction instruction; |
| |
| if (node.isConst) { |
| instruction = addConstant(node); |
| } else { |
| List<HInstruction> inputs = <HInstruction>[]; |
| for (Link<ast.Node> link = node.elements.nodes; |
| !link.isEmpty; |
| link = link.tail) { |
| visit(link.head); |
| inputs.add(pop()); |
| } |
| instruction = buildLiteralList(inputs); |
| add(instruction); |
| instruction = setRtiIfNeeded(instruction, node); |
| } |
| |
| TypeMask type = |
| TypeMaskFactory.inferredForNode(sourceElement, node, compiler); |
| if (!type.containsAll(compiler.world)) instruction.instructionType = type; |
| stack.add(instruction); |
| } |
| |
| visitConditional(ast.Conditional node) { |
| SsaBranchBuilder brancher = new SsaBranchBuilder(this, node); |
| brancher.handleConditional(() => visit(node.condition), |
| () => visit(node.thenExpression), |
| () => visit(node.elseExpression)); |
| } |
| |
| visitStringInterpolation(ast.StringInterpolation node) { |
| StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node); |
| stringBuilder.visit(node); |
| stack.add(stringBuilder.result); |
| } |
| |
| visitStringInterpolationPart(ast.StringInterpolationPart node) { |
| // The parts are iterated in visitStringInterpolation. |
| compiler.internalError(node, |
| 'SsaBuilder.visitStringInterpolation should not be called.'); |
| } |
| |
| visitEmptyStatement(ast.EmptyStatement node) { |
| // Do nothing, empty statement. |
| } |
| |
| visitModifiers(ast.Modifiers node) { |
| compiler.unimplemented(node, 'SsaFromAstMixin.visitModifiers.'); |
| } |
| |
| visitBreakStatement(ast.BreakStatement node) { |
| assert(!isAborted()); |
| handleInTryStatement(); |
| JumpTarget target = elements.getTargetOf(node); |
| assert(target != null); |
| JumpHandler handler = jumpTargets[target]; |
| assert(handler != null); |
| if (node.target == null) { |
| handler.generateBreak(); |
| } else { |
| LabelDefinition label = elements.getTargetLabel(node); |
| handler.generateBreak(label); |
| } |
| } |
| |
| visitContinueStatement(ast.ContinueStatement node) { |
| handleInTryStatement(); |
| JumpTarget target = elements.getTargetOf(node); |
| assert(target != null); |
| JumpHandler handler = jumpTargets[target]; |
| assert(handler != null); |
| if (node.target == null) { |
| handler.generateContinue(); |
| } else { |
| LabelDefinition label = elements.getTargetLabel(node); |
| assert(label != null); |
| handler.generateContinue(label); |
| } |
| } |
| |
| /** |
| * Creates a [JumpHandler] for a statement. The node must be a jump |
| * target. If there are no breaks or continues targeting the statement, |
| * a special "null handler" is returned. |
| * |
| * [isLoopJump] is [:true:] when the jump handler is for a loop. This is used |
| * to distinguish the synthetized loop created for a switch statement with |
| * continue statements from simple switch statements. |
| */ |
| JumpHandler createJumpHandler(ast.Statement node, {bool isLoopJump}) { |
| JumpTarget element = elements.getTargetDefinition(node); |
| if (element == null || !identical(element.statement, node)) { |
| // No breaks or continues to this node. |
| return new NullJumpHandler(compiler); |
| } |
| if (isLoopJump && node is ast.SwitchStatement) { |
| // Create a special jump handler for loops created for switch statements |
| // with continue statements. |
| return new SwitchCaseJumpHandler(this, element, node); |
| } |
| return new JumpHandler(this, element); |
| } |
| |
| visitForIn(ast.ForIn node) { |
| // Generate a structure equivalent to: |
| // Iterator<E> $iter = <iterable>.iterator; |
| // while ($iter.moveNext()) { |
| // E <declaredIdentifier> = $iter.current; |
| // <body> |
| // } |
| |
| // The iterator is shared between initializer, condition and body. |
| HInstruction iterator; |
| void buildInitializer() { |
| Selector selector = elements.getIteratorSelector(node); |
| visit(node.expression); |
| HInstruction receiver = pop(); |
| pushInvokeDynamic(node, selector, [receiver]); |
| iterator = pop(); |
| } |
| HInstruction buildCondition() { |
| Selector selector = elements.getMoveNextSelector(node); |
| pushInvokeDynamic(node, selector, [iterator]); |
| return popBoolified(); |
| } |
| void buildBody() { |
| Selector call = elements.getCurrentSelector(node); |
| pushInvokeDynamic(node, call, [iterator]); |
| |
| ast.Node identifier = node.declaredIdentifier; |
| Element variable = elements.getForInVariable(node); |
| Selector selector = elements.getSelector(identifier); |
| |
| HInstruction value = pop(); |
| if (identifier.asSend() != null |
| && Elements.isInstanceSend(identifier, elements)) { |
| HInstruction receiver = generateInstanceSendReceiver(identifier); |
| assert(receiver != null); |
| generateInstanceSetterWithCompiledReceiver( |
| null, |
| receiver, |
| value, |
| selector: selector, |
| location: identifier); |
| } else { |
| generateNonInstanceSetter(null, variable, value, location: identifier); |
| } |
| pop(); // Pop the value pushed by the setter call. |
| |
| visit(node.body); |
| } |
| handleLoop(node, buildInitializer, buildCondition, () {}, buildBody); |
| } |
| |
| visitLabel(ast.Label node) { |
| compiler.internalError(node, 'SsaFromAstMixin.visitLabel.'); |
| } |
| |
| visitLabeledStatement(ast.LabeledStatement node) { |
| ast.Statement body = node.statement; |
| if (body is ast.Loop |
| || body is ast.SwitchStatement |
| || Elements.isUnusedLabel(node, elements)) { |
| // Loops and switches handle their own labels. |
| visit(body); |
| return; |
| } |
| JumpTarget targetElement = elements.getTargetDefinition(body); |
| LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler); |
| assert(targetElement.isBreakTarget); |
| JumpHandler handler = new JumpHandler(this, targetElement); |
| // Introduce a new basic block. |
| HBasicBlock entryBlock = openNewBlock(); |
| visit(body); |
| SubGraph bodyGraph = new SubGraph(entryBlock, lastOpenedBlock); |
| |
| HBasicBlock joinBlock = graph.addNewBlock(); |
| List<LocalsHandler> breakHandlers = <LocalsHandler>[]; |
| handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) { |
| breakInstruction.block.addSuccessor(joinBlock); |
| breakHandlers.add(locals); |
| }); |
| bool hasBreak = breakHandlers.length > 0; |
| if (!isAborted()) { |
| goto(current, joinBlock); |
| breakHandlers.add(localsHandler); |
| } |
| open(joinBlock); |
| localsHandler = beforeLocals.mergeMultiple(breakHandlers, joinBlock); |
| |
| if (hasBreak) { |
| // There was at least one reachable break, so the label is needed. |
| entryBlock.setBlockFlow( |
| new HLabeledBlockInformation(new HSubGraphBlockInformation(bodyGraph), |
| handler.labels()), |
| joinBlock); |
| } |
| handler.close(); |
| } |
| |
| visitLiteralMap(ast.LiteralMap node) { |
| if (node.isConst) { |
| stack.add(addConstant(node)); |
| return; |
| } |
| List<HInstruction> listInputs = <HInstruction>[]; |
| for (Link<ast.Node> link = node.entries.nodes; |
| !link.isEmpty; |
| link = link.tail) { |
| visit(link.head); |
| listInputs.add(pop()); |
| listInputs.add(pop()); |
| } |
| |
| ConstructorElement constructor; |
| List<HInstruction> inputs = <HInstruction>[]; |
| |
| if (listInputs.isEmpty) { |
| constructor = backend.mapLiteralConstructorEmpty; |
| } else { |
| constructor = backend.mapLiteralConstructor; |
| HLiteralList keyValuePairs = buildLiteralList(listInputs); |
| add(keyValuePairs); |
| inputs.add(keyValuePairs); |
| } |
| |
| assert(constructor.isFactoryConstructor); |
| |
| ConstructorElement functionElement = constructor; |
| constructor = functionElement.effectiveTarget; |
| |
| InterfaceType type = elements.getType(node); |
| InterfaceType expectedType = |
| functionElement.computeEffectiveTargetType(type); |
| expectedType = localsHandler.substInContext(expectedType); |
| |
| ClassElement cls = constructor.enclosingClass; |
| |
| if (backend.classNeedsRti(cls)) { |
| List<DartType> typeVariable = cls.typeVariables; |
| expectedType.typeArguments.forEach((DartType argument) { |
| inputs.add(analyzeTypeArgument(argument)); |
| }); |
| } |
| |
| // The instruction type will always be a subtype of the mapLiteralClass, but |
| // type inference might discover a more specific type, or find nothing (in |
| // dart2js unit tests). |
| TypeMask mapType = |
| new TypeMask.nonNullSubtype(backend.mapLiteralClass, compiler.world); |
| TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement( |
| constructor, compiler); |
| TypeMask instructionType = |
| mapType.intersection(returnTypeMask, compiler.world); |
| |
| addInlinedInstantiation(expectedType); |
| pushInvokeStatic(node, constructor, inputs, instructionType); |
| removeInlinedInstantiation(expectedType); |
| } |
| |
| visitLiteralMapEntry(ast.LiteralMapEntry node) { |
| visit(node.value); |
| visit(node.key); |
| } |
| |
| visitNamedArgument(ast.NamedArgument node) { |
| visit(node.expression); |
| } |
| |
| Map<ast.CaseMatch, ConstantValue> buildSwitchCaseConstants( |
| ast.SwitchStatement node) { |
| |
| Map<ast.CaseMatch, ConstantValue> constants = |
| new Map<ast.CaseMatch, ConstantValue>(); |
| for (ast.SwitchCase switchCase in node.cases) { |
| for (ast.Node labelOrCase in switchCase.labelsAndCases) { |
| if (labelOrCase is ast.CaseMatch) { |
| ast.CaseMatch match = labelOrCase; |
| ConstantValue constant = getConstantForNode(match.expression); |
| constants[labelOrCase] = constant; |
| } |
| } |
| } |
| return constants; |
| } |
| |
| visitSwitchStatement(ast.SwitchStatement node) { |
| Map<ast.CaseMatch, ConstantValue> constants = |
| buildSwitchCaseConstants(node); |
| |
| // The switch case indices must match those computed in |
| // [SwitchCaseJumpHandler]. |
| bool hasContinue = false; |
| Map<ast.SwitchCase, int> caseIndex = new Map<ast.SwitchCase, int>(); |
| int switchIndex = 1; |
| bool hasDefault = false; |
| for (ast.SwitchCase switchCase in node.cases) { |
| for (ast.Node labelOrCase in switchCase.labelsAndCases) { |
| ast.Node label = labelOrCase.asLabel(); |
| if (label != null) { |
| LabelDefinition labelElement = elements.getLabelDefinition(label); |
| if (labelElement != null && labelElement.isContinueTarget) { |
| hasContinue = true; |
| } |
| } |
| } |
| if (switchCase.isDefaultCase) { |
| hasDefault = true; |
| } |
| caseIndex[switchCase] = switchIndex; |
| switchIndex++; |
| } |
| if (!hasContinue) { |
| // If the switch statement has no switch cases targeted by continue |
| // statements we encode the switch statement directly. |
| buildSimpleSwitchStatement(node, constants); |
| } else { |
| buildComplexSwitchStatement(node, constants, caseIndex, hasDefault); |
| } |
| } |
| |
| /** |
| * Builds a simple switch statement which does not handle uses of continue |
| * statements to labeled switch cases. |
| */ |
| void buildSimpleSwitchStatement(ast.SwitchStatement node, |
| Map<ast.CaseMatch, ConstantValue> constants) { |
| JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false); |
| HInstruction buildExpression() { |
| visit(node.expression); |
| return pop(); |
| } |
| Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) { |
| List<ConstantValue> constantList = <ConstantValue>[]; |
| for (ast.Node labelOrCase in switchCase.labelsAndCases) { |
| if (labelOrCase is ast.CaseMatch) { |
| constantList.add(constants[labelOrCase]); |
| } |
| } |
| return constantList; |
| } |
| bool isDefaultCase(ast.SwitchCase switchCase) { |
| return switchCase.isDefaultCase; |
| } |
| void buildSwitchCase(ast.SwitchCase node) { |
| visit(node.statements); |
| } |
| handleSwitch(node, |
| jumpHandler, |
| buildExpression, |
| node.cases, |
| getConstants, |
| isDefaultCase, |
| buildSwitchCase); |
| jumpHandler.close(); |
| } |
| |
| /** |
| * Builds a switch statement that can handle arbitrary uses of continue |
| * statements to labeled switch cases. |
| */ |
| void buildComplexSwitchStatement(ast.SwitchStatement node, |
| Map<ast.CaseMatch, ConstantValue> constants, |
| Map<ast.SwitchCase, int> caseIndex, |
| bool hasDefault) { |
| // If the switch statement has switch cases targeted by continue |
| // statements we create the following encoding: |
| // |
| // switch (e) { |
| // l_1: case e0: s_1; break; |
| // l_2: case e1: s_2; continue l_i; |
| // ... |
| // l_n: default: s_n; continue l_j; |
| // } |
| // |
| // is encoded as |
| // |
| // var target; |
| // switch (e) { |
| // case e1: target = 1; break; |
| // case e2: target = 2; break; |
| // ... |
| // default: target = n; break; |
| // } |
| // l: while (true) { |
| // switch (target) { |
| // case 1: s_1; break l; |
| // case 2: s_2; target = i; continue l; |
| // ... |
| // case n: s_n; target = j; continue l; |
| // } |
| // } |
| |
| JumpTarget switchTarget = elements.getTargetDefinition(node); |
| HInstruction initialValue = graph.addConstantNull(compiler); |
| localsHandler.updateLocal(switchTarget, initialValue); |
| |
| JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false); |
| var switchCases = node.cases; |
| if (!hasDefault) { |
| // Use [:null:] as the marker for a synthetic default clause. |
| // The synthetic default is added because otherwise, there would be no |
| // good place to give a default value to the local. |
| switchCases = node.cases.nodes.toList()..add(null); |
| } |
| HInstruction buildExpression() { |
| visit(node.expression); |
| return pop(); |
| } |
| Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) { |
| List<ConstantValue> constantList = <ConstantValue>[]; |
| if (switchCase != null) { |
| for (ast.Node labelOrCase in switchCase.labelsAndCases) { |
| if (labelOrCase is ast.CaseMatch) { |
| constantList.add(constants[labelOrCase]); |
| } |
| } |
| } |
| return constantList; |
| } |
| bool isDefaultCase(ast.SwitchCase switchCase) { |
| return switchCase == null || switchCase.isDefaultCase; |
| } |
| void buildSwitchCase(ast.SwitchCase switchCase) { |
| if (switchCase != null) { |
| // Generate 'target = i; break;' for switch case i. |
| int index = caseIndex[switchCase]; |
| HInstruction value = graph.addConstantInt(index, compiler); |
| localsHandler.updateLocal(switchTarget, value); |
| } else { |
| // Generate synthetic default case 'target = null; break;'. |
| HInstruction value = graph.addConstantNull(compiler); |
| localsHandler.updateLocal(switchTarget, value); |
| } |
| jumpTargets[switchTarget].generateBreak(); |
| } |
| handleSwitch(node, |
| jumpHandler, |
| buildExpression, |
| switchCases, |
| getConstants, |
| isDefaultCase, |
| buildSwitchCase); |
| jumpHandler.close(); |
| |
| HInstruction buildCondition() => |
| graph.addConstantBool(true, compiler); |
| |
| void buildSwitch() { |
| HInstruction buildExpression() { |
| return localsHandler.readLocal(switchTarget); |
| } |
| Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) { |
| return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])]; |
| } |
| void buildSwitchCase(ast.SwitchCase switchCase) { |
| visit(switchCase.statements); |
| if (!isAborted()) { |
| // Ensure that we break the loop if the case falls through. (This |
| // is only possible for the last case.) |
| jumpTargets[switchTarget].generateBreak(); |
| } |
| } |
| // Pass a [NullJumpHandler] because the target for the contained break |
| // is not the generated switch statement but instead the loop generated |
| // in the call to [handleLoop] below. |
| handleSwitch(node, |
| new NullJumpHandler(compiler), |
| buildExpression, node.cases, getConstants, |
| (_) => false, // No case is default. |
| buildSwitchCase); |
| } |
| |
| void buildLoop() { |
| handleLoop(node, |
| () {}, |
| buildCondition, |
| () {}, |
| buildSwitch); |
| } |
| |
| if (hasDefault) { |
| buildLoop(); |
| } else { |
| // If the switch statement has no default case, surround the loop with |
| // a test of the target. |
| void buildCondition() { |
| js.Template code = js.js.parseForeignJS('#'); |
| push(createForeign(code, |
| backend.boolType, |
| [localsHandler.readLocal(switchTarget)])); |
| } |
| handleIf(node, buildCondition, buildLoop, () => {}); |
| } |
| } |
| |
| /** |
| * Creates a switch statement. |
| * |
| * [jumpHandler] is the [JumpHandler] for the created switch statement. |
| * [buildExpression] creates the switch expression. |
| * [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or |
| * a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes. |
| * [getConstants] returns the set of constants for a switch case. |
| * [isDefaultCase] returns [:true:] if the provided switch case should be |
| * considered default for the created switch statement. |
| * [buildSwitchCase] creates the statements for the switch case. |
| */ |
| void handleSwitch( |
| ast.Node errorNode, |
| JumpHandler jumpHandler, |
| HInstruction buildExpression(), |
| var switchCases, |
| Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase), |
| bool isDefaultCase(ast.SwitchCase switchCase), |
| void buildSwitchCase(ast.SwitchCase switchCase)) { |
| |
| Map<ast.CaseMatch, ConstantValue> constants = |
| new Map<ast.CaseMatch, ConstantValue>(); |
| |
| HBasicBlock expressionStart = openNewBlock(); |
| HInstruction expression = buildExpression(); |
| if (switchCases.isEmpty) { |
| return; |
| } |
| |
| HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]); |
| HBasicBlock expressionEnd = close(switchInstruction); |
| LocalsHandler savedLocals = localsHandler; |
| |
| List<HStatementInformation> statements = <HStatementInformation>[]; |
| bool hasDefault = false; |
| Element getFallThroughErrorElement = backend.getFallThroughError(); |
| HasNextIterator<ast.Node> caseIterator = |
| new HasNextIterator<ast.Node>(switchCases.iterator); |
| while (caseIterator.hasNext) { |
| ast.SwitchCase switchCase = caseIterator.next(); |
| HBasicBlock block = graph.addNewBlock(); |
| for (ConstantValue constant in getConstants(switchCase)) { |
| HConstant hConstant = graph.addConstant(constant, compiler); |
| switchInstruction.inputs.add(hConstant); |
| hConstant.usedBy.add(switchInstruction); |
| expressionEnd.addSuccessor(block); |
| } |
| |
| if (isDefaultCase(switchCase)) { |
| // An HSwitch has n inputs and n+1 successors, the last being the |
| // default case. |
| expressionEnd.addSuccessor(block); |
| hasDefault = true; |
| } |
| open(block); |
| localsHandler = new LocalsHandler.from(savedLocals); |
| buildSwitchCase(switchCase); |
| if (!isAborted()) { |
| if (caseIterator.hasNext) { |
| pushInvokeStatic(switchCase, getFallThroughErrorElement, []); |
| HInstruction error = pop(); |
| closeAndGotoExit(new HThrow(error)); |
| } else if (!isDefaultCase(switchCase)) { |
| // If there is no default, we will add one later to avoid |
| // the critical edge. So we generate a break statement to make |
| // sure the last case does not fall through to the default case. |
| jumpHandler.generateBreak(); |
| } |
| } |
| statements.add( |
| new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock))); |
| } |
| |
| // Add a join-block if necessary. |
| // We create [joinBlock] early, and then go through the cases that might |
| // want to jump to it. In each case, if we add [joinBlock] as a successor |
| // of another block, we also add an element to [caseHandlers] that is used |
| // to create the phis in [joinBlock]. |
| // If we never jump to the join block, [caseHandlers] will stay empty, and |
| // the join block is never added to the graph. |
| HBasicBlock joinBlock = new HBasicBlock(); |
| List<LocalsHandler> caseHandlers = <LocalsHandler>[]; |
| jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) { |
| instruction.block.addSuccessor(joinBlock); |
| caseHandlers.add(locals); |
| }); |
| jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) { |
| assert(invariant(errorNode, false, |
| message: 'Continue cannot target a switch.')); |
| }); |
| if (!isAborted()) { |
| current.close(new HGoto()); |
| lastOpenedBlock.addSuccessor(joinBlock); |
| caseHandlers.add(localsHandler); |
| } |
| if (!hasDefault) { |
| // Always create a default case, to avoid a critical edge in the |
| // graph. |
| HBasicBlock defaultCase = addNewBlock(); |
| expressionEnd.addSuccessor(defaultCase); |
| open(defaultCase); |
| close(new HGoto()); |
| defaultCase.addSuccessor(joinBlock); |
| caseHandlers.add(savedLocals); |
| statements.add(new HSubGraphBlockInformation(new SubGraph( |
| defaultCase, defaultCase))); |
| } |
| assert(caseHandlers.length == joinBlock.predecessors.length); |
| if (caseHandlers.length != 0) { |
| graph.addBlock(joinBlock); |
| open(joinBlock); |
| if (caseHandlers.length == 1) { |
| localsHandler = caseHandlers[0]; |
| } else { |
| localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock); |
| } |
| } else { |
| // The joinblock is not used. |
| joinBlock = null; |
| } |
| |
| HSubExpressionBlockInformation expressionInfo = |
| new HSubExpressionBlockInformation(new SubExpression(expressionStart, |
| expressionEnd)); |
| expressionStart.setBlockFlow( |
| new HSwitchBlockInformation(expressionInfo, |
| statements, |
| jumpHandler.target, |
| jumpHandler.labels()), |
| joinBlock); |
| |
| jumpHandler.close(); |
| } |
| |
| visitSwitchCase(ast.SwitchCase node) { |
| compiler.internalError(node, 'SsaFromAstMixin.visitSwitchCase.'); |
| } |
| |
| visitCaseMatch(ast.CaseMatch node) { |
| compiler.internalError(node, 'SsaFromAstMixin.visitCaseMatch.'); |
| } |
| |
| visitTryStatement(ast.TryStatement node) { |
| // Save the current locals. The catch block and the finally block |
| // must not reuse the existing locals handler. None of the variables |
| // that have been defined in the body-block will be used, but for |
| // loops we will add (unnecessary) phis that will reference the body |
| // variables. This makes it look as if the variables were used |
| // in a non-dominated block. |
| LocalsHandler savedLocals = new LocalsHandler.from(localsHandler); |
| HBasicBlock enterBlock = openNewBlock(); |
| HTry tryInstruction = new HTry(); |
| close(tryInstruction); |
| bool oldInTryStatement = inTryStatement; |
| inTryStatement = true; |
| |
| HBasicBlock startTryBlock; |
| HBasicBlock endTryBlock; |
| HBasicBlock startCatchBlock; |
| HBasicBlock endCatchBlock; |
| HBasicBlock startFinallyBlock; |
| HBasicBlock endFinallyBlock; |
| |
| startTryBlock = graph.addNewBlock(); |
| open(startTryBlock); |
| visit(node.tryBlock); |
| // We use a [HExitTry] instead of a [HGoto] for the try block |
| // because it will have multiple successors: the join block, and |
| // the catch or finally block. |
| if (!isAborted()) endTryBlock = close(new HExitTry()); |
| SubGraph bodyGraph = new SubGraph(startTryBlock, lastOpenedBlock); |
| SubGraph catchGraph = null; |
| HLocalValue exception = null; |
| |
| if (!node.catchBlocks.isEmpty) { |
| localsHandler = new LocalsHandler.from(savedLocals); |
| startCatchBlock = graph.addNewBlock(); |
| open(startCatchBlock); |
| // Note that the name of this local is irrelevant. |
| SyntheticLocal local = |
| new SyntheticLocal('exception', localsHandler.executableContext); |
| exception = new HLocalValue(local, backend.nonNullType); |
| add(exception); |
| HInstruction oldRethrowableException = rethrowableException; |
| rethrowableException = exception; |
| |
| pushInvokeStatic(node, backend.getExceptionUnwrapper(), [exception]); |
| HInvokeStatic unwrappedException = pop(); |
| tryInstruction.exception = exception; |
| Link<ast.Node> link = node.catchBlocks.nodes; |
| |
| void pushCondition(ast.CatchBlock catchBlock) { |
| if (catchBlock.onKeyword != null) { |
| DartType type = elements.getType(catchBlock.type); |
| if (type == null) { |
| compiler.internalError(catchBlock.type, 'On with no type.'); |
| } |
| HInstruction condition = |
| buildIsNode(catchBlock.type, type, unwrappedException); |
| push(condition); |
| } else { |
| ast.VariableDefinitions declaration = catchBlock.formals.nodes.head; |
| HInstruction condition = null; |
| if (declaration.type == null) { |
| condition = graph.addConstantBool(true, compiler); |
| stack.add(condition); |
| } else { |
| // TODO(aprelev@gmail.com): Once old catch syntax is removed |
| // "if" condition above and this "else" branch should be deleted as |
| // type of declared variable won't matter for the catch |
| // condition. |
| DartType type = elements.getType(declaration.type); |
| if (type == null) { |
| compiler.internalError(catchBlock, 'Catch with unresolved type.'); |
| } |
| condition = buildIsNode(declaration.type, type, unwrappedException); |
| push(condition); |
| } |
| } |
| } |
| |
| void visitThen() { |
| ast.CatchBlock catchBlock = link.head; |
| link = link.tail; |
| if (catchBlock.exception != null) { |
| LocalVariableElement exceptionVariable = |
| elements[catchBlock.exception]; |
| localsHandler.updateLocal(exceptionVariable, |
| unwrappedException); |
| } |
| ast.Node trace = catchBlock.trace; |
| if (trace != null) { |
| pushInvokeStatic(trace, backend.getTraceFromException(), [exception]); |
| HInstruction traceInstruction = pop(); |
| LocalVariableElement traceVariable = elements[trace]; |
| localsHandler.updateLocal(traceVariable, traceInstruction); |
| } |
| visit(catchBlock); |
| } |
| |
| void visitElse() { |
| if (link.isEmpty) { |
| closeAndGotoExit(new HThrow(exception, isRethrow: true)); |
| } else { |
| ast.CatchBlock newBlock = link.head; |
| handleIf(node, |
| () { pushCondition(newBlock); }, |
| visitThen, visitElse); |
| } |
| } |
| |
| ast.CatchBlock firstBlock = link.head; |
| handleIf(node, () { pushCondition(firstBlock); }, visitThen, visitElse); |
| if (!isAborted()) endCatchBlock = close(new HGoto()); |
| |
| rethrowableException = oldRethrowableException; |
| tryInstruction.catchBlock = startCatchBlock; |
| catchGraph = new SubGraph(startCatchBlock, lastOpenedBlock); |
| } |
| |
| SubGraph finallyGraph = null; |
| if (node.finallyBlock != null) { |
| localsHandler = new LocalsHandler.from(savedLocals); |
| startFinallyBlock = graph.addNewBlock(); |
| open(startFinallyBlock); |
| visit(node.finallyBlock); |
| if (!isAborted()) endFinallyBlock = close(new HGoto()); |
| tryInstruction.finallyBlock = startFinallyBlock; |
| finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock); |
| } |
| |
| HBasicBlock exitBlock = graph.addNewBlock(); |
| |
| addOptionalSuccessor(b1, b2) { if (b2 != null) b1.addSuccessor(b2); } |
| addExitTrySuccessor(successor) { |
| if (successor == null) return; |
| // Iterate over all blocks created inside this try/catch, and |
| // attach successor information to blocks that end with |
| // [HExitTry]. |
| for (int i = startTryBlock.id; i < successor.id; i++) { |
| HBasicBlock block = graph.blocks[i]; |
| var last = block.last; |
| if (last is HExitTry) { |
| block.addSuccessor(successor); |
| } |
| } |
| } |
| |
| // Setup all successors. The entry block that contains the [HTry] |
| // has 1) the body, 2) the catch, 3) the finally, and 4) the exit |
| // blocks as successors. |
| enterBlock.addSuccessor(startTryBlock); |
| addOptionalSuccessor(enterBlock, startCatchBlock); |
| addOptionalSuccessor(enterBlock, startFinallyBlock); |
| enterBlock.addSuccessor(exitBlock); |
| |
| // The body has either the catch or the finally block as successor. |
| if (endTryBlock != null) { |
| assert(startCatchBlock != null || startFinallyBlock != null); |
| endTryBlock.addSuccessor( |
| startCatchBlock != null ? startCatchBlock : startFinallyBlock); |
| endTryBlock.addSuccessor(exitBlock); |
| } |
| |
| // The catch block has either the finally or the exit block as |
| // successor. |
| if (endCatchBlock != null) { |
| endCatchBlock.addSuccessor( |
| startFinallyBlock != null ? startFinallyBlock : exitBlock); |
| } |
| |
| // The finally block has the exit block as successor. |
| if (endFinallyBlock != null) { |
| endFinallyBlock.addSuccessor(exitBlock); |
| } |
| |
| // If a block inside try/catch aborts (eg with a return statement), |
| // we explicitely mark this block a predecessor of the catch |
| // block and the finally block. |
| addExitTrySuccessor(startCatchBlock); |
| addExitTrySuccessor(startFinallyBlock); |
| |
| // Use the locals handler not altered by the catch and finally |
| // blocks. |
| localsHandler = savedLocals; |
| open(exitBlock); |
| enterBlock.setBlockFlow( |
| new HTryBlockInformation( |
| wrapStatementGraph(bodyGraph), |
| exception, |
| wrapStatementGraph(catchGraph), |
| wrapStatementGraph(finallyGraph)), |
| exitBlock); |
| inTryStatement = oldInTryStatement; |
| } |
| |
| visitCatchBlock(ast.CatchBlock node) { |
| visit(node.block); |
| } |
| |
| visitTypedef(ast.Typedef node) { |
| compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.'); |
| } |
| |
| visitTypeVariable(ast.TypeVariable node) { |
| compiler.internalError(node, 'SsaFromAstMixin.visitTypeVariable.'); |
| } |
| |
| /** |
| * This method is invoked before inlining the body of [function] into this |
| * [SsaBuilder]. |
| */ |
| void enterInlinedMethod(FunctionElement function, |
| ast.Node _, |
| List<HInstruction> compiledArguments) { |
| TypesInferrer inferrer = compiler.typesTask.typesInferrer; |
| AstInliningState state = new AstInliningState( |
| function, returnLocal, returnType, elements, stack, localsHandler, |
| inTryStatement, |
| allInlinedFunctionsCalledOnce && inferrer.isCalledOnce(function)); |
| inliningStack.add(state); |
| |
| // Setting up the state of the (AST) builder is performed even when the |
| // inlined function is in IR, because the irInliner uses the [returnElement] |
| // of the AST builder. |
| setupStateForInlining(function, compiledArguments); |
| } |
| |
| void leaveInlinedMethod() { |
| HInstruction result = localsHandler.readLocal(returnLocal); |
| AstInliningState state = inliningStack.removeLast(); |
| restoreState(state); |
| stack.add(result); |
| } |
| |
| void doInline(FunctionElement function) { |
| visitInlinedFunction(function); |
| } |
| |
| void emitReturn(HInstruction value, ast.Node node) { |
| if (inliningStack.isEmpty) { |
| closeAndGotoExit(attachPosition(new HReturn(value), node)); |
| } else { |
| localsHandler.updateLocal(returnLocal, value); |
| } |
| } |
| } |
| |
| /** |
| * Visitor that handles generation of string literals (LiteralString, |
| * StringInterpolation), and otherwise delegates to the given visitor for |
| * non-literal subexpressions. |
| */ |
| class StringBuilderVisitor extends ast.Visitor { |
| final SsaBuilder builder; |
| final ast.Node diagnosticNode; |
| |
| /** |
| * The string value generated so far. |
| */ |
| HInstruction result = null; |
| |
| StringBuilderVisitor(this.builder, this.diagnosticNode); |
| |
| Compiler get compiler => builder.compiler; |
| |
| void visit(ast.Node node) { |
| node.accept(this); |
| } |
| |
| visitNode(ast.Node node) { |
| builder.compiler.internalError(node, 'Unexpected node.'); |
| } |
| |
| void visitExpression(ast.Node node) { |
| node.accept(builder); |
| HInstruction expression = builder.pop(); |
| |
| // We want to use HStringify when: |
| // 1. The value is known to be a primitive type, because it might get |
| // constant-folded and codegen has some tricks with JavaScript |
| // conversions. |
| // 2. The value can be primitive, because the library stringifier has |
| // fast-path code for most primitives. |
| if (expression.canBePrimitive(compiler)) { |
| append(stringify(node, expression)); |
| return; |
| } |
| |
| // If the `toString` method is guaranteed to return a string we can call it |
| // directly. |
| Selector selector = |
| new TypedSelector(expression.instructionType, |
| new Selector.call('toString', null, 0), compiler.world); |
| TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler); |
| if (type.containsOnlyString(compiler.world)) { |
| builder.pushInvokeDynamic(node, selector, <HInstruction>[expression]); |
| append(builder.pop()); |
| return; |
| } |
| |
| append(stringify(node, expression)); |
| } |
| |
| void visitStringInterpolation(ast.StringInterpolation node) { |
| node.visitChildren(this); |
| } |
| |
| void visitStringInterpolationPart(ast.StringInterpolationPart node) { |
| visit(node.expression); |
| visit(node.string); |
| } |
| |
| void visitStringJuxtaposition(ast.StringJuxtaposition node) { |
| node.visitChildren(this); |
| } |
| |
| void visitNodeList(ast.NodeList node) { |
| node.visitChildren(this); |
| } |
| |
| void append(HInstruction expression) { |
| result = (result == null) ? expression : concat(result, expression); |
| } |
| |
| HInstruction concat(HInstruction left, HInstruction right) { |
| HInstruction instruction = new HStringConcat( |
| left, right, diagnosticNode, builder.backend.stringType); |
| builder.add(instruction); |
| return instruction; |
| } |
| |
| HInstruction stringify(ast.Node node, HInstruction expression) { |
| HInstruction instruction = |
| new HStringify(expression, node, builder.backend.stringType); |
| builder.add(instruction); |
| return instruction; |
| } |
| } |
| |
| /** |
| * This class visits the method that is a candidate for inlining and |
| * finds whether it is too difficult to inline. |
| */ |
| // TODO(karlklose): refactor to make it possible to distinguish between |
| // implementation restrictions (for example, we *can't* inline multiple returns) |
| // and heuristics (we *shouldn't* inline large functions). |
| class InlineWeeder extends ast.Visitor { |
| // Invariant: *INSIDE_LOOP* > *OUTSIDE_LOOP* |
| static const INLINING_NODES_OUTSIDE_LOOP = 18; |
| static const INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR = 3; |
| static const INLINING_NODES_INSIDE_LOOP = 42; |
| static const INLINING_NODES_INSIDE_LOOP_ARG_FACTOR = 4; |
| |
| bool seenReturn = false; |
| bool tooDifficult = false; |
| int nodeCount = 0; |
| final int maxInliningNodes; |
| final bool useMaxInliningNodes; |
| final bool allowLoops; |
| |
| InlineWeeder(this.maxInliningNodes, |
| this.useMaxInliningNodes, |
| this.allowLoops); |
| |
| static bool canBeInlined(ast.FunctionExpression functionExpression, |
| int maxInliningNodes, |
| bool useMaxInliningNodes, |
| {bool allowLoops: false}) { |
| InlineWeeder weeder = |
| new InlineWeeder(maxInliningNodes, useMaxInliningNodes, allowLoops); |
| weeder.visit(functionExpression.initializers); |
| weeder.visit(functionExpression.body); |
| return !weeder.tooDifficult; |
| } |
| |
| bool registerNode() { |
| if (!useMaxInliningNodes) return true; |
| if (nodeCount++ > maxInliningNodes) { |
| tooDifficult = true; |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| void visit(ast.Node node) { |
| if (node != null) node.accept(this); |
| } |
| |
| void visitNode(ast.Node node) { |
| if (!registerNode()) return; |
| if (seenReturn) { |
| tooDifficult = true; |
| } else { |
| node.visitChildren(this); |
| } |
| } |
| |
| void visitFunctionExpression(ast.Node node) { |
| if (!registerNode()) return; |
| tooDifficult = true; |
| } |
| |
| void visitFunctionDeclaration(ast.Node node) { |
| if (!registerNode()) return; |
| tooDifficult = true; |
| } |
| |
| void visitSend(ast.Send node) { |
| if (!registerNode()) return; |
| node.visitChildren(this); |
| } |
| |
| visitLoop(ast.Node node) { |
| // It's actually not difficult to inline a method with a loop, but |
| // our measurements show that it's currently better to not inline a |
| // method that contains a loop. |
| if (!allowLoops) tooDifficult = true; |
| } |
| |
| void visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) { |
| if (!registerNode()) return; |
| tooDifficult = true; |
| } |
| |
| void visitRethrow(ast.Rethrow node) { |
| if (!registerNode()) return; |
| tooDifficult = true; |
| } |
| |
| void visitReturn(ast.Return node) { |
| if (!registerNode()) return; |
| if (seenReturn |
| || identical(node.beginToken.stringValue, 'native')) { |
| tooDifficult = true; |
| return; |
| } |
| node.visitChildren(this); |
| seenReturn = true; |
| } |
| |
| void visitTryStatement(ast.Node node) { |
| if (!registerNode()) return; |
| tooDifficult = true; |
| } |
| |
| void visitThrow(ast.Throw node) { |
| if (!registerNode()) return; |
| // For now, we don't want to handle throw after a return even if |
| // it is in an "if". |
| if (seenReturn) { |
| tooDifficult = true; |
| } else { |
| node.visitChildren(this); |
| } |
| } |
| } |
| |
| abstract class InliningState { |
| /** |
| * Invariant: [function] must be an implementation element. |
| */ |
| final FunctionElement function; |
| |
| InliningState(this.function) { |
| assert(function.isImplementation); |
| } |
| } |
| |
| class AstInliningState extends InliningState { |
| final Local oldReturnLocal; |
| final DartType oldReturnType; |
| final TreeElements oldElements; |
| final List<HInstruction> oldStack; |
| final LocalsHandler oldLocalsHandler; |
| final bool inTryStatement; |
| final bool allFunctionsCalledOnce; |
| |
| AstInliningState(FunctionElement function, |
| this.oldReturnLocal, |
| this.oldReturnType, |
| this.oldElements, |
| this.oldStack, |
| this.oldLocalsHandler, |
| this.inTryStatement, |
| this.allFunctionsCalledOnce) |
| : super(function); |
| } |
| |
| class SsaBranch { |
| final SsaBranchBuilder branchBuilder; |
| final HBasicBlock block; |
| LocalsHandler startLocals; |
| LocalsHandler exitLocals; |
| SubGraph graph; |
| |
| SsaBranch(this.branchBuilder) : block = new HBasicBlock(); |
| } |
| |
| class SsaBranchBuilder { |
| final SsaBuilder builder; |
| final ast.Node diagnosticNode; |
| |
| SsaBranchBuilder(this.builder, [this.diagnosticNode]); |
| |
| Compiler get compiler => builder.compiler; |
| |
| void checkNotAborted() { |
| if (builder.isAborted()) { |
| compiler.unimplemented(diagnosticNode, "aborted control flow"); |
| } |
| } |
| |
| void buildCondition(void visitCondition(), |
| SsaBranch conditionBranch, |
| SsaBranch thenBranch, |
| SsaBranch elseBranch) { |
| startBranch(conditionBranch); |
| visitCondition(); |
| checkNotAborted(); |
| assert(identical(builder.current, builder.lastOpenedBlock)); |
| HInstruction conditionValue = builder.popBoolified(); |
| HIf branch = new HIf(conditionValue); |
| HBasicBlock conditionExitBlock = builder.current; |
| builder.close(branch); |
| conditionBranch.exitLocals = builder.localsHandler; |
| conditionExitBlock.addSuccessor(thenBranch.block); |
| conditionExitBlock.addSuccessor(elseBranch.block); |
| bool conditionBranchLocalsCanBeReused = |
| mergeLocals(conditionBranch, thenBranch, mayReuseFromLocals: true); |
| mergeLocals(conditionBranch, elseBranch, |
| mayReuseFromLocals: conditionBranchLocalsCanBeReused); |
| |
| conditionBranch.graph = |
| new SubExpression(conditionBranch.block, conditionExitBlock); |
| } |
| |
| /** |
| * Returns true if the locals of the [fromBranch] may be reused. A [:true:] |
| * return value implies that [mayReuseFromLocals] was set to [:true:]. |
| */ |
| bool mergeLocals(SsaBranch fromBranch, SsaBranch toBranch, |
| {bool mayReuseFromLocals}) { |
| LocalsHandler fromLocals = fromBranch.exitLocals; |
| if (toBranch.startLocals == null) { |
| if (mayReuseFromLocals) { |
| toBranch.startLocals = fromLocals; |
| return false; |
| } else { |
| toBranch.startLocals = new LocalsHandler.from(fromLocals); |
| return true; |
| } |
| } else { |
| toBranch.startLocals.mergeWith(fromLocals, toBranch.block); |
| return true; |
| } |
| } |
| |
| void startBranch(SsaBranch branch) { |
| builder.graph.addBlock(branch.block); |
| builder.localsHandler = branch.startLocals; |
| builder.open(branch.block); |
| } |
| |
| HInstruction buildBranch(SsaBranch branch, |
| void visitBranch(), |
| SsaBranch joinBranch, |
| bool isExpression) { |
| startBranch(branch); |
| visitBranch(); |
| branch.graph = new SubGraph(branch.block, builder.lastOpenedBlock); |
| branch.exitLocals = builder.localsHandler; |
| if (!builder.isAborted()) { |
| builder.goto(builder.current, joinBranch.block); |
| mergeLocals(branch, joinBranch, mayReuseFromLocals: true); |
| } |
| if (isExpression) { |
| checkNotAborted(); |
| return builder.pop(); |
| } |
| return null; |
| } |
| |
| handleIf(void visitCondition(), void visitThen(), void visitElse()) { |
| if (visitElse == null) { |
| // Make sure to have an else part to avoid a critical edge. A |
| // critical edge is an edge that connects a block with multiple |
| // successors to a block with multiple predecessors. We avoid |
| // such edges because they prevent inserting copies during code |
| // generation of phi instructions. |
| visitElse = () {}; |
| } |
| |
| _handleDiamondBranch(visitCondition, visitThen, visitElse, false); |
| } |
| |
| handleConditional(void visitCondition(), void visitThen(), void visitElse()) { |
| assert(visitElse != null); |
| _handleDiamondBranch(visitCondition, visitThen, visitElse, true); |
| } |
| |
| void handleLogicalAndOr(void left(), void right(), {bool isAnd}) { |
| // x && y is transformed into: |
| // t0 = boolify(x); |
| // if (t0) { |
| // t1 = boolify(y); |
| // } |
| // result = phi(t1, false); |
| // |
| // x || y is transformed into: |
| // t0 = boolify(x); |
| // if (not(t0)) { |
| // t1 = boolify(y); |
| // } |
| // result = phi(t1, true); |
| HInstruction boolifiedLeft; |
| HInstruction boolifiedRight; |
| |
| void visitCondition() { |
| left(); |
| boolifiedLeft = builder.popBoolified(); |
| builder.stack.add(boolifiedLeft); |
| if (!isAnd) { |
| builder.push(new HNot(builder.pop(), builder.backend.boolType)); |
| } |
| } |
| |
| void visitThen() { |
| right(); |
| boolifiedRight = builder.popBoolified(); |
| } |
| |
| handleIf(visitCondition, visitThen, null); |
| HConstant notIsAnd = |
| builder.graph.addConstantBool(!isAnd, builder.compiler); |
| JavaScriptBackend backend = builder.backend; |
| HPhi result = new HPhi.manyInputs(null, |
| <HInstruction>[boolifiedRight, notIsAnd], |
| backend.dynamicType); |
| builder.current.addPhi(result); |
| builder.stack.add(result); |
| } |
| |
| void handleLogicalAndOrWithLeftNode(ast.Node left, |
| void visitRight(), |
| {bool isAnd}) { |
| // This method is similar to [handleLogicalAndOr] but optimizes the case |
| // where left is a logical "and" or logical "or". |
| // |
| // For example (x && y) && z is transformed into x && (y && z): |
| // t0 = boolify(x); |
| // if (t0) { |
| // t1 = boolify(y); |
| // if (t1) { |
| // t2 = boolify(z); |
| // } |
| // t3 = phi(t2, false); |
| // } |
| // result = phi(t3, false); |
| |
| ast.Send send = left.asSend(); |
| if (send != null && |
| (isAnd ? send.isLogicalAnd : send.isLogicalOr)) { |
| ast.Node newLeft = send.receiver; |
| Link<ast.Node> link = send.argumentsNode.nodes; |
| assert(link.tail.isEmpty); |
| ast.Node middle = link.head; |
| handleLogicalAndOrWithLeftNode( |
| newLeft, |
| () => handleLogicalAndOrWithLeftNode(middle, visitRight, |
| isAnd: isAnd), |
| isAnd: isAnd); |
| } else { |
| handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd); |
| } |
| } |
| |
| void _handleDiamondBranch(void visitCondition(), |
| void visitThen(), |
| void visitElse(), |
| bool isExpression) { |
| SsaBranch conditionBranch = new SsaBranch(this); |
| SsaBranch thenBranch = new SsaBranch(this); |
| SsaBranch elseBranch = new SsaBranch(this); |
| SsaBranch joinBranch = new SsaBranch(this); |
| |
| conditionBranch.startLocals = builder.localsHandler; |
| builder.goto(builder.current, conditionBranch.block); |
| |
| buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch); |
| HInstruction thenValue = |
| buildBranch(thenBranch, visitThen, joinBranch, isExpression); |
| HInstruction elseValue = |
| buildBranch(elseBranch, visitElse, joinBranch, isExpression); |
| |
| if (isExpression) { |
| assert(thenValue != null && elseValue != null); |
| JavaScriptBackend backend = builder.backend; |
| HPhi phi = new HPhi.manyInputs( |
| null, <HInstruction>[thenValue, elseValue], backend.dynamicType); |
| joinBranch.block.addPhi(phi); |
| builder.stack.add(phi); |
| } |
| |
| HBasicBlock thenBlock = thenBranch.block; |
| HBasicBlock elseBlock = elseBranch.block; |
| HBasicBlock joinBlock; |
| // If at least one branch did not abort, open the joinBranch. |
| if (!joinBranch.block.predecessors.isEmpty) { |
| startBranch(joinBranch); |
| joinBlock = joinBranch.block; |
| } |
| |
| HIfBlockInformation info = |
| new HIfBlockInformation( |
| new HSubExpressionBlockInformation(conditionBranch.graph), |
| new HSubGraphBlockInformation(thenBranch.graph), |
| new HSubGraphBlockInformation(elseBranch.graph)); |
| |
| HBasicBlock conditionStartBlock = conditionBranch.block; |
| conditionStartBlock.setBlockFlow(info, joinBlock); |
| SubGraph conditionGraph = conditionBranch.graph; |
| HIf branch = conditionGraph.end.last; |
| assert(branch is HIf); |
| branch.blockInformation = conditionStartBlock.blockFlow; |
| } |
| } |
| |
| class TypeBuilder implements DartTypeVisitor<dynamic, SsaBuilder> { |
| final ClassWorld classWorld; |
| |
| TypeBuilder(this.classWorld); |
| |
| void visitType(DartType type, _) { |
| throw 'Internal error $type'; |
| } |
| |
| void visitVoidType(VoidType type, SsaBuilder builder) { |
| ClassElement cls = builder.backend.findHelper('VoidRuntimeType'); |
| builder.push(new HVoidType(type, new TypeMask.exact(cls, classWorld))); |
| } |
| |
| void visitTypeVariableType(TypeVariableType type, |
| SsaBuilder builder) { |
| ClassElement cls = builder.backend.findHelper('RuntimeType'); |
| TypeMask instructionType = new TypeMask.subclass(cls, classWorld); |
| if (!builder.sourceElement.enclosingElement.isClosure && |
| builder.sourceElement.isInstanceMember) { |
| HInstruction receiver = builder.localsHandler.readThis(); |
| builder.push(new HReadTypeVariable(type, receiver, instructionType)); |
| } else { |
| builder.push( |
| new HReadTypeVariable.noReceiver( |
| type, builder.addTypeVariableReference(type), instructionType)); |
| } |
| } |
| |
| void visitFunctionType(FunctionType type, SsaBuilder builder) { |
| type.returnType.accept(this, builder); |
| HInstruction returnType = builder.pop(); |
| List<HInstruction> inputs = <HInstruction>[returnType]; |
| |
| for (DartType parameter in type.parameterTypes) { |
| parameter.accept(this, builder); |
| inputs.add(builder.pop()); |
| } |
| |
| for (DartType parameter in type.optionalParameterTypes) { |
| parameter.accept(this, builder); |
| inputs.add(builder.pop()); |
| } |
| |
| List<DartType> namedParameterTypes = type.namedParameterTypes; |
| List<String> names = type.namedParameters; |
| for (int index = 0; index < names.length; index++) { |
| ast.DartString dartString = new ast.DartString.literal(names[index]); |
| inputs.add( |
| builder.graph.addConstantString(dartString, builder.compiler)); |
| namedParameterTypes[index].accept(this, builder); |
| inputs.add(builder.pop()); |
| } |
| |
| ClassElement cls = builder.backend.findHelper('RuntimeFunctionType'); |
| builder.push(new HFunctionType(inputs, type, |
| new TypeMask.exact(cls, classWorld))); |
| } |
| |
| void visitMalformedType(MalformedType type, SsaBuilder builder) { |
| visitDynamicType(const DynamicType(), builder); |
| } |
| |
| void visitStatementType(StatementType type, SsaBuilder builder) { |
| throw 'not implemented visitStatementType($type)'; |
| } |
| |
| void visitGenericType(GenericType type, SsaBuilder builder) { |
| throw 'not implemented visitGenericType($type)'; |
| } |
| |
| void visitInterfaceType(InterfaceType type, SsaBuilder builder) { |
| List<HInstruction> inputs = <HInstruction>[]; |
| for (DartType typeArgument in type.typeArguments) { |
| typeArgument.accept(this, builder); |
| inputs.add(builder.pop()); |
| } |
| ClassElement cls; |
| if (type.typeArguments.isEmpty) { |
| cls = builder.backend.findHelper('RuntimeTypePlain'); |
| } else { |
| cls = builder.backend.findHelper('RuntimeTypeGeneric'); |
| } |
| builder.push(new HInterfaceType(inputs, type, |
| new TypeMask.exact(cls, classWorld))); |
| } |
| |
| void visitTypedefType(TypedefType type, SsaBuilder builder) { |
| DartType unaliased = type.unalias(builder.compiler); |
| if (unaliased is TypedefType) throw 'unable to unalias $type'; |
| unaliased.accept(this, builder); |
| } |
| |
| void visitDynamicType(DynamicType type, SsaBuilder builder) { |
| JavaScriptBackend backend = builder.compiler.backend; |
| ClassElement cls = backend.findHelper('DynamicRuntimeType'); |
| builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld))); |
| } |
| } |