| blob | 92323d4a8017041f95331f4b3eb3ce4e3d08d08a |
1 /*
2 * Copyright (c) 1998-2006 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 #ifdef HAVE_CVS_IDENT
21 #endif
25 /*
26 * Elaboration takes as input a complete parse tree and the name of a
27 * root module, and generates as output the elaborated design. This
28 * elaborated design is presented as a Module, which does not
29 * reference any other modules. It is entirely self contained.
30 */
32 # include <typeinfo>
33 # include <sstream>
34 # include <list>
48 {
62 }
64 }
68 {
71 }
73 /*
74 * Elaborate the continuous assign. (This is *not* the procedural
75 * assign.) Elaborate the lvalue and rvalue, and do the assignment.
76 */
78 {
90 /* Normally, l-values to continuous assignments are NOT allowed
91 to implicitly declare nets. However, so many tools do allow
92 it that Icarus Verilog will allow it, at least if extensions
93 are enabled. */
98 /* Elaborate the l-value. */
102 }
110 }
112 /* Handle the special case that the rval is simply an
113 identifier. Get the rval as a NetNet, then use NetBUFZ
114 objects to connect it to the l-value. This is necessary to
115 direct drivers. This is how I attach strengths to the
116 assignment operation. */
124 }
132 }
135 /* If the right hand net is the same type as the left
136 side net (i.e., WIRE/WIRE) then it is enough to just
137 connect them together. Otherwise, put a bufz between
138 them to carry strengths from the rval.
140 While we are at it, handle the case where the r-value
141 is not as wide as the l-value by padding with a
142 constant-0. */
150 /* If the device is linked to itself, a driver is
151 needed. Should I print a warning here? */
155 /* If the nets are different type (i.e., reg vs. tri) then
156 a driver is needed. */
160 /* If there is a delay, then I need a driver to carry
161 it. */
165 /* If there is a strength to be carried, then I need a
166 driver to carry that strength. */
173 /* If the r-value is more narrow then the l-value, pad
174 it to the desired width. */
197 }
209 }
213 /* Don't need a driver, presumably because the
214 r-value already has the needed drivers. Just
215 hook things up. If the r-value is too narrow
216 for the l-value, then sign extend it or zero
217 extend it, whichever makes sense. */
223 }
228 /* Do need a driver. Use BUFZ objects to carry the
229 strength and delays. */
237 else
241 else
245 else
248 }
261 }
264 }
266 /* Elaborate the r-value. Account for the initial decays,
267 which are going to be attached to the last gate before the
268 generated NetNet. */
278 }
284 }
289 /* If the r-value insists on being smaller then the l-value
290 (perhaps it is explicitly sized) the pad it out to be the
291 right width so that something is connected to all the bits
292 of the l-value. */
296 /* If, on the other hand, the r-value insists on being
297 LARGER then the l-value, use a part select to chop it down
298 down to size. */
310 }
317 }
319 /*
320 * Elaborate a Builtin gate. These normally get translated into
321 * NetLogic nodes that reflect the particular logic function.
322 */
324 {
333 /* If the Verilog source has a range specification for the
334 gates, then I am expected to make more than one
335 gate. Figure out how many are desired. */
348 }
355 }
365 else
375 }
376 }
378 /* Now we have a gate count. Elaborate the output expression
379 only. We do it early so that we can see if we can make a
380 wide gate instead of an array of gates. */
385 /* Detect the special case that the l-value width exactly
386 matches the gate count. In this case, we will make a single
387 gate that has the desired vector width. */
394 "Collapsed gate array into single wide "
396 }
398 /* Allocate all the netlist nodes for the gates. */
402 /* Calculate the gate delays from the delay expressions
403 given in the source. For logic gates, the decay time
404 is meaningless because it can never go to high
405 impedance. However, the bufif devices can generate
406 'bz output, so we will pretend that anything can.
408 If only one delay value expression is given (i.e., #5
409 nand(foo,...)) then rise, fall and decay times are
410 all the same value. If two values are given, rise and
411 fall times are use, and the decay time is the minimum
412 of the rise and fall times. Finally, if all three
413 values are given, they are taken as specified. */
423 /* Now make as many gates as the bit count dictates. Give each
424 a unique name, and set the delay times. */
427 ostringstream tmp;
431 else
515 }
529 }
534 /* The gates have all been allocated, this loop runs through
535 the parameters and attaches the ports of the objects. */
540 ? lval_sig
548 /* Handle the case where there is one gate that
549 carries the whole vector width. */
554 NetReplicate*rep
557 instance_width,
558 instance_width);
570 }
580 }
585 /* Handle the case where a single bit is connected
586 repetitively to all the instances. */
592 /* Handle the general case that each bit of the
593 value is connected to a different instance. In
594 this case, the output is handled slightly
595 different from the inputs. */
600 count);
603 /* Connect the concat to the signal. */
606 /* Connect the outputs of the gates to the concat. */
616 }
619 /* Use part selects to get the bits
620 connected to the inputs of out gate. */
632 }
640 }
642 }
643 }
645 /*
646 * Instantiate a module by recursively elaborating it. Set the path of
647 * the recursive elaboration so that signal names get properly
648 * set. Connect the ports of the instantiated module to the signals of
649 * the parameters. This is done with BUFZ gates so that they look just
650 * like continuous assignment connections.
651 */
653 {
661 }
663 // This is the array of pin expressions, shuffled to match the
664 // order of the declaration. If the source instantiation uses
665 // bind by order, this is the same as the source list.Otherwise,
666 // the source list is rearranged by name binding into this list.
669 // If the instance has a pins_ member, then we know we are
670 // binding by name. Therefore, make up a pins array that
671 // reflects the positions of the named ports.
675 // Scan the bindings, matching them with port names.
678 // Given a binding, look at the module port names
679 // for the position that matches the binding name.
682 // If the port name doesn't exist, the find_port
683 // method will return the port count. Detect that
684 // as an error.
691 }
693 // If I already bound something to this port, then
694 // the pins array will already have a pointer
695 // value where I want to place this expression.
699 endl;
702 }
704 // OK, do the binding by placing the expression in
705 // the right place.
707 }
712 /* Handle the special case that no ports are
713 connected. It is possible that this is an empty
714 connect-by-name list, so we'll allow it and assume
715 that is the case. */
722 /* Otherwise, this is a positional list of port
723 connections. In this case, the port count must be
724 right. Check that is is, the get the pin list. */
733 }
735 // No named bindings, just use the positional list I
736 // already have.
739 }
741 // Elaborate these instances of the module. The recursive
742 // elaboration causes the module to generate a netlist with
743 // the ports represented by NetNet objects. I will find them
744 // later.
749 }
753 // Now connect the ports of the newly elaborated designs to
754 // the expressions that are the instantiation parameters. Scan
755 // the pins, elaborate the expressions attached to them, and
756 // bind them to the port of the elaborated module.
758 // This can get rather complicated because the port can be
759 // unconnected (meaning an empty parameter is passed) connected
760 // to a concatenation, or connected to an internally
761 // unconnected port.
765 // Skip unconnected module ports. This happens when a
766 // null parameter is passed in.
770 // While we're here, look to see if this
771 // unconnected (from the outside) port is an
772 // input. If so, consider printing a port binding
773 // warning.
791 }
792 }
795 }
798 // Inside the module, the port is zero or more signals
799 // that were already elaborated. List all those signals
800 // and the NetNet equivalents, for all the instances.
808 }
810 // Count the internal vector bits of the port.
816 // Scan the module sub-ports for this instance...
828 }
829 }
831 // If I find that the port is unconnected inside the
832 // module, then there is nothing to connect. Skip the
833 // argument.
836 }
838 // We know by design that each instance has the same
839 // width port. Therefore, the prts_pin_count must be an
840 // even multiple of the instance count.
847 // Elaborate the expression that connects to the
848 // module[s] port. sig is the thing outside the module
849 // that connects to the port.
855 /* Input to module. elaborate the expression to
856 the desired width. If this in an instance
857 array, then let the net determine it's own
858 width. We use that, then, to decide how to hook
859 it up.
861 NOTE that this also handles the case that the
862 port is actually empty on the inside. We assume
863 in that case that the port is input. */
866 desired_vector_width,
873 }
877 /* Inout to/from module. This is a more
878 complicated case, where the expression must be
879 an lnet, but also an r-value net.
881 Normally, this winds up being the same as if we
882 just elaborated as an lnet, as passing a simple
883 identifier elaborates to the same NetNet in
884 both cases so the extra elaboration has no
885 effect. But if the expression passed to the
886 inout port is a part select, aspecial part
887 select must be created that can paqss data in
888 both directions.
890 Use the elaborate_bi_net method to handle all
891 the possible cases. */
903 }
908 /* Port type must be OUTPUT here. */
910 /* Output from module. Elaborate the port
911 expression as the l-value of a continuous
912 assignment, as the port will continuous assign
913 into the port. */
925 }
927 }
931 #ifndef NDEBUG
935 }
936 #endif
938 /* If we are working with an instance array, then the
939 signal width must match the port width exactly. */
950 }
956 }
958 // Check that the parts have matching pin counts. If
959 // not, they are different widths. Note that idx is 0
960 // based, but users count parameter positions from 1.
980 }
981 }
983 // Connect the sig expression that is the context of the
984 // module instance to the ports of the elaborated module.
986 // The prts_pin_count variable is the total width of the
987 // port and is the maximum number of connections to
988 // make. sig is the elaborated expression that connects
989 // to that port. If sig has too few pins, then reduce
990 // the number of connections to make.
992 // Connect this many of the port pins. If the expression
993 // is too small, then reduce the number of connects.
998 // The spin_modulus is the width of the signal (not the
999 // port) if this is an instance array. This causes
1000 // signals wide enough for a single instance to be
1001 // connected to all the instances.
1006 // Now scan the concatenation that makes up the port,
1007 // connecting pins until we run out of port pins or sig
1008 // pins. The sig object is the NetNet that is connected
1009 // to the port from the outside, and the prts object is
1010 // an array of signals to be connected to the sig.
1017 // The simplest case, there are no
1018 // parts/concatenations on the inside of the
1019 // module, so the port and sig need simply be
1020 // connected directly.
1032 }
1034 // The signal width is exactly the width of a
1035 // single instance of the port. In this case,
1036 // connect the sig to all the ports identically.
1043 prts_vector_width,
1050 }
1061 }
1071 }
1088 }
1090 }
1092 }
1094 /*
1095 * From a UDP definition in the source, make a NetUDP
1096 * object. Elaborate the pin expressions as netlists, then connect
1097 * those networks to the pins.
1098 */
1101 {
1108 /* When the parser notices delay expressions in front of a
1109 module or primitive, it interprets them as parameter
1110 overrides. Correct that misconception here. */
1112 PDelays tmp_del;
1124 }
1134 }
1144 }
1146 }
1166 // This is the array of pin expressions, shuffled to match the
1167 // order of the declaration. If the source instantiation uses
1168 // bind by order, this is the same as the source
1169 // list. Otherwise, the source list is rearranged by name
1170 // binding into this list.
1173 // Detect binding by name. If I am binding by name, then make
1174 // up a pins array that reflects the positions of the named
1175 // ports. If this is simply positional binding in the first
1176 // place, then get the binding from the base class.
1181 // Scan the bindings, matching them with port names.
1184 // Given a binding, look at the module port names
1185 // for the position that matches the binding name.
1188 // If the port name doesn't exist, the find_port
1189 // method will return the port count. Detect that
1190 // as an error.
1197 }
1199 // If I already bound something to this port, then
1200 // the (*exp) array will already have a pointer
1201 // value where I want to place this expression.
1205 endl;
1208 }
1210 // OK, do the binding by placing the expression in
1211 // the right place.
1213 }
1217 /* Otherwise, this is a positional list of port
1218 connections. In this case, the port count must be
1219 right. Check that is is, the get the pin list. */
1228 }
1230 // No named bindings, just use the positional list I
1231 // already have.
1234 }
1237 /* Handle the output port of the primitive special. It is an
1238 output port (the only output port) so must be passed an
1239 l-value net. */
1255 }
1256 }
1258 /* Run through the pins, making netlists for the pin
1259 expressions and connecting them to the pin in question. All
1260 of this is independent of the nature of the UDP. */
1270 }
1273 }
1275 // All done. Add the object to the design.
1277 }
1281 {
1282 // Look for the module type
1288 }
1292 {
1293 // Look for the module type
1298 }
1300 // Try a primitive type
1306 }
1310 }
1313 {
1314 // Look for the module type
1319 }
1321 // Try a primitive type
1326 // Not a module or primitive that I know about yet, so try to
1327 // load a library module file (which parses some new Verilog
1328 // code) and try again.
1331 // Try again to find the module type
1336 }
1338 // Try again to find a primitive type
1342 }
1345 // Not a module or primitive that I know about or can find by
1346 // any means, so give up.
1350 }
1354 {
1360 }
1364 {
1367 }
1369 /*
1370 * This function elaborates delay expressions. This is a little
1371 * different from normal elaboration because the result may need to be
1372 * scaled.
1373 */
1375 {
1378 /* If the delay expression is a real constant or vector
1379 constant, then evaluate it, scale it to the local time
1380 units, and return an adjusted NetEConst. */
1392 }
1403 }
1406 /* The expression is not constant, so generate an expanded
1407 expression that includes the necessary scale shifts, and
1408 return that expression. */
1415 }
1419 }
1426 }
1430 }
1433 }
1436 {
1439 /* elaborate the lval. This detects any part selects and mux
1440 expressions that might exist. */
1444 /* If there is an internal delay expression, elaborate it. */
1452 /* Elaborate the r-value expression, then try to evaluate it. */
1454 /* Find out what the r-value width is going to be. We guess it
1455 will be the l-value width, but it may turn out to be
1456 something else based on self-determined widths inside. */
1461 /* Now elaborate to the expected width. Pass the lwidth to
1462 prune any constant result to fit with the lvalue at hand. */
1468 /* Rewrite delayed assignments as assignments that are
1469 delayed. For example, a = #<d> b; becomes:
1471 begin
1472 tmp = b;
1473 #<d> a = tmp;
1474 end
1476 If the delay is an event delay, then the transform is
1477 similar, with the event delay replacing the time delay. It
1478 is an event delay if the event_ member has a value.
1480 This rewriting of the expression allows me to not bother to
1481 actually and literally represent the delayed assign in the
1482 netlist. The compound statement is exactly equivalent. */
1494 //XXXX delete rv;
1496 }
1505 /* Generate an assignment of the l-value to the temporary... */
1511 /* Generate an assignment of the temporary to the r-value... */
1515 /* Generate the delay statement with the final
1516 assignment attached to it. If this is an event delay,
1517 elaborate the PEventStatement. Otherwise, create the
1518 right NetPDelay object. */
1524 "unable to elaborate event expression."
1528 }
1535 }
1537 /* And build up the complex statement. */
1543 }
1545 /* Based on the specific type of the l-value, do cleanup
1546 processing on the r-value. */
1549 // The r-value is a real. Casting will happen in the
1550 // code generator, so leave it.
1557 }
1563 }
1565 /*
1566 * Elaborate non-blocking assignments. The statement is of the general
1567 * form:
1568 *
1569 * <lval> <= #<delay> <rval> ;
1570 */
1572 {
1575 /* Elaborate the l-value. */
1581 /* Elaborate and precalculate the r-value. */
1586 /* Handle the (common) case that the r-value is a vector. This
1587 includes just about everything but reals. In this case, we
1588 need to pad the r-value to match the width of the l-value.
1590 If in this case the l-val is a variable (i.e. real) then
1591 the width to pad to will be 0, so this code is harmless. */
1598 }
1604 /* All done with this node. Mark its line number and check it in. */
1609 }
1612 /*
1613 * This is the elaboration method for a begin-end block. Try to
1614 * elaborate the entire block, even if it fails somewhere. This way I
1615 * get all the error messages out of it. Then, if I detected a failure
1616 * then pass the failure up.
1617 */
1619 {
1635 }
1639 }
1646 // Handle the special case that the block contains only one
1647 // statement. There is no need to keep the block node. Also,
1648 // don't elide named blocks, because they might be referenced
1649 // elsewhere.
1654 }
1659 // If the statement fails to elaborate, then simply
1660 // ignore it. Presumably, the elaborate for the
1661 // statement already generated an error message and
1662 // marked the error count in the design so no need to
1663 // do any of that here.
1666 }
1668 // If the result turns out to be a noop, then skip it.
1673 }
1676 }
1679 }
1681 /*
1682 * Elaborate a case statement.
1683 */
1685 {
1693 }
1695 /* Count the items in the case statement. Note that there may
1696 be some cases that have multiple guards. Count each as a
1697 separate item. */
1704 else
1706 }
1711 /* Iterate over all the case items (guard/statement pairs)
1712 elaborating them. If the guard has no expression, then this
1713 is a "default" cause. Otherwise, the guard has one or more
1714 expressions, and each guard is a case. */
1722 /* If there are no expressions, then this is the
1723 default case. */
1733 /* If there are one or more expressions, then
1734 iterate over the guard expressions, elaborating
1735 a separate case for each. (Yes, the statement
1736 will be elaborated again for each.) */
1747 }
1748 }
1751 }
1754 {
1761 // Elaborate and try to evaluate the conditional expression.
1768 }
1770 // If the condition of the conditional statement is constant,
1771 // then look at the value and elaborate either the if statement
1772 // or the else statement. I don't need both. If there is no
1773 // else_ statement, the use an empty block as a noop.
1779 }
1793 }
1796 else
1798 }
1800 // If the condition expression is more than 1 bits, then
1801 // generate a comparison operator to get the result down to
1802 // one bit. Turn <e> into <e> != 0;
1808 }
1817 }
1819 // Well, I actually need to generate code to handle the
1820 // conditional, so elaborate.
1824 // Detect the special cases that the if or else statements are
1825 // empty blocks. If this is the case, remove the blocks as
1826 // null statements.
1831 }
1832 }
1838 }
1839 }
1844 }
1847 {
1850 else
1852 }
1854 /*
1855 * A call to a system task involves elaborating all the parameters,
1856 * then passing the list to the NetSTask object.
1857 *XXXX
1858 * There is a single special case in the call to a system
1859 * task. Normally, an expression cannot take an unindexed
1860 * memory. However, it is possible to take a system task parameter a
1861 * memory if the expression is trivial.
1862 */
1864 {
1869 /* Catch the special case that the system task has no
1870 parameters. The "()" string will be parsed as a single
1871 empty parameter, when we really mean no parameters at all. */
1881 /* Attempt to pre-evaluate the parameters. It may be
1882 possible to at least partially reduce the
1883 expression. */
1888 }
1889 }
1890 }
1894 }
1896 /*
1897 * A call to a user defined task is different from a call to a system
1898 * task because a user task in a netlist has no parameters: the
1899 * assignments are done by the calling thread. For example:
1900 *
1901 * task foo;
1902 * input a;
1903 * output b;
1904 * [...]
1905 * endtask;
1906 *
1907 * [...] foo(x, y);
1908 *
1909 * is really:
1910 *
1911 * task foo;
1912 * reg a;
1913 * reg b;
1914 * [...]
1915 * endtask;
1916 *
1917 * [...]
1918 * begin
1919 * a = x;
1920 * foo;
1921 * y = b;
1922 * end
1923 */
1925 {
1934 }
1945 }
1954 }
1958 /* Handle tasks with no parameters specially. There is no need
1959 to make a sequential block to hold the generated code. */
1964 }
1969 /* Detect the case where the definition of the task is known
1970 empty. In this case, we need not bother with calls to the
1971 task, all the assignments, etc. Just return a no-op. */
1976 }
1978 /* Generate assignment statement statements for the input and
1979 INOUT ports of the task. These are managed by writing
1980 assignments with the task port the l-value and the passed
1981 expression the r-value. We know by definition that the port
1982 is a reg type, so this elaboration is pretty obvious. */
1999 }
2001 /* Generate the task call proper... */
2007 /* Generate assignment statements for the output and INOUT
2008 ports of the task. The l-value in this case is the
2009 expression passed as a parameter, and the r-value is the
2010 port to be copied out.
2012 We know by definition that the r-value of this copy-out is
2013 the port, which is a reg. The l-value, however, may be any
2014 expression that can be a target to a procedural
2015 assignment, including a memory word. */
2021 /* Skip input ports. */
2027 /* Elaborate an l-value version of the port expression
2028 for output and inout ports. If the expression does
2029 not exist then quietly skip it, but if the expression
2030 is not a valid l-value print an error message. Note
2031 that the elaborate_lval method already printed a
2032 detailed message. */
2040 }
2043 }
2051 /* Generate the assignment statement. */
2055 }
2058 }
2060 /*
2061 * Elaborate a procedural continuous assign. This really looks very
2062 * much like other procedural assignments, at this point, but there
2063 * is no delay to worry about. The code generator will take care of
2064 * the differences between continuous assign and normal assignments.
2065 */
2067 {
2092 }
2096 }
2099 {
2109 }
2111 /*
2112 * Elaborate the delay statement (of the form #<expr> <statement>) as a
2113 * NetPDelay object. If the expression is constant, evaluate it now
2114 * and make a constant delay. If not, then pass an elaborated
2115 * expression to the constructor of NetPDelay so that the code
2116 * generator knows to evaluate the expression at run time.
2117 */
2119 {
2122 /* This call evaluates the delay expression to a NetEConst, if
2123 possible. This includes transforming NetECReal values to
2124 integers, and applying the proper scaling. */
2131 else
2139 else
2141 }
2143 }
2145 /*
2146 * The disable statement is not yet supported.
2147 */
2149 {
2160 }
2175 }
2180 }
2182 /*
2183 * An event statement is an event delay of some sort, attached to a
2184 * statement. Some Verilog examples are:
2185 *
2186 * @(posedge CLK) $display("clock rise");
2187 * @event_1 $display("event triggered.");
2188 * @(data or negedge clk) $display("data or clock fall.");
2189 *
2190 * The elaborated netlist uses the NetEvent, NetEvWait and NetEvProbe
2191 * classes. The NetEvWait class represents the part of the netlist
2192 * that is executed by behavioral code. The process starts waiting on
2193 * the NetEvent when it executes the NetEvWait step. Net NetEvProbe
2194 * and NetEvTrig are structural and behavioral equivalents that
2195 * trigger the event, and awakens any processes blocking in the
2196 * associated wait.
2197 *
2198 * The basic data structure is:
2199 *
2200 * NetEvWait ---/---> NetEvent <----\---- NetEvProbe
2201 * ... | | ...
2202 * NetEvWait ---+ +---- NetEvProbe
2203 * | ...
2204 * +---- NetEvTrig
2205 *
2206 * That is, many NetEvWait statements may wait on a single NetEvent
2207 * object, and Many NetEvProbe objects may trigger the NetEvent
2208 * object. The many NetEvWait objects pointing to the NetEvent object
2209 * reflects the possibility of different places in the code blocking
2210 * on the same named event, like so:
2211 *
2212 * event foo;
2213 * [...]
2214 * always begin @foo <statement1>; @foo <statement2> end
2215 *
2216 * This tends to not happen with signal edges. The multiple probes
2217 * pointing to the same event reflect the possibility of many
2218 * expressions in the same blocking statement, like so:
2219 *
2220 * wire reset, clk;
2221 * [...]
2222 * always @(reset or posedge clk) <stmt>;
2223 *
2224 * Conjunctions like this cause a NetEvent object be created to
2225 * represent the overall conjunction, and NetEvProbe objects for each
2226 * event expression.
2227 *
2228 * If the NetEvent object represents a named event from the source,
2229 * then there are NetEvTrig objects that represent the trigger
2230 * statements instead of the NetEvProbe objects representing signals.
2231 * For example:
2232 *
2233 * event foo;
2234 * always @foo <stmt>;
2235 * initial begin
2236 * [...]
2237 * -> foo;
2238 * [...]
2239 * -> foo;
2240 * [...]
2241 * end
2242 *
2243 * Each trigger statement in the source generates a separate NetEvTrig
2244 * object in the netlist. Those trigger objects are elaborated
2245 * elsewhere.
2246 *
2247 * Additional complications arise when named events show up in
2248 * conjunctions. An example of such a case is:
2249 *
2250 * event foo;
2251 * wire bar;
2252 * always @(foo or posedge bar) <stmt>;
2253 *
2254 * Since there is by definition a NetEvent object for the foo object,
2255 * this is handled by allowing the NetEvWait object to point to
2256 * multiple NetEvent objects. All the NetEvProbe based objects are
2257 * collected and pointed as the synthetic NetEvent object, and all the
2258 * named events are added into the list of NetEvent object that the
2259 * NetEvWait object can refer to.
2260 */
2264 {
2267 /* Create a single NetEvent and NetEvWait. Then, create a
2268 NetEvProbe for each conjunctive event in the event
2269 list. The NetEvProbe objects all refer back to the NetEvent
2270 object. */
2279 /* If there are no expressions, this is a signal that it is an
2280 @* statement. Generate an expression to use. */
2291 }
2298 }
2315 /* If the expression is an identifier that matches a
2316 named event, then handle this case all at once at
2317 skip the rest of the expression handling. */
2330 }
2331 }
2334 /* So now we have a normal event expression. Elaborate
2335 the sub-expression as a net and decide how to handle
2336 the edge. */
2348 }
2373 }
2380 }
2382 /* If there was at least one conjunction that was an
2383 expression (and not a named event) then add this
2384 event. Otherwise, we didn't use it so delete it. */
2388 /* NOTE: This event that I am adding to the wait may be
2389 a duplicate of another event somewhere else. However,
2390 I don't know that until all the modules are hooked
2391 up, so it is best to leave find_similar_event to
2392 after elaboration. */
2395 }
2398 }
2400 /*
2401 * This is the special case of the event statement, the wait
2402 * statement. This is elaborated into a slightly more complicated
2403 * statement that uses non-wait statements:
2404 *
2405 * wait (<expr>) <statement>
2406 *
2407 * becomes
2408 *
2409 * begin
2410 * while (1 !== <expr>)
2411 * @(<expr inputs>) <noop>;
2412 * <statement>;
2413 * end
2414 */
2417 {
2423 /* Elaborate wait expression. Don't eval yet, we will do that
2424 shortly, after we apply a reduction or. */
2431 }
2433 // If the condition expression is more than 1 bits, then
2434 // generate a reduction operator to get the result down to
2435 // one bit. In other words, Turn <e> into |<e>;
2441 }
2447 }
2449 /* precalculate as much as possible of the wait expression. */
2453 }
2455 /* Detect the unusual case that the wait expression is
2456 constant. Constant true is OK (it becomes transparent) but
2457 constant false is almost certainly not what is intended. */
2463 /* Constant true -- wait(1) <s1> reduces to <s1>. */
2468 }
2470 /* Otherwise, false. wait(0) blocks permanently. */
2477 /* Create an event wait and an otherwise unreferenced
2478 event variable to force a perpetual wait. */
2489 }
2491 /* Invert the sense of the test with an exclusive NOR. In
2492 other words, if this adjusted expression returns TRUE, then
2493 wait. */
2500 }
2515 }
2522 }
2536 /* If there is no real substatement (i.e., "wait (foo) ;") then
2537 we are done. */
2541 /* Create a sequential block to combine the wait loop and the
2542 delayed statement. */
2549 }
2553 {
2563 }
2569 }
2571 /*
2572 * Forever statements are represented directly in the netlist. It is
2573 * theoretically possible to use a while structure with a constant
2574 * expression to represent the loop, but why complicate the code
2575 * generators so?
2576 */
2578 {
2584 }
2586 /*
2587 * Force is like a procedural assignment, most notably prodedural
2588 * continuous assignment:
2589 *
2590 * force <lval> = <rval>
2591 *
2592 * The <lval> can be anything that a normal behavioral assignment can
2593 * take, plus net signals. This is a little bit more lax then the
2594 * other proceedural assignments.
2595 */
2597 {
2622 }
2626 }
2628 /*
2629 * elaborate the for loop as the equivalent while loop. This eases the
2630 * task for the target code generator. The structure is:
2631 *
2632 * begin : top
2633 * name1_ = expr1_;
2634 * while (cond_) begin : body
2635 * statement_;
2636 * name2_ = expr2_;
2637 * end
2638 * end
2639 */
2641 {
2653 /* make the expression, and later the initial assignment to
2654 the condition variable. The statement in the for loop is
2655 very specifically an assignment. */
2662 }
2666 /* Calculate the width of the initialization as if this were
2667 any other assignment statement. */
2672 /* Make the r-value of the initial assignment, and size it
2673 properly. Then use it to build the assignment statement. */
2682 }
2692 /* Elaborate the statement that is contained in the for
2693 loop. If there is an error, this will return 0 and I should
2694 skip the append. No need to worry, the error has been
2695 reported so it's OK that the netlist is bogus. */
2701 /* Elaborate the increment assignment statement at the end of
2702 the for loop. This is also a very specific assignment
2703 statement. Put this into the "body" block. */
2710 }
2715 /* Make the rvalue of the increment expression, and size it
2716 for the lvalue. */
2724 /* Elaborate the condition expression. Try to evaluate it too,
2725 in case it is a constant. This is an interesting case
2726 worthy of a warning. */
2731 }
2736 }
2739 /* All done, build up the loop. */
2745 }
2747 /*
2748 * (See the PTask::elaborate methods for basic common stuff.)
2749 *
2750 * The return value of a function is represented as a reg variable
2751 * within the scope of the function that has the name of the
2752 * function. So for example with the function:
2753 *
2754 * function [7:0] incr;
2755 * input [7:0] in1;
2756 * incr = in1 + 1;
2757 * endfunction
2758 *
2759 * The scope of the function is <parent>.incr and there is a reg
2760 * variable <parent>.incr.incr. The elaborate_1 method is called with
2761 * the scope of the function, so the return reg is easily located.
2762 *
2763 * The function parameters are all inputs, except for the synthetic
2764 * output parameter that is the return value. The return value goes
2765 * into port 0, and the parameters are all the remaining ports.
2766 */
2769 {
2776 }
2786 }
2789 }
2792 {
2802 }
2805 {
2814 }
2819 // If the expression is a constant, handle certain special
2820 // iteration counts.
2833 }
2834 }
2838 }
2840 /*
2841 * A task definition is elaborated by elaborating the statement that
2842 * it contains, and connecting its ports to NetNet objects. The
2843 * netlist doesn't really need the array of parameters once elaboration
2844 * is complete, but this is the best place to store them.
2845 *
2846 * The first elaboration pass finds the reg objects that match the
2847 * port names, and creates the NetTaskDef object. The port names are
2848 * in the form task.port.
2849 *
2850 * task foo;
2851 * output blah;
2852 * begin <body> end
2853 * endtask
2854 *
2855 * So in the foo example, the PWire objects that represent the ports
2856 * of the task will include a foo.blah for the blah port. This port is
2857 * bound to a NetNet object by looking up the name. All of this is
2858 * handled by the PTask::elaborate_sig method and the results stashed
2859 * in the created NetTaskDef attached to the scope.
2860 *
2861 * Elaboration pass 2 for the task definition causes the statement of
2862 * the task to be elaborated and attached to the NetTaskDef object
2863 * created in pass 1.
2864 *
2865 * NOTE: I am not sure why I bothered to prepend the task name to the
2866 * port name when making the port list. It is not really useful, but
2867 * that is what I did in pform_make_task_ports, so there it is.
2868 */
2871 {
2887 }
2888 }
2891 }
2894 {
2909 }
2916 }
2921 }
2923 /*
2924 * The while loop is fairly directly represented in the netlist.
2925 */
2927 {
2931 }
2934 {
2938 }
2948 }
2951 // Evaluate the attributes for this process, if there
2952 // are any. These attributes are to be attached to the
2953 // NetProcTop object.
2967 /* Detect the special case that this is a combinational
2968 always block. We want to attach an _ivl_schedule_push
2969 attribute to this process so that it starts up and
2970 gets into its wait statement before non-combinational
2971 code is executed. */
2994 }
3004 }
3007 {
3011 /* Do not elaborate specify delay paths if this feature is
3012 turned off. */
3016 /* Check for various path types that are not supported. */
3024 }
3034 /* Elaborate the delay values themselves. Remember to scale
3035 them for the timescale/precision of the scope. */
3053 }
3055 }
3070 }
3079 // FIXME: Look for constant expressions here?
3081 // Get a net form.
3084 }
3086 /* Create all the various paths from the path specifier. */
3096 }
3104 }
3112 }
3118 // The presence of the data_source_expression indicates
3119 // that this is an edge sensitive path. If so, then set
3120 // the edges. Note that edge==0 is BOTH edges.
3124 }
3150 }
3165 }
3169 }
3175 }
3177 }
3179 /*
3180 * When a module is instantiated, it creates the scope then uses this
3181 * method to elaborate the contents of the module.
3182 */
3184 {
3188 // Elaborate specparams
3222 }
3227 }
3228 }
3230 // Elaborate within the generate blocks.
3235 }
3237 // Elaborate functions.
3246 }
3248 // Elaborate the task definitions. This is done before the
3249 // behaviors so that task calls may reference these, and after
3250 // the signals so that the tasks can reference them.
3259 }
3261 // Get all the gates of the module and elaborate them by
3262 // connecting them to the signals. The gate may be simple or
3263 // complex.
3271 }
3273 // Elaborate the behaviors, making processes out of them. This
3274 // involves scanning the PProcess* list, creating a NetProcTop
3275 // for each process.
3282 }
3284 // Elaborate the specify paths of the module.
3290 }
3293 }
3296 {
3304 // Check that this scope is one that is contained in the
3305 // container that the caller passed in.
3314 }
3317 }
3320 {
3330 }
3335 };
3338 {
3343 // This is the output design. I fill it in as I scan the root
3344 // module and elaborate what I find.
3347 // Scan the root modules, and elaborate their scopes.
3352 // Look for the root module in the list.
3361 }
3363 // Get the module definition for this root instance.
3366 // Make the root scope.
3375 // Recursively elaborate from this root scope down. This
3376 // does a lot of the grunt work of creating sub-scopes, etc.
3380 }
3386 }
3388 // Errors already? Probably missing root modules. Just give up
3389 // now and return nothing.
3393 // This method recurses through the scopes, looking for
3394 // defparam assignments to apply to the parameters in the
3395 // various scopes. This needs to be done after all the scopes
3396 // and basic parameters are taken care of because the defparam
3397 // can assign to a parameter declared *after* it.
3401 // At this point, all parameter overrides are done. Scan the
3402 // scopes and evaluate the parameters all the way down to
3403 // constants.
3406 // With the parameters evaluated down to constants, we have
3407 // what we need to elaborate signals and memories. This pass
3408 // creates all the NetNet and NetMemory objects for declared
3409 // objects.
3417 }
3418 }
3420 // Now that the structure and parameters are taken care of,
3421 // run through the pform again and generate the full netlist.
3427 }
3433 }
3436 }
3439 /*
3440 * $Log: elaborate.cc,v $
3441 * Revision 1.374 2007/06/05 21:35:51 steve
3442 * Error resiliency (ldoolitt)
3443 *
3444 * Revision 1.373 2007/06/04 02:19:07 steve
3445 * Handle bit/part select of array words in nets.
3446 *
3447 * Revision 1.372 2007/06/02 03:42:12 steve
3448 * Properly evaluate scope path expressions.
3449 *
3450 * Revision 1.371 2007/05/24 04:07:11 steve
3451 * Rework the heirarchical identifier parse syntax and pform
3452 * to handle more general combinations of heirarch and bit selects.
3453 *
3454 * Revision 1.370 2007/04/16 01:10:07 steve
3455 * Properly ignore unsupported ifnone.
3456 *
3457 * Revision 1.369 2007/04/15 20:45:40 steve
3458 * Attach line number information to task calls.
3459 *
3460 * Revision 1.368 2007/04/13 02:34:35 steve
3461 * Parse edge sensitive paths without edge specifier.
3462 *
3463 * Revision 1.367 2007/04/05 03:09:50 steve
3464 * Allow implicit wires in assign l-value.
3465 *
3466 * Revision 1.366 2007/04/01 23:01:10 steve
3467 * Improve port mismatch error message.
3468 *
3469 * Revision 1.365 2007/03/22 16:08:15 steve
3470 * Spelling fixes from Larry
3471 *
3472 * Revision 1.364 2007/03/08 05:30:02 steve
3473 * Limit the calculated widths of constants.
3474 *
3475 * Revision 1.363 2007/03/05 05:59:10 steve
3476 * Handle processes within generate loops.
3477 *
3478 * Revision 1.362 2007/03/03 05:56:55 steve
3479 * Check that path source/destination are ports.
3480 *
3481 * Revision 1.361 2007/03/02 06:13:22 steve
3482 * Add support for edge sensitive spec paths.
3483 *
3484 * Revision 1.360 2007/03/01 06:19:38 steve
3485 * Add support for conditional specify delay paths.
3486 *
3487 * Revision 1.359 2007/02/12 01:52:21 steve
3488 * Parse all specify paths to pform.
3489 *
3490 * Revision 1.358 2007/02/01 05:52:24 steve
3491 * More generous handling of errors in blocks.
3492 *
3493 * Revision 1.357 2007/01/21 04:26:36 steve
3494 * Clean up elaboration of for-loop increment expression.
3495 *
3496 * Revision 1.356 2007/01/19 05:42:40 steve
3497 * Precalculate constant power expressions, and constant function arguments.
3498 *
3499 * Revision 1.355 2007/01/16 05:44:15 steve
3500 * Major rework of array handling. Memories are replaced with the
3501 * more general concept of arrays. The NetMemory and NetEMemory
3502 * classes are removed from the ivl core program, and the IVL_LPM_RAM
3503 * lpm type is removed from the ivl_target API.
3504 *
3505 * Revision 1.354 2006/12/09 01:59:35 steve
3506 * Fix an uninitialized variable warning.
3507 *
3508 * Revision 1.353 2006/12/08 04:09:41 steve
3509 * @* without inputs is an error.
3510 *
3511 * Revision 1.352 2006/11/27 02:01:07 steve
3512 * Fix crash handling constant true conditional.
3513 *
3514 * Revision 1.351 2006/11/26 07:10:30 steve
3515 * Fix compile time eval of condition expresion to do reduction OR of vectors.
3516 *
3517 * Revision 1.350 2006/11/26 06:29:16 steve
3518 * Fix nexus widths for direct link assign and ternary nets.
3519 *
3520 * Revision 1.349 2006/11/04 06:19:25 steve
3521 * Remove last bits of relax_width methods, and use test_width
3522 * to calculate the width of an r-value expression that may
3523 * contain unsized numbers.
3524 *
3525 * Revision 1.348 2006/10/30 05:44:49 steve
3526 * Expression widths with unsized literals are pseudo-infinite width.
3527 *
3528 * Revision 1.347 2006/10/03 15:33:49 steve
3529 * no-specify turns of specparam elaboration.
3530 *
3531 * Revision 1.346 2006/10/03 05:06:00 steve
3532 * Support real valued specify delays, properly scaled.
3533 *
3534 * Revision 1.345 2006/09/28 04:35:18 steve
3535 * Support selective control of specify and xtypes features.
3536 *
3537 * Revision 1.344 2006/09/26 19:48:40 steve
3538 * Missing PSpec.cc file.
3539 *
3540 * Revision 1.343 2006/09/23 04:57:19 steve
3541 * Basic support for specify timing.
3542 *
3543 * Revision 1.342 2006/09/22 22:14:27 steve
3544 * Proper error message when logic array pi count is bad.
3545 *
3546 * Revision 1.341 2006/08/08 05:11:37 steve
3547 * Handle 64bit delay constants.
3548 *
3549 * Revision 1.340 2006/06/02 04:48:50 steve
3550 * Make elaborate_expr methods aware of the width that the context
3551 * requires of it. In the process, fix sizing of the width of unary
3552 * minus is context determined sizes.
3553 *
3554 * Revision 1.339 2006/05/01 20:47:59 steve
3555 * More explicit datatype setup.
3556 *
3557 * Revision 1.338 2006/04/30 05:17:48 steve
3558 * Get the data type of part select results right.
3559 *
3560 * Revision 1.337 2006/04/26 04:43:50 steve
3561 * Chop down assign r-values that elaborate too wide.
3562 *
3563 * Revision 1.336 2006/04/10 00:37:42 steve
3564 * Add support for generate loops w/ wires and gates.
3565 *
3566 * Revision 1.335 2006/03/30 01:49:07 steve
3567 * Fix instance arrays indexed by overridden parameters.
3568 *
3569 * Revision 1.334 2006/01/03 05:22:14 steve
3570 * Handle complex net node delays.
3571 *
3572 * Revision 1.333 2006/01/02 05:33:19 steve
3573 * Node delays can be more general expressions in structural contexts.
3574 *
3575 * Revision 1.332 2005/11/26 00:35:42 steve
3576 * More precise about r-value width of constants.
3577 *
3578 * Revision 1.331 2005/11/10 13:28:11 steve
3579 * Reorganize signal part select handling, and add support for
3580 * indexed part selects.
3581 *
3582 * Expand expression constant propagation to eliminate extra
3583 * sums in certain cases.
3584 *
3585 * Revision 1.330 2005/09/27 04:51:37 steve
3586 * Error message for invalid for-loop index variable.
3587 *
3588 * Revision 1.329 2005/09/14 02:53:13 steve
3589 * Support bool expressions and compares handle them optimally.
3590 *
3591 * Revision 1.328 2005/08/06 17:58:16 steve
3592 * Implement bi-directional part selects.
3593 *
3594 * Revision 1.327 2005/07/15 00:41:09 steve
3595 * More debug information.
3596 *
3597 * Revision 1.326 2005/07/11 16:56:50 steve
3598 * Remove NetVariable and ivl_variable_t structures.
3599 *
3600 * Revision 1.325 2005/06/17 05:06:47 steve
3601 * Debug messages.
3602 *
3603 * Revision 1.324 2005/05/24 01:44:27 steve
3604 * Do sign extension of structuran nets.
3605 *
3606 * Revision 1.323 2005/05/17 20:56:55 steve
3607 * Parameters cannot have their width changed.
3608 *
3609 * Revision 1.322 2005/05/13 05:12:39 steve
3610 * Some debug messages.
3611 *
3612 * Revision 1.321 2005/04/24 23:44:01 steve
3613 * Update DFF support to new data flow.
3614 *
3615 * Revision 1.320 2005/03/05 05:38:33 steve
3616 * Get rval width right for arguments into task calls.
3617 *
3618 * Revision 1.319 2005/02/19 02:43:38 steve
3619 * Support shifts and divide.
3620 *
3621 * Revision 1.318 2005/02/10 04:56:58 steve
3622 * distinguish between single port namy instances, and single instances many sub-ports.
3623 *
3624 * Revision 1.317 2005/02/08 00:12:36 steve
3625 * Add the NetRepeat node, and code generator support.
3626 *
3627 * Revision 1.316 2005/01/30 01:42:05 steve
3628 * Debug messages for PGAssign elaboration.
3629 *
3630 * Revision 1.315 2005/01/22 18:16:00 steve
3631 * Remove obsolete NetSubnet class.
3632 *
3633 * Revision 1.314 2005/01/12 03:17:36 steve
3634 * Properly pad vector widths in pgassign.
3635 *
3636 * Revision 1.313 2005/01/09 20:16:01 steve
3637 * Use PartSelect/PV and VP to handle part selects through ports.
3638 *
3639 * Revision 1.312 2004/12/29 23:55:43 steve
3640 * Unify elaboration of l-values for all proceedural assignments,
3641 * including assing, cassign and force.
3642 *
3643 * Generate NetConcat devices for gate outputs that feed into a
3644 * vector results. Use this to hande gate arrays. Also let gate
3645 * arrays handle vectors of gates when the outputs allow for it.
3646 *
3647 * Revision 1.311 2004/12/15 17:09:11 steve
3648 * Force r-value padded to width.
3649 *
3650 * Revision 1.310 2004/12/12 18:13:39 steve
3651 * Fix r-value width of continuous assign.
3652 *
3653 * Revision 1.309 2004/12/11 02:31:25 steve
3654 * Rework of internals to carry vectors through nexus instead
3655 * of single bits. Make the ivl, tgt-vvp and vvp initial changes
3656 * down this path.
3657 *
3658 */