public boolean startIf(boolean elseIf) { if (elseIf) { startElseIf(); } else { startIf(); } return true; }
public boolean startIf(boolean elseIf) { if (elseIf) { startElseIf(); } else { startIf(); } return true; }
public static int materialize(CodeTreeBuilder builder, Collection<IfTriple> triples, boolean forceNoBlocks) { int blockCount = 0; boolean otherPrepare = false; for (IfTriple triple : triples) { if (triple.prepare != null && !triple.prepare.isEmpty()) { if (!otherPrepare) { if (blockCount == 0 && !forceNoBlocks) { builder.startBlock(); blockCount++; } otherPrepare = true; } builder.tree(triple.prepare); } if (triple.condition != null && !triple.condition.isEmpty()) { if (forceNoBlocks) { throw new AssertionError("no blocks forced but block required"); } builder.startIf().tree(triple.condition).end().startBlock(); blockCount++; } if (triple.statements != null && !triple.statements.isEmpty()) { builder.tree(triple.statements); } } return blockCount; }
throw new AssertionError(); builder.startIf().tree(state.createNotContains(frameState, new Object[]{guard})).end().startBlock(); innerTriples.addAll(initializeSpecializationClass(frameState, group.getSpecialization())); innerTriples.addAll(persistSpecializationClass(frameState, group.getSpecialization()));
@Override public String toString() { CodeTreeBuilder b = CodeTreeBuilder.createBuilder(); b.startGroup(); if (!isEmpty(prepare)) { b.tree(prepare); } if (!isEmpty(condition)) { b.startIf().tree(condition).end().startBlock(); } if (!isEmpty(statements)) { b.tree(statements); } if (!isEmpty(condition)) { b.end(); } b.end(); return b.build().toString(); }
private void generateCheckNewPolymorphismState(CodeTreeBuilder builder) { builder.startIf().string(OLD_STATE + " != 0"); if (requiresExclude()) { builder.string(" || " + OLD_EXCLUDE + " != 0"); } builder.end(); builder.startBlock(); builder.string(CHECK_FOR_POLYMORPHIC_SPECIALIZE + "(" + OLD_STATE); if (requiresExclude()) { builder.string(", " + OLD_EXCLUDE); } if (requiresCacheCheck()) { builder.string(", " + OLD_CACHE_COUNT); } builder.string(");").newLine(); builder.end(); // block }
private static CodeTree createShortCircuit(LocalVariable targetValue, LocalVariable shortCircuitValue, CodeTree tryExecute) { if (shortCircuitValue == null) { return tryExecute; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.tree(shortCircuitValue.createDeclaration(shortCircuitValue.createReference())); builder.tree(targetValue.createDeclaration(builder.create().defaultValue(targetValue.getTypeMirror()).build())); builder.startIf().string(shortCircuitValue.getName()).end().startBlock(); builder.tree(tryExecute); builder.end(); return builder.build(); }
private ExecutableElement createGetInstanceMethod(Modifier visibility) { TypeElement nodeFactoryType = ElementUtils.fromTypeMirror(context.getType(NodeFactory.class)); TypeMirror returnType = ElementUtils.getDeclaredType(nodeFactoryType, node.getNodeType()); CodeExecutableElement method = new CodeExecutableElement(modifiers(), returnType, "getInstance"); if (visibility != null) { method.getModifiers().add(visibility); } method.getModifiers().add(Modifier.STATIC); String varName = instanceVarName(node); CodeTreeBuilder builder = method.createBuilder(); builder.startIf(); builder.string(varName).string(" == null"); builder.end().startBlock(); builder.startStatement(); builder.string(varName); builder.string(" = "); builder.startNew(factoryClassName(node)).end(); builder.end(); builder.end(); builder.startReturn().string(varName).end(); return method; }
private ExecutableElement createGetInstanceMethod(Modifier visibility) { TypeElement nodeFactoryType = ElementUtils.fromTypeMirror(context.getType(NodeFactory.class)); TypeMirror returnType = ElementUtils.getDeclaredType(nodeFactoryType, node.getNodeType()); CodeExecutableElement method = new CodeExecutableElement(modifiers(), returnType, "getInstance"); if (visibility != null) { method.getModifiers().add(visibility); } method.getModifiers().add(Modifier.STATIC); String varName = instanceVarName(node); CodeTreeBuilder builder = method.createBuilder(); builder.startIf(); builder.string(varName).string(" == null"); builder.end().startBlock(); builder.startStatement(); builder.string(varName); builder.string(" = "); builder.startNew(factoryClassName(node)).end(); builder.end(); builder.end(); builder.startReturn().string(varName).end(); return method; }
private CodeTree createFastPathAssumptionCheck(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData forType, FrameState frameState) throws AssertionError { CodeTreeBuilder builder = parent.create(); builder.startIf(); String sep = ""; for (AssumptionExpression assumption : specialization.getAssumptionExpressions()) { builder.string(sep); builder.string("!"); builder.startCall("isValid_").tree(createAssumptionReference(frameState, specialization, assumption)).end(); isValidSignatures.put(ElementUtils.getQualifiedName(assumption.getExpression().getResolvedType()), assumption.getExpression().getResolvedType()); sep = " || "; } builder.end().startBlock(); builder.tree(createTransferToInterpreterAndInvalidate()); builder.tree(createRemoveThis(builder, frameState, forType, specialization)); builder.end(); return builder.build(); }
private Element createIsValid(TypeMirror assumptionType) { CodeExecutableElement isValid = new CodeExecutableElement(modifiers(PRIVATE, STATIC), getType(boolean.class), "isValid_"); CodeTreeBuilder builder = isValid.createBuilder(); if (assumptionType.getKind() == TypeKind.ARRAY) { isValid.addAnnotationMirror(new CodeAnnotationMirror(context.getDeclaredType(ExplodeLoop.class))); isValid.addParameter(new CodeVariableElement(getType(Assumption[].class), "assumptions")); builder.startIf().string("assumptions == null").end().startBlock().returnFalse().end(); builder.startFor().startGroup().type(((ArrayType) assumptionType).getComponentType()).string(" assumption : assumptions").end().end(); builder.startBlock(); builder.startIf().string("assumption == null || !assumption.isValid()").end(); builder.startBlock(); builder.returnFalse(); builder.end(); builder.end(); builder.returnTrue(); } else { isValid.addParameter(new CodeVariableElement(getType(Assumption.class), "assumption")); builder.startReturn().string("assumption != null && assumption.isValid()").end(); } return isValid; }
private Element createCheck() { String methodName = "check"; CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), context.getType(boolean.class), methodName); method.addParameter(new CodeVariableElement(context.getType(Object.class), "value")); CodeTreeBuilder builder = method.createBuilder(); boolean elseIf = false; for (TypeMirror sourceType : sourceTypes) { elseIf = builder.startIf(elseIf); builder.string(seenFieldName(sourceType)).string(" && ").tree(TypeSystemCodeGenerator.check(typeSystem, sourceType, "value")); builder.end(); builder.startBlock().returnTrue().end(); } builder.returnFalse(); return method; }
private CodeExecutableElement createSpecializeImplictTypeMethodFlat(TypeMirror type) { String name = specializeImplicitTypeMethodName(typeSystem, type); CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(int.class), name); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); List<TypeMirror> sourceTypes = typeSystem.lookupSourceTypes(type); CodeTreeBuilder builder = method.createBuilder(); boolean elseIf = false; int mask = 1; for (TypeMirror sourceType : sourceTypes) { elseIf = builder.startIf(elseIf); builder.tree(check(typeSystem, sourceType, LOCAL_VALUE)); builder.end().startBlock(); builder.startReturn(); builder.string("0b", Integer.toBinaryString(mask)); builder.end(); builder.end(); mask = mask << 1; } builder.startElseBlock(); builder.startReturn().string("0").end(); builder.end(); return method; }
private CodeTree createFastPathExecute(CodeTreeBuilder parent, final ExecutableTypeData forType, SpecializationData specialization, FrameState frameState) { CodeTreeBuilder builder = parent.create(); int ifCount = 0; if (specialization.isFallback()) { builder.startIf().startCall(METHOD_FALLBACK_GUARD); if (fallbackNeedsFrame) { if (frameState.get(FRAME_VALUE) != null) { builder.string(FRAME_VALUE); } else { builder.nullLiteral(); } } if (fallbackNeedsState) { builder.string(STATE_VALUE); } frameState.addReferencesTo(builder); builder.end(); builder.end(); builder.startBlock(); ifCount++; } builder.tree(createExecute(builder, frameState, forType, specialization, NodeExecutionMode.FAST_PATH)); builder.end(ifCount); return builder.build(); }
private Element createCheckForPolymorphicSpecialize() { final boolean requiresExclude = requiresExclude(); final boolean requiresCacheCheck = requiresCacheCheck(); TypeMirror returnType = getType(void.class); CodeExecutableElement executable = new CodeExecutableElement(modifiers(PRIVATE), returnType, CHECK_FOR_POLYMORPHIC_SPECIALIZE); executable.addParameter(new CodeVariableElement(state.bitSetType, OLD_STATE)); if (requiresExclude) { executable.addParameter(new CodeVariableElement(exclude.bitSetType, OLD_EXCLUDE)); } if (requiresCacheCheck) { executable.addParameter(new CodeVariableElement(getType(int.class), OLD_CACHE_COUNT)); } CodeTreeBuilder builder = executable.createBuilder(); builder.declaration(state.bitSetType, NEW_STATE, state.createMaskedReference(FrameState.load(this), reachableSpecializations.toArray())); if (requiresExclude) { builder.declaration(exclude.bitSetType, NEW_EXCLUDE, exclude.createReference(FrameState.load(this))); } builder.startIf().string("(" + OLD_STATE + " ^ " + NEW_STATE + ") != 0"); if (requiresExclude) { builder.string(" || "); builder.string("(" + OLD_EXCLUDE + " ^ " + NEW_EXCLUDE + ") != 0"); } if (requiresCacheCheck) { builder.string(" || " + OLD_CACHE_COUNT + " < " + COUNT_CACHES + "()"); } builder.end(); // if builder.startBlock().startStatement().startCall("this", REPORT_POLYMORPHIC_SPECIALIZE).end(2); builder.end(); // true block return executable; }
private void addUnsupportedMethod(CodeTypeElement clazz) { CodeVariableElement seenUnsupportedField = new CodeVariableElement(modifiers(PRIVATE), getType(boolean.class), "seenUnsupported0"); seenUnsupportedField.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(CompilationFinal.class))); clazz.add(seenUnsupportedField); LocalContext locals = LocalContext.load(this); CodeExecutableElement method = locals.createMethod(modifiers(PRIVATE), getType(UnsupportedSpecializationException.class), "unsupported", varArgsThreshold); CodeTreeBuilder builder = method.createBuilder(); builder.startIf().string("!").string(seenUnsupportedField.getName()).end().startBlock(); builder.startStatement().startStaticCall(getType(CompilerDirectives.class), "transferToInterpreterAndInvalidate").end().end(); builder.startStatement().string(seenUnsupportedField.getName()).string(" = true").end(); builder.end(); builder.startReturn(); builder.startNew(getType(UnsupportedSpecializationException.class)); builder.string("this"); builder.tree(createGetSuppliedChildren()); locals.addReferencesTo(builder); builder.end(); builder.end(); clazz.add(method); }
public static CodeExecutableElement createExpectMethod(Modifier visibility, TypeSystemData typeSystem, TypeMirror sourceTypeOriginal, TypeMirror expectedTypeOriginal) { TypeMirror expectedType = ElementUtils.fillInGenericWildcards(expectedTypeOriginal); TypeMirror sourceType = ElementUtils.fillInGenericWildcards(sourceTypeOriginal); if (ElementUtils.isObject(expectedType) || ElementUtils.isVoid(expectedType)) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(STATIC), expectedType, TypeSystemCodeGenerator.expectTypeMethodName(typeSystem, expectedType)); method.setVisibility(visibility); method.addParameter(new CodeVariableElement(sourceType, LOCAL_VALUE)); method.addThrownType(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()); CodeTreeBuilder body = method.createBuilder(); body.startIf().tree(check(typeSystem, expectedType, LOCAL_VALUE)).end().startBlock(); body.startReturn().tree(cast(typeSystem, expectedType, LOCAL_VALUE)).end(); body.end(); body.startThrow().startNew(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()).string(LOCAL_VALUE).end().end(); return method; }
static CodeExecutableElement createExpectMethod(Modifier visibility, TypeSystemData typeSystem, TypeMirror sourceTypeOriginal, TypeMirror expectedTypeOriginal) { TypeMirror expectedType = ElementUtils.fillInGenericWildcards(expectedTypeOriginal); TypeMirror sourceType = ElementUtils.fillInGenericWildcards(sourceTypeOriginal); if (ElementUtils.isObject(expectedType) || ElementUtils.isVoid(expectedType)) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(STATIC), expectedType, TypeSystemCodeGenerator.expectTypeMethodName(typeSystem, expectedType)); method.setVisibility(visibility); method.addParameter(new CodeVariableElement(sourceType, LOCAL_VALUE)); method.addThrownType(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()); CodeTreeBuilder body = method.createBuilder(); body.startIf().tree(check(typeSystem, expectedType, LOCAL_VALUE)).end().startBlock(); body.startReturn().tree(cast(typeSystem, expectedType, LOCAL_VALUE)).end(); body.end(); body.startThrow().startNew(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()).string(LOCAL_VALUE).end().end(); return method; }
elseIf = builder.startIf(elseIf); builder.string("(state & 0b").string(Integer.toBinaryString(mask)).string(") != 0 && "); builder.tree(check(typeSystem, sourceType, LOCAL_VALUE));
private CodeExecutableElement createGetImplicitClass(TypeMirror type) { CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(Class.class), TypeSystemCodeGenerator.getImplicitClass(typeSystem, type)); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); List<TypeMirror> sourceTypes = typeSystem.lookupSourceTypes(type); CodeTreeBuilder builder = method.createBuilder(); boolean elseIf = false; for (TypeMirror sourceType : sourceTypes) { elseIf = builder.startIf(elseIf); builder.tree(check(typeSystem, sourceType, LOCAL_VALUE)).end(); builder.end().startBlock(); builder.startReturn().typeLiteral(sourceType).end(); builder.end(); } builder.startElseIf().string(LOCAL_VALUE).string(" == ").nullLiteral().end(); builder.startBlock(); builder.startReturn().typeLiteral(context.getType(Object.class)).end(); builder.end(); builder.startElseBlock(); builder.tree(createTransferToInterpreterAndInvalidate()); builder.startThrow().startNew(context.getType(IllegalArgumentException.class)).doubleQuote("Illegal type ").end().end(); builder.end(); return method; }