22902233069

Committed 10 Mar 2026 12:22PM UTC coverage: 64.428% (-0.2%) from 64.629%

Build # 22902233069

Build Type

Pull #571

github

Committed by

web-flow

Commit Message

Merge 4fd8b6f6e into 58e412d16

Pull Request Pull Request #571: [MLIR] Added support for cf.assert

Coverage Stats

9 of 128 new or added lines in 3 files covered. (7.03%)

3 existing lines in 1 file now uncovered.

24660 of 38275 relevant lines covered (64.43%)

375.56 hits per line

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

0.0

/sdfg/src/data_flow/library_nodes/stdlib/assert.cpp

#include "sdfg/data_flow/library_nodes/stdlib/assert.h"

#include <cassert>
#include <cstddef>
#include <cstdio>
#include <memory>
#include <nlohmann/json_fwd.hpp>
#include <string>

#include "sdfg/builder/structured_sdfg_builder.h"
#include "sdfg/codegen/code_snippet_factory.h"
#include "sdfg/codegen/dispatchers/block_dispatcher.h"
#include "sdfg/codegen/language_extension.h"
#include "sdfg/codegen/utils.h"
#include "sdfg/data_flow/data_flow_graph.h"
#include "sdfg/data_flow/data_flow_node.h"
#include "sdfg/data_flow/library_node.h"
#include "sdfg/element.h"
#include "sdfg/exceptions.h"
#include "sdfg/function.h"
#include "sdfg/graph/graph.h"
#include "sdfg/structured_control_flow/block.h"
#include "sdfg/symbolic/symbolic.h"

namespace sdfg {
namespace stdlib {

AssertNode::AssertNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    data_flow::DataFlowGraph& parent,
    std::string message
)
    : data_flow::LibraryNode(
          element_id,
          debug_info,
          vertex,
          parent,
          LibraryNodeType_Assert,
          {},
          {"_arg"},
          false,
          data_flow::ImplementationType_NONE
      ),
      message_(message) {}

std::string& AssertNode::message() { return this->message_; }

const std::string& AssertNode::message() const { return this->message_; }

std::string AssertNode::toStr() const {
    if (this->message_.empty()) {
        return "assert(_arg)";
    } else {
        return "assert(_arg && " + this->message_ + ")";
    }
}

symbolic::SymbolSet AssertNode::symbols() const { return {}; }

symbolic::Expression AssertNode::flop() const { return symbolic::zero(); }

std::unique_ptr<data_flow::DataFlowNode> AssertNode::
    clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {
    return std::make_unique<AssertNode>(element_id, this->debug_info(), vertex, parent, this->message());
}

void AssertNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}

nlohmann::json AssertNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {
    const auto& assert_node = static_cast<const AssertNode&>(library_node);

    nlohmann::json j;
    j["code"] = assert_node.code().value();

    j["message"] = assert_node.message();

    return j;
}

data_flow::LibraryNode& AssertNodeSerializer::deserialize(
    const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
) {
    assert(j.contains("code"));
    assert(j.contains("debug_info"));
    assert(j.contains("message"));

    auto code = j["code"].get<std::string>();
    if (code != LibraryNodeType_Assert.value()) {
        throw InvalidSDFGException("Invalid library node code");
    }

    sdfg::serializer::JSONSerializer serializer;
    DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);

    auto message = j["message"].get<std::string>();

    return builder.add_library_node<AssertNode>(parent, debug_info, message);
}

void AssertNodeDispatcher::escape_message(codegen::PrettyPrinter& stream, const std::string& message) {
    stream << "\"";
    for (unsigned char c : message) {
        switch (c) {
            case '\\':
                stream << "\\\\";
                break;
            case '\"':
                stream << "\\\"";
                break;
            case '\n':
                stream << "\\n";
                break;
            case '\r':
                stream << "\\r";
                break;
            case '\t':
                stream << "\\t";
                break;
            case '\v':
                stream << "\\v";
                break;
            case '\f':
                stream << "\\f";
                break;
            case '\b':
                stream << "\\b";
                break;
            case '\a':
                stream << "\\a";
                break;
            default:
                if (c < 0x20 || c == 0x7F) {
                    char buf[5];
                    std::snprintf(buf, sizeof(buf), "\\x%02X", (unsigned) c);
                    stream << buf;
                } else {
                    stream << static_cast<char>(c);
                }
        }
    }
    stream << "\"";
}

AssertNodeDispatcher::AssertNodeDispatcher(
    codegen::LanguageExtension& language_extension,
    const Function& function,
    const data_flow::DataFlowGraph& data_flow_graph,
    const data_flow::LibraryNode& node
)
    : codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}

void AssertNodeDispatcher::dispatch_code(
    codegen::PrettyPrinter& stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::CodeSnippetFactory& library_snippet_factory
) {
    auto& node = static_cast<const AssertNode&>(this->node_);

#ifndef __APPLE__
    std::string bool_cast = "";
#endif
    // Should be in include stream. Change when include handling is reworked!
    if (this->language_extension_.language() == "C") {
        globals_stream << "#include <assert.h>" << std::endl;
    } else {
        globals_stream << "#include <cassert>" << std::endl;
#ifndef __APPLE__
        bool_cast = "static_cast<bool>";
#endif
    }

#ifdef __APPLE__
    stream << "(__builtin_expect(!bool(" << node.input(0) << "), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, \""
           << node.input(0) << "\"";
#else
    stream << "(" << bool_cast << "(" << node.input(0) << ") ? void (0) : __assert_fail(\"" << node.input(0) << "\"";
#endif
    if (!node.message().empty()) {
        stream << " \" && \" ";
        this->escape_message(stream, node.message());
    }
#ifdef __APPLE__
    stream << ") : (void) 0);" << std::endl;
#else
    stream << ", __FILE__, __LINE__, __extension__ __PRETTY_FUNCTION__));" << std::endl;
#endif
}

} // namespace stdlib
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/stdlib/assert.h"
2
3	#include <cassert>
4	#include <cstddef>
5	#include <cstdio>
6	#include <memory>
7	#include <nlohmann/json_fwd.hpp>
8	#include <string>
9
10	#include "sdfg/builder/structured_sdfg_builder.h"
11	#include "sdfg/codegen/code_snippet_factory.h"
12	#include "sdfg/codegen/dispatchers/block_dispatcher.h"
13	#include "sdfg/codegen/language_extension.h"
14	#include "sdfg/codegen/utils.h"
15	#include "sdfg/data_flow/data_flow_graph.h"
16	#include "sdfg/data_flow/data_flow_node.h"
17	#include "sdfg/data_flow/library_node.h"
18	#include "sdfg/element.h"
19	#include "sdfg/exceptions.h"
20	#include "sdfg/function.h"
21	#include "sdfg/graph/graph.h"
22	#include "sdfg/structured_control_flow/block.h"
23	#include "sdfg/symbolic/symbolic.h"
24
25	namespace sdfg {
26	namespace stdlib {
27
28	AssertNode::AssertNode(
29	size_t element_id,
30	const DebugInfo& debug_info,
31	const graph::Vertex vertex,
32	data_flow::DataFlowGraph& parent,
33	std::string message
34	)
NEW 35	: data_flow::LibraryNode(	×
NEW 36	element_id,	×
NEW 37	debug_info,	×
NEW 38	vertex,	×
NEW 39	parent,	×
NEW 40	LibraryNodeType_Assert,	×
NEW 41	{},	×
NEW 42	{"_arg"},	×
NEW 43	false,	×
NEW 44	data_flow::ImplementationType_NONE	×
NEW 45	),	×
NEW 46	message_(message) {}	×
47
NEW 48	std::string& AssertNode::message() { return this->message_; }	×
49
NEW 50	const std::string& AssertNode::message() const { return this->message_; }	×
51
NEW 52	std::string AssertNode::toStr() const {	×
NEW 53	if (this->message_.empty()) {	×
NEW 54	return "assert(_arg)";	×
NEW 55	} else {	×
NEW 56	return "assert(_arg && " + this->message_ + ")";	×
NEW 57	}	×
NEW 58	}	×
59
NEW 60	symbolic::SymbolSet AssertNode::symbols() const { return {}; }	×
61
NEW 62	symbolic::Expression AssertNode::flop() const { return symbolic::zero(); }	×
63
64	std::unique_ptr<data_flow::DataFlowNode> AssertNode::
NEW 65	clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {	×
NEW 66	return std::make_unique<AssertNode>(element_id, this->debug_info(), vertex, parent, this->message());	×
NEW 67	}	×
68
NEW 69	void AssertNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}	×
70
NEW 71	nlohmann::json AssertNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
NEW 72	const auto& assert_node = static_cast<const AssertNode&>(library_node);	×
73
NEW 74	nlohmann::json j;	×
NEW 75	j["code"] = assert_node.code().value();	×
76
NEW 77	j["message"] = assert_node.message();	×
78
NEW 79	return j;	×
NEW 80	}	×
81
82	data_flow::LibraryNode& AssertNodeSerializer::deserialize(
83	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
NEW 84	) {	×
NEW 85	assert(j.contains("code"));	×
NEW 86	assert(j.contains("debug_info"));	×
NEW 87	assert(j.contains("message"));	×
88
NEW 89	auto code = j["code"].get<std::string>();	×
NEW 90	if (code != LibraryNodeType_Assert.value()) {	×
NEW 91	throw InvalidSDFGException("Invalid library node code");	×
NEW 92	}	×
93
NEW 94	sdfg::serializer::JSONSerializer serializer;	×
NEW 95	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
96
NEW 97	auto message = j["message"].get<std::string>();	×
98
NEW 99	return builder.add_library_node<AssertNode>(parent, debug_info, message);	×
NEW 100	}	×
101
NEW 102	void AssertNodeDispatcher::escape_message(codegen::PrettyPrinter& stream, const std::string& message) {	×
NEW 103	stream << "\"";	×
NEW 104	for (unsigned char c : message) {	×
NEW 105	switch (c) {	×
NEW 106	case '\\':	×
NEW 107	stream << "\\\\";	×
NEW 108	break;	×
NEW 109	case '\"':	×
NEW 110	stream << "\\\"";	×
NEW 111	break;	×
NEW 112	case '\n':	×
NEW 113	stream << "\\n";	×
NEW 114	break;	×
NEW 115	case '\r':	×
NEW 116	stream << "\\r";	×
NEW 117	break;	×
NEW 118	case '\t':	×
NEW 119	stream << "\\t";	×
NEW 120	break;	×
NEW 121	case '\v':	×
NEW 122	stream << "\\v";	×
NEW 123	break;	×
NEW 124	case '\f':	×
NEW 125	stream << "\\f";	×
NEW 126	break;	×
NEW 127	case '\b':	×
NEW 128	stream << "\\b";	×
NEW 129	break;	×
NEW 130	case '\a':	×
NEW 131	stream << "\\a";	×
NEW 132	break;	×
NEW 133	default:	×
NEW 134	if (c < 0x20 \|\| c == 0x7F) {	×
NEW 135	char buf[5];	×
NEW 136	std::snprintf(buf, sizeof(buf), "\\x%02X", (unsigned) c);	×
NEW 137	stream << buf;	×
NEW 138	} else {	×
NEW 139	stream << static_cast<char>(c);	×
NEW 140	}	×
NEW 141	}	×
NEW 142	}	×
NEW 143	stream << "\"";	×
NEW 144	}	×
145
146	AssertNodeDispatcher::AssertNodeDispatcher(
147	codegen::LanguageExtension& language_extension,
148	const Function& function,
149	const data_flow::DataFlowGraph& data_flow_graph,
150	const data_flow::LibraryNode& node
151	)
NEW 152	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
153
154	void AssertNodeDispatcher::dispatch_code(
155	codegen::PrettyPrinter& stream,
156	codegen::PrettyPrinter& globals_stream,
157	codegen::CodeSnippetFactory& library_snippet_factory
NEW 158	) {	×
NEW 159	auto& node = static_cast<const AssertNode&>(this->node_);	×
160
NEW 161	#ifndef __APPLE__	×
NEW 162	std::string bool_cast = "";	×
NEW 163	#endif	×
164	// Should be in include stream. Change when include handling is reworked!
NEW 165	if (this->language_extension_.language() == "C") {	×
NEW 166	globals_stream << "#include <assert.h>" << std::endl;	×
NEW 167	} else {	×
NEW 168	globals_stream << "#include <cassert>" << std::endl;	×
NEW 169	#ifndef __APPLE__	×
NEW 170	bool_cast = "static_cast<bool>";	×
NEW 171	#endif	×
NEW 172	}	×
173
174	#ifdef __APPLE__
175	stream << "(__builtin_expect(!bool(" << node.input(0) << "), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, \""
176	<< node.input(0) << "\"";
177	#else
NEW 178	stream << "(" << bool_cast << "(" << node.input(0) << ") ? void (0) : __assert_fail(\"" << node.input(0) << "\"";	×
NEW 179	#endif	×
NEW 180	if (!node.message().empty()) {	×
NEW 181	stream << " \" && \" ";	×
NEW 182	this->escape_message(stream, node.message());	×
NEW 183	}	×
184	#ifdef __APPLE__
185	stream << ") : (void) 0);" << std::endl;
186	#else
NEW 187	stream << ", __FILE__, __LINE__, __extension__ __PRETTY_FUNCTION__));" << std::endl;	×
NEW 188	#endif	×
NEW 189	}	×
190
191	} // namespace stdlib
192	} // namespace sdfg

daisytuner / docc / 22902233069

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