Merge remote-tracking branch 'origin/master' into ord-startup

Signed-off-by: Matt Liberty <mliberty@precisioninno.com>

Author: maliberty

bazel/tcl_wrap_cc.bzl

@@ -9,7 +9,14 @@ cc_library or cc_binary rules. See below for expected usage.
 cc_library(srcs=[":tcl_foo"])
 tcl_wrap_cc(name = "tcl_foo", srcs=["exception.i"],...)
 """
-TclSwigInfo = provider("TclSwigInfo for taking dependencies on other swig info rules", fields = ["transitive_srcs", "includes", "swig_options"])
+TclSwigInfo = provider(
+    "TclSwigInfo for taking dependencies on other swig info rules",
+    fields = [
+        "transitive_srcs",
+        "includes",
+        "swig_options",
+    ],
+)
 
 def _get_transative_srcs(srcs, deps):
     return depset(

src/dpl/src/infrastructure/Grid.cpp

@@ -329,6 +329,10 @@ void Grid::paintPixel(Node* cell, GridX grid_x, GridY grid_y)
   for (GridX x{grid_x}; x < x_end; x++) {
     for (GridY y{grid_y}; y < y_end; y++) {
       Pixel* pixel = gridPixel(x, y);
+      if (pixel == nullptr) {
+        // This can happen if cell padding is larger than the grid.
+        continue;
+      }
       pixel->cell = cell;
       pixel->util = 1.0;
     }

src/odb/include/odb/db.h

@@ -3271,9 +3271,13 @@ class dbInst : public dbObject
                         const char* name,
                         dbRegion* region,
                         bool physical_only = false,
-                        dbModule* parent_module = nullptr
+                        dbModule* parent_module = nullptr);
 
-  );
+  static dbInst* makeUniqueDbInst(dbBlock* block,
+                                  dbMaster* master,
+                                  const char* name,
+                                  bool physical_only,
+                                  dbModule* target_module);
 
   ///
   /// Create a new instance of child_block in top_block.

src/odb/src/db/dbBlock.h

@@ -282,7 +282,8 @@ class _dbBlock : public _dbObject
   dbPropertyItr* _prop_itr;
   dbBlockSearch* _searchDb;
 
-  std::map<std::string, int> _module_name_id_map;
+  std::unordered_map<std::string, int> _module_name_id_map;
+  std::unordered_map<std::string, int> _inst_name_id_map;
 
   unsigned char _num_ext_dbs;
 

src/odb/src/db/dbInst.cpp

@@ -1222,22 +1222,17 @@ dbInst* dbInst::create(dbBlock* block_,
                        dbModule* parent_module)
 {
   _dbBlock* block = (_dbBlock*) block_;
+  if (block->_inst_hash.hasMember(name_)) {
+    return nullptr;
+  }
+
   _dbMaster* master = (_dbMaster*) master_;
   _dbInstHdr* inst_hdr = block->_inst_hdr_hash.find(master->_id);
-
   if (inst_hdr == nullptr) {
     inst_hdr
         = (_dbInstHdr*) dbInstHdr::create((dbBlock*) block, (dbMaster*) master);
   }
 
-  if (block->_inst_hash.hasMember(name_)) {
-    block->getImpl()->getLogger()->error(
-        utl::ODB,
-        385,
-        "Attempt to create instance with duplicate name: {}",
-        name_);
-  }
-
   _dbInst* inst = block->_inst_tbl->create();
 
   if (block->_journal) {
@@ -1354,6 +1349,35 @@ dbInst* dbInst::create(dbBlock* top_block,
   return inst;
 }
 
+dbInst* dbInst::makeUniqueDbInst(dbBlock* block,
+                                 dbMaster* master,
+                                 const char* name,
+                                 bool physical_only,
+                                 dbModule* target_module)
+{
+  dbInst* inst
+      = dbInst::create(block, master, name, physical_only, target_module);
+  if (inst) {
+    return inst;
+  }
+
+  std::unordered_map<std::string, int>& name_id_map
+      = ((_dbBlock*) block)->_inst_name_id_map;
+  std::string inst_base_name(name);
+  do {
+    std::string full_name = inst_base_name;
+    int& id = name_id_map[inst_base_name];
+    if (id > 0) {
+      full_name += "_" + std::to_string(id);
+    }
+    ++id;
+    inst = dbInst::create(
+        block, master, full_name.c_str(), physical_only, target_module);
+  } while (inst == nullptr);
+
+  return inst;
+}
+
 void dbInst::destroy(dbInst* inst_)
 {
   _dbInst* inst = (_dbInst*) inst_;

src/odb/src/db/dbModule.cpp

@@ -548,7 +548,7 @@ dbModule* dbModule::makeUniqueDbModule(const char* cell_name,
     return module;
   }
 
-  std::map<std::string, int>& name_id_map
+  std::unordered_map<std::string, int>& name_id_map
       = ((_dbBlock*) block)->_module_name_id_map;
   std::string orig_cell_name(cell_name);
   std::string module_name = orig_cell_name + '_' + std::string(inst_name);
@@ -729,11 +729,11 @@ void dbModule::copyModuleInsts(dbModule* old_module,
                          ? std::move(old_inst_name).substr(first_idx + 1)
                          : std::move(old_inst_name);
 
-    dbInst* new_inst = dbInst::create(new_module->getOwner(),
-                                      old_inst->getMaster(),
-                                      new_inst_name.c_str(),
-                                      /* phyical only */ false,
-                                      new_module);
+    dbInst* new_inst = dbInst::makeUniqueDbInst(new_module->getOwner(),
+                                                old_inst->getMaster(),
+                                                new_inst_name.c_str(),
+                                                /* phyical only */ false,
+                                                new_module);
     if (new_inst) {
       debugPrint(logger,
                  utl::ODB,

src/rcx/include/rcx/ext.h

@@ -24,7 +24,7 @@ class Ext
 {
  public:
   Ext();
-  ~Ext() = default;
+  ~Ext();
 
   void init(odb::dbDatabase* db, Logger* logger, const char* spef_version);
   void setLogger(Logger* logger);

src/rcx/src/ext.cpp

@@ -23,6 +23,11 @@ Ext::Ext()
   _ext = new extMain();
 }
 
+Ext::~Ext()
+{
+  delete _ext;
+}
+
 void Ext::init(odb::dbDatabase* db, Logger* logger, const char* spef_version)
 {
   _db = db;