fix: strengthens database geometry and connectivity validation

src/database/data/design/IdbDesign.cpp

@@ -132,6 +132,10 @@ IdbDesign::IdbDesign(IdbLayout* layout)
 
 IdbDesign::~IdbDesign()
 {
+  if (_units != nullptr) {
+    delete _units;
+    _units = nullptr;
+  }
   if (_instance_list != nullptr) {
     delete _instance_list;
     _instance_list = nullptr;
@@ -1264,7 +1268,7 @@ bool IdbDesign::writeConnectivitySnapshot(const std::string& path, bool check_fl
 
 bool IdbDesign::connectIOPinToPowerStripe(vector<IdbCoordinate<int32_t>*>& point_list, IdbLayer* layer)
 {
-  if (point_list.size() < _POINT_MAX_ || layer == nullptr) {
+  if (point_list.size() < _POINT_MAX_ || layer == nullptr || _layout == nullptr || _io_pin_list == nullptr || _special_net_list == nullptr) {
     return false;
   }
 
@@ -1317,6 +1321,9 @@ bool IdbDesign::connectIOPinToPowerStripe(vector<IdbCoordinate<int32_t>*>& point
 
 bool IdbDesign::connectPowerStripe(vector<IdbCoordinate<int32_t>*>& point_list, string net_name, string layer_name)
 {
+  if (_special_net_list == nullptr) {
+    return false;
+  }
   return _special_net_list->addPowerStripe(point_list, net_name, layer_name);
 }
 

src/database/data/design/IdbDesign.h

@@ -106,18 +106,90 @@ class IdbDesign
   // setter
   void set_version(std::string version) { _version = version; }
   void set_design_name(std::string name) { _design_name = name; }
-  void set_units(IdbUnits* units) { _units = units; }
-  void set_instance_list(IdbInstanceList* instance_list) { _instance_list = instance_list; }
-  void set_io_pin_list(IdbPins* pin_list) { _io_pin_list = pin_list; }
-  void set_net_list(IdbNetList* net_list) { _net_list = net_list; }
-  void set_via_list(IdbVias* via_list) { _via_list = via_list; }
-  void set_blockage_list(IdbBlockageList* blockage_list) { _blockage_list = blockage_list; }
-  void set_region_list(IdbRegionList* region_list) { _region_list = region_list; }
-  void set_slot_list(IdbSlotList* slot_list) { _slot_list = slot_list; }
-  void set_group_list(IdbGroupList* group_list) { _group_list = group_list; }
-  void set_special_net_list(IdbSpecialNetList* net_list) { _special_net_list = net_list; }
-  void set_fill_list(IdbFillList* fill_list) { _fill_list = fill_list; }
-  void set_bus_bit_chars(IdbBusBitChars* busbit_chars) { _bus_bit_chars = busbit_chars; }
+  void set_units(IdbUnits* units)
+  {
+    if (_units != units) {
+      delete _units;
+    }
+    _units = units == nullptr ? new IdbUnits() : units;
+  }
+  void set_instance_list(IdbInstanceList* instance_list)
+  {
+    if (_instance_list != instance_list) {
+      delete _instance_list;
+      _instance_list = instance_list;
+    }
+  }
+  void set_io_pin_list(IdbPins* pin_list)
+  {
+    if (_io_pin_list != pin_list) {
+      delete _io_pin_list;
+      _io_pin_list = pin_list;
+    }
+  }
+  void set_net_list(IdbNetList* net_list)
+  {
+    if (_net_list != net_list) {
+      delete _net_list;
+      _net_list = net_list;
+    }
+  }
+  void set_via_list(IdbVias* via_list)
+  {
+    if (_via_list != via_list) {
+      delete _via_list;
+      _via_list = via_list;
+    }
+  }
+  void set_blockage_list(IdbBlockageList* blockage_list)
+  {
+    if (_blockage_list != blockage_list) {
+      delete _blockage_list;
+      _blockage_list = blockage_list;
+    }
+  }
+  void set_region_list(IdbRegionList* region_list)
+  {
+    if (_region_list != region_list) {
+      delete _region_list;
+      _region_list = region_list;
+    }
+  }
+  void set_slot_list(IdbSlotList* slot_list)
+  {
+    if (_slot_list != slot_list) {
+      delete _slot_list;
+      _slot_list = slot_list;
+    }
+  }
+  void set_group_list(IdbGroupList* group_list)
+  {
+    if (_group_list != group_list) {
+      delete _group_list;
+      _group_list = group_list;
+    }
+  }
+  void set_special_net_list(IdbSpecialNetList* net_list)
+  {
+    if (_special_net_list != net_list) {
+      delete _special_net_list;
+      _special_net_list = net_list;
+    }
+  }
+  void set_fill_list(IdbFillList* fill_list)
+  {
+    if (_fill_list != fill_list) {
+      delete _fill_list;
+      _fill_list = fill_list;
+    }
+  }
+  void set_bus_bit_chars(IdbBusBitChars* busbit_chars)
+  {
+    if (_bus_bit_chars != busbit_chars) {
+      delete _bus_bit_chars;
+      _bus_bit_chars = busbit_chars;
+    }
+  }
 
   // operator
   int32_t transUnitDB(double value) { return std::round(_units->get_micron_dbu() * value); }

src/database/data/design/IdbEnum.cpp

@@ -32,16 +32,14 @@
 #include "IdbEnum.h"
 
 #include <algorithm>
+#include <cctype>
 #include <cstdio>
 #include <cstdlib>
 
 using namespace std;
 
 namespace idb {
 
-IdbEnum* IdbEnum::_instance = nullptr;
-std::mutex IdbEnum::_mutex;
-
 IdbEnum::IdbEnum()
 {
   _property_map = new IdbInstancePropertyMap();
@@ -54,6 +52,12 @@ IdbEnum::IdbEnum()
 
 IdbEnum::~IdbEnum()
 {
+  delete _property_map;
+  delete _site_property;
+  delete _term_property;
+  delete _layer_property;
+  delete _cell_property;
+  delete _region_property;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -165,7 +169,8 @@ IdbSiteProperty::IdbSiteProperty()
 
 IdbSiteClass IdbSiteProperty::get_class_type(string class_name)
 {
-  std::transform(class_name.begin(), class_name.end(), class_name.begin(), ::toupper);
+  std::transform(class_name.begin(), class_name.end(), class_name.begin(),
+                 [](unsigned char character) { return static_cast<char>(std::toupper(character)); });
   auto result = std::find_if(_site_class_list.begin(), _site_class_list.end(),
                              [class_name](const auto& iter) { return iter.second == class_name; });
 
@@ -263,7 +268,7 @@ std::string IdbEnum::get_orient_type_str(IdbOrient type)
       return "MY90";
       break;
     default:
-      return "R0";
+      return "";
       break;
   }
 }

src/database/data/design/IdbEnum.h

@@ -474,14 +474,8 @@ class IdbEnum
 
   static IdbEnum* GetInstance()
   {
-    if (_instance == nullptr) {
-      _mutex.lock();
-      if (_instance == nullptr) {
-        _instance = new IdbEnum();
-      }
-      _mutex.unlock();
-    }
-    return _instance;
+    static IdbEnum instance;
+    return &instance;
   }
 
   IdbInstancePropertyMap* get_instance_property() { return _property_map; }
@@ -496,9 +490,6 @@ class IdbEnum
   IdbEnum(IdbEnum& other) = delete;
   void operator=(const IdbEnum&) = delete;
 
-  static IdbEnum* _instance;
-  static std::mutex _mutex;
-
   IdbInstancePropertyMap* _property_map;
   IdbSiteProperty* _site_property;
   IdbConnectProperty* _term_property;

src/database/data/design/IdbLayout.cpp

@@ -44,8 +44,7 @@ IdbLayout::IdbLayout()
   _manufacture_grid = -1;
   _die = new IdbDie();
   _core = new IdbCore();
-  // _units            = new IdbUnits();
-  _units = nullptr;
+  _units = new IdbUnits();
   _layers = new IdbLayers();
   _sites = new IdbSites();
   _rows = new IdbRows();
@@ -104,6 +103,10 @@ IdbLayout::~IdbLayout()
     delete _via_rule_list;
     _via_rule_list = nullptr;
   }
+  if (_max_via_stack != nullptr) {
+    delete _max_via_stack;
+    _max_via_stack = nullptr;
+  }
 }
 
 IdbCore* IdbLayout::get_core()
@@ -127,7 +130,12 @@ IdbCore* IdbLayout::get_core()
       max_x = std::max(max_x, row_rect->get_high_x());
       max_y = std::max(max_y, row_rect->get_high_y());
     }
-    _core->set_bounding_box(min_x, min_y, max_x, max_y);
+    if (min_x != INT_MAX) {
+      _core->set_bounding_box(min_x, min_y, max_x, max_y);
+    } else {
+      auto* die_bbox = _die->get_bounding_box();
+      _core->set_bounding_box(die_bbox->get_low_x(), die_bbox->get_low_y(), die_bbox->get_high_x(), die_bbox->get_high_y());
+    }
   } else {
     auto* die_bbox = _die->get_bounding_box();
     _core->set_bounding_box(die_bbox->get_low_x(), die_bbox->get_low_y(), die_bbox->get_high_x(), die_bbox->get_high_y());

src/database/data/design/IdbLayout.h

@@ -33,6 +33,7 @@
 
 #include <cmath>
 #include <iostream>
+#include <limits>
 #include <string>
 #include <vector>
 
@@ -77,20 +78,99 @@ class IdbLayout
 
   // setter
   void set_manufacture_grid(int32_t value) { _manufacture_grid = value; }
-  void set_die(IdbDie* die) { _die = die; }
-  void set_units(IdbUnits* units) { _units = units; }
-  void set_layer(IdbLayers* layers) { _layers = layers; }
-  void set_sites(IdbSites* sites) { _sites = sites; }
-  void set_rows(IdbRows* rows) { _rows = rows; }
-  void set_gcell_grid_list(IdbGCellGridList* gcell_grid_list) { _gcell_grid_list = gcell_grid_list; }
-  void set_track_grid_list(IdbTrackGridList* track_grid_list) { _track_grid_list = track_grid_list; }
+  void set_die(IdbDie* die)
+  {
+    if (_die != die) {
+      delete _die;
+      _die = die;
+    }
+  }
+  void set_units(IdbUnits* units)
+  {
+    if (_units != units) {
+      delete _units;
+    }
+    _units = units == nullptr ? new IdbUnits() : units;
+  }
+  void set_layer(IdbLayers* layers)
+  {
+    if (_layers != layers) {
+      delete _layers;
+      _layers = layers;
+    }
+  }
+  void set_sites(IdbSites* sites)
+  {
+    if (_sites != sites) {
+      delete _sites;
+      _sites = sites;
+    }
+  }
+  void set_rows(IdbRows* rows)
+  {
+    if (_rows != rows) {
+      delete _rows;
+      _rows = rows;
+    }
+  }
+  void set_gcell_grid_list(IdbGCellGridList* gcell_grid_list)
+  {
+    if (_gcell_grid_list != gcell_grid_list) {
+      delete _gcell_grid_list;
+      _gcell_grid_list = gcell_grid_list;
+    }
+  }
+  void set_track_grid_list(IdbTrackGridList* track_grid_list)
+  {
+    if (_track_grid_list != track_grid_list) {
+      delete _track_grid_list;
+      _track_grid_list = track_grid_list;
+    }
+  }
   // void set_macros(IdbMacros* macros){_macros = macros;}
-  void set_cell_master_list(IdbCellMasterList* master_list) { _cell_master_list = master_list; }
-  void set_via_list(IdbVias* via_list) { _via_list = via_list; }
-  void set_via_rule_list(IdbViaRuleList* via_rule_list) { _via_rule_list = via_rule_list; }
-  void set_max_via_stack(IdbMaxViaStack* max_via_stack) { _max_via_stack = max_via_stack; }
+  void set_cell_master_list(IdbCellMasterList* master_list)
+  {
+    if (_cell_master_list != master_list) {
+      delete _cell_master_list;
+      _cell_master_list = master_list;
+    }
+  }
+  void set_via_list(IdbVias* via_list)
+  {
+    if (_via_list != via_list) {
+      delete _via_list;
+      _via_list = via_list;
+    }
+  }
+  void set_via_rule_list(IdbViaRuleList* via_rule_list)
+  {
+    if (_via_rule_list != via_rule_list) {
+      delete _via_rule_list;
+      _via_rule_list = via_rule_list;
+    }
+  }
+  void set_max_via_stack(IdbMaxViaStack* max_via_stack)
+  {
+    if (_max_via_stack != max_via_stack) {
+      delete _max_via_stack;
+      _max_via_stack = max_via_stack;
+    }
+  }
   // operator
-  int32_t transAreaDB(double value) { return std::round(std::pow(_units->get_micron_dbu(), 2) * value); }
+  int32_t transAreaDB(double value)
+  {
+    const double area = std::round(std::pow(_units->get_micron_dbu(), 2) * value);
+    if (!std::isfinite(area)) {
+      return area < 0 ? std::numeric_limits<int32_t>::min() : std::numeric_limits<int32_t>::max();
+    }
+    if (area > std::numeric_limits<int32_t>::max()) {
+      return std::numeric_limits<int32_t>::max();
+    }
+    if (area < std::numeric_limits<int32_t>::min()) {
+      return std::numeric_limits<int32_t>::min();
+    }
+    return static_cast<int32_t>(area);
+  }
   int32_t transUnitDB(double value) { return std::round(_units->get_micron_dbu() * value); }      // get (class IdbUnits -> (int32) _micron_dbu) * value
   void initDie(int32_t ll_x, int32_t ll_y, int32_t ur_x, int32_t ur_y);
   IdbRow* createRow(std::string row_name, std::string site_name, int32_t orig_x, int32_t orig_y, IdbOrient site_orient, int32_t num_x,

src/database/data/design/IdbObject.h

@@ -43,14 +43,21 @@ class IdbObject
  public:
   IdbObject();
   virtual ~IdbObject();
+  IdbObject(const IdbObject&) = delete;
+  IdbObject& operator=(const IdbObject&) = delete;
 
   // getter
   IdbRect* get_bounding_box() { return _bounding_box; }
-  uint64_t& get_id() { return _id; }
+  uint64_t get_id() const { return _id; }
 
   // setter
   bool set_bounding_box(int32_t ll_x, int32_t ll_y, int32_t ur_x, int32_t ur_y);
-  void set_bounding_box(IdbRect* bounding_box) { _bounding_box = bounding_box; }
+  void set_bounding_box(IdbRect* bounding_box)
+  {
+    if (bounding_box != nullptr) {
+      set_bounding_box(*bounding_box);
+    }
+  }
   void set_bounding_box(IdbRect bounding_box);
   void set_id(uint64_t id) { _id = id; }