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