CPUから実装してどこまで行けるか？

module _Nand(
	input wire a,
	input wire b,
	output wire out);

	assign out = ~(a & b);
endmodule

module _Not(
	input wire in,
	output wire out);

	_Nand nand1(
		.a(1'b1),
		.b(in),
		.out(out));
endmodule

module _And(
	input wire a,
	input wire b,
	output wire out);

	wire nandOut;
	_Nand nand1(.a(a), .b(b), .out(nandOut));
	_Not not1(.in(nandOut), .out(out));
endmodule

module _Or(
	input wire a,
	input wire b,
	output wire out);

	wire not1Out, not2Out, andOut;

	_Not not1(.in(a), .out(not1Out));
	_Not not2(.in(b), .out(not2Out));
	_And and1(.a(not1Out), .b(not2Out), .out(andOut));
	_Not not3(.in(andOut), .out(out));
endmodule

module HalfAdder(
	input wire a,		// 値１
	input wire b,		// 値２
	output wire sum,	// 結果
	output wire carry);	// キャリーフラグ
 
	_Xor xor1(.a(a), .b(b), .out(sum));
	_And and1(.a(a), .b(b), .out(carry));
endmodule

module FullAdder(
	input wire a,		// 値１
	input wire b,		// 値２
	input wire c,		// 下位の桁上がり
	output wire sum,	// 加算結果
	output wire carry);	// 桁上がり
 
	wire ha1Sum;
	wire ha1Carry;
	wire ha2Carry;

	HalfAdder ha1(a, b, ha1Sum, ha1Carry);
	HalfAdder ha2(ha1Sum, c, sum, ha2Carry);

	_Or or1(.a(ha1Carry), .b(ha2Carry), .out(carry));
endmodule

module Add16(
	input wire[15:0] a,		// 値１
	input wire[15:0] b,		// 値２
	output wire[15:0] out);	// 結果
 
	wire[15:0] carry;

	FullAdder fa1(a[0], b[0], 1'b0, out[0], carry[0]);
	FullAdder fa2(a[1], b[1], carry[0], out[1], carry[1]);
	FullAdder fa3(a[2], b[2], carry[1], out[2], carry[2]);
	FullAdder fa4(a[3], b[3], carry[2], out[3], carry[3]);
	FullAdder fa5(a[4], b[4], carry[3], out[4], carry[4]);
	FullAdder fa6(a[5], b[5], carry[4], out[5], carry[5]);
	FullAdder fa7(a[6], b[6], carry[5], out[6], carry[6]);
	FullAdder fa8(a[7], b[7], carry[6], out[7], carry[7]);
	FullAdder fa9(a[8], b[8], carry[7], out[8], carry[8]);
	FullAdder fa10(a[9], b[9], carry[8], out[9], carry[9]);
	FullAdder fa11(a[10], b[10], carry[9], out[10], carry[10]);
	FullAdder fa12(a[11], b[11], carry[10], out[11], carry[11]);
	FullAdder fa13(a[12], b[12], carry[11], out[12], carry[12]);
	FullAdder fa14(a[13], b[13], carry[12], out[13], carry[13]);
	FullAdder fa15(a[14], b[14], carry[13], out[14], carry[14]);
	FullAdder fa16(a[15], b[15], carry[14], out[15], carry[15]);
endmodule

module Inc16(
	input wire[15:0] a,		// 値
	output wire[15:0] out);	// 結果

	Add16 add(a, 16'd1, out);
endmodule

module ALU(
	input wire[15:0] x,		// 値x
	input wire[15:0] y,		// 値y
	input wire zx,			// 入力xをゼロにする
	input wire nx,			// 入力xを反転する
	input wire zy,			// 入力yをゼロにする
	input wire ny,			// 入力yを反転する
	input wire f,			// 関数コード（1：加算、0：And演算）
	input wire no,			// 出力outを反転する
	output wire[15:0] out,	// 結果
	output wire zr,			// out=0 の場合にtrue
	output wire ng);		// out<0 の場合にtrue

	// 入力xをゼロにする
	wire [15:0] zxX;
	assign zxX = zx ? 16'b0 : x;

	// 入力xを反転する
	wire[15:0] notZxX;
	Not16 not16x(.in(zxX), .out(notZxX));
	wire[15:0] nxX;
	assign nxX = nx ? notZxX : zxX;
	
	// 入力yをゼロにする
	wire [15:0] zyY;
	assign zyY = zy ? 1'b0 : y;

	// 入力yを反転する
	wire[15:0] notZyY;
	Not16 not16y(.in(zyY), .out(notZyY));
	wire[15:0] nyY;
	assign nyY = ny ? notZyY : zyY;

	// 関数コード（1：加算、0：And演算）
	// 1：加算　用
	wire [15:0] workAdd16;
	Add16 add16(
		.a(nxX),
		.b(nyY),
		.out(workAdd16));

	// 0：And演算 用
	wire[15:0] andXY;
	And16 and16(.a(nxX), .b(nyY), .out(andXY));

	// 関数実行
	wire[15:0] fOut;
	assign fOut = f ? workAdd16 : andXY;

	// 出力outを反転する
	wire[15:0] fNotOut;
	Not16 not16forOut(.in(fOut), .out(fNotOut));
	assign out = no ? fNotOut : fOut;

	// out=0 の場合にtrue
	assign zr = (out == 16'd0) ? 1'b1 : 1'b0;

	// out<0 の場合にtrue
	assign ng = (out[15] == 1'b1) ? 1'b1 : 1'b0;
endmodule

module Bit(
	input wire clk,			// clk
	input wire in,			// in値
	input wire load,		// load
	output wire out);		// out

	reg val;				// 1ビットの値を保持

	// クロックの立ち上がりでloadが1の時にin値を保持
	always @(posedge clk) begin
		if(load == 1'b1) begin
			val <= in;
		end
	end

	// 保持しているvalを出力
	assign out = val;
endmodule

module Register(
	input wire clk,			// clk
	input wire[15:0] in,	// in値
	input wire load,		// load
	output wire[15:0] out);	// out

	Bit bit0(.clk(clk), .in(in[0]), .load(load), .out(out[0]));
	Bit bit1(.clk(clk), .in(in[1]), .load(load), .out(out[1]));
	Bit bit2(.clk(clk), .in(in[2]), .load(load), .out(out[2]));
	Bit bit3(.clk(clk), .in(in[3]), .load(load), .out(out[3]));
	Bit bit4(.clk(clk), .in(in[4]), .load(load), .out(out[4]));
	Bit bit5(.clk(clk), .in(in[5]), .load(load), .out(out[5]));
	Bit bit6(.clk(clk), .in(in[6]), .load(load), .out(out[6]));
	Bit bit7(.clk(clk), .in(in[7]), .load(load), .out(out[7]));
	Bit bit8(.clk(clk), .in(in[8]), .load(load), .out(out[8]));
	Bit bit9(.clk(clk), .in(in[9]), .load(load), .out(out[9]));
	Bit bit10(.clk(clk), .in(in[10]), .load(load), .out(out[10]));
	Bit bit11(.clk(clk), .in(in[11]), .load(load), .out(out[11]));
	Bit bit12(.clk(clk), .in(in[12]), .load(load), .out(out[12]));
	Bit bit13(.clk(clk), .in(in[13]), .load(load), .out(out[13]));
	Bit bit14(.clk(clk), .in(in[14]), .load(load), .out(out[14]));
	Bit bit15(.clk(clk), .in(in[15]), .load(load), .out(out[15]));
endmodule

module RAM4K(
	input wire clk,				// clk
	input wire[15:0] in,		// in値
	input wire[11:0] address,	// アドレス
	input wire load,			// write enable
	output wire[15:0] out);		// out

	reg[15:0] RAM[4096-1:0];

	initial begin
		integer ii;
		for(ii = 0; ii < 4096; ii = ii + 1) begin
			RAM[ii] <= 16'd0;
		end
	end

	always @(posedge clk) begin
		if(load == 1'b1) begin
			RAM[address] <= in;
		end
	end

	assign out = RAM[address];
endmodule

module RAM16K(
	input wire clk,				// clk
	input wire[15:0] in,		// in値
	input wire[14:0] address,	// アドレス
	input wire load,			// write enable
	output wire[15:0] out);		// out

	// アドレスをセレクタとして、load値をload0～3に振り分ける
	wire load0,load1,load2,load3;
	DMux4Way dmux4(
		.in(load),
		.sel(address[13:12]),
		.a(load0), .b(load1), .c(load2), .d(load3));

	// load0～3でRegister0～3をロード、またはリードする
	wire[15:0] out0,out1,out2,out3;
	RAM4K ram0(.clk(clk), .in(in), .load(load0), .address(address[11:0]), .out(out0));
	RAM4K ram1(.clk(clk), .in(in), .load(load1), .address(address[11:0]), .out(out1));
	RAM4K ram2(.clk(clk), .in(in), .load(load2), .address(address[11:0]), .out(out2));
	RAM4K ram3(.clk(clk), .in(in), .load(load3), .address(address[11:0]), .out(out3));

	// リードしたout0～3をアドレスをセレクタにしてoutに出力する
	Mux4Way16 mux8(
		.a(out0), .b(out1), .c(out2), .d(out3),
		.sel(address[13:12]),
		.out(out));
endmodule

module PC(
	input wire clk,				// clk
	input wire[15:0] in,		// in値
	input wire inc,				// incliment flg
	input wire load,			// write enable flg
	input wire reset,			// reset flg
	output wire[15:0] out);		// out

	// インクリメント	
	wire[15:0] regOut, incOut;
	Inc16 inc16(.a(regOut), .out(incOut));

	// inc値により、Register値かインクリメント値かをregOrIncOutに配線
	wire[15:0] regOrIncOut;
	Mux16 mux1(.a(regOut), .b(incOut), .sel(inc), .out(regOrIncOut));

	// load値により、Reg/Inc値かin値をloadOutに配線
	wire[15:0] loadOut;
	Mux16 mux2(.a(regOrIncOut), .b(in), .sel(load), .out(loadOut));

	// reset値により、loadOutか0かをtoRegに配線
	// toRegはInc16にフィードバックされる
	wire[15:0] toReg;
	Mux16 mux3(.a(loadOut), .b(16'b0), .sel(reset), .out(toReg));

	Register reg1(.clk(clk), .in(toReg), .load(1'b1), .out(out));
	assign regOut = out;

endmodule

0: 0_000000000000010		// A命令：3 をAレジスタに格納する
1: 111_0_110000_010_000		// C命令：Aレジスタの値をDレジスタに格納する
2: 0_000000000000011		// A命令：4 をAレジスタに格納する
3: 111_0_000010_010_000		// C命令：AレジスタとDレジスタの値で加算を行い、結果をDレジスタに格納する
4: 0_000000000000000		// A命令：0 をAレジスタに格納する
5: 111_0_001100_001_000		// C命令：Dレジスタの値をCPU出力のoutMに出力する
6: 0_000000000000110		// A命令：6 をAレジスタに格納する
7: 111_0_000000_000_111		// C命令：強制的にAレジスタの値をプログラムカウンタに格納する
							// つまり、6～7番地で永久ループする