$print internal cell, for formatting tasks

Makefile

@@ -652,12 +652,7 @@ $(eval $(call add_include_file,backends/cxxrtl/cxxrtl_vcd_capi.h))
 
 OBJS += kernel/driver.o kernel/register.o kernel/rtlil.o kernel/log.o kernel/calc.o kernel/yosys.o
 OBJS += kernel/binding.o
-ifeq ($(ENABLE_ABC),1)
-ifneq ($(ABCEXTERNAL),)
-kernel/yosys.o: CXXFLAGS += -DABCEXTERNAL='"$(ABCEXTERNAL)"'
-endif
-endif
-OBJS += kernel/cellaigs.o kernel/celledges.o kernel/satgen.o kernel/qcsat.o kernel/mem.o kernel/ffmerge.o kernel/ff.o kernel/yw.o kernel/json.o
+OBJS += kernel/cellaigs.o kernel/celledges.o kernel/satgen.o kernel/qcsat.o kernel/mem.o kernel/ffmerge.o kernel/ff.o kernel/yw.o kernel/json.o kernel/fmt.o
 ifeq ($(ENABLE_ZLIB),1)
 OBJS += kernel/fstdata.o
 endif
@@ -669,6 +664,11 @@ endif
 
 kernel/log.o: CXXFLAGS += -DYOSYS_SRC='"$(YOSYS_SRC)"'
 kernel/yosys.o: CXXFLAGS += -DYOSYS_DATDIR='"$(DATDIR)"' -DYOSYS_PROGRAM_PREFIX='"$(PROGRAM_PREFIX)"'
+ifeq ($(ENABLE_ABC),1)
+ifneq ($(ABCEXTERNAL),)
+kernel/yosys.o: CXXFLAGS += -DABCEXTERNAL='"$(ABCEXTERNAL)"'
+endif
+endif
 
 OBJS += libs/bigint/BigIntegerAlgorithms.o libs/bigint/BigInteger.o libs/bigint/BigIntegerUtils.o
 OBJS += libs/bigint/BigUnsigned.o libs/bigint/BigUnsignedInABase.o
@@ -882,6 +882,7 @@ endif
 	+cd tests/memfile && bash run-test.sh
 	+cd tests/verilog && bash run-test.sh
 	+cd tests/xprop && bash run-test.sh $(SEEDOPT)
+	+cd tests/fmt && bash run-test.sh
 	@echo ""
 	@echo "  Passed \"make test\"."
 	@echo ""

backends/cxxrtl/cxxrtl.h

@@ -518,6 +518,14 @@ struct value : public expr_base<value<Bits>> {
 		return count;
 	}
 
+	size_t chunks_used() const {
+		for (size_t n = chunks; n > 0; n--) {
+			if (data[n - 1] != 0)
+				return n;
+		}
+		return 0;
+	}
+
 	template<bool Invert, bool CarryIn>
 	std::pair<value<Bits>, bool /*CarryOut*/> alu(const value<Bits> &other) const {
 		value<Bits> result;
@@ -575,6 +583,84 @@ struct value : public expr_base<value<Bits>> {
 		result.data[result.chunks - 1] &= result.msb_mask;
 		return result;
 	}
+
+	// parallel to BigUnsigned::divideWithRemainder; quotient is stored in q,
+	// *this is left with the remainder.  See that function for commentary describing
+	// how/why this works.
+	void divideWithRemainder(const value<Bits> &b, value<Bits> &q) {
+		assert(this != &q);
+
+		if (this == &b || &q == &b) {
+			value<Bits> tmpB(b);
+			divideWithRemainder(tmpB, q);
+			return;
+		}
+
+		q = value<Bits> {0u};
+
+		size_t blen = b.chunks_used();
+		if (blen == 0) {
+			return;
+		}
+
+		size_t len = chunks_used();
+		if (len < blen) {
+			return;
+		}
+
+		size_t i, j, k;
+		size_t i2;
+		chunk_t temp;
+		bool borrowIn, borrowOut;
+
+		size_t origLen = len;
+		len++;
+		chunk::type blk[len];
+		std::copy(data, data + origLen, blk);
+		blk[origLen] = 0;
+		chunk::type subtractBuf[len];
+		std::fill(subtractBuf, subtractBuf + len, 0);
+
+		size_t qlen = origLen - blen + 1;
+
+		i = qlen;
+		while (i > 0) {
+			i--;
+			i2 = chunk::bits;
+			while (i2 > 0) {
+				i2--;
+				for (j = 0, k = i, borrowIn = false; j <= blen; j++, k++) {
+					temp = blk[k] - getShiftedBlock(b, j, i2);
+					borrowOut = (temp > blk[k]);
+					if (borrowIn) {
+						borrowOut |= (temp == 0);
+						temp--;
+					}
+					subtractBuf[k] = temp;
+					borrowIn = borrowOut;
+				}
+				for (; k < origLen && borrowIn; k++) {
+					borrowIn = (blk[k] == 0);
+					subtractBuf[k] = blk[k] - 1;
+				}
+				if (!borrowIn) {
+					q.data[i] |= (chunk::type(1) << i2);
+					while (k > i) {
+						k--;
+						blk[k] = subtractBuf[k];
+					}
+				}
+			}
+		}
+
+		std::copy(blk, blk + origLen, data);
+	}
+
+	static chunk::type getShiftedBlock(const value<Bits> &num, size_t x, size_t y) {
+		chunk::type part1 = (x == 0 || y == 0) ? 0 : (num.data[x - 1] >> (chunk::bits - y));
+		chunk::type part2 = (x == num.chunks) ? 0 : (num.data[x] << y);
+		return part1 | part2;
+	}
 };
 
 // Expression template for a slice, usable as lvalue or rvalue, and composable with other expression templates here.
@@ -707,6 +793,99 @@ std::ostream &operator<<(std::ostream &os, const value<Bits> &val) {
 	return os;
 }
 
+template<size_t Bits>
+struct value_formatted {
+	const value<Bits> &val;
+	bool character;
+	bool justify_left;
+	char padding;
+	int width;
+	int base;
+	bool signed_;
+	bool plus;
+
+	value_formatted(const value<Bits> &val, bool character, bool justify_left, char padding, int width, int base, bool signed_, bool plus) :
+		val(val), character(character), justify_left(justify_left), padding(padding), width(width), base(base), signed_(signed_), plus(plus) {}
+	value_formatted(const value_formatted<Bits> &) = delete;
+	value_formatted<Bits> &operator=(const value_formatted<Bits> &rhs) = delete;
+};
+
+template<size_t Bits>
+std::ostream &operator<<(std::ostream &os, const value_formatted<Bits> &vf)
+{
+	value<Bits> val = vf.val;
+
+	std::string buf;
+
+	// We might want to replace some of these bit() calls with direct
+	// chunk access if it turns out to be slow enough to matter.
+
+	if (!vf.character) {
+		size_t width = Bits;
+		if (vf.base != 10) {
+			width = 0;
+			for (size_t index = 0; index < Bits; index++)
+				if (val.bit(index))
+					width = index + 1;
+		}
+
+		if (vf.base == 2) {
+			for (size_t i = width; i > 0; i--)
+				buf += (val.bit(i - 1) ? '1' : '0');
+		} else if (vf.base == 8 || vf.base == 16) {
+			size_t step = (vf.base == 16) ? 4 : 3;
+			for (size_t index = 0; index < width; index += step) {
+				uint8_t value = val.bit(index) | (val.bit(index + 1) << 1) | (val.bit(index + 2) << 2);
+				if (step == 4)
+					value |= val.bit(index + 3) << 3;
+				buf += "0123456789abcdef"[value];
+			}
+			std::reverse(buf.begin(), buf.end());
+		} else if (vf.base == 10) {
+			bool negative = vf.signed_ && val.is_neg();
+			if (negative)
+				val = val.neg();
+			if (val.is_zero())
+				buf += '0';
+			while (!val.is_zero()) {
+				value<Bits> quotient;
+				val.divideWithRemainder(value<Bits>{10u}, quotient);
+				buf += '0' + val.template trunc<(Bits > 4 ? 4 : Bits)>().val().template get<uint8_t>();
+				val = quotient;
+			}
+			if (negative || vf.plus)
+				buf += negative ? '-' : '+';
+			std::reverse(buf.begin(), buf.end());
+		} else assert(false);
+	} else {
+		buf.reserve(Bits/8);
+		for (int i = 0; i < Bits; i += 8) {
+			char ch = 0;
+			for (int j = 0; j < 8 && i + j < int(Bits); j++)
+				if (val.bit(i + j))
+					ch |= 1 << j;
+			if (ch != 0)
+				buf.append({ch});
+		}
+		std::reverse(buf.begin(), buf.end());
+	}
+
+	assert(vf.width == 0 || vf.padding != '\0');
+	if (!vf.justify_left && buf.size() < vf.width) {
+		size_t pad_width = vf.width - buf.size();
+		if (vf.padding == '0' && (buf.front() == '+' || buf.front() == '-')) {
+			os << buf.front();
+			buf.erase(0, 1);
+		}
+		os << std::string(pad_width, vf.padding);
+	}
+	os << buf;
+	if (vf.justify_left && buf.size() < vf.width)
+		os << std::string(vf.width - buf.size(), vf.padding);
+
+	return os;
+}
+
 template<size_t Bits>
 struct wire {
 	static constexpr size_t bits = Bits;
@@ -1091,7 +1270,10 @@ struct module {
 	virtual bool eval() = 0;
 	virtual bool commit() = 0;
 
+	unsigned int steps = 0;
+
 	size_t step() {
+		++steps;
 		size_t deltas = 0;
 		bool converged = false;
 		do {