emit.cc

   1 /*
   2  * Copyright (c) 1998-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 /*
  25  * The emit function is called to generate the output required of the
  26  * target.
  27  */
  28 # include  "target.h"
  29 # include  "netlist.h"
  30 # include  <typeinfo>
  31 # include  <cassert>
  32 # include  <cstring>
  33
  34 bool NetNode::emit_node(struct target_t*tgt) const
  35 {
  36       cerr << "EMIT: Gate type? " << typeid(*this).name() << endl;
  37       return false;
  38 }
  39
  40 bool NetLogic::emit_node(struct target_t*tgt) const
  41 {
  42       tgt->logic(this);
  43       return true;
  44 }
  45
  46 bool NetUDP::emit_node(struct target_t*tgt) const
  47 {
  48       tgt->udp(this);
  49       return true;
  50 }
  51
  52 bool NetAbs::emit_node(struct target_t*tgt) const
  53 {
  54       tgt->lpm_abs(this);
  55       return true;
  56 }
  57
  58 bool NetAddSub::emit_node(struct target_t*tgt) const
  59 {
  60       tgt->lpm_add_sub(this);
  61       return true;
  62 }
  63
  64 bool NetArrayDq::emit_node(struct target_t*tgt) const
  65 {
  66       return tgt->lpm_array_dq(this);
  67 }
  68
  69 bool NetCaseCmp::emit_node(struct target_t*tgt) const
  70 {
  71       tgt->net_case_cmp(this);
  72       return true;
  73 }
  74
  75 bool NetCLShift::emit_node(struct target_t*tgt) const
  76 {
  77       tgt->lpm_clshift(this);
  78       return true;
  79 }
  80
  81 bool NetCompare::emit_node(struct target_t*tgt) const
  82 {
  83       tgt->lpm_compare(this);
  84       return true;
  85 }
  86
  87 bool NetConcat::emit_node(struct target_t*tgt) const
  88 {
  89       return tgt->concat(this);
  90 }
  91
  92 bool NetConst::emit_node(struct target_t*tgt) const
  93 {
  94       return tgt->net_const(this);
  95 }
  96
  97 bool NetDivide::emit_node(struct target_t*tgt) const
  98 {
  99       tgt->lpm_divide(this);
 100       return true;
 101 }
 102
 103 bool NetFF::emit_node(struct target_t*tgt) const
 104 {
 105       tgt->lpm_ff(this);
 106       return true;
 107 }
 108
 109 bool NetLiteral::emit_node(struct target_t*tgt) const
 110 {
 111       return tgt->net_literal(this);
 112 }
 113
 114 bool NetModulo::emit_node(struct target_t*tgt) const
 115 {
 116       tgt->lpm_modulo(this);
 117       return true;
 118 }
 119
 120 bool NetMult::emit_node(struct target_t*tgt) const
 121 {
 122       tgt->lpm_mult(this);
 123       return true;
 124 }
 125
 126 bool NetMux::emit_node(struct target_t*tgt) const
 127 {
 128       tgt->lpm_mux(this);
 129       return true;
 130 }
 131
 132 bool NetPartSelect::emit_node(struct target_t*tgt) const
 133 {
 134       return tgt->part_select(this);
 135 }
 136
 137 bool NetPow::emit_node(struct target_t*tgt) const
 138 {
 139       tgt->lpm_pow(this);
 140       return true;
 141 }
 142
 143 bool NetReplicate::emit_node(struct target_t*tgt) const
 144 {
 145       return tgt->replicate(this);
 146 }
 147
 148 bool NetSignExtend::emit_node(struct target_t*tgt) const
 149 {
 150       return tgt->sign_extend(this);
 151 }
 152
 153 bool NetUReduce::emit_node(struct target_t*tgt) const
 154 {
 155       return tgt->ureduce(this);
 156 }
 157
 158 bool NetSysFunc::emit_node(struct target_t*tgt) const
 159 {
 160       return tgt->net_sysfunction(this);
 161 }
 162
 163 bool NetUserFunc::emit_node(struct target_t*tgt) const
 164 {
 165       return tgt->net_function(this);
 166 }
 167
 168 bool NetTran::emit_node(struct target_t*tgt) const
 169 {
 170       return tgt->tran(this);
 171 }
 172
 173 bool NetBUFZ::emit_node(struct target_t*tgt) const
 174 {
 175       return tgt->bufz(this);
 176 }
 177
 178 bool NetProcTop::emit(struct target_t*tgt) const
 179 {
 180       return tgt->process(this);
 181 }
 182
 183 bool NetProc::emit_proc(struct target_t*tgt) const
 184 {
 185       cerr << "EMIT: Proc type? " << typeid(*this).name() << endl;
 186       return false;
 187 }
 188
 189 bool NetAssign::emit_proc(struct target_t*tgt) const
 190 {
 191       tgt->proc_assign(this);
 192       return true;
 193 }
 194
 195 bool NetAssignNB::emit_proc(struct target_t*tgt) const
 196 {
 197       tgt->proc_assign_nb(this);
 198       return true;
 199 }
 200
 201 bool NetBlock::emit_proc(struct target_t*tgt) const
 202 {
 203       return tgt->proc_block(this);
 204 }
 205
 206 bool NetCase::emit_proc(struct target_t*tgt) const
 207 {
 208       tgt->proc_case(this);
 209       return true;
 210 }
 211
 212 bool NetCAssign::emit_proc(struct target_t*tgt) const
 213 {
 214       return tgt->proc_cassign(this);
 215 }
 216
 217 bool NetCondit::emit_proc(struct target_t*tgt) const
 218 {
 219       return tgt->proc_condit(this);
 220 }
 221
 222 bool NetDeassign::emit_proc(struct target_t*tgt) const
 223 {
 224       return tgt->proc_deassign(this);
 225 }
 226
 227 bool NetDisable::emit_proc(struct target_t*tgt) const
 228 {
 229       return tgt->proc_disable(this);
 230 }
 231
 232 bool NetForce::emit_proc(struct target_t*tgt) const
 233 {
 234       return tgt->proc_force(this);
 235 }
 236
 237 bool NetForever::emit_proc(struct target_t*tgt) const
 238 {
 239       tgt->proc_forever(this);
 240       return true;
 241 }
 242
 243 bool NetPDelay::emit_proc(struct target_t*tgt) const
 244 {
 245       return tgt->proc_delay(this);
 246 }
 247
 248 bool NetPDelay::emit_proc_recurse(struct target_t*tgt) const
 249 {
 250       if (statement_) return statement_->emit_proc(tgt);
 251       return true;
 252 }
 253
 254 bool NetRelease::emit_proc(struct target_t*tgt) const
 255 {
 256       return tgt->proc_release(this);
 257 }
 258
 259 bool NetRepeat::emit_proc(struct target_t*tgt) const
 260 {
 261       tgt->proc_repeat(this);
 262       return true;
 263 }
 264
 265 bool NetSTask::emit_proc(struct target_t*tgt) const
 266 {
 267       tgt->proc_stask(this);
 268       return true;
 269 }
 270
 271 bool NetUTask::emit_proc(struct target_t*tgt) const
 272 {
 273       tgt->proc_utask(this);
 274       return true;
 275 }
 276
 277 bool NetWhile::emit_proc(struct target_t*tgt) const
 278 {
 279       tgt->proc_while(this);
 280       return true;
 281 }
 282
 283 void NetBlock::emit_recurse(struct target_t*tgt) const
 284 {
 285       if (last_ == 0)
 286             return;
 287
 288       NetProc*cur = last_;
 289       do {
 290             cur = cur->next_;
 291             cur->emit_proc(tgt);
 292       } while (cur != last_);
 293 }
 294
 295 bool NetCondit::emit_recurse_if(struct target_t*tgt) const
 296 {
 297       if (if_)
 298             return if_->emit_proc(tgt);
 299       else
 300             return true;
 301 }
 302
 303 bool NetCondit::emit_recurse_else(struct target_t*tgt) const
 304 {
 305       if (else_)
 306             return else_->emit_proc(tgt);
 307       else
 308             return true;
 309 }
 310
 311 bool NetEvProbe::emit_node(struct target_t*tgt) const
 312 {
 313       tgt->net_probe(this);
 314       return true;
 315 }
 316
 317 bool NetEvTrig::emit_proc(struct target_t*tgt) const
 318 {
 319       return tgt->proc_trigger(this);
 320 }
 321
 322 bool NetEvWait::emit_proc(struct target_t*tgt) const
 323 {
 324       return tgt->proc_wait(this);
 325 }
 326
 327 bool NetEvWait::emit_recurse(struct target_t*tgt) const
 328 {
 329       if (!statement_) return true;
 330       return statement_->emit_proc(tgt);
 331 }
 332
 333 void NetForever::emit_recurse(struct target_t*tgt) const
 334 {
 335       if (statement_)
 336             statement_->emit_proc(tgt);
 337 }
 338
 339 void NetRepeat::emit_recurse(struct target_t*tgt) const
 340 {
 341       if (statement_)
 342             statement_->emit_proc(tgt);
 343 }
 344
 345 void NetScope::emit_scope(struct target_t*tgt) const
 346 {
 347       tgt->scope(this);
 348
 349       for (NetEvent*cur = events_ ;  cur ;  cur = cur->snext_)
 350             tgt->event(cur);
 351
 352       for (NetScope*cur = sub_ ;  cur ;  cur = cur->sib_)
 353             cur->emit_scope(tgt);
 354
 355       if (signals_) {
 356             NetNet*cur = signals_->sig_next_;
 357             do {
 358                   tgt->signal(cur);
 359                   cur = cur->sig_next_;
 360             } while (cur != signals_->sig_next_);
 361
 362               /* Run the signals again, but this time to connect the
 363                  delay paths. This is done as a second pass because
 364                  the paths reference other signals that may be later
 365                  in the list. We can do it here becase delay paths are
 366                  always connected within the scope. */
 367             cur = signals_->sig_next_;
 368             do {
 369                   tgt->signal_paths(cur);
 370                   cur = cur->sig_next_;
 371             } while (cur != signals_->sig_next_);
 372       }
 373
 374 }
 375
 376 bool NetScope::emit_defs(struct target_t*tgt) const
 377 {
 378       bool flag = true;
 379
 380       switch (type_) {
 381           case MODULE:
 382             for (NetScope*cur = sub_ ;  cur ;  cur = cur->sib_)
 383                   flag &= cur->emit_defs(tgt);
 384             break;
 385
 386           case FUNC:
 387             flag &= tgt->func_def(this);
 388             break;
 389           case TASK:
 390             tgt->task_def(this);
 391             break;
 392           default:  /* BEGIN_END and FORK_JOIN, GENERATE... */
 393             for (NetScope*cur = sub_ ;  cur ;  cur = cur->sib_)
 394                   flag &= cur->emit_defs(tgt);
 395             break;
 396       }
 397
 398       return flag;
 399 }
 400
 401 void NetWhile::emit_proc_recurse(struct target_t*tgt) const
 402 {
 403       proc_->emit_proc(tgt);
 404 }
 405
 406 int Design::emit(struct target_t*tgt) const
 407 {
 408       int rc = 0;
 409
 410       if (tgt->start_design(this) == false)
 411             return -2;
 412
 413         // enumerate the scopes
 414       for (list<NetScope*>::const_iterator scope = root_scopes_.begin();
 415            scope != root_scopes_.end(); scope++)
 416             (*scope)->emit_scope(tgt);
 417
 418
 419         // emit nodes
 420       bool nodes_rc = true;
 421       if (nodes_) {
 422             NetNode*cur = nodes_->node_next_;
 423             do {
 424                   nodes_rc = nodes_rc && cur->emit_node(tgt);
 425                   cur = cur->node_next_;
 426             } while (cur != nodes_->node_next_);
 427       }
 428
 429
 430         // emit task and function definitions
 431       bool tasks_rc = true;
 432       for (list<NetScope*>::const_iterator scope = root_scopes_.begin();
 433            scope != root_scopes_.end(); scope++)
 434             tasks_rc &= (*scope)->emit_defs(tgt);
 435
 436
 437         // emit the processes
 438       bool proc_rc = true;
 439       for (const NetProcTop*idx = procs_ ;  idx ;  idx = idx->next_)
 440             proc_rc &= idx->emit(tgt);
 441
 442       rc = tgt->end_design(this);
 443
 444       if (nodes_rc == false)
 445             return -1;
 446       if (tasks_rc == false)
 447             return -2;
 448       if (proc_rc == false)
 449           return -3;
 450
 451       return rc;
 452 }
 453
 454 void NetEBinary::expr_scan(struct expr_scan_t*tgt) const
 455 {
 456       tgt->expr_binary(this);
 457 }
 458
 459 void NetEConcat::expr_scan(struct expr_scan_t*tgt) const
 460 {
 461       tgt->expr_concat(this);
 462 }
 463
 464 void NetEConst::expr_scan(struct expr_scan_t*tgt) const
 465 {
 466       tgt->expr_const(this);
 467 }
 468
 469 void NetEConstParam::expr_scan(struct expr_scan_t*tgt) const
 470 {
 471       tgt->expr_param(this);
 472 }
 473
 474 void NetECReal::expr_scan(struct expr_scan_t*tgt) const
 475 {
 476       tgt->expr_creal(this);
 477 }
 478
 479 void NetECRealParam::expr_scan(struct expr_scan_t*tgt) const
 480 {
 481       tgt->expr_rparam(this);
 482 }
 483
 484 void NetEParam::expr_scan(struct expr_scan_t*tgt) const
 485 {
 486       cerr << get_fileline() << ":internal error: unexpected NetEParam."
 487            << endl;
 488 }
 489
 490 void NetEEvent::expr_scan(struct expr_scan_t*tgt) const
 491 {
 492       tgt->expr_event(this);
 493 }
 494
 495 void NetEScope::expr_scan(struct expr_scan_t*tgt) const
 496 {
 497       tgt->expr_scope(this);
 498 }
 499
 500 void NetESelect::expr_scan(struct expr_scan_t*tgt) const
 501 {
 502       tgt->expr_select(this);
 503 }
 504
 505 void NetESFunc::expr_scan(struct expr_scan_t*tgt) const
 506 {
 507       tgt->expr_sfunc(this);
 508 }
 509
 510 void NetEUFunc::expr_scan(struct expr_scan_t*tgt) const
 511 {
 512       tgt->expr_ufunc(this);
 513 }
 514
 515 void NetESignal::expr_scan(struct expr_scan_t*tgt) const
 516 {
 517       tgt->expr_signal(this);
 518 }
 519
 520 void NetETernary::expr_scan(struct expr_scan_t*tgt) const
 521 {
 522       tgt->expr_ternary(this);
 523 }
 524
 525 void NetEUnary::expr_scan(struct expr_scan_t*tgt) const
 526 {
 527       tgt->expr_unary(this);
 528 }
 529
 530 int emit(const Design*des, const char*type)
 531 {
 532       for (unsigned idx = 0 ;  target_table[idx] ;  idx += 1) {
 533             const struct target*tgt = target_table[idx];
 534             if (strcmp(tgt->name, type) == 0)
 535                   return des->emit(tgt->meth);
 536
 537       }
 538
 539       cerr << "error: Code generator type " << type
 540            << " not found." << endl;
 541       return -1;
 542 }