Run "make clangformat".

Signed-off-by: Keith Rothman <537074+litghost@users.noreply.github.com>

common/arch_pybindings_shared.h

@@ -112,17 +112,17 @@ fn_wrapper_2a_v<Context, decltype(&Context::writeSVG), &Context::writeSVG, pass_
                 pass_through<std::string>>::def_wrap(ctx_cls, "writeSVG");
 
 // const\_range\<BelBucketId\> getBelBuckets() const
-fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets, wrap_context<BelBucketRange>>::def_wrap(ctx_cls,
+fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets,
-                                                                                                         "getBelBuckets");
+              wrap_context<BelBucketRange>>::def_wrap(ctx_cls, "getBelBuckets");
 // BelBucketId getBelBucketForBel(BelId bel) const
 fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel), &Context::getBelBucketForBel, conv_to_str<BelBucketId>,
               conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
 // BelBucketId getBelBucketForCellType(IdString cell\_type) const
-fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType, conv_to_str<BelBucketId>,
+fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType,
-              conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
+              conv_to_str<BelBucketId>, conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
 // const\_range\<BelId\> getBelsInBucket(BelBucketId bucket) const
-fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket, wrap_context<BelRangeForBelBucket>,
+fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket,
-              conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
+              wrap_context<BelRangeForBelBucket>, conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
 // bool isValidBelForCellType(IdString cell\_type, BelId bel) const
 fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType), &Context::isValidBelForCellType, pass_through<bool>,
               conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(ctx_cls, "isValidBelForCellType");

common/archcheck.cc

@@ -53,7 +53,7 @@ void archcheck_names(const Context *ctx)
     }
 
     log_info("Checking bucket names..\n");
-    for(BelBucketId bucket : ctx->getBelBuckets()) {
+    for (BelBucketId bucket : ctx->getBelBuckets()) {
         IdString name = ctx->getBelBucketName(bucket);
         BelBucketId bucket2 = ctx->getBelBucketByName(name);
         if (bucket != bucket2) {
@@ -204,12 +204,12 @@ void archcheck_buckets(const Context *ctx)
     // BEL buckets should be subsets of BELs that form an exact cover.
     // In particular that means cell types in a bucket should only be
     // placable in that bucket.
-    for(BelBucketId bucket : ctx->getBelBuckets()) {
+    for (BelBucketId bucket : ctx->getBelBuckets()) {
 
         // Find out which cell types are in this bucket.
         std::unordered_set<IdString> cell_types_in_bucket;
-        for(IdString cell_type : ctx->getCellTypes()) {
+        for (IdString cell_type : ctx->getCellTypes()) {
-            if(ctx->getBelBucketForCellType(cell_type) == bucket) {
+            if (ctx->getBelBucketForCellType(cell_type) == bucket) {
                 cell_types_in_bucket.insert(cell_type);
             }
         }
@@ -219,7 +219,7 @@ void archcheck_buckets(const Context *ctx)
         std::unordered_set<IdString> cell_types_unused;
 
         std::unordered_set<BelId> bels_in_bucket;
-        for(BelId bel : ctx->getBelsInBucket(bucket)) {
+        for (BelId bel : ctx->getBelsInBucket(bucket)) {
             BelBucketId bucket2 = ctx->getBelBucketForBel(bel);
             log_assert(bucket == bucket2);
 
@@ -227,9 +227,9 @@ void archcheck_buckets(const Context *ctx)
 
             // Check to see if a cell type not in this bucket can be
             // placed at a BEL in this bucket.
-            for(IdString cell_type : ctx->getCellTypes()) {
+            for (IdString cell_type : ctx->getCellTypes()) {
-                if(ctx->getBelBucketForCellType(cell_type) == bucket) {
+                if (ctx->getBelBucketForCellType(cell_type) == bucket) {
-                    if(ctx->isValidBelForCellType(cell_type, bel)) {
+                    if (ctx->isValidBelForCellType(cell_type, bel)) {
                         cell_types_unused.erase(cell_type);
                     }
                 } else {
@@ -240,8 +240,8 @@ void archcheck_buckets(const Context *ctx)
 
         // Verify that any BEL not in this bucket reports a different
         // bucket.
-        for(BelId bel : ctx->getBels()) {
+        for (BelId bel : ctx->getBels()) {
-            if(ctx->getBelBucketForBel(bel) != bucket) {
+            if (ctx->getBelBucketForBel(bel) != bucket) {
                 log_assert(bels_in_bucket.count(bel) == 0);
             }
         }

common/fast_bels.h

@@ -20,24 +20,30 @@
 
 #pragma once
 
-#include "nextpnr.h"
 #include <cstddef>
+#include "nextpnr.h"
 
 NEXTPNR_NAMESPACE_BEGIN
 
 // FastBels is a lookup class that provides a fast lookup for finding BELs
 // that support a given cell type.
-struct FastBels {
+struct FastBels
-    struct TypeData {
+{
+    struct TypeData
+    {
         size_t type_index;
         int number_of_possible_bels;
     };
 
-    FastBels(Context *ctx, bool check_bel_available, int minBelsForGridPick) : ctx(ctx), check_bel_available(check_bel_available), minBelsForGridPick(minBelsForGridPick) {}
+    FastBels(Context *ctx, bool check_bel_available, int minBelsForGridPick)
+            : ctx(ctx), check_bel_available(check_bel_available), minBelsForGridPick(minBelsForGridPick)
+    {
+    }
 
-    void addCellType(IdString cell_type) {
+    void addCellType(IdString cell_type)
+    {
         auto iter = cell_types.find(cell_type);
-        if(iter != cell_types.end()) {
+        if (iter != cell_types.end()) {
             // This cell type has already been added to the fast BEL lookup.
             return;
         }
@@ -50,7 +56,7 @@ struct FastBels {
         auto &bel_data = fast_bels_by_cell_type.at(type_idx);
 
         for (auto bel : ctx->getBels()) {
-            if(!ctx->isValidBelForCellType(cell_type, bel)) {
+            if (!ctx->isValidBelForCellType(cell_type, bel)) {
                 continue;
             }
 
@@ -58,11 +64,11 @@ struct FastBels {
         }
 
         for (auto bel : ctx->getBels()) {
-            if(check_bel_available && !ctx->checkBelAvail(bel)) {
+            if (check_bel_available && !ctx->checkBelAvail(bel)) {
                 continue;
             }
 
-            if(!ctx->isValidBelForCellType(cell_type, bel)) {
+            if (!ctx->isValidBelForCellType(cell_type, bel)) {
                 continue;
             }
 
@@ -83,9 +89,10 @@ struct FastBels {
         }
     }
 
-    void addBelBucket(BelBucketId partition) {
+    void addBelBucket(BelBucketId partition)
+    {
         auto iter = partition_types.find(partition);
-        if(iter != partition_types.end()) {
+        if (iter != partition_types.end()) {
             // This partition has already been added to the fast BEL lookup.
             return;
         }
@@ -98,7 +105,7 @@ struct FastBels {
         auto &bel_data = fast_bels_by_partition_type.at(type_idx);
 
         for (auto bel : ctx->getBels()) {
-            if(ctx->getBelBucketForBel(bel) != partition) {
+            if (ctx->getBelBucketForBel(bel) != partition) {
                 continue;
             }
 
@@ -106,11 +113,11 @@ struct FastBels {
         }
 
         for (auto bel : ctx->getBels()) {
-            if(check_bel_available && !ctx->checkBelAvail(bel)) {
+            if (check_bel_available && !ctx->checkBelAvail(bel)) {
                 continue;
             }
 
-            if(ctx->getBelBucketForBel(bel) != partition) {
+            if (ctx->getBelBucketForBel(bel) != partition) {
                 continue;
             }
 
@@ -133,9 +140,10 @@ struct FastBels {
 
     typedef std::vector<std::vector<std::vector<BelId>>> FastBelsData;
 
-    int getBelsForCellType(IdString cell_type, FastBelsData **data) {
+    int getBelsForCellType(IdString cell_type, FastBelsData **data)
+    {
         auto iter = cell_types.find(cell_type);
-        if(iter == cell_types.end()) {
+        if (iter == cell_types.end()) {
             addCellType(cell_type);
             iter = cell_types.find(cell_type);
             NPNR_ASSERT(iter != cell_types.end());
@@ -147,9 +155,10 @@ struct FastBels {
         return cell_type_data.number_of_possible_bels;
     }
 
-    size_t getBelsForBelBucket(BelBucketId partition, FastBelsData **data) {
+    size_t getBelsForBelBucket(BelBucketId partition, FastBelsData **data)
+    {
         auto iter = partition_types.find(partition);
-        if(iter == partition_types.end()) {
+        if (iter == partition_types.end()) {
             addBelBucket(partition);
             iter = partition_types.find(partition);
             NPNR_ASSERT(iter != partition_types.end());

common/place_common.cc

@@ -118,7 +118,8 @@ bool place_single_cell(Context *ctx, CellInfo *cell, bool require_legality)
         }
         IdString targetType = cell->type;
         for (auto bel : ctx->getBels()) {
-            if (ctx->isValidBelForCellType(targetType, bel) && (!require_legality || ctx->isValidBelForCell(cell, bel))) {
+            if (ctx->isValidBelForCellType(targetType, bel) &&
+                (!require_legality || ctx->isValidBelForCell(cell, bel))) {
                 if (ctx->checkBelAvail(bel)) {
                     wirelen_t wirelen = get_cell_metric_at_bel(ctx, cell, bel, MetricType::COST);
                     if (iters >= 4)

common/placer1.cc

@@ -39,11 +39,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vector>
+#include "fast_bels.h"
 #include "log.h"
 #include "place_common.h"
 #include "timing.h"
 #include "util.h"
-#include "fast_bels.h"
 
 namespace std {
 template <> struct hash<std::pair<NEXTPNR_NAMESPACE_PREFIX IdString, std::size_t>>
@@ -76,7 +76,8 @@ class SAPlacer
     };
 
   public:
-    SAPlacer(Context *ctx, Placer1Cfg cfg) : ctx(ctx), fast_bels(ctx, /*check_bel_available=*/false, cfg.minBelsForGridPick), cfg(cfg)
+    SAPlacer(Context *ctx, Placer1Cfg cfg)
+            : ctx(ctx), fast_bels(ctx, /*check_bel_available=*/false, cfg.minBelsForGridPick), cfg(cfg)
     {
         for (auto bel : ctx->getBels()) {
             Loc loc = ctx->getBelLocation(bel);
@@ -91,7 +92,7 @@ class SAPlacer
             cell_types_in_use.insert(cell_type);
         }
 
-        for(auto cell_type : cell_types_in_use) {
+        for (auto cell_type : cell_types_in_use) {
             fast_bels.addCellType(cell_type);
         }
 

common/placer_heap.cc

@@ -44,13 +44,13 @@
 #include <queue>
 #include <tuple>
 #include <unordered_map>
+#include "fast_bels.h"
 #include "log.h"
 #include "nextpnr.h"
 #include "place_common.h"
 #include "placer1.h"
 #include "timing.h"
 #include "util.h"
-#include "fast_bels.h"
 
 NEXTPNR_NAMESPACE_BEGIN
 
@@ -138,7 +138,10 @@ template <typename T> struct EquationSystem
 class HeAPPlacer
 {
   public:
-    HeAPPlacer(Context *ctx, PlacerHeapCfg cfg) : ctx(ctx), cfg(cfg), fast_bels(ctx, /*check_bel_available=*/true, -1) { Eigen::initParallel(); }
+    HeAPPlacer(Context *ctx, PlacerHeapCfg cfg) : ctx(ctx), cfg(cfg), fast_bels(ctx, /*check_bel_available=*/true, -1)
+    {
+        Eigen::initParallel();
+    }
 
     bool place()
     {
@@ -429,10 +432,10 @@ class HeAPPlacer
             buckets_in_use.insert(bucket);
         }
 
-        for(auto cell_type : cell_types_in_use) {
+        for (auto cell_type : cell_types_in_use) {
             fast_bels.addCellType(cell_type);
         }
-        for(auto bucket : buckets_in_use) {
+        for (auto bucket : buckets_in_use) {
             fast_bels.addBelBucket(bucket);
         }
 
@@ -500,8 +503,8 @@ class HeAPPlacer
                 continue;
             }
 
-            for(auto cell_type : cell_types) {
+            for (auto cell_type : cell_types) {
-                if(ctx->isValidBelForCellType(cell_type, bel)) {
+                if (ctx->isValidBelForCellType(cell_type, bel)) {
                     available_bels[cell_type].push_back(bel);
                 }
             }
@@ -532,23 +535,21 @@ class HeAPPlacer
                     // all.
                     if (!available_bels.count(ci->type)) {
                         log_error("Unable to place cell '%s', no BELs remaining to implement cell type '%s'\n",
-                                ci->name.c_str(ctx),
+                                  ci->name.c_str(ctx), ci->type.c_str(ctx));
-                                ci->type.c_str(ctx));
                     }
 
                     // Find an unused BEL from bels_for_cell_type.
                     auto &bels_for_cell_type = available_bels.at(ci->type);
                     BelId bel;
-                    while(true) {
+                    while (true) {
                         if (bels_for_cell_type.empty()) {
                             log_error("Unable to place cell '%s', no BELs remaining to implement cell type '%s'\n",
-                                    ci->name.c_str(ctx),
+                                      ci->name.c_str(ctx), ci->type.c_str(ctx));
-                                    ci->type.c_str(ctx));
                         }
 
                         BelId candidate_bel = bels_for_cell_type.back();
                         bels_for_cell_type.pop_back();
-                        if(bels_used.count(candidate_bel)) {
+                        if (bels_used.count(candidate_bel)) {
                             // candidate_bel has already been used by another
                             // cell type, skip it.
                             continue;
@@ -1202,13 +1203,12 @@ class HeAPPlacer
             return int(fb.at(type)->at(x).at(y).size());
         }
 
-        bool is_cell_fixed(const CellInfo & cell) const {
+        bool is_cell_fixed(const CellInfo &cell) const
+        {
             return buckets.count(ctx->getBelBucketForCellType(cell.type)) == 0;
         }
 
-        size_t cell_index(const CellInfo & cell) const {
+        size_t cell_index(const CellInfo &cell) const { return type_index.at(ctx->getBelBucketForCellType(cell.type)); }
-            return type_index.at(ctx->getBelBucketForCellType(cell.type));
-        }
 
         void init()
         {
@@ -1239,9 +1239,9 @@ class HeAPPlacer
 
             for (auto &cell_loc : p->cell_locs) {
                 IdString cell_name = cell_loc.first;
-                const CellInfo & cell = *ctx->cells.at(cell_name);
+                const CellInfo &cell = *ctx->cells.at(cell_name);
-                const CellLocation & loc = cell_loc.second;
+                const CellLocation &loc = cell_loc.second;
-                if(is_cell_fixed(cell)) {
+                if (is_cell_fixed(cell)) {
                     continue;
                 }
 
@@ -1261,9 +1261,9 @@ class HeAPPlacer
 
             for (auto &cell_loc : p->cell_locs) {
                 IdString cell_name = cell_loc.first;
-                const CellInfo & cell = *ctx->cells.at(cell_name);
+                const CellInfo &cell = *ctx->cells.at(cell_name);
-                const CellLocation & loc = cell_loc.second;
+                const CellLocation &loc = cell_loc.second;
-                if(is_cell_fixed(cell)) {
+                if (is_cell_fixed(cell)) {
                     continue;
                 }
 
@@ -1285,7 +1285,7 @@ class HeAPPlacer
             }
 
             for (auto cell : p->solve_cells) {
-                if(is_cell_fixed(*cell)) {
+                if (is_cell_fixed(*cell)) {
                     continue;
                 }
 
@@ -1476,8 +1476,7 @@ class HeAPPlacer
                             if (reg.cells > reg.bels) {
                                 IdString bucket_name = ctx->getBelBucketName(bucket);
                                 log_error("Failed to expand region (%d, %d) |_> (%d, %d) of %d %ss\n", reg.x0, reg.y0,
-                                          reg.x1, reg.y1, reg.cells.at(type_index.at(bucket)),
+                                          reg.x1, reg.y1, reg.cells.at(type_index.at(bucket)), bucket_name.c_str(ctx));
-                                          bucket_name.c_str(ctx));
                             }
                         }
                         break;

ecp5/arch.cc

@@ -117,11 +117,11 @@ Arch::Arch(ArchArgs args) : args(args)
     bel_to_cell.resize(chip_info->height * chip_info->width * max_loc_bels, nullptr);
 
     std::unordered_set<IdString> bel_types;
-    for(BelId bel : getBels()) {
+    for (BelId bel : getBels()) {
         bel_types.insert(getBelType(bel));
     }
 
-    for(IdString bel_type : bel_types) {
+    for (IdString bel_type : bel_types) {
         cell_types.push_back(bel_type);
 
         BelBucketId bucket;

ecp5/arch.h

@@ -950,44 +950,40 @@ struct Arch : BaseCtx
 
     // -------------------------------------------------
     // Placement validity checks
-    bool isValidBelForCellType(IdString cell_type, BelId bel) const {
+    bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
-        return cell_type == getBelType(bel);
-    }
 
-    const std::vector<IdString> &getCellTypes() const {
+    const std::vector<IdString> &getCellTypes() const { return cell_types; }
-        return cell_types;
-    }
 
-    std::vector<BelBucketId> getBelBuckets() const {
+    std::vector<BelBucketId> getBelBuckets() const { return buckets; }
-        return buckets;
-    }
 
-    IdString getBelBucketName(BelBucketId bucket) const {
+    IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
-        return bucket.name;
-    }
 
-    BelBucketId getBelBucketByName(IdString name) const {
+    BelBucketId getBelBucketByName(IdString name) const
+    {
         BelBucketId bucket;
         bucket.name = name;
         return bucket;
     }
 
-    BelBucketId getBelBucketForBel(BelId bel) const {
+    BelBucketId getBelBucketForBel(BelId bel) const
+    {
         BelBucketId bucket;
         bucket.name = getBelType(bel);
         return bucket;
     }
 
-    BelBucketId getBelBucketForCellType(IdString cell_type) const {
+    BelBucketId getBelBucketForCellType(IdString cell_type) const
+    {
         BelBucketId bucket;
         bucket.name = cell_type;
         return bucket;
     }
 
-    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
+    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
+    {
         std::vector<BelId> bels;
-        for(BelId bel : getBels()) {
+        for (BelId bel : getBels()) {
-            if(getBelType(bel) == bucket.name) {
+            if (getBelType(bel) == bucket.name) {
                 bels.push_back(bel);
             }
         }

ecp5/arch_pybindings.cc

@@ -59,8 +59,8 @@ void arch_wrap_python(py::module &m)
     typedef const PipRange UphillPipRange;
     typedef const PipRange DownhillPipRange;
 
-    typedef const std::vector<BelBucketId> & BelBucketRange;
+    typedef const std::vector<BelBucketId> &BelBucketRange;
-    typedef const std::vector<BelId> & BelRangeForBelBucket;
+    typedef const std::vector<BelId> &BelRangeForBelBucket;
 #include "arch_pybindings_shared.h"
 
     WRAP_RANGE(m, Bel, conv_to_str<BelId>);

ecp5/archdefs.h

@@ -126,15 +126,13 @@ struct PipId
     }
 };
 
-struct BelBucketId {
+struct BelBucketId
+{
     IdString name;
 
     bool operator==(const BelBucketId &other) const { return (name == other.name); }
     bool operator!=(const BelBucketId &other) const { return (name != other.name); }
-    bool operator<(const BelBucketId &other) const
+    bool operator<(const BelBucketId &other) const { return name < other.name; }
-    {
-        return name < other.name;
-    }
 };
 
 struct GroupId

generic/arch.h

@@ -271,40 +271,32 @@ struct Arch : BaseCtx
     bool place();
     bool route();
 
-    std::vector<IdString> getCellTypes() const {
+    std::vector<IdString> getCellTypes() const
+    {
         std::vector<IdString> cell_types;
         cell_types.reserve(bels.size());
-        for(auto bel : bels) {
+        for (auto bel : bels) {
             cell_types.push_back(bel.first);
         }
 
         return cell_types;
     }
 
-    std::vector<BelBucketId> getBelBuckets() const {
+    std::vector<BelBucketId> getBelBuckets() const { return getCellTypes(); }
-        return getCellTypes();
-    }
 
-    IdString getBelBucketName(BelBucketId bucket) const {
+    IdString getBelBucketName(BelBucketId bucket) const { return bucket; }
-        return bucket;
-    }
 
-    BelBucketId getBelBucketByName(IdString bucket) const {
+    BelBucketId getBelBucketByName(IdString bucket) const { return bucket; }
-        return bucket;
-    }
 
-    BelBucketId getBelBucketForBel(BelId bel) const {
+    BelBucketId getBelBucketForBel(BelId bel) const { return getBelType(bel); }
-        return getBelType(bel);
-    }
 
-    BelBucketId getBelBucketForCellType(IdString cell_type) const {
+    BelBucketId getBelBucketForCellType(IdString cell_type) const { return cell_type; }
-        return cell_type;
-    }
 
-    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
+    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
+    {
         std::vector<BelId> bels;
-        for(BelId bel : getBels()) {
+        for (BelId bel : getBels()) {
-            if(bucket == getBelBucketForBel(bel)) {
+            if (bucket == getBelBucketForBel(bel)) {
                 bels.push_back(bel);
             }
         }
@@ -323,9 +315,7 @@ struct Arch : BaseCtx
     // Get the TimingClockingInfo of a port
     TimingClockingInfo getPortClockingInfo(const CellInfo *cell, IdString port, int index) const;
 
-    bool isValidBelForCellType(IdString cell_type, BelId bel) const {
+    bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
-        return cell_type == getBelType(bel);
-    }
     bool isValidBelForCell(CellInfo *cell, BelId bel) const;
     bool isBelLocationValid(BelId bel) const;
 

generic/arch_pybindings.cc

@@ -227,30 +227,26 @@ void arch_wrap_python(py::module &m)
                                                        "clock"_a, "clktoq"_a);
 
     // const\_range\<BelBucketId\> getBelBuckets() const
-    fn_wrapper_0a<Context, decltype(&Context::getBelBuckets),
+    fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets,
-        &Context::getBelBuckets,
+                  wrap_context<const std::vector<BelBucketId> &>>::def_wrap(ctx_cls, "getBelBuckets");
-        wrap_context<const std::vector<BelBucketId> &>>::def_wrap(ctx_cls, "getBelBuckets");
 
     // BelBucketId getBelBucketForBel(BelId bel) const
-    fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel),
+    fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel), &Context::getBelBucketForBel,
-        &Context::getBelBucketForBel, conv_to_str<BelBucketId>,
+                  conv_to_str<BelBucketId>, conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
-        conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
 
     // BelBucketId getBelBucketForCellType(IdString cell\_type) const
-    fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType),
+    fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType,
-        &Context::getBelBucketForCellType, conv_to_str<BelBucketId>,
+                  conv_to_str<BelBucketId>, conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
-        conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
 
     // const\_range\<BelId\> getBelsInBucket(BelBucketId bucket) const
-    fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket),
+    fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket,
-        &Context::getBelsInBucket, wrap_context<const std::vector<BelId> &>,
+                  wrap_context<const std::vector<BelId> &>, conv_from_str<BelBucketId>>::def_wrap(ctx_cls,
-        conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
+                                                                                                  "getBelsInBucket");
 
     // bool isValidBelForCellType(IdString cell\_type, BelId bel) const
-    fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType),
+    fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType), &Context::isValidBelForCellType,
-        &Context::isValidBelForCellType, pass_through<bool>,
+                  pass_through<bool>, conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(ctx_cls,
-        conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(
+                                                                                               "isValidBelForCellType");
-                ctx_cls, "isValidBelForCellType");
 
     WRAP_MAP_UPTR(m, CellMap, "IdCellMap");
     WRAP_MAP_UPTR(m, NetMap, "IdNetMap");

gowin/arch.cc

@@ -741,11 +741,11 @@ Arch::Arch(ArchArgs args) : args(args)
     decal_graphics[IdString()];
 
     std::unordered_set<IdString> bel_types;
-    for(BelId bel : getBels()) {
+    for (BelId bel : getBels()) {
         bel_types.insert(getBelType(bel));
     }
 
-    for(IdString bel_type : bel_types) {
+    for (IdString bel_type : bel_types) {
         cell_types.push_back(bel_type);
     }
 }

gowin/arch.h

@@ -422,38 +422,25 @@ struct Arch : BaseCtx
     // Get the TimingClockingInfo of a port
     TimingClockingInfo getPortClockingInfo(const CellInfo *cell, IdString port, int index) const;
 
-    bool isValidBelForCellType(IdString cell_type, BelId bel) const {
+    bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
-        return cell_type == getBelType(bel);
-    }
 
-    const std::vector<IdString> &getCellTypes() const {
+    const std::vector<IdString> &getCellTypes() const { return cell_types; }
-        return cell_types;
-    }
 
-    std::vector<BelBucketId> getBelBuckets() const {
+    std::vector<BelBucketId> getBelBuckets() const { return cell_types; }
-        return cell_types;
-    }
 
-    IdString getBelBucketName(BelBucketId bucket) const {
+    IdString getBelBucketName(BelBucketId bucket) const { return bucket; }
-        return bucket;
-    }
 
-    BelBucketId getBelBucketByName(IdString name) const {
+    BelBucketId getBelBucketByName(IdString name) const { return name; }
-        return name;
-    }
 
-    BelBucketId getBelBucketForBel(BelId bel) const {
+    BelBucketId getBelBucketForBel(BelId bel) const { return getBelType(bel); }
-        return getBelType(bel);
-    }
 
-    BelBucketId getBelBucketForCellType(IdString cell_type) const {
+    BelBucketId getBelBucketForCellType(IdString cell_type) const { return cell_type; }
-        return cell_type;
-    }
 
-    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
+    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
+    {
         std::vector<BelId> bels;
-        for(BelId bel : getBels()) {
+        for (BelId bel : getBels()) {
-            if(getBelType(bel) == bucket) {
+            if (getBelType(bel) == bucket) {
                 bels.push_back(bel);
             }
         }

ice40/arch.cc

@@ -117,11 +117,11 @@ Arch::Arch(ArchArgs args) : args(args)
     switches_locked.resize(chip_info->num_switches);
 
     std::unordered_set<IdString> bel_types;
-    for(BelId bel : getBels()) {
+    for (BelId bel : getBels()) {
         bel_types.insert(getBelType(bel));
     }
 
-    for(IdString bel_type : bel_types) {
+    for (IdString bel_type : bel_types) {
         cell_types.push_back(bel_type);
 
         BelBucketId bucket;

ice40/arch.h

@@ -822,44 +822,40 @@ struct Arch : BaseCtx
     // implemented in arch_place.cc)
 
     // Whether this cell type can be placed at this BEL.
-    bool isValidBelForCellType(IdString cell_type, BelId bel) const {
+    bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
-        return cell_type == getBelType(bel);
-    }
 
-    const std::vector<IdString> &getCellTypes() const {
+    const std::vector<IdString> &getCellTypes() const { return cell_types; }
-        return cell_types;
-    }
 
-    std::vector<BelBucketId> getBelBuckets() const {
+    std::vector<BelBucketId> getBelBuckets() const { return buckets; }
-        return buckets;
-    }
 
-    IdString getBelBucketName(BelBucketId bucket) const {
+    IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
-        return bucket.name;
-    }
 
-    BelBucketId getBelBucketByName(IdString name) const {
+    BelBucketId getBelBucketByName(IdString name) const
+    {
         BelBucketId bucket;
         bucket.name = name;
         return bucket;
     }
 
-    BelBucketId getBelBucketForBel(BelId bel) const {
+    BelBucketId getBelBucketForBel(BelId bel) const
+    {
         BelBucketId bucket;
         bucket.name = getBelType(bel);
         return bucket;
     }
 
-    BelBucketId getBelBucketForCellType(IdString cell_type) const {
+    BelBucketId getBelBucketForCellType(IdString cell_type) const
+    {
         BelBucketId bucket;
         bucket.name = cell_type;
         return bucket;
     }
 
-    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
+    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
+    {
         std::vector<BelId> bels;
-        for(BelId bel : getBels()) {
+        for (BelId bel : getBels()) {
-            if(getBelType(bel) == bucket.name) {
+            if (getBelType(bel) == bucket.name) {
                 bels.push_back(bel);
             }
         }

ice40/arch_pybindings.cc

@@ -75,8 +75,8 @@ void arch_wrap_python(py::module &m)
     typedef const PipRange UphillPipRange;
     typedef const PipRange DownhillPipRange;
 
-    typedef const std::vector<BelBucketId> & BelBucketRange;
+    typedef const std::vector<BelBucketId> &BelBucketRange;
-    typedef const std::vector<BelId> & BelRangeForBelBucket;
+    typedef const std::vector<BelId> &BelRangeForBelBucket;
 #include "arch_pybindings_shared.h"
 
     WRAP_RANGE(m, Bel, conv_to_str<BelId>);
@@ -85,7 +85,6 @@ void arch_wrap_python(py::module &m)
     WRAP_RANGE(m, Pip, conv_to_str<PipId>);
     WRAP_RANGE(m, BelPin, wrap_context<BelPin>);
 
-
     WRAP_MAP_UPTR(m, CellMap, "IdCellMap");
     WRAP_MAP_UPTR(m, NetMap, "IdNetMap");
     WRAP_MAP(m, HierarchyMap, wrap_context<HierarchicalCell &>, "HierarchyMap");

ice40/archdefs.h

@@ -170,15 +170,13 @@ struct ArchCellInfo
     };
 };
 
-struct BelBucketId {
+struct BelBucketId
+{
     IdString name;
 
     bool operator==(const BelBucketId &other) const { return (name == other.name); }
     bool operator!=(const BelBucketId &other) const { return (name != other.name); }
-    bool operator<(const BelBucketId &other) const
+    bool operator<(const BelBucketId &other) const { return name < other.name; }
-    {
-        return name < other.name;
-    }
 };
 
 NEXTPNR_NAMESPACE_END

nexus/arch.cc

@@ -173,11 +173,11 @@ Arch::Arch(ArchArgs args) : args(args)
         log_error("Unknown speed grade '%s'.\n", speed.c_str());
 
     std::unordered_set<IdString> bel_types;
-    for(BelId bel : getBels()) {
+    for (BelId bel : getBels()) {
         bel_types.insert(getBelType(bel));
     }
 
-    for(IdString bel_type : bel_types) {
+    for (IdString bel_type : bel_types) {
         cell_types.push_back(bel_type);
 
         BelBucketId bucket;

nexus/arch.h

@@ -1336,44 +1336,40 @@ struct Arch : BaseCtx
     // implemented in arch_place.cc)
 
     // Whether this cell type can be placed at this BEL.
-    bool isValidBelForCellType(IdString cell_type, BelId bel) const {
+    bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
-        return cell_type == getBelType(bel);
-    }
 
-    const std::vector<IdString> &getCellTypes() const {
+    const std::vector<IdString> &getCellTypes() const { return cell_types; }
-        return cell_types;
-    }
 
-    std::vector<BelBucketId> getBelBuckets() const {
+    std::vector<BelBucketId> getBelBuckets() const { return buckets; }
-        return buckets;
-    }
 
-    IdString getBelBucketName(BelBucketId bucket) const {
+    IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
-        return bucket.name;
-    }
 
-    BelBucketId getBelBucketByName(IdString name) const {
+    BelBucketId getBelBucketByName(IdString name) const
+    {
         BelBucketId bucket;
         bucket.name = name;
         return bucket;
     }
 
-    BelBucketId getBelBucketForBel(BelId bel) const {
+    BelBucketId getBelBucketForBel(BelId bel) const
+    {
         BelBucketId bucket;
         bucket.name = getBelType(bel);
         return bucket;
     }
 
-    BelBucketId getBelBucketForCellType(IdString cell_type) const {
+    BelBucketId getBelBucketForCellType(IdString cell_type) const
+    {
         BelBucketId bucket;
         bucket.name = cell_type;
         return bucket;
     }
 
-    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
+    std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
+    {
         std::vector<BelId> bels;
-        for(BelId bel : getBels()) {
+        for (BelId bel : getBels()) {
-            if(getBelType(bel) == bucket.name) {
+            if (getBelType(bel) == bucket.name) {
                 bels.push_back(bel);
             }
         }

nexus/arch_pybindings.cc

@@ -55,8 +55,8 @@ void arch_wrap_python(py::module &m)
     typedef UpDownhillPipRange DownhillPipRange;
     typedef WireBelPinRange BelPinRange;
 
-    typedef const std::vector<BelBucketId> & BelBucketRange;
+    typedef const std::vector<BelBucketId> &BelBucketRange;
-    typedef const std::vector<BelId> & BelRangeForBelBucket;
+    typedef const std::vector<BelId> &BelRangeForBelBucket;
 
 #include "arch_pybindings_shared.h"
 

nexus/archdefs.h

@@ -114,15 +114,13 @@ struct PipId
     }
 };
 
-struct BelBucketId {
+struct BelBucketId
+{
     IdString name;
 
     bool operator==(const BelBucketId &other) const { return (name == other.name); }
     bool operator!=(const BelBucketId &other) const { return (name != other.name); }
-    bool operator<(const BelBucketId &other) const
+    bool operator<(const BelBucketId &other) const { return name < other.name; }
-    {
-        return name < other.name;
-    }
 };
 
 struct GroupId