net_expr.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 # include  "netlist.h"
  22 # include  "compiler.h"
  23 # include  <iostream>
  24
  25 /*
  26  * the grand default data type is a logic vector.
  27  */
  28 ivl_variable_type_t NetExpr::expr_type() const
  29 {
  30       return IVL_VT_LOGIC;
  31 }
  32
  33 /*
  34  * Create an add/sub node from the two operands. Make a best guess of
  35  * the
  36  */
  37 NetEBAdd::NetEBAdd(char op, NetExpr*l, NetExpr*r, bool lossless_flag)
  38 : NetEBinary(op, l, r)
  39 {
  40       NetEConst* tmp;
  41
  42         /* Catch the special case that one of the operands is an
  43            unsized constant number. If so, then we should set the
  44            width of that number to the size of the other operand, plus
  45            one. This expands the expression to account for the largest
  46            possible result.
  47
  48            The set_width applied to a constant value will only
  49            truncate the constant so far as it can still hold its
  50            logical value, so this is safe to do. */
  51       if ( (tmp = dynamic_cast<NetEConst*>(r))
  52            && (! tmp->has_width())
  53            && (tmp->expr_width() > l->expr_width()) ) {
  54
  55             unsigned target_width = l->expr_width() + 1;
  56             r->set_width(target_width);
  57
  58               /* Note: This constant value will not gain a defined
  59                  width from this. Make sure. */
  60             assert(! r->has_width() );
  61
  62       } else if ( (tmp = dynamic_cast<NetEConst*>(l))
  63            && (! tmp->has_width())
  64            && (tmp->expr_width() > r->expr_width()) ) {
  65
  66             unsigned target_width = r->expr_width() + 1;
  67             l->set_width(target_width);
  68
  69               /* Note: This constant value will not gain a defined
  70                  width from this. Make sure. */
  71             assert(! l->has_width() );
  72
  73       }
  74
  75       unsigned pad_width = lossless_flag? 1 : 0;
  76
  77         /* Now that we have the operand sizes the way we like, or as
  78            good as we are going to get them, set the size of myself. */
  79       if (r->expr_width() > l->expr_width()) {
  80
  81             expr_width(r->expr_width() + pad_width);
  82
  83       } else {
  84             expr_width(l->expr_width() + pad_width);
  85       }
  86
  87       cast_signed(l->has_sign() && r->has_sign());
  88 }
  89
  90 NetEBAdd::~NetEBAdd()
  91 {
  92 }
  93
  94 NetEBAdd* NetEBAdd::dup_expr() const
  95 {
  96       NetEBAdd*result = new NetEBAdd(op_, left_->dup_expr(),
  97                                      right_->dup_expr());
  98       return result;
  99 }
 100
 101 ivl_variable_type_t NetEBAdd::expr_type() const
 102 {
 103       if (left_->expr_type() == IVL_VT_REAL)
 104             return IVL_VT_REAL;
 105
 106       if (right_->expr_type() == IVL_VT_REAL)
 107             return IVL_VT_REAL;
 108
 109       return IVL_VT_LOGIC;
 110 }
 111
 112 /*
 113  * Create a comparison operator with two sub-expressions.
 114  *
 115  * Handle the special case of an unsized constant on the left or right
 116  * side by resizing the number to match the other
 117  * expression. Otherwise, the netlist will have to allow the
 118  * expressions to have different widths.
 119  */
 120 NetEBComp::NetEBComp(char op, NetExpr*l, NetExpr*r)
 121 : NetEBinary(op, l, r)
 122 {
 123       if (NetEConst*tmp = dynamic_cast<NetEConst*>(r)) do {
 124
 125             if (tmp->has_width())
 126                   break;
 127
 128             if (l->expr_width() == 0)
 129                   break;
 130
 131             if (tmp->expr_width() == l->expr_width())
 132                   break;
 133
 134             tmp->set_width(l->expr_width());
 135
 136       } while (0);
 137
 138       if (NetEConst*tmp = dynamic_cast<NetEConst*>(l)) do {
 139
 140             if (tmp->has_width())
 141                   break;
 142
 143             if (r->expr_width() == 0)
 144                   break;
 145
 146             if (tmp->expr_width() == r->expr_width())
 147                   break;
 148
 149             tmp->set_width(r->expr_width());
 150
 151       } while (0);
 152
 153
 154       expr_width(1);
 155 }
 156
 157 NetEBComp::~NetEBComp()
 158 {
 159 }
 160
 161 bool NetEBComp::has_width() const
 162 {
 163       return true;
 164 }
 165
 166 ivl_variable_type_t NetEBComp::expr_type() const
 167 {
 168         // Case compare always returns BOOL
 169       if (op() == 'E' || op() == 'N')
 170             return IVL_VT_BOOL;
 171
 172       if (left()->expr_type() == IVL_VT_LOGIC)
 173             return IVL_VT_LOGIC;
 174
 175       if (right()->expr_type() == IVL_VT_LOGIC)
 176             return IVL_VT_LOGIC;
 177
 178       return IVL_VT_BOOL;
 179 }
 180
 181 NetEBDiv::NetEBDiv(char op, NetExpr*l, NetExpr*r)
 182 : NetEBinary(op, l, r)
 183 {
 184       unsigned w = l->expr_width();
 185       if (r->expr_width() > w)
 186             w = r->expr_width();
 187
 188       expr_width(w);
 189       cast_signed(l->has_sign() && r->has_sign());
 190 }
 191
 192 NetEBDiv::~NetEBDiv()
 193 {
 194 }
 195
 196 NetEBDiv* NetEBDiv::dup_expr() const
 197 {
 198       NetEBDiv*result = new NetEBDiv(op_, left_->dup_expr(),
 199                                        right_->dup_expr());
 200       return result;
 201 }
 202
 203 ivl_variable_type_t NetEBDiv::expr_type() const
 204 {
 205       if (left_->expr_type() == IVL_VT_REAL)
 206             return IVL_VT_REAL;
 207
 208       if (right_->expr_type() == IVL_VT_REAL)
 209             return IVL_VT_REAL;
 210
 211       return IVL_VT_LOGIC;
 212 }
 213
 214 NetEBMult::NetEBMult(char op, NetExpr*l, NetExpr*r)
 215 : NetEBinary(op, l, r)
 216 {
 217       expr_width(l->expr_width() + r->expr_width());
 218       cast_signed(l->has_sign() && r->has_sign());
 219
 220         /* If it turns out that this is not a signed expression, then
 221            cast the signedness out of the operands as well. */
 222       if (! has_sign()) {
 223             l->cast_signed(false);
 224             r->cast_signed(false);
 225       }
 226 }
 227
 228 NetEBMult::~NetEBMult()
 229 {
 230 }
 231
 232 NetEBMult* NetEBMult::dup_expr() const
 233 {
 234       NetEBMult*result = new NetEBMult(op_, left_->dup_expr(),
 235                                        right_->dup_expr());
 236       return result;
 237 }
 238
 239 ivl_variable_type_t NetEBMult::expr_type() const
 240 {
 241       if (left_->expr_type() == IVL_VT_REAL)
 242             return IVL_VT_REAL;
 243
 244       if (right_->expr_type() == IVL_VT_REAL)
 245             return IVL_VT_REAL;
 246
 247       return IVL_VT_LOGIC;
 248 }
 249
 250 NetEBPow::NetEBPow(char op, NetExpr*l, NetExpr*r)
 251 : NetEBinary(op, l, r)
 252 {
 253       assert(op == 'p');
 254       expr_width(l->expr_width());
 255       cast_signed(l->has_sign() || r->has_sign());
 256 }
 257
 258 NetEBPow::~NetEBPow()
 259 {
 260 }
 261
 262 NetEBPow* NetEBPow::dup_expr() const
 263 {
 264       NetEBPow*result = new NetEBPow(op_, left_->dup_expr(),
 265                                      right_->dup_expr());
 266       result->set_line(*this);
 267       return result;
 268 }
 269
 270 ivl_variable_type_t NetEBPow::expr_type() const
 271 {
 272       if (right_->expr_type() == IVL_VT_REAL)
 273             return IVL_VT_REAL;
 274       if (left_->expr_type() == IVL_VT_REAL)
 275             return IVL_VT_REAL;
 276       if (left_->has_sign())
 277             return IVL_VT_REAL;
 278       if (right_->has_sign())
 279             return IVL_VT_REAL;
 280
 281       return IVL_VT_LOGIC;
 282 }
 283
 284 NetEBShift::NetEBShift(char op, NetExpr*l, NetExpr*r)
 285 : NetEBinary(op, l, r)
 286 {
 287       expr_width(l->expr_width());
 288
 289         // The >>> is signed if the left operand is signed.
 290       if (op == 'R') cast_signed(l->has_sign());
 291 }
 292
 293 NetEBShift::~NetEBShift()
 294 {
 295 }
 296
 297 bool NetEBShift::has_width() const
 298 {
 299       return left_->has_width();
 300 }
 301
 302 NetEBShift* NetEBShift::dup_expr() const
 303 {
 304       NetEBShift*result = new NetEBShift(op_, left_->dup_expr(),
 305                                          right_->dup_expr());
 306       return result;
 307 }
 308
 309 NetEConcat::NetEConcat(unsigned cnt, NetExpr* r)
 310 : parms_(cnt), repeat_(r)
 311 {
 312       if (repeat_ == 0) {
 313             repeat_calculated_ = true;
 314             repeat_value_ = 1;
 315       } else {
 316             repeat_calculated_ = false;
 317       }
 318
 319       expr_width(0);
 320 }
 321
 322 NetEConcat::~NetEConcat()
 323 {
 324       for (unsigned idx = 0 ;  idx < parms_.count() ;  idx += 1)
 325             delete parms_[idx];
 326 }
 327
 328 bool NetEConcat::has_width() const
 329 {
 330       return true;
 331 }
 332
 333 void NetEConcat::set(unsigned idx, NetExpr*e)
 334 {
 335       assert(idx < parms_.count());
 336       assert(parms_[idx] == 0);
 337       parms_[idx] = e;
 338       expr_width( expr_width() + e->expr_width() );
 339 }
 340
 341 NetEConcat* NetEConcat::dup_expr() const
 342 {
 343       NetEConcat*dup = new NetEConcat(parms_.count(), repeat_);
 344       for (unsigned idx = 0 ;  idx < parms_.count() ;  idx += 1)
 345             if (parms_[idx]) {
 346                   NetExpr*tmp = parms_[idx]->dup_expr();
 347                   assert(tmp);
 348                   dup->parms_[idx] = tmp;
 349             }
 350
 351
 352       dup->expr_width(expr_width());
 353       return dup;
 354 }
 355
 356 unsigned NetEConcat::repeat()
 357 {
 358       if (repeat_calculated_)
 359             return repeat_value_;
 360
 361       assert(repeat_);
 362
 363       if (! dynamic_cast<NetEConst*>(repeat_)) {
 364             NetExpr*tmp = repeat_->eval_tree();
 365             if (tmp != 0) {
 366                   delete repeat_;
 367                   repeat_ = tmp;
 368             }
 369       }
 370
 371       NetEConst*repeat_const = dynamic_cast<NetEConst*>(repeat_);
 372
 373         /* This should not be possible, as it was checked earlier to
 374            assure that this is a constant expression. */
 375       if (repeat_const == 0) {
 376             cerr << get_line() << ": internal error: repeat expression "
 377                  << "is not a compile time constant." << endl;
 378             cerr << get_line() << ":               : Expression is: "
 379                  << *repeat_ << endl;
 380             repeat_calculated_ = true;
 381             repeat_value_ = 1;
 382             return 1;
 383       }
 384
 385       repeat_calculated_ = true;
 386       repeat_value_ = repeat_const->value().as_ulong();
 387
 388       delete repeat_;
 389       repeat_ = 0;
 390
 391       return repeat_value_;
 392 }
 393
 394 unsigned NetEConcat::repeat() const
 395 {
 396       assert(repeat_calculated_);
 397       return repeat_value_;
 398 }
 399
 400 NetECReal::NetECReal(const verireal&val)
 401 : value_(val)
 402 {
 403       expr_width(1);
 404 }
 405
 406 NetECReal::~NetECReal()
 407 {
 408 }
 409
 410 const verireal& NetECReal::value() const
 411 {
 412       return value_;
 413 }
 414
 415 bool NetECReal::has_width() const
 416 {
 417       return false;
 418 }
 419
 420 NetECReal* NetECReal::dup_expr() const
 421 {
 422       NetECReal*tmp = new NetECReal(value_);
 423       tmp->set_line(*this);
 424       return tmp;
 425 }
 426
 427 ivl_variable_type_t NetECReal::expr_type() const
 428 {
 429       return IVL_VT_REAL;
 430 }
 431
 432 NetECRealParam::NetECRealParam(NetScope*s, perm_string n, const verireal&v)
 433 : NetECReal(v), scope_(s), name_(n)
 434 {
 435 }
 436
 437 NetECRealParam::~NetECRealParam()
 438 {
 439 }
 440
 441 perm_string NetECRealParam::name() const
 442 {
 443       return name_;
 444 }
 445
 446 const NetScope* NetECRealParam::scope() const
 447 {
 448       return scope_;
 449 }
 450
 451
 452 NetEParam::NetEParam()
 453 : des_(0), scope_(0)
 454 {
 455 }
 456
 457 NetEParam::NetEParam(Design*d, NetScope*s, perm_string n)
 458 : des_(d), scope_(s), name_(n)
 459 {
 460 }
 461
 462 NetEParam::~NetEParam()
 463 {
 464 }
 465
 466 bool NetEParam::has_width() const
 467 {
 468       return false;
 469 }
 470
 471 NetEParam* NetEParam::dup_expr() const
 472 {
 473       NetEParam*tmp = new NetEParam(des_, scope_, name_);
 474       tmp->set_line(*this);
 475       return tmp;
 476 }
 477
 478 NetESelect::NetESelect(NetExpr*exp, NetExpr*base, unsigned wid)
 479 : expr_(exp), base_(base)
 480 {
 481       expr_width(wid);
 482 }
 483
 484 NetESelect::~NetESelect()
 485 {
 486       delete expr_;
 487       delete base_;
 488 }
 489
 490 const NetExpr*NetESelect::sub_expr() const
 491 {
 492       return expr_;
 493 }
 494
 495 const NetExpr*NetESelect::select() const
 496 {
 497       return base_;
 498 }
 499
 500 bool NetESelect::has_width() const
 501 {
 502       return true;
 503 }
 504
 505 NetESFunc::NetESFunc(const char*n, ivl_variable_type_t t,
 506                      unsigned width, unsigned np)
 507 : name_(0), type_(t)
 508 {
 509       name_ = lex_strings.add(n);
 510       expr_width(width);
 511       nparms_ = np;
 512       parms_ = new NetExpr*[np];
 513       for (unsigned idx = 0 ;  idx < nparms_ ;  idx += 1)
 514             parms_[idx] = 0;
 515 }
 516
 517 NetESFunc::~NetESFunc()
 518 {
 519       for (unsigned idx = 0 ;  idx < nparms_ ;  idx += 1)
 520             if (parms_[idx]) delete parms_[idx];
 521
 522       delete[]parms_;
 523         /* name_ string ls lex_strings allocated. */
 524 }
 525
 526 const char* NetESFunc::name() const
 527 {
 528       return name_;
 529 }
 530
 531 unsigned NetESFunc::nparms() const
 532 {
 533       return nparms_;
 534 }
 535
 536 void NetESFunc::parm(unsigned idx, NetExpr*v)
 537 {
 538       assert(idx < nparms_);
 539       if (parms_[idx])
 540             delete parms_[idx];
 541       parms_[idx] = v;
 542 }
 543
 544 const NetExpr* NetESFunc::parm(unsigned idx) const
 545 {
 546       assert(idx < nparms_);
 547       return parms_[idx];
 548 }
 549
 550 NetExpr* NetESFunc::parm(unsigned idx)
 551 {
 552       assert(idx < nparms_);
 553       return parms_[idx];
 554 }
 555
 556 ivl_variable_type_t NetESFunc::expr_type() const
 557 {
 558       return type_;
 559 }