@Override public void visitStructDefinitionType(StructDefinitionType structDefinitionType) { super.visitStructDefinitionType(structDefinitionType); if (structDefinitionType.hasStructNameType()) { assert !structDeclarationMap.containsKey(structDefinitionType.getStructNameType()); structDeclarationMap.put(structDefinitionType.getStructNameType(), structDefinitionType); } }
private List<String> getStructNames(List<Declaration> toBeAdded) { return toBeAdded .stream() .map(StructUtils::getStructDefinitions) .reduce(new ArrayList<>(), ListConcat::concatenate) .stream() .filter(StructDefinitionType::hasStructNameType) .map(item -> item.getStructNameType().getName()) .collect(Collectors.toList()); }
private Set<String> getStructNamesFromShader(TranslationUnit tu) { return tu.getStructDefinitions() .stream() .filter(StructDefinitionType::hasStructNameType) .map(item -> item.getStructNameType()) .filter(item -> item instanceof StructNameType) .map(item -> ((StructNameType) item).getName()) .collect(Collectors.toSet()); }
public String getOuterStructName() { return outerStruct.getStructNameType().getName(); } }
private Type fuzzType() { List<Type> candidates = new ArrayList<>(); candidates.addAll(BasicType.allBasicTypes()); candidates.addAll(fuzzingContext.getStructDeclarations() .stream() .map(item -> item.getStructNameType()) .collect(Collectors.toList())); return candidates.get(generator.nextInt(candidates.size())); }
public StructDefinitionType getStructDefinition(StructNameType type) { return getStructDefinitions() .stream() .filter(item -> item.hasStructNameType() && item.getStructNameType().equals(type)) .findAny() .get(); }
public void addStructDefinition(StructDefinitionType sdt) { assert sdt.hasStructNameType(); structMapping.put(sdt.getStructNameType().getName(), sdt); }
public static boolean declaresReferencedStruct(TranslationUnit tu, VariablesDeclaration variablesDeclaration) { return StructUtils.getStructDefinitions(variablesDeclaration) .stream() .filter(item -> item.hasStructNameType()) .map(item -> item.getStructNameType()) .anyMatch(item -> countStructReferences(tu, item) > 1); }
@Override public void visitStructDefinitionType(StructDefinitionType structDefinitionType) { super.visitStructDefinitionType(structDefinitionType); // TODO: right now we do not obfuscate fields of anonymous structs. if (structDefinitionType.hasStructNameType()) { final String oldName = structDefinitionType.getStructNameType().getName(); final String newName = renameStruct(oldName); namedStructRenaming.put(oldName, newName); structDefinitionTypes.add(structDefinitionType); final Map<String, String> fieldRenaming = new HashMap<>(); for (String fieldName : structDefinitionType.getFieldNames()) { fieldRenaming.put(fieldName, renameStructField(fieldName)); } structFieldRenaming.put(structDefinitionType.getStructNameType(), fieldRenaming); } }
@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);
private Expr makeInitializationExpr(StructDefinitionType structDefinitionType, Expr originalInitializer) { List<Expr> args = new ArrayList<>(); for (int i = 0; i < structDefinitionType.getNumFields(); i++) { if (structDefinitionType.getFieldName(i).startsWith(Constants.STRUCTIFICATION_FIELD_PREFIX)) { final Type fieldType = structDefinitionType.getFieldType(i); args.add(fieldType instanceof StructNameType ? makeInitializationExpr(tu.getStructDefinition((StructNameType) fieldType), originalInitializer) : fieldType.getCanonicalConstant()); } else { args.add(originalInitializer); } } return new TypeConstructorExpr(structDefinitionType.getStructNameType().getName(), args); }
private void obfuscateTranslationUnit(TranslationUnit tu) { this.typer = new Typer(tu, tu.getShadingLanguageVersion()); visit(tu); for (VariableDeclInfo declInfo : varDeclMapping.keySet()) { assert varDeclMapping.containsKey(declInfo); declInfo.setName(varDeclMapping.get(declInfo)); } for (ParameterDecl parameterDecl : paramDeclMapping.keySet()) { assert paramDeclMapping.containsKey(parameterDecl); parameterDecl.setName(paramDeclMapping.get(parameterDecl)); } for (StructDefinitionType structDefinitionType : structDefinitionTypes) { if (structDefinitionType.hasStructNameType()) { final StructNameType structNameType = structDefinitionType.getStructNameType(); for (int i = 0; i < structDefinitionType.getNumFields(); i++) { assert structFieldRenaming.get(structNameType) .containsKey(structDefinitionType.getFieldName(i)); structDefinitionType.setFieldName(i, structFieldRenaming.get(structNameType) .get(structDefinitionType.getFieldName(i))); } } } new StandardVisitor() { @Override public void visitStructNameType(StructNameType structNameType) { structNameType.setName(namedStructRenaming.get(structNameType.getName())); } }.visit(tu); }
@Override public void visitStructDefinitionType(StructDefinitionType structDefinitionType) { out.append("struct "); if (structDefinitionType.hasStructNameType()) { visit(structDefinitionType.getStructNameType()); out.append(" "); } out.append("{" + newLine()); increaseIndent(); for (String name : structDefinitionType.getFieldNames()) { out.append(indent()); visit(structDefinitionType.getFieldType(name)); out.append(" " + name); processArrayInfo(structDefinitionType.getFieldType(name)); out.append(";" + newLine()); } decreaseIndent(); out.append("}"); }
@Override public void visitStructDefinitionType(StructDefinitionType structDefinitionType) { if (structDefinitionType.hasStructNameType()) { visitChildFromParent(structDefinitionType.getStructNameType(), structDefinitionType); } for (String name : structDefinitionType.getFieldNames()) { visitChildFromParent(structDefinitionType.getFieldType(name), structDefinitionType); } }
fieldTypes.add(newStructs.get(0).getStructNameType()); } else {
throw new RuntimeException("Could not find a struct named " + structName + " in scope."); assert sdt.getStructNameType().getName().equals(structName); return new TypeConstructorExpr(structName, sdt.getFieldTypes() .stream().map(item -> makeExpr(item, false, constContext, depth + 1))
if (!structType.equals(innerStruct.getStructNameType())) { return; if (!typer.lookupType(outerMemberLookupExpr.getStructure()) .getWithoutQualifiers() .equals(outerStruct.getStructNameType())) { return;
private void structifyDeclaration(String enclosingStructVariableName, StructDefinitionType enclosingStructType) { declToTransform.getVariablesDeclaration() .setBaseType(enclosingStructType.getStructNameType()); final VariableDeclInfo declInfo = declToTransform.getVariablesDeclaration().getDeclInfo(0); declInfo.setName(enclosingStructVariableName); if (declInfo.hasInitializer()) { declInfo.setInitializer( new ScalarInitializer( makeInitializationExpr(enclosingStructType, ((ScalarInitializer) declInfo.getInitializer()).getExpr()) ) ); } }