Remove Parameters library and refactor Driver.

In addition to removing all the extraneous Driver invocations that created various top-level Parameters instances,
this commit also lays the groundwork for stanza-firrtl/verilator based testing of Modules that extend BasicTester.

The execution-based tests have been updated accordingly. They will only succeed if firrtl and verilator binaries have been installed.
Further work is needed on individual tests to use assertions instead of .io.error.

21 files changed, 438 insertions, 929 deletions

diff --git a/src/main/resources/top.cpp b/src/main/resources/top.cpp
new file mode 100644
index 00000000..8951032e
--- /dev/null
+++ b/src/main/resources/top.cpp
@@ -0,0 +1,91 @@
+#include <verilated.h>
+#include <iostream>
+
+#if VM_TRACE
+# include <verilated_vcd_c.h>	// Trace file format header
+#endif
+
+using namespace std;
+
+//VGCDTester *top;
+TOP_TYPE *top;
+
+vluint64_t main_time = 0;       // Current simulation time
+        // This is a 64-bit integer to reduce wrap over issues and
+        // allow modulus.  You can also use a double, if you wish.
+
+double sc_time_stamp () { // Called by $time in Verilog
+  return main_time;       // converts to double, to match
+                          // what SystemC does
+}
+
+// TODO Provide command-line options like vcd filename, timeout count, etc.
+const long timeout = 100000000L;
+
+int main(int argc, char** argv) {
+  vluint32_t done = 0;
+  Verilated::commandArgs(argc, argv);   // Remember args
+  top = new TOP_TYPE;
+
+#if VM_TRACE			// If verilator was invoked with --trace
+    Verilated::traceEverOn(true);	// Verilator must compute traced signals
+    VL_PRINTF("Enabling waves...\n");
+    VerilatedVcdC* tfp = new VerilatedVcdC;
+    top->trace (tfp, 99);	// Trace 99 levels of hierarchy
+    tfp->open ("dump.vcd");	// Open the dump file
+#endif
+
+
+  top->reset = 1; 
+
+  cout << "Starting simulation!\n";
+
+  while (!Verilated::gotFinish() && !done && main_time < timeout) {
+    if (main_time > 10) {
+      top->reset = 0;   // Deassert reset
+    }
+    if ((main_time % 10) == 1) {
+      top->clock = 1;       // Toggle clock
+    }
+    if ((main_time % 10) == 6) {
+      top->clock = 0;
+    }
+    top->eval();               // Evaluate model
+#if VM_TRACE
+	if (tfp) tfp->dump (main_time);	// Create waveform trace for this timestamp
+#endif
+    done = top->io__024done;
+    main_time++;               // Time passes...
+  }
+
+  // Run for 10 more clocks
+  vluint64_t end_time = main_time + 100;
+  while (main_time < end_time) {
+    if ((main_time % 10) == 1) {
+      top->clock = 1;       // Toggle clock
+    }
+    if ((main_time % 10) == 6) {
+      top->clock = 0;
+    }
+    top->eval();               // Evaluate model
+#if VM_TRACE
+	if (tfp) tfp->dump (main_time);	// Create waveform trace for this timestamp
+#endif
+    main_time++;               // Time passes...
+  }
+
+#if VM_TRACE
+    if (tfp) tfp->close();
+#endif
+
+  if (main_time >= timeout)
+    cout << "Simulation terminated by timeout at cycle " << main_time << endl;
+  else 
+    cout << "Simulation completed at cycle " << main_time << endl;
+
+  int error = top->io__024error;
+  cout << "Simulation return value: " << error << endl;
+
+  return error;
+}
+
diff --git a/src/main/scala/Chisel/Aggregate.scala b/src/main/scala/Chisel/Aggregate.scala
index 07362b9b..e6ac6b85 100644
--- a/src/main/scala/Chisel/Aggregate.scala
+++ b/src/main/scala/Chisel/Aggregate.scala
@@ -313,17 +313,6 @@ class Bundle extends Aggregate(NO_DIR) {
   }
 }
 
-object Bundle {
-  private val keywords =
-    HashSet[String]("flip", "asInput", "asOutput", "cloneType", "toBits")
-
-  def apply[T <: Bundle](b: => T)(implicit p: Parameters): T = {
-    Builder.paramsScope(p.push){ b }
-  }
-
-  //TODO @deprecated("Use Chisel.paramsScope object","08-01-2015")
-  def apply[T <: Bundle](b: => T,  f: PartialFunction[Any,Any]): T = {
-    val q = Builder.getParams.alterPartial(f)
-    apply(b)(q)
-  }
+private[Chisel] object Bundle {
+  val keywords = List("flip", "asInput", "asOutput", "cloneType", "toBits")
 }
diff --git a/src/main/scala/Chisel/Driver.scala b/src/main/scala/Chisel/Driver.scala
index 5247dc0f..64356b21 100644
--- a/src/main/scala/Chisel/Driver.scala
+++ b/src/main/scala/Chisel/Driver.scala
@@ -2,75 +2,100 @@
 
 package Chisel
 
-import collection.mutable.{ArrayBuffer, HashSet, HashMap, Stack, LinkedHashSet, Queue => ScalaQueue}
-import scala.math.min
+import scala.sys.process._
+import java.io._
 
 trait FileSystemUtilities {
-  def createOutputFile(name: String, contents: String) {
-    val f = new java.io.FileWriter(name)
-    f.write(contents)
-    f.close
+  def writeTempFile(pre: String, post: String, contents: String): File = {
+    val t = File.createTempFile(pre, post)
+    val w = new FileWriter(t)
+    w.write(contents)
+    w.close()
+    t
+  }
+
+  // This "fire-and-forgets" the method, which can be lazily read through
+  // a Stream[String], and accumulates all errors on a StringBuffer
+  def sourceFilesAt(baseDir: String): (Stream[String], StringBuffer) = {
+    val buffer = new StringBuffer()
+    val cmd = Seq("find", baseDir, "-name", "*.scala", "-type", "f")
+    val lines = cmd lines_! ProcessLogger(buffer append _)
+    (lines, buffer)
   }
 }
 
-object Driver extends FileSystemUtilities {
+trait BackendCompilationUtilities {
+  def makeHarness(template: String => String, post: String)(f: File): File = {
+    val prefix = f.toString.split("/").last
+    val vf = new File(f.toString + post)
+    val w = new FileWriter(vf)
+    w.write(template(prefix))
+    w.close()
+    vf
+  }
 
-  /** Instantiates a ChiselConfig class with the given name and uses it for elaboration */
-  def elaborateWithConfigName[T <: Module](
-      gen: () => T,
-      configClassName: String,
-      projectName: Option[String] = None,
-      collectConstraints: Boolean = false): Unit = {
-    val className = projectName match {
-      case Some(pn) => s"$pn.$configClassName"
-      case None => configClassName
-    }
-    val config = try {
-      Class.forName(className).newInstance.asInstanceOf[ChiselConfig]
-    } catch {
-      case e: java.lang.ClassNotFoundException =>
-        throwException("Could not find the ChiselConfig subclass you asked for (i.e. \"" +
-                          className + "\"), did you misspell it?", e)
-    }
-    elaborateWithConfig(gen, config, collectConstraints)
+  def firrtlToVerilog(prefix: String, dir: File): ProcessBuilder = {
+    Process(
+      Seq("firrtl",
+          "-i", s"$prefix.fir",
+          "-o", s"$prefix.v",
+          "-X", "verilog"),
+      dir)
   }
 
-  /** Uses the provided ChiselConfig for elaboration */
-  def elaborateWithConfig[T <: Module](
-      gen: () => T,
-      config: ChiselConfig,
-      collectConstraints: Boolean = false): Unit = {
-    val world = if(collectConstraints) config.toCollector else config.toInstance
-    val p = Parameters.root(world)
-    config.topConstraints.foreach(c => p.constrain(c))
-    elaborate(gen, p, config)
+  def verilogToCpp(
+      prefix: String,
+      dir: File,
+      vDut: File,
+      cppHarness: File,
+      vH: File): ProcessBuilder =
+    Seq("verilator",
+        "--cc", vDut.toString,
+        "--assert",
+        "--Wno-fatal",
+        "--trace",
+        "-O2",
+        "+define+TOP_TYPE=V"+prefix,
+        "-CFLAGS", s"""-Wno-undefined-bool-conversion -O2 -DTOP_TYPE=V$prefix -include ${vH.toString}""",
+        "-Mdir", dir.toString,
+        "--exe", cppHarness.toString)
+
+  def cppToExe(prefix: String, dir: File): ProcessBuilder =
+    Seq("make", "-C", dir.toString, "-j", "-f", s"V${prefix}.mk", s"V${prefix}")
+
+  def executeExpectingFailure(
+      prefix: String,
+      dir: File,
+      assertionMsg: String = "Assertion failed"): Boolean = {
+    var triggered = false
+    val e = Process(s"./V${prefix}", dir) ! ProcessLogger(line =>
+      triggered = triggered || line.contains(assertionMsg))
+    triggered
   }
 
-  /** Elaborates the circuit specified in the gen function, optionally uses
-    * a parameter space to supply context-aware values.
-    *  TODO: Distinguish between cases where we dump to file vs return IR for
-    *        use by other Drivers.
-    */
-  private[Chisel] def elaborateWrappedModule[T <: Module](gen: () => T, p: Parameters, c: Option[ChiselConfig]) {
-    val ir = Builder.build(gen())
-    val name = c match {
-      case None => ir.name
-      case Some(config) => s"${ir.name}.$config"
-    }
-    createOutputFile(s"$name.knb", p.getKnobs)
-    createOutputFile(s"$name.cst", p.getConstraints)
-    createOutputFile(s"$name.prm", ir.parameterDump.getDump)
-    createOutputFile(s"$name.fir", ir.emit)
+  def executeExpectingSuccess(prefix: String, dir: File): Boolean = {
+    !executeExpectingFailure(prefix, dir)
   }
-  def elaborate[T <: Module](gen: () => T): Unit =
-    elaborate(gen, Parameters.empty)
-  def elaborate[T <: Module](gen: () => T, p: Parameters): Unit =
-    elaborateWrappedModule(() => Module(gen())(p), p, None)
-  private def elaborate[T <: Module](gen: () => T, p: Parameters, c: ChiselConfig): Unit =
-    elaborateWrappedModule(() => Module(gen())(p), p, Some(c))
+
 }
 
-object chiselMain {
-  def apply[T <: Module](args: Array[String], gen: () => T, p: Parameters = Parameters.empty): Unit =
-    Driver.elaborateWrappedModule(gen, p, None)
+object Driver extends FileSystemUtilities with BackendCompilationUtilities {
+
+  /** Elaborates the Module specified in the gen function into a Circuit 
+    *
+    *  @param gen a function that creates a Module hierarchy
+    *
+    *  @return the resulting Chisel IR in the form of a Circuit (TODO: Should be FIRRTL IR)
+    */
+  def elaborate[T <: Module](gen: () => T): Circuit = Builder.build(Module(gen()))
+  
+  def emit[T <: Module](gen: () => T): String = elaborate(gen).emit
+
+  def dumpFirrtl(ir: Circuit, optName: Option[File]): File = {
+    val f = optName.getOrElse(new File(ir.name + ".fir"))
+    val w = new FileWriter(f)
+    w.write(ir.emit)
+    w.close()
+    f
+  }
 }
diff --git a/src/main/scala/Chisel/Module.scala b/src/main/scala/Chisel/Module.scala
index 1c1c02de..f799a7ce 100644
--- a/src/main/scala/Chisel/Module.scala
+++ b/src/main/scala/Chisel/Module.scala
@@ -6,37 +6,27 @@ import Builder.pushCommand
 import Builder.dynamicContext
 
 object Module {
-  // TODO: update documentation when parameters gets removed from core Chisel
-  // and this gets simplified.
   /** A wrapper method that all Module instantiations must be wrapped in
     * (necessary to help Chisel track internal state).
     *
     * @param m the Module being created
-    * @param p Parameters passed down implicitly from that it is created in
     *
-    * @return the input module `m`
+    * @return the input module `m` with Chisel metadata properly set
     */
-  def apply[T <: Module](bc: => T)(implicit currParams: Parameters = Builder.getParams.push): T = {
-    paramsScope(currParams) {
-      val parent = dynamicContext.currentModule
-      val m = bc.setRefs()
-      // init module outputs
-      m._commands prependAll (for (p <- m.io.flatten; if p.dir == OUTPUT)
-        yield Connect(p.lref, p.fromInt(0).ref))
-      dynamicContext.currentModule = parent
-      val ports = m.computePorts
-      Builder.components += Component(m, m.name, ports, m._commands)
-      pushCommand(DefInstance(m, ports))
-      // init instance inputs
-      for (p <- m.io.flatten; if p.dir == INPUT)
-        p := p.fromInt(0)
-      m
-    }.connectImplicitIOs()
-  }
-
-  //TODO @deprecated("Use Chisel.paramsScope object","08-01-2015")
-  def apply[T <: Module](m: => T, f: PartialFunction[Any,Any]): T = {
-    apply(m)(Builder.getParams.alterPartial(f))
+  def apply[T <: Module](bc: => T): T = {
+    val parent = dynamicContext.currentModule
+    val m = bc.setRefs()
+    // init module outputs
+    m._commands prependAll (for (p <- m.io.flatten; if p.dir == OUTPUT)
+      yield Connect(p.lref, p.fromInt(0).ref))
+    dynamicContext.currentModule = parent
+    val ports = m.computePorts
+    Builder.components += Component(m, m.name, ports, m._commands)
+    pushCommand(DefInstance(m, ports))
+    // init instance inputs
+    for (p <- m.io.flatten; if p.dir == INPUT)
+      p := p.fromInt(0)
+    m.connectImplicitIOs()
   }
 }
 
diff --git a/src/main/scala/Chisel/Parameters.scala b/src/main/scala/Chisel/Parameters.scala
deleted file mode 100644
index c2d32fbd..00000000
--- a/src/main/scala/Chisel/Parameters.scala
+++ /dev/null
@@ -1,669 +0,0 @@
-/*
- Constructing Hardware in a Scala Embedded Language, Copyright (c) 2014, The
- Regents of the University of California, through Lawrence Berkeley National
- Laboratory (subject to receipt of any required approvals from the U.S. Dept.
-   of Energy).  All rights reserved.
-
- If you have questions about your rights to use or distribute this software,
- please contact Berkeley Lab's Technology Transfer Department at  TTD@lbl.gov.
-
- NOTICE.  This software is owned by the U.S. Department of Energy.  As such,
- the U.S. Government has been granted for itself and others acting on its
- behalf a paid-up, nonexclusive, irrevocable, worldwide license in the Software
- to reproduce, prepare derivative works, and perform publicly and display
- publicly.  Beginning five (5) years after the date permission to assert
- copyright is obtained from the U.S. Department of Energy, and subject to any
- subsequent five (5) year renewals, the U.S. Government is granted for itself
- and others acting on its behalf a paid-up, nonexclusive, irrevocable,
- worldwide license in the Software to reproduce, prepare derivative works,
- distribute copies to the public, perform publicly and display publicly, and to
- permit others to do so.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- (1) Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- (2) Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- (3) Neither the name of the University of California, Lawrence Berkeley
- National Laboratory, U.S. Dept. of Energy nor the names of its contributors
- may be used to endorse or promote products derived from this software without
- specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You are under no obligation whatsoever to provide any bug fixes, patches, or
- upgrades to the features, functionality or performance of the source code
- ("Enhancements") to anyone; however, if you choose to make your Enhancements
- available either publicly, or directly to Lawrence Berkeley National
- Laboratory, without imposing a separate written license agreement for such
- Enhancements, then you hereby grant the following license: a  non-exclusive,
- royalty-free perpetual license to install, use, modify, prepare derivative
- works, incorporate into other computer software, distribute, and sublicense
- such enhancements or derivative works thereof, in binary and source code form.
-
- Authors: J. Bachan, A. Izraelevitz, H. Cook
-*/
-
-package Chisel
-
-import scala.collection.immutable.{Seq=>Seq, Iterable=>Iterable}
-import scala.{collection=>readonly}
-import scala.collection.mutable
-
-// Convention: leading _'s on names means private to the outside world
-// but accessible to anything in this file.
-
-@deprecated("params is now globally available as Chisel.params object","08-01-2015")
-abstract trait UsesParameters { }
-
-object params {
-  def apply[T](field:Any):T = Builder.getParams.apply(field)
-  def apply[T](field:Field[T]):T = Builder.getParams.apply(field)
-  // TODO: provide other mutators of Parameters? or @deprecate this and make
-  // Parameters private, only mutateable through paramsScope?
-  def alterPartial[T](mask: PartialFunction[Any,Any]): Parameters = {
-    Builder.getParams.alterPartial(mask)
-  }
-  def constrain(gen:ViewSym=>Ex[Boolean]) = Builder.getParams.constrain(gen)
-}
-
-object paramsScope {
-  def apply[T](p: Parameters)(body: => T): T = {
-    Builder.paramsScope(p)(body)
-  }
-  def apply[T,S](mask: Map[S,Any])(body: => T): T = {
-    apply(Builder.getParams.alter(mask))(body)
-  }
-  def apply[T](mask: PartialFunction[Any,Any])(body: => T): T = {
-    apply(Builder.getParams.alterPartial(mask))(body)
-  }
-}
-
-class ParameterUndefinedException(field:Any, cause:Throwable=null)
-  extends RuntimeException("Parameter " + field + " undefined.", cause)
-class KnobUndefinedException(field:Any, cause:Throwable=null)
-  extends RuntimeException("Knob " + field + " undefined.", cause)
-
-// Knobs are top level free variables that go into the constraint solver.
-final case class Knob[T](name:Any)
-
-// Fields are wrappers around particular a particular parameter's type
-class Field[T]
-
-class ChiselConfig(
-  val topDefinitions: World.TopDefs = { (a,b,c) => {throw new scala.MatchError(a)}},
-  val topConstraints: List[ViewSym=>Ex[Boolean]] = List( ex => ExLit[Boolean](true) ),
-  val knobValues: Any=>Any = { case x => {throw new scala.MatchError(x)}}
-) {
-  import Implicits._
-  type Constraint = ViewSym=>Ex[Boolean]
-
-  def this(that: ChiselConfig) = this(that.topDefinitions,
-                                      that.topConstraints,
-                                      that.knobValues)
-
-  def ++(that: ChiselConfig) = {
-    new ChiselConfig(this.addDefinitions(that.topDefinitions),
-                      this.addConstraints(that.topConstraints),
-                      this.addKnobValues(that.knobValues))
-  }
-
-  def addDefinitions(that: World.TopDefs): World.TopDefs = {
-    (pname,site,here) => {
-      try this.topDefinitions(pname, site, here)
-      catch {
-        case e: scala.MatchError => that(pname, site, here)
-      }
-    }
-  }
-
-  def addConstraints(that: List[Constraint]):List[Constraint] = {
-    this.topConstraints ++ that
-  }
-
-
-  def addKnobValues(that: Any=>Any): Any=>Any = { case x =>
-    try this.knobValues(x)
-    catch {
-      case e: scala.MatchError => that(x)
-    }
-  }
-
-  def toCollector = new Collector(this.topDefinitions, this.knobValues)
-  def toInstance = new Instance(this.topDefinitions, this.knobValues)
-  override def toString = this.getClass.getSimpleName
-}
-
-// TODO eliminate this or move it to DynamicContext
-object Dump {
-  def apply[T](key:Any,value:T):T = Builder.parameterDump.apply(key, value)
-  def apply[T](knob:Knob[T]):Knob[T] = Builder.parameterDump.apply(knob)
-}
-
-class ParameterDump {
-  val dump = mutable.Set[Tuple2[Any,Any]]()
-  val knobList = mutable.ListBuffer[Any]()
-  def apply[T](key:Any,value:T):T = {addToDump(key,value); value}
-  def apply[T](knob:Knob[T]):Knob[T] = {knobList += knob.name; knob}
-  def addToDump(key:Any,value:Any) = dump += ((key,value))
-  def getDump:String = if (!dump.isEmpty) {
-    dump.map(_.toString).reduce(_+"\n"+_) + "\n"
-  } else {
-    ""
-  }
-}
-
-// objects given to the user in mask functions (site,here,up)
-abstract class View {
-  protected val deftSite: View // when views are queried without a specifying a site this is the default
-
-  // use `this` view's behavior to query for a parameters value as if
-  // the original site were `site`
-  def apply[T](pname:Any, site:View):T
-  def sym[T](pname:Any, site:View):Ex[T]
-
-  // query for a parameters value using the default site
-  final def apply[T](pname:Any):T = apply[T](pname, deftSite)
-  final def apply[T](field:Field[T]):T = apply[T](field.asInstanceOf[Any], deftSite)
-
-  final def sym[T](pname:Any):Ex[T] = sym[T](pname, deftSite)
-  final def sym[T](field:Field[T]):Ex[T] = sym[T](field.asInstanceOf[Any], deftSite)
-}
-
-/* Wrap a View to make the application return the symbolic expression,
- * basically a shorthand to save typing '.sym'
- * before:
- *   val v: View
- *   v.sym[Int]("x") // returns Ex[_]
- * now:
- *   val vs = ViewSym(v)
- *   vs[Int]("xs") // Ex[_]
-*/
-final case class ViewSym(view:View) {
-  def apply[T](f:Any):Ex[T] = view.sym[T](f)
-  def apply[T](f:Field[T]):Ex[T] = view.sym[T](f)
-  def apply[T](f:Any, site:View):Ex[T] = view.sym[T](f, site)
-  def apply[T](f:Field[T], site:View):Ex[T] = view.sym[T](f, site)
-}
-
-
-// internal type to represent functions that evaluate parameter values
-abstract class _Lookup {
-
-  def apply[T](pname:Any, site:View):Ex[T]
-
-  // build a new Lookup that just defers to this one
-  final def push() = {
-    val me = this
-    new _Lookup {
-      def apply[T](pname:Any, site:View) = me.apply(pname, site)
-    }
-  }
-}
-
-// Internal type used as name in all ExVar[T]'s
-sealed abstract class _Var[T]
-
-// Variables which are 'free' parameters when seen from the top level.
-final case class _VarKnob[T](kname:Any) extends _Var[T] {
-  override def toString = kname.toString
-}
-// Variables whose values are computed by `expr`. The term 'let' comes
-// from the idea of 'let' bindings in functional languages i.e.:
-final case class _VarLet[T](pname:Any,expr:Ex[T]) extends _Var[T] {
-  override def toString = pname.toString + "{" + expr.toString + "}"
-}
-
-
-object World {
-  // An alias for the type of function provided by user to describe parameters that
-  // reach the top level. The return of this function can be either:
-  //   Knob(k): this parameter maps to the constraint variable `k`
-  //   Ex: this parameter is computed using the expression
-  //   Any(thing else): variable takes a literal value
-  type TopDefs = (/*pname:*/Any,/*site:*/View,/*here:*/View) => Any/*Knob[_] | Ex[_] | Any*/
-}
-
-// Worlds collect the variable definitions and constraints seen when building hardware.
-abstract class World(
-    topDefs: World.TopDefs
-  ) {
-
-  val _knobs = new mutable.HashSet[Any]
-  abstract class _View extends View {
-    val look: _Lookup
-
-    def apply[T](pname:Any, site:View):T = {
-      _eval(look(pname, site).asInstanceOf[Ex[T]])
-    }
-    def sym[T](pname:Any, site:View):Ex[T] = {
-      _bindLet[T](pname,look(pname, site).asInstanceOf[Ex[T]])
-    }
-  }
-
-  // evaluate an expression against this world
-  def _eval[T](e:Ex[T]):T = {
-    Ex.eval(e, {
-      case v:_VarKnob[_] => {
-        _knobs += v.kname
-        val e = _knobValue(v.kname)
-        if(Builder.parameterDump.knobList.contains(v.kname)) {Builder.parameterDump.addToDump(v.kname,e);e} else e
-      }
-      case v:_VarLet[_] => _eval(v.expr.asInstanceOf[Ex[T]])
-    })
-  }
-
-  // create a view whose default site is itself
-  def _siteView(look:_Lookup):View = {
-    val _look = look
-    new _View {
-      val look = _look
-      val deftSite = this
-    }
-  }
-
-  // create a View which with a supplied default site
-  def _otherView(look:_Lookup, deftSite:View):View = {
-    val _look = look
-    val _deft = deftSite
-    new _View {
-      val look = _look
-      val deftSite = _deft
-    }
-  }
-
-  // the top level lookup
-  def _topLook():_Lookup = {
-    class TopLookup extends _Lookup {
-
-      def apply[T](pname:Any, site:View):Ex[T] = {
-        val here = _otherView(this, site)
-        (
-          try topDefs(pname, site, here)
-          catch {
-            case e:scala.MatchError => throw new ParameterUndefinedException(pname, e)
-          }
-        ) match {
-          case k:Knob[T @unchecked] => ExVar[T](_VarKnob[T](k.name))
-          case ex:Ex[T @unchecked] => _bindLet[T](pname,ex)
-          case lit => ExLit(lit.asInstanceOf[T])
-        }
-      }
-    }
-    new TopLookup
-  }
-
-  def _bindLet[T](pname:Any,expr:Ex[T]):Ex[T]
-
-  def _constrain(e:Ex[Boolean]):Unit
-
-  def _knobValue(kname:Any):Any
-
-  def getConstraints:String = ""
-
-  def getKnobs:String = ""
-}
-
-// a world responsible for collecting all constraints in the first pass
-class Collector(
-    topDefs: World.TopDefs,
-    knobVal: Any=>Any // maps knob names to default-values
-  )
-  extends World(topDefs) {
-
-  val _constraints = new mutable.HashSet[Ex[Boolean]]
-
-  def knobs():List[Any] = {
-    _knobs.toList
-  }
-
-  def constraints():List[Ex[Boolean]] = {
-    _constraints.toList
-  }
-
-  def _bindLet[T](pname:Any,expr:Ex[T]):Ex[T] = {
-    expr match {
-      case e:ExVar[T] => expr
-      case e:ExLit[T] => expr
-      case _ => ExVar[T](_VarLet[T](pname,expr))
-    }
-  }
-
-  def _constrain(c:Ex[Boolean]) = {
-    _constraints += c // add the constraint
-
-    // Also add all equality constraints for all bound variables in the
-    // constraint expression and do it recursively for all expressions
-    // being bound to.
-    var q = List[Ex[_]](c)
-    while(!q.isEmpty) {
-      val e = q.head  // pop an expression
-      q = q.tail
-      // walk over the variables in `e`
-      for(e <- Ex.unfurl(e)) {
-        e match {
-          case ExVar(_VarLet(p,e1)) => {
-            // form the equality constraint
-            val c1 = ExEq[Any](e.asInstanceOf[Ex[Any]], e1.asInstanceOf[Ex[Any]])
-            // recurse into the expression if its never been seen before
-            if(!_constraints.contains(c1)) {
-              _constraints += c1
-              q ::= e1 // push
-            }
-          }
-          case _ => {}
-        }
-      }
-    }
-  }
-
-  def _knobValue(kname:Any) = {
-     try knobVal(kname)
-     catch {
-       case e:scala.MatchError => throw new KnobUndefinedException(kname, e)
-     }
-  }
-
-  override def getConstraints:String = if(constraints.isEmpty) "" else constraints.map("( " + _.toString + " )").reduce(_ +"\n" + _) + "\n"
-
-  override def getKnobs:String = if(knobs.isEmpty) "" else {
-    knobs.map(_.toString).reduce(_ + "\n" + _) + "\n"
-  }
-}
-
-// a world instantianted to a specific mapping of knobs to values
-class Instance(
-    topDefs: World.TopDefs,
-    knobVal: Any=>Any
-  )
-  extends World(topDefs) {
-
-  def _bindLet[T](pname:Any,expr:Ex[T]):Ex[T] = expr
-  def _constrain(e:Ex[Boolean]) = {}
-  def _knobValue(kname:Any) = {
-     try knobVal(kname)
-     catch {
-       case e:scala.MatchError => throw new KnobUndefinedException(kname, e)
-     }
-  }
-}
-
-object Parameters {
-  def root(w:World) = {
-    new Parameters(w, w._topLook())
-  }
-  def empty = Parameters.root(new Collector((a,b,c) => {throw new ParameterUndefinedException(a); a},(a:Any) => {throw new KnobUndefinedException(a); a}))
-
-  // Mask making helpers
-
-  // Lift a regular function into a mask by looking for MatchError's and
-  // interpreting those as calls to up
-  def makeMask(mask:(Any,View,View,View)=>Any) = {
-    (f:Any, site:View, here:View, up:View) => {
-      try mask(f,site,here,up)
-      catch {case e:MatchError => up.sym[Any](f, site)}
-    }
-  }
-
-  // Lift a Map to be a mask.
-  def makeMask(mask:Map[Any,Any]) = {
-    (f:Any, site:View, here:View, up:View) => {
-      mask.get(f) match {
-        case Some(y) => y
-        case None => up.sym[Any](f, site)
-      }
-    }
-  }
-
-  // Lift a PartialFunction to be a mask.
-  def makeMask(mask:PartialFunction[Any,Any]) = {
-    (f:Any, site:View, here:View, up:View) => {
-
-      if(mask.isDefinedAt(f))
-        mask.apply(f)
-      else {
-        up.sym[Any](f, site)
-      }
-    }
-  }
-}
-
-final class Parameters(
-    private val _world: World,
-    private val _look: _Lookup
-  ) {
-
-  private def _site() = _world._siteView(_look)
-
-  // Create a new Parameters that just defers to this one. This is identical
-  // to doing an `alter` but not overriding any values.
-  def push():Parameters =
-    new Parameters(_world, _look.push())
-
-  def apply[T](field:Any):T =
-    _world._eval(_look(field, _site())).asInstanceOf[T]
-
-  def apply[T](field:Field[T]):T =
-    _world._eval(_look(field, _site())).asInstanceOf[T]
-
-  def constrain(gen:ViewSym=>Ex[Boolean]) = {
-    val g = gen(new ViewSym(_site()))
-    if(!_world._eval(g)) Builder.error("Constraint failed: " + g.toString)
-    _world._constrain(g)
-  }
-
-  private def _alter(mask:(/*field*/Any,/*site*/View,/*here*/View,/*up*/View)=>Any) = {
-    class KidLookup extends _Lookup {
-
-      def apply[T](f:Any, site:View):Ex[T] = {
-        val here = _world._otherView(this, site)
-        val up = _world._otherView(_look, site)
-
-        mask(f, site, here, up) match {
-          case e:Ex[T @unchecked] => e
-          case lit => ExLit(lit.asInstanceOf[T])
-        }
-      }
-    }
-
-    new Parameters(_world, new KidLookup)
-  }
-
-  def alter(mask:(/*field*/Any,/*site*/View,/*here*/View,/*up*/View)=>Any) =
-    _alter(Parameters.makeMask(mask))
-
-  def alter[T](mask:Map[T,Any]) =
-    _alter(Parameters.makeMask(mask.asInstanceOf[Map[Any,Any]]))
-
-  def alterPartial(mask:PartialFunction[Any,Any]) =
-    _alter(Parameters.makeMask(mask))
-
-  def getConstraints:String = _world.getConstraints
-
-  def getKnobs:String = _world.getKnobs
-}
-
-
-/*
- Expression Library
-*/
-abstract class Ex[T] {
-  override def toString = Ex.pretty(this)
-}
-
-case class IntEx (expr:Ex[Int]) {
-  def === (x:IntEx):Ex[Boolean] = (ExEq[Int](expr,x.expr))
-  def +   (x:IntEx):Ex[Int] = ExAdd(expr,x.expr)
-  def -   (x:IntEx):Ex[Int] = ExSub(expr,x.expr)
-  def *   (x:IntEx):Ex[Int] = ExMul(expr,x.expr)
-  def %   (x:IntEx):Ex[Int] = ExMod(expr,x.expr)
-  def <   (x:IntEx):Ex[Boolean] = ExLt(expr,x.expr)
-  def >   (x:IntEx):Ex[Boolean] = ExGt(expr,x.expr)
-  def <=  (x:IntEx):Ex[Boolean] = ExLte(expr,x.expr)
-  def >=  (x:IntEx):Ex[Boolean] = ExGte(expr,x.expr)
-  def in  (x:List[IntEx]):Ex[Boolean] = {
-    val canBound = x.map(_.expr match {
-      case e:ExVar[_] => false
-      case _ => true
-    }).reduce(_ && _)
-    if (canBound) {
-      val max = x.map(i => Ex.eval(i.expr,(x:Any)=>null)).max
-      val min = x.map(i => Ex.eval(i.expr,(x:Any)=>null)).min
-      ExAnd(IntEx(expr) in Range(min,max), IntEx(expr) _in x)
-    } else {
-      IntEx(expr) _in x
-    }
-  }
-  def in  (x:Range):Ex[Boolean] = ExAnd(ExGte(expr,ExLit[Int](x.min)),ExLte(expr,ExLit[Int](x.max)))
-  private def _in (x:List[IntEx]):Ex[Boolean] = {
-    if (x.isEmpty) ExLit[Boolean](false) else {
-      ExOr(IntEx(expr) === x.head,IntEx(expr) _in x.tail)
-    }
-  }
-}
-
-case class BoolEx (expr:Ex[Boolean]) {
-  def &&  (x:BoolEx):Ex[Boolean] = ExAnd(expr,x.expr)
-  def ||  (x:BoolEx):Ex[Boolean] = ExOr(expr,x.expr)
-  def ^   (x:BoolEx):Ex[Boolean] = ExXor(expr,x.expr)
-  def === (x:BoolEx):Ex[Boolean] = ExEq[Boolean](expr,x.expr)
-  def !== (x:BoolEx):Ex[Boolean] = ExEq[Boolean](expr,x.expr)
-}
-
-object Implicits {
-  implicit def ExInt_IntEx(i:Ex[Int]):IntEx = IntEx(i)
-  implicit def Int_IntEx(i:Int):IntEx = IntEx(ExLit[Int](i))
-  implicit def ExBool_BoolEx(b:Ex[Boolean]):BoolEx = BoolEx(b)
-  implicit def Bool_IntEx(b:Boolean):BoolEx = BoolEx(ExLit[Boolean](b))
-
-  implicit def ListInt_ListExInt(l:List[Int]):List[IntEx] = l.map((x:Int) => IntEx(ExLit[Int](x)))
-  implicit def ListExInt_ListExInt(l:List[Ex[Int]]):List[IntEx] = l.map((x:Ex[Int]) => IntEx(x))
-}
-
-final case class ExLit[T](value:T) extends Ex[T]
-final case class ExVar[T](name:Any) extends Ex[T]
-
-final case class ExAnd(a:Ex[Boolean], b:Ex[Boolean]) extends Ex[Boolean]
-final case class ExOr(a:Ex[Boolean], b:Ex[Boolean]) extends Ex[Boolean]
-final case class ExXor(a:Ex[Boolean], b:Ex[Boolean]) extends Ex[Boolean]
-
-final case class ExEq[T](a:Ex[T], b:Ex[T]) extends Ex[Boolean]
-final case class ExNeq[T](a:Ex[T], b:Ex[T]) extends Ex[Boolean]
-
-final case class ExLt(a:Ex[Int], b:Ex[Int]) extends Ex[Boolean]
-final case class ExLte(a:Ex[Int], b:Ex[Int]) extends Ex[Boolean]
-final case class ExGt(a:Ex[Int], b:Ex[Int]) extends Ex[Boolean]
-final case class ExGte(a:Ex[Int], b:Ex[Int]) extends Ex[Boolean]
-final case class ExAdd(a:Ex[Int], b:Ex[Int]) extends Ex[Int]
-final case class ExSub(a:Ex[Int], b:Ex[Int]) extends Ex[Int]
-final case class ExMul(a:Ex[Int], b:Ex[Int]) extends Ex[Int]
-final case class ExMod(a:Ex[Int], b:Ex[Int]) extends Ex[Int]
-
-object Ex {
-  // evaluate an expression given a context that maps variable names to values
-  def eval[T](e:Ex[T], ctx:Any=>Any):T = e match {
-    case ExLit(v) => v.asInstanceOf[T]
-    case ExVar(nm) => ctx(nm).asInstanceOf[T]
-    case ExAnd(a,b) => eval(a,ctx) && eval(b,ctx)
-    case ExOr(a,b) => eval(a,ctx) || eval(b,ctx)
-    case ExXor(a,b) => eval(a,ctx) ^ eval(b,ctx)
-    case e:ExEq[u] => eval(e.a,ctx) == eval(e.b,ctx)
-    case e:ExNeq[u] => eval(e.a,ctx) != eval(e.b,ctx)
-    case ExLt(a,b) => eval(a,ctx) < eval(b,ctx)
-    case ExLte(a,b) => eval(a,ctx) <= eval(b,ctx)
-    case ExGt(a,b) => eval(a,ctx) > eval(b,ctx)
-    case ExGte(a,b) => eval(a,ctx) >= eval(b,ctx)
-    case ExAdd(a,b) => eval(a,ctx) + eval(b,ctx)
-    case ExSub(a,b) => eval(a,ctx) - eval(b,ctx)
-    case ExMul(a,b) => eval(a,ctx) * eval(b,ctx)
-    case ExMod(a,b) => eval(a,ctx) % eval(b,ctx)
-  }
-
-  // get shallow list of subexpressions
-  def subExs(e:Ex[_]):List[Ex[_]] = e match {
-    case ExLit(_) => Nil
-    case ExVar(_) => Nil
-    case ExAnd(a,b) => List(a,b)
-    case ExOr(a,b) => List(a,b)
-    case ExXor(a,b) => List(a,b)
-    case ExEq(a,b) => List(a,b)
-    case ExNeq(a,b) => List(a,b)
-    case ExLt(a,b) => List(a,b)
-    case ExLte(a,b) => List(a,b)
-    case ExGt(a,b) => List(a,b)
-    case ExGte(a,b) => List(a,b)
-    case ExAdd(a,b) => List(a,b)
-    case ExSub(a,b) => List(a,b)
-    case ExMul(a,b) => List(a,b)
-    case ExMod(a,b) => List(a,b)
-  }
-
-  // get all subexpressions including the expression given
-  def unfurl(e:Ex[_]):List[Ex[_]] =
-    e :: (subExs(e) flatMap unfurl)
-
-  // pretty-print expression
-  def pretty(e:Ex[_]):String = {
-    // precedence rank for deciding where to put parentheses
-    def rank(e:Ex[_]):Int = e match {
-      case e:ExAnd => 40
-      case e:ExOr => 50
-      case e:ExXor => 50
-      case e:ExEq[_] => 30
-      case e:ExNeq[_] => 30
-      case e:ExLt => 30
-      case e:ExLte => 30
-      case e:ExGt => 30
-      case e:ExGte => 30
-      case e:ExAdd => 20
-      case e:ExSub => 20
-      case e:ExMul => 20
-      case e:ExMod => 20
-      case e:ExLit[_] => 0
-      case e:ExVar[_] => 0
-    }
-
-    val r = rank(e)
-
-    def term(t:Ex[_]):String = {
-      val rt = rank(t)
-      //if(rt >= r)
-        "( " + t.toString + " )"
-      //else
-        //t.toString
-    }
-
-    import Implicits._
-    e match {
-      case ExLit(v) => v.toString
-      case e:ExVar[_]=> "$"+e.name
-      case ExAnd(a,b) => term(a)+" && "+term(b)
-      case ExOr(a,b) => term(a)+" || "+term(b)
-      case ExXor(a,b) => term(a)+" ^ "+term(b)
-      case ExEq(a,b) => term(a)+" = "+term(b)
-      case ExNeq(a,b) => term(a)+" != "+term(b)
-      case ExLt(a,b) => term(a)+" < "+term(b)
-      case ExLte(a,b) => term(a)+" <= "+term(b)
-      case ExGt(a,b) => term(a)+" > "+term(b)
-      case ExGte(a,b) => term(a)+" >= "+term(b)
-      case ExAdd(a,b) => term(a)+" + "+term(b)
-      case ExSub(a,b) => term(a)+" - "+term(b)
-      case ExMul(a,b) => term(a)+" * "+term(b)
-      case ExMod(a,b) => term(a)+" % "+term(b)
-    }
-  }
-}
diff --git a/src/main/scala/Chisel/internal/Builder.scala b/src/main/scala/Chisel/internal/Builder.scala
index b3c4ae40..79d5d6aa 100644
--- a/src/main/scala/Chisel/internal/Builder.scala
+++ b/src/main/scala/Chisel/internal/Builder.scala
@@ -74,21 +74,18 @@ private class DynamicContext {
   val globalRefMap = new RefMap
   val components = ArrayBuffer[Component]()
   var currentModule: Option[Module] = None
-  val parameterDump = new ParameterDump
   val errors = new ErrorLog
 }
 
 private object Builder {
   // All global mutable state must be referenced via dynamicContextVar!!
   private val dynamicContextVar = new DynamicVariable[Option[DynamicContext]](None)
-  private val currentParamsVar = new DynamicVariable[Parameters](Parameters.empty)
 
   def dynamicContext: DynamicContext = dynamicContextVar.value.get
   def idGen: IdGen = dynamicContext.idGen
   def globalNamespace: Namespace = dynamicContext.globalNamespace
   def globalRefMap: RefMap = dynamicContext.globalRefMap
   def components: ArrayBuffer[Component] = dynamicContext.components
-  def parameterDump: ParameterDump = dynamicContext.parameterDump
 
   def pushCommand[T <: Command](c: T): T = {
     dynamicContext.currentModule.foreach(_._commands += c)
@@ -99,11 +96,6 @@ private object Builder {
   def errors: ErrorLog = dynamicContext.errors
   def error(m: => String): Unit = errors.error(m)
 
-  def getParams: Parameters = currentParamsVar.value
-  def paramsScope[T](p: Parameters)(body: => T): T = {
-    currentParamsVar.withValue(p)(body)
-  }
-
   def build[T <: Module](f: => T): Circuit = {
     dynamicContextVar.withValue(Some(new DynamicContext)) {
       errors.info("Elaborating design...")
@@ -112,7 +104,7 @@ private object Builder {
       errors.checkpoint()
       errors.info("Done elaborating.")
 
-      Circuit(components.last.name, components, globalRefMap, parameterDump)
+      Circuit(components.last.name, components, globalRefMap)
     }
   }
 }
diff --git a/src/main/scala/Chisel/ir/IR.scala b/src/main/scala/Chisel/ir/IR.scala
index e25d3f56..106ad20c 100644
--- a/src/main/scala/Chisel/ir/IR.scala
+++ b/src/main/scala/Chisel/ir/IR.scala
@@ -152,6 +152,6 @@ case class ConnectInit(loc: Node, exp: Arg) extends Command
 case class Component(id: Module, name: String, ports: Seq[Port], commands: Seq[Command]) extends Arg
 case class Port(id: Data, dir: Direction)
 
-case class Circuit(name: String, components: Seq[Component], refMap: RefMap, parameterDump: ParameterDump) {
+case class Circuit(name: String, components: Seq[Component], refMap: RefMap) {
   def emit: String = new Emitter(this).toString
 }
diff --git a/src/main/scala/Chisel/testers/BasicTester.scala b/src/main/scala/Chisel/testers/BasicTester.scala
index c73567c4..dbb269bb 100644
--- a/src/main/scala/Chisel/testers/BasicTester.scala
+++ b/src/main/scala/Chisel/testers/BasicTester.scala
@@ -10,4 +10,6 @@ class BasicTester extends Module {
   }
   io.done := Bool(false)
   io.error := UInt(0)
+
+  def popCount(n: Long) = n.toBinaryString.count(_=='1')
 }
diff --git a/src/main/scala/Chisel/testers/Driver.scala b/src/main/scala/Chisel/testers/Driver.scala
deleted file mode 100644
index 860ef69c..00000000
--- a/src/main/scala/Chisel/testers/Driver.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-// See LICENSE for license details.
-
-package Chisel.testers
-import Chisel._
-
-object TesterDriver {
-  /** For use with modules that should successfully be elaborated by the
-    * frontend, and which can be turned into executeables with error codes. */
-  def execute(t: => BasicTester): Boolean = {
-    val circuit = Builder.build(Module(t))
-    //val executable = invokeFIRRTL(circuit)
-    //Process(executable) !
-    true
-  }
-
-  /** For use with modules that should illicit errors from the frontend
-    * or which produce IR with consistantly checkable properties. */
-  def elaborate(t: => Module): Circuit = {
-    Builder.build(Module(t))
-  }
-}
diff --git a/src/main/scala/Chisel/testers/TesterDriver.scala b/src/main/scala/Chisel/testers/TesterDriver.scala
new file mode 100644
index 00000000..657f7d37
--- /dev/null
+++ b/src/main/scala/Chisel/testers/TesterDriver.scala
@@ -0,0 +1,37 @@
+// See LICENSE for license details.
+
+package Chisel.testers
+import Chisel._
+import scala.sys.process._
+import java.io.File
+
+object TesterDriver extends BackendCompilationUtilities with FileSystemUtilities {
+  /** For use with modules that should successfully be elaborated by the
+    * frontend, and which can be turned into executeables with assertions. */
+  def execute(t: () => BasicTester): Boolean = {
+    // Invoke the chisel compiler to get the circuit's IR
+    val circuit = Driver.elaborate(t)
+
+    // Set up a bunch of file handlers based on a random temp filename,
+    // plus the quirks of Verilator's naming conventions
+    val target = circuit.name
+    val fname = File.createTempFile(target, "")
+    val path = fname.getParentFile.toString
+    val prefix = fname.toString.split("/").last
+    val dir = new File(System.getProperty("java.io.tmpdir"))
+    val vDut = new File(fname.toString + ".v")
+    val vH = new File(path + "/V" + prefix + ".h")
+    val cppHarness = new File(fname.toString + ".cpp")
+
+    // For now, dump the IR out to a file
+    Driver.dumpFirrtl(circuit, Some(new File(fname.toString + ".fir")))
+
+    // Use sys.Process to invoke a bunch of backend stuff, then run the resulting exe
+    if(((new File(System.getProperty("user.dir") + "/src/main/resources/top.cpp") #> cppHarness) #&&
+        firrtlToVerilog(prefix, dir) #&&
+        verilogToCpp(prefix, dir, vDut, cppHarness, vH) #&&
+        cppToExe(prefix, dir)).! == 0) {
+      executeExpectingSuccess(prefix, dir)
+    } else false
+  }
+}
diff --git a/src/test/scala/chiselTests/BitwiseOps.scala b/src/test/scala/chiselTests/BitwiseOps.scala
index 86c7131b..d180c11e 100644
--- a/src/test/scala/chiselTests/BitwiseOps.scala
+++ b/src/test/scala/chiselTests/BitwiseOps.scala
@@ -7,18 +7,18 @@ import org.scalatest._
 import org.scalatest.prop._
 import Chisel.testers.BasicTester
 
-class BitwiseOpsSpec extends ChiselPropSpec {
+class BitwiseOpsTester(w: Int, _a: Int, _b: Int) extends BasicTester {
+  io.done := Bool(true)
+  val mask = (1 << w) - 1
+  val a = UInt(_a)
+  val b = UInt(_b)
+  when(~a != UInt(mask & ~_a)) { io.error := UInt(1) }
+  when((a & b) != UInt(mask & (_a & _b))) { io.error := UInt(2) }
+  when((a | b)  != UInt(mask & (_a | _b))) { io.error := UInt(3) }
+  when((a ^ b) != UInt(mask & (_a ^ _b))) { io.error := UInt(4) }
+}
 
-  class BitwiseOpsTester(w: Int, _a: Int, _b: Int) extends BasicTester {
-    io.done := Bool(true)
-    val mask = (1 << w) - 1
-    val a = UInt(_a)
-    val b = UInt(_b)
-    when(~a != UInt(mask & ~_a)) { io.error := UInt(1) }
-    when((a & b) != UInt(mask & (_a & _b))) { io.error := UInt(2) }
-    when((a | b)  != UInt(mask & (_a | _b))) { io.error := UInt(3) }
-    when((a ^ b) != UInt(mask & (_a ^ _b))) { io.error := UInt(4) }
-  }
+class BitwiseOpsSpec extends ChiselPropSpec {
 
   property("All bit-wise ops should return the correct result") {
     forAll(safeUIntPair) { case(w: Int, a: Int, b: Int) =>
diff --git a/src/test/scala/chiselTests/BundleWire.scala b/src/test/scala/chiselTests/BundleWire.scala
index 99dc665f..5beed039 100644
--- a/src/test/scala/chiselTests/BundleWire.scala
+++ b/src/test/scala/chiselTests/BundleWire.scala
@@ -23,15 +23,15 @@ class BundleWire(n: Int) extends Module {
   }
 }
 
-class BundleWireSpec extends ChiselPropSpec {
+class BundleWireTester(n: Int, x: Int, y: Int) extends BasicTester {
+  val dut = Module(new BundleWire(n))
+  io.done := Bool(true)
+  dut.io.in.x := UInt(x)
+  dut.io.in.y := UInt(y)
+  io.error := dut.io.outs.map(o => o.x != UInt(x) || o.y != UInt(y)).foldLeft(UInt(0))(_##_)
+}
 
-  class BundleWireTester(n: Int, x: Int, y: Int) extends BasicTester {
-    val dut = Module(new BundleWire(n))
-    io.done := Bool(true)
-    dut.io.in.x := UInt(x)
-    dut.io.in.y := UInt(y)
-    io.error := dut.io.outs.map(o => o.x != UInt(x) || o.y != UInt(y)).foldLeft(UInt(0))(_##_)
-  }
+class BundleWireSpec extends ChiselPropSpec {
 
   property("All vec elems should match the inputs") {
     forAll(vecSizes, safeUInts, safeUInts) { (n: Int, x: Int, y: Int) =>
diff --git a/src/test/scala/chiselTests/ChiselSpec.scala b/src/test/scala/chiselTests/ChiselSpec.scala
index 1fe77a0e..88aaf06c 100644
--- a/src/test/scala/chiselTests/ChiselSpec.scala
+++ b/src/test/scala/chiselTests/ChiselSpec.scala
@@ -10,8 +10,8 @@ import Chisel.testers._
 
 /** Common utility functions for Chisel unit tests. */
 trait ChiselRunners {
-  def execute(t: => BasicTester): Boolean = TesterDriver.execute(t)
-  def elaborate(t: => Module): Circuit = TesterDriver.elaborate(t)
+  def execute(t: => BasicTester): Boolean = TesterDriver.execute(() => t)
+  def elaborate(t: => Module): Circuit = Driver.elaborate(() => t)
 }
 
 /** Spec base class for BDD-style testers. */
@@ -19,11 +19,9 @@ class ChiselFlatSpec extends FlatSpec with ChiselRunners with Matchers
 
 /** Spec base class for property-based testers. */
 class ChiselPropSpec extends PropSpec with ChiselRunners with PropertyChecks {
-  /** Returns the number of 1s in the binary representation of the input. */
-  def popCount(n: Long): Int = n.toBinaryString.count(_ == '1')
 
   // Generator for small positive integers.
-  val smallPosInts = Gen.choose(1, 7)
+  val smallPosInts = Gen.choose(1, 4)
 
   // Generator for widths considered "safe".
   val safeUIntWidth = Gen.choose(1, 30)
diff --git a/src/test/scala/chiselTests/ComplexAssign.scala b/src/test/scala/chiselTests/ComplexAssign.scala
index 09743e04..64fc8bda 100644
--- a/src/test/scala/chiselTests/ComplexAssign.scala
+++ b/src/test/scala/chiselTests/ComplexAssign.scala
@@ -29,23 +29,23 @@ class ComplexAssign(w: Int) extends Module {
   }
 }
 
+class ComplexAssignTester(enList: List[Boolean], re: Int, im: Int) extends BasicTester {
+  val (cnt, wrap) = Counter(Bool(true), enList.size)
+  val dut = Module(new ComplexAssign(32))
+  dut.io.in.re := UInt(re)
+  dut.io.in.im := UInt(im)
+  dut.io.e := Vec(enList.map(Bool(_)))(cnt)
+  val re_correct = dut.io.out.re === Mux(dut.io.e, dut.io.in.re, UInt(0))
+  val im_correct = dut.io.out.im === Mux(dut.io.e, dut.io.in.im, UInt(0))
+  when(!re_correct || !im_correct) {
+    io.done := Bool(true); io.error := cnt
+  } .elsewhen(wrap) { io.done := Bool(true) }
+}
+   
 class ComplexAssignSpec extends ChiselPropSpec {
 
-  class ComplexAssignTester(enList: List[Boolean], re: Int, im: Int) extends BasicTester {
-    val (cnt, wrap) = Counter(Bool(true), enList.size)
-    val dut = Module(new ComplexAssign(32))
-    dut.io.in.re := UInt(re)
-    dut.io.in.im := UInt(im)
-    dut.io.e := Vec(enList.map(Bool(_)))(cnt)
-    val re_correct = dut.io.out.re === Mux(dut.io.e, dut.io.in.re, UInt(0))
-    val im_correct = dut.io.out.im === Mux(dut.io.e, dut.io.in.im, UInt(0))
-    when(!re_correct || !im_correct) {
-      io.done := Bool(true); io.error := cnt
-    } .elsewhen(wrap) { io.done := Bool(true) }
-  }
-
   property("All complex assignments should return the correct result") {
-    forAll(enSequence(4), safeUInts, safeUInts) { (en: List[Boolean], re: Int, im: Int) =>
+    forAll(enSequence(2), safeUInts, safeUInts) { (en: List[Boolean], re: Int, im: Int) =>
       assert(execute{ new ComplexAssignTester(en, re, im) })
     }
   }
diff --git a/src/test/scala/chiselTests/Counter.scala b/src/test/scala/chiselTests/Counter.scala
index 0e8601b3..080130df 100644
--- a/src/test/scala/chiselTests/Counter.scala
+++ b/src/test/scala/chiselTests/Counter.scala
@@ -6,37 +6,37 @@ import org.scalatest._
 import org.scalatest.prop._
 import Chisel.testers.BasicTester
 
-class CounterSpec extends ChiselPropSpec {
+class CountTester(max: Int) extends BasicTester {
+  val cnt = Counter(max)
+  when(cnt.value === UInt(max)) { io.done := Bool(true) }
+}
 
-  class CountTester(max: Int) extends BasicTester {
-    val cnt = Counter(max)
-    when(cnt.value === UInt(max)) { io.done := Bool(true) }
+class EnableTester(seed: Int) extends BasicTester {
+  val ens = Reg(init = UInt(seed))
+  ens := ens >> 1
+  val (cntEn, cntWrap) = Counter(ens(0), 32)
+  val cnt = Counter(32)
+  when(cnt.value === UInt(31)) {
+    io.done := Bool(true)
+    io.error := cnt.value != UInt(popCount(seed))
   }
+}
+
+class WrapTester(max: Int) extends BasicTester {
+  val (cnt, wrap) = Counter(Bool(true), max)
+  when(wrap) { io.done := Bool(true); io.error := cnt != UInt(max) }
+}
+
+class CounterSpec extends ChiselPropSpec {
 
   property("Counter should count up") {
     forAll(smallPosInts) { (max: Int) => assert(execute{ new CountTester(max) }) }
   }
 
-  class EnableTester(seed: Int) extends BasicTester {
-    val ens = Reg(init = UInt(seed))
-    ens := ens >> 1
-    val (cntEn, cntWrap) = Counter(ens(0), 32)
-    val cnt = Counter(32)
-    when(cnt.value === UInt(31)) {
-      io.done := Bool(true)
-      io.error := cnt.value != UInt(popCount(seed))
-    }
-  }
-
   property("Counter can be en/disabled") {
     forAll(safeUInts) { (seed: Int) => assert(execute{ new EnableTester(seed) }) }
   }
 
-  class WrapTester(max: Int) extends BasicTester {
-    val (cnt, wrap) = Counter(Bool(true), max)
-    when(wrap) { io.done := Bool(true); io.error := cnt != UInt(max) }
-  }
-
   property("Counter should wrap") {
     forAll(smallPosInts) { (max: Int) => assert(execute{ new WrapTester(max) }) }
   }
diff --git a/src/test/scala/chiselTests/Decoder.scala b/src/test/scala/chiselTests/Decoder.scala
index 9ac0a3b7..7751804b 100644
--- a/src/test/scala/chiselTests/Decoder.scala
+++ b/src/test/scala/chiselTests/Decoder.scala
@@ -15,16 +15,16 @@ class Decoder(bitpats: List[String]) extends Module {
   io.matched := Vec(bitpats.map(BitPat(_) === io.inst)).reduce(_||_)
 }
 
-class DecoderSpec extends ChiselPropSpec {
+class DecoderTester(pairs: List[(String, String)]) extends BasicTester {
+  val (insts, bitpats) = pairs.unzip
+  val (cnt, wrap) = Counter(Bool(true), pairs.size)
+  val dut = Module(new Decoder(bitpats))
+  dut.io.inst := Vec(insts.map(UInt(_)))(cnt)
+  when(!dut.io.matched) { io.done := Bool(true); io.error := cnt }
+  when(wrap) { io.done := Bool(true) }
+}
 
-  class DecoderTester(pairs: List[(String, String)]) extends BasicTester {
-    val (insts, bitpats) = pairs.unzip
-    val (cnt, wrap) = Counter(Bool(true), pairs.size)
-    val dut = Module(new Decoder(bitpats))
-    dut.io.inst := Vec(insts.map(UInt(_)))(cnt)
-    when(!dut.io.matched) { io.done := Bool(true); io.error := cnt }
-    when(wrap) { io.done := Bool(true) }
-  }
+class DecoderSpec extends ChiselPropSpec {
 
   // Use a single Int to make both a specific instruction and a BitPat that will match it
   val bitpatPair = for(seed <- Arbitrary.arbitrary[Int]) yield {
@@ -36,7 +36,7 @@ class DecoderSpec extends ChiselPropSpec {
   private def nPairs(n: Int) = Gen.containerOfN[List, (String,String)](n,bitpatPair)
 
   property("BitPat wildcards should be usable in decoding") {
-    forAll(nPairs(16)){ (pairs: List[(String, String)]) =>
+    forAll(nPairs(4)){ (pairs: List[(String, String)]) =>
       assert(execute{ new DecoderTester(pairs) })
     }
   }
diff --git a/src/test/scala/chiselTests/GCD.scala b/src/test/scala/chiselTests/GCD.scala
index 48a96f0d..acc1e84e 100644
--- a/src/test/scala/chiselTests/GCD.scala
+++ b/src/test/scala/chiselTests/GCD.scala
@@ -24,21 +24,21 @@ class GCD extends Module {
   io.v := y === UInt(0)
 }
 
-class GCDSpec extends ChiselPropSpec {
-
-  class GCDTester(a: Int, b: Int, z: Int) extends BasicTester {
-    val dut = Module(new GCD)
-    val first = Reg(init=Bool(true))
-    dut.io.a := UInt(a)
-    dut.io.b := UInt(b)
-    dut.io.e := first
-    when(first) { first := Bool(false) }
-    when(dut.io.v) {
-      io.done := Bool(true)
-      io.error := (dut.io.z != UInt(z)).toUInt
-    }
+class GCDTester(a: Int, b: Int, z: Int) extends BasicTester {
+  val dut = Module(new GCD)
+  val first = Reg(init=Bool(true))
+  dut.io.a := UInt(a)
+  dut.io.b := UInt(b)
+  dut.io.e := first
+  when(first) { first := Bool(false) }
+  when(dut.io.v) {
+    io.done := Bool(true)
+    io.error := (dut.io.z != UInt(z)).toUInt
   }
+}
 
+class GCDSpec extends ChiselPropSpec {
+  
   //TODO: use generators and this function to make z's
   def gcd(a: Int, b: Int): Int = if(b == 0) a else gcd(b, a%b)
 
diff --git a/src/test/scala/chiselTests/Harness.scala b/src/test/scala/chiselTests/Harness.scala
new file mode 100644
index 00000000..98ad3b11
--- /dev/null
+++ b/src/test/scala/chiselTests/Harness.scala
@@ -0,0 +1,75 @@
+package chiselTests
+import Chisel.testers.BasicTester
+import org.scalatest._
+import org.scalatest.prop._
+import java.io.File
+
+class HarnessSpec extends ChiselPropSpec 
+  with Chisel.BackendCompilationUtilities {
+
+  def makeTrivialVerilog = makeHarness((prefix: String) => s"""
+module ${prefix};
+  initial begin
+    $$display("$prefix!");
+    $$finish;
+  end
+endmodule
+""", ".v") _
+
+  def makeFailingVerilog = makeHarness((prefix: String) => s"""
+module $prefix;
+  initial begin
+    assert (1 == 0) else $$error("My specific, expected error message!");
+    $$display("$prefix!");
+    $$finish;
+  end
+endmodule
+""", ".v") _
+
+  def makeCppHarness = makeHarness((prefix: String) => s"""
+#include "V$prefix.h"
+#include "verilated.h"
+
+vluint64_t main_time = 0;
+double sc_time_stamp () { return main_time; }
+
+int main(int argc, char **argv, char **env) {
+    Verilated::commandArgs(argc, argv);
+    V${prefix}* top = new V${prefix};
+    while (!Verilated::gotFinish()) { top->eval(); }
+    delete top;
+    exit(0);
+}
+""", ".cpp") _
+
+  val dir = new File(System.getProperty("java.io.tmpdir"))
+
+  def simpleHarnessBackend(make: File => File): String = {
+    val target = "test"
+    val fname = File.createTempFile(target, "")
+    val path = fname.getParentFile.toString
+    val prefix = fname.toString.split("/").last
+    val vDut = make(fname)
+    val vH = new File(path + "/V" + prefix + ".h")
+    val cppHarness = makeCppHarness(fname)
+    verilogToCpp(target, dir, vDut, cppHarness, vH).!
+    cppToExe(prefix, dir).!
+    prefix
+  }
+
+  property("Test making trivial verilog harness and executing") {
+    val prefix = simpleHarnessBackend(makeTrivialVerilog)
+
+    assert(executeExpectingSuccess(prefix, dir))
+  }
+
+  property("Test that assertion failues in Verilog are caught") {
+    val prefix = simpleHarnessBackend(makeFailingVerilog)
+
+    assert(!executeExpectingSuccess(prefix, dir))
+    assert(executeExpectingFailure(prefix, dir))
+    assert(executeExpectingFailure(prefix, dir, "My specific, expected error message!"))
+    assert(!executeExpectingFailure(prefix, dir, "A string that doesn't match any test output"))
+  }
+}
+ 
diff --git a/src/test/scala/chiselTests/MulLookup.scala b/src/test/scala/chiselTests/MulLookup.scala
index 18dcc431..93917a4e 100644
--- a/src/test/scala/chiselTests/MulLookup.scala
+++ b/src/test/scala/chiselTests/MulLookup.scala
@@ -22,15 +22,15 @@ class MulLookup(val w: Int) extends Module {
   io.z := tbl(((io.x << w) | io.y))
 }
 
-class MulLookupSpec extends ChiselPropSpec {
+class MulLookupTester(w: Int, x: Int, y: Int) extends BasicTester {
+  val dut = Module(new MulLookup(w))
+  dut.io.x := UInt(x)
+  dut.io.y := UInt(y)
+  io.done := Bool(true)
+  io.error := dut.io.z != UInt(x * y)
+}
 
-  class MulLookupTester(w: Int, x: Int, y: Int) extends BasicTester {
-    val dut = Module(new MulLookup(w))
-    dut.io.x := UInt(x)
-    dut.io.y := UInt(y)
-    io.done := Bool(true)
-    io.error := dut.io.z != UInt(x * y)
-  }
+class MulLookupSpec extends ChiselPropSpec {
 
   property("Mul lookup table should return the correct result") {
     forAll(smallPosInts, smallPosInts) { (x: Int, y: Int) =>
diff --git a/src/test/scala/chiselTests/Tbl.scala b/src/test/scala/chiselTests/Tbl.scala
index 072f993f..40f71c69 100644
--- a/src/test/scala/chiselTests/Tbl.scala
+++ b/src/test/scala/chiselTests/Tbl.scala
@@ -23,22 +23,22 @@ class Tbl(w: Int, n: Int) extends Module {
   }
 }
 
-class TblSpec extends ChiselPropSpec {
+class TblTester(w: Int, n: Int, idxs: List[Int], values: List[Int]) extends BasicTester {
+  val (cnt, wrap) = Counter(Bool(true), idxs.size)
+  val dut = Module(new Tbl(w, n))
+  val vvalues = Vec(values.map(UInt(_)))
+  val vidxs = Vec(idxs.map(UInt(_)))
+  val prev_idx = vidxs(cnt - UInt(1))
+  val prev_value = vvalues(cnt - UInt(1))
+  dut.io.wi := vidxs(cnt)
+  dut.io.ri := prev_idx
+  dut.io.we := Bool(true) //TODO enSequence
+  dut.io.d := vvalues(cnt)
+  when(cnt > UInt(0) && dut.io.o != prev_value) { io.done := Bool(true); io.error := prev_idx }
+  when(wrap) { io.done := Bool(true) }
+}
 
-  class TblTester(w: Int, n: Int, idxs: List[Int], values: List[Int]) extends BasicTester {
-    val (cnt, wrap) = Counter(Bool(true), idxs.size)
-    val dut = Module(new Tbl(w, n))
-    val vvalues = Vec(values.map(UInt(_)))
-    val vidxs = Vec(idxs.map(UInt(_)))
-    val prev_idx = vidxs(cnt - UInt(1))
-    val prev_value = vvalues(cnt - UInt(1))
-    dut.io.wi := vidxs(cnt)
-    dut.io.ri := prev_idx
-    dut.io.we := Bool(true) //TODO enSequence
-    dut.io.d := vvalues(cnt)
-    when(cnt > UInt(0) && dut.io.o != prev_value) { io.done := Bool(true); io.error := prev_idx }
-    when(wrap) { io.done := Bool(true) }
-  }
+class TblSpec extends ChiselPropSpec {
 
   property("All table reads should return the previous write") {
     forAll(safeUIntPairN(8)) { case(w: Int, pairs: List[(Int, Int)]) =>
diff --git a/src/test/scala/chiselTests/Vec.scala b/src/test/scala/chiselTests/Vec.scala
index ea670f37..4430ab66 100644
--- a/src/test/scala/chiselTests/Vec.scala
+++ b/src/test/scala/chiselTests/Vec.scala
@@ -7,15 +7,36 @@ import org.scalatest._
 import org.scalatest.prop._
 import Chisel.testers.BasicTester
 
-class VecSpec extends ChiselPropSpec {
+class ValueTester(w: Int, values: List[Int]) extends BasicTester {
+  io.done := Bool(true)
+  val v = Vec(values.map(UInt(_, width = w))) // TODO: does this need a Wire? Why no error?
+  io.error := v.zip(values).map { case(a,b) =>
+    a != UInt(b)
+  }.foldLeft(UInt(0))(_##_)
+}
 
-  class ValueTester(w: Int, values: List[Int]) extends BasicTester {
-    io.done := Bool(true)
-    val v = Vec(values.map(UInt(_, width = w))) // TODO: does this need a Wire? Why no error?
-    io.error := v.zip(values).map { case(a,b) =>
-      a != UInt(b)
-    }.foldLeft(UInt(0))(_##_)
-  }
+class TabulateTester(n: Int) extends BasicTester {
+  io.done := Bool(true)
+  val v = Vec(Range(0, n).map(i => UInt(i * 2)))
+  val x = Vec(Array.tabulate(n){ i => UInt(i * 2) })
+  val u = Vec.tabulate(n)(i => UInt(i*2))
+  when(v.toBits != x.toBits) { io.error := UInt(1) }
+  when(v.toBits != u.toBits) { io.error := UInt(2) }
+  when(x.toBits != u.toBits) { io.error := UInt(3) }
+}
+
+class ShiftRegisterTester(n: Int) extends BasicTester {
+  val (cnt, wrap) = Counter(Bool(true), n*2)
+  when(wrap) { io.done := Bool(true) }
+
+  val shifter = Vec(Reg(UInt(width = log2Up(n))), n)
+  (shifter, shifter drop 1).zipped.foreach(_ := _)
+  shifter(n-1) := cnt
+  val expected = cnt - UInt(n)
+  when(cnt >= UInt(n) && expected != shifter(0)) { io.done := Bool(true); io.error := expected }
+}
+
+class VecSpec extends ChiselPropSpec {
 
   property("Vecs should be assignable") {
     forAll(safeUIntN(8)) { case(w: Int, v: List[Int]) =>
@@ -23,31 +44,10 @@ class VecSpec extends ChiselPropSpec {
     }
   }
 
-  class TabulateTester(n: Int) extends BasicTester {
-    io.done := Bool(true)
-    val v = Vec(Range(0, n).map(i => UInt(i * 2)))
-    val x = Vec(Array.tabulate(n){ i => UInt(i * 2) })
-    val u = Vec.tabulate(n)(i => UInt(i*2))
-    when(v.toBits != x.toBits) { io.error := UInt(1) }
-    when(v.toBits != u.toBits) { io.error := UInt(2) }
-    when(x.toBits != u.toBits) { io.error := UInt(3) }
-  }
-
   property("Vecs should tabulate correctly") {
     forAll(smallPosInts) { (n: Int) => assert(execute{ new TabulateTester(n) }) }
   }
 
-  class ShiftRegisterTester(n: Int) extends BasicTester {
-    val (cnt, wrap) = Counter(Bool(true), n*2)
-    when(wrap) { io.done := Bool(true) }
-
-    val shifter = Vec(Reg(UInt(width = log2Up(n))), n)
-    (shifter, shifter drop 1).zipped.foreach(_ := _)
-    shifter(n-1) := cnt
-    val expected = cnt - UInt(n)
-    when(cnt >= UInt(n) && expected != shifter(0)) { io.done := Bool(true); io.error := expected }
-  }
-
   property("Vecs of regs should be usable as shift registers") {
     forAll(smallPosInts) { (n: Int) => assert(execute{ new ShiftRegisterTester(n) }) }
   }