caiyu/nextpnr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clangformat

Browse Source 
Signed-off-by: gatecat <gatecat@ds0.me>
This commit is contained in:
gatecat 2024-01-12 10:09:28 +01:00
parent d00fdc8f7a
commit 2afb1f632e
11 changed files with 243 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
common/kernel/base_arch.h
View File

@ -185,7 +185,8 @@ template <typename R> struct BaseArch : ArchAPI<R>
return empty_if_possible<typename R::BelAttrsRangeT>(); return empty_if_possible<typename R::BelAttrsRangeT>();
} }
virtual typename R::CellBelPinRangeT getBelPinsForCellPin(const CellInfo * /*cell_info*/, IdString pin) const override virtual typename R::CellBelPinRangeT getBelPinsForCellPin(const CellInfo * /*cell_info*/,
IdString pin) const override
{ {
return return_if_match<std::array<IdString, 1>, typename R::CellBelPinRangeT>({pin}); return return_if_match<std::array<IdString, 1>, typename R::CellBelPinRangeT>({pin});
} }
@ -314,7 +315,8 @@ template <typename R> struct BaseArch : ArchAPI<R>
}; };
// Delay methods // Delay methods
virtual bool getArcDelayOverride(const NetInfo * /*net_info*/, const PortRef &/*sink*/, DelayQuad &/*delay*/) const override virtual bool getArcDelayOverride(const NetInfo * /*net_info*/, const PortRef & /*sink*/,
DelayQuad & /*delay*/) const override
{ {
return false; return false;
} }
@ -330,15 +332,18 @@ template <typename R> struct BaseArch : ArchAPI<R>
virtual DecalXY getGroupDecal(GroupId /*group*/) const override { return DecalXY(); } virtual DecalXY getGroupDecal(GroupId /*group*/) const override { return DecalXY(); }
// Cell timing methods // Cell timing methods
virtual bool getCellDelay(const CellInfo * /*cell*/, IdString /*fromPort*/, IdString /*toPort*/, DelayQuad &/*delay*/) const override virtual bool getCellDelay(const CellInfo * /*cell*/, IdString /*fromPort*/, IdString /*toPort*/,
DelayQuad & /*delay*/) const override
{ {
return false; return false;
} }
virtual TimingPortClass getPortTimingClass(const CellInfo * /*cell*/, IdString /*port*/, int &/*clockInfoCount*/) const override virtual TimingPortClass getPortTimingClass(const CellInfo * /*cell*/, IdString /*port*/,
int & /*clockInfoCount*/) const override
{ {
return TMG_IGNORE; return TMG_IGNORE;
} }
virtual TimingClockingInfo getPortClockingInfo(const CellInfo * /*cell*/, IdString /*port*/, int /*index*/) const override virtual TimingClockingInfo getPortClockingInfo(const CellInfo * /*cell*/, IdString /*port*/,
int /*index*/) const override
{ {
NPNR_ASSERT_FALSE("unreachable"); NPNR_ASSERT_FALSE("unreachable");
} }

8
common/kernel/command.h
View File

@ -34,7 +34,7 @@ class CommandHandler
{ {
public: public:
CommandHandler(int argc, char **argv); CommandHandler(int argc, char **argv);
virtual ~CommandHandler() { } virtual ~CommandHandler() {}
int exec(); int exec();
void load_json(Context *ctx, std::string filename); void load_json(Context *ctx, std::string filename);
@ -45,9 +45,9 @@ class CommandHandler
virtual void setupArchContext(Context *ctx) = 0; virtual void setupArchContext(Context *ctx) = 0;
virtual std::unique_ptr<Context> createContext(dict<std::string, Property> &values) = 0; virtual std::unique_ptr<Context> createContext(dict<std::string, Property> &values) = 0;
virtual po::options_description getArchOptions() = 0; virtual po::options_description getArchOptions() = 0;
virtual void validate() { } virtual void validate() {}
virtual void customAfterLoad(Context * /*ctx*/) { } virtual void customAfterLoad(Context * /*ctx*/) {}
virtual void customBitstream(Context * /*ctx*/) { } virtual void customBitstream(Context * /*ctx*/) {}
void conflicting_options(const boost::program_options::variables_map &vm, const char *opt1, const char *opt2); void conflicting_options(const boost::program_options::variables_map &vm, const char *opt1, const char *opt2);
private: private:

20
common/kernel/hashlib.h
View File

@ -380,8 +380,8 @@ template <typename K, typename T, typename OPS> class dict
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
using value_type = std::pair<K, T>; using value_type = std::pair<K, T>;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
using pointer = const std::pair<K, T>*; using pointer = const std::pair<K, T> *;
using reference = const std::pair<K, T>&; using reference = const std::pair<K, T> &;
const_iterator() {} const_iterator() {}
const_iterator operator++() const_iterator operator++()
{ {
@ -413,8 +413,8 @@ template <typename K, typename T, typename OPS> class dict
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
using value_type = std::pair<K, T>; using value_type = std::pair<K, T>;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
using pointer = std::pair<K, T>*; using pointer = std::pair<K, T> *;
using reference = std::pair<K, T>&; using reference = std::pair<K, T> &;
iterator() {} iterator() {}
iterator operator++() iterator operator++()
{ {
@ -831,8 +831,8 @@ template <typename K, typename OPS> class pool
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
using value_type = K; using value_type = K;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
using pointer = const K*; using pointer = const K *;
using reference = const K&; using reference = const K &;
const_iterator() {} const_iterator() {}
const_iterator operator++() const_iterator operator++()
{ {
@ -858,8 +858,8 @@ template <typename K, typename OPS> class pool
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
using value_type = K; using value_type = K;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
using pointer = K*; using pointer = K *;
using reference = K&; using reference = K &;
iterator() {} iterator() {}
iterator operator++() iterator operator++()
{ {
@ -1068,8 +1068,8 @@ template <typename K, int offset, typename OPS> class idict
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
using value_type = K; using value_type = K;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
using pointer = const K*; using pointer = const K *;
using reference = const K&; using reference = const K &;
const_iterator() {} const_iterator() {}
const_iterator operator++() const_iterator operator++()
{ {

8
common/kernel/idstringlist.h
View File

@ -35,10 +35,10 @@ struct IdStringList
{ {
SSOArray<IdString, 4> ids; SSOArray<IdString, 4> ids;
IdStringList() : ids(1, IdString()) { } IdStringList() : ids(1, IdString()) {}
explicit IdStringList(size_t n) : ids(n, IdString()) { } explicit IdStringList(size_t n) : ids(n, IdString()) {}
explicit IdStringList(IdString id) : ids(1, id) { } explicit IdStringList(IdString id) : ids(1, id) {}
template <typename Tlist> explicit IdStringList(const Tlist &list) : ids(list) { } template <typename Tlist> explicit IdStringList(const Tlist &list) : ids(list) {}
static IdStringList parse(Context *ctx, const std::string &str); static IdStringList parse(Context *ctx, const std::string &str);
void build_str(const Context *ctx, std::string &str) const; void build_str(const Context *ctx, std::string &str) const;

34
common/kernel/nextpnr_types.h
View File

@ -81,8 +81,8 @@ struct PortRef
struct DelayPair struct DelayPair
{ {
DelayPair(){}; DelayPair(){};
explicit DelayPair(delay_t delay) : min_delay(delay), max_delay(delay) { } explicit DelayPair(delay_t delay) : min_delay(delay), max_delay(delay) {}
DelayPair(delay_t min_delay, delay_t max_delay) : min_delay(min_delay), max_delay(max_delay) { } DelayPair(delay_t min_delay, delay_t max_delay) : min_delay(min_delay), max_delay(max_delay) {}
delay_t minDelay() const { return min_delay; } delay_t minDelay() const { return min_delay; }
delay_t maxDelay() const { return max_delay; } delay_t maxDelay() const { return max_delay; }
delay_t min_delay, max_delay; delay_t min_delay, max_delay;
@ -100,12 +100,14 @@ struct DelayPair
struct DelayQuad struct DelayQuad
{ {
DelayPair rise, fall; DelayPair rise, fall;
DelayQuad() { } DelayQuad() {}
explicit DelayQuad(delay_t delay) : rise(delay), fall(delay) { } explicit DelayQuad(delay_t delay) : rise(delay), fall(delay) {}
DelayQuad(delay_t min_delay, delay_t max_delay) : rise(min_delay, max_delay), fall(min_delay, max_delay) { } DelayQuad(delay_t min_delay, delay_t max_delay) : rise(min_delay, max_delay), fall(min_delay, max_delay) {}
DelayQuad(DelayPair rise, DelayPair fall) : rise(rise), fall(fall) { } DelayQuad(DelayPair rise, DelayPair fall) : rise(rise), fall(fall) {}
DelayQuad(delay_t min_rise, delay_t max_rise, delay_t min_fall, delay_t max_fall) DelayQuad(delay_t min_rise, delay_t max_rise, delay_t min_fall, delay_t max_fall)
: rise(min_rise, max_rise), fall(min_fall, max_fall) { } : rise(min_rise, max_rise), fall(min_fall, max_fall)
{
}
delay_t minRiseDelay() const { return rise.minDelay(); } delay_t minRiseDelay() const { return rise.minDelay(); }
delay_t maxRiseDelay() const { return rise.maxDelay(); } delay_t maxRiseDelay() const { return rise.maxDelay(); }
@ -124,7 +126,7 @@ struct ClockConstraint;
struct NetInfo : ArchNetInfo struct NetInfo : ArchNetInfo
{ {
explicit NetInfo(IdString name) : name(name) { } explicit NetInfo(IdString name) : name(name) {}
IdString name, hierpath; IdString name, hierpath;
int32_t udata = 0; int32_t udata = 0;
@ -203,14 +205,20 @@ struct PseudoCell
struct RegionPlug : PseudoCell struct RegionPlug : PseudoCell
{ {
RegionPlug(Loc loc) : loc(loc) { } // 'loc' is a notional location for the placer only RegionPlug(Loc loc) : loc(loc) {} // 'loc' is a notional location for the placer only
Loc getLocation() const override { return loc; } Loc getLocation() const override { return loc; }
WireId getPortWire(IdString port) const override { return port_wires.at(port); } WireId getPortWire(IdString port) const override { return port_wires.at(port); }
// TODO: partial reconfiguration region timing // TODO: partial reconfiguration region timing
bool getDelay(IdString /*fromPort*/, IdString /*toPort*/, DelayQuad &/*delay*/) const override { return false; } bool getDelay(IdString /*fromPort*/, IdString /*toPort*/, DelayQuad & /*delay*/) const override { return false; }
TimingPortClass getPortTimingClass(IdString /*port*/, int &/*clockInfoCount*/) const override { return TMG_IGNORE; } TimingPortClass getPortTimingClass(IdString /*port*/, int & /*clockInfoCount*/) const override
TimingClockingInfo getPortClockingInfo(IdString /*port*/, int /*index*/) const override { return TimingClockingInfo{}; } {
return TMG_IGNORE;
}
TimingClockingInfo getPortClockingInfo(IdString /*port*/, int /*index*/) const override
{
return TimingClockingInfo{};
}
dict<IdString, WireId> port_wires; dict<IdString, WireId> port_wires;
Loc loc; Loc loc;
@ -218,7 +226,7 @@ struct RegionPlug : PseudoCell
struct CellInfo : ArchCellInfo struct CellInfo : ArchCellInfo
{ {
CellInfo(Context *ctx, IdString name, IdString type) : ctx(ctx), name(name), type(type) { } CellInfo(Context *ctx, IdString name, IdString type) : ctx(ctx), name(name), type(type) {}
Context *ctx = nullptr; Context *ctx = nullptr;
IdString name, type, hierpath; IdString name, type, hierpath;

6
common/kernel/pycontainers.h
View File

@ -290,7 +290,7 @@ template <typename T1, typename T2> struct pair_wrapper
x.second = val.cast<T2>(); x.second = val.cast<T2>();
} }
static int len(T &/*x*/) { return 2; } static int len(T & /*x*/) { return 2; }
static iter_pair<T &, int> iter(T &x) { return iter_pair<T &, int>(boost::ref(x), 0); }; static iter_pair<T &, int> iter(T &x) { return iter_pair<T &, int>(boost::ref(x), 0); };
@ -348,7 +348,7 @@ template <typename T1, typename T2, typename value_conv> struct map_pair_wrapper
x.base.first)); x.base.first));
} }
static int len(wrapped_pair &/*x*/) { return 2; } static int len(wrapped_pair & /*x*/) { return 2; }
static iter_pair<wrapped_pair &, int> iter(wrapped_pair &x) static iter_pair<wrapped_pair &, int> iter(wrapped_pair &x)
{ {
@ -476,7 +476,7 @@ template <typename T1, typename T2> struct map_pair_wrapper_uptr
x.base.first)); x.base.first));
} }
static int len(wrapped_pair &/*x*/) { return 2; } static int len(wrapped_pair & /*x*/) { return 2; }
static iter_pair<wrapped_pair &, int> iter(wrapped_pair &x) static iter_pair<wrapped_pair &, int> iter(wrapped_pair &x)
{ {

2
common/kernel/pywrappers.h
View File

@ -35,7 +35,7 @@ template <typename T> struct ContextualWrapper
Context *ctx; Context *ctx;
T base; T base;
inline ContextualWrapper(Context *c, T x) : ctx(c), base(x) { } inline ContextualWrapper(Context *c, T x) : ctx(c), base(x) {}
inline operator T() { return base; } inline operator T() { return base; }
typedef T base_type; typedef T base_type;

2
common/place/timing_opt.h
View File

@ -24,7 +24,7 @@ NEXTPNR_NAMESPACE_BEGIN
struct TimingOptCfg struct TimingOptCfg
{ {
TimingOptCfg(Context * /*ctx*/) { } TimingOptCfg(Context * /*ctx*/) {}
// The timing optimiser will *only* optimise cells of these types // The timing optimiser will *only* optimise cells of these types
// Normally these would only be logic cells (or tiles if applicable), the algorithm makes little sense // Normally these would only be logic cells (or tiles if applicable), the algorithm makes little sense

6
gui/treemodel.h
View File

@ -103,8 +103,8 @@ class Item
virtual void fetchMore() {} virtual void fetchMore() {}
virtual boost::optional<Item *> getById(IdStringList /*id*/) { return boost::none; } virtual boost::optional<Item *> getById(IdStringList /*id*/) { return boost::none; }
virtual void search(QList<Item *> &/*results*/, QString /*text*/, int /*limit*/) { } virtual void search(QList<Item *> & /*results*/, QString /*text*/, int /*limit*/) {}
virtual void updateElements(Context * /*ctx*/, std::vector<IdStringList> /*elements*/) { } virtual void updateElements(Context * /*ctx*/, std::vector<IdStringList> /*elements*/) {}
virtual ~Item() virtual ~Item()
{ {
@ -147,7 +147,7 @@ class IdList : public Item
public: public:
// Create an IdList at given parent that will contain elements of // Create an IdList at given parent that will contain elements of
// the given type. // the given type.
IdList(ElementType type) : Item("root", nullptr), child_type_(type) { } IdList(ElementType type) : Item("root", nullptr), child_type_(type) {}
// Split a name into alpha/non-alpha parts, which is then used for sorting // Split a name into alpha/non-alpha parts, which is then used for sorting
// of children. // of children.

240
rust/rust.cc
View File

@ -22,42 +22,43 @@
#include "nextpnr.h" #include "nextpnr.h"
namespace { namespace {
USING_NEXTPNR_NAMESPACE; USING_NEXTPNR_NAMESPACE;
template<typename T> static inline uint64_t wrap(const T &thing) noexcept { template <typename T> static inline uint64_t wrap(const T &thing) noexcept
{
static_assert(sizeof(T) <= 8, "T is too big for FFI"); static_assert(sizeof(T) <= 8, "T is too big for FFI");
uint64_t b = 0; uint64_t b = 0;
memcpy(&b, &thing, sizeof(T)); memcpy(&b, &thing, sizeof(T));
return b; return b;
} }
template<typename T> static inline T unwrap(const std::array<uint8_t, 8> &value) noexcept { template <typename T> static inline T unwrap(const std::array<uint8_t, 8> &value) noexcept
{
static_assert(sizeof(T) <= 8, "T is too big for FFI"); static_assert(sizeof(T) <= 8, "T is too big for FFI");
T result{}; T result{};
memcpy(&result, value.data(), sizeof(result)); memcpy(&result, value.data(), sizeof(result));
return result; return result;
} }
template<typename T> static inline T unwrap(const uint64_t value) noexcept { template <typename T> static inline T unwrap(const uint64_t value) noexcept
{
std::array<uint8_t, 8> data{}; std::array<uint8_t, 8> data{};
static_assert(sizeof(value) >= data.size(), "uint64_t is not an appropriate size"); static_assert(sizeof(value) >= data.size(), "uint64_t is not an appropriate size");
memcpy(data.data(), &value, data.size()); memcpy(data.data(), &value, data.size());
return unwrap<T>(data); return unwrap<T>(data);
}
static inline BelId unwrap_bel(const uint64_t bel) noexcept
{ return unwrap<BelId>(bel); }
static inline PipId unwrap_pip(const uint64_t pip) noexcept
{ return unwrap<PipId>(pip); }
static inline WireId unwrap_wire(const uint64_t wire) noexcept
{ return unwrap<WireId>(wire); }
} }
static inline BelId unwrap_bel(const uint64_t bel) noexcept { return unwrap<BelId>(bel); }
static inline PipId unwrap_pip(const uint64_t pip) noexcept { return unwrap<PipId>(pip); }
static inline WireId unwrap_wire(const uint64_t wire) noexcept { return unwrap<WireId>(wire); }
} // namespace
using DownhillIter = decltype(Context(ArchArgs()).getPipsDownhill(WireId()).begin()); using DownhillIter = decltype(Context(ArchArgs()).getPipsDownhill(WireId()).begin());
struct DownhillIterWrapper { struct DownhillIterWrapper
{
DownhillIter current; DownhillIter current;
DownhillIter end; DownhillIter end;
@ -65,7 +66,8 @@ struct DownhillIterWrapper {
}; };
using UphillIter = decltype(Context(ArchArgs()).getPipsUphill(WireId()).begin()); using UphillIter = decltype(Context(ArchArgs()).getPipsUphill(WireId()).begin());
struct UphillIterWrapper { struct UphillIterWrapper
{
UphillIter current; UphillIter current;
UphillIter end; UphillIter end;
@ -73,39 +75,65 @@ struct UphillIterWrapper {
}; };
extern "C" { extern "C" {
USING_NEXTPNR_NAMESPACE; USING_NEXTPNR_NAMESPACE;
void npnr_log_info(const char *string) { log_info("%s", string); } void npnr_log_info(const char *string) { log_info("%s", string); }
void npnr_log_error(const char *string) { log_error("%s", string); } void npnr_log_error(const char *string) { log_error("%s", string); }
uint64_t npnr_belid_null() { return wrap(BelId()); } uint64_t npnr_belid_null() { return wrap(BelId()); }
uint64_t npnr_wireid_null() { return wrap(WireId()); } uint64_t npnr_wireid_null() { return wrap(WireId()); }
uint64_t npnr_pipid_null() { return wrap(PipId()); } uint64_t npnr_pipid_null() { return wrap(PipId()); }
int npnr_context_get_grid_dim_x(const Context *ctx) { return ctx->getGridDimX(); } int npnr_context_get_grid_dim_x(const Context *ctx) { return ctx->getGridDimX(); }
int npnr_context_get_grid_dim_y(const Context *ctx) { return ctx->getGridDimY(); } int npnr_context_get_grid_dim_y(const Context *ctx) { return ctx->getGridDimY(); }
void npnr_context_bind_bel(Context *ctx, uint64_t bel, CellInfo* cell, PlaceStrength strength) { return ctx->bindBel(unwrap_bel(bel), cell, strength); } void npnr_context_bind_bel(Context *ctx, uint64_t bel, CellInfo *cell, PlaceStrength strength)
void npnr_context_unbind_bel(Context *ctx, uint64_t bel) { return ctx->unbindBel(unwrap_bel(bel)); } {
bool npnr_context_check_bel_avail(Context *ctx, uint64_t bel) { return ctx->checkBelAvail(unwrap_bel(bel)); } return ctx->bindBel(unwrap_bel(bel), cell, strength);
void npnr_context_bind_wire(Context *ctx, uint64_t wire, NetInfo* net, PlaceStrength strength) { ctx->bindWire(unwrap_wire(wire), net, strength); } }
void npnr_context_unbind_wire(Context *ctx, uint64_t wire) { ctx->unbindWire(unwrap_wire(wire)); } void npnr_context_unbind_bel(Context *ctx, uint64_t bel) { return ctx->unbindBel(unwrap_bel(bel)); }
void npnr_context_bind_pip(Context *ctx, uint64_t pip, NetInfo* net, PlaceStrength strength) { ctx->bindPip(unwrap_pip(pip), net, strength); } bool npnr_context_check_bel_avail(Context *ctx, uint64_t bel) { return ctx->checkBelAvail(unwrap_bel(bel)); }
void npnr_context_unbind_pip(Context *ctx, uint64_t pip) { ctx->unbindPip(unwrap_pip(pip)); } void npnr_context_bind_wire(Context *ctx, uint64_t wire, NetInfo *net, PlaceStrength strength)
uint64_t npnr_context_get_pip_src_wire(const Context *ctx, uint64_t pip) { return wrap(ctx->getPipSrcWire(unwrap_pip(pip))); } {
uint64_t npnr_context_get_pip_dst_wire(const Context *ctx, uint64_t pip) { return wrap(ctx->getPipDstWire(unwrap_pip(pip))); } ctx->bindWire(unwrap_wire(wire), net, strength);
float npnr_context_estimate_delay(const Context *ctx, uint64_t src, uint64_t dst) { return ctx->getDelayNS(ctx->estimateDelay(unwrap_wire(src), unwrap_wire(dst))); } }
float npnr_context_get_pip_delay(const Context *ctx, uint64_t pip) { return ctx->getDelayNS(ctx->getPipDelay(unwrap_pip(pip)).maxDelay()); } void npnr_context_unbind_wire(Context *ctx, uint64_t wire) { ctx->unbindWire(unwrap_wire(wire)); }
float npnr_context_get_wire_delay(const Context *ctx, uint64_t wire) { return ctx->getDelayNS(ctx->getWireDelay(unwrap_wire(wire)).maxDelay()); } void npnr_context_bind_pip(Context *ctx, uint64_t pip, NetInfo *net, PlaceStrength strength)
float npnr_context_delay_epsilon(const Context *ctx) { return ctx->getDelayNS(ctx->getDelayEpsilon()); } {
Loc npnr_context_get_pip_location(const Context *ctx, uint64_t pip) { return ctx->getPipLocation(unwrap_pip(pip)); } ctx->bindPip(unwrap_pip(pip), net, strength);
bool npnr_context_check_pip_avail_for_net(const Context *ctx, uint64_t pip, NetInfo *net) { return ctx->checkPipAvailForNet(unwrap_pip(pip), net); } }
void npnr_context_unbind_pip(Context *ctx, uint64_t pip) { ctx->unbindPip(unwrap_pip(pip)); }
uint64_t npnr_context_get_pip_src_wire(const Context *ctx, uint64_t pip)
{
return wrap(ctx->getPipSrcWire(unwrap_pip(pip)));
}
uint64_t npnr_context_get_pip_dst_wire(const Context *ctx, uint64_t pip)
{
return wrap(ctx->getPipDstWire(unwrap_pip(pip)));
}
float npnr_context_estimate_delay(const Context *ctx, uint64_t src, uint64_t dst)
{
return ctx->getDelayNS(ctx->estimateDelay(unwrap_wire(src), unwrap_wire(dst)));
}
float npnr_context_get_pip_delay(const Context *ctx, uint64_t pip)
{
return ctx->getDelayNS(ctx->getPipDelay(unwrap_pip(pip)).maxDelay());
}
float npnr_context_get_wire_delay(const Context *ctx, uint64_t wire)
{
return ctx->getDelayNS(ctx->getWireDelay(unwrap_wire(wire)).maxDelay());
}
float npnr_context_delay_epsilon(const Context *ctx) { return ctx->getDelayNS(ctx->getDelayEpsilon()); }
Loc npnr_context_get_pip_location(const Context *ctx, uint64_t pip) { return ctx->getPipLocation(unwrap_pip(pip)); }
bool npnr_context_check_pip_avail_for_net(const Context *ctx, uint64_t pip, NetInfo *net)
{
return ctx->checkPipAvailForNet(unwrap_pip(pip), net);
}
uint64_t npnr_context_get_pips_leak(const Context *const ctx, uint64_t **const pips) { uint64_t npnr_context_get_pips_leak(const Context *const ctx, uint64_t **const pips)
{
const auto ctx_pips{ctx->getPips()}; const auto ctx_pips{ctx->getPips()};
const auto size{ const auto size{std::accumulate(ctx_pips.begin(), ctx_pips.end(), /*initial value*/ size_t{},
std::accumulate(ctx_pips.begin(), ctx_pips.end(), /*initial value*/ size_t{}, [](size_t value, const auto & /*pip*/) { return value + 1U; })};
[](size_t value, const auto &/*pip*/) { return value + 1U; }
)};
*pips = new uint64_t[size]; *pips = new uint64_t[size];
auto idx = 0; auto idx = 0;
for (const auto &pip : ctx_pips) { for (const auto &pip : ctx_pips) {
@ -114,14 +142,13 @@ extern "C" {
} }
// Yes, by never deleting pip_vec, we leak memory. // Yes, by never deleting pip_vec, we leak memory.
return size; return size;
} }
uint64_t npnr_context_get_wires_leak(const Context *const ctx, uint64_t **const wires) { uint64_t npnr_context_get_wires_leak(const Context *const ctx, uint64_t **const wires)
{
const auto ctx_wires{ctx->getWires()}; const auto ctx_wires{ctx->getWires()};
const auto size{ const auto size{std::accumulate(ctx_wires.begin(), ctx_wires.end(), /*initial value*/ size_t{},
std::accumulate(ctx_wires.begin(), ctx_wires.end(), /*initial value*/ size_t{}, [](size_t value, const auto & /*wire*/) { return value + 1U; })};
[](size_t value, const auto &/*wire*/) { return value + 1U; }
)};
*wires = new uint64_t[size]; *wires = new uint64_t[size];
auto idx = 0; auto idx = 0;
for (const auto &wire : ctx_wires) { for (const auto &wire : ctx_wires) {
@ -130,107 +157,100 @@ extern "C" {
} }
// Yes, by never deleting wires, we leak memory. // Yes, by never deleting wires, we leak memory.
return size; return size;
} }
void npnr_context_check(const Context *ctx) { ctx->check(); } void npnr_context_check(const Context *ctx) { ctx->check(); }
bool npnr_context_debug(const Context *ctx) { return ctx->debug; } bool npnr_context_debug(const Context *ctx) { return ctx->debug; }
int npnr_context_id(const Context *ctx, const char *str) { return ctx->id(str).hash(); } int npnr_context_id(const Context *ctx, const char *str) { return ctx->id(str).hash(); }
const char *npnr_context_name_of(const Context *ctx, IdString str) { return ctx->nameOf(str); } const char *npnr_context_name_of(const Context *ctx, IdString str) { return ctx->nameOf(str); }
const char *npnr_context_name_of_pip(const Context *ctx, uint64_t pip) { return ctx->nameOfPip(unwrap_pip(pip)); } const char *npnr_context_name_of_pip(const Context *ctx, uint64_t pip) { return ctx->nameOfPip(unwrap_pip(pip)); }
const char *npnr_context_name_of_wire(const Context *ctx, uint64_t wire) { return ctx->nameOfWire(unwrap_wire(wire)); } const char *npnr_context_name_of_wire(const Context *ctx, uint64_t wire) { return ctx->nameOfWire(unwrap_wire(wire)); }
bool npnr_context_verbose(const Context *ctx) { return ctx->verbose; } bool npnr_context_verbose(const Context *ctx) { return ctx->verbose; }
uint64_t npnr_context_get_netinfo_source_wire(const Context *ctx, const NetInfo *net) { return wrap(ctx->getNetinfoSourceWire(net)); } uint64_t npnr_context_get_netinfo_source_wire(const Context *ctx, const NetInfo *net)
uint64_t npnr_context_get_netinfo_sink_wire(const Context *ctx, const NetInfo *net, const PortRef *sink, uint32_t n) { return wrap(ctx->getNetinfoSinkWire(net, *sink, n)); } {
return wrap(ctx->getNetinfoSourceWire(net));
}
uint64_t npnr_context_get_netinfo_sink_wire(const Context *ctx, const NetInfo *net, const PortRef *sink, uint32_t n)
{
return wrap(ctx->getNetinfoSinkWire(net, *sink, n));
}
uint32_t npnr_context_nets_leak(const Context *ctx, int **names, NetInfo ***nets) { uint32_t npnr_context_nets_leak(const Context *ctx, int **names, NetInfo ***nets)
{
auto size = ctx->nets.size(); auto size = ctx->nets.size();
*names = new int[size]; *names = new int[size];
*nets = new NetInfo*[size]; *nets = new NetInfo *[size];
auto idx = 0; auto idx = 0;
for (auto& item : ctx->nets) { for (auto &item : ctx->nets) {
(*names)[idx] = item.first.index; (*names)[idx] = item.first.index;
(*nets)[idx] = item.second.get(); (*nets)[idx] = item.second.get();
idx++; idx++;
} }
// Yes, by never deleting `names` and `nets` we leak memory. // Yes, by never deleting `names` and `nets` we leak memory.
return size; return size;
} }
DownhillIterWrapper *npnr_context_get_pips_downhill(Context *ctx, uint64_t wire_id) { DownhillIterWrapper *npnr_context_get_pips_downhill(Context *ctx, uint64_t wire_id)
{
auto wire = unwrap_wire(wire_id); auto wire = unwrap_wire(wire_id);
auto range = ctx->getPipsDownhill(wire); auto range = ctx->getPipsDownhill(wire);
return new DownhillIterWrapper(range.begin(), range.end()); return new DownhillIterWrapper(range.begin(), range.end());
} }
void npnr_delete_downhill_iter(DownhillIterWrapper *iter) { void npnr_delete_downhill_iter(DownhillIterWrapper *iter) { delete iter; }
delete iter; UphillIterWrapper *npnr_context_get_pips_uphill(Context *ctx, uint64_t wire_id)
} {
UphillIterWrapper *npnr_context_get_pips_uphill(Context *ctx, uint64_t wire_id) {
auto wire = unwrap_wire(wire_id); auto wire = unwrap_wire(wire_id);
auto range = ctx->getPipsUphill(wire); auto range = ctx->getPipsUphill(wire);
return new UphillIterWrapper(range.begin(), range.end()); return new UphillIterWrapper(range.begin(), range.end());
} }
void npnr_delete_uphill_iter(UphillIterWrapper *iter) { void npnr_delete_uphill_iter(UphillIterWrapper *iter) { delete iter; }
delete iter;
}
PortRef* npnr_netinfo_driver(NetInfo *net) { PortRef *npnr_netinfo_driver(NetInfo *net)
{
if (net == nullptr) { if (net == nullptr) {
return nullptr; return nullptr;
} }
return &net->driver; return &net->driver;
} }
uint32_t npnr_netinfo_users_leak(NetInfo *net, PortRef ***users) { uint32_t npnr_netinfo_users_leak(NetInfo *net, PortRef ***users)
{
auto size = net->users.entries(); auto size = net->users.entries();
*users = new PortRef*[size]; *users = new PortRef *[size];
auto idx = 0; auto idx = 0;
for (auto& item : net->users) { for (auto &item : net->users) {
(*users)[idx] = &item; (*users)[idx] = &item;
idx++; idx++;
} }
// Yes, by not freeing `users`, we leak memory. // Yes, by not freeing `users`, we leak memory.
return size; return size;
} }
#ifdef ARCH_ECP5 #ifdef ARCH_ECP5
bool npnr_netinfo_is_global(NetInfo *net) { return net->is_global; } bool npnr_netinfo_is_global(NetInfo *net) { return net->is_global; }
#else #else
bool npnr_netinfo_is_global(NetInfo * /*net*/) { return false; } bool npnr_netinfo_is_global(NetInfo * /*net*/) { return false; }
#endif #endif
int32_t npnr_netinfo_udata(NetInfo *net) { return net->udata; } int32_t npnr_netinfo_udata(NetInfo *net) { return net->udata; }
void npnr_netinfo_udata_set(NetInfo *net, int32_t value) { net->udata = value; } void npnr_netinfo_udata_set(NetInfo *net, int32_t value) { net->udata = value; }
CellInfo* npnr_portref_cell(const PortRef *port) { return port->cell; } CellInfo *npnr_portref_cell(const PortRef *port) { return port->cell; }
Loc npnr_cellinfo_get_location(const CellInfo *info) { return info->getLocation(); } Loc npnr_cellinfo_get_location(const CellInfo *info) { return info->getLocation(); }
void npnr_inc_downhill_iter(DownhillIterWrapper *iter) { void npnr_inc_downhill_iter(DownhillIterWrapper *iter) { ++iter->current; }
++iter->current; uint64_t npnr_deref_downhill_iter(DownhillIterWrapper *iter) { return wrap(*iter->current); }
} bool npnr_is_downhill_iter_done(DownhillIterWrapper *iter) { return !(iter->current != iter->end); }
uint64_t npnr_deref_downhill_iter(DownhillIterWrapper *iter) { void npnr_inc_uphill_iter(UphillIterWrapper *iter) { ++iter->current; }
return wrap(*iter->current); uint64_t npnr_deref_uphill_iter(UphillIterWrapper *iter) { return wrap(*iter->current); }
} bool npnr_is_uphill_iter_done(UphillIterWrapper *iter) { return !(iter->current != iter->end); }
bool npnr_is_downhill_iter_done(DownhillIterWrapper *iter) {
return !(iter->current != iter->end);
}
void npnr_inc_uphill_iter(UphillIterWrapper *iter) {
++iter->current;
}
uint64_t npnr_deref_uphill_iter(UphillIterWrapper *iter) {
return wrap(*iter->current);
}
bool npnr_is_uphill_iter_done(UphillIterWrapper *iter) {
return !(iter->current != iter->end);
}
void rust_example_printnets(Context *ctx); void rust_example_printnets(Context *ctx);
} }
NEXTPNR_NAMESPACE_BEGIN NEXTPNR_NAMESPACE_BEGIN
void example_printnets(Context *ctx) { void example_printnets(Context *ctx) { rust_example_printnets(ctx); }
rust_example_printnets(ctx);
}
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END

2
rust/rust.h
View File

@ -25,7 +25,7 @@
#include "nextpnr.h" #include "nextpnr.h"
NEXTPNR_NAMESPACE_BEGIN NEXTPNR_NAMESPACE_BEGIN
void example_printnets(Context* ctx); void example_printnets(Context *ctx);
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END