net_nex_input.cc

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