1 ///////////////////////////////////////////////////////////////////////////////
2 // BSD 3-Clause License
3 //
4 // Copyright (c) 2019, Nefelus Inc
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // * Redistributions of source code must retain the above copyright notice, this
11 // list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above copyright notice,
14 // this list of conditions and the following disclaimer in the documentation
15 // and/or other materials provided with the distribution.
16 //
17 // * Neither the name of the copyright holder nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
25 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 // POSSIBILITY OF SUCH DAMAGE.
32
33 #include "dbMaster.h"
34
35 #include "db.h"
36 #include "dbBox.h"
37 #include "dbBoxItr.h"
38 #include "dbDatabase.h"
39 #include "dbHashTable.hpp"
40 #include "dbLib.h"
41 #include "dbMPin.h"
42 #include "dbMPinItr.h"
43 #include "dbMTerm.h"
44 #include "dbSite.h"
45 #include "dbTable.h"
46 #include "dbTable.hpp"
47 #include "dbTarget.h"
48 #include "dbTargetItr.h"
49 #include "dbTechLayerAntennaRule.h"
50 #include "dbTransform.h"
51
52 namespace odb {
53
54 template class dbHashTable<_dbMTerm>;
55 template class dbTable<_dbMaster>;
56
operator ==(const _dbMaster & rhs) const57 bool _dbMaster::operator==(const _dbMaster& rhs) const
58 {
59 if (_flags._frozen != rhs._flags._frozen)
60 return false;
61
62 if (_flags._x_symmetry != rhs._flags._x_symmetry)
63 return false;
64
65 if (_flags._y_symmetry != rhs._flags._y_symmetry)
66 return false;
67
68 if (_flags._R90_symmetry != rhs._flags._R90_symmetry)
69 return false;
70
71 if (_flags._type != rhs._flags._type)
72 return false;
73
74 if (_x != rhs._x)
75 return false;
76
77 if (_y != rhs._y)
78 return false;
79
80 if (_height != rhs._height)
81 return false;
82
83 if (_width != rhs._width)
84 return false;
85
86 if (_mterm_cnt != rhs._mterm_cnt)
87 return false;
88
89 if (_id != rhs._id)
90 return false;
91
92 if (_name && rhs._name) {
93 if (strcmp(_name, rhs._name) != 0)
94 return false;
95 } else if (_name || rhs._name)
96 return false;
97
98 if (_next_entry != rhs._next_entry)
99 return false;
100
101 if (_leq != rhs._leq)
102 return false;
103
104 if (_eeq != rhs._eeq)
105 return false;
106
107 if (_obstructions != rhs._obstructions)
108 return false;
109
110 if (_site != rhs._site)
111 return false;
112
113 if (_mterm_hash != rhs._mterm_hash)
114 return false;
115
116 if (*_mterm_tbl != *rhs._mterm_tbl)
117 return false;
118
119 if (*_mpin_tbl != *rhs._mpin_tbl)
120 return false;
121
122 if (*_target_tbl != *rhs._target_tbl)
123 return false;
124
125 if (*_box_tbl != *rhs._box_tbl)
126 return false;
127
128 if (*_antenna_pin_model_tbl != *rhs._antenna_pin_model_tbl)
129 return false;
130
131 return true;
132 }
133
differences(dbDiff & diff,const char * field,const _dbMaster & rhs) const134 void _dbMaster::differences(dbDiff& diff,
135 const char* field,
136 const _dbMaster& rhs) const
137 {
138 DIFF_BEGIN
139 DIFF_FIELD(_flags._frozen);
140 DIFF_FIELD(_flags._x_symmetry);
141 DIFF_FIELD(_flags._y_symmetry);
142 DIFF_FIELD(_flags._R90_symmetry);
143 DIFF_FIELD(_flags._type);
144 DIFF_FIELD(_x);
145 DIFF_FIELD(_y);
146 DIFF_FIELD(_height);
147 DIFF_FIELD(_width);
148 DIFF_FIELD(_mterm_cnt);
149 DIFF_FIELD(_id);
150 DIFF_FIELD(_name);
151 DIFF_FIELD(_next_entry);
152 DIFF_FIELD(_leq);
153 DIFF_FIELD(_eeq);
154 DIFF_FIELD(_obstructions);
155 DIFF_FIELD(_site);
156 DIFF_HASH_TABLE(_mterm_hash);
157 DIFF_TABLE_NO_DEEP(_mterm_tbl);
158 DIFF_TABLE_NO_DEEP(_mpin_tbl);
159 DIFF_TABLE_NO_DEEP(_target_tbl);
160 DIFF_TABLE_NO_DEEP(_box_tbl);
161 DIFF_TABLE_NO_DEEP(_antenna_pin_model_tbl);
162 DIFF_END
163 }
164
out(dbDiff & diff,char side,const char * field) const165 void _dbMaster::out(dbDiff& diff, char side, const char* field) const
166 {
167 DIFF_OUT_BEGIN
168 DIFF_OUT_FIELD(_flags._frozen);
169 DIFF_OUT_FIELD(_flags._x_symmetry);
170 DIFF_OUT_FIELD(_flags._y_symmetry);
171 DIFF_OUT_FIELD(_flags._R90_symmetry);
172 DIFF_OUT_FIELD(_flags._type);
173 DIFF_OUT_FIELD(_x);
174 DIFF_OUT_FIELD(_y);
175 DIFF_OUT_FIELD(_height);
176 DIFF_OUT_FIELD(_width);
177 DIFF_OUT_FIELD(_mterm_cnt);
178 DIFF_OUT_FIELD(_id);
179 DIFF_OUT_FIELD(_name);
180 DIFF_OUT_FIELD(_next_entry);
181 DIFF_OUT_FIELD(_leq);
182 DIFF_OUT_FIELD(_eeq);
183 DIFF_OUT_FIELD(_obstructions);
184 DIFF_OUT_FIELD(_site);
185 DIFF_OUT_HASH_TABLE(_mterm_hash);
186 DIFF_OUT_TABLE_NO_DEEP(_mterm_tbl);
187 DIFF_OUT_TABLE_NO_DEEP(_mpin_tbl);
188 DIFF_OUT_TABLE_NO_DEEP(_target_tbl);
189 DIFF_OUT_TABLE_NO_DEEP(_box_tbl);
190 DIFF_OUT_TABLE_NO_DEEP(_antenna_pin_model_tbl);
191 DIFF_END
192 }
193
194 ////////////////////////////////////////////////////////////////////
195 //
196 // _dbMaster - Methods
197 //
198 ////////////////////////////////////////////////////////////////////
_dbMaster(_dbDatabase * db)199 _dbMaster::_dbMaster(_dbDatabase* db)
200 {
201 _flags._x_symmetry = 0;
202 _flags._y_symmetry = 0;
203 _flags._R90_symmetry = 0;
204 _flags._type = dbMasterType::CORE;
205 _flags._frozen = 0;
206 _flags._mark = 0;
207 _flags._special_power = 0;
208 _flags._sequential = 0;
209 _flags._spare_bits_19 = 0;
210
211 _x = 0;
212 _y = 0;
213 _height = 0;
214 _width = 0;
215 _mterm_cnt = 0;
216 _id = 0;
217 _name = 0;
218
219 _mterm_tbl = new dbTable<_dbMTerm>(
220 db, this, (GetObjTbl_t) &_dbMaster::getObjectTable, dbMTermObj, 4, 2);
221 ZALLOCATED(_mterm_tbl);
222
223 _mpin_tbl = new dbTable<_dbMPin>(
224 db, this, (GetObjTbl_t) &_dbMaster::getObjectTable, dbMPinObj, 4, 2);
225 ZALLOCATED(_mpin_tbl);
226
227 _target_tbl = new dbTable<_dbTarget>(
228 db, this, (GetObjTbl_t) &_dbMaster::getObjectTable, dbTargetObj, 4, 2);
229 ZALLOCATED(_target_tbl);
230
231 _box_tbl = new dbTable<_dbBox>(
232 db, this, (GetObjTbl_t) &_dbMaster::getObjectTable, dbBoxObj, 8, 3);
233 ZALLOCATED(_box_tbl);
234
235 _antenna_pin_model_tbl = new dbTable<_dbTechAntennaPinModel>(
236 db,
237 this,
238 (GetObjTbl_t) &_dbMaster::getObjectTable,
239 dbTechAntennaPinModelObj,
240 8,
241 3);
242 ZALLOCATED(_antenna_pin_model_tbl);
243
244 _box_itr = new dbBoxItr(_box_tbl);
245 ZALLOCATED(_box_itr);
246
247 _mpin_itr = new dbMPinItr(_mpin_tbl);
248 ZALLOCATED(_mpin_itr);
249
250 _target_itr = new dbTargetItr(_target_tbl);
251 ZALLOCATED(_target_itr);
252
253 _mterm_hash.setTable(_mterm_tbl);
254
255 _sta_cell = nullptr;
256 _clocked_mterm_index = 0;
257 _output_mterm_index = 0;
258 }
259
_dbMaster(_dbDatabase * db,const _dbMaster & m)260 _dbMaster::_dbMaster(_dbDatabase* db, const _dbMaster& m)
261 : _flags(m._flags),
262 _x(m._x),
263 _y(m._y),
264 _height(m._height),
265 _width(m._width),
266 _mterm_cnt(m._mterm_cnt),
267 _id(m._id),
268 _name(NULL),
269 _next_entry(m._next_entry),
270 _leq(m._leq),
271 _eeq(m._eeq),
272 _obstructions(m._obstructions),
273 _site(m._site),
274 _mterm_hash(m._mterm_hash),
275 _sta_cell(m._sta_cell),
276 _clocked_mterm_index(m._clocked_mterm_index),
277 _output_mterm_index(m._output_mterm_index)
278 {
279 if (m._name) {
280 _name = strdup(m._name);
281 ZALLOCATED(_name);
282 }
283
284 _mterm_tbl = new dbTable<_dbMTerm>(db, this, *m._mterm_tbl);
285 ZALLOCATED(_mterm_tbl);
286
287 _mpin_tbl = new dbTable<_dbMPin>(db, this, *m._mpin_tbl);
288 ZALLOCATED(_mpin_tbl);
289
290 _target_tbl = new dbTable<_dbTarget>(db, this, *m._target_tbl);
291 ZALLOCATED(_target_tbl);
292
293 _box_tbl = new dbTable<_dbBox>(db, this, *m._box_tbl);
294 ZALLOCATED(_box_tbl);
295
296 _antenna_pin_model_tbl = new dbTable<_dbTechAntennaPinModel>(
297 db, this, *m._antenna_pin_model_tbl);
298 ZALLOCATED(_antenna_pin_model_tbl);
299
300 _box_itr = new dbBoxItr(_box_tbl);
301 ZALLOCATED(_box_itr);
302
303 _mpin_itr = new dbMPinItr(_mpin_tbl);
304 ZALLOCATED(_mpin_itr);
305
306 _target_itr = new dbTargetItr(_target_tbl);
307 ZALLOCATED(_target_itr);
308
309 _mterm_hash.setTable(_mterm_tbl);
310 }
311
~_dbMaster()312 _dbMaster::~_dbMaster()
313 {
314 delete _mterm_tbl;
315 delete _mpin_tbl;
316 delete _target_tbl;
317 delete _box_tbl;
318 delete _antenna_pin_model_tbl;
319 delete _box_itr;
320 delete _mpin_itr;
321 delete _target_itr;
322
323 if (_name)
324 free((void*) _name);
325 }
326
operator <<(dbOStream & stream,const _dbMaster & master)327 dbOStream& operator<<(dbOStream& stream, const _dbMaster& master)
328 {
329 uint* bit_field = (uint*) &master._flags;
330 stream << *bit_field;
331 stream << master._x;
332 stream << master._y;
333 stream << master._height;
334 stream << master._width;
335 stream << master._mterm_cnt;
336 stream << master._id;
337 stream << master._name;
338 stream << master._next_entry;
339 stream << master._leq;
340 stream << master._eeq;
341 stream << master._obstructions;
342 stream << master._site;
343 stream << master._mterm_hash;
344 stream << *master._mterm_tbl;
345 stream << *master._mpin_tbl;
346 stream << *master._target_tbl;
347 stream << *master._box_tbl;
348 stream << *master._antenna_pin_model_tbl;
349 return stream;
350 }
351
operator >>(dbIStream & stream,_dbMaster & master)352 dbIStream& operator>>(dbIStream& stream, _dbMaster& master)
353 {
354 uint* bit_field = (uint*) &master._flags;
355 stream >> *bit_field;
356 stream >> master._x;
357 stream >> master._y;
358 stream >> master._height;
359 stream >> master._width;
360 stream >> master._mterm_cnt;
361 stream >> master._id;
362 stream >> master._name;
363 stream >> master._next_entry;
364 stream >> master._leq;
365 stream >> master._eeq;
366 stream >> master._obstructions;
367 stream >> master._site;
368 stream >> master._mterm_hash;
369 stream >> *master._mterm_tbl;
370 stream >> *master._mpin_tbl;
371 stream >> *master._target_tbl;
372 stream >> *master._box_tbl;
373 stream >> *master._antenna_pin_model_tbl;
374 return stream;
375 }
376
getObjectTable(dbObjectType type)377 dbObjectTable* _dbMaster::getObjectTable(dbObjectType type)
378 {
379 switch (type) {
380 case dbMTermObj:
381 return _mterm_tbl;
382 case dbMPinObj:
383 return _mpin_tbl;
384 case dbTargetObj:
385 return _target_tbl;
386 case dbBoxObj:
387 return _box_tbl;
388 case dbTechAntennaPinModelObj:
389 return _antenna_pin_model_tbl;
390 default:
391 break; // DIMITRIS_COMP_WARN
392 }
393
394 return getTable()->getObjectTable(type);
395 }
396
397 ////////////////////////////////////////////////////////////////////
398 //
399 // dbMaster - Methods
400 //
401 ////////////////////////////////////////////////////////////////////
402
getName()403 std::string dbMaster::getName()
404 {
405 _dbMaster* master = (_dbMaster*) this;
406 return master->_name;
407 }
408
getConstName()409 const char* dbMaster::getConstName()
410 {
411 _dbMaster* master = (_dbMaster*) this;
412 return master->_name;
413 }
414
getOrigin(int & x,int & y)415 void dbMaster::getOrigin(int& x, int& y)
416 {
417 _dbMaster* master = (_dbMaster*) this;
418 x = master->_x;
419 y = master->_y;
420 }
421
setOrigin(int x,int y)422 void dbMaster::setOrigin(int x, int y)
423 {
424 _dbMaster* master = (_dbMaster*) this;
425 master->_x = x;
426 master->_y = y;
427 }
428
staCell()429 void* dbMaster::staCell()
430 {
431 _dbMaster* master = (_dbMaster*) this;
432 return master->_sta_cell;
433 }
434
staSetCell(void * cell)435 void dbMaster::staSetCell(void* cell)
436 {
437 _dbMaster* master = (_dbMaster*) this;
438 master->_sta_cell = cell;
439 }
440
getWidth() const441 uint dbMaster::getWidth() const
442 {
443 _dbMaster* master = (_dbMaster*) this;
444 return master->_width;
445 }
446
setWidth(uint w)447 void dbMaster::setWidth(uint w)
448 {
449 _dbMaster* master = (_dbMaster*) this;
450 master->_width = w;
451 }
452
getHeight() const453 uint dbMaster::getHeight() const
454 {
455 _dbMaster* master = (_dbMaster*) this;
456 return master->_height;
457 }
458
setHeight(uint h)459 void dbMaster::setHeight(uint h)
460 {
461 _dbMaster* master = (_dbMaster*) this;
462 master->_height = h;
463 }
464
getType() const465 dbMasterType dbMaster::getType() const
466 {
467 _dbMaster* master = (_dbMaster*) this;
468 return dbMasterType(master->_flags._type);
469 }
470
setType(dbMasterType type)471 void dbMaster::setType(dbMasterType type)
472 {
473 _dbMaster* master = (_dbMaster*) this;
474 master->_flags._type = type.getValue();
475 }
476
getLEQ()477 dbMaster* dbMaster::getLEQ()
478 {
479 _dbMaster* master = (_dbMaster*) this;
480
481 if (master->_leq == 0)
482 return NULL;
483
484 _dbLib* lib = (_dbLib*) master->getOwner();
485 return (dbMaster*) lib->_master_tbl->getPtr(master->_leq);
486 }
487
setLEQ(dbMaster * leq)488 void dbMaster::setLEQ(dbMaster* leq)
489 {
490 _dbMaster* master = (_dbMaster*) this;
491 master->_leq = leq->getImpl()->getOID();
492 }
493
getEEQ()494 dbMaster* dbMaster::getEEQ()
495 {
496 _dbMaster* master = (_dbMaster*) this;
497
498 if (master->_eeq == 0)
499 return NULL;
500
501 _dbLib* lib = (_dbLib*) master->getOwner();
502 return (dbMaster*) lib->_master_tbl->getPtr(master->_eeq);
503 }
504
setEEQ(dbMaster * eeq)505 void dbMaster::setEEQ(dbMaster* eeq)
506 {
507 _dbMaster* master = (_dbMaster*) this;
508 master->_eeq = eeq->getImpl()->getOID();
509 }
510
getMTerms()511 dbSet<dbMTerm> dbMaster::getMTerms()
512 {
513 _dbMaster* master = (_dbMaster*) this;
514 return dbSet<dbMTerm>(master, master->_mterm_tbl);
515 }
516
findMTerm(const char * name)517 dbMTerm* dbMaster::findMTerm(const char* name)
518 {
519 _dbMaster* master = (_dbMaster*) this;
520 return (dbMTerm*) master->_mterm_hash.find(name);
521 }
522
findMTerm(dbBlock * block,const char * name)523 dbMTerm* dbMaster::findMTerm(dbBlock* block, const char* name)
524 {
525 dbMTerm* mterm = findMTerm(name);
526 if (mterm)
527 return mterm;
528 char blk_left_bus_del, blk_right_bus_del, lib_left_bus_del, lib_right_bus_del;
529 char ttname[max_name_length];
530 uint ii = 0;
531 block->getBusDelimeters(blk_left_bus_del, blk_right_bus_del);
532 getLib()->getBusDelimeters(lib_left_bus_del, lib_right_bus_del);
533 if (lib_left_bus_del == '\0' || lib_right_bus_del == '\0')
534 return mterm;
535
536 if (lib_left_bus_del != blk_left_bus_del
537 || lib_right_bus_del != blk_right_bus_del) {
538 while (name[ii] != '\0') {
539 if (name[ii] == blk_left_bus_del)
540 ttname[ii] = lib_left_bus_del;
541 else if (name[ii] == blk_right_bus_del)
542 ttname[ii] = lib_right_bus_del;
543 else
544 ttname[ii] = name[ii];
545 ii++;
546 }
547 ttname[ii] = '\0';
548 mterm = findMTerm(ttname);
549 }
550 return mterm;
551 }
552
getLib()553 dbLib* dbMaster::getLib()
554 {
555 return (dbLib*) getImpl()->getOwner();
556 }
557
getObstructions()558 dbSet<dbBox> dbMaster::getObstructions()
559 {
560 _dbMaster* master = (_dbMaster*) this;
561 return dbSet<dbBox>(master, master->_box_itr);
562 }
563
isFrozen()564 bool dbMaster::isFrozen()
565 {
566 _dbMaster* master = (_dbMaster*) this;
567 return master->_flags._frozen != 0;
568 }
569
getMTermCount()570 int dbMaster::getMTermCount()
571 {
572 _dbMaster* master = (_dbMaster*) this;
573 return master->_mterm_cnt;
574 }
575
setSite(dbSite * site)576 void dbMaster::setSite(dbSite* site)
577 {
578 _dbMaster* master = (_dbMaster*) this;
579 master->_site = site->getImpl()->getOID();
580 }
581
getSite()582 dbSite* dbMaster::getSite()
583 {
584 _dbMaster* master = (_dbMaster*) this;
585 _dbLib* lib = (_dbLib*) master->getOwner();
586
587 if (master->_site == 0)
588 return NULL;
589
590 return (dbSite*) lib->_site_tbl->getPtr(master->_site);
591 }
592
setSymmetryX()593 void dbMaster::setSymmetryX()
594 {
595 _dbMaster* master = (_dbMaster*) this;
596 master->_flags._x_symmetry = 1;
597 }
598
getSymmetryX()599 bool dbMaster::getSymmetryX()
600 {
601 _dbMaster* master = (_dbMaster*) this;
602 return master->_flags._x_symmetry != 0;
603 }
604
setSymmetryY()605 void dbMaster::setSymmetryY()
606 {
607 _dbMaster* master = (_dbMaster*) this;
608 master->_flags._y_symmetry = 1;
609 }
610
getSymmetryY()611 bool dbMaster::getSymmetryY()
612 {
613 _dbMaster* master = (_dbMaster*) this;
614 return master->_flags._y_symmetry != 0;
615 }
616
setSymmetryR90()617 void dbMaster::setSymmetryR90()
618 {
619 _dbMaster* master = (_dbMaster*) this;
620 master->_flags._R90_symmetry = 1;
621 }
622
getSymmetryR90()623 bool dbMaster::getSymmetryR90()
624 {
625 _dbMaster* master = (_dbMaster*) this;
626 return master->_flags._R90_symmetry != 0;
627 }
628
setFrozen()629 void dbMaster::setFrozen()
630 {
631 _dbMaster* master = (_dbMaster*) this;
632
633 if (master->_flags._frozen == 1)
634 return;
635
636 master->_flags._frozen = 1;
637
638 // set the order id on the mterm.
639 // this id is used to index mterms on a inst-hdr
640 dbSet<dbMTerm> mterms = getMTerms();
641 dbSet<dbMTerm>::iterator itr;
642 int i = 0;
643
644 for (itr = mterms.begin(); itr != mterms.end(); ++itr) {
645 _dbMTerm* mterm = (_dbMTerm*) *itr;
646 mterm->_order_id = i++;
647 }
648 }
getOutputIndex()649 int dbMaster::getOutputIndex()
650 {
651 _dbMaster* master = (_dbMaster*) this;
652 return master->_output_mterm_index;
653 }
setOutputIndex(int v)654 void dbMaster::setOutputIndex(int v)
655 {
656 _dbMaster* master = (_dbMaster*) this;
657 master->_output_mterm_index = v;
658 }
setClockedIndex(int v)659 void dbMaster::setClockedIndex(int v)
660 {
661 _dbMaster* master = (_dbMaster*) this;
662 master->_clocked_mterm_index = v;
663 }
getClockedIndex()664 int dbMaster::getClockedIndex()
665 {
666 _dbMaster* master = (_dbMaster*) this;
667 return master->_clocked_mterm_index;
668 }
setSequential(uint v)669 void dbMaster::setSequential(uint v)
670 {
671 _dbMaster* master = (_dbMaster*) this;
672 master->_flags._sequential = v;
673 }
674
isSequential()675 bool dbMaster::isSequential()
676 {
677 _dbMaster* master = (_dbMaster*) this;
678 return master->_flags._sequential > 0 ? true : false;
679 }
setMark(uint mark)680 void dbMaster::setMark(uint mark)
681 {
682 _dbMaster* master = (_dbMaster*) this;
683 master->_flags._mark = mark;
684 }
685
isMarked()686 uint dbMaster::isMarked()
687 {
688 _dbMaster* master = (_dbMaster*) this;
689 return master->_flags._mark;
690 }
691
setSpecialPower(bool value)692 void dbMaster::setSpecialPower(bool value)
693 {
694 _dbMaster* master = (_dbMaster*) this;
695 master->_flags._special_power = (value == true) ? 1 : 0;
696 }
697
isSpecialPower()698 bool dbMaster::isSpecialPower()
699 {
700 _dbMaster* master = (_dbMaster*) this;
701 return master->_flags._special_power == 1;
702 }
703
getPlacementBoundary(Rect & r)704 void dbMaster::getPlacementBoundary(Rect& r)
705 {
706 _dbMaster* master = (_dbMaster*) this;
707 r = Rect(0, 0, master->_width, master->_height);
708 dbTransform t(Point(-master->_x, -master->_y));
709 t.apply(r);
710 }
711
transform(dbTransform & t)712 void dbMaster::transform(dbTransform& t)
713 {
714 //_dbMaster * master = (_dbMaster *) this;
715 dbSet<dbBox> obs = getObstructions();
716 dbSet<dbBox>::iterator itr;
717
718 for (itr = obs.begin(); itr != obs.end(); ++itr) {
719 _dbBox* box = (_dbBox*) *itr;
720 t.apply(box->_shape._rect);
721 }
722
723 dbSet<dbMTerm> mterms = getMTerms();
724 dbSet<dbMTerm>::iterator mitr;
725
726 for (mitr = mterms.begin(); mitr != mterms.end(); ++mitr) {
727 dbMTerm* mterm = *mitr;
728 dbSet<dbMPin> mpins = mterm->getMPins();
729 dbSet<dbMPin>::iterator pitr;
730
731 for (pitr = mpins.begin(); pitr != mpins.end(); ++pitr) {
732 dbMPin* mpin = *pitr;
733
734 dbSet<dbBox> geoms = mpin->getGeometry();
735 dbSet<dbBox>::iterator gitr;
736
737 for (gitr = geoms.begin(); gitr != geoms.end(); ++gitr) {
738 _dbBox* box = (_dbBox*) *gitr;
739 t.apply(box->_shape._rect);
740 }
741 }
742 }
743 }
744
getMasterId()745 int dbMaster::getMasterId()
746 {
747 _dbMaster* master = (_dbMaster*) this;
748 return master->_id;
749 }
750
create(dbLib * lib_,const char * name_)751 dbMaster* dbMaster::create(dbLib* lib_, const char* name_)
752 {
753 if (lib_->findMaster(name_))
754 return NULL;
755
756 _dbLib* lib = (_dbLib*) lib_;
757 _dbDatabase* db = lib->getDatabase();
758 _dbMaster* master = lib->_master_tbl->create();
759 master->_name = strdup(name_);
760 ZALLOCATED(master->_name);
761 master->_id = db->_master_id++;
762 lib->_master_hash.insert(master);
763 return (dbMaster*) master;
764 }
765
getMaster(dbLib * lib_,uint dbid_)766 dbMaster* dbMaster::getMaster(dbLib* lib_, uint dbid_)
767 {
768 _dbLib* lib = (_dbLib*) lib_;
769 return (dbMaster*) lib->_master_tbl->getPtr(dbid_);
770 }
771
isFiller()772 bool dbMaster::isFiller()
773 {
774 _dbMaster* master = (_dbMaster*) this;
775 // dbMasterType type= dbMasterType(master->_flags._type);
776
777 if (getMTermCount() == 2) {
778 bool signal = false;
779 dbSet<dbMTerm>::iterator itr;
780 dbSet<dbMTerm> mterms = getMTerms();
781 for (itr = mterms.begin(); itr != mterms.end(); ++itr) {
782 dbMTerm* mt = *itr;
783 if (!((mt->getSigType() == dbSigType::GROUND)
784 || (mt->getSigType() == dbSigType::POWER))) {
785 signal = true;
786 break;
787 }
788 }
789 if (!signal)
790 return true;
791 }
792
793 switch (master->_flags._type) {
794 case dbMasterType::CORE_SPACER:
795 return true;
796 default:
797 return false;
798 }
799 }
800
isCoreAutoPlaceable()801 bool dbMaster::isCoreAutoPlaceable()
802 {
803 // Use switch so if new types are added we get a compiler warning.
804 switch (getType()) {
805 case dbMasterType::CORE:
806 case dbMasterType::CORE_FEEDTHRU:
807 case dbMasterType::CORE_TIEHIGH:
808 case dbMasterType::CORE_TIELOW:
809 case dbMasterType::CORE_SPACER:
810 case dbMasterType::CORE_WELLTAP:
811 case dbMasterType::CORE_ANTENNACELL:
812 case dbMasterType::BLOCK:
813 case dbMasterType::BLOCK_BLACKBOX:
814 case dbMasterType::BLOCK_SOFT:
815 case dbMasterType::ENDCAP:
816 case dbMasterType::ENDCAP_PRE:
817 case dbMasterType::ENDCAP_POST:
818 case dbMasterType::ENDCAP_TOPLEFT:
819 case dbMasterType::ENDCAP_TOPRIGHT:
820 case dbMasterType::ENDCAP_BOTTOMLEFT:
821 case dbMasterType::ENDCAP_BOTTOMRIGHT:
822 return true;
823 // These classes are completely ignored by the placer.
824 case dbMasterType::COVER:
825 case dbMasterType::COVER_BUMP:
826 case dbMasterType::RING:
827 case dbMasterType::PAD:
828 case dbMasterType::PAD_AREAIO:
829 case dbMasterType::PAD_INPUT:
830 case dbMasterType::PAD_OUTPUT:
831 case dbMasterType::PAD_INOUT:
832 case dbMasterType::PAD_POWER:
833 case dbMasterType::PAD_SPACER:
834 case dbMasterType::NONE:
835 return false;
836 }
837 // gcc warning
838 return false;
839 }
840
841 } // namespace odb
842