t-dll.h

   1 #ifndef __t_dll_H
   2 #define __t_dll_H
   3 /*
   4  * Copyright (c) 2000-2004 Stephen Williams (steve@icarus.com)
   5  *
   6  *    This source code is free software; you can redistribute it
   7  *    and/or modify it in source code form under the terms of the GNU
   8  *    General Public License as published by the Free Software
   9  *    Foundation; either version 2 of the License, or (at your option)
  10  *    any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  20  */
  21 #ifdef HAVE_CVS_IDENT
  22 #ident "$Id: t-dll.h,v 1.143 2007/06/02 03:42:13 steve Exp $"
  23 #endif
  24
  25 # include  "target.h"
  26 # include  "ivl_target.h"
  27 # include  "StringHeap.h"
  28 # include  "netlist.h"
  29
  30 #if defined(__MINGW32__)
  31 #include <windows.h>
  32 typedef void *ivl_dll_t;
  33 #elif defined(HAVE_DLFCN_H)
  34 # include  <dlfcn.h>
  35 typedef void* ivl_dll_t;
  36 #elif defined(HAVE_DL_H)
  37 # include  <dl.h>
  38 typedef shl_t ivl_dll_t;
  39 #else
  40 # error No DLL stub support for this target.
  41 #endif
  42
  43 struct ivl_design_s {
  44
  45       int time_precision;
  46
  47       ivl_scope_t *roots_;
  48       unsigned nroots_;
  49
  50       ivl_process_t threads_;
  51
  52       ivl_net_const_t*consts;
  53       unsigned nconsts;
  54
  55       const Design*self;
  56 };
  57
  58 /*
  59  * The DLL target type loads a named object file to handle the process
  60  * of scanning the netlist. When it is time to start the design, I
  61  * locate and link in the desired DLL, then start calling methods. The
  62  * DLL will call me back to get information out of the netlist in
  63  * particular.
  64  */
  65 struct dll_target  : public target_t, public expr_scan_t {
  66
  67       bool start_design(const Design*);
  68       int  end_design(const Design*);
  69
  70       bool bufz(const NetBUFZ*);
  71       void event(const NetEvent*);
  72       void logic(const NetLogic*);
  73       bool ureduce(const NetUReduce*);
  74       void net_case_cmp(const NetCaseCmp*);
  75       void udp(const NetUDP*);
  76       void lpm_add_sub(const NetAddSub*);
  77       bool lpm_array_dq(const NetArrayDq*);
  78       void lpm_clshift(const NetCLShift*);
  79       void lpm_compare(const NetCompare*);
  80       void lpm_divide(const NetDivide*);
  81       void lpm_ff(const NetFF*);
  82       void lpm_modulo(const NetModulo*);
  83       void lpm_mult(const NetMult*);
  84       void lpm_mux(const NetMux*);
  85       bool concat(const NetConcat*);
  86       bool part_select(const NetPartSelect*);
  87       bool replicate(const NetReplicate*);
  88       void net_assign(const NetAssign_*);
  89       bool net_sysfunction(const NetSysFunc*);
  90       bool net_function(const NetUserFunc*);
  91       bool net_const(const NetConst*);
  92       bool net_literal(const NetLiteral*);
  93       void net_probe(const NetEvProbe*);
  94       bool sign_extend(const NetSignExtend*);
  95
  96       bool process(const NetProcTop*);
  97       void scope(const NetScope*);
  98       void signal(const NetNet*);
  99       bool signal_paths(const NetNet*);
 100       ivl_dll_t dll_;
 101
 102       ivl_design_s des_;
 103
 104       target_design_f target_;
 105
 106
 107         /* These methods and members are used for forming the
 108            statements of a thread. */
 109       struct ivl_statement_s*stmt_cur_;
 110       void proc_assign(const NetAssign*);
 111       void proc_assign_nb(const NetAssignNB*);
 112       bool proc_block(const NetBlock*);
 113       void proc_case(const NetCase*);
 114       bool proc_cassign(const NetCAssign*);
 115       bool proc_condit(const NetCondit*);
 116       bool proc_deassign(const NetDeassign*);
 117       bool proc_delay(const NetPDelay*);
 118       bool proc_disable(const NetDisable*);
 119       bool proc_force(const NetForce*);
 120       void proc_forever(const NetForever*);
 121       bool proc_release(const NetRelease*);
 122       void proc_repeat(const NetRepeat*);
 123       void proc_stask(const NetSTask*);
 124       bool proc_trigger(const NetEvTrig*);
 125       void proc_utask(const NetUTask*);
 126       bool proc_wait(const NetEvWait*);
 127       void proc_while(const NetWhile*);
 128
 129       bool func_def(const NetScope*);
 130       void task_def(const NetScope*);
 131
 132       struct ivl_expr_s*expr_;
 133       void expr_binary(const NetEBinary*);
 134       void expr_concat(const NetEConcat*);
 135       void expr_const(const NetEConst*);
 136       void expr_creal(const NetECReal*);
 137       void expr_param(const NetEConstParam*);
 138       void expr_event(const NetEEvent*);
 139       void expr_scope(const NetEScope*);
 140       void expr_select(const NetESelect*);
 141       void expr_sfunc(const NetESFunc*);
 142       void expr_ternary(const NetETernary*);
 143       void expr_ufunc(const NetEUFunc*);
 144       void expr_unary(const NetEUnary*);
 145       void expr_signal(const NetESignal*);
 146
 147       ivl_scope_t lookup_scope_(const NetScope*scope);
 148
 149       ivl_attribute_s* fill_in_attributes(const Attrib*net);
 150       void logic_attributes(struct ivl_net_logic_s *obj, const NetNode*net);
 151
 152     private:
 153       StringHeap strings_;
 154
 155       static ivl_scope_t find_scope(ivl_design_s &des, const NetScope*cur);
 156       static ivl_signal_t find_signal(ivl_design_s &des, const NetNet*net);
 157       static ivl_parameter_t scope_find_param(ivl_scope_t scope,
 158                                               const char*name);
 159
 160       void add_root(ivl_design_s &des_, const NetScope *s);
 161
 162       void make_assign_lvals_(const NetAssignBase*net);
 163       void sub_off_from_expr_(long);
 164       void mul_expr_by_const_(long);
 165
 166       void make_logic_delays_(struct ivl_net_logic_s*obj, const NetObj*net);
 167       void make_scope_parameters(ivl_scope_t scope, const NetScope*net);
 168       void make_scope_param_expr(ivl_parameter_t cur_par, NetExpr*etmp);
 169
 170       static ivl_expr_t expr_from_value_(const verinum&that);
 171 };
 172
 173 /*
 174  * These are various private declarations used by the t-dll target.
 175  */
 176
 177 struct ivl_delaypath_s {
 178       ivl_nexus_t src;
 179       ivl_nexus_t condit;
 180       bool posedge;
 181       bool negedge;
 182       uint64_t delay[12];
 183 };
 184
 185 struct ivl_event_s {
 186       perm_string name;
 187       ivl_scope_t scope;
 188       unsigned nany, nneg, npos;
 189       ivl_nexus_t*pins;
 190 };
 191
 192 /*
 193  * The ivl_expr_t is an opaque reference to one of these
 194  * structures. This structure holds all the information we need about
 195  * an expression node, including its type, the expression width, and
 196  * type specific properties.
 197  */
 198 struct ivl_expr_s {
 199       ivl_expr_type_t type_;
 200       ivl_variable_type_t value_;
 201
 202       unsigned width_;
 203       unsigned signed_ : 1;
 204
 205       union {
 206             struct {
 207                   char op_;
 208                   ivl_expr_t lef_;
 209                   ivl_expr_t rig_;
 210             } binary_;
 211
 212             struct {
 213                   unsigned   rept;
 214                   unsigned   parms;
 215                   ivl_expr_t*parm;
 216             } concat_;
 217
 218             struct {
 219                   char*bits_;
 220                   ivl_parameter_t parameter;
 221             } number_;
 222
 223             struct {
 224                   ivl_event_t event;
 225             } event_;
 226
 227             struct {
 228                   ivl_scope_t scope;
 229             } scope_;
 230
 231             struct {
 232                   ivl_signal_t sig;
 233                   ivl_expr_t word;
 234             } signal_;
 235
 236             struct {
 237                   const char *name_;
 238                   ivl_expr_t *parm;
 239                   unsigned   parms;
 240             } sfunc_;
 241
 242             struct {
 243                   char*value_;
 244                   ivl_parameter_t parameter;
 245             } string_;
 246
 247             struct {
 248                   ivl_expr_t cond;
 249                   ivl_expr_t true_e;
 250                   ivl_expr_t false_e;
 251             } ternary_;
 252
 253             struct {
 254                   ivl_memory_t mem_;
 255                   ivl_expr_t idx_;
 256             } memory_;
 257
 258             struct {
 259                   ivl_scope_t def;
 260                   ivl_expr_t  *parm;
 261                   unsigned    parms;
 262             } ufunc_;
 263
 264             struct {
 265                   unsigned long value;
 266             } ulong_;
 267
 268             struct {
 269                   double value;
 270                   ivl_parameter_t parameter;
 271             } real_;
 272
 273             struct {
 274                   char op_;
 275                   ivl_expr_t sub_;
 276             } unary_;
 277
 278       } u_;
 279 };
 280
 281 /*
 282  * LPM devices are handled by this suite of types. The ivl_lpm_s
 283  * structure holds the core, including a type code, the object name
 284  * and scope. The other properties of the device are held in the type
 285  * specific member of the union.
 286  */
 287
 288 struct ivl_lpm_s {
 289       ivl_lpm_type_t type;
 290       ivl_scope_t scope;
 291       perm_string name;
 292         // Value returned by ivl_lpm_width;
 293       unsigned width;
 294
 295       union {
 296             struct ivl_lpm_ff_s {
 297                   ivl_nexus_t clk;
 298                   ivl_nexus_t we;
 299                   ivl_nexus_t aclr;
 300                   ivl_nexus_t aset;
 301                   ivl_nexus_t sclr;
 302                   ivl_nexus_t sset;
 303                   union {
 304                         ivl_nexus_t*pins;
 305                         ivl_nexus_t pin;
 306                   } q;
 307                   union {
 308                         ivl_nexus_t*pins;
 309                         ivl_nexus_t pin;
 310                   } d;
 311                   ivl_expr_t aset_value;
 312                   ivl_expr_t sset_value;
 313             } ff;
 314
 315             struct ivl_lpm_mux_s {
 316                   unsigned size;
 317                   unsigned swid;
 318                   ivl_nexus_t*d;
 319                   ivl_nexus_t q, s;
 320             } mux;
 321
 322             struct ivl_lpm_shift_s {
 323                   unsigned select;
 324                   unsigned signed_flag :1;
 325                   ivl_nexus_t q, d, s;
 326             } shift;
 327
 328             struct ivl_lpm_arith_s {
 329                   unsigned signed_flag :1;
 330                   ivl_nexus_t q,  a,  b;
 331             } arith;
 332
 333             struct ivl_lpm_array_s {
 334                   ivl_signal_t sig;
 335                   unsigned swid;
 336                   ivl_nexus_t q,  a;
 337             } array;
 338
 339             struct ivl_concat_s {
 340                   unsigned inputs;
 341                   ivl_nexus_t*pins;
 342             } concat;
 343
 344             struct ivl_part_s {
 345                   unsigned base;
 346                   unsigned signed_flag :1;
 347                   ivl_nexus_t q, a, s;
 348             } part;
 349
 350               // IVL_LPM_RE_* and IVL_LPM_SIGN_EXT use this.
 351             struct ivl_lpm_reduce_s {
 352                   ivl_nexus_t q,  a;
 353             } reduce;
 354
 355             struct ivl_lpm_repeat_s {
 356                   unsigned count;
 357                   ivl_nexus_t q, a;
 358             } repeat;
 359
 360             struct ivl_lpm_sfunc_s {
 361                   const char* fun_name;
 362                   unsigned ports;
 363                   ivl_nexus_t*pins;
 364             } sfunc;
 365
 366             struct ivl_lpm_ufunc_s {
 367                   ivl_scope_t def;
 368                   unsigned ports;
 369                   ivl_nexus_t*pins;
 370             } ufunc;
 371       } u_;
 372 };
 373
 374 /*
 375  * This object represents l-values to assignments. The l-value can be
 376  * a register bit or part select, or a memory word select with a part
 377  * select.
 378  */
 379
 380 enum ivl_lval_type_t {
 381       IVL_LVAL_REG = 0,
 382       IVL_LVAL_MUX = 1,
 383       /* IVL_LVAL_MEM = 2, / Deprecated in favor of LVAL_ARR? */
 384       IVL_LVAL_NET = 3, /* Only force can have NET l-values */
 385       IVL_LVAL_ARR = 4
 386 };
 387
 388 struct ivl_lval_s {
 389       ivl_expr_t loff;
 390       ivl_expr_t idx;
 391       unsigned width_;
 392       unsigned type_   : 8;
 393       union {
 394             ivl_signal_t sig;
 395             ivl_memory_t mem;
 396       } n;
 397 };
 398
 399 /*
 400  * This object represents a literal constant, possibly signed, in a
 401  * structural context.
 402  */
 403 struct ivl_net_const_s {
 404       ivl_variable_type_t type;
 405       unsigned width_;
 406       unsigned signed_ : 1;
 407
 408       union {
 409             double real_value;
 410             char bit_[sizeof(char*)];
 411             char *bits_;
 412       } b;
 413
 414       ivl_nexus_t pin_;
 415 };
 416
 417 /*
 418  * Logic gates (just about everything that has a single output) are
 419  * represented structurally by instances of this object.
 420  */
 421 struct ivl_net_logic_s {
 422       ivl_logic_t type_;
 423       unsigned width_;
 424       ivl_udp_t udp;
 425
 426       perm_string name_;
 427       ivl_scope_t scope_;
 428
 429       unsigned npins_;
 430       ivl_nexus_t*pins_;
 431
 432       struct ivl_attribute_s*attr;
 433       unsigned nattr;
 434
 435       ivl_expr_t delay[3];
 436 };
 437
 438
 439 /*
 440  * UDP definition.
 441  */
 442 struct ivl_udp_s {
 443       perm_string name;
 444       unsigned nin;
 445       int sequ; /* boolen */
 446       char init;
 447       unsigned nrows;
 448       typedef const char*ccharp_t;
 449       ccharp_t*table; // zero terminated array of pointers
 450 };
 451
 452 /*
 453  * The ivl_nexus_t is a single-bit link of some number of pins of
 454  * devices. the __nexus_ptr structure is a helper that actually does
 455  * the pointing.
 456  *
 457  * The type_ member specifies which of the object pointers in the
 458  * union are valid.
 459  *
 460  * The drive01 members gives the strength of the drive that the device
 461  * is applying to the nexus, with 0 HiZ and 3 supply. If the pin is an
 462  * input to the device, then the drives are both HiZ.
 463  */
 464 struct ivl_nexus_ptr_s {
 465       unsigned pin_;
 466       unsigned type_ : 8;
 467       unsigned drive0 : 3;
 468       unsigned drive1 : 3;
 469       union {
 470             ivl_signal_t    sig; /* type 0 */
 471             ivl_net_logic_t log; /* type 1 */
 472             ivl_net_const_t con; /* type 2 */
 473             ivl_lpm_t       lpm; /* type 3 */
 474       } l;
 475 };
 476 # define __NEXUS_PTR_SIG 0
 477 # define __NEXUS_PTR_LOG 1
 478 # define __NEXUS_PTR_CON 2
 479 # define __NEXUS_PTR_LPM 3
 480
 481 /*
 482  * NOTE: ONLY allocat ivl_nexus_s objects with the included "new" operator.
 483  */
 484 struct ivl_nexus_s {
 485       unsigned nptr_;
 486       struct ivl_nexus_ptr_s*ptrs_;
 487       const Nexus*nexus_;
 488       const char*name_;
 489       void*private_data;
 490
 491       void* operator new (size_t s);
 492       void  operator delete(void*obj, size_t s); // Not implemented
 493 };
 494
 495 /*
 496  * This is the implementation of a parameter. Each scope has a list of
 497  * these.
 498  */
 499 struct ivl_parameter_s {
 500       perm_string basename;
 501       ivl_scope_t scope;
 502       ivl_expr_t  value;
 503 };
 504 /*
 505  * All we know about a process it its type (initial or always) and the
 506  * single statement that is it. A process also has a scope, although
 507  * that generally only matters for VPI calls.
 508  */
 509 struct ivl_process_s {
 510       ivl_process_type_t type_;
 511       ivl_scope_t scope_;
 512       ivl_statement_t stmt_;
 513
 514       struct ivl_attribute_s*attr;
 515       unsigned nattr;
 516
 517       ivl_process_t next_;
 518 };
 519
 520 /*
 521  * Scopes are kept in a tree. Each scope points to its first child,
 522  * and also to any siblings. Thus a parent can scan all its children
 523  * by following its child pointer then following sibling pointers from
 524  * there.
 525  */
 526 struct ivl_scope_s {
 527       ivl_scope_t child_, sibling_, parent;
 528
 529       perm_string name_;
 530       perm_string tname_;
 531       ivl_scope_type_t type_;
 532
 533       unsigned nsigs_;
 534       ivl_signal_t*sigs_;
 535
 536       unsigned nlog_;
 537       ivl_net_logic_t*log_;
 538
 539       unsigned nevent_;
 540       ivl_event_t* event_;
 541
 542       unsigned nlpm_;
 543       ivl_lpm_t* lpm_;
 544
 545       unsigned nparam_;
 546       ivl_parameter_t param_;
 547
 548         /* Scopes that are tasks/functions have a definition. */
 549       ivl_statement_t def;
 550
 551       unsigned ports;
 552       ivl_signal_t*port;
 553
 554       signed int time_units :8;
 555
 556       struct ivl_attribute_s*attr;
 557       unsigned nattr;
 558 };
 559
 560 /*
 561  * A signal is a thing like a wire, a reg, or whatever. It has a type,
 562  * and if it is a port is also has a direction. Signals are collected
 563  * into scopes (which also point back to me) and have pins that
 564  * connect to the rest of the netlist.
 565  */
 566 struct ivl_signal_s {
 567       ivl_signal_type_t type_;
 568       ivl_signal_port_t port_;
 569       ivl_variable_type_t data_type;
 570
 571       unsigned width_;
 572       unsigned signed_ : 1;
 573       unsigned isint_  : 1;
 574       unsigned local_  : 1;
 575
 576         /* For now, support only 0 or 1 array dimensions. */
 577       unsigned array_dimensions_ : 1;
 578
 579         /* These encode the run-time index for the least significant
 580            bit, and the distance to the second bit. */
 581       signed lsb_index;
 582       signed lsb_dist;
 583
 584       perm_string name_;
 585       ivl_scope_t scope_;
 586
 587       unsigned array_words;
 588       int array_base;
 589       union {
 590             ivl_nexus_t pin;
 591             ivl_nexus_t*pins;
 592       };
 593
 594       ivl_delaypath_s*path;
 595       unsigned npath;
 596
 597       struct ivl_attribute_s*attr;
 598       unsigned nattr;
 599 };
 600
 601 /*
 602  * The ivl_statement_t represents any statement. The type of statement
 603  * is defined by the ivl_statement_type_t enumeration. Given the type,
 604  * certain information about the statement may be available.
 605  */
 606 struct ivl_statement_s {
 607       enum ivl_statement_type_e type_;
 608       union {
 609             struct { /* IVL_ST_ASSIGN IVL_ST_ASSIGN_NB
 610                         IVL_ST_CASSIGN, IVL_ST_DEASSIGN */
 611                   unsigned lvals_;
 612                   struct ivl_lval_s*lval_;
 613                   ivl_expr_t rval_;
 614                   ivl_expr_t delay;
 615             } assign_;
 616
 617             struct { /* IVL_ST_BLOCK, IVL_ST_FORK */
 618                   struct ivl_statement_s*stmt_;
 619                   unsigned nstmt_;
 620                   ivl_scope_t scope;
 621             } block_;
 622
 623             struct { /* IVL_ST_CASE, IVL_ST_CASEX, IVL_ST_CASEZ */
 624                   ivl_expr_t cond;
 625                   unsigned ncase;
 626                   ivl_expr_t*case_ex;
 627                   struct ivl_statement_s*case_st;
 628             } case_;
 629
 630             struct { /* IVL_ST_CONDIT */
 631                     /* This is the condition expression */
 632                   ivl_expr_t cond_;
 633                     /* This is two statements, the true and false. */
 634                   struct ivl_statement_s*stmt_;
 635             } condit_;
 636
 637             struct { /* IVL_ST_DELAY */
 638                   uint64_t delay_;
 639                   ivl_statement_t stmt_;
 640             } delay_;
 641
 642             struct { /* IVL_ST_DELAYX */
 643                   ivl_expr_t expr; /* XXXX */
 644                   ivl_statement_t stmt_;
 645             } delayx_;
 646
 647             struct { /* IVL_ST_DISABLE */
 648                   ivl_scope_t scope;
 649             } disable_;
 650
 651             struct { /* IVL_ST_FOREVER */
 652                   ivl_statement_t stmt_;
 653             } forever_;
 654
 655             struct { /* IVL_ST_STASK */
 656                   const char*name_;
 657                   unsigned   nparm_;
 658                   ivl_expr_t*parms_;
 659             } stask_;
 660
 661             struct { /* IVL_ST_UTASK */
 662                   ivl_scope_t def;
 663             } utask_;
 664
 665             struct { /* IVL_ST_TRIGGER IVL_ST_WAIT */
 666                   unsigned nevent;
 667                   union {
 668                         ivl_event_t event;
 669                         ivl_event_t*events;
 670                   };
 671                   ivl_statement_t stmt_;
 672             } wait_;
 673
 674             struct { /* IVL_ST_WHILE IVL_ST_REPEAT */
 675                   ivl_expr_t cond_;
 676                   ivl_statement_t stmt_;
 677             } while_;
 678       } u_;
 679 };
 680
 681 /*
 682  * $Log: t-dll.h,v $
 683  * Revision 1.143  2007/06/02 03:42:13  steve
 684  *  Properly evaluate scope path expressions.
 685  *
 686  * Revision 1.142  2007/04/02 01:12:34  steve
 687  *  Seperate arrayness from word count
 688  *
 689  * Revision 1.141  2007/03/26 20:32:47  steve
 690  *  More efficient allocate of ivl_nexus_t objects.
 691  *
 692  * Revision 1.140  2007/03/26 16:51:49  steve
 693  *  do not calculate nexus name unless needed.
 694  *
 695  * Revision 1.139  2007/03/02 06:13:22  steve
 696  *  Add support for edge sensitive spec paths.
 697  *
 698  * Revision 1.138  2007/03/01 06:19:39  steve
 699  *  Add support for conditional specify delay paths.
 700  *
 701  * Revision 1.137  2007/01/17 05:00:12  steve
 702  *  Dead code for memories in scopes.
 703  *
 704  * Revision 1.136  2007/01/17 04:39:18  steve
 705  *  Remove dead code related to memories.
 706  *
 707  * Revision 1.135  2007/01/16 05:44:16  steve
 708  *  Major rework of array handling. Memories are replaced with the
 709  *  more general concept of arrays. The NetMemory and NetEMemory
 710  *  classes are removed from the ivl core program, and the IVL_LPM_RAM
 711  *  lpm type is removed from the ivl_target API.
 712  *
 713  * Revision 1.134  2006/11/10 05:44:45  steve
 714  *  Process delay paths in second path over signals.
 715  *
 716  * Revision 1.133  2006/09/23 04:57:19  steve
 717  *  Basic support for specify timing.
 718  *
 719  * Revision 1.132  2006/08/08 05:11:37  steve
 720  *  Handle 64bit delay constants.
 721  *
 722  * Revision 1.131  2006/06/18 04:15:50  steve
 723  *  Add support for system functions in continuous assignments.
 724  *
 725  * Revision 1.130  2006/02/02 02:43:59  steve
 726  *  Allow part selects of memory words in l-values.
 727  *
 728  * Revision 1.129  2006/01/02 05:33:19  steve
 729  *  Node delays can be more general expressions in structural contexts.
 730  *
 731  * Revision 1.128  2005/07/11 16:56:51  steve
 732  *  Remove NetVariable and ivl_variable_t structures.
 733  *
 734  * Revision 1.127  2005/07/07 16:22:49  steve
 735  *  Generalize signals to carry types.
 736  *
 737  * Revision 1.126  2005/05/24 01:44:28  steve
 738  *  Do sign extension of structuran nets.
 739  *
 740  * Revision 1.125  2005/05/08 23:44:08  steve
 741  *  Add support for variable part select.
 742  *
 743  * Revision 1.124  2005/04/01 06:04:30  steve
 744  *  Clean up handle of UDPs.
 745  *
 746  * Revision 1.123  2005/03/18 02:56:04  steve
 747  *  Add support for LPM_UFUNC user defined functions.
 748  *
 749  * Revision 1.122  2005/02/19 02:43:39  steve
 750  *  Support shifts and divide.
 751  *
 752  * Revision 1.121  2005/02/12 06:25:40  steve
 753  *  Restructure NetMux devices to pass vectors.
 754  *  Generate NetMux devices from ternary expressions,
 755  *  Reduce NetMux devices to bufif when appropriate.
 756  *
 757  * Revision 1.120  2005/02/08 00:12:36  steve
 758  *  Add the NetRepeat node, and code generator support.
 759  *
 760  * Revision 1.119  2005/02/03 04:56:20  steve
 761  *  laborate reduction gates into LPM_RED_ nodes.
 762  *
 763  * Revision 1.118  2005/01/24 05:28:31  steve
 764  *  Remove the NetEBitSel and combine all bit/part select
 765  *  behavior into the NetESelect node and IVL_EX_SELECT
 766  *  ivl_target expression type.
 767  *
 768  * Revision 1.117  2004/12/29 23:55:43  steve
 769  *  Unify elaboration of l-values for all proceedural assignments,
 770  *  including assing, cassign and force.
 771  *
 772  *  Generate NetConcat devices for gate outputs that feed into a
 773  *  vector results. Use this to hande gate arrays. Also let gate
 774  *  arrays handle vectors of gates when the outputs allow for it.
 775  *
 776  * Revision 1.116  2004/12/11 02:31:28  steve
 777  *  Rework of internals to carry vectors through nexus instead
 778  *  of single bits. Make the ivl, tgt-vvp and vvp initial changes
 779  *  down this path.
 780  *
 781  * Revision 1.115  2004/10/04 01:10:56  steve
 782  *  Clean up spurious trailing white space.
 783  *
 784  * Revision 1.114  2004/06/30 02:16:27  steve
 785  *  Implement signed divide and signed right shift in nets.
 786  *
 787  * Revision 1.113  2004/05/31 23:34:39  steve
 788  *  Rewire/generalize parsing an elaboration of
 789  *  function return values to allow for better
 790  *  speed and more type support.
 791  *
 792  * Revision 1.112  2004/02/20 06:22:58  steve
 793  *  parameter keys are per_strings.
 794  *
 795  * Revision 1.111  2004/02/19 07:06:57  steve
 796  *  LPM, logic and Variables have perm_string names.
 797  *
 798  * Revision 1.110  2004/02/19 06:57:11  steve
 799  *  Memory and Event names use perm_string.
 800  *
 801  * Revision 1.109  2004/02/18 17:11:58  steve
 802  *  Use perm_strings for named langiage items.
 803  *
 804  * Revision 1.108  2003/12/03 02:46:24  steve
 805  *  Add support for wait on list of named events.
 806  *
 807  * Revision 1.107  2003/11/10 20:59:04  steve
 808  *  Design::get_flag returns const char* instead of string.
 809  *
 810  * Revision 1.106  2003/09/03 23:33:29  steve
 811  *  Pass FF synchronous set values to code generator.
 812  *
 813  * Revision 1.105  2003/08/15 02:23:53  steve
 814  *  Add synthesis support for synchronous reset.
 815  *
 816  * Revision 1.104  2003/06/23 01:25:44  steve
 817  *  Module attributes make it al the way to ivl_target.
 818  *
 819  * Revision 1.103  2003/06/17 21:28:59  steve
 820  *  Remove short int restrictions from vvp opcodes. (part 2)
 821  *
 822  * Revision 1.102  2003/04/22 04:48:30  steve
 823  *  Support event names as expressions elements.
 824  *
 825  * Revision 1.101  2003/04/11 05:18:08  steve
 826  *  Handle signed magnitude compare all the
 827  *  way through to the vvp code generator.
 828  *
 829  * Revision 1.100  2003/03/10 23:40:54  steve
 830  *  Keep parameter constants for the ivl_target API.
 831  *
 832  * Revision 1.99  2003/03/01 06:25:30  steve
 833  *  Add the lex_strings string handler, and put
 834  *  scope names and system task/function names
 835  *  into this table. Also, permallocate event
 836  *  names from the beginning.
 837  */
 838 #endif