net_link.cc

   1 /*
   2  * Copyright (c) 2000-2008 Stephen Williams (steve@icarus.com)
   3  *
   4  *    This source code is free software; you can redistribute it
   5  *    and/or modify it in source code form under the terms of the GNU
   6  *    General Public License as published by the Free Software
   7  *    Foundation; either version 2 of the License, or (at your option)
   8  *    any later version.
   9  *
  10  *    This program is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *    GNU General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU General Public License
  16  *    along with this program; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  18  */
  19
  20 # include "config.h"
  21
  22 # include  <iostream>
  23
  24 # include  "netlist.h"
  25 # include  <sstream>
  26 # include  <cstring>
  27 # include  <string>
  28 # include  <typeinfo>
  29 #ifdef HAVE_MALLOC_H
  30 # include  <malloc.h>
  31 #endif
  32
  33 void connect(Nexus*l, Link&r)
  34 {
  35       assert(l);
  36       assert(r.nexus_);
  37
  38       if (l == r.nexus_)
  39             return;
  40
  41
  42       Nexus*tmp = r.nexus_;
  43       while (Link*cur = tmp->list_) {
  44             tmp->list_ = cur->next_;
  45             cur->nexus_ = 0;
  46             cur->next_  = 0;
  47             l->relink(cur);
  48       }
  49
  50       l->driven_ = Nexus::NO_GUESS;
  51
  52       assert(tmp->list_ == 0);
  53       delete tmp;
  54 }
  55
  56 void connect(Link&l, Link&r)
  57 {
  58       assert(&l != &r);
  59       if (r.is_linked() && !l.is_linked())
  60             connect(r.nexus_, l);
  61       else
  62             connect(l.nexus_, r);
  63 }
  64
  65 Link::Link()
  66 : dir_(PASSIVE), drive0_(STRONG), drive1_(STRONG), init_(verinum::Vx),
  67   inst_(0), next_(0), nexus_(0)
  68 {
  69       (new Nexus()) -> relink(this);
  70 }
  71
  72 Link::~Link()
  73 {
  74       assert(nexus_);
  75       Nexus*tmp = nexus_;
  76       nexus_->unlink(this);
  77       if (tmp->list_ == 0)
  78             delete tmp;
  79 }
  80
  81 Nexus* Link::nexus()
  82 {
  83       return nexus_;
  84 }
  85
  86 const Nexus* Link::nexus() const
  87 {
  88       return nexus_;
  89 }
  90
  91 void Link::set_dir(DIR d)
  92 {
  93       dir_ = d;
  94 }
  95
  96 Link::DIR Link::get_dir() const
  97 {
  98       return dir_;
  99 }
 100
 101 void Link::drivers_delays(NetExpr*rise, NetExpr*fall, NetExpr*decay)
 102 {
 103       nexus_->drivers_delays(rise, fall, decay);
 104 }
 105
 106 void Link::drive0(Link::strength_t str)
 107 {
 108       drive0_ = str;
 109 }
 110
 111 void Link::drive1(Link::strength_t str)
 112 {
 113       drive1_ = str;
 114 }
 115
 116 Link::strength_t Link::drive0() const
 117 {
 118       return drive0_;
 119 }
 120
 121 Link::strength_t Link::drive1() const
 122 {
 123       return drive1_;
 124 }
 125
 126 void Link::set_init(verinum::V val)
 127 {
 128       init_ = val;
 129 }
 130
 131 verinum::V Link::get_init() const
 132 {
 133       return init_;
 134 }
 135
 136
 137 void Link::cur_link(NetObj*&net, unsigned &pin)
 138 {
 139       net = node_;
 140       pin = pin_;
 141 }
 142
 143 void Link::cur_link(const NetObj*&net, unsigned &pin) const
 144 {
 145       net = node_;
 146       pin = pin_;
 147 }
 148
 149 void Link::unlink()
 150 {
 151       assert(nexus_);
 152       if (! is_linked())
 153             return;
 154
 155       nexus_->unlink(this);
 156       (new Nexus()) -> relink(this);
 157 }
 158
 159 bool Link::is_equal(const Link&that) const
 160 {
 161       return (node_ == that.node_) && (pin_ == that.pin_);
 162 }
 163
 164 bool Link::is_linked() const
 165 {
 166       if (next_)
 167             return true;
 168       if (nexus_->first_nlink() != this)
 169             return true;
 170
 171       return false;
 172 }
 173
 174 bool Link::is_linked(const Link&that) const
 175 {
 176       return nexus_ == that.nexus_;
 177 }
 178
 179 Link* Link::next_nlink()
 180 {
 181       return next_;
 182 }
 183
 184 const Link* Link::next_nlink() const
 185 {
 186       return next_;
 187 }
 188
 189 const NetObj*Link::get_obj() const
 190 {
 191       return node_;
 192 }
 193
 194 NetObj*Link::get_obj()
 195 {
 196       return node_;
 197 }
 198
 199 unsigned Link::get_pin() const
 200 {
 201       return pin_;
 202 }
 203
 204 void Link::set_name(perm_string n, unsigned i)
 205 {
 206       name_ = n;
 207       inst_ = i;
 208 }
 209
 210 perm_string Link::get_name() const
 211 {
 212       return name_;
 213 }
 214
 215 unsigned Link::get_inst() const
 216 {
 217       return inst_;
 218 }
 219
 220 Nexus::Nexus()
 221 {
 222       name_ = 0;
 223       list_ = 0;
 224       driven_ = NO_GUESS;
 225       t_cookie_ = 0;
 226 }
 227
 228 Nexus::~Nexus()
 229 {
 230       assert(list_ == 0);
 231       if (name_)
 232             delete[]name_;
 233 }
 234
 235 verinum::V Nexus::get_init() const
 236 {
 237       assert(list_);
 238       for (Link*cur = list_ ;  cur ;  cur = cur->next_) {
 239             if (cur->get_dir() == Link::OUTPUT)
 240                   return verinum::Vx;
 241
 242             if ((cur->get_dir() == Link::PASSIVE)
 243                 && (cur->get_init() != verinum::Vz))
 244                   return cur->get_init();
 245       }
 246
 247       return verinum::Vz;
 248 }
 249
 250 void Nexus::drivers_delays(NetExpr*rise, NetExpr*fall, NetExpr*decay)
 251 {
 252       for (Link*cur = list_ ; cur ; cur = cur->next_) {
 253             if (cur->get_dir() != Link::OUTPUT)
 254                   continue;
 255
 256             NetObj*obj = cur->get_obj();
 257             obj->rise_time(rise);
 258             obj->fall_time(fall);
 259             obj->decay_time(decay);
 260       }
 261 }
 262
 263 void Nexus::unlink(Link*that)
 264 {
 265       if (name_) {
 266             delete[] name_;
 267             name_ = 0;
 268       }
 269
 270         /* If the link I'm removing was a driver for this nexus, then
 271            cancel my guess of the driven value. */
 272       if (that->get_dir() != Link::INPUT)
 273             driven_ = NO_GUESS;
 274
 275       assert(that);
 276       if (list_ == that) {
 277             list_ = that->next_;
 278             that->next_ = 0;
 279             that->nexus_ = 0;
 280             return;
 281       }
 282
 283       Link*cur = list_;
 284       while (cur->next_ != that) {
 285             assert(cur->next_);
 286             cur = cur->next_;
 287       }
 288
 289       cur->next_ = that->next_;
 290       that->nexus_ = 0;
 291       that->next_ = 0;
 292 }
 293
 294 void Nexus::relink(Link*that)
 295 {
 296       if (name_) {
 297             delete[] name_;
 298             name_ = 0;
 299       }
 300
 301         /* If the link I'm adding is a driver for this nexus, then
 302            cancel my guess of the driven value. */
 303       if (that->get_dir() != Link::INPUT)
 304             driven_ = NO_GUESS;
 305
 306       assert(that->nexus_ == 0);
 307       assert(that->next_ == 0);
 308       that->next_ = list_;
 309       that->nexus_ = this;
 310       list_ = that;
 311 }
 312
 313 Link* Nexus::first_nlink()
 314 {
 315       return list_;
 316 }
 317
 318 const Link* Nexus::first_nlink() const
 319 {
 320       return list_;
 321 }
 322
 323 ivl_nexus_t Nexus::t_cookie() const
 324 {
 325       return t_cookie_;
 326 }
 327
 328 ivl_nexus_t Nexus::t_cookie(ivl_nexus_t val)const
 329 {
 330       ivl_nexus_t tmp = t_cookie_;
 331       t_cookie_ = val;
 332       return tmp;
 333 }
 334
 335 unsigned Nexus::vector_width() const
 336 {
 337       for (const Link*cur = first_nlink() ; cur ; cur = cur->next_nlink()) {
 338             const NetNet*sig = dynamic_cast<const NetNet*>(cur->get_obj());
 339             if (sig == 0)
 340                   continue;
 341
 342             return sig->vector_width();
 343       }
 344
 345       return 0;
 346 }
 347
 348 NetNet* Nexus::pick_any_net()
 349 {
 350       for (Link*cur = first_nlink() ; cur ; cur = cur->next_nlink()) {
 351             NetNet*sig = dynamic_cast<NetNet*>(cur->get_obj());
 352             if (sig != 0)
 353                   return sig;
 354       }
 355
 356       return 0;
 357 }
 358
 359 const char* Nexus::name() const
 360 {
 361       if (name_)
 362             return name_;
 363
 364       const NetNet*sig = 0;
 365       unsigned pin = 0;
 366       for (const Link*cur = first_nlink()
 367                  ;  cur  ;  cur = cur->next_nlink()) {
 368
 369             const NetNet*cursig = dynamic_cast<const NetNet*>(cur->get_obj());
 370             if (cursig == 0)
 371                   continue;
 372
 373             if (sig == 0) {
 374                   sig = cursig;
 375                   pin = cur->get_pin();
 376                   continue;
 377             }
 378
 379             if ((cursig->pin_count() == 1) && (sig->pin_count() > 1))
 380                   continue;
 381
 382             if ((cursig->pin_count() > 1) && (sig->pin_count() == 1)) {
 383                   sig = cursig;
 384                   pin = cur->get_pin();
 385                   continue;
 386             }
 387
 388             if (cursig->local_flag() && !sig->local_flag())
 389                   continue;
 390
 391             if (cursig->name() < sig->name())
 392                   continue;
 393
 394             sig = cursig;
 395             pin = cur->get_pin();
 396       }
 397
 398       if (sig == 0) {
 399             const Link*lnk = first_nlink();
 400             const NetObj*obj = lnk->get_obj();
 401             pin = lnk->get_pin();
 402             cerr << "internal error: No signal for nexus of " <<
 403                   obj->name() << " pin " << pin << "(" <<
 404                   lnk->get_name() << "<" << lnk->get_inst() << ">)"
 405                   " type=" << typeid(*obj).name() << "?" << endl;
 406
 407       }
 408       assert(sig);
 409       ostringstream tmp;
 410       tmp << scope_path(sig->scope()) << "." << sig->name();
 411       if (sig->pin_count() > 1)
 412             tmp << "<" << pin << ">";
 413
 414       const string tmps = tmp.str();
 415       name_ = new char[strlen(tmps.c_str()) + 1];
 416       strcpy(name_, tmps.c_str());
 417       return name_;
 418 }
 419
 420
 421 NexusSet::NexusSet()
 422 {
 423       items_ = 0;
 424       nitems_ = 0;
 425 }
 426
 427 NexusSet::~NexusSet()
 428 {
 429       if (nitems_ > 0) {
 430             assert(items_ != 0);
 431             free(items_);
 432       } else {
 433             assert(items_ == 0);
 434       }
 435 }
 436
 437 unsigned NexusSet::count() const
 438 {
 439       return nitems_;
 440 }
 441
 442 void NexusSet::add(Nexus*that)
 443 {
 444       if (nitems_ == 0) {
 445             assert(items_ == 0);
 446             items_ = (Nexus**)malloc(sizeof(Nexus*));
 447             items_[0] = that;
 448             nitems_ = 1;
 449             return;
 450       }
 451
 452       unsigned ptr = bsearch_(that);
 453       if (ptr < nitems_) {
 454             assert(items_[ptr] == that);
 455             return;
 456       }
 457
 458       assert(ptr == nitems_);
 459
 460       items_ = (Nexus**)realloc(items_, (nitems_+1) * sizeof(Nexus*));
 461       items_[ptr] = that;
 462       nitems_ += 1;
 463 }
 464
 465 void NexusSet::add(const NexusSet&that)
 466 {
 467       for (unsigned idx = 0 ;  idx < that.nitems_ ;  idx += 1)
 468             add(that.items_[idx]);
 469 }
 470
 471 void NexusSet::rem(Nexus*that)
 472 {
 473       if (nitems_ == 0)
 474             return;
 475
 476       unsigned ptr = bsearch_(that);
 477       if (ptr >= nitems_)
 478             return;
 479
 480       if (nitems_ == 1) {
 481             free(items_);
 482             items_ = 0;
 483             nitems_ = 0;
 484             return;
 485       }
 486
 487       for (unsigned idx = ptr ;  idx < (nitems_-1) ;  idx += 1)
 488             items_[idx] = items_[idx+1];
 489
 490       items_ = (Nexus**)realloc(items_, (nitems_-1) * sizeof(Nexus*));
 491       nitems_ -= 1;
 492 }
 493
 494 void NexusSet::rem(const NexusSet&that)
 495 {
 496       for (unsigned idx = 0 ;  idx < that.nitems_ ;  idx += 1)
 497             rem(that.items_[idx]);
 498 }
 499
 500 Nexus* NexusSet::operator[] (unsigned idx) const
 501 {
 502       assert(idx < nitems_);
 503       return items_[idx];
 504 }
 505
 506 unsigned NexusSet::bsearch_(Nexus*that) const
 507 {
 508       for (unsigned idx = 0 ;  idx < nitems_ ;  idx += 1) {
 509             if (items_[idx] == that)
 510                   return idx;
 511       }
 512
 513       return nitems_;
 514 }
 515
 516 bool NexusSet::contains(const NexusSet&that) const
 517 {
 518       for (unsigned idx = 0 ;  idx < that.nitems_ ;  idx += 1) {
 519             unsigned where = bsearch_(that[idx]);
 520             if (where == nitems_)
 521                   return false;
 522             if (items_[where] != that[idx])
 523                   return false;
 524       }
 525
 526       return true;
 527 }
 528
 529 bool NexusSet::intersect(const NexusSet&that) const
 530 {
 531       for (unsigned idx = 0 ;  idx < that.nitems_ ;  idx += 1) {
 532             unsigned where = bsearch_(that[idx]);
 533             if (where == nitems_)
 534                   continue;
 535             if (items_[where] == that[idx])
 536                   return true;
 537       }
 538
 539       return false;
 540 }