RISC-Vとは｜ARM・x86との違いを逆アセンブルとqemuで実測

CPU は、決められた命令しか実行できません。その「どんな命令があり、どうビットで表すか」の決まりが命令セット（ISA）です。RISC-V は、この決まりを誰でも読めて、誰でも使える形で公開しています。

flowchart TD
    SRC[C などのソースコード] --> CC[コンパイラ<br>-march=rv64gc]
    CC --> BIN[RISC-V の機械語]
    SPEC[仕様 RISC-V ISA<br>RISC-V International] -.決める.-> BIN
    BIN --> HW1[各社のCPU<br>コアIP・自社設計]
    BIN --> HW2[qemu などの<br>エミュレーター]

よく調べられることの答えを先にまとめます。

確認環境：Ubuntu 24.04.5 LTS（x86_64、Intel Xeon 2.10GHz・2コア）の上で、Ubuntu の公式リポジトリから apt-get download で取得した .deb（gcc-13-riscv64-linux-gnu 13.3.0・binutils-riscv64-linux-gnu 2.42・libc6-riscv64-cross 2.39・qemu-user 8.2.2、比較用に gcc-13-aarch64-linux-gnu 13.3.0）を dpkg-deb -x で作業用のフォルダーに展開して使いました（システムへのインストールと binfmt の登録はしていません）。x86-64 側はホストの GCC 13.3.0 です。自分で書いた C のプログラムを3つの CPU 向けにビルドし、objdump の逆アセンブル、size でのサイズ、qemu-riscv64・qemu-aarch64 での実行結果を並べています。コードの大きさの比較には、EEMBC の CoreMark（GitHub の eembc/coremark、コミット 1f483d5）をコンパイルしてサイズだけを測りました。仕様の内容は RISC-V International の ISA マニュアル（v20260120）と公式サイト、採用製品・動向は各社・各団体の公式発表で確かめた範囲だけを書いています。図は mermaid で描画を確かめました（確認日 2026年10月29日）。

RISC-Vとは（命令セット＝CPUとソフトの約束ごと）

この節では、RISC-V が「何」なのか、CPU や ARM・x86 とどういう関係にあるのかが分かります。

RISC-V は、CPU が理解する命令の種類と、その命令をビットでどう表すかを決めた仕様（命令セットアーキテクチャ、ISA）です。 読み方は「リスクファイブ」で、仕様書にも "pronounced risk-five" と書かれています。RISC-V という名前の CPU の製品が1つあるわけではなく、この仕様に従って各社や大学が CPU を設計します。

• ISA（命令セット）：「足し算は add、メモリから読むのは lw」のような命令の一覧と、そのビットの並び。ソフト（コンパイラ）とハード（CPU）の間の約束。
• CPU（実装）：ISA の約束どおりに命令を実行する回路。同じ ISA でも、速さ・消費電力・大きさは設計によって大きく違う。
• RISC：命令を単純にして、1つ1つを速く実行するという設計の考え方。RISC-V はカリフォルニア大学バークレー校で続いた RISC の研究の5代目にあたるので「V（5）」が付いています。

RISC-V International の公式サイトによると、RISC-V はバークレー校の研究者が 2010年5月に始めた命令セットです。2015年に RISC-V Foundation が36の創設メンバーで発足し、2020年3月にスイスで RISC-V International Association として法人化しました。今の仕様は、この非営利団体が管理しています。

手元で、同じ C のプログラムを RISC-V・ARM（AArch64）・x86-64 向けにビルドして動かすと、出力はまったく同じでした。ソースコードは同じでも、出来上がる機械語は CPU ごとに別物で、それぞれの ISA に合わせて作られます。

$ qemu-riscv64 -L $R/usr/riscv64-linux-gnu ./isa-rv     # RISC-V（qemu で実行）
add3(1,2,3)=6 counter=3 find(5)=4 find(7)=-1 twice_plus1(20)=41
sizeof(long)=8 sizeof(void*)=8
endian: first byte=0x44

$ qemu-aarch64 -L $R/usr/aarch64-linux-gnu ./isa-a64   # ARM（AArch64、qemu で実行）
add3(1,2,3)=6 counter=3 find(5)=4 find(7)=-1 twice_plus1(20)=41
...
$ ./isa-x86                                             # x86-64（そのまま実行）
add3(1,2,3)=6 counter=3 find(5)=4 find(7)=-1 twice_plus1(20)=41
...

3つとも long とポインタは8バイト、0x11223344 の先頭のバイトは 0x44（リトルエンディアン）でした。

RISC-VとARM・x86の違い（比較表）

この節では、RISC-V・ARM・x86 の違いを、仕様の持ち主・命令の長さ・手元で測った数字で比べた結果が分かります。

いちばん大きな違いは「誰が仕様を持ち、どういう条件で使えるか」です。 命令の作りの違いは、そのあとに来ます。

下の2行は、この記事で実際にビルドして測った値です（次の節以降で原文を示します）。x86-64 の値には、Ubuntu の GCC が既定で付ける endbr64（関数の先頭に置く4バイトの命令）が含まれています。

オープンなISAの意味とライセンス（無料なのは何か）

この節では、「RISC-V はオープン」「無料」が、具体的に何を指しているのかが分かります。

無料なのは「ISA を使う権利」です。 RISC-V International は公式サイトで、RISC-V を "an open, royalty-free ISA" と説明し、"anyone may leverage RISC-V as a building block in their open or proprietary solutions and services"（誰でも、オープンなものにも、独自の製品やサービスにも、RISC-V を部品として使える）と書いています。仕様書（ISA マニュアル）は、版 2.2 の前書きで Creative Commons Attribution 4.0 のライセンスで公開すると書かれ、以降の版も同じライセンスとされています。

ARM の場合、Arm 社は公式サイトで、大企業向けの Arm Total Access、スタートアップや中小企業向けの Arm Flexible Access（製造費はテープアウト時にプロジェクトごと）、大学向けの Arm Academic Access という契約の形を案内しています。「Arm の技術を使うには Arm 社との契約が入口」、「RISC-V は契約なしに仕様を使える」という違いです。

• オープンなのは仕様です。RISC-V の CPU がすべてオープンソースの回路というわけではありません。独自に設計し、設計データを公開しない RISC-V のコアも多くあります。
• 独自の命令を足すこともできます。仕様では、標準でない拡張は「X」で始まる名前にする決まりです。

拡張の名前の読み方（RV64GC・RVA23・Zba）

この節では、「RV64GC」「rv64imafdc_zicsr_zifencei」「RVA23」のような名前を、仕様の決まりと実物で読めるようになります。

RISC-V は「基本の整数命令（I）」に「拡張」を足して使います。名前は、ビット幅＋基本命令＋拡張の文字の並びです。 仕様の命名規則（ISA マニュアルの「ISA Extension Naming Conventions」）によると、名前は RV32I・RV32E・RV64I・RV64E のどれかで始まり、大文字と小文字は区別しません。

仕様には "We have also defined an abbreviation "G" to represent the "IMAFDZicsr_Zifencei" base and extensions" とあります。つまり RV64GC は「RV64I＋M・A・F・D・Zicsr・Zifencei＋C」で、Linux が動く64ビットの RISC-V の標準的な組み合わせです。

実物：ELF ファイルに書かれた ISA の名前

GCC が作るファイルには、どの拡張を使ったかが書き込まれています。readelf -A で読めます。

$ riscv64-linux-gnu-gcc-13 -Q --help=target | grep -E -- '-march=|-mabi='
  -mabi=                      		lp64d
  -march=                     		rv64imafdc_zicsr_zifencei

$ riscv64-linux-gnu-gcc-13 -O2 -march=rv64g -mabi=lp64d -c isa.c -o isa-g.o
$ riscv64-linux-gnu-readelf -A isa-g.o | grep arch
  Tag_RISCV_arch: "rv64i2p1_m2p0_a2p1_f2p2_d2p2_zicsr2p0_zifencei2p0_zmmul1p0"

$ riscv64-linux-gnu-gcc-13 -O2 -march=rv64gc_zba_zbb -c isa.c -o isa-b.o
$ riscv64-linux-gnu-readelf -A isa-b.o | grep arch
  Tag_RISCV_arch: "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zifencei2p0_zmmul1p0_zba1p0_zbb1p0"

• Ubuntu の RISC-V 向け GCC の既定は rv64imafdc_zicsr_zifencei（＝RV64GC）と、ABI（関数の呼び出し方の決まり）lp64d でした。
• i2p1 は「I 拡張の版 2.1」です。仕様では、版の大きい番号と小さい番号を「p」でつなぎます。
• -march=rv64g と書くと、G が i・m・a・f・d・zicsr・zifencei に展開されました。
• 拡張どうしは「_」でつなぎます。rv64gc_zba_zbb のように、Z で始まる拡張は「_」で区切って後ろに足します。

プロファイル（RVA23）とは

拡張を自由に選べると、OS やアプリは「どの拡張がある前提で作るか」に困ります。そこで、決まった拡張の組み合わせに名前を付けたのがプロファイルです。 RISC-V International は2024年10月21日、64ビットのアプリケーションプロセッサー向けのプロファイル RVA23 の批准を発表しました。発表では、ベクトル（V）とハイパーバイザー（H）の拡張が必須とされています。同じ発表の中で Google の担当者は、RVA23 が Android の RISC-V の ABI の基準になったと述べています。

RISC-V向けにクロスコンパイルする（gcc-riscv64-linux-gnu）

この節では、x86 のパソコンの上で RISC-V 用のプログラムを作る（クロスコンパイルする）手順が分かります。

Ubuntu では、RISC-V 向けのクロスコンパイラ（gcc-riscv64-linux-gnu）と、ユーザーモードの qemu（qemu-user）を入れると、x86 のパソコンで RISC-V のプログラムをビルドして動かせます。 一般的な入れ方は次のとおりです。

sudo apt install gcc-riscv64-linux-gnu qemu-user
riscv64-linux-gnu-gcc hello.c -o hello-rv
qemu-riscv64 -L /usr/riscv64-linux-gnu ./hello-rv

この記事では、ほかの作業と環境を分けるため、apt-get download で .deb を取得し、dpkg-deb -x で作業用のフォルダー（以下 $R）に展開して使いました。この場合は、ライブラリの場所を GCC に教える --sysroot が要ります。

$ riscv64-linux-gnu-gcc-13 --sysroot=$R hello.c -o hello-rv
$ file hello-rv
hello-rv: ELF 64-bit LSB pie executable, UCB RISC-V, RVC, double-float ABI, version 1 (SYSV),
dynamically linked, interpreter /lib/ld-linux-riscv64-lp64d.so.1, ..., for GNU/Linux 4.15.0, not stripped
$ qemu-riscv64 -L $R/usr/riscv64-linux-gnu ./hello-rv
hello RISC-V

同じ手順で gcc-13-aarch64-linux-gnu も展開し、ARM（AArch64）向けのビルドと qemu-aarch64 での実行も並べました。ビルドの考え方（コンパイル→リンク）は、関連記事「コンパイルとは｜意味・インタプリタとの違いを6言語の実行で解説」で扱っています。

逆アセンブルでRISC-V・ARM・x86を比べる（add・addi・lw・sw・beq・jal）

この節では、同じ C の関数が、RISC-V・ARM・x86 でどんな命令になるのかを、objdump -d の原文で比べた結果が分かります。

比べたのは、次の4つの関数です（-O2、関数が1つにまとめられないよう noinline を付けています）。

int counter;                                   /* グローバル変数（メモリ上） */

__attribute__((noinline)) long add3(long a, long b, long c) { return a + b + c; }

__attribute__((noinline)) void bump(void) { counter = counter + 1; }

__attribute__((noinline)) int find(const int *a, int n, int key) {
    for (int i = 0; i < n; i++)
        if (a[i] == key) return i;
    return -1;
}

__attribute__((noinline)) long twice_plus1(long x) { return add3(x, x, 1); }

RISC-V（RV64G・圧縮命令なし）

左の16進数が機械語、右がその読み方です。圧縮命令を使わない -march=rv64g では、すべての命令が8桁（4バイト＝32ビット）になりました。

$ riscv64-linux-gnu-objdump -d isa-rvg
00000000000008fc <add3>:
 8fc:	00b50533          	add	a0,a0,a1
 900:	00c50533          	add	a0,a0,a2
 904:	00008067          	ret

0000000000000908 <bump>:
 908:	00001717          	auipc	a4,0x1
 90c:	70470713          	addi	a4,a4,1796 # 200c <counter>
 910:	00072783          	lw	a5,0(a4)
 914:	0017879b          	addiw	a5,a5,1
 918:	00f72023          	sw	a5,0(a4)
 91c:	00008067          	ret

0000000000000920 <find>:
 920:	02b05463          	blez	a1,948 <find+0x28>
 924:	00050793          	mv	a5,a0
 928:	00000513          	li	a0,0
 92c:	00c0006f          	j	938 <find+0x18>
 930:	0015051b          	addiw	a0,a0,1
 934:	00a58a63          	beq	a1,a0,948 <find+0x28>
 938:	0007a703          	lw	a4,0(a5)
 93c:	00478793          	addi	a5,a5,4
 940:	fec718e3          	bne	a4,a2,930 <find+0x10>
 944:	00008067          	ret
 948:	fff00513          	li	a0,-1
 94c:	00008067          	ret

0000000000000950 <twice_plus1>:
 950:	00050593          	mv	a1,a0
 954:	00100613          	li	a2,1
 958:	fa5ff06f          	j	8fc <add3>

ret・mv・li・j は読みやすくするための別名（疑似命令）です。-M no-aliases を付けると、本当の命令が見えます。

$ riscv64-linux-gnu-objdump -d -M no-aliases isa-rvg
 904:	00008067          	jalr	zero,0(ra)
 950:	00050593          	addi	a1,a0,0
 954:	00100613          	addi	a2,zero,1
 958:	fa5ff06f          	jal	zero,8fc <add3>

上から順に、ret は jalr zero,0(ra)（ra のアドレスへ戻る）、mv は addi a1,a0,0、li は addi a2,zero,1、j は戻り先を残さない jal zero,… でした。

main から関数を呼ぶところは、戻り先を ra レジスタに残す jal になっていました。

 706:	190000ef          	jal	896 <bump>
 718:	178000ef          	jal	890 <add3>
 732:	174000ef          	jal	8a6 <find>

ARM（AArch64）と x86-64

$ aarch64-linux-gnu-objdump -d isa-a64            # ARM（AArch64）
00000000000009a0 <add3>:
 9a0:	8b010000 	add	x0, x0, x1
 9a4:	8b020000 	add	x0, x0, x2
 9a8:	d65f03c0 	ret
00000000000009b0 <bump>:
 9b0:	90000101 	adrp	x1, 20000 <__data_start>
 9b4:	b9401420 	ldr	w0, [x1, #20]
 9b8:	11000400 	add	w0, w0, #0x1
 9bc:	b9001420 	str	w0, [x1, #20]
 9c0:	d65f03c0 	ret

$ objdump -d -M intel isa-x86                     # x86-64
0000000000001290 <add3>:
    1290:	f3 0f 1e fa          	endbr64
    1294:	48 01 f7             	add    rdi,rsi
    1297:	48 8d 04 17          	lea    rax,[rdi+rdx*1]
    129b:	c3                   	ret
00000000000012a0 <bump>:
    12a0:	f3 0f 1e fa          	endbr64
    12a4:	83 05 69 2d 00 00 01 	add    DWORD PTR [rip+0x2d69],0x1        # 4014 <counter>
    12ab:	c3                   	ret

RISC-Vの命令は32ビット固定長（機械語をビットで分解する）

この節では、RISC-V の機械語が32ビットの中でどう区切られているかを、実際の命令をビットに分解して確かめた結果が分かります。

仕様には "The base RISC-V ISA has fixed-length 32-bit instructions that must be naturally aligned on 32-bit boundaries." とあり、基本の命令は32ビット固定長です。 32ビットの命令は下位2ビットが必ず 11 で、16ビットの圧縮命令は 00・01・10 を使います。CPU は、先頭の2ビットを見るだけで命令の長さが分かります。

逆アセンブルに出てきた機械語を、自作の Python のスクリプト（各ビットの位置を取り出すだけのもの）で分解しました。

$ python3 decode.py 00b50533 70470713 00072783 00f72023 00a58a63 190000ef fa5ff06f 00001717
00b50533  00000000101101010000010100110011  R型  funct7=0000000 rs2=a1 rs1=a0 funct3=000 rd=a0 opcode=0110011
70470713  01110000010001110000011100010011  I型  imm=1796 rs1=a4 funct3=000 rd=a4 opcode=0010011
00072783  00000000000001110010011110000011  I型  imm=0 rs1=a4 funct3=010 rd=a5 opcode=0000011
00f72023  00000000111101110010000000100011  S型  imm=0 rs2=a5 rs1=a4 funct3=010 opcode=0100011
00a58a63  00000000101001011000101001100011  B型  imm=20 rs2=a0 rs1=a1 funct3=000 opcode=1100011
190000ef  00011001000000000000000011101111  J型  imm=400 rd=ra opcode=1101111
fa5ff06f  11111010010111111111000001101111  J型  imm=-92 rd=zero opcode=1101111
00001717  00000000000000000001011100010111  U型  imm=0x1 rd=a4 opcode=0010111

• rd・rs1・rs2 の場所が、どの形式でも同じビット位置にあります。 分解した表でも、rs1 は常に15〜19ビット目でした。仕様は "The RISC-V ISA keeps the source (rs1 and rs2) and destination (rd) registers at the same position in all formats to simplify decoding." と、解読を単純にするための作りだと説明しています。
• B型・J型の飛び先は、命令の位置からの差（相対値）です。beq の imm=20 は、0x934＋20＝0x948 で、逆アセンブルの <find+0x28> と一致しました。
• auipc＋addi の2命令で、グローバル変数 counter のアドレスを作っています。12ビットの定数では遠くのアドレスを表せないためです。

x0 は常に0

仕様は "Register x0 is hardwired with all bits equal to 0." としています。x0 に書き込もうとしても、読むと0のままでした。

long r;
__asm__ volatile ("addi x0, x0, 5\n\t"   /* x0 に 5 を足して書き込もうとする */
                  "mv %0, x0" : "=r"(r)); /* x0 を読む */
printf("x0 = %ld\n", r);

$ qemu-riscv64 -L $R/usr/riscv64-linux-gnu ./x0
x0 = 0

仕様では、rd が x0 の addi は何もしない命令（HINT）として扱われ、addi x0, x0, 0 が NOP（何もしない命令）の正式な形です。mv（＝addi rd, rs, 0）や li（＝addi rd, zero, 定数）のように、x0 を「0の入ったレジスタ」として使うことで、命令の種類を少なくしています。

圧縮命令（C拡張）でサイズはどれだけ減るか（実測）

この節では、16ビットの圧縮命令を使うと、プログラムの大きさが実際にどれだけ変わるかが、3つの測り方で分かります。

仕様は C 拡張について "Typically, 50%-60% of the RISC-V instructions in a program can be replaced with RVC instructions, resulting in a 25%-30% code-size reduction." と書いています。手元で測ると、命令の約54%が16ビットになり、コードは約27%小さくなりました。

1. 同じ関数を RV64G と RV64GC で

RV64GC（既定）で同じ isa.c をビルドすると、多くの命令が4桁（2バイト）になりました。

$ riscv64-linux-gnu-objdump -d isa-rv          # RV64GC
0000000000000890 <add3>:
 890:	952e                	add	a0,a0,a1
 892:	9532                	add	a0,a0,a2
 894:	8082                	ret
0000000000000896 <bump>:
 896:	00001717          	auipc	a4,0x1
 89a:	77670713          	addi	a4,a4,1910 # 200c <counter>
 89e:	431c                	lw	a5,0(a4)
 8a0:	2785                	addiw	a5,a5,1
 8a2:	c31c                	sw	a5,0(a4)
 8a4:	8082                	ret

$ riscv64-linux-gnu-objdump -d -M no-aliases isa-rv
 890:	952e                	c.add	a0,a1
 892:	9532                	c.add	a0,a2
 894:	8082                	c.jr	ra

関数ごとの大きさ（nm -S で測ったバイト数）です。

2. CoreMark をビルドして .text を比べる

もう少し大きなコードとして、CPU の性能比較に使われる CoreMark の本体（core_list_join・core_main・core_matrix・core_state・core_util の5ファイル）をコンパイルし、size -A で .text の合計を測りました（プラットフォーム依存の core_portme は除く）。

RV64GC の命令の数を長さ別に数えると、次のとおりでした。

$ riscv64-linux-gnu-objdump -d rv64gc-O2/core_*.o | (2バイトと4バイトの命令を数える)
rv64gc-O2: 2byte=1364 4byte=1183 total=2547 ratio=53.6%
rv64gc-Os: 2byte=1090 4byte=907 total=1997 ratio=54.6%
rv64g-O2:  2byte=0    4byte=2547 total=2547 ratio=0.0%

RV64G と RV64GC で、命令の数はどちらも2,547個で同じでした。 仕様の "each RVC instruction expands into a single 32-bit instruction"（圧縮命令は、それぞれ1つの32ビットの命令に対応する）のとおり、圧縮命令は「同じ命令の短い書き方」で、命令の数は変わらず、バイト数だけが減っています。

3. glibc（libc.so.6）全体

Ubuntu の glibc 2.39 の libc.so.6 を3つの CPU で比べました。RISC-V 版は C 拡張を使ってビルドされています。

glibc は CPU ごとに入っている最適化版の関数（x86-64 なら AVX2 用など）の数が違うため、この差は ISA の違いだけではありません。ISA どうしを公平に比べるなら、同じソースを同じコンパイラ・同じ最適化で比べる（1と2）のが確実です。

• 圧縮命令が使えるのは、よく使う形に限られます。仕様によると、一部の形式は32本のうち8本のレジスタしか指定できず、c.beqz・c.bnez の飛び先は±256バイト、c.j は±2KiB までです。

qemuでRISC-Vのプログラムを実行する（qemu-riscv64）

この節では、RISC-V の実機が無くても、qemu で RISC-V のプログラムを動かす方法と、そのとき何が起きているかが分かります。

qemu-riscv64（qemu-user）は、RISC-V の命令をその場で x86 の命令に変換しながら実行し、システムコールはホストの Linux に渡します。 そのため、RISC-V の Linux 向けのプログラムを、x86 の Linux の上でそのまま動かせます。

$ qemu-riscv64 --version
qemu-riscv64 version 8.2.2 (Debian 1:8.2.2+ds-0ubuntu1.18)

$ qemu-riscv64 -cpu help
any
max
rv64
shakti-c
sifive-e51
sifive-u54
thead-c906
veyron-v1
x-rv128

静的リンクなら -L なしで動く

$ riscv64-linux-gnu-gcc-13 --sysroot=$R -static -O2 hello.c -o hello-rv-static
$ ls -l hello-rv hello-rv-static
8488 hello-rv
556080 hello-rv-static
$ qemu-riscv64 ./hello-rv-static
hello RISC-V

C のライブラリを中に含むため 8,488 バイトから 556,080 バイトになりましたが、-L なしで動きました。

-strace でシステムコールを見る

-strace を付けると、RISC-V のプログラムが出したシステムコールが表示されます。最後は write で文字を出し、exit_group で終わっていました。

$ qemu-riscv64 -strace ./hello-rv-static
6114 brk(0x00000000000ab000) = 0x00000000000ab000
6114 mprotect(0x000000000007e000,16384,PROT_READ) = 0
6114 fstat(1,0x00002aaaab2a3748) = 0
6114 write(1,0x8a740,13)hello RISC-V
 = 13
6114 exit_group(0)

qemu での速さは CPU の性能ではない

2,000万までの素数を数える自作のプログラム（エラトステネスのふるい）を、3回ずつ動かした時間です。答え（1,270,607個、合計 12,272,577,818,052）は3つとも同じでした。

この数字は、qemu が命令を変換する手間を測ったもので、RISC-V や ARM の CPU の速さとは関係ありません。 実機の性能は、CPU の設計・クロック・メモリで決まります。qemu は「正しく動くか」「どんな命令になるか」を確かめる道具として使います。

B拡張・V拡張を試す（Illegal instructionになる条件）

この節では、ビット操作（Zba・Zbb）とベクトル（V）の拡張で命令がどう変わるかと、CPU が拡張を持たないときに何が起きるかが分かります。

Zba・Zbb：1命令で済むようになる

__attribute__((noinline)) int bits(unsigned long x) { return __builtin_popcountl(x); }
__attribute__((noinline)) long pick(const int *a, long i) { return a[i]; }

$ riscv64-linux-gnu-gcc-13 -O3 -march=rv64gc ext.c -o ext-rv64gc
000000000000081c <bits>:
 81c:	1141                	addi	sp,sp,-16
 81e:	e406                	sd	ra,8(sp)
 820:	030000ef          	jal	850 <__popcountdi2>
 ...
000000000000082c <pick>:
 82c:	058a                	slli	a1,a1,0x2
 82e:	952e                	add	a0,a0,a1
 830:	4108                	lw	a0,0(a0)

$ riscv64-linux-gnu-gcc-13 -O3 -march=rv64gc_zba_zbb ext.c -o ext-rv64gc_zba_zbb
000000000000081c <bits>:
 81c:	60251513          	cpop	a0,a0
 820:	8082                	ret
0000000000000822 <pick>:
 822:	20a5c5b3          	sh2add	a1,a1,a0
 826:	4188                	lw	a0,0(a1)

1になっているビットを数える処理は、ライブラリの関数呼び出しから cpop の1命令に、配列の位置の計算（i×4＋先頭）は slli＋add から sh2add の1命令になりました。

CPU に拡張が無いと Illegal instruction

qemu の CPU から Zbb を外して、同じファイルを動かしました。

$ qemu-riscv64 -L $R/usr/riscv64-linux-gnu ./ext-rv64gc_zba_zbb
bits(0xF0F0)=8 pick(a,5)=5 c[63]=6363
$ qemu-riscv64 -cpu rv64,zbb=false -L $R/usr/riscv64-linux-gnu ./ext-rv64gc_zba_zbb
Illegal instruction
$ echo $?
132

コンパイルは通っても、動かす CPU がその拡張を持っていなければ、実行した瞬間に「Illegal instruction」で止まります。 -march には、動かす CPU（またはプロファイル）が持っている拡張だけを書きます。

V拡張：同じファイルが、ベクトルの長さに合わせて動く

V 拡張の組み込み関数（intrinsics）で、配列の足し算を書きました。

#include <riscv_vector.h>
/* V拡張の組み込み関数で c[i] = a[i] + b[i] を計算する */
__attribute__((noinline)) void vadd(int *c, const int *a, const int *b, size_t n) {
    while (n > 0) {
        size_t vl = __riscv_vsetvl_e32m1(n);          /* 今回まとめて処理する要素数 */
        vint32m1_t va = __riscv_vle32_v_i32m1(a, vl);
        vint32m1_t vb = __riscv_vle32_v_i32m1(b, vl);
        __riscv_vse32_v_i32m1(c, __riscv_vadd_vv_i32m1(va, vb, vl), vl);
        a += vl; b += vl; c += vl; n -= vl;
    }
}

$ riscv64-linux-gnu-gcc-13 -O2 -march=rv64gcv -mabi=lp64d vec.c -o vec
 80a:	0d06f7d7          	vsetvli	a5,a3,e32,m1,ta,ma
 812:	0205ec07          	vle32.v	v24,(a1)
 816:	02066c87          	vle32.v	v25,(a2)
 81c:	038c8c57          	vadd.vv	v24,v24,v25
 820:	02056c27          	vse32.v	v24,(a0)

$ for v in 128 256 512; do qemu-riscv64 -cpu rv64,v=true,vlen=$v -L ... ./vec; done
vector version is not specified, use the default value v1.0
c[0]=0 c[63]=6363 vlmax(e32,m1)=4
vector version is not specified, use the default value v1.0
c[0]=0 c[63]=6363 vlmax(e32,m1)=8
vector version is not specified, use the default value v1.0
c[0]=0 c[63]=6363 vlmax(e32,m1)=16

同じ実行ファイルのまま、ベクトルレジスタの長さ（VLEN）が128・256・512ビットの CPU で、1回に処理する要素数が4・8・16個に変わり、答えは同じでした。 vsetvli が「この CPU では1回に何個できるか」を実行時に返すためです。x86 の SSE・AVX のように、レジスタの幅ごとに別の命令を書き分ける作りとは考え方が違います。

普通の C のループを自動でベクトル命令にする機能は、手元の GCC 13.3 では働きませんでした。V 拡張を確実に使うなら、組み込み関数を書くか、より新しいコンパイラを使います。

RISC-Vの採用製品と動向（2026年10月29日時点）

この節では、RISC-V がどんな製品・OS で使われているかを、各社・各団体の公式発表で確かめた範囲で知ることができます。

RISC-V は、マイコンのような小さな CPU から、Linux が動く64ビットの CPU まで広がっています。 以下は、2026年10月29日時点で公式のページ・発表で確かめた内容だけです。

• RISC-V のボードで新しい Ubuntu を動かすなら、ボードが RVA23 に対応しているか、RVA20（RV64GC 相当）止まりかを確かめます。

CPU が命令をどう速く実行しているか（パイプライン・分岐予測・キャッシュ）は ISA ではなく CPU の設計の話で、関連記事「CPUの気持ち8選｜分岐予測・キャッシュライン・高速化」で扱っています。

RISC-Vでよくあるエラーとつまずき・誤解

この節では、RISC-V のプログラムをビルド・実行するときに出たエラーの原文と原因、よくある誤解が分かります。

よくある誤解

C 言語の基本（ポインタ・メモリ）が分かっていると、逆アセンブルの lw・sw が何を読み書きしているか追いやすくなります。関連記事「C言語とは｜入門から環境構築・ポインタ・mallocまで実行例で解説」で扱っています。

判断表：RISC-Vを選ぶ・学ぶ場面

この節では、RISC-V を製品・開発・学習で選ぶかどうかを、場面ごとに判断できます。

学ぶ順番の例です。

1. 1C の小さな関数を書き、RISC-V 向けにコンパイルするgcc-riscv64-linux-gnu と objdump -d
2. 2-M no-aliases で本当の命令を読むret・mv・li の正体を知る
3. 3qemu-riscv64 で実行し、-strace で OS とのやり取りを見る静的リンクなら -L なしで動く
4. 4-march を変えて、命令とサイズの変化を見るrv64g・rv64gc・_zba_zbb・v
5. 5仕様書（ISA マニュアル）の RV32I の章を読む命令の形式と x0・jal・分岐の範囲

複数の CPU 向けのビルドを繰り返すときは、CC=riscv64-linux-gnu-gcc のように Makefile の変数でコンパイラを切り替えると楽です。書き方は関連記事「Makefileの書き方｜自動変数一覧とタスクランナー用テンプレート」で扱っています。

よくある質問

Q. RISC-Vとは何ですか？ A. CPU が理解する命令の種類と、そのビットの表し方を決めた仕様（命令セット、ISA）です。仕様は公開され、使用料なしで誰でも使えます。2010年にカリフォルニア大学バークレー校で始まり、今はスイスの非営利団体 RISC-V International が管理しています。

Q. RISC-V の読み方は？ A. 「リスクファイブ」です。V はローマ数字の5です。

Q. RISC-V と ARM の違いは？ A. ARM は Arm 社が持つ ISA で、使うには Arm 社との契約が入口になります。RISC-V は仕様が公開され、契約なしに使えます。命令の作りはどちらもロード・ストア型の32ビット固定長ですが、RISC-V は16ビットの圧縮命令を混ぜられ、拡張を選んで組み合わせます。手元の CoreMark では、RV64GC の .text が AArch64 より約15%小さくなりました。

Q. RISC-V のパソコンやスマホは買えますか？ A. RISC-V のマイコンや、Linux が動く開発ボードは製品として出ています。新しい Ubuntu（25.10 以降）は RVA23 に対応した CPU を前提にしているため、Linux を動かすならボードの対応プロファイルを確かめます。一般向けのスマホ・パソコンでは、2026年10月29日時点で x86・ARM が主流です。

Q. RISC-V を学ぶのに実機は要りますか？ A. 要りません。Ubuntu なら gcc-riscv64-linux-gnu と qemu-user で、ビルド・逆アセンブル・実行まで x86 のパソコンでできます。この記事の結果もすべて qemu で確かめました。

Q. RVA23 とは何ですか？ A. 64ビットのアプリケーションプロセッサー向けに、必須の拡張をまとめたプロファイルです。2024年10月21日に批准が発表され、ベクトル（V）とハイパーバイザー（H）の拡張が必須とされています。

Q. Illegal instruction と出て止まります。 A. CPU が持っていない拡張の命令を実行しています。readelf -A の Tag_RISCV_arch でファイルが使う拡張を確かめ、-march を動かす CPU に合わせてビルドし直します。手元では、Zbb の無い CPU で cpop を実行したときと、V の無い CPU で vsetvli を実行したときに出ました。

Q. RISC-V は ARM を置き換えますか？ A. この記事では予測はしません。確かめられる事実としては、Debian 13 が riscv64 を正式にサポートし、Ubuntu が RVA23 を基準に据え、Android の ABI の基準が RVA23 になった、という OS 側の対応が進んでいます。

まとめ

• RISC-V は、オープンで使用料のかからない命令セット（ISA）。CPU の製品名ではなく、仕様を RISC-V International が管理し、各社がその仕様で CPU を作る。
• ARM・x86 との一番の違いは、仕様の持ち主と使う条件。無料なのは ISA を使う権利で、コアの設計データやチップは別に費用がかかる。
• 名前は「RV64」＋「I」＋拡張の文字。G は IMAFD＋Zicsr＋Zifencei、RV64GC が Linux 向けの標準で、新しい OS は RVA23 を前提にし始めている。
• 基本の命令は32ビット固定長。手元の CoreMark では、C 拡張で命令の約54%が16ビットになり、命令の数は同じまま .text が約27%小さくなった。
• gcc-riscv64-linux-gnu と qemu-riscv64 で、x86 のパソコンでもビルド・逆アセンブル・実行まで確かめられる。CPU に無い拡張を使うと Illegal instruction になる。

参考・出典

確認日はいずれも 2026年10月29日です。

• RISC-V International「About RISC-V International」：https://riscv.org/about/
• RISC-V International「The RISC-V Instruction Set Manual」（v20260120、Introduction）：https://docs.riscv.org/reference/isa/v20260120/unpriv/intro.html
• 同「RV32I Base Integer Instruction Set」：https://docs.riscv.org/reference/isa/v20260120/unpriv/rv32.html
• 同「"C" Extension for Compressed Instructions」：https://docs.riscv.org/reference/isa/v20260120/unpriv/c-st-ext.html
• 同「ISA Extension Naming Conventions」：https://docs.riscv.org/reference/isa/v20260120/unpriv/naming.html
• 同「Colophon」（版の履歴・ライセンス）：https://docs.riscv.org/reference/isa/v20260120/unpriv/colophon.html
• RISC-V International「RISC-V Announces Ratification of the RVA23 Profile Standard」（2024年10月21日）：https://riscv.org/blog/risc-v-announces-ratification-of-the-rva23-profile-standard/
• Arm「Licensing」：https://www.arm.com/products/licensing
• Debian「Debian 13 "trixie" released」（2025年8月9日）：https://www.debian.org/News/2025/20250809
• Canonical「Canonical and Ubuntu RISC-V: a 2025 retro and looking forward to 2026」（2026年2月27日）：https://ubuntu.com/blog/canonical-and-ubuntu-risc-v-a-2025-retro-and-looking-forward-to-2026
• Espressif「ESP32-C3」：https://www.espressif.com/en/products/socs/esp32-c3
• Raspberry Pi「RP2350」：https://www.raspberrypi.com/products/rp2350/
• EEMBC「CoreMark」（ソースコード）：https://github.com/eembc/coremark

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。