use of com.oracle.truffle.dsl.processor.expression.DSLExpression in project graal by oracle.
the class FlatNodeGenFactory method visitSpecializationGroup.
private CodeTree visitSpecializationGroup(CodeTreeBuilder parent, SpecializationGroup group, ExecutableTypeData forType, FrameState frameState, List<SpecializationData> allowedSpecializations, NodeExecutionMode mode) {
CodeTreeBuilder builder = parent.create();
boolean hasFallthrough = false;
boolean hasImplicitCast = false;
List<IfTriple> cachedTriples = new ArrayList<>();
for (TypeGuard guard : group.getTypeGuards()) {
IfTriple triple = createTypeCheckOrCast(frameState, group, guard, mode, false, true);
if (triple != null) {
cachedTriples.add(triple);
}
hasImplicitCast = hasImplicitCast || node.getTypeSystem().hasImplicitSourceTypes(guard.getType());
if (!mode.isGuardFallback()) {
triple = createTypeCheckOrCast(frameState, group, guard, mode, true, true);
if (triple != null) {
cachedTriples.add(triple);
}
}
}
SpecializationData specialization = group.getSpecialization();
SpecializationData[] specializations = group.collectSpecializations().toArray(new SpecializationData[0]);
List<GuardExpression> guardExpressions = new ArrayList<>(group.getGuards());
// out of the loop.
if (specialization != null && specialization.hasMultipleInstances()) {
List<GuardExpression> unboundGuards = new ArrayList<>();
for (GuardExpression guard : guardExpressions) {
if (!specialization.isGuardBoundWithCache(guard)) {
unboundGuards.add(guard);
} else {
// we need to stop as we need to ensure guard execution order
break;
}
}
cachedTriples.addAll(createMethodGuardCheck(frameState, group, unboundGuards, mode));
guardExpressions.removeAll(unboundGuards);
}
boolean useSpecializationClass = specialization != null && useSpecializationClass(specialization);
if (mode.isFastPath()) {
int ifCount = 0;
final boolean stateGuaranteed = group.isLast() && allowedSpecializations != null && allowedSpecializations.size() == 1 && group.getAllSpecializations().size() == allowedSpecializations.size();
if ((!group.isEmpty() || specialization != null)) {
CodeTree stateCheck = state.createContains(frameState, specializations);
CodeTree stateGuard = null;
CodeTree assertCheck = null;
if (stateGuaranteed) {
assertCheck = CodeTreeBuilder.createBuilder().startAssert().tree(stateCheck).end().build();
} else {
stateGuard = stateCheck;
}
cachedTriples.add(0, new IfTriple(null, stateGuard, assertCheck));
}
ifCount += IfTriple.materialize(builder, IfTriple.optimize(cachedTriples), false);
// reset current triples
cachedTriples = new ArrayList<>();
String specializationLocalName = null;
if (useSpecializationClass) {
specializationLocalName = createSpecializationLocalName(specialization);
builder.tree(loadSpecializationClass(frameState, specialization));
if (specialization.getMaximumNumberOfInstances() > 1) {
builder.startWhile();
} else {
builder.startIf();
}
builder.string(specializationLocalName, " != null");
builder.end();
builder.startBlock();
ifCount++;
}
if (specialization != null) {
if (!specialization.getAssumptionExpressions().isEmpty()) {
builder.tree(createFastPathAssumptionCheck(builder, specialization, forType, frameState));
}
}
cachedTriples = createMethodGuardCheck(frameState, group, guardExpressions, mode);
int innerIfCount = IfTriple.materialize(builder, IfTriple.optimize(cachedTriples), false);
SpecializationGroup prev = null;
for (SpecializationGroup child : group.getChildren()) {
if (prev != null && !prev.hasFallthrough()) {
break;
}
builder.tree(visitSpecializationGroup(builder, child, forType, frameState.copy(), allowedSpecializations, mode));
}
if (specialization != null && (prev == null || prev.hasFallthrough())) {
builder.tree(createFastPathExecute(builder, forType, specialization, frameState));
}
builder.end(innerIfCount);
hasFallthrough |= innerIfCount > 0;
if (useSpecializationClass && specialization.getMaximumNumberOfInstances() > 1) {
String name = createSpecializationLocalName(specialization);
builder.startStatement().string(name, " = ", name, ".next_").end();
}
builder.end(ifCount);
hasFallthrough |= ifCount > 0;
} else if (mode.isSlowPath()) {
if (specialization != null && mayBeExcluded(specialization)) {
CodeTree excludeCheck = exclude.createNotContains(frameState, specializations);
cachedTriples.add(0, new IfTriple(null, excludeCheck, null));
}
int outerIfCount = 0;
if (specialization == null) {
cachedTriples.addAll(createMethodGuardCheck(frameState, group, guardExpressions, mode));
outerIfCount += IfTriple.materialize(builder, IfTriple.optimize(cachedTriples), false);
SpecializationGroup prev = null;
for (SpecializationGroup child : group.getChildren()) {
if (prev != null && !prev.hasFallthrough()) {
break;
}
builder.tree(visitSpecializationGroup(builder, child, forType, frameState.copy(), allowedSpecializations, mode));
prev = child;
}
} else {
outerIfCount += IfTriple.materialize(builder, IfTriple.optimize(cachedTriples), false);
String countName = specialization != null ? "count" + specialization.getIndex() + "_" : null;
boolean needsDuplicationCheck = specialization.isGuardBindsCache() || specialization.hasMultipleInstances();
boolean useDuplicateFlag = specialization.isGuardBindsCache() && !specialization.hasMultipleInstances();
String duplicateFoundName = specialization.getId() + "_duplicateFound_";
int innerIfCount = 0;
String specializationLocalName = createSpecializationLocalName(specialization);
if (needsDuplicationCheck) {
builder.tree(createDuplicationCheck(builder, frameState, group, guardExpressions, useDuplicateFlag, countName, duplicateFoundName, specializationLocalName));
builder.startIf();
if (useDuplicateFlag) {
// we reuse the specialization class local name instead of a duplicate found
// name
builder.string("!", duplicateFoundName);
} else {
builder.string(createSpecializationLocalName(specialization), " == null");
}
builder.end().startBlock();
innerIfCount++;
}
List<IfTriple> innerTripples = createMethodGuardCheck(frameState, group, guardExpressions, mode);
List<AssumptionExpression> assumptions = specialization.getAssumptionExpressions();
if (!assumptions.isEmpty()) {
for (AssumptionExpression assumption : assumptions) {
innerTripples.addAll(createAssumptionSlowPathTriples(frameState, group, assumption));
}
}
if (specialization.hasMultipleInstances()) {
DSLExpression limit = specialization.getLimitExpression();
innerTripples.addAll(initializeCaches(frameState, group, specialization.getBoundCaches(limit), NodeExecutionMode.SLOW_PATH, true, false));
CodeTree limitExpression = DSLExpressionGenerator.write(limit, null, castBoundTypes(bindExpressionValues(frameState, limit, specialization)));
CodeTree limitCondition = CodeTreeBuilder.createBuilder().string(countName).string(" < ").tree(limitExpression).build();
innerTripples.add(new IfTriple(null, limitCondition, null));
// assert that specialization is not initialized
// otherwise we have been inserting invalid instances
assertSpecializationClassNotInitialized(frameState, specialization);
} else if (needsDuplicationCheck) {
innerTripples.add(new IfTriple(null, state.createNotContains(frameState, new Object[] { specialization }), null));
}
innerIfCount += IfTriple.materialize(builder, IfTriple.optimize(innerTripples), false);
builder.tree(createSpecialize(builder, frameState, group, specialization));
if (needsDuplicationCheck) {
hasFallthrough = true;
if (useDuplicateFlag) {
builder.startStatement().string(duplicateFoundName, " = true").end();
}
builder.end(innerIfCount);
// need to ensure that we update the implicit cast specializations on duplicates
CodeTree updateImplicitCast = createUpdateImplicitCastState(builder, frameState, specialization);
if (updateImplicitCast != null) {
builder.startElseBlock();
builder.tree(createUpdateImplicitCastState(builder, frameState, specialization));
builder.tree(state.createSet(frameState, new Object[] { specialization }, true, true));
builder.end();
}
builder.startIf();
if (useDuplicateFlag) {
builder.string(duplicateFoundName);
} else {
builder.string(createSpecializationLocalName(specialization), " != null");
}
builder.end().startBlock();
builder.tree(createExecute(builder, frameState, executeAndSpecializeType, specialization, mode));
builder.end();
} else {
builder.tree(createExecute(builder, frameState, executeAndSpecializeType, specialization, mode));
builder.end(innerIfCount);
hasFallthrough |= innerIfCount > 0;
}
}
builder.end(outerIfCount);
hasFallthrough |= outerIfCount > 0;
} else if (mode.isGuardFallback()) {
int ifCount = 0;
if (specialization != null && specialization.getMaximumNumberOfInstances() > 1) {
throw new AssertionError("unsupported path. should be caught by parser..");
}
int innerIfCount = 0;
cachedTriples.addAll(createMethodGuardCheck(frameState, group, guardExpressions, mode));
cachedTriples.addAll(createAssumptionCheckTriples(frameState, specialization));
cachedTriples = IfTriple.optimize(cachedTriples);
if (specialization != null && !hasImplicitCast) {
IfTriple singleCondition = null;
if (cachedTriples.size() == 1) {
singleCondition = cachedTriples.get(0);
}
if (singleCondition != null) {
int index = cachedTriples.indexOf(singleCondition);
CodeTree stateCheck = state.createNotContains(frameState, specializations);
cachedTriples.set(index, new IfTriple(singleCondition.prepare, combineTrees(" && ", stateCheck, singleCondition.condition), singleCondition.statements));
fallbackNeedsState = true;
}
}
innerIfCount += IfTriple.materialize(builder, cachedTriples, false);
SpecializationGroup prev = null;
for (SpecializationGroup child : group.getChildren()) {
if (prev != null && !prev.hasFallthrough()) {
break;
}
builder.tree(visitSpecializationGroup(builder, child, forType, frameState.copy(), allowedSpecializations, mode));
prev = child;
}
if (specialization != null) {
builder.returnFalse();
}
builder.end(innerIfCount);
builder.end(ifCount);
hasFallthrough |= ifCount > 0 || innerIfCount > 0;
} else {
throw new AssertionError("unexpected path");
}
group.setFallthrough(hasFallthrough);
return builder.build();
}
use of com.oracle.truffle.dsl.processor.expression.DSLExpression in project graal by oracle.
the class FlatNodeGenFactory method accessesCachedState.
private static boolean accessesCachedState(List<SpecializationData> specializations) {
final AtomicBoolean needsState = new AtomicBoolean(false);
for (final SpecializationData specialization : specializations) {
if (!specialization.getAssumptionExpressions().isEmpty()) {
needsState.set(true);
break;
}
for (GuardExpression expression : specialization.getGuards()) {
expression.getExpression().accept(new DSLExpressionVisitor() {
public void visitVariable(Variable binary) {
if (!needsState.get() && isVariableAccessMember(binary)) {
needsState.set(true);
}
}
private boolean isVariableAccessMember(Variable variable) {
if (variable.getName().equals("null") && variable.getReceiver() == null) {
return false;
}
Parameter p = specialization.findByVariable(variable.getResolvedVariable());
if (p == null && !variable.getResolvedVariable().getModifiers().contains(STATIC)) {
DSLExpression receiver = variable.getReceiver();
if (receiver instanceof Variable) {
return isVariableAccessMember((Variable) receiver);
} else if (receiver instanceof Call) {
return isMethodAccessMember((Call) receiver);
}
return true;
} else if (p != null && p.getSpecification().isCached()) {
return true;
}
return false;
}
public void visitBooleanLiteral(BooleanLiteral binary) {
}
public void visitNegate(Negate negate) {
}
public void visitIntLiteral(IntLiteral binary) {
}
private boolean isMethodAccessMember(Call call) {
if (!call.getResolvedMethod().getModifiers().contains(STATIC)) {
DSLExpression receiver = call.getReceiver();
if (receiver instanceof Variable) {
return isVariableAccessMember((Variable) receiver);
} else if (receiver instanceof Call) {
return isMethodAccessMember((Call) receiver);
}
return true;
}
return false;
}
public void visitCall(Call call) {
if (!needsState.get() && isMethodAccessMember(call)) {
needsState.set(true);
}
}
public void visitBinary(Binary binary) {
}
});
}
}
boolean needsStat = needsState.get();
return needsStat;
}
use of com.oracle.truffle.dsl.processor.expression.DSLExpression in project graal by oracle.
the class GuardExpression method isConstantTrueInSlowPath.
public boolean isConstantTrueInSlowPath(ProcessorContext context) {
DSLExpression reducedExpression = getExpression().reduce(new AbstractDSLExpressionReducer() {
@Override
public DSLExpression visitVariable(Variable binary) {
// on the slow path we can assume all cache expressions inlined.
for (CacheExpression cache : source.getCaches()) {
if (ElementUtils.variableEquals(cache.getParameter().getVariableElement(), binary.getResolvedVariable())) {
return cache.getExpression();
}
}
return super.visitVariable(binary);
}
@Override
public DSLExpression visitCall(Call binary) {
ExecutableElement method = binary.getResolvedMethod();
if (!method.getSimpleName().toString().equals("equals")) {
return binary;
}
if (method.getModifiers().contains(Modifier.STATIC)) {
return binary;
}
if (!ElementUtils.typeEquals(method.getReturnType(), context.getType(boolean.class))) {
return binary;
}
if (method.getParameters().size() != 1) {
return binary;
}
// signature: receiver.equals(receiver) can be folded to true
DSLExpression receiver = binary.getReceiver();
DSLExpression firstArg = binary.getParameters().get(0);
if (receiver instanceof Variable && firstArg instanceof Variable) {
if (receiver.equals(firstArg)) {
return new BooleanLiteral(true);
}
}
return super.visitCall(binary);
}
@Override
public DSLExpression visitBinary(Binary binary) {
// signature: value == value can be folded to true
if (IDENTITY_FOLD_OPERATORS.contains(binary.getOperator())) {
if (binary.getLeft() instanceof Variable && binary.getRight() instanceof Variable) {
Variable leftVar = ((Variable) binary.getLeft());
Variable rightVar = ((Variable) binary.getRight());
if (leftVar.equals(rightVar)) {
// double and float cannot be folded as NaN is never identity equal
if (!ElementUtils.typeEquals(leftVar.getResolvedType(), context.getType(float.class)) && !ElementUtils.typeEquals(leftVar.getResolvedType(), context.getType(double.class))) {
return new BooleanLiteral(true);
}
}
}
}
return super.visitBinary(binary);
}
});
Object o = reducedExpression.resolveConstant();
if (o instanceof Boolean) {
if (((Boolean) o).booleanValue()) {
return true;
}
}
return false;
}
use of com.oracle.truffle.dsl.processor.expression.DSLExpression in project graal by oracle.
the class GuardExpression method equalsNegated.
public boolean equalsNegated(GuardExpression other) {
boolean negated = false;
DSLExpression thisExpression = expression;
if (thisExpression instanceof Negate) {
negated = true;
thisExpression = ((Negate) thisExpression).getReceiver();
}
boolean otherNegated = false;
DSLExpression otherExpression = other.expression;
if (otherExpression instanceof Negate) {
otherNegated = true;
otherExpression = ((Negate) otherExpression).getReceiver();
}
return Objects.equals(thisExpression, otherExpression) && negated != otherNegated;
}
use of com.oracle.truffle.dsl.processor.expression.DSLExpression in project graal by oracle.
the class NodeParser method initializeAssumptions.
private void initializeAssumptions(SpecializationData specialization, DSLExpressionResolver resolver) {
final DeclaredType assumptionType = context.getDeclaredType(Assumption.class);
final TypeMirror assumptionArrayType = new ArrayCodeTypeMirror(assumptionType);
final List<String> assumptionDefinitions = ElementUtils.getAnnotationValueList(String.class, specialization.getMarkerAnnotation(), "assumptions");
List<AssumptionExpression> assumptionExpressions = new ArrayList<>();
int assumptionId = 0;
for (String assumption : assumptionDefinitions) {
AssumptionExpression assumptionExpression;
DSLExpression expression = null;
try {
expression = DSLExpression.parse(assumption);
expression.accept(resolver);
assumptionExpression = new AssumptionExpression(specialization, expression, "assumption" + assumptionId);
if (!ElementUtils.isAssignable(expression.getResolvedType(), assumptionType) && !ElementUtils.isAssignable(expression.getResolvedType(), assumptionArrayType)) {
assumptionExpression.addError("Incompatible return type %s. Assumptions must be assignable to %s or %s.", ElementUtils.getSimpleName(expression.getResolvedType()), ElementUtils.getSimpleName(assumptionType), ElementUtils.getSimpleName(assumptionArrayType));
}
if (specialization.isDynamicParameterBound(expression)) {
specialization.addError("Assumption expressions must not bind dynamic parameter values.");
}
} catch (InvalidExpressionException e) {
assumptionExpression = new AssumptionExpression(specialization, null, "assumption" + assumptionId);
assumptionExpression.addError("Error parsing expression '%s': %s", assumption, e.getMessage());
}
assumptionExpressions.add(assumptionExpression);
assumptionId++;
}
specialization.setAssumptionExpressions(assumptionExpressions);
}
Aggregations