riscv
/
yosys
mirror of https://github.com/YosysHQ/yosys.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

functional backend: error out if multiply driven or undriven signals are seen, dont bother putting them in functionalir

This commit is contained in:
Emily Schmidt 2024-07-18 14:23:00 +01:00
parent 145af6f10d
commit 6d329e142d
4 changed files with 5 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
backends/functional/cxx.cc
View File

@ -154,7 +154,6 @@ template<class NodePrinter> struct CxxPrintVisitor : public FunctionalIR::Abstra
void state(Node, IdString name) override { print("current_state.{}", state_struct[name]); }
void memory_read(Node, Node mem, Node addr) override { print("{}.read({})", mem, addr); }
void memory_write(Node, Node mem, Node addr, Node data) override { print("{}.write({}, {})", mem, addr, data); }
void undriven(Node, int width) override { print("Signal<{}>(0)", width); }
};
struct CxxModule {

5
backends/functional/smtlib.cc
View File

@ -180,8 +180,6 @@ struct SmtPrintVisitor : public FunctionalIR::AbstractVisitor<SExpr> {
SExpr input(Node, IdString name) override { return input_struct.access("inputs", name); }
SExpr state(Node, IdString name) override { return state_struct.access("state", name); }
SExpr undriven(Node, int width) override { return literal(RTLIL::Const(State::S0, width)); }
};
struct SmtModule {
@ -227,8 +225,7 @@ struct SmtModule {
list("state", state_struct.name)),
list("Pair", output_struct.name, state_struct.name)));
auto inlined = [&](FunctionalIR::Node n) {
return n.fn() == FunctionalIR::Fn::constant ||
n.fn() == FunctionalIR::Fn::undriven;
return n.fn() == FunctionalIR::Fn::constant;
};
SmtPrintVisitor visitor(input_struct, state_struct);
auto node_to_sexpr = [&](FunctionalIR::Node n) -> SExpr {

14
kernel/functionalir.cc
View File

@ -56,8 +56,6 @@ const char *FunctionalIR::fn_to_string(FunctionalIR::Fn fn) {
case FunctionalIR::Fn::constant: return "constant";
case FunctionalIR::Fn::input: return "input";
case FunctionalIR::Fn::state: return "state";
case FunctionalIR::Fn::multiple: return "multiple";
case FunctionalIR::Fn::undriven: return "undriven";
case FunctionalIR::Fn::memory_read: return "memory_read";
case FunctionalIR::Fn::memory_write: return "memory_write";
}
@ -75,7 +73,6 @@ struct PrintVisitor : FunctionalIR::DefaultVisitor<std::string> {
std::string constant(Node, RTLIL::Const value) override { return "constant(" + value.as_string() + ")"; }
std::string input(Node, IdString name) override { return "input(" + name.str() + ")"; }
std::string state(Node, IdString name) override { return "state(" + name.str() + ")"; }
std::string undriven(Node, int width) override { return "undriven(" + std::to_string(width) + ")"; }
std::string default_handler(Node self) override {
std::string ret = FunctionalIR::fn_to_string(self.fn());
ret += "(";
@ -625,14 +622,11 @@ public:
factory.suggest_name(node, "$const" + std::to_string(chunk.size()) + "b" + chunk.constant().as_string());
factory.update_pending(pending, node);
} else if (chunk.is_multiple()) {
vector<Node> args;
for (auto const &driver : chunk.multiple().multiple())
args.push_back(enqueue(driver));
Node node = factory.multiple(args, chunk.size());
factory.update_pending(pending, node);
log_error("Signal %s has multiple drivers. This is not supported by the functional backend. "
"If tristate drivers are used, call tristate -formal to avoid this error.\n", log_signal(chunk));
} else if (chunk.is_none()) {
Node node = factory.undriven(chunk.size());
factory.update_pending(pending, node);
log_error("The design contains an undriven signal %s. This is not supported by the functional backend. "
"Call setundef with appropriate options to avoid this error.\n", log_signal(chunk));
} else {
log_error("unhandled drivespec: %s\n", log_signal(chunk));
log_abort();

19
kernel/functionalir.h
View File

@ -127,12 +127,6 @@ public:
// state(a: IdString): any
// returns the current value of the state variable with the specified name
state,
// multiple(a: any, b: any, c: any, ...): any
// indicates a value driven by multiple inputs
multiple,
// undriven(width: int): bit[width]
// indicates an undriven value
undriven,
// memory_read(memory: memory[addr_width, data_width], addr: bit[addr_width]): bit[data_width] = memory[addr]
memory_read,
// memory_write(memory: memory[addr_width, data_width], addr: bit[addr_width], data: bit[data_width]): memory[addr_width, data_width]
@ -277,8 +271,6 @@ public:
case Fn::state: return v.state(*this, _ref.function().as_idstring()); break;
case Fn::memory_read: return v.memory_read(*this, arg(0), arg(1)); break;
case Fn::memory_write: return v.memory_write(*this, arg(0), arg(1), arg(2)); break;
case Fn::multiple: log_error("multiple in visit"); break;
case Fn::undriven: return v.undriven(*this, width()); break;
}
}
std::string to_string();
@ -319,7 +311,6 @@ public:
virtual T state(Node self, IdString name) = 0;
virtual T memory_read(Node self, Node mem, Node addr) = 0;
virtual T memory_write(Node self, Node mem, Node addr, Node data) = 0;
virtual T undriven(Node self, int width) = 0;
};
// DefaultVisitor provides defaults for all visitor methods which just calls default_handler
template<class T> struct DefaultVisitor : public AbstractVisitor<T> {
@ -357,7 +348,6 @@ public:
T state(Node self, IdString) override { return default_handler(self); }
T memory_read(Node self, Node, Node) override { return default_handler(self); }
T memory_write(Node self, Node, Node, Node) override { return default_handler(self); }
T undriven(Node self, int) override { return default_handler(self); }
};
// a factory is used to modify a FunctionalIR. it creates new nodes and allows for some modification of existing nodes.
class Factory {
@ -475,15 +465,6 @@ public:
_ir.add_state(name, Sort(addr_width, data_width));
return add(NodeData(Fn::state, name), Sort(addr_width, data_width), {});
}
Node multiple(vector<Node> args, int width) {
auto node = add(Fn::multiple, Sort(width), {});
for(const auto &arg : args)
mutate(node).append_arg(arg._ref);
return node;
}
Node undriven(int width) {
return add(Fn::undriven, Sort(width), {});
}
void declare_output(Node node, IdString name, int width) {
_ir.add_output(name, Sort(width));
mutate(node).assign_key({name, false});