private Expr makeTypeConstructor(BasicType type, Supplier<ConstantExpr> supplier, int width) { List<Expr> args = new ArrayList<>(); for (int i = 0; i < width; i++) { args.add(supplier.get()); } return new TypeConstructorExpr(type.toString(), args); }
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { super.visitTypeConstructorExpr(typeConstructorExpr); if (typeConstructorExpr.getTypename().equals(getOuterStructName())) { TypeConstructorExpr oldArg = (TypeConstructorExpr) typeConstructorExpr.removeArg(indexOfInlinedField); for (int i = 0; i < oldArg.getNumArgs(); i++) { typeConstructorExpr.insertArg(indexOfInlinedField + i, oldArg.getArg(i)); } } }
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { out.append(typeConstructorExpr.getTypename() + "("); boolean first = true; for (Expr e : typeConstructorExpr.getArgs()) { if (!first) { out.append(", "); } first = false; visit(e); } out.append(")"); }
boolean isFullyReducedConstant(Expr expr) { if (expr instanceof ConstantExpr) { return true; } if (!(expr instanceof TypeConstructorExpr)) { return false; } TypeConstructorExpr tce = (TypeConstructorExpr) expr; for (int i = 0; i < tce.getNumChildren(); i++) { if (!isFullyReducedConstant(tce.getChild(i))) { return false; } } return true; }
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { super.visitTypeConstructorExpr(typeConstructorExpr); final String typename = typeConstructorExpr.getTypename(); if (namedStructRenaming.containsKey(typename)) { typeConstructorExpr.setTypename(namedStructRenaming.get(typename)); } }
private void findFoldFpScalarVectorBinaryOpportunities(IAstNode parent, Expr child, Expr lhs, Expr rhs, BinaryOperator<Float> op) { if (isFpConstant(lhs) && isFpVectorConstant(rhs)) { final TypeConstructorExpr typeConstructorExpr = (TypeConstructorExpr) rhs; addReplaceWithExpr(parent, child, new TypeConstructorExpr(typeConstructorExpr.getTypename(), typeConstructorExpr.getArgs() .stream() .map(item -> (FloatConstantExpr) item) .map(item -> new FloatConstantExpr(op.apply( Float.valueOf(((FloatConstantExpr) lhs).getValue()), Float.valueOf(item.getValue())).toString())) .collect(Collectors.toList()))); } if (isFpConstant(rhs) && isFpVectorConstant(lhs)) { final TypeConstructorExpr typeConstructorExpr = (TypeConstructorExpr) lhs; addReplaceWithExpr(parent, child, new TypeConstructorExpr(typeConstructorExpr.getTypename(), typeConstructorExpr.getArgs() .stream() .map(item -> (FloatConstantExpr) item) .map(item -> new FloatConstantExpr(op.apply( Float.valueOf(item.getValue()), Float.valueOf(((FloatConstantExpr) rhs).getValue())).toString())) .collect(Collectors.toList()))); } }
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { super.visitTypeConstructorExpr(typeConstructorExpr); if (!typeConstructorExpr.getTypename().equals( targetStruct.getStructNameType().getName())) { return; } // This is the target struct, so remove the appropriate constructor component typeConstructorExpr.removeArg(index); } }.visit(subtreeInWhichStructIsUsed);
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { super.visitTypeConstructorExpr(typeConstructorExpr); if (typeConstructorExpr.getTypename().equals(toLookFor.getName())) { counter++; } }
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { for (Expr e : typeConstructorExpr.getArgs()) { visitChildFromParent(e, typeConstructorExpr); } }
return false; if (tce.getNumArgs() == 1 && isOneFloat(tce.getArg(0))) { return true; if (tce.getNumArgs() != dim * dim) { return false; final Expr element = tce.getArg(i * dim + j); if (i == j) { if (!isOneFloat(element)) {
final Optional<ScalarInitializer> componentInitializer = initializer.map(item -> new ScalarInitializer(((TypeConstructorExpr) item.getExpr()) .getArg(currentIndex)));
@Override public void visitTypeConstructorExpr(TypeConstructorExpr typeConstructorExpr) { super.visitTypeConstructorExpr(typeConstructorExpr); switch (typeConstructorExpr.getTypename()) { case "float": types.put(typeConstructorExpr, BasicType.FLOAT); default: final StructNameType maybeStructType = new StructNameType(typeConstructorExpr.getTypename()); if (structDeclarationMap.containsKey(maybeStructType)) { types.put(typeConstructorExpr, maybeStructType); return; throw new RuntimeException("Unknown type constructor " + typeConstructorExpr.getTypename());
private boolean isZeroFloatVecOrSquareMat(Expr expr) { if (!(expr instanceof TypeConstructorExpr)) { return false; } if (!Arrays.asList(BasicType.VEC2, BasicType.VEC3, BasicType.VEC4, BasicType.MAT2X2, BasicType.MAT3X3, BasicType.MAT4X4).contains(typer.lookupType(expr))) { return false; } return ((TypeConstructorExpr) expr).getArgs() .stream().allMatch(item -> isZeroFloat(item) || isZeroFloatVecOrSquareMat(item)); }
return; if (basicType.getNumElements() != tce.getNumArgs()) { throw new RuntimeException("Should be unreachable."); addReplaceWithExpr(parent, child, new ParenExpr(tce.getArg(index)));
@Override public TypeConstructorExpr clone() { return new TypeConstructorExpr(type, args.stream().map(x -> x.clone()).collect(Collectors.toList())); }
private static boolean isFpVectorConstant(Expr expr) { return expr instanceof TypeConstructorExpr && Arrays.asList(BasicType.VEC2.toString(), BasicType.VEC3.toString(), BasicType.VEC4.toString()) .contains(((TypeConstructorExpr) expr).getTypename()) && ((TypeConstructorExpr) expr).getArgs() .stream() .allMatch(FoldConstantReductionOpportunities::isFpConstant); }
private boolean isOneFloatVec(Expr expr) { if (!(expr instanceof TypeConstructorExpr)) { return false; } if (!Arrays.asList(BasicType.VEC2, BasicType.VEC3, BasicType.VEC4) .contains(typer.lookupType(expr))) { return false; } return ((TypeConstructorExpr) expr).getArgs() .stream().allMatch(item -> isOneFloat(item) || isOneFloatVec(item)); }
@Override public Expr generateExpr(IRandom generator, Expr... args) { assert args.length == getNumArguments(); return new TypeConstructorExpr(resultType.toString(), Arrays.asList(args)); }
public static Expr getBasicTypeLiteralExpr(BasicType baseType, List<Number> args) { List<Expr> argExprs; if (baseType.getElementType() == BasicType.FLOAT) { argExprs = args.stream().map(item -> new FloatConstantExpr(item.toString())) .collect(Collectors.toList()); } else if (baseType.getElementType() == BasicType.UINT) { argExprs = args.stream().map(item -> new UIntConstantExpr(item.toString() + "u")) .collect(Collectors.toList()); } else { argExprs = args.stream().map(item -> new IntConstantExpr(item.toString())) .collect(Collectors.toList()); } if (argExprs.size() == 1) { return argExprs.get(0); } return new TypeConstructorExpr(baseType.toString(), argExprs); }
public Expr makeOpaqueBoolean(boolean value, BasicType type, boolean constContext, final int depth, Fuzzer fuzzer) { assert type.isBoolean(); if (type == BasicType.BOOL) { return makeOpaqueBooleanScalar(value, constContext, depth, fuzzer); } List<Expr> args = new ArrayList<>(); for (int i = 0; i < type.getNumElements(); i++) { args.add(makeOpaqueBoolean(value, BasicType.BOOL, constContext, depth, fuzzer)); } return new TypeConstructorExpr(type.toString(), args); }