Merge pull request #284 from ucb-bar/more_utils_cleanups

More utils cleanups

9 files changed, 169 insertions, 143 deletions

diff --git a/src/main/scala/firrtl/passes/Checks.scala b/src/main/scala/firrtl/passes/Checks.scala
index bba3efe7..16b16ff7 100644
--- a/src/main/scala/firrtl/passes/Checks.scala
+++ b/src/main/scala/firrtl/passes/Checks.scala
@@ -572,12 +572,12 @@ object CheckWidths extends Pass {
             errors append new WidthTooSmall(info, mname, e.value)
           case _ =>
         }
-        case DoPrim(Bits, Seq(a), Seq(hi, lo), _) if long_BANG(a.tpe) <= hi =>
-          errors append new BitsWidthException(info, mname, hi, long_BANG(a.tpe))
-        case DoPrim(Head, Seq(a), Seq(n), _) if long_BANG(a.tpe) < n =>
-          errors append new HeadWidthException(info, mname, n, long_BANG(a.tpe))
-        case DoPrim(Tail, Seq(a), Seq(n), _) if long_BANG(a.tpe) <= n =>
-          errors append new TailWidthException(info, mname, n, long_BANG(a.tpe))
+        case DoPrim(Bits, Seq(a), Seq(hi, lo), _) if bitWidth(a.tpe) <= hi =>
+          errors append new BitsWidthException(info, mname, hi, bitWidth(a.tpe))
+        case DoPrim(Head, Seq(a), Seq(n), _) if bitWidth(a.tpe) < n =>
+          errors append new HeadWidthException(info, mname, n, bitWidth(a.tpe))
+        case DoPrim(Tail, Seq(a), Seq(n), _) if bitWidth(a.tpe) <= n =>
+          errors append new TailWidthException(info, mname, n, bitWidth(a.tpe))
         case _ =>
       }
       e map check_width_w(info, mname) map check_width_e(info, mname)
diff --git a/src/main/scala/firrtl/passes/ConstProp.scala b/src/main/scala/firrtl/passes/ConstProp.scala
index a4d9078c..789f2e03 100644
--- a/src/main/scala/firrtl/passes/ConstProp.scala
+++ b/src/main/scala/firrtl/passes/ConstProp.scala
@@ -38,7 +38,7 @@ import annotation.tailrec
 object ConstProp extends Pass {
   def name = "Constant Propagation"
 
-  private def pad(e: Expression, t: Type) = (long_BANG(e.tpe), long_BANG(t)) match {
+  private def pad(e: Expression, t: Type) = (bitWidth(e.tpe), bitWidth(t)) match {
     case (we, wt) if we < wt => DoPrim(Pad, Seq(e), Seq(wt), t)
     case (we, wt) if we == wt => e
   }
@@ -62,7 +62,7 @@ object ConstProp extends Pass {
     def simplify(e: Expression, lhs: Literal, rhs: Expression) = lhs match {
       case UIntLiteral(v, w) if v == 0 => UIntLiteral(0, w)
       case SIntLiteral(v, w) if v == 0 => UIntLiteral(0, w)
-      case UIntLiteral(v, IntWidth(w)) if v == (BigInt(1) << long_BANG(rhs.tpe).toInt) - 1 => rhs
+      case UIntLiteral(v, IntWidth(w)) if v == (BigInt(1) << bitWidth(rhs.tpe).toInt) - 1 => rhs
       case _ => e
     }
   }
@@ -72,7 +72,7 @@ object ConstProp extends Pass {
     def simplify(e: Expression, lhs: Literal, rhs: Expression) = lhs match {
       case UIntLiteral(v, _) if v == 0 => rhs
       case SIntLiteral(v, _) if v == 0 => asUInt(rhs, e.tpe)
-      case UIntLiteral(v, IntWidth(w)) if v == (BigInt(1) << long_BANG(rhs.tpe).toInt) - 1 => lhs
+      case UIntLiteral(v, IntWidth(w)) if v == (BigInt(1) << bitWidth(rhs.tpe).toInt) - 1 => lhs
       case _ => e
     }
   }
@@ -89,7 +89,7 @@ object ConstProp extends Pass {
   object FoldEqual extends FoldLogicalOp {
     def fold(c1: Literal, c2: Literal) = UIntLiteral(if (c1.value == c2.value) 1 else 0, IntWidth(1))
     def simplify(e: Expression, lhs: Literal, rhs: Expression) = lhs match {
-      case UIntLiteral(v, IntWidth(w)) if v == 1 && w == 1 && long_BANG(rhs.tpe) == 1 => rhs
+      case UIntLiteral(v, IntWidth(w)) if v == 1 && w == 1 && bitWidth(rhs.tpe) == 1 => rhs
       case _ => e
     }
   }
@@ -97,7 +97,7 @@ object ConstProp extends Pass {
   object FoldNotEqual extends FoldLogicalOp {
     def fold(c1: Literal, c2: Literal) = UIntLiteral(if (c1.value != c2.value) 1 else 0, IntWidth(1))
     def simplify(e: Expression, lhs: Literal, rhs: Expression) = lhs match {
-      case UIntLiteral(v, IntWidth(w)) if v == 0 && w == 1 && long_BANG(rhs.tpe) == 1 => rhs
+      case UIntLiteral(v, IntWidth(w)) if v == 0 && w == 1 && bitWidth(rhs.tpe) == 1 => rhs
       case _ => e
     }
   }
@@ -226,7 +226,7 @@ object ConstProp extends Pass {
     case Pad => e.args(0) match {
       case UIntLiteral(v, _) => UIntLiteral(v, IntWidth(e.consts(0)))
       case SIntLiteral(v, _) => SIntLiteral(v, IntWidth(e.consts(0)))
-      case _ if long_BANG(e.args(0).tpe) == e.consts(0) => e.args(0)
+      case _ if bitWidth(e.args(0).tpe) == e.consts(0) => e.args(0)
       case _ => e
     }
     case Bits => e.args(0) match {
@@ -234,9 +234,9 @@ object ConstProp extends Pass {
         val hi = e.consts(0).toInt
         val lo = e.consts(1).toInt
         require(hi >= lo)
-        UIntLiteral((lit.value >> lo) & ((BigInt(1) << (hi - lo + 1)) - 1), width_BANG(e.tpe))
+        UIntLiteral((lit.value >> lo) & ((BigInt(1) << (hi - lo + 1)) - 1), getWidth(e.tpe))
       }
-      case x if long_BANG(e.tpe) == long_BANG(x.tpe) => x.tpe match {
+      case x if bitWidth(e.tpe) == bitWidth(x.tpe) => x.tpe match {
         case t: UIntType => x
         case _ => asUInt(x, e.tpe)
       }
@@ -253,7 +253,7 @@ object ConstProp extends Pass {
   private def constPropMux(m: Mux): Expression = (m.tval, m.fval) match {
     case _ if m.tval == m.fval => m.tval
     case (t: UIntLiteral, f: UIntLiteral) =>
-      if (t.value == 1 && f.value == 0 && long_BANG(m.tpe) == 1) m.cond
+      if (t.value == 1 && f.value == 0 && bitWidth(m.tpe) == 1) m.cond
       else constPropMuxCond(m)
     case _ => constPropMuxCond(m)
   }
diff --git a/src/main/scala/firrtl/passes/InferTypes.scala b/src/main/scala/firrtl/passes/InferTypes.scala
index b36298e8..79200a58 100644
--- a/src/main/scala/firrtl/passes/InferTypes.scala
+++ b/src/main/scala/firrtl/passes/InferTypes.scala
@@ -66,20 +66,20 @@ object InferTypes extends Pass {
         types(s.name) = t
         s copy (tpe = t)
       case s: DefWire =>
-        val t = remove_unknowns(get_type(s))
+        val t = remove_unknowns(s.tpe)
         types(s.name) = t
         s copy (tpe = t)
       case s: DefNode =>
-        val sx = s map infer_types_e(types)
-        val t = remove_unknowns(get_type(sx))
+        val sx = (s map infer_types_e(types)).asInstanceOf[DefNode]
+        val t = remove_unknowns(sx.value.tpe)
         types(s.name) = t
         sx map infer_types_e(types)
       case s: DefRegister =>
-        val t = remove_unknowns(get_type(s))
+        val t = remove_unknowns(s.tpe)
         types(s.name) = t
         s copy (tpe = t) map infer_types_e(types)
       case s: DefMemory =>
-        val t = remove_unknowns(get_type(s))
+        val t = remove_unknowns(MemPortUtils.memType(s))
         types(s.name) = t
         s copy (dataType = remove_unknowns(s.dataType))
       case s => s map infer_types_s(types) map infer_types_e(types)
@@ -128,10 +128,10 @@ object CInferTypes extends Pass {
         types(s.name) = s.tpe
         s
       case (s: DefNode) =>
-        types(s.name) = get_type(s)
+        types(s.name) = s.value.tpe
         s
       case (s: DefMemory) =>
-        types(s.name) = get_type(s)
+        types(s.name) = MemPortUtils.memType(s)
         s
       case (s: CDefMPort) =>
         val t = types getOrElse(s.mem, UnknownType)
diff --git a/src/main/scala/firrtl/passes/InferWidths.scala b/src/main/scala/firrtl/passes/InferWidths.scala
index 5a81c268..6b2ff6ed 100644
--- a/src/main/scala/firrtl/passes/InferWidths.scala
+++ b/src/main/scala/firrtl/passes/InferWidths.scala
@@ -214,8 +214,8 @@ object InferWidths extends Pass {
     def get_constraints_e(e: Expression): Expression = {
       e match {
         case (e: Mux) => v ++= Seq(
-          WGeq(width_BANG(e.cond), IntWidth(1)),
-          WGeq(IntWidth(1), width_BANG(e.cond))
+          WGeq(getWidth(e.cond), IntWidth(1)),
+          WGeq(IntWidth(1), getWidth(e.cond))
         )
         case _ =>
       }
@@ -230,8 +230,8 @@ object InferWidths extends Pass {
           val exps = create_exps(s.expr)
           v ++= ((locs zip exps).zipWithIndex map {case ((locx, expx), i) =>
             get_flip(s.loc.tpe, i, Default) match {
-              case Default => WGeq(width_BANG(locx), width_BANG(expx))
-              case Flip => WGeq(width_BANG(expx), width_BANG(locx))
+              case Default => WGeq(getWidth(locx), getWidth(expx))
+              case Flip => WGeq(getWidth(expx), getWidth(locx))
             }
           })
         case (s: PartialConnect) =>
@@ -242,17 +242,17 @@ object InferWidths extends Pass {
             val locx = locs(x)
             val expx = exps(y)
             get_flip(s.loc.tpe, x, Default) match {
-              case Default => WGeq(width_BANG(locx), width_BANG(expx))
-              case Flip => WGeq(width_BANG(expx), width_BANG(locx))
+              case Default => WGeq(getWidth(locx), getWidth(expx))
+              case Flip => WGeq(getWidth(expx), getWidth(locx))
             }
           })
         case (s:DefRegister) => v ++= (Seq(
-           WGeq(width_BANG(s.reset), IntWidth(1)),
-           WGeq(IntWidth(1), width_BANG(s.reset))
+           WGeq(getWidth(s.reset), IntWidth(1)),
+           WGeq(IntWidth(1), getWidth(s.reset))
         ) ++ get_constraints_t(s.tpe, s.init.tpe, Default))
         case (s:Conditionally) => v ++= Seq(
-           WGeq(width_BANG(s.pred), IntWidth(1)),
-           WGeq(IntWidth(1), width_BANG(s.pred))
+           WGeq(getWidth(s.pred), IntWidth(1)),
+           WGeq(IntWidth(1), getWidth(s.pred))
         )
         case _ =>
       }
diff --git a/src/main/scala/firrtl/passes/MemUtils.scala b/src/main/scala/firrtl/passes/MemUtils.scala
index adbf23e5..87033176 100644
--- a/src/main/scala/firrtl/passes/MemUtils.scala
+++ b/src/main/scala/firrtl/passes/MemUtils.scala
@@ -38,24 +38,23 @@ object seqCat {
   def apply(args: Seq[Expression]): Expression = args.length match {
     case 0 => error("Empty Seq passed to seqcat")
     case 1 => args(0)
-    case 2 => DoPrim(PrimOps.Cat, args, Seq.empty[BigInt], UIntType(UnknownWidth))
-    case _ => {
-      val seqs = args.splitAt(args.length/2)
-      DoPrim(PrimOps.Cat, Seq(seqCat(seqs._1), seqCat(seqs._2)), Seq.empty[BigInt], UIntType(UnknownWidth))
-    }
+    case 2 => DoPrim(PrimOps.Cat, args, Nil, UIntType(UnknownWidth))
+    case _ =>
+      val (high, low) = args splitAt (args.length / 2)
+      DoPrim(PrimOps.Cat, Seq(seqCat(high), seqCat(low)), Nil, UIntType(UnknownWidth))
   }
 }
 
 object toBits {
   def apply(e: Expression): Expression = e match {
-    case ex: WRef => hiercat(ex, ex.tpe)
-    case ex: WSubField => hiercat(ex, ex.tpe)
-    case ex: WSubIndex => hiercat(ex, ex.tpe)
+    case ex @ (_: WRef | _: WSubField | _: WSubIndex) => hiercat(ex, ex.tpe)
     case t => error("Invalid operand expression for toBits!")
   }
-  def hiercat(e: Expression, dt: Type): Expression = dt match {
-    case t: VectorType => seqCat((0 until t.size).reverse.map(i => hiercat(WSubIndex(e, i, t.tpe, UNKNOWNGENDER), t.tpe)))
-    case t: BundleType => seqCat(t.fields.map(f => hiercat(WSubField(e, f.name, f.tpe, UNKNOWNGENDER), f.tpe)))
+  private def hiercat(e: Expression, dt: Type): Expression = dt match {
+    case t: VectorType => seqCat((0 until t.size) map (i =>
+      hiercat(WSubIndex(e, i, t.tpe, UNKNOWNGENDER),t.tpe)))
+    case t: BundleType => seqCat(t.fields map (f =>
+      hiercat(WSubField(e, f.name, f.tpe, UNKNOWNGENDER), f.tpe)))
     case t: GroundType => e
     case t => error("Unknown type encountered in toBits!")
   }
@@ -64,23 +63,36 @@ object toBits {
 // TODO: make easier to understand
 object toBitMask {
   def apply(e: Expression, dataType: Type): Expression = e match {
-    case ex: WRef => hiermask(ex, ex.tpe, dataType)
-    case ex: WSubField => hiermask(ex, ex.tpe, dataType)
-    case ex: WSubIndex => hiermask(ex, ex.tpe, dataType)
+    case ex @ (_: WRef | _: WSubField | _: WSubIndex) => hiermask(ex, ex.tpe, dataType)
     case t => error("Invalid operand expression for toBits!")
   }
-  def hiermask(e: Expression, maskType: Type, dataType: Type): Expression = (maskType, dataType) match {
-    case (mt: VectorType, dt: VectorType) => seqCat((0 until mt.size).reverse.map(i => hiermask(WSubIndex(e, i, mt.tpe, UNKNOWNGENDER), mt.tpe, dt.tpe)))
-    case (mt: BundleType, dt: BundleType) => seqCat((mt.fields zip dt.fields).map { case (mf, df) =>
-      hiermask(WSubField(e, mf.name, mf.tpe, UNKNOWNGENDER), mf.tpe, df.tpe) } )
-    case (mt: UIntType, dt: GroundType) => seqCat(List.fill(bitWidth(dt).intValue)(e))
-    case (mt, dt) => error("Invalid type for mask component!")
+  private def hiermask(e: Expression, maskType: Type, dataType: Type): Expression =
+    (maskType, dataType) match {
+      case (mt: VectorType, dt: VectorType) =>
+        seqCat((0 until mt.size).reverse map { i =>
+          hiermask(WSubIndex(e, i, mt.tpe, UNKNOWNGENDER), mt.tpe, dt.tpe)
+        })
+      case (mt: BundleType, dt: BundleType) =>
+        seqCat((mt.fields zip dt.fields) map { case (mf, df) =>
+          hiermask(WSubField(e, mf.name, mf.tpe, UNKNOWNGENDER), mf.tpe, df.tpe)
+        })
+      case (mt: UIntType, dt: GroundType) =>
+        seqCat(List.fill(bitWidth(dt).intValue)(e))
+      case (mt, dt) => error("Invalid type for mask component!")
+    }
+}
+
+object getWidth {
+  def apply(t: Type): Width = t match {
+    case t: GroundType => t.width
+    case _ => error("No width!")
   }
+  def apply(e: Expression): Width = apply(e.tpe)
 }
 
 object bitWidth {
   def apply(dt: Type): BigInt = widthOf(dt)
-  def widthOf(dt: Type): BigInt = dt match {
+  private def widthOf(dt: Type): BigInt = dt match {
     case t: VectorType => t.size * bitWidth(t.tpe)
     case t: BundleType => t.fields.map(f => bitWidth(f.tpe)).foldLeft(BigInt(0))(_+_)
     case GroundType(IntWidth(width)) => width
@@ -91,43 +103,47 @@ object bitWidth {
 object fromBits {
   def apply(lhs: Expression, rhs: Expression): Statement = {
     val fbits = lhs match {
-      case ex: WRef => getPart(ex, ex.tpe, rhs, 0)
-      case ex: WSubField => getPart(ex, ex.tpe, rhs, 0)
-      case ex: WSubIndex => getPart(ex, ex.tpe, rhs, 0)
-      case t => error("Invalid LHS expression for fromBits!")
+      case ex @ (_: WRef | _: WSubField | _: WSubIndex) => getPart(ex, ex.tpe, rhs, 0)
+      case _ => error("Invalid LHS expression for fromBits!")
     }
     Block(fbits._2)
   }
-  def getPartGround(lhs: Expression, lhst: Type, rhs: Expression, offset: BigInt): (BigInt, Seq[Statement]) = {
+  private def getPartGround(lhs: Expression,
+                            lhst: Type,
+                            rhs: Expression,
+                            offset: BigInt): (BigInt, Seq[Statement]) = {
     val intWidth = bitWidth(lhst)
-    val sel = DoPrim(PrimOps.Bits, Seq(rhs), Seq(offset+intWidth-1, offset), UnknownType)
+    val sel = DoPrim(PrimOps.Bits, Seq(rhs), Seq(offset + intWidth - 1, offset), UnknownType)
     (offset + intWidth, Seq(Connect(NoInfo, lhs, sel)))
   }
-  def getPart(lhs: Expression, lhst: Type, rhs: Expression, offset: BigInt): (BigInt, Seq[Statement]) = {
+  private def getPart(lhs: Expression,
+                      lhst: Type,
+                      rhs: Expression,
+                      offset: BigInt): (BigInt, Seq[Statement]) =
     lhst match {
-      case t: VectorType => {
-        var currentOffset = offset
-        var stmts = Seq.empty[Statement]
-        for (i <- (0 until t.size)) {
-          val (tmpOffset, substmts) = getPart(WSubIndex(lhs, i, t.tpe, UNKNOWNGENDER), t.tpe, rhs, currentOffset)
-          stmts = stmts ++ substmts
-          currentOffset = tmpOffset
-        }
-        (currentOffset, stmts)
+      case t: VectorType => (0 until t.size foldRight (offset, Seq[Statement]())) {
+        case (i, (curOffset, stmts)) =>
+          val subidx = WSubIndex(lhs, i, t.tpe, UNKNOWNGENDER)
+          val (tmpOffset, substmts) = getPart(subidx, t.tpe, rhs, curOffset)
+          (tmpOffset, stmts ++ substmts)
       }
-      case t: BundleType => {
-        var currentOffset = offset
-        var stmts = Seq.empty[Statement]
-        for (f <- t.fields.reverse) {
-          val (tmpOffset, substmts) = getPart(WSubField(lhs, f.name, f.tpe, UNKNOWNGENDER), f.tpe, rhs, currentOffset)
-          stmts = stmts ++ substmts
-          currentOffset = tmpOffset
-        }
-        (currentOffset, stmts)
+      case t: BundleType => (t.fields foldRight (offset, Seq[Statement]())) {
+        case (f, (curOffset, stmts)) =>
+          val subfield = WSubField(lhs, f.name, f.tpe, UNKNOWNGENDER)
+          val (tmpOffset, substmts) = getPart(subfield, f.tpe, rhs, curOffset)
+          (tmpOffset, stmts ++ substmts)
       }
       case t: GroundType => getPartGround(lhs, t, rhs, offset)
       case t => error("Unknown type encountered in fromBits!")
     }
+}
+
+object createMask {
+  def apply(dt: Type): Type = dt match {
+    case t: VectorType => VectorType(apply(t.tpe), t.size)
+    case t: BundleType => BundleType(t.fields map (f => f copy (tpe=apply(f.tpe))))
+    case t: UIntType => BoolType
+    case t: SIntType => BoolType
   }
 }
 
@@ -138,78 +154,88 @@ object MemPortUtils {
   def flattenType(t: Type) = UIntType(IntWidth(bitWidth(t)))
 
   def defaultPortSeq(mem: DefMemory) = Seq(
-    Field("addr", Default, UIntType(IntWidth(ceil_log2(mem.depth)))),
-    Field("en", Default, UIntType(IntWidth(1))),
+    Field("addr", Default, UIntType(IntWidth(ceil_log2(mem.depth) max 1))),
+    Field("en", Default, BoolType),
     Field("clk", Default, ClockType)
   )
 
-  def getFillWMask(mem: DefMemory) = {
-    val maskGran = getInfo(mem.info, "maskGran")
-    if (maskGran == None) false
-    else maskGran.get == 1
-  }
+  def getFillWMask(mem: DefMemory) =
+    getInfo(mem.info, "maskGran") match {
+      case None => false
+      case Some(maskGran) => maskGran == 1
+    }
 
-  def rPortToBundle(mem: DefMemory) = BundleType(defaultPortSeq(mem) :+ Field("data", Flip, mem.dataType))
-  def rPortToFlattenBundle(mem: DefMemory) = BundleType(defaultPortSeq(mem) :+ Field("data", Flip, flattenType(mem.dataType)))
+  def rPortToBundle(mem: DefMemory) = BundleType(
+    defaultPortSeq(mem) :+ Field("data", Flip, mem.dataType))
+  def rPortToFlattenBundle(mem: DefMemory) = BundleType(
+    defaultPortSeq(mem) :+ Field("data", Flip, flattenType(mem.dataType)))
 
-  def wPortToBundle(mem: DefMemory) = {
-    val defaultSeq = defaultPortSeq(mem) :+ Field("data", Default, mem.dataType)
-    BundleType(
-      if (containsInfo(mem.info, "maskGran")) defaultSeq :+ Field("mask", Default, create_mask(mem.dataType))
-      else defaultSeq
-    )
-  }
-
-  def wPortToFlattenBundle(mem: DefMemory) = {
-    val defaultSeq = defaultPortSeq(mem) :+ Field("data", Default, flattenType(mem.dataType))
-    BundleType(
-      if (containsInfo(mem.info, "maskGran")) {
-        defaultSeq :+ {
-          if (getFillWMask(mem)) Field("mask", Default, flattenType(mem.dataType))
-          else Field("mask", Default, flattenType(create_mask(mem.dataType)))
-        }
-      }
-      else defaultSeq
-    )  
-  }
-  // TODO: Don't use create_mask???
+  def wPortToBundle(mem: DefMemory) = BundleType(
+    (defaultPortSeq(mem) :+ Field("data", Default, mem.dataType)) ++
+    (if (!containsInfo(mem.info, "maskGran")) Nil
+     else Seq(Field("mask", Default, createMask(mem.dataType))))
+  )
+  def wPortToFlattenBundle(mem: DefMemory) = BundleType(
+    (defaultPortSeq(mem) :+ Field("data", Default, flattenType(mem.dataType))) ++
+    (if (!containsInfo(mem.info, "maskGran")) Nil
+     else if (getFillWMask(mem)) Seq(Field("mask", Default, flattenType(mem.dataType)))
+     else Seq(Field("mask", Default, flattenType(createMask(mem.dataType)))))
+  )
+  // TODO: Don't use createMask???
 
-  def rwPortToBundle(mem: DefMemory) = {
-    val defaultSeq = defaultPortSeq(mem) ++ Seq(
-      Field("wmode", Default, UIntType(IntWidth(1))),
+  def rwPortToBundle(mem: DefMemory) = BundleType(
+    defaultPortSeq(mem) ++ Seq(
+      Field("wmode", Default, BoolType),
       Field("wdata", Default, mem.dataType),
       Field("rdata", Flip, mem.dataType)
+    ) ++ (if (!containsInfo(mem.info, "maskGran")) Nil
+     else Seq(Field("wmask", Default, createMask(mem.dataType)))
     )
-    BundleType(
-      if (containsInfo(mem.info, "maskGran")) defaultSeq :+ Field("wmask", Default, create_mask(mem.dataType))
-      else defaultSeq
-    )
-  }
+  )
 
-  def rwPortToFlattenBundle(mem: DefMemory) = {
-    val defaultSeq = defaultPortSeq(mem) ++ Seq(
+  def rwPortToFlattenBundle(mem: DefMemory) = BundleType(
+    defaultPortSeq(mem) ++ Seq(
       Field("wmode", Default, UIntType(IntWidth(1))),
       Field("wdata", Default, flattenType(mem.dataType)),
       Field("rdata", Flip, flattenType(mem.dataType))
-    )
-    BundleType(
-      if (containsInfo(mem.info, "maskGran")) {
-        defaultSeq :+ {
-          if (getFillWMask(mem)) Field("wmask", Default, flattenType(mem.dataType))
-          else Field("wmask", Default, flattenType(create_mask(mem.dataType)))
-        }
-      }
-      else defaultSeq
+    ) ++ (if (!containsInfo(mem.info, "maskGran")) Nil
+     else if (getFillWMask(mem)) Seq(Field("wmask", Default, flattenType(mem.dataType)))
+     else Seq(Field("wmask", Default, flattenType(createMask(mem.dataType))))
     )  
-  }
+  )
 
   def memToBundle(s: DefMemory) = BundleType(
-    s.readers.map(p => Field(p, Default, rPortToBundle(s))) ++
-      s.writers.map(p => Field(p, Default, wPortToBundle(s))) ++
-      s.readwriters.map(p => Field(p, Default, rwPortToBundle(s))))
+    s.readers.map(Field(_, Flip, rPortToBundle(s))) ++
+    s.writers.map(Field(_, Flip, wPortToBundle(s))) ++
+    s.readwriters.map(Field(_, Flip, rwPortToBundle(s))))
   
   def memToFlattenBundle(s: DefMemory) = BundleType(
-    s.readers.map(p => Field(p, Default, rPortToFlattenBundle(s))) ++
-      s.writers.map(p => Field(p, Default, wPortToFlattenBundle(s))) ++
-      s.readwriters.map(p => Field(p, Default, rwPortToFlattenBundle(s))))
+    s.readers.map(Field(_, Flip, rPortToFlattenBundle(s))) ++
+    s.writers.map(Field(_, Flip, wPortToFlattenBundle(s))) ++
+    s.readwriters.map(Field(_, Flip, rwPortToFlattenBundle(s))))
+
+  // Todo: merge it with memToBundle
+  def memType(mem: DefMemory) = {
+    val rType = rPortToBundle(mem)
+    val wType = BundleType(defaultPortSeq(mem) ++ Seq(
+      Field("data", Default, mem.dataType),
+      Field("mask", Default, createMask(mem.dataType))))
+    val rwType = BundleType(defaultPortSeq(mem) ++ Seq(
+      Field("rdata", Flip, mem.dataType),
+      Field("wmode", Default, UIntType(IntWidth(1))),
+      Field("wdata", Default, mem.dataType),
+      Field("wmask", Default, createMask(mem.dataType))))
+    BundleType(
+      (mem.readers map (Field(_, Flip, rType))) ++
+      (mem.writers map (Field(_, Flip, wType))) ++
+      (mem.readwriters map (Field(_, Flip, rwType))))
+  }
+
+  def kind(s: DefMemory) = MemKind(s.readers ++ s.writers ++ s.readwriters)
+  def memPortField(s: DefMemory, p: String, f: String) = {
+    val mem = WRef(s.name, memType(s), kind(s), UNKNOWNGENDER)
+    val t1 = field_type(mem.tpe, p)
+    val t2 = field_type(t1, f)
+    WSubField(WSubField(mem, p, t1, UNKNOWNGENDER), f, t2, UNKNOWNGENDER)
+  }
 }
diff --git a/src/main/scala/firrtl/passes/PadWidths.scala b/src/main/scala/firrtl/passes/PadWidths.scala
index 1a134d11..bef9ac33 100644
--- a/src/main/scala/firrtl/passes/PadWidths.scala
+++ b/src/main/scala/firrtl/passes/PadWidths.scala
@@ -4,12 +4,11 @@ package passes
 import firrtl.ir._
 import firrtl.PrimOps._
 import firrtl.Mappers._
-import firrtl.Utils.long_BANG
 
 // Makes all implicit width extensions and truncations explicit
 object PadWidths extends Pass {
    def name = "Pad Widths"
-   private def width(t: Type): Int = long_BANG(t).toInt
+   private def width(t: Type): Int = bitWidth(t).toInt
    private def width(e: Expression): Int = width(e.tpe)
    // Returns an expression with the correct integer width
    private def fixup(i: Int)(e: Expression) = {
diff --git a/src/main/scala/firrtl/passes/RemoveCHIRRTL.scala b/src/main/scala/firrtl/passes/RemoveCHIRRTL.scala
index 2bae92a7..ca860ab6 100644
--- a/src/main/scala/firrtl/passes/RemoveCHIRRTL.scala
+++ b/src/main/scala/firrtl/passes/RemoveCHIRRTL.scala
@@ -101,7 +101,7 @@ object RemoveCHIRRTL extends Pass {
         Connect(s.info, SubField(SubField(Reference(s.name, ut), r.name, ut), wmode, taddr), zero)
       )
       def set_write (vec: Seq[MPort], data: String, mask: String) = vec flatMap {r =>
-        val tmask = create_mask(s.tpe)
+        val tmask = createMask(s.tpe)
         IsInvalid(s.info, SubField(SubField(Reference(s.name, ut), r.name, ut), data, tdata)) +:
              (create_exps(SubField(SubField(Reference(s.name, ut), r.name, ut), mask, tmask))
                map (Connect(s.info, _, zero))
@@ -160,7 +160,7 @@ object RemoveCHIRRTL extends Pass {
     e map get_mask(refs) match {
       case e: Reference => refs get e.name match {
         case None => e
-        case Some(p) => SubField(p.exp, p.mask, create_mask(e.tpe))
+        case Some(p) => SubField(p.exp, p.mask, createMask(e.tpe))
       }
       case e => e
     }
diff --git a/src/main/scala/firrtl/passes/ReplaceMemMacros.scala b/src/main/scala/firrtl/passes/ReplaceMemMacros.scala
index 54c522d7..7bb9c6c4 100644
--- a/src/main/scala/firrtl/passes/ReplaceMemMacros.scala
+++ b/src/main/scala/firrtl/passes/ReplaceMemMacros.scala
@@ -117,7 +117,7 @@ class ReplaceMemMacros(writer: ConfWriter) extends Pass {
       )
     )
     if (containsInfo(wrapperMem.info, "maskGran")) {
-      val wrapperMask = create_mask(wrapperMem.dataType)
+      val wrapperMask = createMask(wrapperMem.dataType)
       val fillWMask = getFillWMask(wrapperMem)
       val bbMask = if (fillWMask) flattenType(wrapperMem.dataType) else flattenType(wrapperMask)
       val rhs = {
@@ -150,7 +150,7 @@ class ReplaceMemMacros(writer: ConfWriter) extends Pass {
       )
     )
     if (containsInfo(wrapperMem.info, "maskGran")) {
-      val wrapperMask = create_mask(wrapperMem.dataType)
+      val wrapperMask = createMask(wrapperMem.dataType)
       val fillWMask = getFillWMask(wrapperMem)
       val bbMask = if (fillWMask) flattenType(wrapperMem.dataType) else flattenType(wrapperMask)
       val rhs = {
diff --git a/src/main/scala/firrtl/passes/Uniquify.scala b/src/main/scala/firrtl/passes/Uniquify.scala
index d034719a..758791b2 100644
--- a/src/main/scala/firrtl/passes/Uniquify.scala
+++ b/src/main/scala/firrtl/passes/Uniquify.scala
@@ -34,6 +34,7 @@ import firrtl._
 import firrtl.ir._
 import firrtl.Utils._
 import firrtl.Mappers._
+import MemPortUtils.memType
 
 /** Resolve name collisions that would occur in [[LowerTypes]]
   *
@@ -228,7 +229,7 @@ object Uniquify extends Pass {
       case s: WDefInstance => Seq(Field(s.name, Default, s.tpe))
       case s: DefMemory => s.dataType match {
         case (_: UIntType | _: SIntType) =>
-          Seq(Field(s.name, Default, get_type(s)))
+          Seq(Field(s.name, Default, memType(s)))
         case tpe: BundleType =>
           val newFields = tpe.fields map ( f =>
             DefMemory(s.info, f.name, f.tpe, s.depth, s.writeLatency,
@@ -241,7 +242,7 @@ object Uniquify extends Pass {
           ) flatMap (recStmtToType)
           Seq(Field(s.name, Default, BundleType(newFields)))
       }
-      case s: DefNode => Seq(Field(s.name, Default, get_type(s)))
+      case s: DefNode => Seq(Field(s.name, Default, s.value.tpe))
       case s: Conditionally => recStmtToType(s.conseq) ++ recStmtToType(s.alt)
       case s: Block => (s.stmts map (recStmtToType)).flatten
       case s => Seq()
@@ -305,7 +306,7 @@ object Uniquify extends Pass {
               val dataType = uniquifyNamesType(s.dataType, node.elts)
               val mem = s.copy(name = node.name, dataType = dataType)
               // Create new mapping to handle references to memory data fields
-              val uniqueMemMap = createNameMapping(get_type(s), get_type(mem))
+              val uniqueMemMap = createNameMapping(memType(s), memType(mem))
               nameMap(s.name) = NameMapNode(node.name, node.elts ++ uniqueMemMap)
               mem
             } else {