Remove all remaning uses of uint and use uint32_t instead.

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

src/ant/src/AntennaChecker.cc

@@ -167,7 +167,7 @@ void AntennaChecker::Impl::initAntennaRules()
       const odb::dbTechLayerAntennaRule::pwl_pair diffPSR
           = antenna_rule->getDiffPSR();
 
-      uint wire_thickness_dbu = 0;
+      uint32_t wire_thickness_dbu = 0;
       tech_layer->getThickness(wire_thickness_dbu);
 
       const odb::dbTechLayerType layerType = tech_layer->getType();
@@ -492,7 +492,7 @@ void AntennaChecker::Impl::calculateAreas(
 
       if (it.first->getRoutingLevel() != 0) {
         // Calculate side area of wire
-        uint wire_thickness_dbu = 0;
+        uint32_t wire_thickness_dbu = 0;
         it.first->getThickness(wire_thickness_dbu);
         double wire_thickness = block_->dbuToMicrons(wire_thickness_dbu);
         info.side_area = block_->dbuToMicrons(gtl::perimeter(node_it->pol)

src/cts/src/TreeBuilder.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cassert>
 #include <cmath>
+#include <cstdint>
 #include <limits>
 #include <string>
 #include <vector>
@@ -26,7 +27,7 @@ void TreeBuilder::mergeBlockages()
   namespace gtl = boost::polygon;
   using boost::polygon::operators::operator+=;
 
-  uint macros_max_dx = 0, macros_max_dy = 0;
+  uint32_t macros_max_dx = 0, macros_max_dy = 0;
   odb::dbBlock* block = db_->getChip()->getBlock();
   gtl::polygon_90_set_data<int> blockage_polygons;
   // Add the macros into the polygon set

src/cts/src/TritonCTS.cpp

@@ -1627,7 +1627,7 @@ void TritonCTS::writeClockNetsToDb(TreeBuilder* builder,
   topClockInstInputPin->connect(topClockNet);
   topClockNet->setSigType(odb::dbSigType::CLOCK);
 
-  std::map<int, odb::uint> fanoutcount;
+  std::map<int, int> fanoutcount;
 
   // create subNets
   numClkNets_ = 0;
@@ -1875,8 +1875,8 @@ int TritonCTS::getNetSpacing(odb::dbTechLayer* layer,
   } else if (!layer->getV54SpacingRules().empty()) {
     for (auto rule : layer->getV54SpacingRules()) {
       if (rule->hasRange()) {
-        uint rmin;
-        uint rmax;
+        uint32_t rmin;
+        uint32_t rmax;
         rule->getRange(rmin, rmax);
         if (width1 < rmin || width2 > rmax) {
           continue;

src/cut/src/blif.cpp

@@ -4,6 +4,7 @@
 #include "cut/blif.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <fstream>
 #include <iostream>
 #include <iterator>
@@ -74,15 +75,15 @@ bool Blif::writeBlif(const char* file_name, bool write_arrival_requireds)
   }
 
   std::set<odb::dbInst*>& insts = this->instances_to_optimize_;
-  std::map<odb::uint, odb::dbInst*> instMap;
+  std::map<uint32_t, odb::dbInst*> instMap;
   std::vector<std::string> subckts;
   std::set<std::string> inputs, outputs, const0, const1, clocks;
 
   subckts.resize(insts.size());
   int instIndex = 0;
 
   for (auto&& inst : insts) {
-    instMap.insert(std::pair<odb::uint, odb::dbInst*>(inst->getId(), inst));
+    instMap.insert(std::pair<uint32_t, odb::dbInst*>(inst->getId(), inst));
   }
 
   for (auto&& inst : insts) {

src/dpl/src/infrastructure/network.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -71,8 +72,8 @@ class Network
  public:
   std::vector<std::unique_ptr<Node>>& getNodes() { return nodes_; }
   int getNumNodes() const { return (int) nodes_.size(); }
-  uint getNumCells() const { return cells_cnt_; }
-  uint getNumTerminals() const { return terminals_cnt_; }
+  uint32_t getNumCells() const { return cells_cnt_; }
+  uint32_t getNumTerminals() const { return terminals_cnt_; }
   Node* getNode(int i) { return nodes_[i].get(); }
   Node* getNode(odb::dbInst* inst);
   Node* getNode(odb::dbBTerm* term);
@@ -130,8 +131,8 @@ class Network
   std::unordered_map<odb::dbBTerm*, int> term_to_node_idx_;
   std::unordered_map<odb::dbMaster*, int> master_to_idx_;
   std::unordered_map<odb::dbNet*, int> net_to_edge_idx_;
-  uint cells_cnt_{0};
-  uint terminals_cnt_{0};
+  uint32_t cells_cnt_{0};
+  uint32_t terminals_cnt_{0};
 };
 
 }  // namespace dpl

src/drt/src/dr/FlexDR.cpp

@@ -654,7 +654,7 @@ void FlexDR::reportIterationViolations() const
                   getDesign()->getTopBlock()->getNumMarkers());
     if (getDesign()->getTopBlock()->getNumMarkers() > 0) {
       // report violations
-      std::map<std::string, std::map<frLayerNum, uint>> violations;
+      std::map<std::string, std::map<frLayerNum, uint32_t>> violations;
       std::set<frLayerNum> layers;
       const std::map<std::string, std::string> relabel
           = {{"Lef58SpacingEndOfLine", "EOL"},

src/drt/src/io/GuideProcessor.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <map>
@@ -1605,7 +1606,7 @@ void GuidePathFinder::updateNodeMap(
 void GuidePathFinder::clipGuides(std::vector<frRect>& rects)
 {
   for (auto& [pt, indices] : node_map_) {
-    const uint num_indices = indices.size();
+    const uint32_t num_indices = indices.size();
     if (num_indices != 1) {
       continue;
     }
@@ -1648,7 +1649,7 @@ void GuidePathFinder::mergeGuides(std::vector<frRect>& rects)
   };
   for (auto& [pt, indices] : node_map_) {
     std::vector<int> visited_indices = getVisitedIndices(indices, visited_);
-    const uint num_indices = visited_indices.size();
+    const uint32_t num_indices = visited_indices.size();
     if (num_indices == 2) {
       const auto first_idx = *(visited_indices.begin());
       const auto second_idx = *std::prev(visited_indices.end());

src/drt/src/io/io.cpp

@@ -7,6 +7,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <list>
@@ -493,36 +494,36 @@ void io::Parser::getSBoxCoords(odb::dbSBox* box,
   int y1 = box->yMin();
   int x2 = box->xMax();
   int y2 = box->yMax();
-  uint dx = box->getDX();
-  uint dy = box->getDY();
-  uint w;
+  uint32_t dx = box->getDX();
+  uint32_t dy = box->getDY();
+  uint32_t w;
   switch (box->getDirection()) {
     case odb::dbSBox::UNDEFINED: {
       bool dx_even = ((dx & 1) == 0);
       bool dy_even = ((dy & 1) == 0);
       if (dx_even && dy_even) {
         if (dy < dx) {
           w = dy;
-          uint dw = dy >> 1;
+          uint32_t dw = dy >> 1;
           y1 += dw;
           y2 -= dw;
           assert(y1 == y2);
         } else {
           w = dx;
-          uint dw = dx >> 1;
+          uint32_t dw = dx >> 1;
           x1 += dw;
           x2 -= dw;
           assert(x1 == x2);
         }
       } else if (dx_even) {
         w = dx;
-        uint dw = dx >> 1;
+        uint32_t dw = dx >> 1;
         x1 += dw;
         x2 -= dw;
         assert(x1 == x2);
       } else if (dy_even) {
         w = dy;
-        uint dw = dy >> 1;
+        uint32_t dw = dy >> 1;
         y1 += dw;
         y2 -= dw;
         assert(y1 == y2);
@@ -533,15 +534,15 @@ void io::Parser::getSBoxCoords(odb::dbSBox* box,
     }
     case odb::dbSBox::HORIZONTAL: {
       w = dy;
-      uint dw = dy >> 1;
+      uint32_t dw = dy >> 1;
       y1 += dw;
       y2 -= dw;
       assert(y1 == y2);
       break;
     }
     case odb::dbSBox::VERTICAL: {
       w = dx;
-      uint dw = dx >> 1;
+      uint32_t dw = dx >> 1;
       x1 += dw;
       x2 -= dw;
       assert(x1 == x2);
@@ -2380,7 +2381,7 @@ void io::Parser::addRoutingLayer(odb::dbTechLayer* layer)
     }
 
     frCollection<frSpacingTableTwRowType> rowVals;
-    for (uint j = 0; j < layer->getTwoWidthsSpacingTableNumWidths(); ++j) {
+    for (uint32_t j = 0; j < layer->getTwoWidthsSpacingTableNumWidths(); ++j) {
       frCoord width = layer->getTwoWidthsSpacingTableWidth(j);
       frCoord prl = layer->getTwoWidthsSpacingTablePRL(j);
       rowVals.push_back(frSpacingTableTwRowType(width, prl));
@@ -3996,7 +3997,7 @@ int io::TopLayerBTermHandler::countNetBTermsAboveMaxLayer(odb::dbNet* net)
 bool io::TopLayerBTermHandler::netHasStackedVias(odb::dbNet* net)
 {
   int bterms_above_max_layer = countNetBTermsAboveMaxLayer(net);
-  uint wire_cnt = 0, via_cnt = 0;
+  uint32_t wire_cnt = 0, via_cnt = 0;
   net->getWireCount(wire_cnt, via_cnt);
 
   if (wire_cnt != 0 || via_cnt == 0) {

src/drt/test/gcTest.cpp

@@ -26,6 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <tuple>
@@ -1260,8 +1261,8 @@ TEST_P(CutSpcTblFixture, cut_spc_tbl)
   auto dbRule = odb::dbTechLayerCutSpacingTableDefRule::create(layer);
   dbRule->setDefault(100);
   dbRule->setVertical(true);
-  std::map<std::string, uint> row_map;
-  std::map<std::string, uint> col_map;
+  std::map<std::string, uint32_t> row_map;
+  std::map<std::string, uint32_t> col_map;
   std::vector<std::vector<std::pair<int, int>>> table;
   row_map["Vx/SIDE"] = 1;
   row_map["Vx/END"] = 0;

src/grt/src/GlobalRouter.cpp

@@ -3962,8 +3962,8 @@ std::vector<std::pair<int, int>> GlobalRouter::calcLayerPitches(int max_layer)
         int minSpc = 0;
         for (auto rule : layer->getV54SpacingRules()) {
           if (rule->hasRange()) {
-            uint rmin;
-            uint rmax;
+            uint32_t rmin;
+            uint32_t rmax;
             rule->getRange(rmin, rmax);
             if (layer_width < rmin || layer_width > rmax) {
               continue;
@@ -4465,11 +4465,11 @@ void GlobalRouter::findLayerExtensions(std::vector<int>& layer_extensions)
       // PARALLELRUNLENGTH
 
       if (obstruct_layer->hasTwoWidthsSpacingRules()) {
-        std::vector<std::vector<odb::uint>> spacing_table;
+        std::vector<std::vector<uint32_t>> spacing_table;
         obstruct_layer->getTwoWidthsSpacingTable(spacing_table);
         if (!spacing_table.empty()) {
-          std::vector<odb::uint> last_row = spacing_table.back();
-          odb::uint last_value = last_row.back();
+          std::vector<uint32_t> last_row = spacing_table.back();
+          uint32_t last_value = last_row.back();
           if (last_value > spacing_extension) {
             spacing_extension = last_value;
           }
@@ -4726,7 +4726,7 @@ void GlobalRouter::findNetsObstructions(odb::Rect& die_area)
   }
 
   for (odb::dbNet* db_net : nets) {
-    odb::uint wire_cnt = 0, via_cnt = 0;
+    uint32_t wire_cnt = 0, via_cnt = 0;
     db_net->getWireCount(wire_cnt, via_cnt);
     if (wire_cnt == 0) {
       continue;