Example #1
0
/*
 * Builds a ref.deref call around an expression if the it is of ref-type
 */
core::ExpressionPtr tryDeref(const core::ExpressionPtr& expr) {
	NodeManager& mgr = expr.getNodeManager();
	IRBuilder builder(mgr);
	const lang::BasicGenerator& gen = expr->getNodeManager().getLangBasic();

	// core::ExpressionPtr retExpr = expr;
	if (core::RefTypePtr&& refTy = expr->getType().isa<core::RefTypePtr>()) {
		return builder.callExpr(refTy->getElementType(), gen.getRefDeref(), expr);
	}
	return expr;
}
Example #2
0
/*
 * Builds a ref.deref call around an expression if the it is of type ref<ref<'a>>
 */
core::ExpressionPtr removeDoubleRef(const core::ExpressionPtr& expr){
	if (core::RefTypePtr&& refTy = expr->getType().isa<core::RefTypePtr>()) {
		 // on non array types remove also a single ref
		if(refTy->getElementType()->getNodeType() == core::NT_RefType || refTy->toString().find("array") == string::npos) {
			core::NodeManager& mgr = expr->getNodeManager();
			const core::IRBuilder& builder(mgr);
			const lang::BasicGenerator& gen = builder.getLangBasic();
			return builder.callExpr(refTy->getElementType(), gen.getRefDeref(), expr);
		}
	}
	return expr;
}
Example #3
0
/*
 * takes the expression passed to size (in bytes) and tries to extract the size in number of elements as well as the type to be used
 */
bool extractSizeFromSizeof(const core::ExpressionPtr& arg, core::ExpressionPtr& size, core::TypePtr& type, bool foundMul) {
	// get rid of casts
	NodePtr uncasted = arg;
	while (uncasted->getNodeType() == core::NT_CastExpr) {
		uncasted = uncasted.as<CastExprPtr>()->getSubExpression();
	}

	if (const CallExprPtr call = uncasted.isa<CallExprPtr>()) {
		// check if there is a multiplication
		if(call->getFunctionExpr()->toString().find(".mul") != string::npos && call->getArguments().size() == 2) {
			IRBuilder builder(arg->getNodeManager());
			// recursively look into arguments of multiplication
			if(extractSizeFromSizeof(call->getArgument(0), size, type, true)) {
				if(size)
					size = builder.callExpr(call->getType(), call->getFunctionExpr(), size, call->getArgument(1));
				else
					size = call->getArgument(1);
				return true;
			}
			if(extractSizeFromSizeof(call->getArgument(1), size, type, true)){
				if(size)
					size = builder.callExpr(call->getType(), call->getFunctionExpr(), call->getArgument(0), size);
				else
					size = call->getArgument(0);
				return true;
			}
		}
		// check if we reached a sizeof call
		if (call->toString().substr(0, 6).find("sizeof") != string::npos) {
			// extract the type to be allocated
			type = call->getArgument(0)->getType().isa<GenericTypePtr>()->getTypeParameter(0);
			assert(type && "Type could not be extracted!");

			if(!foundMul){ // no multiplication, just sizeof alone is passed as argument -> only one element
				IRBuilder builder(arg->getNodeManager());
				size = builder.literal(arg->getNodeManager().getLangBasic().getUInt8(), "1");
				return true;
			}

			return true;
		}
	}
	return false;
}
Example #4
0
core::ExpressionPtr getVarOutOfCrazyInspireConstruct(const core::ExpressionPtr& arg) {
	core::NodeManager& mgr = arg->getNodeManager();
	core::IRBuilder builder(mgr);
	const core::lang::BasicGenerator& gen = mgr.getLangBasic();

// remove stuff added by (void*)&
	core::CallExprPtr stripped = arg.isa<core::CallExprPtr>();

	if (!stripped) {
		return arg;
	}

	auto funExpr = stripped->getFunctionExpr();
	if(builder.getNodeManager().getLangBasic().isScalarToArray(funExpr) ||
			builder.getNodeManager().getLangBasic().isRefDeref(funExpr) || gen.isRefReinterpret(funExpr)) {
		return getVarOutOfCrazyInspireConstruct(stripped->getArgument(0));
	}

	return arg;
}
Example #5
0
	void replaceVars(core::ExpressionPtr& expr, core::NodeMap map) {
		if(!expr) { return; }
		core::NodeManager& mgr = expr->getNodeManager();
		expr = core::transform::replaceAll(mgr, expr, map, core::transform::globalReplacement).as<core::ExpressionPtr>();
	}