19236269568

Committed 10 Nov 2025 03:10PM UTC coverage: 61.551% (+0.02%) from 61.533%

Build # 19236269568

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #331 from daisytuner/pointer-syms

allow interpretation of pointers as ints in symbolic expressions

Run Details

54 of 95 new or added lines in 19 files covered. (56.84%)

3 existing lines in 3 files now uncovered.

10391 of 16882 relevant lines covered (61.55%)

107.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.24

/src/codegen/language_extensions/cpp_language_extension.cpp

#include "sdfg/codegen/language_extensions/cpp_language_extension.h"

#include "sdfg/codegen/utils.h"
#include "sdfg/data_flow/tasklet.h"

namespace sdfg {
namespace codegen {

std::string CPPLanguageExtension::primitive_type(const types::PrimitiveType prim_type) {
    switch (prim_type) {
        case types::PrimitiveType::Void:
            return "void";
        case types::PrimitiveType::Bool:
            return "bool";
        case types::PrimitiveType::Int8:
            return "signed char";
        case types::PrimitiveType::Int16:
            return "short";
        case types::PrimitiveType::Int32:
            return "int";
        case types::PrimitiveType::Int64:
            return "long long";
        case types::PrimitiveType::Int128:
            return "__int128";
        case types::PrimitiveType::UInt8:
            return "char";
        case types::PrimitiveType::UInt16:
            return "unsigned short";
        case types::PrimitiveType::UInt32:
            return "unsigned int";
        case types::PrimitiveType::UInt64:
            return "unsigned long long";
        case types::PrimitiveType::UInt128:
            return "unsigned __int128";
        case types::PrimitiveType::Half:
            return "__fp16";
        case types::PrimitiveType::BFloat:
            return "__bf16";
        case types::PrimitiveType::Float:
            return "float";
        case types::PrimitiveType::Double:
            return "double";
        case types::PrimitiveType::X86_FP80:
            return "long double";
        case types::PrimitiveType::FP128:
            return "__float128";
        case types::PrimitiveType::PPC_FP128:
            return "__float128";
    }

    throw std::runtime_error("Unknown primitive type");
};

std::string CPPLanguageExtension::
    declaration(const std::string& name, const types::IType& type, bool use_initializer, bool use_alignment) {
    std::stringstream val;

    if (auto scalar_type = dynamic_cast<const types::Scalar*>(&type)) {
        val << primitive_type(scalar_type->primitive_type());
        val << " ";
        val << name;
    } else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {
        auto& element_type = array_type->element_type();
        val << declaration(name + "[" + this->expression(array_type->num_elements()) + "]", element_type);
    } else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {
        if (pointer_type->has_pointee_type()) {
            const types::IType& pointee = pointer_type->pointee_type();

            const bool pointee_is_function_or_array = dynamic_cast<const types::Function*>(&pointee) ||
                                                      dynamic_cast<const types::Array*>(&pointee);

            // Parenthesise *only* when it is needed to bind tighter than [] or ()
            std::string decorated = pointee_is_function_or_array ? "(*" + name + ")" : "*" + name;

            val << declaration(decorated, pointee);
        } else {
            val << "void*";
            val << " " << name;
        }
    } else if (auto ref_type = dynamic_cast<const Reference*>(&type)) {
        val << declaration("&" + name, ref_type->reference_type());
    } else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {
        val << structure_type->name();
        val << " ";
        val << name;
    } else if (auto function_type = dynamic_cast<const types::Function*>(&type)) {
        std::stringstream params;
        for (size_t i = 0; i < function_type->num_params(); ++i) {
            params << declaration("", function_type->param_type(symbolic::integer(i)));
            if (i + 1 < function_type->num_params()) params << ", ";
        }
        if (function_type->is_var_arg()) {
            // ISO C++ forbids empty parameter lists before ...
            if (function_type->num_params() > 0) {
                params << ", ";
                params << "...";
            }
        }

        const std::string fun_name = name + "(" + params.str() + ")";
        val << declaration(fun_name, function_type->return_type());
    } else {
        throw std::runtime_error("Unknown declaration type");
    }

    if (use_alignment && type.alignment() > 0) {
        val << " __attribute__((aligned(" << type.alignment() << ")))";
    }
    if (use_initializer && !type.initializer().empty()) {
        val << " = " << type.initializer();
    }

    return val.str();
};

std::string CPPLanguageExtension::type_cast(const std::string& name, const types::IType& type) {
    std::stringstream val;

    val << "reinterpret_cast";
    val << "<";
    val << declaration("", type);
    val << ">";
    val << "(" << name << ")";

    return val.str();
};

std::string CPPLanguageExtension::subset(const types::IType& type, const data_flow::Subset& sub) {
    if (sub.empty()) {
        return "";
    }

    if (dynamic_cast<const types::Scalar*>(&type)) {
        return "";
    } else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {
        std::string subset_str = "[" + this->expression(sub.at(0)) + "]";

        if (sub.size() > 1) {
            data_flow::Subset element_subset(sub.begin() + 1, sub.end());
            auto& element_type = array_type->element_type();
            return subset_str + subset(element_type, element_subset);
        } else {
            return subset_str;
        }
    } else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {
        std::string subset_str = "[" + this->expression(sub.at(0)) + "]";

        data_flow::Subset element_subset(sub.begin() + 1, sub.end());
        auto& pointee_type = pointer_type->pointee_type();
        return subset_str + subset(pointee_type, element_subset);
    } else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {
        auto& definition = this->function_.structure(structure_type->name());

        std::string subset_str = ".member_" + this->expression(sub.at(0));
        if (sub.size() > 1) {
            auto member = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(0));
            auto& member_type = definition.member_type(member);
            data_flow::Subset element_subset(sub.begin() + 1, sub.end());
            return subset_str + subset(member_type, element_subset);
        } else {
            return subset_str;
        }
    }

    throw std::invalid_argument("Invalid subset type");
};

std::string CPPLanguageExtension::expression(const symbolic::Expression expr) {
    CPPSymbolicPrinter printer(this->function_, this->external_prefix_);
    return printer.apply(expr);
};

std::string CPPLanguageExtension::access_node(const data_flow::AccessNode& node) {
    if (dynamic_cast<const data_flow::ConstantNode*>(&node)) {
        std::string name = node.data();
        if (symbolic::is_nullptr(symbolic::symbol(name))) {
            return "nullptr";
        }
        return name;
    } else {
        std::string name = node.data();
        if (this->function_.is_external(name)) {
            return "(&" + this->external_prefix_ + name + ")";
        }
        return name;
    }
};

std::string CPPLanguageExtension::tasklet(const data_flow::Tasklet& tasklet) {
    switch (tasklet.code()) {
        case data_flow::TaskletCode::assign:
            return tasklet.inputs().at(0);
        case data_flow::TaskletCode::fp_neg:
            return "-" + tasklet.inputs().at(0);
        case data_flow::TaskletCode::fp_add:
            return tasklet.inputs().at(0) + " + " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_sub:
            return tasklet.inputs().at(0) + " - " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_mul:
            return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_div:
            return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_rem:
            return "remainder(" + tasklet.inputs().at(0) + ", " + tasklet.inputs().at(1) + ")";
        case data_flow::TaskletCode::fp_fma:
            return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1) + " + " + tasklet.inputs().at(2);
        case data_flow::TaskletCode::fp_oeq:
            return tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_one:
            return tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ogt:
            return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_oge:
            return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_olt:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ole:
            return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ord:
            return "std::isnan(" + tasklet.inputs().at(0) + ") && std::isnan(" + tasklet.inputs().at(1) + ")";
        case data_flow::TaskletCode::fp_ueq:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_une:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ugt:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_uge:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ult:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_ule:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")" + " || " +
                   tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::fp_uno:
            return "std::isnan(" + tasklet.inputs().at(0) + ") || std::isnan(" + tasklet.inputs().at(1) + ")";
        case data_flow::TaskletCode::int_add:
            return tasklet.inputs().at(0) + " + " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_sub:
            return tasklet.inputs().at(0) + " - " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_mul:
            return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_sdiv:
            return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_srem:
            return tasklet.inputs().at(0) + " % " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_udiv:
            return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_urem:
            return tasklet.inputs().at(0) + " % " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_and:
            return tasklet.inputs().at(0) + " & " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_or:
            return tasklet.inputs().at(0) + " | " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_xor:
            return tasklet.inputs().at(0) + " ^ " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_shl:
            return tasklet.inputs().at(0) + " << " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_lshr:
            return tasklet.inputs().at(0) + " >> " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ashr:
            return tasklet.inputs().at(0) + " >> " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_smin:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +
                   tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_smax:
            return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +
                   tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_scmp:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? -1 : (" + tasklet.inputs().at(0) +
                   " > " + tasklet.inputs().at(1) + " ? 1 : 0)";
        case data_flow::TaskletCode::int_umin:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +
                   tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_umax:
            return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +
                   tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ucmp:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? -1 : (" + tasklet.inputs().at(0) +
                   " > " + tasklet.inputs().at(1) + " ? 1 : 0)";
        case data_flow::TaskletCode::int_abs:
            return "(" + tasklet.inputs().at(0) + " < 0 ? -" + tasklet.inputs().at(0) + " : " + tasklet.inputs().at(0) +
                   ")";
        case data_flow::TaskletCode::int_eq:
            return tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ne:
            return tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_sgt:
            return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_sge:
            return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_slt:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_sle:
            return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ugt:
            return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_uge:
            return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ult:
            return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);
        case data_flow::TaskletCode::int_ule:
            return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);
    };
    throw std::invalid_argument("Invalid tasklet code");
};

std::string CPPLanguageExtension::zero(const types::PrimitiveType prim_type) {
    switch (prim_type) {
        case types::Void:
            throw InvalidSDFGException("No zero for void type possible");
        case types::Bool:
            return "false";
        case types::Int8:
            return "0";
        case types::Int16:
            return "0";
        case types::Int32:
            return "0";
        case types::Int64:
            return "0ll";
        case types::Int128:
            return "0";
        case types::UInt8:
            return "0u";
        case types::UInt16:
            return "0u";
        case types::UInt32:
            return "0u";
        case types::UInt64:
            return "0ull";
        case types::UInt128:
            return "0u";
        case types::Half:
            throw InvalidSDFGException("Currently unsupported");
        case types::BFloat:
            throw InvalidSDFGException("Currently unsupported");
        case types::Float:
            return "0.0f";
        case types::Double:
            return "0.0";
        case types::X86_FP80:
            return "0.0l";
        case types::FP128:
            throw InvalidSDFGException("Currently unsupported");
        case types::PPC_FP128:
            throw InvalidSDFGException("Currently unsupported");
    }
}

void CPPSymbolicPrinter::bvisit(const SymEngine::Infty& x) {
    if (x.is_negative_infinity())
        str_ = "-INFINITY";
    else if (x.is_positive_infinity())
        str_ = "INFINITY";
};

void CPPSymbolicPrinter::bvisit(const SymEngine::BooleanAtom& x) { str_ = x.get_val() ? "true" : "false"; };

void CPPSymbolicPrinter::bvisit(const SymEngine::Symbol& x) {
    if (symbolic::is_nullptr(symbolic::symbol(x.get_name()))) {
        str_ = "(reinterpret_cast<uintptr_t>(nullptr))";
        return;
    }
    std::string name = x.get_name();

    if (this->function_.is_external(name)) {
        name = "(&" + this->external_prefix_ + name + ")";
    }
    if (this->function_.exists(name) && this->function_.type(name).type_id() == types::TypeID::Pointer) {
        name = "(reinterpret_cast<uintptr_t>(" + name + "))";
    }

    str_ = name;
};

void CPPSymbolicPrinter::bvisit(const SymEngine::And& x) {
    std::ostringstream s;
    auto container = x.get_container();
    s << apply(*container.begin());
    for (auto it = ++(container.begin()); it != container.end(); ++it) {
        s << " && " << apply(*it);
    }
    str_ = parenthesize(s.str());
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Or& x) {
    std::ostringstream s;
    auto container = x.get_container();
    s << apply(*container.begin());
    for (auto it = ++(container.begin()); it != container.end(); ++it) {
        s << " || " << apply(*it);
    }
    str_ = parenthesize(s.str());
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Not& x) {
    str_ = "!" + apply(x.get_arg());
    str_ = parenthesize(str_);
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Equality& x) {
    str_ = apply(x.get_args()[0]) + " == " + apply(x.get_args()[1]);
    str_ = parenthesize(str_);
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Unequality& x) {
    str_ = apply(x.get_args()[0]) + " != " + apply(x.get_args()[1]);
    str_ = parenthesize(str_);
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Min& x) {
    std::ostringstream s;
    auto container = x.get_args();
    if (container.size() == 1) {
        s << apply(*container.begin());
    } else {
        s << "__daisy_min(";
        s << apply(*container.begin());

        // Recursively apply __daisy_min to the arguments
        SymEngine::vec_basic subargs;
        for (auto it = ++(container.begin()); it != container.end(); ++it) {
            subargs.push_back(*it);
        }
        auto submin = SymEngine::min(subargs);
        s << ", " << apply(submin);

        s << ")";
    }

    str_ = s.str();
};

void CPPSymbolicPrinter::bvisit(const SymEngine::Max& x) {
    std::ostringstream s;
    auto container = x.get_args();
    if (container.size() == 1) {
        s << apply(*container.begin());
    } else {
        s << "__daisy_max(";
        s << apply(*container.begin());

        // Recursively apply __daisy_max to the arguments
        SymEngine::vec_basic subargs;
        for (auto it = ++(container.begin()); it != container.end(); ++it) {
            subargs.push_back(*it);
        }
        auto submax = SymEngine::max(subargs);
        s << ", " << apply(submax);

        s << ")";
    }

    str_ = s.str();
};

void CPPSymbolicPrinter::bvisit(const SymEngine::FunctionSymbol& x) {
    if (x.get_name() == "idiv") {
        str_ = "((" + apply(x.get_args()[0]) + ") / (" + apply(x.get_args()[1]) + "))";
    } else if (x.get_name() == "iabs") {
        str_ = "((" + apply(x.get_args()[0]) + ") < 0 ? -(" + apply(x.get_args()[0]) + ") : (" +
               apply(x.get_args()[0]) + "))";
    } else if (x.get_name() == "imod") {
        str_ = "((" + apply(x.get_args()[0]) + ") % (" + apply(x.get_args()[1]) + "))";
    } else if (x.get_name() == "sizeof") {
        auto& so = dynamic_cast<const symbolic::SizeOfTypeFunction&>(x);
        auto& type = so.get_type();
        CPPLanguageExtension lang(this->function_, this->external_prefix_);
        str_ = "sizeof(" + lang.declaration("", type) + ")";
    } else {
        throw std::runtime_error("Unsupported function symbol: " + x.get_name());
    }
};

void CPPSymbolicPrinter::_print_pow(
    std::ostringstream& o,
    const SymEngine::RCP<const SymEngine::Basic>& a,
    const SymEngine::RCP<const SymEngine::Basic>& b
) {
    if (SymEngine::eq(*a, *SymEngine::E)) {
        o << "exp(" << apply(b) << ")";
    } else if (SymEngine::eq(*b, *SymEngine::rational(1, 2))) {
        o << "sqrt(" << apply(a) << ")";
    } else if (SymEngine::eq(*b, *SymEngine::rational(1, 3))) {
        o << "cbrt(" << apply(a) << ")";
    } else if (SymEngine::eq(*b, *SymEngine::integer(2))) {
        o << "((" + apply(a) + ") * (" + apply(a) + "))";
    } else {
        o << "__daisy_sym_pow(" << apply(a) << ", " << apply(b) << ")";
    }
};

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/language_extensions/cpp_language_extension.h"
2
3	#include "sdfg/codegen/utils.h"
4	#include "sdfg/data_flow/tasklet.h"
5
6	namespace sdfg {
7	namespace codegen {
8
9	std::string CPPLanguageExtension::primitive_type(const types::PrimitiveType prim_type) {	22✔
10	switch (prim_type) {	22✔
11	case types::PrimitiveType::Void:
12	return "void";	2✔
13	case types::PrimitiveType::Bool:
14	return "bool";	1✔
15	case types::PrimitiveType::Int8:
16	return "signed char";	1✔
17	case types::PrimitiveType::Int16:
18	return "short";	1✔
19	case types::PrimitiveType::Int32:
20	return "int";	6✔
21	case types::PrimitiveType::Int64:
22	return "long long";	1✔
23	case types::PrimitiveType::Int128:
24	return "__int128";	×
25	case types::PrimitiveType::UInt8:
26	return "char";	4✔
27	case types::PrimitiveType::UInt16:
28	return "unsigned short";	1✔
29	case types::PrimitiveType::UInt32:
30	return "unsigned int";	1✔
31	case types::PrimitiveType::UInt64:
32	return "unsigned long long";	1✔
33	case types::PrimitiveType::UInt128:
34	return "unsigned __int128";	×
35	case types::PrimitiveType::Half:
36	return "__fp16";	×
37	case types::PrimitiveType::BFloat:
38	return "__bf16";	×
39	case types::PrimitiveType::Float:
40	return "float";	2✔
41	case types::PrimitiveType::Double:
42	return "double";	1✔
43	case types::PrimitiveType::X86_FP80:
44	return "long double";	×
45	case types::PrimitiveType::FP128:
46	return "__float128";	×
47	case types::PrimitiveType::PPC_FP128:
48	return "__float128";	×
49	}
50
51	throw std::runtime_error("Unknown primitive type");	×
52	};	22✔
53
54	std::string CPPLanguageExtension::
55	declaration(const std::string& name, const types::IType& type, bool use_initializer, bool use_alignment) {	21✔
56	std::stringstream val;	21✔
57
58	if (auto scalar_type = dynamic_cast<const types::Scalar*>(&type)) {	21✔
59	val << primitive_type(scalar_type->primitive_type());	10✔
60	val << " ";	10✔
61	val << name;	10✔
62	} else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {	21✔
63	auto& element_type = array_type->element_type();	3✔
64	val << declaration(name + "[" + this->expression(array_type->num_elements()) + "]", element_type);	3✔
65	} else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {	11✔
66	if (pointer_type->has_pointee_type()) {	4✔
67	const types::IType& pointee = pointer_type->pointee_type();	3✔
68
69	const bool pointee_is_function_or_array = dynamic_cast<const types::Function*>(&pointee) \|\|	6✔
70	dynamic_cast<const types::Array*>(&pointee);	3✔
71
72	// Parenthesise only when it is needed to bind tighter than [] or ()
73	std::string decorated = pointee_is_function_or_array ? "(" + name + ")" : "" + name;	3✔
74
75	val << declaration(decorated, pointee);	3✔
76	} else {	3✔
77	val << "void*";	1✔
78	val << " " << name;	1✔
79	}
80	} else if (auto ref_type = dynamic_cast<const Reference*>(&type)) {	8✔
81	val << declaration("&" + name, ref_type->reference_type());	×
82	} else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {	4✔
83	val << structure_type->name();	4✔
84	val << " ";	4✔
85	val << name;	4✔
86	} else if (auto function_type = dynamic_cast<const types::Function*>(&type)) {	4✔
87	std::stringstream params;	×
88	for (size_t i = 0; i < function_type->num_params(); ++i) {	×
89	params << declaration("", function_type->param_type(symbolic::integer(i)));	×
90	if (i + 1 < function_type->num_params()) params << ", ";	×
91	}	×
92	if (function_type->is_var_arg()) {	×
93	// ISO C++ forbids empty parameter lists before ...
94	if (function_type->num_params() > 0) {	×
95	params << ", ";	×
96	params << "...";	×
97	}	×
98	}	×
99
100	const std::string fun_name = name + "(" + params.str() + ")";	×
101	val << declaration(fun_name, function_type->return_type());	×
102	} else {	×
103	throw std::runtime_error("Unknown declaration type");	×
104	}
105
106	if (use_alignment && type.alignment() > 0) {	21✔
107	val << " __attribute__((aligned(" << type.alignment() << ")))";	×
108	}	×
109	if (use_initializer && !type.initializer().empty()) {	21✔
110	val << " = " << type.initializer();	×
111	}	×
112
113	return val.str();	21✔
114	};	21✔
115
116	std::string CPPLanguageExtension::type_cast(const std::string& name, const types::IType& type) {	1✔
117	std::stringstream val;	1✔
118
119	val << "reinterpret_cast";	1✔
120	val << "<";	1✔
121	val << declaration("", type);	1✔
122	val << ">";	1✔
123	val << "(" << name << ")";	1✔
124
125	return val.str();	1✔
126	};	1✔
127
128	std::string CPPLanguageExtension::subset(const types::IType& type, const data_flow::Subset& sub) {	3✔
129	if (sub.empty()) {	3✔
130	return "";	1✔
131	}
132
133	if (dynamic_cast<const types::Scalar*>(&type)) {	2✔
134	return "";	×
135	} else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {	2✔
136	std::string subset_str = "[" + this->expression(sub.at(0)) + "]";	1✔
137
138	if (sub.size() > 1) {	1✔
139	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	×
140	auto& element_type = array_type->element_type();	×
NEW 141	return subset_str + subset(element_type, element_subset);	×
142	} else {	×
143	return subset_str;	1✔
144	}
145	} else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {	2✔
146	std::string subset_str = "[" + this->expression(sub.at(0)) + "]";	×
147
148	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	×
149	auto& pointee_type = pointer_type->pointee_type();	×
NEW 150	return subset_str + subset(pointee_type, element_subset);	×
151	} else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {	1✔
152	auto& definition = this->function_.structure(structure_type->name());	1✔
153
154	std::string subset_str = ".member_" + this->expression(sub.at(0));	1✔
155	if (sub.size() > 1) {	1✔
156	auto member = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(0));	×
157	auto& member_type = definition.member_type(member);	×
158	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	×
NEW 159	return subset_str + subset(member_type, element_subset);	×
160	} else {	×
161	return subset_str;	1✔
162	}
163	}	1✔
164
165	throw std::invalid_argument("Invalid subset type");	×
166	};	3✔
167
168	std::string CPPLanguageExtension::expression(const symbolic::Expression expr) {	9✔
169	CPPSymbolicPrinter printer(this->function_, this->external_prefix_);	9✔
170	return printer.apply(expr);	9✔
171	};	9✔
172
173	std::string CPPLanguageExtension::access_node(const data_flow::AccessNode& node) {	×
174	if (dynamic_cast<const data_flow::ConstantNode*>(&node)) {	×
175	std::string name = node.data();	×
176	if (symbolic::is_nullptr(symbolic::symbol(name))) {	×
NEW 177	return "nullptr";	×
178	}
179	return name;	×
180	} else {	×
181	std::string name = node.data();	×
NEW 182	if (this->function_.is_external(name)) {	×
183	return "(&" + this->external_prefix_ + name + ")";	×
184	}
185	return name;	×
186	}	×
187	};	×
188
189	std::string CPPLanguageExtension::tasklet(const data_flow::Tasklet& tasklet) {	×
190	switch (tasklet.code()) {	×
191	case data_flow::TaskletCode::assign:
192	return tasklet.inputs().at(0);	×
193	case data_flow::TaskletCode::fp_neg:
194	return "-" + tasklet.inputs().at(0);	×
195	case data_flow::TaskletCode::fp_add:
196	return tasklet.inputs().at(0) + " + " + tasklet.inputs().at(1);	×
197	case data_flow::TaskletCode::fp_sub:
198	return tasklet.inputs().at(0) + " - " + tasklet.inputs().at(1);	×
199	case data_flow::TaskletCode::fp_mul:
200	return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1);	×
201	case data_flow::TaskletCode::fp_div:
202	return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);	×
203	case data_flow::TaskletCode::fp_rem:
204	return "remainder(" + tasklet.inputs().at(0) + ", " + tasklet.inputs().at(1) + ")";	×
205	case data_flow::TaskletCode::fp_fma:
206	return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1) + " + " + tasklet.inputs().at(2);	×
207	case data_flow::TaskletCode::fp_oeq:
208	return tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);	×
209	case data_flow::TaskletCode::fp_one:
210	return tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);	×
211	case data_flow::TaskletCode::fp_ogt:
212	return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);	×
213	case data_flow::TaskletCode::fp_oge:
214	return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);	×
215	case data_flow::TaskletCode::fp_olt:
216	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);	×
217	case data_flow::TaskletCode::fp_ole:
218	return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);	×
219	case data_flow::TaskletCode::fp_ord:
220	return "std::isnan(" + tasklet.inputs().at(0) + ") && std::isnan(" + tasklet.inputs().at(1) + ")";	×
221	case data_flow::TaskletCode::fp_ueq:
222	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
223	tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);	×
224	case data_flow::TaskletCode::fp_une:
225	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
226	tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);	×
227	case data_flow::TaskletCode::fp_ugt:
228	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
229	tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);	×
230	case data_flow::TaskletCode::fp_uge:
231	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
232	tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);	×
233	case data_flow::TaskletCode::fp_ult:
234	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
235	tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);	×
236	case data_flow::TaskletCode::fp_ule:
237	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")" + " \|\| " +	×
238	tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);	×
239	case data_flow::TaskletCode::fp_uno:
240	return "std::isnan(" + tasklet.inputs().at(0) + ") \|\| std::isnan(" + tasklet.inputs().at(1) + ")";	×
241	case data_flow::TaskletCode::int_add:
242	return tasklet.inputs().at(0) + " + " + tasklet.inputs().at(1);	×
243	case data_flow::TaskletCode::int_sub:
244	return tasklet.inputs().at(0) + " - " + tasklet.inputs().at(1);	×
245	case data_flow::TaskletCode::int_mul:
246	return tasklet.inputs().at(0) + " * " + tasklet.inputs().at(1);	×
247	case data_flow::TaskletCode::int_sdiv:
248	return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);	×
249	case data_flow::TaskletCode::int_srem:
250	return tasklet.inputs().at(0) + " % " + tasklet.inputs().at(1);	×
251	case data_flow::TaskletCode::int_udiv:
252	return tasklet.inputs().at(0) + " / " + tasklet.inputs().at(1);	×
253	case data_flow::TaskletCode::int_urem:
254	return tasklet.inputs().at(0) + " % " + tasklet.inputs().at(1);	×
255	case data_flow::TaskletCode::int_and:
256	return tasklet.inputs().at(0) + " & " + tasklet.inputs().at(1);	×
257	case data_flow::TaskletCode::int_or:
258	return tasklet.inputs().at(0) + " \| " + tasklet.inputs().at(1);	×
259	case data_flow::TaskletCode::int_xor:
260	return tasklet.inputs().at(0) + " ^ " + tasklet.inputs().at(1);	×
261	case data_flow::TaskletCode::int_shl:
262	return tasklet.inputs().at(0) + " << " + tasklet.inputs().at(1);	×
263	case data_flow::TaskletCode::int_lshr:
264	return tasklet.inputs().at(0) + " >> " + tasklet.inputs().at(1);	×
265	case data_flow::TaskletCode::int_ashr:
266	return tasklet.inputs().at(0) + " >> " + tasklet.inputs().at(1);	×
267	case data_flow::TaskletCode::int_smin:
268	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +	×
269	tasklet.inputs().at(1);	×
270	case data_flow::TaskletCode::int_smax:
271	return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +	×
272	tasklet.inputs().at(1);	×
273	case data_flow::TaskletCode::int_scmp:
274	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? -1 : (" + tasklet.inputs().at(0) +	×
275	" > " + tasklet.inputs().at(1) + " ? 1 : 0)";	×
276	case data_flow::TaskletCode::int_umin:
277	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +	×
278	tasklet.inputs().at(1);	×
279	case data_flow::TaskletCode::int_umax:
280	return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1) + " ? " + tasklet.inputs().at(0) + " : " +	×
281	tasklet.inputs().at(1);	×
282	case data_flow::TaskletCode::int_ucmp:
283	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1) + " ? -1 : (" + tasklet.inputs().at(0) +	×
284	" > " + tasklet.inputs().at(1) + " ? 1 : 0)";	×
285	case data_flow::TaskletCode::int_abs:
286	return "(" + tasklet.inputs().at(0) + " < 0 ? -" + tasklet.inputs().at(0) + " : " + tasklet.inputs().at(0) +	×
287	")";
288	case data_flow::TaskletCode::int_eq:
289	return tasklet.inputs().at(0) + " == " + tasklet.inputs().at(1);	×
290	case data_flow::TaskletCode::int_ne:
291	return tasklet.inputs().at(0) + " != " + tasklet.inputs().at(1);	×
292	case data_flow::TaskletCode::int_sgt:
293	return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);	×
294	case data_flow::TaskletCode::int_sge:
295	return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);	×
296	case data_flow::TaskletCode::int_slt:
297	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);	×
298	case data_flow::TaskletCode::int_sle:
299	return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);	×
300	case data_flow::TaskletCode::int_ugt:
301	return tasklet.inputs().at(0) + " > " + tasklet.inputs().at(1);	×
302	case data_flow::TaskletCode::int_uge:
303	return tasklet.inputs().at(0) + " >= " + tasklet.inputs().at(1);	×
304	case data_flow::TaskletCode::int_ult:
305	return tasklet.inputs().at(0) + " < " + tasklet.inputs().at(1);	×
306	case data_flow::TaskletCode::int_ule:
307	return tasklet.inputs().at(0) + " <= " + tasklet.inputs().at(1);	×
308	};
309	throw std::invalid_argument("Invalid tasklet code");	×
310	};	×
311
312	std::string CPPLanguageExtension::zero(const types::PrimitiveType prim_type) {	×
313	switch (prim_type) {	×
314	case types::Void:
315	throw InvalidSDFGException("No zero for void type possible");	×
316	case types::Bool:
317	return "false";	×
318	case types::Int8:
319	return "0";	×
320	case types::Int16:
321	return "0";	×
322	case types::Int32:
323	return "0";	×
324	case types::Int64:
325	return "0ll";	×
326	case types::Int128:
327	return "0";	×
328	case types::UInt8:
329	return "0u";	×
330	case types::UInt16:
331	return "0u";	×
332	case types::UInt32:
333	return "0u";	×
334	case types::UInt64:
335	return "0ull";	×
336	case types::UInt128:
337	return "0u";	×
338	case types::Half:
339	throw InvalidSDFGException("Currently unsupported");	×
340	case types::BFloat:
341	throw InvalidSDFGException("Currently unsupported");	×
342	case types::Float:
343	return "0.0f";	×
344	case types::Double:
345	return "0.0";	×
346	case types::X86_FP80:
347	return "0.0l";	×
348	case types::FP128:
349	throw InvalidSDFGException("Currently unsupported");	×
350	case types::PPC_FP128:
351	throw InvalidSDFGException("Currently unsupported");	×
352	}	×
353	}	×
354
355	void CPPSymbolicPrinter::bvisit(const SymEngine::Infty& x) {	×
356	if (x.is_negative_infinity())	×
357	str_ = "-INFINITY";	×
358	else if (x.is_positive_infinity())	×
359	str_ = "INFINITY";	×
360	};	×
361
362	void CPPSymbolicPrinter::bvisit(const SymEngine::BooleanAtom& x) { str_ = x.get_val() ? "true" : "false"; };	×
363
364	void CPPSymbolicPrinter::bvisit(const SymEngine::Symbol& x) {	5✔
365	if (symbolic::is_nullptr(symbolic::symbol(x.get_name()))) {	5✔
NEW 366	str_ = "(reinterpret_cast<uintptr_t>(nullptr))";	×
367	return;	×
368	}
369	std::string name = x.get_name();	5✔
370
371	if (this->function_.is_external(name)) {	5✔
372	name = "(&" + this->external_prefix_ + name + ")";	1✔
373	}	1✔
374	if (this->function_.exists(name) && this->function_.type(name).type_id() == types::TypeID::Pointer) {	5✔
NEW 375	name = "(reinterpret_cast<uintptr_t>(" + name + "))";	×
NEW 376	}	×
377
378	str_ = name;	5✔
379	};	5✔
380
381	void CPPSymbolicPrinter::bvisit(const SymEngine::And& x) {	×
382	std::ostringstream s;	×
383	auto container = x.get_container();	×
384	s << apply(*container.begin());	×
385	for (auto it = ++(container.begin()); it != container.end(); ++it) {	×
386	s << " && " << apply(*it);	×
387	}	×
388	str_ = parenthesize(s.str());	×
389	};	×
390
391	void CPPSymbolicPrinter::bvisit(const SymEngine::Or& x) {	×
392	std::ostringstream s;	×
393	auto container = x.get_container();	×
394	s << apply(*container.begin());	×
395	for (auto it = ++(container.begin()); it != container.end(); ++it) {	×
396	s << " \|\| " << apply(*it);	×
397	}	×
398	str_ = parenthesize(s.str());	×
399	};	×
400
401	void CPPSymbolicPrinter::bvisit(const SymEngine::Not& x) {	×
402	str_ = "!" + apply(x.get_arg());	×
403	str_ = parenthesize(str_);	×
404	};	×
405
406	void CPPSymbolicPrinter::bvisit(const SymEngine::Equality& x) {	×
407	str_ = apply(x.get_args()[0]) + " == " + apply(x.get_args()[1]);	×
408	str_ = parenthesize(str_);	×
409	};	×
410
411	void CPPSymbolicPrinter::bvisit(const SymEngine::Unequality& x) {	×
412	str_ = apply(x.get_args()[0]) + " != " + apply(x.get_args()[1]);	×
413	str_ = parenthesize(str_);	×
414	};	×
415
416	void CPPSymbolicPrinter::bvisit(const SymEngine::Min& x) {	×
417	std::ostringstream s;	×
418	auto container = x.get_args();	×
419	if (container.size() == 1) {	×
420	s << apply(*container.begin());	×
421	} else {	×
422	s << "__daisy_min(";	×
423	s << apply(*container.begin());	×
424
425	// Recursively apply __daisy_min to the arguments
426	SymEngine::vec_basic subargs;	×
427	for (auto it = ++(container.begin()); it != container.end(); ++it) {	×
428	subargs.push_back(*it);	×
429	}	×
430	auto submin = SymEngine::min(subargs);	×
431	s << ", " << apply(submin);	×
432
433	s << ")";	×
434	}	×
435
436	str_ = s.str();	×
437	};	×
438
439	void CPPSymbolicPrinter::bvisit(const SymEngine::Max& x) {	×
440	std::ostringstream s;	×
441	auto container = x.get_args();	×
442	if (container.size() == 1) {	×
443	s << apply(*container.begin());	×
444	} else {	×
445	s << "__daisy_max(";	×
446	s << apply(*container.begin());	×
447
448	// Recursively apply __daisy_max to the arguments
449	SymEngine::vec_basic subargs;	×
450	for (auto it = ++(container.begin()); it != container.end(); ++it) {	×
451	subargs.push_back(*it);	×
452	}	×
453	auto submax = SymEngine::max(subargs);	×
454	s << ", " << apply(submax);	×
455
456	s << ")";	×
457	}	×
458
459	str_ = s.str();	×
460	};	×
461
462	void CPPSymbolicPrinter::bvisit(const SymEngine::FunctionSymbol& x) {	1✔
463	if (x.get_name() == "idiv") {	1✔
464	str_ = "((" + apply(x.get_args()[0]) + ") / (" + apply(x.get_args()[1]) + "))";	×
465	} else if (x.get_name() == "iabs") {	1✔
466	str_ = "((" + apply(x.get_args()[0]) + ") < 0 ? -(" + apply(x.get_args()[0]) + ") : (" +	×
467	apply(x.get_args()[0]) + "))";	×
468	} else if (x.get_name() == "imod") {	1✔
469	str_ = "((" + apply(x.get_args()[0]) + ") % (" + apply(x.get_args()[1]) + "))";	×
470	} else if (x.get_name() == "sizeof") {	1✔
471	auto& so = dynamic_cast<const symbolic::SizeOfTypeFunction&>(x);	1✔
472	auto& type = so.get_type();	1✔
473	CPPLanguageExtension lang(this->function_, this->external_prefix_);	1✔
474	str_ = "sizeof(" + lang.declaration("", type) + ")";	1✔
475	} else {	1✔
476	throw std::runtime_error("Unsupported function symbol: " + x.get_name());	×
477	}
478	};	1✔
479
480	void CPPSymbolicPrinter::_print_pow(	2✔
481	std::ostringstream& o,
482	const SymEngine::RCP<const SymEngine::Basic>& a,
483	const SymEngine::RCP<const SymEngine::Basic>& b
484	) {
485	if (SymEngine::eq(a, SymEngine::E)) {	2✔
486	o << "exp(" << apply(b) << ")";	×
487	} else if (SymEngine::eq(b, SymEngine::rational(1, 2))) {	2✔
488	o << "sqrt(" << apply(a) << ")";	×
489	} else if (SymEngine::eq(b, SymEngine::rational(1, 3))) {	2✔
490	o << "cbrt(" << apply(a) << ")";	×
491	} else if (SymEngine::eq(b, SymEngine::integer(2))) {	2✔
492	o << "((" + apply(a) + ") * (" + apply(a) + "))";	2✔
493	} else {	2✔
494	o << "__daisy_sym_pow(" << apply(a) << ", " << apply(b) << ")";	×
495	}
496	};	2✔
497
498	} // namespace codegen
499	} // namespace sdfg

daisytuner / sdfglib / 19236269568

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous