net_nex_input.cc

   1 /*
   2  * Copyright (c) 2002 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 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: net_nex_input.cc,v 1.16 2007/01/16 05:44:15 steve Exp $"
  21 #endif
  22
  23 # include "config.h"
  24
  25 # include <iostream>
  26
  27 # include  <cassert>
  28 # include  <typeinfo>
  29 # include  "netlist.h"
  30 # include  "netmisc.h"
  31
  32 NexusSet* NetExpr::nex_input(bool rem_out)
  33 {
  34       cerr << get_line()
  35            << ": internal error: nex_input not implemented: "
  36            << *this << endl;
  37       return 0;
  38 }
  39
  40 NexusSet* NetProc::nex_input(bool rem_out)
  41 {
  42       cerr << get_line()
  43            << ": internal error: NetProc::nex_input not implemented"
  44            << endl;
  45       return 0;
  46 }
  47
  48 NexusSet* NetEBinary::nex_input(bool rem_out)
  49 {
  50       NexusSet*result = left_->nex_input(rem_out);
  51       NexusSet*tmp = right_->nex_input(rem_out);
  52       result->add(*tmp);
  53       delete tmp;
  54       return result;
  55 }
  56
  57 NexusSet* NetEConcat::nex_input(bool rem_out)
  58 {
  59       NexusSet*result = parms_[0]->nex_input(rem_out);
  60       for (unsigned idx = 1 ;  idx < parms_.count() ;  idx += 1) {
  61             NexusSet*tmp = parms_[idx]->nex_input(rem_out);
  62             result->add(*tmp);
  63             delete tmp;
  64       }
  65       return result;
  66 }
  67
  68 /*
  69  * A constant has not inputs, so always return an empty set.
  70  */
  71 NexusSet* NetEConst::nex_input(bool rem_out)
  72 {
  73       return new NexusSet;
  74 }
  75
  76 NexusSet* NetECReal::nex_input(bool rem_out)
  77 {
  78       return new NexusSet;
  79 }
  80
  81 /*
  82  * A parameter by definition has no inputs. It represents a constant
  83  * value, even if that value is a constant expression.
  84  */
  85 NexusSet* NetEParam::nex_input(bool rem_out)
  86 {
  87       return new NexusSet;
  88 }
  89
  90 NexusSet* NetEEvent::nex_input(bool rem_out)
  91 {
  92       return new NexusSet;
  93 }
  94
  95 NexusSet* NetEScope::nex_input(bool rem_out)
  96 {
  97       return new NexusSet;
  98 }
  99
 100 NexusSet* NetESelect::nex_input(bool rem_out)
 101 {
 102       NexusSet*result = base_? base_->nex_input(rem_out) : new NexusSet();
 103       NexusSet*tmp = expr_->nex_input(rem_out);
 104       result->add(*tmp);
 105       delete tmp;
 106       return result;
 107 }
 108
 109 NexusSet* NetESFunc::nex_input(bool rem_out)
 110 {
 111       if (nparms_ == 0)
 112             return new NexusSet;
 113
 114       NexusSet*result = parms_[0]->nex_input(rem_out);
 115       for (unsigned idx = 1 ;  idx < nparms_ ;  idx += 1) {
 116             NexusSet*tmp = parms_[idx]->nex_input(rem_out);
 117             result->add(*tmp);
 118             delete tmp;
 119       }
 120       return result;
 121 }
 122
 123 NexusSet* NetESignal::nex_input(bool rem_out)
 124 {
 125       NexusSet*result = new NexusSet;
 126       for (unsigned idx = 0 ;  idx < net_->pin_count() ;  idx += 1)
 127             result->add(net_->pin(idx).nexus());
 128
 129       return result;
 130 }
 131
 132 NexusSet* NetETernary::nex_input(bool rem_out)
 133 {
 134       NexusSet*tmp;
 135       NexusSet*result = cond_->nex_input(rem_out);
 136
 137       tmp = true_val_->nex_input(rem_out);
 138       result->add(*tmp);
 139       delete tmp;
 140
 141       tmp = false_val_->nex_input(rem_out);
 142       result->add(*tmp);
 143       delete tmp;
 144
 145       return result;
 146 }
 147
 148 NexusSet* NetEUFunc::nex_input(bool rem_out)
 149 {
 150       NexusSet*result = new NexusSet;
 151       for (unsigned idx = 0 ;  idx < parms_.count() ;  idx += 1) {
 152             NexusSet*tmp = parms_[idx]->nex_input(rem_out);
 153             result->add(*tmp);
 154             delete tmp;
 155       }
 156
 157       return result;
 158 }
 159
 160 NexusSet* NetEUnary::nex_input(bool rem_out)
 161 {
 162       return expr_->nex_input(rem_out);
 163 }
 164
 165 NexusSet* NetAssign_::nex_input(bool rem_out)
 166 {
 167       NexusSet*result = new NexusSet;
 168       if (word_) {
 169             NexusSet*tmp = word_->nex_input(rem_out);
 170             result->add(*tmp);
 171             delete tmp;
 172       }
 173       if (base_) {
 174             NexusSet*tmp = base_->nex_input(rem_out);
 175             result->add(*tmp);
 176             delete tmp;
 177       }
 178
 179       return result;
 180 }
 181
 182 NexusSet* NetAssignBase::nex_input(bool rem_out)
 183 {
 184       NexusSet*result = rval_->nex_input(rem_out);
 185
 186         /* It is possible that the lval_ can hav nex_input values. In
 187            particular, index expressions are statement inputs as well,
 188            so should be addressed here. */
 189       for (NetAssign_*cur = lval_ ;  cur ;  cur = cur->more) {
 190             NexusSet*tmp = cur->nex_input(rem_out);
 191             result->add(*tmp);
 192             delete tmp;
 193       }
 194
 195       return result;
 196 }
 197
 198 /*
 199  * The nex_input of a begin/end block is the NexusSet of bits that the
 200  * block reads from outside the block. That means it is the union of
 201  * the nex_input for all the substatements.
 202  *
 203  * The input set for a sequential set is not exactly the union of the
 204  * input sets because there is the possibility of intermediate values,
 205  * that don't deserve to be in the input set. To wit:
 206  *
 207  *      begin
 208  *         t = a + b;
 209  *         c = ~t;
 210  *      end
 211  *
 212  * In this example, "t" should not be in the input set because it is
 213  * used by the sequence as a temporary value.
 214  */
 215 NexusSet* NetBlock::nex_input(bool rem_out)
 216 {
 217       if (last_ == 0)
 218             return new NexusSet;
 219
 220       if (type_ == PARA) {
 221             cerr << get_line() << ": internal error: Sorry, "
 222                  << "I don't know how to synthesize fork/join blocks."
 223                  << endl;
 224             return 0;
 225       }
 226
 227       NetProc*cur = last_->next_;
 228         /* This is the accumulated input set. */
 229       NexusSet*result = new NexusSet;
 230         /* This is an accumulated output set. */
 231       NexusSet*prev = new NexusSet;
 232
 233       do {
 234               /* Get the inputs for the current statement. */
 235             NexusSet*tmp = cur->nex_input(rem_out);
 236
 237               /* Add the current input set to the accumulated input set. */
 238             result->add(*tmp);
 239             delete tmp;
 240
 241               /* Add the current outputs to the accumulated output set,
 242                  so they can be removed from the input set below. */
 243             cur->nex_output(*prev);
 244
 245             cur = cur->next_;
 246       } while (cur != last_->next_);
 247
 248         /* Remove from the input set those bits that are outputs
 249            from other statements. They aren't really inputs
 250            to the block, just internal intermediate values. */
 251       if (rem_out) result->rem(*prev);
 252
 253       return result;
 254 }
 255
 256 /*
 257  * The inputs to a case statement are the inputs to the expression,
 258  * the inputs to all the guards, and the inputs to all the guarded
 259  * statements.
 260  */
 261 NexusSet* NetCase::nex_input(bool rem_out)
 262 {
 263       NexusSet*result = expr_->nex_input(rem_out);
 264       if (result == 0)
 265             return 0;
 266
 267       for (unsigned idx = 0 ;  idx < nitems_ ;  idx += 1) {
 268
 269               /* Skip cases that have empty statements. */
 270             if (items_[idx].statement == 0)
 271                   continue;
 272
 273             NexusSet*tmp = items_[idx].statement->nex_input(rem_out);
 274             assert(tmp);
 275             result->add(*tmp);
 276             delete tmp;
 277
 278               /* Usually, this is the guard expression. The default
 279                  case is special and is identified by a null
 280                  guard. The default guard obviously has no input. */
 281             if (items_[idx].guard) {
 282                   tmp = items_[idx].guard->nex_input(rem_out);
 283                   assert(tmp);
 284                   result->add(*tmp);
 285                   delete tmp;
 286             }
 287       }
 288
 289       return result;
 290 }
 291
 292 NexusSet* NetCAssign::nex_input(bool rem_out)
 293 {
 294       cerr << get_line() << ": internal warning: NetCAssign::nex_input()"
 295            << " not implemented." << endl;
 296       return new NexusSet;
 297 }
 298
 299 NexusSet* NetCondit::nex_input(bool rem_out)
 300 {
 301       NexusSet*result = expr_->nex_input(rem_out);
 302       if (if_ != 0) {
 303             NexusSet*tmp = if_->nex_input(rem_out);
 304             result->add(*tmp);
 305             delete tmp;
 306       }
 307
 308       if (else_ != 0) {
 309             NexusSet*tmp = else_->nex_input(rem_out);
 310             result->add(*tmp);
 311             delete tmp;
 312       }
 313
 314       return result;
 315 }
 316
 317 NexusSet* NetForce::nex_input(bool rem_out)
 318 {
 319       cerr << get_line() << ": internal warning: NetForce::nex_input()"
 320            << " not implemented." << endl;
 321       return new NexusSet;
 322 }
 323
 324 NexusSet* NetForever::nex_input(bool rem_out)
 325 {
 326       NexusSet*result = statement_->nex_input(rem_out);
 327       return result;
 328 }
 329
 330 /*
 331  * The NetPDelay statement is a statement of the form
 332  *
 333  *   #<expr> <statement>
 334  *
 335  * The nex_input set is the input set of the <statement>. Do *not*
 336  * include the input set of the <expr> because it does not affect the
 337  * result.
 338  */
 339 NexusSet* NetPDelay::nex_input(bool rem_out)
 340 {
 341       NexusSet*result = statement_->nex_input(rem_out);
 342       return result;
 343 }
 344
 345 NexusSet* NetRepeat::nex_input(bool rem_out)
 346 {
 347       NexusSet*result = statement_->nex_input(rem_out);
 348       NexusSet*tmp = expr_->nex_input(rem_out);
 349       result->add(*tmp);
 350       delete tmp;
 351       return result;
 352 }
 353
 354 NexusSet* NetSTask::nex_input(bool rem_out)
 355 {
 356       if (parms_.count() == 0)
 357             return new NexusSet;
 358
 359       NexusSet*result = parms_[0]->nex_input(rem_out);
 360       for (unsigned idx = 1 ;  idx < parms_.count() ;  idx += 1) {
 361             NexusSet*tmp = parms_[idx]->nex_input(rem_out);
 362             result->add(*tmp);
 363             delete tmp;
 364       }
 365
 366       return result;
 367 }
 368
 369 /*
 370  * The NetUTask represents a call to a user defined task. There are no
 371  * parameters to consider, because the compiler already removed them
 372  * and converted them to blocking assignments.
 373  */
 374 NexusSet* NetUTask::nex_input(bool rem_out)
 375 {
 376       return new NexusSet;
 377 }
 378
 379 NexusSet* NetWhile::nex_input(bool rem_out)
 380 {
 381       NexusSet*result = proc_->nex_input(rem_out);
 382       NexusSet*tmp = cond_->nex_input(rem_out);
 383       result->add(*tmp);
 384       delete tmp;
 385       return result;
 386 }
 387