手を上げるチップくんゆるふわ半導体
考え中のチップくん

自作CPU入門|Pythonでレジスタ・ALU・命令サイクルを動かす

2026-11-18 ・ 実践

#CPU#自作CPU#命令サイクル#ALU#Python#実践

自作CPUとは、レジスタ・ALU(演算回路)・命令デコーダといった基本部品を自分の手で組み合わせて、小さな命令セットを実行できるようにした計算機のことです。この記事では、これまでPythonで作った全加算器・フリップフロップ・デコーダを1つのCPUシミュレータにまとめ、フェッチ→デコード→実行の命令サイクルで、足し算とループのプログラムを実際に動かします。

この記事で分かること

  • 自作CPUとは、レジスタ・ALU・デコーダなどの基本部品を組み合わせて命令を実行できるようにした計算機のこと
  • CPUの動作は「フェッチ(命令を読む)→デコード(解読する)→実行する」の繰り返し(命令サイクル)であること
  • 8ビットの命令(4bit opcode + 4bit operand)をデコーダで解読し、LOADI・ADD・JMPなど7種類の命令を実行する4bit CPUを作れること
  • 引き算専用の回路を作らず、2の補数を足すだけでカウントダウンのループが書けること

対象読者:論理回路・ALU・フリップフロップをPythonで試した後、CPU全体の動きまで組み立てたいエンジニアの方

執筆:ゆるふわ半導体編集部 最終更新日:2026年11月18日

CPUは何を繰り返しているのか

CPUは、命令を1つ読み、解読し、実行する——これをひたすら繰り返しているだけの機械です。これを**命令サイクル(フェッチ・デコード・実行サイクル)**と呼びます1。

命令サイクル

📥

フェッチ

次の命令をメモリから読む

→
🔍

デコード

命令の種類と対象を解読

→
⚙️

実行

ALUやメモリを動かす

どの命令を読むかは**プログラムカウンタ(PC)**という、次に読む番地を覚えているレジスタが決めます2。実行が終わるとPCは次に進み、ジャンプ命令が来ればPCに別の番地が書き込まれます。このPCは、フリップフロップで作ったカウンタそのものです。

部品はすでに揃っている

今回作るCPUの部品は、これまでの記事で1つずつ作ったものの再利用です。

部品役割作った記事
ALU(加算器)足し算を実行する4ビット加算器
レジスタ・PC値や番地を記憶するフリップフロップ
デコーダ命令の種類を解読するマルチプレクサとデコーダ
論理ゲートすべての土台NANDから全加算器

今回のCPUは1個のアキュムレータ(ACC、計算結果を置く専用レジスタ)とメモリ16番地だけの、ごく小さな構成にします。実際のCPUが持つ複数のレジスタやキャッシュは省略し、命令サイクルの骨格だけを見えるようにします。

準備

Python標準機能だけ。

命令セット(ISA)を決める

命令は8ビット(1バイト)で表します。上位4ビットがオペコード(命令の種類)、下位4ビットがオペランド(対象の番地や即値)です。

opcode命令意味
1LOADI nACCに即値nを入れる
2ADD addrACCにmem[addr]を足す
3STORE addrACCをmem[addr]に保存する
4JZ addrACCが0ならaddrへジャンプ
5JMP addr無条件にaddrへジャンプ
6OUTACCを出力する
7HALT停止する

例えば LOADI 3 は opcode=1, operand=3 なので、上位4ビットに1、下位4ビットに3を置いた 0x13 という1バイトになります。これがマシン語です。

命令を解読する:デコーダの出番

マルチプレクサとデコーダで作った decoder() 関数を、そのまま命令の解読に使います。opcodeを渡すと「その命令だけが1になったリスト」が返るので、どの命令かを特定できます。

Python
def decoder(address, n):
    # addressで指定した1本だけ1、他は0(マルチプレクサとデコーダの記事と同じ関数)
    return [1 if i == address else 0 for i in range(2 ** n)]
 
OPNAMES = {0: "NOP", 1: "LOADI", 2: "ADD", 3: "STORE", 4: "JZ", 5: "JMP", 6: "OUT", 7: "HALT"}
 
instr = 0x13          # LOADI 3
opcode, operand = instr >> 4, instr & 0xF
select = decoder(opcode, 3)    # [0,1,0,0,0,0,0,0] → 1番目が立つ
print(OPNAMES[select.index(1)], operand)   # LOADI 3
LOADI 3

実際のCPUでは、この「解読して対応する回路を選ぶ」部分を専用のデコーダ回路(ハードウェア)がナノ秒単位でやっています。ここではPythonの decoder() で同じ考え方を再現しました。

①足し算を実行するCPUを組む

ALUには4ビット加算器をそのまま使います。CPU本体は「メモリ・PC・ACC」を持ち、命令サイクルを1命令ずつ回す step() と、HALTまで回し続ける run() を持ちます。

Python
def full_adder(a, b, cin):
    s = a ^ b ^ cin
    cout = (a & b) | (b & cin) | (a & cin)
    return s, cout
 
def adder4(a, b):
    result, carry = [], 0
    for i in range(4):
        s, carry = full_adder(a[i], b[i], carry)
        result.append(s)
    return result, carry
 
def to_bits(n): return [(n >> i) & 1 for i in range(4)]
def to_int(bits): return sum(b << i for i, b in enumerate(bits))
 
def add4(x, y):
    # 4ビット加算器の記事と同じadder4を使い、桁あふれは無視(mod16)
    s, _ = adder4(to_bits(x), to_bits(y))
    return to_int(s)
 
class CPU:
    def __init__(self, program):
        self.mem = [0] * 16
        for i, byte in enumerate(program):
            self.mem[i] = byte
        self.pc = 0      # プログラムカウンタ
        self.acc = 0     # アキュムレータ
        self.halted = False
        self.out = []
 
    def step(self):
        instr = self.mem[self.pc]
        opcode, operand = instr >> 4, instr & 0xF
        op = OPNAMES[decoder(opcode, 3).index(1)]   # デコード
        self.pc = (self.pc + 1) & 0xF                # 次の番地へ(フェッチの準備)
 
        if op == "LOADI":   self.acc = operand
        elif op == "ADD":   self.acc = add4(self.acc, self.mem[operand])
        elif op == "STORE": self.mem[operand] = self.acc
        elif op == "JZ":
            if self.acc == 0: self.pc = operand
        elif op == "JMP":   self.pc = operand
        elif op == "OUT":   self.out.append(self.acc)
        elif op == "HALT":  self.halted = True
        return op
 
    def run(self, max_steps=100):
        steps = 0
        while not self.halted and steps < max_steps:
            self.step()
            steps += 1
        return steps

「3を記憶 → 一旦mem[8]に保存 → 4を記憶 → mem[8](3)を足す → 出力 → 停止」というプログラムを動かします。

Python
program = [
    0x13,  # 0: LOADI 3
    0x38,  # 1: STORE 8   mem[8] = 3
    0x14,  # 2: LOADI 4
    0x28,  # 3: ADD 8     acc = 4 + mem[8] = 7
    0x60,  # 4: OUT
    0x70,  # 5: HALT
]
 
cpu = CPU(program)
steps = cpu.run()
print("steps:", steps, "out:", cpu.out)
steps: 6 out: [7]

6ステップ(6つの命令サイクル)で 3 + 4 = 7 が出力され、HALTで止まりました。Pythonの関数呼び出しとして足し算していたものが、「メモリに置かれたマシン語を1つずつ解読して実行する」形に変わっただけだと分かります。

🌱

なぜアキュムレータ1個だけなのか

実際のCPU(x86やARM、RISC-Vなど)は、ACCに相当するレジスタを複数個(レジスタファイル)持っています。ここでは命令サイクルの骨格を見せるため、レジスタを1個に絞って単純化しました。RISC-Vの解説では、実際の命令セットがどれだけのレジスタを使うかに触れています。

②ループを回す:JMPとJZ、引き算は「足し算」で

このCPUには引き算の命令がありません。それでもループでカウントダウンできます。種は2の補数です。4ビットで15(1111)を足すと、桁あふれした分は切り捨てられるため、1を引いたのと同じ結果になります3。

Python
program2 = [
    0x1F,  # 0: LOADI 15   acc=15(4bitでの -1 に相当)
    0x39,  # 1: STORE 9    mem[9] = 15
    0x13,  # 2: LOADI 3    acc=3
    0x60,  # 3: OUT        ← ループの先頭
    0x29,  # 4: ADD 9      acc = acc + mem[9](mod16なので -1 と同じ)
    0x48,  # 5: JZ 8       acc==0 なら8番地(HALT)へ
    0x53,  # 6: JMP 3      そうでなければループ先頭へ
    0x00,  # 7: NOP(未使用)
    0x70,  # 8: HALT
]
 
cpu2 = CPU(program2)
steps2 = cpu2.run()
print("steps:", steps2, "out:", cpu2.out)
steps: 15 out: [3, 2, 1]

3 → 2 → 1 と出力してから、ACCが0になった瞬間に JZ が発動してHALTへ飛びました。「足すことしかできないALU」でも、2の補数と JZ・JMP を組み合わせれば、引き算もループも表現できます。

⚠️

オーバーフローのチェックはしていない

今回のCPUはACCが4bitの範囲(0〜15)を超えても何もチェックしません。実際のCPUはオーバーフローフラグやキャリーフラグを持ち、JZ 以外にも条件分岐の種類を増やして複雑な制御を可能にしています。

まとめ

  • CPUは「フェッチ→デコード→実行」の命令サイクルをひたすら繰り返す機械
  • 命令は「opcode(種類)+ operand(対象)」の組み合わせで、デコーダで解読する
  • 加算器・フリップフロップ・デコーダを組み合わせれば、小さなCPUをPythonで作れる
  • 引き算専用の回路がなくても、2の補数を足すだけでループや条件分岐が書ける

よくある質問

Q. このCPUは何ビットのCPUですか?

A. 命令は8ビット(opcode 4ビット+operand 4ビット)ですが、計算するデータ(ACC)は4ビットです。実際の4ビットCPUの例としては1970年代のIntel 4004がありますが、本記事のCPUは教育用の単純化したモデルで、特定の実機を再現したものではありません。

Q. もっとレジスタを増やすことはできますか?

A. できます。ACC(アキュムレータ)を複数のレジスタの配列にして、命令のoperandでどのレジスタを使うか指定するように拡張すれば、レジスタファイルを持つCPUに近づきます。その場合はoperandのビット数をレジスタ番号と番地で分割する必要があります。

Q. このシミュレータの次は何を学べばよいですか?

A. 実際のハードウェア記述言語で同じ発想の回路を書く場合は、[Verilog入門](/learn/verilog-getting-started)が次の一歩になります。命令セットの設計そのものをもっと知りたい場合は、実在する命令セットアーキテクチャである[RISC-V](/learn/risc-v-explained)の解説が参考になります。

📚 もう少し詳しく(背景)気になる人向け・タップで開く

今回のCPUは、プログラム(命令)とデータを同じメモリ空間に置くノイマン型アーキテクチャの縮小モデルです。プログラムカウンタが増え続けながら命令を順に読む構造は、現在の大半のCPUに共通する基本設計で、プログラムとデータが同じバスを共有することによる制約は「ノイマン型のボトルネック」と呼ばれます2。

実際のCPUとの違いは主に3つあります。1つめは並列性で、実機は命令サイクルの各段階(フェッチ・デコード・実行)を同時に重ねて進める「パイプライン」で高速化しています。2つめはレジスタの数で、本記事は1個のACCだけですが、実機は数十本のレジスタを持ちます。3つめは命令の複雑さで、実機の命令セットには乗算・除算・浮動小数点演算・メモリ保護など、はるかに多くの種類があります。それでも「フェッチ→デコード→実行」という骨格自体は変わりません。

次の一歩 🌸

ALUの作り方は4ビット加算器、記憶の持たせ方はフリップフロップ、命令の解読はマルチプレクサとデコーダ、CPU全体の考え方はCPUはどう計算するのかへどうぞ。

参考資料・出典

ゆるふわポータルでは、一次情報・公的資料にもとづき、専門用語をできるだけやさしく翻訳することを心がけています。内容に誤りや古い情報がある場合は、お問い合わせからご連絡ください。

執筆:ゆるふわ半導体編集部 最終更新日:2026年11月18日

Footnotes

  1. 命令サイクル(instruction cycle)は、フェッチ・デコード・実行の各段階からなる、CPUが命令を処理する基本的な繰り返し単位。 ↩

  2. プログラムカウンタ(PC)は次に実行する命令のメモリ番地を保持するレジスタ。通常は命令を読むたびに増加し、分岐命令で書き換えられる。プログラムとデータを同じメモリに置く構成はノイマン型アーキテクチャと呼ばれる。 ↩ ↩2

  3. 2の補数表現では、ある数を2の補数で表した値を足すことが、その数を引くことと同じ結果になる。これにより、加算器だけで減算も実行でき、符号によって回路を分ける必要がなくなる。 ↩

この記事をシェア:𝕏 で共有LINEで送る

🔥 この分野の最新トレンドをチェック →

あわせて読みたい