前書き

言い訳

本書はまだ執筆途中です．不完全な部分があることをお許しください．

しかしながら，誤りの指摘や改善のためのコメントは歓迎いたします． 本書のGithubリポジトリはこちらです．

本書の目的

本書は筆者（権藤克彦）が東京工業大学の 情報工学系で 長年担当したアセンブリ言語の授業の資料をオンライン資料として まとめ直したものです． Intel x86-64，Linux，GNUアセンブラを前提として「アセンブリ言語とは何か」 「具体的にどうプログラミングすればいいのか」を分かりやすくお伝えすることが目的です．

ただし，本書では以下は扱っていません．

• 浮動小数点命令
• (デバイスドライバの実装に必要な)I/O命令
• (OSの実装に必要な)特権命令
• MMX/SSE/AVXなどの拡張命令

いや，書いてもいいのですが分量が膨大になるので面倒くさいんです． もしOS自作に興味があるなら書籍ゼロからのOS自作入門を強くお勧めします．

本書で使う環境

本書では以下の環境を使用しています．皆さんの環境がLinuxであれば多少違っても大丈夫なはずです．

• Ubuntu 22.04 LTS (OS)
• GNU gcc-11.3.0 (コンパイラ)
• GNU binutils-2.38 (バイナリ・ユーティリティ，GNUアセンブラasを含む)
• GNU gdb-12.1 (デバッガ)

デバッガはアセンブリ言語の実行結果を確認するために便利ですので，ぜひ準備して下さい．

しかし，WindowsやmacOSの場合は，本書の内容と大きく異なってしまいます． アセンブリ言語は環境への依存度が高く，そのため移植性がとても低いからです．

皆さんのパソコンがWindowsやmacOSだった場合，Linux環境を導入する方法として以下のようないろいろな方法があります．筆者のお勧めは

• WindowsならWSL2を使う
• Intel Macなら仮想マシンVirtualBoxをインストールして，Ubuntu Desktopをインストールする (Apple Silicon Mac用のVirtualBoxは2023/12/6時点でベータ版です)
• Apple Silicon Macなら仮想マシンUTM/QEMUをインストールして， (仮想化ではなく)エミュレートでUbuntu Serverをインストールする

です．

Linux環境を導入する方法：

• WSL2 (Windows Subsystem for Linux 2)を使えるように設定する．
• VirtualBoxや VMWare Fusion などの仮想マシンをインストールして，その仮想マシン上にUbuntuなどのLinuxをインストールする． Apple Silicon Mac上では，Intel Linuxのイメージは動作不可(2024/3現在)．
• UTM/QEMUの仮想マシンに， （仮想化ではなく）エミュレートでUbuntu ServerなどのLinuxをインストールする． 動作が遅いので，Ubuntu Desktop ではなく Ubuntu Server が良いです． Ubuntu Serverのコンソールではコピペもできないので，sshでホストマシンからログインできるようにすると便利． Apple Silicon Mac上で，Intel Linuxのイメージが動作可能．
• Dockerなどのコンテナ実行環境をインストールして，その上でUbuntuなどのLinuxをインストールする．既存のイメージを使っても良い．Apple Silicon Mac上のDockerで，Intel Linuxのイメージが動作可能です．
• オンライン環境（例えばrepl.it）を使う．

Linux環境の導入方法を書くと切りが無いので，皆さん自身でググって下さい．

私が使った Ubuntu 22.04 LTSにはgccなどが未インストールなので， 以下のコマンドでインストールしました．

$ sudo apt install build-essential
$ sudo apt install gdb

本書のライセンス

Copyright (C) 2023 Katsuhiko Gondow

本書はクリエイティブ・コモンズ4.0表示(CC-BY-NC 4.0)で提供します．

本書の作成・公開環境

• マークダウン環境 mdbook
• お絵かきツール draw.io
• 公開環境 Github Pages

本書のお約束

メモリの図では0番地が常に上

本書ではメモリの図を書く時，必ず0番地(低位アドレス)が上， 高位アドレスが下になるようにします．

その結果，本書の図では「スタックは上に成長」，「ヒープは下に成長」することになります (メモリレイアウト)．

❶❷などの黒丸数字は説明用

実行結果中の❶や❷などの黒丸数字は，説明のために私が追加したものです． 実行結果の出力ではありません． 例えば，以下が例で，fileコマンドの出力例です． 本文中の説明と実行結果のどこが対応しているのかを明示するために使います．

$ file add5.o
add5.o: ❶ELF 64-bit ❷LSB ❸relocatable, x86-64, ❹version 1 (SYSV), ❺not stripped

Practical Binary Analysis という書籍がこうしていて便利なので真似させてもらっています．

一部を隠してます．

「細かい説明」「演習問題の答え」などはdetailsタグを使って隠しています． 最初は読み飛ばして構いません．読む場合は▶ボタンを押して下さい．

一部の図はタブ表示にしています

一部の図はタブ切り替えでパラパラ漫画のように表示しています． 一度に全部を表示するとゴチャゴチャする場合などに使います． 以下はタブ表示の例です．

末尾コール最適化の前

末尾コール最適化後

サンプルコードがあります

サンプルコード には2種類のファイルがあります．

• *.s アセンブリコード
• *.txt gdbのコマンド列が書かれたファイル

これらのファイルとデバッガgdbを使って機械語命令を実行・確認する方法は， こちらに説明があります． (サンプルコードの準備，めっちゃ大変だったので活用して頂けるととても嬉しいです)．

(説明せず)擬似コードを使っている部分があります

例えば，mov命令の説明では movq %rax, %rbxの動作の説明として，%rbx = %raxと書いています． %rbx = %raxはアセンブリ言語でも無くC言語でも無い， C言語風の擬似コード(psuedo code)です． 「%raxレジスタの値を%rbxレジスタに格納する」という動作を 簡潔に表現する手段として使わせて下さい．

本書のお断り

2023/10/5現在，日本語検索に対応しました．

「ですます」調と「だである」調がまざってる

すみません，自覚してますがとりあえず放置です． 後で統一するかも知れませんし，しないかも知れません．

サンプルコードのインデントがおかしい

すみません，インデントしたコードブロック中でmdbookの#include機能を使うと 表示が狂ってしまうため，意図的にインデントしていない箇所が多々あります．

Todo

• Intel CET対応のtigerlakeでサンプルコードを試していない．

  デフォルトのビルドで(endbr64が無い)サンプルコードがこけるとまずい どなたか tigerlakeのパソコンを貸して下さい😁

アセンブリ言語の概要

機械語とアセンブリ言語とは何か？（短い説明）

機械語（マシン語）：

• CPUが直接実行できる唯一の言語．
• 機械語命令を2進数（バイナリ，数字の列）で表現．

アセンブリ言語：

• 機械語を記号で表現したプログラミング言語．
• 例1：機械語命令01010101をアセンブリ言語ではpushq %rbpという記号（ニモニック，mnemonic）で表す（x86-64の場合，以下同様）．
• 例2：メモリのアドレス1000番地をアセンブリ言語ではadd5などの記号（ラベル）で表す．

2進数の機械語命令と，機械語命令のニモニックは概ね，1対1に対応しており， 機械的に変換できます．ただし，その変換方法を覚える必要はありません． アセンブルや逆アセンブルしてくれる コマンド（プログラム）にやってもらえばいいのです．

ただ，アセンブリ言語の仕組みを理解するには，オブジェクトファイル*.oや 実行可能ファイルa.outの中身や仕組みを理解する必要があるため， バイナリファイルの節では説明が多くなっています．

機械語とアセンブリ言語の具体例（逆アセンブル）

まず以下の簡単なCのプログラムadd5.cを用意して下さい．

// add5.c
int add5 (int n)
{
    return n + 5;
}

add5.cをgcc -cで処理すると， オブジェクトファイルadd5.oができます． このadd5.oに対してobjdump -dを実行すると， 逆アセンブル(disassemble)した結果が表示されます．

$ gcc -c add5.c
$ ls
add5.c  add5.o
$ objdump -d add5.o
./add5.o:     file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <add5>:
   0:	f3 0f 1e fa          	endbr64 
   4:	55                   	push   %rbp
   5:	48 89 e5             	mov    %rsp,%rbp
   8:	89 7d fc             	mov    %edi,-0x4(%rbp)
   b:	8b 45 fc             	mov    -0x4(%rbp),%eax
   e:	83 c0 05             	add    $0x5,%eax
  11:	5d                   	pop    %rbp
  12:	c3                   	ret    

逆アセンブルとは，a.outや*.o中の機械語命令を アセンブリ言語のニモニック表現に変換することです． 上の実行例で，左側に機械語命令，右側にニモニックが表示されています． (一番左側の数字は，.textセクションの先頭からのバイト数（16進表記）です）． 例えば，4バイト目にある55は機械語命令（を16進数で表記したもの）， 55の右側のpush %rbpが，55に対応するニモニックです． 16進数を使っているのは，2進数で表記すると長くなるからです．

Cコードをアセンブリコードにコンパイルする

add5.cに対して， 以下のコマンドを実行して，add5.sを作成して下さい． これで「アセンブリ言語で書かれたプログラム（アセンブリコード）」がどんなものかを見れます．

$ gcc -S add5.c
$ ls
add5.c  add5.s

-Sオプションをつけて処理すると， gccはCのプログラム(add5.c)からアセンブリコード(add5.s)を生成します． この処理を「狭義のコンパイル」と呼びます （広義のコンパイルはCのプログラムから実行可能ファイル(a.out)を 生成する処理を指します）． gcc -Sは「コンパイラ」と呼ばれます．コンパイルするコマンドだからです．

add5.sの中身は例えば以下となります．

注意： gccのバージョンの違いにより，同じLinuxでもadd5.sの中身が以下と異なることがあります．

以下では表示が長いので省略しています． 全てを表示するには右にあるボタンを押して下さい． （ここではadd5.sの中身は理解できなくてOKです）．

$ cat add5.s
        .file   "add5.c"
        .text
        .globl  add5
        .type   add5, @function
add5:
.LFB0:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    %edi, -4(%rbp)
        movl    -4(%rbp), %eax
        addl    $5, %eax
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE0:
        .size   add5, .-add5
        .ident  "GCC: (Ubuntu 11.3.0-1ubuntu1~22.04.1) 11.3.0"
        .section        .note.GNU-stack,"",@progbits
        .section        .note.gnu.property,"a"
        .align 8
        .long   1f - 0f
        .long   4f - 1f
        .long   5
0:
        .string "GNU"
1:
        .align 8
        .long   0xc0000002
        .long   3f - 2f
2:
        .long   0x3
3:
        .align 8
4:

このうち実行に関係する部分だけを残したアセンブリコードが以下になります．

# add5.s
    .text
    .globl add5
    .type add5, @function
add5:
    pushq %rbp
    movq  %rsp, %rbp
    movl  %edi, -4(%rbp)
    movl  -4(%rbp), %eax
    addl  $5, %eax
    popq  %rbp
    ret
    .size  add5, .-add5

各行の意味は次の次の節で説明しますが， ちょっとだけ説明します．

• .textなどドット.で始まる命令はアセンブラ命令です
• add5:など名前の後ろにコロン:があるものはラベルの定義です
• %rbpなど，パーセント%で始まるものはレジスタです
• $5など，ドル$で始まるものは定数(即値)です．
• addl $5, %eaxは「レジスタ%eaxの値と定数の5を足し算した結果を %eaxレジスタに格納する」という動作を行う機械語命令です
• #から行末まではコメントです

AT&T形式とIntel形式とは

x86-64用のアセンブラには本書で扱うGNUアセンブラ以外にも， NASM (netwide assembler)などいくつかあり， 困ったことにアセンブリ言語の表記が異なります． この表記方法には大きく2種類：AT&T形式とIntel形式があります． 本書で扱うGNUアセンブラはAT&T形式，NASMやIntelのマニュアルはIntel形式を使っています．

一番大きな違いは機械語命令の引数(オペランドといいます)の順番です．

• AT&T形式は「左から右へ」，つまり代入先のオペランドを右に書きます
• Intel形式は「右から左へ」，つまり代入先のオペランドを左に書きます

他にもAT&T形式には%や$がつくなど，細かい違いがあります． ここで詳しく説明します．

なお，gccに-S -masm=intelとオプションを設定すると， 出力されるアセンブリコードをIntel形式に変更できます．

$ gcc -S -masm=intel add5.c

        .intel_syntax noprefix
        .text
        .globl  add5
        .type   add5, @function
add5:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR -4[rbp], edi
        mov     eax, DWORD PTR -4[rbp]
        add     eax, 5
        pop     rbp
        ret
        .size   add5, .-add5

(DWORDは4バイト (double word)を意味しています)

なお，消した行の説明を以下に書きますが，読み飛ばしてOKです．

add5.sの各行の意味の説明の前に，説明の都合上， アセンブルとアセンブラを説明します．

アセンブリコードをオブジェクトファイルにアセンブルする

add5.sに対して，以下のコマンドを実行すると， add5.oが生成されます．この処理をアセンブル(assemble)といいます． そして，アセンブルを行うプログラム（コマンド）を アセンブラ(assembler)と呼びます． gcc -cは内部的にアセンブラasを呼び出します． asは本書で使用するGNUアセンブラのコマンド名です．

$ gcc -c add5.s
$ ls
add5.c add5.o add5.s

アセンブル処理は逆アセンブルとちょうど逆の関係です． (逆アセンブルは，バイナリから機械語命令のニモニックを復元しますが， アセンブラ命令やラベルやコメントは復元できません． ですので，完全な逆の関係ではありません．)

add5.oはバイナリファイルです． また，add5.oから作成する実行可能ファイルa.outもバイナリファイルです． バイナリ(の中身)については次の章，3節.バイナリで説明します．

アセンブリ言語の構成要素

add5.sはアセンブリ言語のプログラムであり， アセンブリコード (assembly code)と呼びます． アセンブリコードは以下の4つを組み合わせて書きます．

• 機械語命令 (例：pushq %rbp)
• アセンブラ命令 (例：.text)
• ラベル定義 (例：add5:)
• コメント (例：# add5.s)

特に機械語命令(machine instruction)とアセンブラ命令(assembler directive) の違いに注意して下さい．

• 機械語命令はCPUが実行する命令です． 例えば，pushq %rbpは機械語命令(のニモニック)です． このpushq %rbpはa.outが実行された時にCPUが実行します．

  一方，アセンブラがすることは例えば add5.s中のpushq %rbpという機械語命令のニモニックを 0x55という2進数(ここでは16進数表記)に変換して，add5.oに出力するだけです． アセンブラはpushq %rbpという機械語命令を実行しません． アセンブラにとって，pushq %rbpも0x55も両方とも単なるデータに過ぎないのです．

• アセンブラ命令はアセンブラが実行する命令です． 例えば，.textはアセンブラ命令です． 本書が使用するGNUアセンブラではドット記号.で始まる命令は全てアセンブラ命令です．

  アセンブラはadd5.sからadd5.oを出力（アセンブル）します． そのアセンブラに対して行う指示がアセンブラ命令です． 例えば，.textは「出力先を.textセクションにせよ」を アセンブラに指示しています． アセンブラはアセンブル時に.textというアセンブラ命令を実行します (CPUがa.outを実行するときではありません）．

アセンブリ言語は1行に1つが基本

アセンブリ言語は基本的に1行に1つだけ， 「機械語命令」「アセンブラ命令」「ラベル定義」「コメント」 のいずれかを書くのが基本です． ただし，複数を組み合わせて1行にできる場合もあります． 以下に可能な例を示します． (正確な定義はGNUアセンブラの文法を参照下さい)．

• OK add5: pushq %rbp (ラベル定義と機械語命令)
• OK pushq %rbp; movq %rsp, %rbp (機械語命令と機械語命令，セミコロン;で区切る)
• OK pushq %rbp # コメント (機械語命令とコメント)
• OK .text # コメント (アセンブラ命令とコメント)

add5.s中の# add5.s

# add5.sはgcc -Sの出力ではなく，私が付け加えた行です． この行はコメントです．#から行末までがコメントとなり， アセンブラは単にコメントを無視します． つまりコメントは(C言語のコメントと同じで)人間が読むためだけのものです．

add5.s中の.text

.textは「出力先を.textセクションにせよ」と アセンブラに指示しています． セクションでも説明しますが， add5.oやa.outなどのバイナリファイルの中身はセクションという単位で 区切られています． このため，アセンブラが機械語やデータを2進数に変換して出力する時， 「どのセクションに出力するのか」の指定が必要となるのです．

.textセクション以外には，代表的なセクションとして， .dataセクション，.rodataセクションがあります． それぞれの役割は以下の通りです．

• .text 機械語命令(例：pushq %rbp)を置くセクション
• .data 初期化済みの静的変数の値(例：0x1234)を置くセクション
• .rodata 読み込みのみ(read only)の値(例："hello\n\0")を置くセクション

例えば，以下のアセンブリコードfoo.sがあるとします (.rodataセクションを指定する際は，.sectionが必要です)．

# foo.s
.text            # .textセクションに出力せよ
pushq %rbp
movq %rsp, %rbp
.data            # .dataセクションに出力せよ
.long 0x11223344
.section .rodata # .rodataセクションに出力せよ
.string "hello\n"

このfoo.sをアセンブラが処理すると以下になります(以下の図を見ながら読んで下さい)．

• pushq %rbpを2進数にすると 0x55， movq %rsp, %rbpを2進数にすると 0x48 0x89 0xe5 なので， これら合計4バイトを.textセクションに出力します．

• .dataは「.dataセクションに出力せよ」 .longは「指定したデータを4バイトの2進数として出力せよ」という意味です． 0x11223344を2進数にすると 0x44 0x33 0x22 0x11なので これら4バイトを.dataセクションに出力します． (出力が逆順になっているように見えるのは x86-64がリトルエンディアンだからです．)

• .section .rodataは「.rodataセクションに出力せよ」 .stringは「指定した文字列をASCIIコードの2進数として出力せよ」という意味です． "hello\n"を2進数にすると 0x68 0x65 0x6c 0x6c 0x64 0x0a 0x00なので， これら7バイトを.rodataセクションに出力します． (最後の'\0'はヌル文字です．C言語では文字列定数の最後に自動的に ヌル文字が追加されますが，アセンブリ言語では必ずしもそうではありません． .stringはヌル文字を追加します． 一方，(ここでは使っていませんが).asciiはヌル文字を追加しません)． ASCIIコードはman asciiで確認できます．

add5.s中のadd5:，.globl add5，.type add5, @function，.size add5, .-add5

add5:はラベルの定義

add5:はadd5というラベルを定義しています． ラベルはアドレスを表しています． もっと具体的には「ラベルは，そのラベル直後の機械語命令や値が， メモリ上に配置された時のアドレス」になります．

例えば，次のアセンブリコードがあり，

add5:
    pushq %rbp 

このpushq %rbp命令の2進数表現0x55が0x1234番地に置かれたとします．

この時，ラベルadd5の値は0x1234になります． （ここでは話を単純化しています．ラベルの値が最終的に決まるまで， 再配置(relocation)などの処理が入ります）

ラベルの参照

で，大事なラベルの使い方（参照）です． 機械語命令のニモニック中で，アドレスを書ける場所にはラベルも書けるのです． 例えば，関数をコールする命令call命令でadd5関数を呼び出す時， 以下の2行はどちらも同じ意味になります． ラベルadd5の値は0x1234になるからです． （ここでも話を単純化しています．関数や変数のアドレスは 絶対アドレスではなく，相対アドレスなどが使われることがあるからです）．

    call 0x1234
    call add5    

どちらの書き方でも，アセンブラのアセンブル結果は同じになります． （もちろん通常はラベルを使います．具体的なアドレスを使って アセンブリコードを書くのは人間にとってはつらいからです）．

記号表がラベルを管理する

アセンブラはラベルのアドレスが何番地になるかを管理するために， アセンブル時に記号表(symbol table)を作ります． 記号表中の情報は割と単純で，主に以下の6つです．

ここで，add5.sのラベルadd5が

• 配置されるセクションが.textなのは，ラベルの定義add5:の前に.textが指定されているから
• グローバルなのは，.globl add5と指定されているから
• 関数という型なのは，.type add5, @functionと指定されているから
• サイズが15バイトなのは，.size add5, .-add5と指定されているから (サイズ15バイトは.-add5から自動計算されます)

です． ここでグローバルの意味は，C言語のグローバル関数やグローバル変数と(ほぼ)同じです． グローバルなシンボルは他のファイルからも参照できます．

nmコマンドを使うと記号表の中身を表示できます．

$ nm ./a.out |egrep add5
0000000000001234 T add5

大文字Tは「.text中のグローバルシンボル」であることを意味しています． （小文字tだと「.text中のグローバルではないシンボル」という意味になります）． このnmの出力では「add5が関数」という情報とサイズが表示できていません． readelfコマンドを使うと，❶関数であることとサイズが❷15バイトであることを表示できます．

$ readelf -s ./a.out | egrep add5
     1: 0000000000001234    ❷15 ❶FUNC    GLOBAL DEFAULT    1 add5

$ readelf -S add5.o セクションヘッダを表示
There are 12 section headers, starting at offset 0x258:
Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000000000  00000040
       0000000000000013  0000000000000000  AX       0     0     1
  [ 2] .data             PROGBITS         0000000000000000  00000053
       0000000000000000  0000000000000000  WA       0     0     1
  [ 3] .bss              NOBITS           0000000000000000  00000053
       0000000000000000  0000000000000000  WA       0     0     1
（中略）↓これが記号表 (symbol table)
  [ 9]❶.symtab           SYMTAB           0000000000000000  000000d8
       00000000000000f0  0000000000000018          10     9     8

add5.s中のpushq %rbp，movq %rsp, %rbp，popq %rbp

movq %rsp, %rbp

%rspと%rbpはどちらもレジスタです． (GNUアセンブラではレジスタの名前の先頭に必ず%が付きます)． レジスタはCPU内の高速なメモリです．CPUはメモリにアクセスするよりも， はるかに高速にレジスタにアクセスできます． %rspと%rbpはどちらも8バイト長のデータを格納できます．

movq %rsp, %rbpという機械語命令は 「%rspレジスタの値を%rbpにコピーする」という命令です． movqのmovは「move (移動)」，qは「処理するサイズが8バイト」であることを意味しています． (moveといいつつ，実行内容はコピーです．%rspに古い値が残るからです．)

仮にmovq %rsp, %rbpを実行する前に， %rspの値が0x11223344，%rbpの値が0x55667788とします． movq %rsp, %rbpを実行すると， %rspの値が%rbpにコピーされるので， %rspの値も%rbpの値も0x11223344になります． 要するに，movq命令はC言語の代入文と同じです．

pushq %rbpとpopq %rbp

pushq %rbpは「スタックに%rbpの値をプッシュする」機械語命令です． 以下の図のように，%rbp中の値をスタックの一番上にコピーします． スタックはコピー先の部分を含めて上に成長します（赤枠の部分がスタック全体）．

popq %rbpは「スタックからポップした値を%rbpに格納する」という機械語命令です． 以下の図のように，スタックの一番上の値を%rbpにコピーします． スタックはコピー元の部分だけ下に縮みます（赤枠の部分がスタック全体）．

これだけだと，pushq %rbpやpopq %rbpの役割がよく分かりませんね． 実はこの2つの命令は以下で説明するスタックフレームの処理に関係しています．

データ構造としてのスタック

スタック(stack)は超基本的なデータ構造であり， 以下の図の通り，プッシュ操作とポップ操作でデータの格納と取り出しを行います．

• プッシュはスタックの一番上にデータを格納します
• ポップはスタックの一番上からデータを取り出します

最後に格納したデータが，取り出す時は先に取り出されるので， 後入れ先出し方式(LIFO: last in first out)とも呼ばれます．

スタックは関数呼び出しの実装に便利なデータ構造です． 関数呼び出しからリターンするときは，呼び出された順番とは逆順にリターンするからです．

スタックとスタックフレーム

スタックとはプロセス（実行中のプログラム）が使用するメモリの領域の1つです． ここでのスタックは関数呼び出しのためのスタックなので， コールスタック(call stack)と呼ぶのが正式名称なのですが， 慣習に習って本書でも単にスタックと呼びます．

関数を呼び出すと，スタックフレームというデータがスタックに追加(プッシュ)されて， スタックは上に成長します．その関数からリターンすると， そのスタックフレームはスタックから削除(ポップ)されて縮みます． スタックフレームは関数呼び出し1回分のデータで， 局所変数，引数，返り値，戻り番地(リターンアドレス)，退避したレジスタの値などを含みます．

例えば，main関数がadd5関数を呼び出して，add5からリターンすると以下の図になります．

%rspと%rbpは一番上のスタックフレームの上下を指す

さて，ここでようやく%rspレジスタと%rbpレジスタの出番です． 実は%rspと%rbpは以下の図のように， スタック上の一番上のスタックフレームの上下を指す役割を担っています．

「レジスタがスタックを指す」というのは具体的に以下の図の状態です． つまり， スタックフレームの一番上のアドレス(例えば0x11223344)が %rspに入っていて，%rspの値をそのアドレスとして使う意図がある場合， 「%rspはスタックフレームの一番上を指す」と言い， 上の図のように矢印で図表現します． (%rbpも同様です)

%rspは常にスタックの一番上を指す

pushq命令で プッシュすると%rspはプッシュしたデータの一番上を指すようにずれるので， %rspは常にスタックの一番上(スタックトップ)を指します． また，%rbpをプッシュしたので下図のように プッシュした値もスタックフレームの一番下を指しています．

同様にpopq命令でポップした時はポップで取り出したデータ分だけ %rspが指す先は下にずれて，やはり%rspはスタックトップを指します． 下図では保存した%rbpの値をポップして%rbpに格納したので， この時だけ「ひとつ下のスタックフレームの一番下」を%rbpは指しています (が，通常，この直後にリターンして一番上のスタックフレームは破棄されます． ですので，すぐに「%rspと%rbpは常に一番上のスタックフレームの上下を指す」 という状態に戻ります．)

pushq %rbp と movq %rsp, %rbp は新しいスタックフレームを作る

関数を呼び出すと，その関数のための新しくスタックフレームを作る必要があります． 誰が作るのかというと「呼び出された関数自身」が作ります(これはABIが定める事項です)．

ここでは関数mainが関数add5をcall命令で呼び出すとして説明します．

main:
   ...
   call add5

add5:
   pushq %rbp
   movq %rsp, %rbp

これらの命令を実行した時のスタックの様子は以下の図のとおりです． (「call前」等のボタンを押して，図を切り替えて下さい)

call前

call後

push %rbp後

movq %rsp, %rbp後

一つずつ説明していきます．

• call命令実行前はmain関数が一番上のスタックフレームです． その上下を%rspと%rbpが指しています．
• call命令を実行してadd5関数に実行を移す際に， call命令はスタック上に戻り番地(リターンアドレス)をプッシュします． 戻り番地とは「関数からリターンした時にどのアドレスに実行を戻せばよいか」 　を表す番地です．この場合ではcall add5命令の次のアドレスが戻り番地になります．
• push %rbp命令を実行すると，今の%rbpレジスタの値をスタック上にプッシュします． 上の説明と見比べて下さい． 新しいスタックフレームを作る際に，%rbpに新しい値を設定する必要があるために， 今の%rbpの値をスタック上に退避（保存）するため，pushq %rbpが必要となります．
• 次に movq %rsp, %rbp を実行します． 実はadd5のスタックフレームはとても小さくて「古い%rbp」しか入っていません． ですので，%rspの値を%rbpにコピーすれば， 「add5のスタックフレームの上下を%rspと%rspが指している」という状態にできます． この動作も上で説明したので見比べて下さい．

以上で，add5のための新しいスタックフレームを作れました．

popq %rbpは今のスタックフレームを捨てる

これは前節での説明のちょうど逆になります．

popq %rbp
ret

を実行すると，スタックフレームは以下の図になります．

popq %rbp前

popq %rbp後

ret後

• popq %rbpの実行前は，スタックトップ付近はこの図の状態になっています． (コンパイラがこの図の状態になるようにアセンブリコードを出力します． 自分でアセンブリコードを書く場合は，この図の状態になるように正しくプログラムする必要があります) 「この図の状態」をもう少し説明すると以下になります．

  • スタックトップには 古い%rbp が格納されていて， その 古い%rbp は1つ前のスタックフレームの一番下を指している．
  • スタックトップのひとつ下には戻り番地が格納されている．
  • さらにその下にはadd5を呼び出した関数(ここではmain)のスタックフレームがある．

• popq %rbpを実行すると，%rbpはmain関数のスタックフレームの一番下を 指すようになります．(上の説明と合わせて読んで下さい．) また，ポップの結果，%rspが指す先が下にずれて，戻り番地を指すように変わりました．

• ret命令はスタックトップから戻り番地をポップして，次に実行する命令のアドレスをポップした戻り番地に設定します．スタックの状態はadd5を呼び出す前の状態に戻りました．

全てのスタックフレームは「古い`%rbp`」で数珠つなぎ

実は下の図のように全てのスタックフレームは「古い%rbp」で数珠つなぎ， つまり線形リスト(linked list)になっています

add5.s中の movl %edi, -4(%rbp)， movl -4(%rbp), %eax， addl $5, %eax

ここでは以下の3命令を説明します． 直感的にはこの3命令で「n + 5」を計算しています．

  movl  %edi, -4(%rbp)
  movl  -4(%rbp), %eax
  addl  $5, %eax

• まず-4(%rbp)を説明します． これは「%rbp中のアドレスから4を引いた数」をアドレスとしてメモリを 読み書きすることを意味しています．以下の図はスタックをより正確に描いています．

  • メモリは1バイトごとにアドレスが付いています． 古い%rbpや戻り番地のデータはそれぞれ8バイトなので， アドレス8つ分(つまり8バイト)の場所を占めています．
  • 多バイト長のデータはそのデータが占めている先頭のアドレスを使って メモリを読み書きします．(本書の図ではメモリの0番地が常に上にあることを思い出してください)． ですので，1バイトごとのアドレスで考えると，%rbpはスタックフレームの 一番下を指していません．
  • そして，-4(%rbp)は「%rbpから4を引いたアドレスのメモリ」ですので， 以下の図で-4(%rbp)が指している場所を先頭とするメモリ領域になります．

• 次に%ediと%eaxについて説明します．

  • 以下の図のようにx86-64には8バイト長の%rdiと%raxという 汎用レジスタがあります(他にも汎用レジスタはありますがここでは割愛)． その右半分にそれぞれ%ediと%eaxという名前が付いています． %ediと%eaxは4バイト長です．
  • %rdiレジスタは関数呼び出しでは第1引数を渡すために使われます． add5の第1引数nはint型で，この場合は4バイト長だったため， %ediにnの値が入っています．
  • %raxレジスタは関数呼び出しでは返り値を返すために使われます． add5の返り値の方がint型なので，%eaxに値を入れてから 関数をリターンすれば，返り値が返せることになります．

• 次に以下の2つの命令を説明します．

  movl  %edi, -4(%rbp)
  movl  -4(%rbp), %eax

• movlのlは4バイトのデータをコピーすることを表しています．ですので， 例えば，movl %edi, -4(%rbp)は%edi中の4バイトデータを 先頭アドレスが-4(%rbp)から4バイト分の領域 (この図で一番上の赤い部分) にコピーする命令になります．

• この2つの命令で「%edi中の4バイトを-4(%rbp)にコピー」して，次に 「-4(%rbp)中の4バイトを%eaxにコピー」しています． 「%ediから%eaxに直接コピーすればいいんじゃね?」と思った方，正解です． 実はこの場合は(-4(%rbp)に格納しても使われないので)不要なのですが， コンパイラは 「引数nの実体の場所を-4(%rbp)としたので， -4(%rbp)にもnの値を格納する」という判断をしたようです．

• addl $5, %eax命令を説明します．

  • この命令は%eaxの値と定数5の値を足し算した結果を%eaxに格納します．
  • つまり，n + 5の結果がこの命令の実行後に%eaxに入ります．
  • GNUアセンブラでは定数の先頭にはドルマーク$が付きます． ただし，-4(%rbp)の-4など，ドルマークが付かないこともあります．

以上でadd5.sの説明が終わりました(お疲れ様でした)．

%rspより上のメモリ領域に勝手に書き込んで良いのか(レッドゾーン)

LinuxのABI System V ABIではOKです． LinuxのABIでは%rspレジスタの上，128バイトの領域をレッドゾーンと呼び， この領域には好きに読み書きして良いことになっています． (ABIが「割り込みハンドラやシグナルハンドラが実行されても， レッドゾーンの値は破壊されない」ことを保証しています．） もちろん，自分自身で関数を呼び出すとレッドゾーン中の値は壊れるので， レッドゾーンは葉関数(leaf function)，つまり関数を呼び出さない関数 が使うのが一般的です． レッドゾーンのおかげで，%rspをずらさずにメモリの読み書きができるので， その分だけ実行が高速になります．

バイナリファイル

バイナリファイルの中身を見る

16進ダンプ

add5.cやadd5.sはテキストファイルですが， 2節のアセンブリ言語で作成した add5.oはバイナリファイルです． バイナリファイルなので，lessコマンドでは中身を読めません．

$ less add5.o
^?❶ELF^B^A^A^@^@^@^@^@^@^@^@^@^A^@>^@^A^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@X^B
^@^@^@^@^@^@^@^@^@^@@^@^@^@^@^@@^@^L^@^K^@<F3>^O^^<FA>UH<89><E5><89>}<FC><8B>E
（長いので省略）

バイナリファイルの中身を読むには例えばodコマンドを使います．

$ od -t x1 add5.o
0000000 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
0000020 01 00 3e 00 01 00 00 00 00 00 00 00 00 00 00 00
（長いので省略）

一番左の数字が「先頭からのバイト数(16進表記)」， その右側に並んでいるのが「1バイトごとに16進表記したファイルの中身」です． （1バイトのデータは2桁の16進数で表せることを思い出しましょう． 例えば，add5.oの中身の先頭4バイトの値は7F 45 4C 46です）．

-t x1というオプションは「1バイトごとに16進数で表示せよ」という意味です． このような出力を16進ダンプ(hex dump)と言います． 他に16進ダンプするコマンドとして，xxdやhexdumpなどがあります．

ちなみに，add5.cはテキストファイルですが，内容は2進数で保存されて いますので，odコマンドで中身を表示できます．

$ od -t x1 add5.c
0000000 69 6e 74 20 61 64 64 35 20 28 69 6e 74 20 6e 29
0000020 0a 7b 0a 20 20 20 20 72 65 74 75 72 6e 20 6e 20
0000040 2b 20 35 3b 0a 7d 0a
0000047

先頭の69はASCII文字iの文字コード， 同様に，次の6eは文字n，その次の74は文字tなので， add5.cの先頭3文字がintであることを確認できます． ASCIIコード表はman asciiコマンドで閲覧できます． （例えば，16進数の0x69は10進数の105です． ASCIIコード表の105番目の文字はiです．）

$ man ascii

ASCII(7)                   Linux Programmer's Manual                  ASCII(7)

NAME
       ascii - ASCII character set encoded in octal， decimal， and hexadecimal

DESCRIPTION
       ASCII is the American Standard Code for Information Interchange.  It is
       a 7-bit code.  Many 8-bit codes (e.g.， ISO  8859-1)  contain  ASCII  as
       their  lower  half.  The international counterpart of ASCII is known as
       ISO 646-IRV.

       The following table contains the 128 ASCII characters.

       C program '\X' escapes are noted.

       Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char
       ────────────────────────────────────────────────────────────────────────
       000   0     00    NUL '\0' (null character)   100   64    40    @
       001   1     01    SOH (start of heading)      101   65    41    A
       002   2     02    STX (start of text)         102   66    42    B
（以下略）

なお，odコマンドに-cオプションをつけると， (文字として表示可能なバイトは)文字が表示されます．

$ od -t x1 -c add5.c
0000000  69  6e  74  20  61  64  64  35  20  28  69  6e  74  20  6e  29
          i   n   t       a   d   d   5       (   i   n   t       n   )
0000020  0a  7b  0a  20  20  20  20  72  65  74  75  72  6e  20  6e  20
         \n   {  \n                   r   e   t   u   r   n       n    
0000040  2b  20  35  3b  0a  7d  0a
          +       5   ;  \n   }  \n
0000047

コンピュータの中のデータはすべて0と1から成る

ここで大事なことを復習しましょう． それは 「コンピュータの中のデータは，どんな種類のデータであっても， 機械語命令であっても，すべて0と1だけで表現されている」 ということです． ですので，テキストはバイナリでもあるのです．

• テキスト=文字として表示可能な2進数だけを含むデータ
• バイナリ=文字以外の2進数も含んだデータ

注意： 本書で，テキスト(text)という言葉には2種類の意味があることに注意して下さい．

• 1つは「文字」を意味します．例：「テキストファイル」（文字が入ったファイル）
• もう1つは「機械語命令列」を意味します．例：「テキストセクション」（機械語命令列が格納されるセクション）

2進数と符号化

前節で説明した通り， コンピュータ中では全てのものを0と1の2進数で表現する必要があります． そのため，データの種類ごとに2進数での表現方法，つまり符号化 (encoding)の方法が定められています． 例えば，

• 文字UをASCII文字として符号化すると，01010101になります．
• pushq %rbpをx86-64の機械語命令として符号化すると，01010101になります．

おや，どちらも同じ01010101になってしまいました． この2進数がUなのかpushq %rbpなのか，どうやって区別すればいいでしょう？ 答えは「これだけでは区別できません」です．

別の手段（情報）を使って，いま自分が注目しているデータが， 文字なのか機械語命令なのかを知る必要があります． 例えば，この後で説明する.textセクションにある 2進数のデータ列は「.textセクションに存在するから」という理由で 機械語命令として解釈されます．

fileコマンド

16進ダンプ以外の方法で，add5.oの中身を見てみます． まずはfileコマンドです． fileコマンドはファイルの種類の情報を教えてくれます．

$ file add5.o
add5.o: ❶ELF 64-bit ❷LSB ❸relocatable， x86-64， ❹version 1 (SYSV)， ❺not stripped

これで，add5.oが64ビットの❶ELFバイナリであることが分かりました． ELFはバイナリ形式(バイナリを格納するためのファイルフォーマット)の1つです． Linuxを含めて多くのOSがELFをバイナリ形式として使っています．

$ readelf -h a.out
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:        ELF64
  Data:         2's complement, ❶little endian
  Version:      1 (current)
  OS/ABI:       UNIX - System V
(以下略)

$ cat little.s
.text
❶.long 0x11223344
$ gcc -c little.s
$ objdump -h little.o
foo.o:     file format elf64-x86-64
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000004  0000000000000000  0000000000000000 ❷00000040  2**0
                  CONTENTS， ALLOC， LOAD， READONLY， CODE
  1 .data         00000000  0000000000000000  0000000000000000  00000044  2**0
                  CONTENTS， ALLOC， LOAD， DATA
  2 .bss          00000000  0000000000000000  0000000000000000  00000044  2**0
                  ALLOC
$ od -t x1 -j0x40 little.o | head -n1
0000100 ❸44 33 22 11 00 00 00 00 00 00 00 00 00 00 00 00

$ ls -l add5.o
-rw-rw-r-- 1 gondow gondow 1368 Jul 19 10:09 add5.o
$ strip add5.o
$ ls -l add5.o
-rw-rw-r-- 1 gondow gondow 880 Jul 19 14:58 add5.o

$ objcopy --dump-section .text=foo little.o
$ od -t x1 foo
0000000 44 33 22 11
0000004

$ objcopy --add-section .text2=foo --set-section-flags .hoge=noload,readonly little.o
$ objdump -h little.o
little.o:     file format elf64-x86-64
Sections:
Idx Name       Size      VMA               LMA               File off  Algn
  0 .text      00000004  0000000000000000  0000000000000000  00000040  2**0
               CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data      00000000  0000000000000000  0000000000000000  00000044  2**0
               CONTENTS, ALLOC, LOAD, DATA
  2 .bss       00000000  0000000000000000  0000000000000000  00000044  2**0
               ALLOC
  3 ❶.text2     00000004  0000000000000000  0000000000000000  00000044  2**0
               CONTENTS, READONLY

なお，fileコマンドはバイナリ以外のファイルにも使えます．

$ file add5.c
add5.c: ASCII text
$ file add5.s
add5.s: assembler source， ASCII text
$ file .
.:  directory
$ file /dev/null
/dev/null: character special (1/3)

セクションとobjdump -hコマンド

バイナリファイルの構造はざっくり以下の図のようになっています．

• 最初のヘッダ以外の四角をセクション(section)と呼びます．
• バイナリはセクションという単位で区切られていて，それぞれ別の目的でデータが格納されます．
• ヘッダは目次の役割で「どこにどんなセクションがあるか」という情報を保持しています．

ヘッダの情報はobjdump -hで表示できます．

$ objdump -h add5.o
add5.o:     file format elf64-x86-64
Sections:
Idx Name     Size      VMA               LMA               File off  Algn
  0 .text    00000013  0000000000000000  0000000000000000  00000040  2**0
             CONTENTS， ALLOC， LOAD， READONLY， CODE
  1 .data    00000000  0000000000000000  0000000000000000  00000053  2**0
             CONTENTS， ALLOC， LOAD， DATA
  2 .bss     00000000  0000000000000000  0000000000000000  00000053  2**0
             ALLOC
(以下略)

ここでは「.text，.data，.bssという3つのセクションがある」ことを 見ればOKです．

// bss.c
int a [1024];
int main (void)
{
   return a[0];
}

$ gcc -S bss.c
$ cat bss.s
(関係する箇所以外は削除)
 ❶ .bss                # 以下を.bssセクションに出力
    .align 32           # 次の出力アドレスを32の倍数にせよ
    .type   a, @object  # ラベルaの型はオブジェクト(関数ではなくデータ)
    .size   a, 4096     # ラベルaのサイズは4096バイト
a:                      # ラベルaの定義
 ❷ .zero   4096        # 4096バイト分のゼロを出力せよ

$ gcc -g bss.c
$ objdump -h ./a.out
Sections:
Idx Name          Size      VMA               LMA                File off  Algn
(中略)
23 ❸.bss     ❹ 00001020  0000000000004020  0000000000004020 ❺ 00003010  2**5
                ❼ALLOC
24   .comment    0000002b  0000000000000000  0000000000000000 ❻ 00003010  2**0
                  CONTENTS, READONLY

さらに代表的なセクションである.rodataも説明します．

• .rodataセクションは読み込みのみ(read-only)なデータの値を格納します．例えば，C言語の文字列定数"hello"は書き込み禁止なので，"hello"の2進数表現が.rodataセクションに格納されます．

バイナリファイルには上記以外のセクションも数多く使われますが， まずはこの基本の4種類 (.text， .data， .bss， .rodata) を覚えましょう．

記号表の中身を表示させる(nmコマンド)

バイナリファイル中には記号表(symbol table)があることが多いです． 記号表とは「変数名や関数名がバイナリ中では何番地のアドレスになっているか」という情報です． nmコマンドでバイナリファイル中の記号表を表示できます． まず，以下のfoo.cを準備して下さい．

// foo.c
int g1 = 999;
int g2;
int s1 = 888;
int s2;
int main ()
{
    static int s3 = 777;
    static int s4;
    int ❼i1 = 666;
    int ❼i2;
}

そしてコンパイルして，nmコマンドで記号表の中身を表示させます．

$ gcc -c foo.c
$ nm foo.o
0000000000000000 ❶D g1
0000000000000000 ❸B g2
0000000000000000 ❺T main
0000000000000004 ❶D s1
0000000000000004 ❸B s2
0000000000000008 ❷d ❻s3.0
0000000000000008 ❹b ❻s4.1

この出力の読み方は以下の通りです．

• ❶Dと❷dは.dataセクションのシンボル，❸Bと❹bは.bssセクションのシンボル，❺Tとtは.textセクションのシンボルであることを表す
• 大文字はグローバル（ファイルをまたがって有効なシンボル），小文字はファイルローカルなシンボルであることを表す
• static付きの局所変数を表すシンボルは 他の関数中の同名のシンボルと区別するために， ❻.0や.1などが付加されることがある．
• 左側の00，04，08がシンボルに対応するアドレスですが，再配置前(relocation前)なので仮のアドレス(各セクションの先頭からのオフセット)
• (staticのついてない)局所変数❼は記号表には含まれていない． 局所変数(自動変数)は実行時にスタック上に実体が確保されます．

ASLRとPIE（ちょっと脱線）

オブジェクトファイルのセクションごとの仮のアドレスは， リンク後のa.outでは具体的なアドレスになります

$ gcc foo.c
$ nm ./a.out | egrep g1
0000000000004010 D g1
$ nm ./a.out | egrep main
                 U __libc_start_main@@GLIBC_2.34
0000000000001129 T main

$ readelf -h ./a.out | egrep Entry
  Entry point address:           ❶ 0x1040
$ objdump -d ./a.out | egrep 1040
0000000000001040 ❷ <_start>:
    1040:	f3 0f 1e fa          	endbr64 

出力が長くなるので，g1とmainのアドレスだけ載せています． g1のアドレスは0x4010番地，mainのアドレスは0x1129番地となりました． ただし，このまま実行すると，g1やmainのアドレスはこれらのアドレスにはならず， 実行するたびに変わります． これはASLRやPIEというセキュリティ対策機能のためです．

確かめてみましょう． 以下のfoo2.cを普通にコンパイルして実行してみます．

// foo2.c
#include <stdio.h>
int g1 = 999;
int main ()
{
    printf ("%p, %p\n", &g1, main);
}

以下の通り，g1やmainのアドレスは実行するたびに変わりますし， nmが出力したアドレスとも異なります．

$ gcc foo2.c
$ ./a.out
0x557f2361e010， 0x557f2361b149
$ ./a.out
0x55a40e6f5010， 0x55a40e6f2149
$ ./a.out
0x562750663010， 0x562750660149
$ 

ここではASLRとPIEの機能を無効にして，アドレスが変わらなくなることを確認します．

$ sudo sysctl -w kernel.randomize_va_space=0  # ASLRをオフ
$ gcc -no-pie foo2.c                          # PIEをオフ
$ nm ./a.out | egrep main
                 U __libc_start_main@@GLIBC_2.34
0000000000401136 T main
$ nm ./a.out | egrep g1
0000000000404030 D g1
$ ./a.out
&g1=0x404030， main=0x401136
$ ./a.out
&g1=0x404030， main=0x401136
$ ./a.out
&g1=0x404030， main=0x401136

ASLRとPIEの機能をオフにすることで，アドレスが変わらなくなり， かつnmが出力するアドレスと同じになることが確認できました．

注意： 不用意なASLRとPIEの無効化はセキュリティ機能を下げるので避けるべきです． しかしデバッグ作業ではアドレスが変わらなくなるので ASLRとPIEの無効化が有用な場合もあります． なお，デバッガ中ではASLRは無効化されていることが多いです．

$ sudo sysctl -w kernel.randomize_va_space=0

$ sudo sysctl -w kernel.randomize_va_space=1

$ gcc -no-pie foo2.c

逆アセンブル再び

逆アセンブルで説明した通り， objdump -d ./a.outで逆アセンブル結果が表示されます（再掲）．

$ objdump -d add5.o
add5.o:     file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <add5>:
   0:	f3 0f 1e fa          	endbr64 
   4:	55                   	push   %rbp
   5:	48 89 e5             	mov    %rsp，%rbp
   8:	89 7d fc             	mov    %edi，-0x4(%rbp)
   b:	8b 45 fc             	mov    -0x4(%rbp)，%eax
   e:	83 c0 05             	add    $0x5，%eax
  11:	5d                   	pop    %rbp
  12:	c3                   	retq   

objdumpコマンドはadd5.oの.textセクションを抽出し， そのデータを機械語命令として解釈して，対応するニモニックを出力しています．

この出力によれば，.textセクションの先頭4バイトはF3 0F 1E FAで， この4バイトがendbr64命令になります （x86-64の命令長は可変長で，1バイト〜15バイトです）．

以下では.textセクションの先頭4バイトがF3 0F 1E FAであることを確認します．

セクションのヘッダを出力するコマンドobjdump -hの出力を再掲します．

$ objdump -h add5.o
add5.o:     file format elf64-x86-64
Sections:
Idx Name     Size      VMA               LMA                File off  Algn
  0 .text    00000013  0000000000000000  0000000000000000 ❶00000040  2**0
             CONTENTS， ALLOC， LOAD， READONLY， CODE
  1 .data    00000000  0000000000000000  0000000000000000   00000053  2**0
             CONTENTS， ALLOC， LOAD， DATA
  2 .bss     00000000  0000000000000000  0000000000000000   00000053  2**0
             ALLOC

.textセクションのFile offの欄を見ると❶00000040とあります． これは.textセクションがadd5.oの先頭から16進数で40バイト 目(以後，0x40と表記)にあることを意味しています．

odコマンドの-jオプションを使うと，指定したバイト数だけ， 先頭をスキップしてくれます． この-jオプションを使って，0x40バイトスキップして， .textセクションの最初だけを16進ダンプします （head -n3は先頭の3行だけ表示します）．

$ od -t x1 -j0x40 add5.o | head -n3
0000100 ❶f3 0f 1e fa 55 48 89 e5 89 7d fc 8b 45 fc 83 c0
0000120   05 5d c3 00 47 43 43 3a 20 28 55 62 75 6e 74 75
0000140   20 39 2e 34 2e 30 2d 31 75 62 75 6e 74 75 31 7e

この結果❶を見ると，.textセクションの最初の4バイトは F3 0F 1E FAであることが分かります． これは上の逆アセンブルの結果の先頭4バイトと一致しており， endbr64命令が，add5.oの先頭から0x40バイト目に存在することが分かりました．

広義のコンパイルとリンク

ここでは広義のコンパイル，つまりCのプログラムfoo.cから 実行可能ファイルa.outを生成する処理の中身を見ていきます． いちばん大事なのは最後のリンク(link)です．

• ❶ Cの前処理，すなわち#includeや#defineなどの前処理命令の処理と，マクロ（例えば<stdio.h>が定義するNULLやEOF）の展開を行います．gcc -Eコマンドで実行できますが，内部的にはカッコ内のcppやcc1コマンドが実行されています（現在はcc1）．
• ❷ 狭義のコンパイル処理で，Cのプログラムをアセンブリコードに変換します．
• ❸ アセンブラ(asコマンド)によるアセンブル処理で，オブジェクトファイルfoo.oを生成します．foo.o中にはバイナリの機械語命令が入っています．
• ❹ foo.oだけでは実行可能ファイルは作れません．例えば，printfなどのライブラリ関数の実体は， libc.a(静的ライブラリ)やlibc.so(動的ライブラリ)の中にあるからです． また，main関数を呼び出すためのCスタートアップルーチン(多くの場合，crt*.oというファイル名)も必要です． また，分割コンパイルの機能を使った結果，foo.oは他のC言語のプログラムをアセンブルしたオブジェクトファイル*.oが必要なことがよくあります． 「このような他のバイナリとfoo.oを合体させてa.outを生成する処理」のことをリンク(link)と呼びます．

広義のコンパイルで具体的にどのような処理が行われてるのかを見るには， -vをつけてgcc -vとコンパイルすれば表示されます． （以下では表示を省略しています．全てを表示するにはボタンを押して下さい）．

$ gcc -v main.c add5.s |& tee out
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
 Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.3.0-1ubuntu1~22.04.1' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c，ada，c++，go，brig，d，fortran，objc，obj-c++，m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32，m64，mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-aYxV0E/gcc-11-11.3.0/debian/tmp-nvptx/usr，amdgcn-amdhsa=/build/gcc-11-aYxV0E/gcc-11-11.3.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2
 Thread model: posix
 Supported LTO compression algorithms: zlib zstd
 gcc version 11.3.0 (Ubuntu 11.3.0-1ubuntu1~22.04.1) 
 COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64' '-dumpdir' 'a-'
  /usr/lib/gcc/x86_64-linux-gnu/11/cc1 -quiet -v -imultiarch x86_64-linux-gnu main.c -quiet -dumpdir a- -dumpbase main.c -dumpbase-ext .c -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccTw9Mym.s
 GNU C17 (Ubuntu 11.3.0-1ubuntu1~22.04.1) version 11.3.0 (x86_64-linux-gnu)
 	compiled by GNU C version 11.3.0， GMP version 6.2.1， MPFR version 4.1.0， MPC version 1.2.1， isl version isl-0.24-GMP
 
 GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
 ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
 ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"
 ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"
 #include "..." search starts here:
 #include <...> search starts here:
  /usr/lib/gcc/x86_64-linux-gnu/11/include
  /usr/local/include
  /usr/include/x86_64-linux-gnu
  /usr/include
 End of search list.
 GNU C17 (Ubuntu 11.3.0-1ubuntu1~22.04.1) version 11.3.0 (x86_64-linux-gnu)
 	compiled by GNU C version 11.3.0， GMP version 6.2.1， MPFR version 4.1.0， MPC version 1.2.1， isl version isl-0.24-GMP
 
 GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
 Compiler executable checksum: e13e2dc98bfa673227c4000e476a9388
 COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64' '-dumpdir' 'a-'
  as -v --64 -o /tmp/cc5o7Jgg.o /tmp/ccTw9Mym.s
 GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38
 COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64' '-dumpdir' 'a-'
  as -v --64 -o /tmp/ccUs2R16.o add5.s
 GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38
 COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/
 LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/
 COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64' '-dumpdir' 'a.'
  /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccgnuv0i.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. /tmp/cc5o7Jgg.o /tmp/ccUs2R16.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o
 COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64' '-dumpdir' 'a.'

バイナリファイルの種類

実行可能ファイルa.outに関連するバイナリファイルには 以下の4種類があります：

• オブジェクトファイル(*.o)
• 実行可能ファイル(a.out)
• 静的ライブラリファイル(lib*.a)
• 動的ライブラリファイル(lib*.so)

オブジェクトファイル(*.o)

オブジェクトファイルとはLinuxでファイル名の拡張子が.oなファイルです． オブジェクトファイルは機械語命令を含んでいますが， このオブジェクトファイル単体では実行することができません． 実行を可能にするにはリンク(link)処理を経て， 実行可能ファイル を作成する必要があります．

オブジェクトファイルは再配置可能オブジェクトファイル (relocatable object file)と呼ばれることもあります． オブジェクトファイルはリンク時に再配置（アドレス調整）が可能だからです．

実行可能ファイル(a.out)

実行可能ファイル(executable file)はその名前の通り，OSに実行を依頼すればそのままで実行できるバイナリファイルのことです． 例えば，hello wordの実行可能ファイルa.outはシェル上で以下のように実行できます．

$ ./a.out
hello， world

lsなどのシェル上で実行可能なコマンドも実行可能ファイルです．

$ which ls
/usr/bin/ls
$ file /usr/bin/ls
/usr/bin/ls: ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， ❶interpreter /lib64/ld-linux-x86-64.so.2， ❷BuildID[sha1]=2f15ad836be3339dec0e2e6a3c637e08e48aacbd， for GNU/Linux 3.2.0， stripped
$ ls
a.out add5.c add5.o add5.s

$ readelf -h ./a.out
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement， little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
❶Entry point address:               0x401050
  Start of program headers:          64 (bytes into file)
  Start of section headers:          16832 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         13
  Size of section headers:           64 (bytes)
  Number of section headers:         36
  Section header string table index: 35

$ objdump -d ./a.out | egrep 401050 -A 5
0000000000401050 ❷ <_start>:
  401050:	f3 0f 1e fa          	endbr64 
  401054:	31 ed                	xor    %ebp，%ebp
  401056:	49 89 d1             	mov    %rdx，%r9
  401059:	5e                   	pop    %rsi
  40105a:	48 89 e2             	mov    %rsp，%rdx
  40105d:	48 83 e4 f0          	and    $0xfffffffffffffff0，%rsp

$ gcc hello.c
$ cp a.out a.out.stripped
$ strip a.out.stripped
$ file a.out a.out.stripped
a.out:          ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， interpreter /lib64/ld-linux-x86-64.so.2， BuildID[sha1]=308260da4f7fb6d4116c12670adf6e503637abba， for GNU/Linux 3.2.0， not stripped
a.out.stripped: ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， interpreter /lib64/ld-linux-x86-64.so.2， BuildID[sha1]=308260da4f7fb6d4116c12670adf6e503637abba， for GNU/Linux 3.2.0， stripped

$ sha1sum ./a.out
ff99525ad6a48d78d35d3108401af935a6ca9bbe  ./a.out

実行可能なコマンドには実行可能ファイルではなく， スクリプトなことがあります．

$ which shasum
/usr/bin/shasum
$ file /usr/bin/shasum
/usr/bin/shasum: Perl script text executable
$ head -3 /usr/bin/shasum
#!/usr/bin/perl
    eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
	if 0; # ^ Run only under a shell

shasumコマンドは(実行可能ファイルではなく)Perlスクリプトでした．

静的ライブラリ(lib*.a)

静的ライブラリ(static library)は静的リンク するときに使われるライブラリです． ライブラリとは複数のオブジェクトファイルを１つのファイルにまとめたもの（アーカイブ）です．

LinuxなどのUNIX系のOSでは静的ライブラリのファイル拡張子は.aが多いです． またWindowsでは.libです． printfの実体が入っているC標準ライブラリの 静的ライブラリのファイル名はlibc.aです．

動的ライブラリ(lib*.so)

動的ライブラリ(dynamic library)は動的リンク するときに使われるライブラリです． 動的ライブラリは共有ライブラリ(shared library)とも呼ばれます． 動的ライブラリは複数のプロセスからメモリ上で共有されるからです．

Linuxでは動的ライブラリのファイル拡張子は.soです(shared objectの略)． 処理系の都合でファイル拡張子に数字がつくことがあります（例：.so.6）． 動的ライブラリのファイル拡張子はUnix系のOSでも様々です． Windowsでは.dllです．

静的リンクと動的リンク

静的ライブラリは静的リンクに使われるライブラリで， 動的ライブラリは動的リンクに使われるライブラリです．

静的リンク

静的リンクとはコンパイル時にリンクを行う手法です． 仕組みは単純ですが，ファイルやメモリの使用量が増える欠点があります． この図で説明したリンクは実は静的リンクでした．

静的リンクしたファイルa.outはリンク済みなので， ライブラリ関数(例えばprintf)の実体もa.outの中に入っています．

a.outごとにprintfのコピーが作られるので， ファイルの使用量が無駄に増えてしまいます． またa.out中のprintfは実行時にもメモリ上で共有されないので， メモリの使用量も無駄に増えてしまいます．

静的リンクでコンパイルしてみる

// hello.c
#include <stdio.h>
int main (int ac, char **ag)
{
    printf ("hello (%d)\n", ac);
}

静的リンクするには-staticオプションをつけます（-static無しだと動的リンクになります）． printfに第2引数を与えているのは，こうしないと，コンパイラが勝手に printfの呼び出しをputsに変更してしまうことがあるからです．

a.outをfileコマンドで確認するとstatically linkedとあり❶， 静的リンクできたことが分かります．

$ gcc -static hello.c
$ file ./a.out
./a.out: ELF 64-bit LSB executable， x86-64， version 1 (GNU/Linux)， ❶statically linked， BuildID[sha1]=40fe6c0daaf2d49fabad4d37bc34fcdd12cb8da9， for GNU/Linux 3.2.0， not stripped
$ ./a.out
hello (1)

$ objdump -d ./a.out | egrep ❷-A 14 ❶"<main>:"
0000000000401cb5 <main>:
  401cb5:	f3 0f 1e fa          	endbr64 
  401cb9:	55                   	push   %rbp
  401cba:	48 89 e5             	mov    %rsp，%rbp
  401cbd:	48 83 ec 10          	sub    $0x10，%rsp
  401cc1:	89 7d fc             	mov    %edi，-0x4(%rbp)
  401cc4:	48 89 75 f0          	mov    %rsi，-0x10(%rbp)
  401cc8:	8b 45 fc             	mov    -0x4(%rbp)，%eax
  401ccb:	89 c6                	mov    %eax，%esi
  401ccd:	48 8d 3d 30 33 09 00 	lea    0x93330(%rip)，%rdi        # 495004 <_IO_stdin_used+0x4>
  401cd4:	b8 00 00 00 00       	mov    $0x0，%eax
  401cd9:	e8 72 ec 00 00       	callq  410950 ❸<_IO_printf>
  401cde:	b8 00 00 00 00       	mov    $0x0，%eax
  401ce3:	c9                   	leaveq 
  401ce4:	c3                   	retq   

$ objdump -d ./a.out | egrep -A 5 "<_IO_printf>:"
0000000000410950 <_IO_printf>:
  410950:	f3 0f 1e fa          	endbr64 
  410954:	48 81 ec d8 00 00 00 	sub    $0xd8，%rsp
  41095b:	49 89 fa             	mov    %rdi，%r10
  41095e:	48 89 74 24 28       	mov    %rsi，0x28(%rsp)
  410963:	48 89 54 24 30       	mov    %rdx，0x30(%rsp)

$ nm ./a.out | egrep _IO_printf
0000000000410950 T _IO_printf

$ nm ./a.out | egrep 410950
0000000000410950 T _IO_printf
0000000000410950 T __printf
0000000000410950 T printf

動的リンク

動的リンクとは実行を始める際のロード時（a.outをメモリにコピーする時） あるいは実行途中にメモリ上でリンクを行う手法です． 現在ではファイルやメモリの消費量を抑えるため，デフォルトで動的リンクが使われることが多いです．

動的リンクしたファイルa.outには 「ライブラリ関数(例えばprintf)とのリンクが必要だよ」という 小さな参照情報だけが入っており，printfの実体は入っていません． 実際のリンクは実行時にメモリ上で行います．

a.outにはprintfを含まないので，ファイルの使用量を抑えられます． またa.out中のprintfは実行時にはメモリ上で共有されるので， メモリの使用量も抑えられます．

ファイルサイズを比較してみると，静的リンクしたa.out-staticは約870KB， 動的リンクしたa.out-dynamicは約17KBで，50倍ものサイズ差がありました．

$ gcc -static -o a.out-static hello.c
$ gcc -o a.out-dynamic hello.c
$ ls -l a.out*
-rwxrwxr-x 1 gondow gondow  16696 Jul 20 17:52 a.out-dynamic
-rwxrwxr-x 1 gondow gondow 871832 Jul 20 17:51 a.out-static

動的リンクでコンパイルしてみる

Linuxでは-staticオプションをつけなければ動的リンクになります．

$ gcc hello.c
$ file a.out
a.out: ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， interpreter /lib64/ld-linux-x86-64.so.2， BuildID[sha1]=308260da4f7fb6d4116c12670adf6e503637abba， for GNU/Linux 3.2.0， not stripped
$ ./a.out
hello (1)

実行時にリンクが必要な動的ライブラリの情報はlddコマンドで表示できます．

$ ldd ./a.out
	❶linux-vdso.so.1 (0x00007ffd21638000)
	❷libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcfef5c1000)
	❸/lib64/ld-linux-x86-64.so.2 (0x00007fcfef7d8000)

このa.outはlinux-vsdo.so.1，libc.so.6，ld-linux-x86-64.so.2という 3つの動的ライブラリと実行時にリンクする必要があることを表示しています． libc.so.6は（LD_LIBRARY_PATHなどの設定がなければ） 絶対パス/lib/x86_64-linux-gnu/libc.so.6とリンクされます．

$ nm -D /lib/x86_64-linux-gnu/libc.so.6 | egrep ' T printf'
0000000000061c90 T printf
0000000000061100 T printf_size
0000000000061bb0 T printf_size_info

$ nm /lib/x86_64-linux-gnu/libc.so.6
nm: /lib/x86_64-linux-gnu/libc.so.6: ❶no symbols

練習問題：動的にリンクしたa.out中にprintfの実体が無いことを確認せよ

nmコマンドでa.outにはmainを始めごく少数の 関数しか定義しておらず，その中にprintfは入っていないことが以下で確認できます．

$ nm ./a.out | egrep ' T '
00000000000011f8 T _fini
00000000000011f0 T __libc_csu_fini
0000000000001180 T __libc_csu_init
0000000000001149 T main
0000000000001060 T _start

またnmの出力をprintfで検索すると，GLIBC中のprintfへの参照はあるが a.out中では未定義(U)となっていることが分かります．

$ nm ./a.out | egrep 'printf'
                 U printf@@GLIBC_2.34

なお逆アセンブルすると<printf@plt>という小さな関数が見つかりますが， これはprintfの実体ではありません．

$ objdump -d ./a.out | egrep -A 5 "<printf"
0000000000001050 <printf@plt>:
    1050:	f3 0f 1e fa          	endbr64 
    1054:	f2 ff 25 75 2f 00 00 	bnd jmpq ❶*0x2f75(%rip)        # 3fd0 <printf@GLIBC_2.34>
    105b:	0f 1f 44 00 00       	nopl   0x0(%rax，%rax，1)

<printf@plt>はprintfを呼び出す単なる踏み台で， PLT (procedure linkage table)という仕組みです． PLTはprintfの最初の呼び出しまでprintfのアドレス解決 (address resolution)を遅延します．具体的には次の2ステップになります．

• printf@pltの間接ジャンプ先❶の初期値は「動的リンクする関数（動的リンカ）」になっているため，最初にprintf@pltが呼ばれると，動的リンクを行い，その結果，間接ジャンプ先が「printfの実体」に変更されます❷． そして動的リンカは何もなかったかのようにprintfを呼び出します． （ちなみにprintf@pltの間接ジャンプで参照するメモリ領域は GOT (global offset table)と呼ばれます）
• その結果，2回目以降の以下の間接ジャンプ❶では(動的リンカを経由せずに)printfが呼ばれます．

つまり，GOTにprintfのアドレスを格納することが，ここではアドレス解決になっています．

静的ライブラリを作成してみる

// main.c
#include <stdio.h>
int add5 (int n);
int main (void)
{
    printf ("%d\n", add5 (10));
}

// add5.c
int add5 (int n)
{
    return n + 5;
}

$ gcc -c add5.c   
$ ar rcs libadd5.a add5.o  ❶
$ ar t libadd5.a
add5.o  ❷
$ file libadd5.a
libadd5.a: current ar archive
$ gcc ❸-static -o a.out-static main.c ❹-L. ❺-ladd5
$ file a.out-static
file ./a.out-static
./a.out-static: ELF 64-bit LSB executable， x86-64， version 1 (GNU/Linux)， statically linked， BuildID[sha1]=1bf84a77504302513d6219e4b27316309d08ed2d， for GNU/Linux 3.2.0， not stripped
$ ./a.out-static 
15 ❻

• ❶ ar rcsコマンドでadd5.oからlibadd5.aを作成します．
• ❷ ar tコマンドでlibadd5.aの中身を調べます．中身はadd5.oだけでした．
• ❸❹❺ gccでmain.cとlibadd5.aを静的リンクします． 静的リンクするために❸-staticオプションが必要です． libadd5.aがカレントディレクトリにあることを伝えるために❹-L.が必要です． 静的リンクする静的ライブラリがlibadd5.aであることを伝えるために ❺-ladd5が必要です．（前のlibと後の.aは自動的に付加されます）
• ❻ 実行してみると，静的ライブラリlibadd5.a中のadd5関数を呼び出せました．

動的ライブラリを作成してみる

add5.cとmain.cは 前節と同じものを使います．

$ gcc -c add5.c   
$ gcc ❶-fPIC ❷-shared -o libadd5.so add5.o
$ file libadd5.so
libadd5.so: ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， BuildID[sha1]=415ef51f32145b59c51e836a25959f0f66039768， not stripped
$ gcc main.c -ladd5 -L. ❸-Wl，-rpath .
$ file ./a.out
./a.out: ELF 64-bit LSB shared object， x86-64， version 1 (SYSV)， dynamically linked， interpreter /lib64/ld-linux-x86-64.so.2， BuildID[sha1]=a5d4f8ef61cef4e0b063376333f07170d312c546， for GNU/Linux 3.2.0， not stripped
$ ldd ./a.out
	linux-vdso.so.1 (0x00007ffff7fcd000)
	libadd5.so => ❹./libadd5.so (0x00007ffff7fbd000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007ffff7dad000)
	/lib64/ld-linux-x86-64.so.2 (0x00007ffff7fcf000)
$ ./a.out
15 ❺ 

• ❶❷ add5.cから動的ライブラリlibadd5.soを作ります． libadd5.soを位置独立コード(PIC)にするために，❶-fPICが必要です． libadd5.soを共有オブジェクト(shared object)にするために，❷-sharedが必要です．
• ❸ gccでmain.cとlibadd5.soを動的リンクします． 実行時に動的ライブラリを探索するパスを❸-Wl，-rpath .で指定しています． ここではlibadd5.soをカレントディレクトリに置いているためです． （セキュリティ上，実際に使う際は絶対パスを指定する方が安全でしょう）． ちなみに-Wl，-rpath .をgccに指定すると， ldコマンド に-rpath .というオプションが渡されます ．
• ❹ lddコマンドで調べると，a.out中のlibadd5.soは ./libadd5.soを参照していることを確認できました．
• ❺ 実行してみると，動的ライブラリlibadd5.so中のadd5関数を呼び出せました．

$ readelf -d ./a.out | egrep PATH
 0x000000000000001d (RUNPATH)            Library runpath: ❻[.]

$ export LD_RUN_PATH="."
$ gcc main.c -ladd5 -L. 
$ readelf -d ./a.out | egrep PATH
 0x000000000000001d (RUNPATH)            Library runpath: [.]

$ export LD_LIBRARY_PATH="/tmp"
$ cp libadd5.so /tmp
$ ldd ./a.out
	libadd5.so => ❼/tmp/libadd5.so (0x00007ffffffb8000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fffffd8b000)
	/lib64/ld-linux-x86-64.so.2 (0x00007ffffffc4000)

デバッグ情報

デバッグ情報とは

デバッグ情報とはgccに-gオプションをつけると バイナリに付加される情報で， デバッグ時に有用なソースコード中の情報を含んでいます． 例えば，変数の型情報や，ソースコード中の行番号が挙げられます．

$ gcc ❶ -g main.c add5.c
$ file ./a.out
./a.out: ELF 64-bit LSB pie executable， x86-64， version 1 (SYSV)， dynamically linked， interpreter /lib64/ld-linux-x86-64.so.2， BuildID[sha1]=68a01f5977ae542600062913c447a7ba7f2fad62， for GNU/Linux 3.2.0， ❷ with debug_info， not stripped

❶-gオプションをつけてコンパイルしてから，fileコマンドで調べると， ❷デバッグ情報が含まれていることを確認できます．

コンパイラは様々なデバッグ情報の形式を扱えます． LinuxのELFバイナリではDWARFデバッグ情報 が使われることが多いです．(以下，DWARFを前提として説明します)

デバッグ情報が無いと，デバッガでファイル名や行番号が表示されない

デバッグ情報無しでデバッガgdbを使うとどうなるか試してみましょう． add5.cとmain.cは 前節と同じものを使います． (gdbの使い方の詳細はデバッガgdbの使い方を参照下さい)．

$ gcc ❶ main.c add5.c
$ gdb ./a.out
(gdb) ❷ b add5
Breakpoint 1 at 0x1175
(gdb) ❸ r
Starting program: /tmp/a.out 
Breakpoint 1， 0x0000555555555175 in ❹ add5 ()
(gdb) bt
#0 ❻ 0x0000555555555175 in ❺ add5 ()
#1    0x000055555555515b in    main ()
(gdb) quit

-gオプション無しで❶コンパイルしています． add5関数にブレークポイントを設定❷します． ブレークポイントとはプログラムの実行を一時的に停止する場所です． 関数名add5でブレークポイントを指定したので， 実行するとadd5関数の先頭で実行が一時停止します．

❸ runコマンド (rはrunコマンドの省略形)で実行した所， add5関数でブレーク(実行を一時停止)できたのですが， 関数名add5だけが表示され，ファイル名や行番号が表示されません❹． バックトレースを出力しても同様です❺．

バックトレースとは「main関数から現在実行中の関数までの， 関数呼び出し系列」のことです． ここではmain関数がadd5関数を呼び出しただけなので， バックトレースは2行しかありません． ❻0x0000555555555175はadd5関数が 0x0000555555555175番地の機械語命令を実行する直前で実行を停止していることを 示しています．

デバッグ情報があると，デバッガでファイル名や行番号が表示される

今回はデバッグ情報ありでデバッガを使ってみます．

$ gcc ❶ -g main.c add5.c
$ gdb ./a.out
(gdb) b add5
Breakpoint 1 at 0x1175: ❷ file add5.c， line 2.
(gdb) r
Starting program: /tmp/a.out 
Breakpoint 1， add5 (n=10) at ❸ add5.c:2
2	{
(gdb) bt
#0  add5 (n=10) at ❹ add5.c:2
#1  0x000055555555515b in main () at main.c:5

$ gcc ❶ -g main.c add5.c
$ gdb ./a.out
(gdb) b add5
Breakpoint 1 at 0x1183: ❷ file add5.c， line 3.
(gdb) r
Breakpoint 1， add5 (n=10) at ❸ add5.c:3
3	    return n + 5;
(gdb) bt
#0  add5 (n=10) at ❹ add5.c:3
#1  0x000055555555515b in main () at main.c:5

• ❶ -gをつけたので，a.outにはデバッグ情報が付加されています．
• 先程とは異なり，❷❸❹ファイル名add5.cや行番号3が付加されています．

デバッグ情報があると，行番号とアドレスを相互変換できる．

アドレス→行番号の変換

デバッグ情報があるバイナリに対しては， addr2lineコマンドでアドレスを対応する行番号に変換できます．

$ gcc -g main.c add5.c
$ objdump -d ./a.out | egrep -A 4 "<main>:"
0000000000001149 <main>:
    1149:	f3 0f 1e fa          	endbr64 
    114d:	55                   	push   %rbp
    114e:	48 89 e5             	mov    %rsp，%rbp
    1151:	bf 0a 00 00 00       	mov    $0xa，%edi
$  addr2line -e ./a.out ❶ 0x1149
❷/tmp/main.c:4

上の実行例ではaddr2lineコマンドで， 0x1149番地の機械語命令はソースコードでは❷/tmp/main.cの4行目に 対応していることが分かりました．

デバッガ上でも確かめてみましょう．

(gdb) b main
Breakpoint 1 at 0x1151: file main.c， line 5.
(gdb) r
Breakpoint 1， main () at main.c:5
5	    printf ("%d\n"， add5 (10));
(gdb) ❶ disas
Dump of assembler code for function main:
   0x0000555555555149 <+0>:	endbr64 
   0x000055555555514d <+4>:	push   %rbp
   0x000055555555514e <+5>:	mov    %rsp，%rbp
=> 0x0000555555555151 <+8>:	mov    $0xa，%edi
   0x0000555555555156 <+13>:	call   0x555555555178 <add5>
(以下略)
(gdb) ❷ info line *0x0000555555555149 
Line 4 of "main.c" starts at address 0x555555555149 <main>
   and ends at 0x555555555151 <main+8>.
(gdb) ❸ info line main.c:4
Line 4 of "main.c" starts at address 0x555555555149 <main>
   and ends at 0x555555555151 <main+8>.

• (objdumpコマンドでも可能ですが) gdb上でも逆アセンブルできます． 逆アセンブルのコマンドはdisassembleですが長いので， 短縮名disasをここでは使っています． (gdbは他のコマンドと区別できる範囲で，コマンド名を省略できます)． ASLRとPIEが有効な場合， デバッガ上で逆アセンブルすると，実際のメモリのアドレスが表示されて便利です． この場合，上では0x1149番地だったのに， 0x0000555555555149番地に変わっています．
• gdbの❷info lineコマンドを使うと，アドレスから行番号に変換できます． 0x555555555149番地はmain.cの4行目に対応しており， また，この行は機械語命令では0x555555555149番地から0x555555555151に 対応していると表示されています．
• gdb上では❸info lineコマンドを使って， 行番号からアドレスへの変換もできます．

なお，gdbでlayout asmとすると逆アセンブル結果を常に表示できます． ブレークポイント(左端のbやB)や次に実行する機械語命令の位置(>)が 表示されて分かりやすいです．

行番号→アドレスの変換

コマンドライン上で，行番号をアドレスに変換するには (コマンドがちょっと長くなりますが)以下のようにgdbを使います．

$ gdb ./a.out -ex "info line main.c:4" --batch
Line 4 of "main.c" starts at address ❶0x1149 <main> and ends at 0x1151 <main+8>.

上ではプログラムを実行せずにアドレスを取得したので， a.outファイル中のアドレス❶0x1149が表示されています． 実行時のアドレスを表示したいなら，以下のようにします (バッチモードで，b main，run，info line main.c:4という3つのコマンドを実行しています)． 実行時のアドレス❷0x555555555149を表示できました．

$ gdb ./a.out -ex "b main" -ex "r" -ex "info line main.c:4" --batch
Breakpoint 1， main () at main.c:5
5	    printf ("%d\n"， add5 (10));
Line 4 of "main.c" starts at address ❷0x555555555149 <main> and ends at 0x555555555151 <main+8>.

以下のようにline2addrなどの名前でシェル関数を定義すれば， 短く書けます(が，そんなに頻繁には使わないかも)．

$ function line2addr () {
> command gdb $1 -ex "info line $2" --batch
> }
$ line2addr ./a.out main.c:4
Line 4 of "main.c" starts at address 0x1149 <main> and ends at 0x1151 <main+8>.

デバッグ情報があると，逆アセンブル時にソースコードも表示できる

デバッグ情報がある場合， (objdump -dではなく)objdump -Sで逆アセンブルすると ソースコードも表示できます． ❶関数add5の定義部分であること， ❷return n + 5;の行のコンパイル結果であること， などが見やすくなります．

$ gcc -g -c add5.c
$ objdump -S ./add5.o
./add5.o:     file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <add5>:
❶ int add5 (int n)
{
   0:	f3 0f 1e fa          	endbr64 
   4:	55                   	push   %rbp
   5:	48 89 e5             	mov    %rsp，%rbp
   8:	89 7d fc             	mov    %edi，-0x4(%rbp)
 ❷ return n + 5;
   b:	8b 45 fc             	mov    -0x4(%rbp)，%eax
   e:	83 c0 05             	add    $0x5，%eax
}
  11:	5d                   	pop    %rbp
  12:	c3                   	ret    

デバッガでレジスタの値を確認する

デバッガでレジスタの値を確認できます．

$ gcc -g main.c add5.c
$ gdb ./aout
(gdb) b add5
Breakpoint 1 at 0x1183: file add5.c， line 3.
(gdb) r
Breakpoint 1， add5 (n=10) at add5.c:3
3	    return n + 5;
(gdb) p ❶ $rdi
$1 = 10
(gdb) ❷ info reg
Undefined info command: "regs".  Try "help info".
(gdb) info reg
rax            0x555555555149      93824992235849
rbx            0x0                 0
rcx            0x555555557dc0      93824992247232
rdx            0x7fffffffe048      140737488347208
rsi            0x7fffffffe038      140737488347192
rdi            0xa                 10
(以下略，qを押して表示を停止)

• ❶ gdbでは%ではなく$をつけてレジスタ名を指定します． pはprintコマンドの省略名です．%rdiの値が10であることが分かりました． 16進数で表示したい場合は，p/x $rdiと/xをつけます
• ❷ レジスタの値一覧はinfo regで表示できます．ページャが起動されるので，qを押して表示を停止します．

gdbでlayout regsとすると，レジスタの値を常に表示できます．

• layout regsするとレジスタの値一覧が表示されます． 上から「レジスタ表示」「ソースコード表示」「コマンド入力」のためのウィンドウです．
• focus regsや，ctrl-x oなどを入力すると，レジスタ表示ウィンドウが選択されます． この状態で↓キーを押すと(あるいはマウスでスクロールされると） レジスタ表示ウィンドウの表示をスクロールできます．
• ctrl-x aを入力すると，元の表示方法に戻ります．

デバッガでメモリの値を確認する

add5.cとmain.cを を実行し，add5関数のスタックフレームが作成された直後は 以下の図(ここで使った図の再掲) になっています．

これをデバッガで確認しましょう．

$ gcc -g main.c add5.c
$ gdb ./a.out
(gdb) b add5
Breakpoint 1 at 0x1183: file add5.c， line 3.
(gdb) r
Breakpoint 1， add5 (n=10) at add5.c:3
3	    return n + 5;
(gdb) disas
Dump of assembler code for function add5:
   0x0000555555555178 <+0>:	endbr64 
   0x000055555555517c <+4>:	push   %rbp
   0x000055555555517d <+5>:	mov    %rsp，%rbp
   0x0000555555555180 <+8>:	mov    %edi，-0x4(%rbp)
=> 0x0000555555555183 <+11>:	mov    -0x4(%rbp)，%eax
   0x0000555555555186 <+14>:	add    $0x5，%eax
   0x0000555555555189 <+17>:	pop    %rbp
   0x000055555555518a <+18>:	ret    
(gdb) ❶ p/x $rsp
$1 = 0x7fffffffdf10
(gdb) ❷ p/x $rbp
$2 = 0x7fffffffdf10
(gdb) ❸ x/1gx 0x7fffffffdf10
0x7fffffffdf10:	0x00007fffffffdf20
(gdb) ❹ x/1gx $rsp
0x7fffffffdf10:	0x00007fffffffdf20
(gdb) ❺ x/8bx $rsp
0x7fffffffdf10:	0x20 0xdf 0xff 0xff 0xff 0x7f 0x00 0x00

• ❶❷ %rspと%rbpレジスタの値を調べると，どちらも 0x7fffffffdf10番地でした．

• ❸ x/1gx 0x7fffffffdf10 はメモリの中身を表示するコマンドです．

  • xのコマンド名は examine memory から来ています．
  • /1gxは出力形式を指定しています． この場合は「8バイトのデータを16進表記で1つ表示」という意味です．

• ❹ 具体的なアドレス(ここでは0x7fffffffdf10)ではなく， レジスタ名 (ここでは$rsp)を指定して， 　そのレジスタが指しているメモリの中身を表示できます．
• ❺ /1gxではなく/8bxと表示形式を指定すると， 「1バイトのデータを16進表記で8個表示」という意味になります． 0x7FFFFFFFDF10から0x7FFFFFFFDF17までの各番地には，それぞれ， 以下の図の通り， 0x20，0xDF，0xFF，0xFF，0xFF，0x7F，0x00，0x00という値が メモリ中に入っていることが分かります． この格納されている8バイトのデータ0x00007fffffffdf20はアドレスであり， 以下の図の一番下のアドレス(赤字の部分)を指しています．

(上のデバッグの続き)
(gdb) ❻ x/1gx $rsp+8
0x7fffffffdf18:	0x000055555555515b
(gdb) ❼ x/8bx $rsp+8
0x7fffffffdf18:	0x5b	0x51	0x55	0x55	0x55	0x55	0x00	0x00
(gdb) ❽ disas 0x000055555555515b
Dump of assembler code for function main:
   0x0000555555555149 <+0>:	endbr64 
   0x000055555555514d <+4>:	push   %rbp
   0x000055555555514e <+5>:	mov    %rsp，%rbp
   0x0000555555555151 <+8>:	mov    $0xa，%edi
   0x0000555555555156 <+13>:	call   0x555555555178 <add5>
❾ 0x000055555555515b <+18>:	mov    %eax，%esi
   0x000055555555515d <+20>:	lea    0xea0(%rip)，%rax        # 0x555555556004
   0x0000555555555164 <+27>:	mov    %rax，%rdi
   0x0000555555555167 <+30>:	mov    $0x0，%eax
   0x000055555555516c <+35>:	call   0x555555555050 <printf@plt>
   0x0000555555555171 <+40>:	mov    $0x0，%eax
   0x0000555555555176 <+45>:	pop    %rbp
   0x0000555555555177 <+46>:	ret    
End of assembler dump.

• ❻ x/1gxを使って，上の図の8(%rsp)のアドレスの中身を表示させています． 8(%rsp)の意味は「%rspの値に8を足したアドレス」です． gdb中では「$rsp + 8」と入力します．
• ❼ x/8bxを使って，上の図の8(%rsp)のアドレスを1バイトごとに表示しました． 上記の図の通り， 0x7FFFFFFFDF18から0x7FFFFFFFDF1Fまでの各番地には，それぞれ， 0x5B，0x51，0x55，0x55，0x55，0x55，0x00，0x00が 格納されていることが分かりました．
• ❻の結果で得た0x000055555555515b番地を使って❽逆アセンブルしてみると， ❾この番地は「call add5」の次の命令 (この場合は mov %eax， %esi)であることが 分かりました． このように，戻り番地 (return address)は通常， 「その関数を呼び出したcall命令の次の命令のアドレス」になります．

戻り番地が通常ではない場合って?

末尾コール最適化 (tail-call optimization; TCO)が起こった時が該当します．

末尾コール最適化の前

末尾コール最適化後

• 上の「末尾コール最適化の前」の図ではmain関数がAを呼び， 関数AがBを呼んでいます．また逆の順番でリターンします． しかし，call Bの次の命令がret (次の命令❷)になっているため， 関数Bからリターンした後，関数Aでは何もせず，mainにリターンしています．
• そこで「末尾コール最適化の後」の図のように，関数A中のcall命令を 無条件ジャンプ命令 jmpに書き換えて，関数Bからは(Aを経由せず) 直接，main関数のリターンするように書き換えて無駄なリターンを省くことができます． これが末尾コール最適化です．
• その結果，関数Bのリターンアドレスは，関数A中のcall命令の次のアドレス (次の命令❷)ではなく，関数main中の「次の命令❶」となってしまいました． これが戻り番地が通常ではない場合の一例です．

デバッグ情報を直接見る

objdump，readelf，llvm_dwarfdumpコマンドを使うと， デバッグ情報の中身を直接見ることができます．

objdump -W

デバッグ情報には例えば，以下のものがあります

• デバッグ情報 (.debug_info)
• 行情報 (.debug_line)
• アドレス情報 (.debug_aranges)
• フレーム情報 (.eh_frame)
• 省略情報 (.debug_abbrev)

objdump -W add5.o とすると，add5.o中のデバッグ情報を全て表示します -Wi， -Wl， -Wr， -Wf，-Waとすると， それぞれ，デバッグ情報，行情報，アドレス情報，フレーム情報， 省略情報だけを表示できます．

$ objdump -W add5.o | less
add5.o:     file format elf64-x86-64

Contents of the .debug_info section:

  Compilation Unit @ offset 0x0:
   Length:        0x62 (32-bit)
   Version:       5
   Unit Type:     DW_UT_compile (1)
   Abbrev Offset: 0x0
   Pointer Size:  8
 <0><c>: Abbrev Number: 1 (DW_TAG_compile_unit)
    <d>   DW_AT_producer    : (indirect string， offset: 0x5): GNU C17 11.3.0 -mtune=generic -march=x86-64 -g -fasynchronous-unwind-tables -fstack-protector-strong -fstack-clash-protection -fcf-protection
    <11>   DW_AT_language    : 29       (C11)
    <12>   DW_AT_name        : (indirect line string， offset: 0x5): add5.c
(以下略)

上記の出力例では例えば「ファイル名add5.cを省略番号1とします」という情報を含んでいます（詳細は省略し． コンパイル単位 (compile unit)とはファイルのことです．

例えば，以下の部分は 仮引数の情報として「変数名は❻n， ❷add5.cの❸1行目❹15カラム目で宣言されていて， 型は❺<0x5e>を見てね．変数の場所は❻(DW_OP_fbreg: -20)」となってます．

<2><50>: Abbrev Number: 3 (DW_TAG_formal_parameter)
    <51>   DW_AT_name        : ❶ n
    <53>   DW_AT_decl_file   : ❷ 1
    <54>   DW_AT_decl_line   : ❸ 1
    <55>   DW_AT_decl_column : ❹ 15
    <56>   DW_AT_type        : ❺ <0x5e>
    <5a>   DW_AT_location    : 2 byte block: 91 6c ❻ (DW_OP_fbreg: -20)

❻DW_OP_fbreg: -20とは

「CFA (canonical frame address)から -20バイトのオフセットの位置」を意味しています． CFAはDWARFデバッグ情報が定める仮想的なレジスタでCPUごとに異なります． x86-64の場合は「call命令を実行する直前の%rspの値」なので，以下になります． (call命令が戻り番地をスタックにプッシュすることを思い出しましょう)． 引数n(下図で赤い部分)の先頭アドレスは， CFAからちょうど-20バイトの場所にあることが確認できました．

-fomit-frame-pointerでコンパイルされていなければ， (通常は関数の先頭でpush %rbpするので)以下の式が成り立ちます．

CFA == %rbp + 16

なお，fbreg は frame base registerの略だと思います．

$ objdump -Wi add5.o
(一部略)
<1><5e>: Abbrev Number: ❶4 (DW_TAG_base_type)
    <5f>   DW_AT_byte_size   : 4
    <60>   DW_AT_encoding    : 5         (signed)
    <61>   DW_AT_name        : int

$ objdump -Wa add5.o
(一部略)
❷4 ❸DW_TAG_base_type    [no children]
    DW_AT_byte_size    DW_FORM_data1
    DW_AT_encoding     DW_FORM_data1
  ❹DW_AT_name       ❺DW_FORM_string
    DW_AT value: 0     DW_FORM value: 0

LEB128とは

LEB128 (little endian base 128)は任意の大きさの整数を扱える 可変長の符号化方式です．直感的にはLEB128はUTF-8の整数版です．

LEB128はDWARFやWebAssemblyなどで使われています． (ですので，DWARFデバッグ情報にはLEB128の符号化が使われている箇所があります． デバッグ情報の16進ダンプを解析する際は注意しましょう)．

LEB128には符号ありと符号なしの2種類がありますが，以下では符号なしで説明します．

ここでは123456を符号なしLEB128形式に変換します． 結果は最下位バイトから，0xC0，0xC4，0x07の3バイトになります． まずbcコマンドで2進数にします❶．

$ bc
obase=2
123456
❶ 11110001001000000

次に以下のステップを踏みます．

ステップ1

ステップ2

ステップ3

ステップ4

ステップ4の結果をbcコマンドで16進数にします❷．

$ bc
obase=16
ibase=2
000001111100010011000000
❷ 7C4C0

結果の16進数❷0x7C4C0 を1バイトごとに最下位バイトから出力すると， 最終的な結果は0xC0，0xC4，0x07となります． LEB128の最上位バイトの最上位ビットは必ず0で， それ以外のバイトはの最上位ビットは1なので， サイズ情報がなくても， 元の整数に戻す際，どのバイトまで処理すればよいかが分かります．

型の情報<0x5e>は以下にありました． 「サイズは❼ 4バイト，❽符号あり，型名は❾int」です．

<1><5e>: Abbrev Number: 4 (DW_TAG_base_type)
    <5f>   DW_AT_byte_size   : ❼ 4
    <60>   DW_AT_encoding    : 5        ❽ (signed)
    <61>   DW_AT_name        : ❾ int

またデバッグ情報情報があちこちに散っています． 例えば，❷「ファイル1」の情報はどこにあるかというと

    <53> ❷ DW_AT_decl_file   : 1

行情報にありました． 以下でエントリ1の情報を見ると，add5.cと分かりました．

$ objdump -Wl add5.o | less
(中略)
The File Name Table (offset 0x2c, lines 2, columns 2):
  Entry Dir     Name
  0     0       (indirect line string, offset: 0x11): add5.c
  1     0       (indirect line string, offset: 0x18): add5.c

readelf

readelfコマンドでもobjdumpと同様にDWARFデバッグ情報を表示できます． 以下は実行例です．

$ readelf -wi ./add5.o
Contents of the .debug_info section:

  Compilation Unit @ offset 0x0:
   Length:        0x62 (32-bit)
   Version:       5
   Unit Type:     DW_UT_compile (1)
   Abbrev Offset: 0x0
   Pointer Size:  8
 <0><c>: Abbrev Number: 1 (DW_TAG_compile_unit)
    <d>   DW_AT_producer    : (indirect string, offset: 0x5): GNU C17 11.3.0 -mtune=generic -march=x86-64 -g -fasynchronous-unwind-tables -fstack-protector-strong -fstack-clash-protection -fcf-protection
    <11>   DW_AT_language    : 29       (C11)
    <12>   DW_AT_name        : (indirect line string, offset: 0x5): add5.c
    <16>   DW_AT_comp_dir    : (indirect line string, offset: 0x0): /tmp
    <1a>   DW_AT_low_pc      : 0x0
    <22>   DW_AT_high_pc     : 0x13
    <2a>   DW_AT_stmt_list   : 0x0
(以下略)

メモリマップを見る

pmapコマンドでメモリマップを見る

pmapコマンドを使うと， 実行中のプログラム(プロセス)がどのメモリ領域を使用しているか (メモリマップ)を調べられます． (この出力は/procファイルシステムの /proc/プロセス番号/mapsの内容から作られています)．

$ cat 
❶ ^Z   
[1]+  Stopped                 cat
$ ps | egrep cat
❷  7687 pts/0    00:00:00 cat
$ ❸ pmap 7687
7687:   cat
❼000055f74daf2000      8K r---- cat
❼000055f74daf4000     16K r-x-- cat
❼000055f74daf8000      8K r---- cat
❼000055f74dafa000      4K r---- cat
❼000055f74dafb000      4K rw--- cat
000055f74dafc000    132K rw---   [ anon ]
00007f63a7e00000   6628K r---- locale-archive
00007f63a8600000    160K r---- libc.so.6
00007f63a8628000   1620K r-x-- libc.so.6
00007f63a87bd000    352K r---- libc.so.6
00007f63a8815000     16K r---- libc.so.6
00007f63a8819000      8K rw--- libc.so.6
00007f63a881b000     52K rw---   [ anon ]
00007f63a8829000    148K rw---   [ anon ]
00007f63a885d000      8K rw---   [ anon ]
00007f63a885f000      8K r---- ld-linux-x86-64.so.2
00007f63a8861000    168K r-x-- ld-linux-x86-64.so.2
00007f63a888b000     44K r---- ld-linux-x86-64.so.2
00007f63a8897000      8K r---- ld-linux-x86-64.so.2
00007f63a8899000      8K rw--- ld-linux-x86-64.so.2
❹ 00007fff86f9f000 132K ❺rw---   ❻[ stack ]
00007fff86ff8000     16K r----   [ anon ]
00007fff86ffc000      8K r-x--   [ anon ]
ffffffffff600000      4K --x--   [ anon ]
 total             9560K
$ fg
❽ ^D

• まず catコマンドを起動します．ファイル名を指定していないので， 標準入力からの入力待ちになります． ここで❶ ctrl-z を入力して，catコマンドの実行を中断 (suspend)します． pmapコマンドは実行中のプロセスにしか実行できないため， catコマンドが実行中のまま終了しないように，こうしています．

• 次にpsコマンドでcatコマンドのプロセス番号を調べます． ❷7687がプロセス番号と分かりました．

• ❸プロセス番号7687を引数としてpmapコマンドを実行します．

• 出力の各行が使用中のメモリ領域の情報を示しています．例えば，❹の行は次を意味しています．

  ❹ 00007fff86f9f000 132K ❺rw--- ❻[ stack ]

  • ❹アドレス`00007fff86f9f000'からサイズ132KBの領域を使用している．
  • このメモリ領域の❻アクセス権限は読み書きが可能で，実行は不可．
    • r 読み込み可能
    • w 書き込み可能
    • x 実行可能
  • このメモリ領域は❻スタックとして使用している

• catコマンド自身は以下の5つのメモリ領域を使用しています．

  ❼000055f74daf2000      8K r---- cat
  ❼000055f74daf4000     16K r-x-- cat
  ❼000055f74daf8000      8K r---- cat
  ❼000055f74dafa000      4K r---- cat
  ❼000055f74dafb000      4K rw--- cat
  

  • アクセス権限が r-x--のものは，.textセクションでしょう． (.textセクションは通常，実行可能かつ書き込み禁止にするからです)
  • アクセス権限が rw----のものは，.dataセクションでしょう． (.dataセクションは通常，実行禁止かつ書き込み可能にするからです)
  • 残りの3つのアクセス権限が r---- のものは，.rodataセクションなどでしょう． (詳細は調べていません)
  • 使用しているサイズが4KBの倍数なのは，x86-64でよくある ページ(page)サイズが4KBだからです． (ページとは仮想記憶方式の1つであるページングで使われる， 固定長(例えば4KB)に区切ったメモリ領域のことです)． プロセスはmmapシステムコールを使って，OSからページ単位でメモリを割り当ててもらい，その際にページごとにアクセス権限を設定できます．

• 最後に❽で，中断していたcatコマンドをfgコマンドで実行を再開し， ctrl-Dを入力してcatコマンドの実行を終了しています．

gdbでメモリマップを見る

gdbでもメモリマップを見ることができます

$ gdb /usr/bin/cat
(gdb) r
ctrl-z
Program received signal SIGTSTP, Stopped (user).
(gdb) info proc map
process 7821
Mapped address spaces:

          Start Addr           End Addr       Size     Offset  Perms  objfile
      0x555555554000     0x555555556000     0x2000        0x0  r--p   /usr/bin/cat
      0x555555556000     0x55555555a000     0x4000     0x2000 ❶r-xp   /usr/bin/cat
      0x55555555a000     0x55555555c000     0x2000     0x6000  r--p   /usr/bin/cat
      0x55555555c000     0x55555555d000     0x1000     0x7000  r--p   /usr/bin/cat
      0x55555555d000     0x55555555e000     0x1000     0x8000  rw-p   /usr/bin/cat
      0x55555555e000     0x55555557f000    0x21000        0x0  rw-p   [heap]
      0x7ffff7400000     0x7ffff7a79000   0x679000        0x0  r--p   /usr/lib/locale/locale-archive
      0x7ffff7c00000     0x7ffff7c28000    0x28000        0x0  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7c28000     0x7ffff7dbd000   0x195000    0x28000  r-xp   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7dbd000     0x7ffff7e15000    0x58000   0x1bd000  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7e15000     0x7ffff7e19000     0x4000   0x214000  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7e19000     0x7ffff7e1b000     0x2000   0x218000  rw-p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7e1b000     0x7ffff7e28000     0xd000        0x0  rw-p   
      0x7ffff7f87000     0x7ffff7fac000    0x25000        0x0  rw-p   
      0x7ffff7fbb000     0x7ffff7fbd000     0x2000        0x0  rw-p   
      0x7ffff7fbd000     0x7ffff7fc1000     0x4000        0x0  r--p   [vvar]
      0x7ffff7fc1000     0x7ffff7fc3000     0x2000        0x0  r-xp   [vdso]
      0x7ffff7fc3000     0x7ffff7fc5000     0x2000        0x0  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7fc5000     0x7ffff7fef000    0x2a000     0x2000  r-xp   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7fef000     0x7ffff7ffa000     0xb000    0x2c000  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7ffb000     0x7ffff7ffd000     0x2000    0x37000  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7ffd000     0x7ffff7fff000     0x2000    0x39000  rw-p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffffffde000     0x7ffffffff000    0x21000        0x0  rw-p   [stack]
  0xffffffffff600000 0xffffffffff601000     0x1000        0x0  --xp   [vsyscall]

再配置情報

再配置情報の概要

再配置情報(relocation information)とは「後でアドレス調整する時のために， 機械語命令中のどの場所をどんな方法で書き換えればよいか」を表す情報です． オブジェクトファイル*.oは一般的に再配置情報を含んでいます．

// asm/reloc-main.c
#include <stdio.h>
extern int x;
int main ()
{
    printf ("%d\n", x);
}

// asm/reloc-sub.c
int x = 999;

例えば，上のreloc-main.cと reloc-sub.cを見て下さい． reloc-main.c中で参照している変数xの実体はreloc-main.c中には無く， 実体はreloc-sub.c中にあります．

ですので，reloc-main.s中の movq x(%rip), %eaxをアセンブルしてreloc-main.oを作っても， この時点ではxのアドレスが不明なので，仮のアドレス(上図では00 00 00 00) にするしかありません． そこで，このmovq x(%rip), %eax命令に対する再配置情報として 「この命令の2バイト目から4バイトを4バイト長の%rip相対アドレスで埋める」 という情報(R_X86_64_PC32，後述)を reloc-main.o中に保持しておき，リンク時に正しいアドレスを埋め込むのです．

$ gcc -c reloc-main.c
$ gcc -c reloc-sub.c
$ gcc reloc-main.o reloc-sub.o

reloc-main.oとreloc-sub.oをリンクしてa.outを作ると， (様々な*.o中のセクションを一列に並べることで) 変数xのアドレスが0x4010に決まり， 上図の「次の命令」のアドレスも0x1157に決まりました． 仮のアドレスに埋めたかったのは，%rip相対番地でしたので， 0x4010-0x1157=0x2EB9と計算した0x2EB9番地を仮のアドレスの部分に埋めました． これが再配置です．

様々な*.o中のセクションを一列に並べることで，とは

例えば上図でfoo2.o中の変数xのアドレスは仮アドレス0x1000ですが， foo1.oとfoo2.o中のセクションを1列に並べると， リンク後は「a.outの先頭アドレスが(例えば)0x4000なので，先頭から数えると， (0x4000 + 0x0500 + 0x1000 = 0x5500という計算をして) 変数xのアドレスは0x5500に決まりますよね」という話です．

objdump -dr で再配置情報を見てみる

$ gcc -g -c reloc-main.c
$ objdump -dr reloc-main.o
./reloc-main.o:     file format elf64-x86-64
Disassembly of section .text:

0000000000000000 <main>:
   0:	f3 0f 1e fa          	endbr64 
   4:	55                   	push   %rbp
   5:	48 89 e5             	mov    %rsp,%rbp
   8:	8b 05 ❶ 00 00 00 00    mov    0x0(%rip),%eax        # e <main+0xe>
		❷ a: R_X86_64_PC32	x-0x4
   e:	89 c6                	mov    %eax,%esi
  10:	48 8d 05 ❸ 00 00 00 00 	lea    0x0(%rip),%rax        # 17 <main+0x17>
		❹ 13: R_X86_64_PC32	.rodata-0x4
  17:	48 89 c7             	mov    %rax,%rdi
  1a:	b8 00 00 00 00       	mov    $0x0,%eax
  1f:	e8 00 00 00 00       	call   24 <main+0x24>
			20: R_X86_64_PLT32	printf-0x4
  24:	b8 00 00 00 00       	mov    $0x0,%eax
  29:	5d                   	pop    %rbp
  2a:	c3                   	ret    

前節の説明を，実際に再配置情報を見ることで確かめます． 上の実行例はobjdump -drでreloc-main.oの逆アセンブルの結果と 再配置情報の両方を表示させたものです．

• ❶を見ると図の通り，仮のアドレス 00 00 00 00 を確認できます．
• ❷のa: R_X86_64_PC32 x-0x4が再配置情報です．
  • aは仮のアドレスを書き換える場所(.textセクションの先頭からのオフセット)です． 命令mov 0x0(%rip), %eaxの先頭のオフセットが0x8なので， 0x8に2を足した値が0xaとなっています (このmov命令の最初の2バイトはオペコード)．
  • R_X86_64_PC32は再配置の方法を表しています． 「%rip相対アドレスで4バイト(32ビット)としてアドレスを埋める」ことを意味しています． (PCはプログラムカウンタ，つまり%ripを使うことを意味しています)．
  • x-0x4は「変数xのアドレスを使って埋める値を計算せよ． その際に-0x4を足して調整せよ」を意味しています．

0x4010 + (-4) - (0x1157 - 4) = 0x2EB9

• ❸は"%d\n"という文字列の仮アドレス，❹はその仮アドレスの再配置情報です． ❶❷と同様です．

readelf -rで再配置情報を見てみる

$ readelf -r reloc-main.o | less
Relocation section '.rela.text' at offset 0x5b0 contains 3 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
00000000000a  000a00000002 R_X86_64_PC32     0000000000000000 x - 4
000000000013  000300000002 R_X86_64_PC32     0000000000000000 .rodata - 4
000000000020  000b00000004 R_X86_64_PLT32    0000000000000000 printf - 4
(略)

readelf -rでもobjdump -drと同様の結果が得られます．

PLTの再配置情報

printfの再配置情報も見てみましょう．

$ objdump -dr ./reloc-main.o
./reloc-main.o:     file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <main>:
   0:   f3 0f 1e fa             endbr64 
   4:   55                      push   %rbp
   5:   48 89 e5                mov    %rsp,%rbp
   8:   8b 05 00 00 00 00       mov    0x0(%rip),%eax        # e <main+0xe>
                        a: R_X86_64_PC32        x-0x4
   e:   89 c6                   mov    %eax,%esi
  10:   48 8d 05 00 00 00 00    lea    0x0(%rip),%rax        # 17 <main+0x17>
                        13: R_X86_64_PC32       .rodata-0x4
  17:   48 89 c7                mov    %rax,%rdi
  1a:   b8 00 00 00 00          mov    $0x0,%eax
  1f:   e8 ❶ 00 00 00 00       call   24 <main+0x24>
             ❷ 20: R_X86_64_PLT32      printf-0x4
  24:   b8 00 00 00 00          mov    $0x0,%eax
  29:   5d                      pop    %rbp
  2a:   c3                      ret    

$ objdump -d ./a.out
0000000000001149 <main>:
    1149:       f3 0f 1e fa             endbr64 
    114d:       55                      push   %rbp
    114e:       48 89 e5                mov    %rsp,%rbp
    1151:       8b 05 b9 2e 00 00       mov    0x2eb9(%rip),%eax        # 4010 <x>
    1157:       89 c6                   mov    %eax,%esi
    1159:       48 8d 05 a4 0e 00 00    lea    0xea4(%rip),%rax        # 2004 <_IO_stdin_used+0x4>
    1160:       48 89 c7                mov    %rax,%rdi
    1163:       b8 00 00 00 00          mov    $0x0,%eax
    1168:     ❸e8 e3 fe ff ff          call   1050 <printf@plt>
    116d:       b8 00 00 00 00          mov    $0x0,%eax
    1172:       5d                      pop    %rbp
    1173:       c3                      ret    

先程のxの場合とほぼ同じです．

• ❶を見ると図の左側の通り，仮のアドレス 00 00 00 00 を確認できます．
• ❷の20: R_X86_64_PLT32 printf-0x4が再配置情報です．
  • 20は仮のアドレスを書き換える場所(オフセット)です．
  • R_X86_64_PLT32は再配置の方法を表しており 「printf@pltへの%rip相対アドレス (4バイト(32ビット))を埋める」ことを意味しています．
  • printf-0x4は「変数printf@pltのアドレスを使って埋める値を計算せよ． その際に-0x4を足して調整せよ」を意味しています．

0x1050 + (-4) - (0x116D - 4) = -0x11D = 0xFFFFFEE3

• a.out中では「次の命令」が0x116D番地，printf@pltが0x1050番地と決まったので，0x1050 - 0x116D = -0x11D = 0xFFFFFEE3番地が ❸の部分に埋め込まれました．

ここでも説明した通り， printfの実体はCライブラリの中にあり， (gccのデフォルト動作である)動的リンクの場合， PLTとGOTの仕組みを使って，printfを呼び出します． これは先程のxの場合は 「(main関数中の)次の命令と変数xの相対アドレスは固定で決まる」のに対して， printfの場合は固定で決まらないからです (Cライブラリが実行時に何番地にロードされるか不明だから)．

そこで，

• main関数中では(printfを直接呼ぶのではなく)， (printfのための踏み台である)printf@pltを呼び出す．
• printf@pltはGOT領域に実行時に書き込まれるprintfのアドレスを使い， 間接ジャンプ (上図ではbnd jmp *0x2f75(%rip))して， 本物のprintfを呼び出す．

という仕組みになっています．

ABI と API

ABIとAPIはどちらも互換性のための規格(お約束)ですが， 対象がそれぞれ，バイナリ，ソースコード，と異なります．

ABI

• ABI = Application Binary Interface
• バイナリコードのためのインタフェース規格．
• 同じABIをサポートするシステム上では再コンパイル無しで 同じバイナリを使ったり実行できる．
• ABIはコーリングコンベンション(関数呼び出し規約, calling convention)， バイトオーダ，アラインメント，バイナリ形式などを定める
• Linux AMD64のABI はSystem V ABI (AMD64)

API

• API = Application Programming Interface
• ソースコードのためのインタフェース規格
• 同じAPIをサポートするシステム上では再コンパイルすれば 同じソースコードを実行できる．
• 例えば，POSIXはUNIXのAPIであり，LinuxはPOSIXにほぼ準拠している．
  POSIXはシステムコール，ライブラリ関数，マクロなどの形式や意味を定めている
  • POSIXはここに書いてあるとおり，opengroup.orgに登録することで無料で入手可能

アーキテクチャ

一般的なコンピュータの構成要素

コンピュータの基本構造

• コンピュータでは上図のように，CPU，メインメモリ(以後，単にメモリ)， 入出力装置が，バス(bus)と呼ばれる信号線でつながっています．

• CPUは制御装置，ALU(演算装置)，レジスタから構成されています

• バスはデジタルの信号線です． アドレスバス，データバス，制御バスがあります(図にはこの区別は書いていません)．

• 上図にはキャッシュやMMUなどがありませんが， 本書の範囲ではこの図の知識で十分です．

CPUの基本構成

• 制御装置 = フェッチ実行サイクルをひたすら繰り返します
• ALU = 四則演算や論理演算などを計算します
• レジスタ
  • 高速・小容量・固定長のメモリです
  • 特定の役割を持つ専用レジスタ(例: プログラムカウンタ%rip)と， 様々な用途に使える汎用レジスタ(例: %rax)に概ね分かれています．

メモリ

• メモリはRAMです．揮発性があります(電源が切れると記憶内容は失われます)．
• メモリは巨大なバイトの配列です
  • メモリのアドレスを指定して，メモリの内容を読み書きします
  • バイト単位だけでなく，4バイトや8バイトなどの連続するメモリ領域も読み書きできます
• 通常，メモリには1バイトごとに連番のアドレスがつきます これをバイトアドレッシングといいます．

実際の物理アドレスには，RAMだけでなく，ROMや memory-mapped I/O (メモリのアドレスを使ってアクセスする入出力装置，例えばVRAM)も マップされています．ただし，これらは通常はユーザプロセスからは見えないので気にしなくて良いです．

フェッチ実行サイクル

• CPUは次の動作をひたすら繰り返します

  1. フェッチ(fetch)
  • プログラムカウンタ(%rip)が指す機械語命令を メモリからCPUに読み込みます
  • 次の機械語命令を指すように，プログラムカウンタの値を増やします
  2. デコード(decode)
  • 読み込んだ命令を解析して，実行の準備をします
  • 例えば，必要ならメモリからオペランドの値をCPUに読み込みます
  3. 実行(execute)
  • 読み込んだ機械語命令を実行します

x86-64のレジスタ

汎用レジスタ

• 上記16個のレジスタが汎用レジスタ(general-purpose register)です． 原則として，プログラマが自由に使えます．
• ただし，%rspはスタックポインタ，%rbpはベースポインタと呼び， 一番上のスタックフレームの上下を指す という役割があります． (ただし，-fomit-frame-pointer オプションでコンパイルされたa.out中では，%rbpはベースポインタとしてではなく， 汎用レジスタとして使われています)．

caller-save/callee-saveレジスタ

引数

プログラムカウンタ（命令ポインタ）

ステータスレジスタ（フラグレジスタ）

本書で扱うフラグ

ステータスレジスタのうち，本書は以下の6つのフラグを扱います． フラグの値が1になることを「フラグがセットされる」「フラグが立つ」と表現します． またフラグの値が0になることを「フラグがクリアされる」「フラグが消える」と表現します．

CFフラグが立つ例

# asm/cf.s
    .text
    .globl main
    .type main, @function
main:
    movb $0xFF, %al
    addb $1, %al  # オーバーフローでCFが立つ
    ret
    .size main, .-main

$ gcc -g cf.s
$ gdb ./a.out
(gdb) b 8
Breakpoint 1 at 0x112d: file cf.s, line 8.
(gdb) r
Breakpoint 1, main () at cf.s:8
8	    ret
(gdb) p $al
$1 = ❶ 0
(gdb) p $eflags
$2 = [ ❷ CF PF AF ZF IF ]
(gdb) quit

• movb $0xFF, %alとaddb $1, %alで，1バイト符号なし整数の加算0xFF+1をすると，オーバーフローが起きて%alの値は❶ 0になります． (1バイト符号なし整数の範囲は0〜255です．0xFF+1は255+1=256となり (1バイト符号なし整数として)オーバーフローが起きています)．
• p $eflagsでステータスフラグを調べると，❷ CF フラグが立っています．

OFフラグが立つ例

# asm/of.s
    .text
    .globl main
    .type main, @function
main:
    movb $0x7F, %al
    addb $1, %al  # オーバーフローでOFが立つ
    ret
    .size main, .-main

$ gcc -g of.s
$ gdb ./a.out
(gdb) b main
Breakpoint 1 at 0x1129: file of.s, line 6.
(gdb) r
Breakpoint 1, main () at of.s:6
6	    movb $0x7F, %al
(gdb) si
7	    addb $1, %al  # オーバーフローでOFが立つ
(gdb) si
main () at of.s:8
8	    ret
(gdb) p $al
$1 = ❶ -128
(gdb) p $eflags
$1 = [ AF SF IF ❷ OF ]
(gdb) ❸ p/u $al
$2 = ❹ 128
(gdb) quit

• movb $0x7F, %alとaddb $1, %alで，1バイト符号あり整数の加算0x7F+1をすると，オーバーフローが起きて%alの値は❶ -128になります． (1バイト符号あり整数の範囲は-128〜127です．0x7F+1は127+1=128となり (1バイト符号あり整数として)オーバーフローが起きています)．
• p $eflagsでステータスフラグを調べると，❷ OF フラグが立っています．
• なお，符号なし(❸u)オプションをつけて%alレジスタの値を表示させると， 符号なしの結果として正しい❹ 128という結果になりました． (x86-64は符号なし・符号ありを区別せず，どちらに対しても正しい結果を 計算します)．
• ここで説明する通り， 符号あり整数のオーバーフローは未定義動作になるので， 符号あり整数のオーバーフローを起こすプログラムは書いてはいけません．

レジスタの別名

%raxレジスタの別名 (%rbx, %rcx, %rdxも同様)

• %raxの下位32ビットは%eaxとしてアクセス可能
• %eaxの下位16ビットは%axとしてアクセス可能
• %axの上位8ビットは%ahとしてアクセス可能
• %axの下位8ビットは%alとしてアクセス可能

# asm/reg.s
    .text
    .globl main
    .type main, @function
main:
    movq $0x1122334455667788, %rax # ❶
    ret
    .size main, .-main

$ gcc -g reg.s
$ gdb ./a.out
(gdb) b main
Breakpoint 1 at 0x1129: file reg.s, line 6.
(gdb) r
Breakpoint 1, main () at reg.s:6
6	    movq $0x1122334455667788, %rax
(gdb) si
main () at reg.s:7
7	    ret
(gdb) p/x $rax
$1 = ❷ 0x1122334455667788
(gdb) p/x $eax
$2 = ❸ 0x55667788
(gdb) p/x $ax
$3 = ❹ 0x7788
(gdb) p/x $ah
$4 = ❺ 0x77
(gdb) p/x $al
$5 = ❻ 0x88
(gdb) q

%rbpレジスタの別名 (%rsp, %rdi, %rsiも同様)

• %rbpの下位32ビットは%ebpとしてアクセス可能
• %ebpの下位16ビットは%bpとしてアクセス可能
• %bpの下位8ビットは%bplとしてアクセス可能

%r8レジスタの別名 (%r9〜%r15も同様)

• %r8の下位32ビットは%r8dとしてアクセス可能
• %r8dの下位16ビットは%r8wとしてアクセス可能
• %r8wの下位8ビットは%r8bとしてアクセス可能

同時に使えない制限

• 一部のレジスタは%ah, %bh, %ch, %dhと一緒には使えない．
• 例：movb %ah, (%r8) や movb %ah, %bplはエラーになる．
• 正確にはREXプリフィクス付きの命令では，%ah, %bh, %ch, %dhを使えない．

32ビットレジスタ上の演算は64ビットレジスタの上位32ビットをゼロにする

• 例:movl $0xAABBCCDD, %eaxを実行すると%raxの上位32ビットが全てゼロになる
• 例: movw $0x1122, %axやmovb $0x11, %alでは上位をゼロにすることはない

上位32ビットをゼロにする実行例

# asm/zero-upper32.s
    .text
    .globl main
    .type main, @function
main:
    movq $0x1122334455667788, %rax
    movl $0xAABBCCDD, %eax
    movq $0x1122334455667788, %rax
    movw $0x1122, %ax
    movq $0x1122334455667788, %rax
    movb $0x11, %al
    ret
    .size main, .-main

# zero-upper32.txt
b 7
r
list 6,7
p/z $rax
si
p/z $rax
echo # 以下が出力されれば成功\n
echo # $1 = 0x1122334455667788 (%raxは8バイトの値を保持)\n
echo # $2 = 0x00000000aabbccdd (%raxの上位4バイトがゼロになった)\n
quit

$ gcc -g zero-upper32.s
$ gdb ./a.out -x zero-upper32.txt
Breakpoint 1, main () at zero-upper32.s:7
7	    movl $0xAABBCCDD, %eax
6	    movq $0x1122334455667788, %rax
7	    movl $0xAABBCCDD, %eax
$1 = 0x1122334455667788
8	    movq $0x1122334455667788, %rax
$2 = 0x00000000aabbccdd
# 以下が出力されれば成功
# $1 = 0x1122334455667788 (%raxは8バイトの値を保持)
# $2 = 0x00000000aabbccdd (%raxの上位4バイトがゼロになった)

オペレーティングシステムの存在

OSは邪魔!?

• アセンブリ言語の利点はCPUや 周辺機器のハードウェア(入出力装置)がよく見えることです
• でもユーザプロセス(皆さんが普通に実行しているプログラム)は OS上で動作するので，OSはCPUやハードウェアの詳細を見せない働きをします
  • この抽象化のおかげで，通常のアプリケーションを開発する際に， CPUやハードウェアの詳細を気にすること無くプログラミングできるわけですが．
• 例えば，OSは以下を隠しています．以下でもう少し詳しく説明します．
  • OSによるマルチタスク処理: ユーザプロセスはCPUを専有しているように見えます．
  • ハードウェアの詳細(例: ハードディスク): ユーザプロセスはシステムコール経由でハードウェア等にアクセスします．
  • 物理メモリ: ユーザプロセスは仮想メモリのみアクセス可能で， 物理メモリへの直接アクセスはできません．
  • 割り込み (interrupt): ハードウェアがCPUに非同期的に(asyncronously)送る信号が割り込みです． ユーザプロセスが割り込みを直接受け取ることはありません． 　　

OSによるマルチタスク処理

• ユーザプロセスから見ると「ずっとCPUやレジスタを専有している」ように見えます．
• メモリはユーザプロセスごとに割り当てられますが， CPUの数は少ないので，OSはCPU上で実行するユーザプロセスを定期的に切り替えています．
  • このユーザプロセスの切り替えにはタイマー割り込みを使っています． タイマー割り込みが発生すると，OSがブート時に設定した割り込みハンドラを CPUが自動的に起動します．
  • その際，ユーザプロセスが使っていたCPUのレジスタ値はメモリに退避します． 実行再開時にはレジスタ値をメモリから回復します．
• ユーザプロセスのプログラムを書く時は， マルチタスクのことを気にする必要はありません(ただしリアルタイムシステムなどは除く)．

システムコール

• ユーザプロセスは直接，周辺機器のハードウェアを操作できません． ユーザプロセスが直接操作するのは面倒だし危険なので， 通常，OSが「ユーザプロセスによるハードウェア操作」を禁止しているからです．
  • (Linuxではシステムコールiopermやioplを使って， この禁止を解除できますが，本書では説明しません)．
• そのため，ユーザプロセスはシステムコールを使って， ハードウェア操作をカーネル(OS本体)に依頼します．
  • ユーザプロセスが動作するアドレス空間をユーザ空間， カーネルが動作するアドレス空間をカーネル空間と呼びます． カーネル空間ではCPUの特権命令の実行やハードウェア操作が可能です．
  • printfなどのライブラリ関数の呼び出しにはcall命令とret命令を使います． 一方，writeなどのシステムコールの呼び出しは トラップ命令(ソフトウェア割り込み命令)である， syscall/sysret，sysenter/sysexit，int/iretなどを使います． システムコールの呼び出しにはユーザ空間からカーネル空間への切り替えが 必要だからです．
• システムコール内では入出力命令(in, out, mov)を実行することで ハードウェアの操作を行います． ハードウェア側から来る割り込みは，予めOSが設定した割り込みハンドラが対処します． ユーザ空間ではCPUの特権命令を実行できないので， ユーザプロセス内では(iopermやioplを使わない限り)これらの操作をできません．

仮想メモリ

• OSはx86-64のページング機能などを使って仮想メモリを有効化しています．
  • 上図でプロセスAとプロセスBは物理メモリの一部を仮想メモリとして (仮想アドレスを使って)アクセスできる状態です．
  • printfはプロセスAとプロセスBで共有しています．
  • 共有しているprintf以外は，プロセスはお互いに他のプロセスのメモリの中身にアクセスできません．

• 仮想メモリが有効な状態では， CPUが扱うアドレス(%ripやメモリ参照でアクセスするアドレス) はすべて仮想アドレスです． CPU上で動作するプログラム(a.out)は 物理メモリのアドレスを使ってのアクセスはできません．

• 仮想アドレスから物理アドレスへの変換:

  • OSは「仮想アドレスと物理アドレスの対応表」であるページテーブルを 　物理メモリ上で管理します．
  • 実際の変換はCPUとバスの間にあるMMU(memory management unit)が高速に行います． MMUはCPUから仮想アドレスを受け取り，それを物理アドレスに変換してから， バス上で物理アドレスを使って物理メモリにアクセスします．

割り込みとシグナル

• CPUはバスを介して周辺機器とつながってます． 例えば，キーボードのキーを押すと，キーを押すたび，離すたびに， CPUに割り込みを伝えます．
• 割り込み(interrupt)は周辺機器側からCPUに非同期的(asynchronously)に 送る信号です．
• CPUは割り込みを受け取ると，(ブート時にOSが設定した)割り込みハンドラを自動的に 起動して，その割り込みに対処します．
• 一部の割り込みはユーザプロセスにUNIXシグナルとして配送されます． 例えば，ユーザプロセスはタイマー割り込みを直接，受け取ることはできませんが， (alarmやsetitimerなどのシステムコールを使えば) SIGALRMというUNIXシグナルを受け取ることができます．

バイナリ(2進数)でのデータ表現

2進数と符号化

ここでも説明しましたが， コンピュータの中のデータは，どんな種類のデータ(例えば，整数，文字， 音声，画像)であっても， 機械語命令であっても，すべて0と1だけで表現されています．

そして，そのためにデータの種類ごとに2進数での表現方法，つまり符号化 (encoding)の方法が定められています． 例えば，

• 文字UをASCII文字として符号化すると，01010101になります．
• pushq %rbpをx86-64の機械語命令として符号化すると，01010101になります．

おや，どちらも同じ01010101になってしまいました． この2進数がPなのかpushq %rbpなのか，どうやって区別すればいいでしょう？ 答えは「これだけでは区別できません」です．

別の手段（情報）を使って，いま自分が注目しているデータが， 文字なのか機械語命令なのかを知る必要があります． 例えば，この後で説明する.textセクションにある 2進数のデータ列は「.textセクションに存在するから」という理由で 機械語命令として解釈されます．

以下では，整数(特に2の補数による負の数の表現)， ASCII文字コード，機械語命令の符号化などを説明します．

2進数と10進数と16進数

位取り記数法

• 10進数で \( 234 \) という数字の値は \[ 2\times 10^2 + 3\times 10^1 + 4\times 10^0 = 200 + 30 + 4 = 234 \]

• 2進数で \( 1101 \) という数字の値は (2進数→10進数の変換)

\[ 1\times 2^3 + 1\times 2^2 + 0\times 2^1 + 1\times 2^0 = 8+4+0+1=13 \]

• 一般的に，n進数で \( d_m d_{m-1} \cdots d_2 d_1 d_0 \) という数字の値は \[ \sum_{i=0}^m d_i\times n^i = d_m\times n^m + d_{m-1}\times n^{m-1} + \cdots d_2\times n^2 + d_1\times n^1 + d_0\times n^0 \]

  • この「数字を並べる記法」を位取り記数法 (positional notation)という．
  • nを底 (base), あるいは基数 (radix)と呼ぶ．

• 16進数も同様

  • 0から9，AからFまでの数字を使う．Aは10，Bは11，\(\cdots\)，Fは15を表す．
  • 16進数で \( 1\mathrm{F}4 \) という数字の値は (16進数→10進数の変換) \[ 1\times 16^2 + \mathrm{F}\times 16^1 + 4\times 16^0 = 256 + 240 + 4 = 500 \]
  • 2進数は表記が長くなるため，16進数を使って短く表記すると便利(だから使う)．

対応表

変換方法

2進数→16進数，16進数→2進数

• 最下位ビットから4桁ずつまとめる(上位ビットには0を埋める)． 4ビットごとに16進数にすれば良い(10進数ではこの方法は使えない)

10進数→2進数

• 割り算を使う方法

  • 0になるまで繰り返し2で割り，余りを逆順に並べる．
  • 例: 13を2進数に変換

  \[ \left. \begin{align} 13\div 2 = 6 \cdots 1 \\ 6\div 2 = 3 \cdots 0 \\ 3\div 2 = 1 \cdots 1 \\ 1\div 2 = 0 \cdots 1 \end{align} \right\} 余りを下から上に並べて 1101 \]

  • これでうまくいく理由は以下の計算と同じだからです

\[ \begin{eqnarray} 13 &=& 2\times6 + \textcolor{red}{1} \\ &=& 2 \times (2 \times 3 + \textcolor{green}{0}) + \textcolor{red}{1}\\ &=& 2 \times (2 \times (2 \times 1 + \textcolor{blue}{1}) + \textcolor{green}{0}) + \textcolor{red}{1}\\ &=& 2 \times ( 2 \times (2 \times (2 \times 0 + \textcolor{magenta}{1}) + \textcolor{blue}{1}) + \textcolor{green}{0}) + \textcolor{red}{1}\\ &=& 2 \times ( 2 \times (2^2 \times 0 + 2^1 \times \textcolor{magenta}{1} + 2 ^0 \times \textcolor{blue}{1}) + \textcolor{green}{0}) + \textcolor{red}{1}\\ &=& 2 \times ( 2^3 \times 0 + 2^2 \times \textcolor{magenta}{1} + 2^1 \times \textcolor{blue}{1} + 2^0 \times \textcolor{green}{0}) + \textcolor{red}{1}\\ &=& 2^4 \times 0 + 2^3 \times \textcolor{magenta}{1} + 2^2 \times \textcolor{blue}{1} + 2^1 \times \textcolor{green}{0} + 2^0 \times \textcolor{red}{1}\\ &=& (2進数で)\textcolor{magenta}{1}\textcolor{blue}{1}\textcolor{green}{0}\textcolor{red}{1}\\ \end{eqnarray} \]

• 2のべき乗を使う方法

  • 大きい2のべき乗から順番に， 例えば，\(2^3=8\)を引けたら，\(2^3\)の位を1にする． 0になるまで繰り返す．
  • 例: 13を2進数に変換

\[ \left. \begin{eqnarray} 13 - 2^3 &=& 5 \rightarrow 2^3の位は1 \\ 5 - 2^2 &=& 1 \rightarrow 2^2の位は1 \\ 1 - 2^1 &=& 引けない \rightarrow 2^1の位は0 \\ 1 - 2^0 &=& 0 \rightarrow 2^0の位は1 \end{eqnarray} \right\} 上から下に並べて 1101 \]

• bcコマンドを使う方法

  • bcは電卓コマンド．

    $ bc
    1+2*3+10/5
    9
    ^D         (ctrl-dで終了)
    $
    

  • 例: 10進数 13を2進数に変換

    $ bc
    obase=2  (出力の底を2に変更)
    13
    1101     (13の2進数は1101)
    ^D
    $
    

  • 例: 16進数 1F4 を2進数に変換

    $ bc
    obase=2    (出力の底を2に変更)
    ibase=16   (入力の底を16に変更，入力の底の変更は出力の後が良い)
    1F4
    111110100  (1F4の2進数は111110100)
    ^D
    $
    

用語: ビット，バイト，LSB，MSB

ビットとバイト

• ビット (bit)

  • ビットはコンピュータが扱うデータ量の最小単位．binary digit の略．
  • 2進数のひと桁が1ビット．1ビットで0か1かの2通りの状態を表現．

• バイト (byte)

  • 通常，8ビットのこと

• ビットやバイトはレジスタやメモリなどの記憶領域の容量の単位としても使われます
  • レジスタ%raxは8バイトのデータを格納できます．
  • (バイトアドレッシングの)メモリは1つのアドレスごとに1バイトのデータを格納できます

MSBとLSB

• ビット列で最左のビットを最上位ビット (MSB, most significant bit)といいます
• ビット列で最右のビットを最下位ビット (LSB, least significant bit)といいます
• 多倍長データの最上位バイト (most significant byte)と 最下位バイト (least significant byte)も略称がMSBとLSBなので， どちらを指すかは要注意です

ビットの呼び方

• LSBから左に(0から始めて)0ビット目，1ビット目，...，7ビット目と呼ぶことが多いです (例えばIntelのマニュアルで Intel 64 and IA-32 Architectures Software Developer Manuals)
• 0から数え始めることを0オリジン (zero-origin)，あるいは0ベース (zero-based)といいます

ワード，ロング，クアッド

• ワード，ロング，クアッドのサイズはアーキテクチャ依存です． x86-64では，それぞれ，2バイト，4バイト，8バイトになります．
• C言語の整数型やポインタ型のサイズはプラットフォーム依存です． 最近主流のLP64データモデルでは， 上記の通り，intは4バイト，longとポインタは8バイトになります．
• GNUアセンブラでは次の表記等でデータのサイズを指定します．
  • アセンブラ命令で整数データを出力する際には， サイズに応じて，.byte，.word，.long，.quadを使います
  • 多くの機械語命令でオペランドのサイズを命令サフィックスで指定します． 例えば，movqは オペランドのサイズが8バイトであることを示します

<stdint.h>

• 符号あり

• 符号なし

• <stdint.h>は標準ヘッダファイルで，固定長の整数や 符号の有無を確実に扱いたい時に便利です．

文字コード

文字コードとは

• 文字コード = 各文字を区別するために，重複無く割り振った番号です
  • ASCIIコードで文字Aの文字コードは(7ビットの)65
  • ASCIIコードで文字9の文字コードは(7ビットの)57

// ascii.c
#include <stdio.h>
int main ()
{
    printf ("'%c', %d\n", 'A', 'A');
    printf ("'%c', %d\n", '9', '9');
}

$ gcc -g ascii.c
$ ./a.out
'A', 65
'9', 57

• 文字コードにはいろいろな種類がありますが，GNUアセンブラではASCIIコードのみを使います．

• 文字コードはフォント(書体)や文字の大きさの情報は含んでいません．

  

  例えば，上図の文字Aはフォントも大きさも異なりますが， どちらもASCIIコードでは同じ「7ビットの65」です．

ASCIIコード

ASCIIコード表

• 128個の文字を扱うコード体系
  • 通常，MSBを0にした1バイトデータとして扱う
• 英字アルファベット，数字，記号，制御文字 (control character)を含む

制御文字

• 制御文字は出力装置に(文字表示以外の)動作を要求します

  • 例: 改行文字 ^J (line feed, C言語では\n)は端末ディスプレイに改行を要求する． 「次に表示する位置を変更する」という動作を要求しています．

  • 例: エスケープ文字 ^[で始まる文字列 ^[[7mは文字反転， ^[[0mは元に戻すというANSIエスケープシーケンスです． 「次に表示する文字と背景の色を変更する」という動作を要求しています．

    $ echo -e "aaa \E[7mbbb\E[0m ccc"
    aaa bbb ccc
    $ cat
    aaa  ^[[7mbbb  ^[[0mccc     (ctrl-vを押してからエスケープキーを入力)
    aaa  bbb  ccc
    

    echoコマンドの-eは「バックスラッシュによるエスケープを解釈する」というオプションです．また，\Eはbashでエスケープ文字を表すエスケープシーケンスです． ほとんどの端末ソフトで文字列bbbと背景色の色が反転します． catコマンドの場合は，ctrl-vを押してからエスケープキーを押すと エスケープ文字が入力できて，^[と表示されます(2文字に見えますがこれで1文字です)．

  • ASCIIの以下の制御文字は覚えておきましょう．

    制御文字	意味	C言語のエスケープ文字	キーボード中のキー
    ^@	ヌル文字	\0
    ^D	End of File (EOF)
    ^H	Back Space (後退)	\b	Back Space
    ^I	Horizontal Tab (水平タブ)	\t	Tab
    ^J	Line Feed (改行)	\n
    ^M	Carriage Return (復帰)	\r	Enter
    ^[	Escape (エスケープ)		Esc
    ^?	Delete (削除)		Delete

ctrl-j や ctrl-m で改行できる(ことが多い)理由

• 歴史的な話ですが，ctrlキーを押しながら，あるキー(例えばj)を押すと， jのASCIIコード(2進数8ビット表記で 01101010)の 上位３ビットをゼロにした 00001010 (つまり改行文字 ^J)を入力できました．
• そのなごりで，今でもctrl-jやctrl-mを押すとEnterキーの入力と同じ動作を するソフトウェアが多くあります． 同様に，ctrl-iでTabを，ctrl-[でEscapeを，ctrl-hでBack Spaceを 入力できるソフトウェアが多いです．
• もちろん，現在ではキーの処理はソフトウェアごとに自由に決められるので， ctrl-jで常に改行できるわけではありません．

ファイルの改行文字

• LinuxやmacOSのファイルでは，通常，ファイル中の改行を Line Feed (^j, LF)の1文字で表します． 一方，Windows では Carriage Return (^m, CR)とLine Feed (^j, LF)の2文字で表すことが多いです． (ファイル中の改行文字はエディタの設定で通常，変更可能)．

• このため，Windows で作成したファイルを Linux で開くと， 行末に ^M が見えることがあります．「改行が CR LF なんだな」と思って下さい．

  $ ❶ cat foo2.txt
  hello
  byebye
  $ ❷ cat -v foo2.txt
  ❸ hello^M
  byebye^M
  
  $ ❹ od -c -t x1 foo2.txt
  0000000   h   e   l   l   o ❺ \r  \n   b   y   e   b   y   e  \r  \n
           68  65  6c  6c  6f    0d  0a  62  79  65  62  79  65  0d  0a
  0000017
  

  • 例えば，改行が CR LF なファイルfoo2.txtを用意して， ❶ catで表示すると普通に表示されますが， ❷ -vオプション(制御文字を可視化)を使うと，❸^Mが表示されました．
  • ❹ odコマンドを使っても，CRの存在を確認できます (❺ \r)．

文字集合と符号化方式，UnicodeとUTF-8

GNUアセンブラではASCIIコードのみを使用するので， この節の話はスキップ可能です．

• ASCIIコードでは文字コード(文字の背番号，コードポイント)をそのままバイナリ表現として使っていました．
• 一方，多くの文字コード体系では文字集合と符号化方式を区別しています．

  • 例えば，Unicodeは(ほぼ世界中の)文字を定める文字集合です． Unicodeで日本語の「あ」のコードポイントは0x3042です．

  • UTF-8はUnicodeの符号化方式の一つです． UTF-8で「あ」をバイト列に符号化すると，0xE3，0x81，0x82になります． (Unicodeの他の符号化方式として，UTF-16やUTF-32もあります)．

    

    $ cat a.txt
    あ
    $ od -t x1 a.txt
    0000000 e3 81 82 0a
    0000004
    

    odコマンドで確かめると「あ」が0xE3，0x81，0x82のバイト列と確認できます． 最後の0x0Aは改行文字 (\n)ですね．

  • 1110や 10を使う理由は あるバイトが文字の最初のバイトなのか，２バイト目以降なのかを簡単に 区別できるからです． また，1バイトの文字 (例えば A)と混同する心配もありません．

  • UTF-8はASCIIと互換性があるのが大きな利点です． ASCIIコードで書かれたテキストはそのままUTF-8として処理できます．

符号なし整数

符号なし整数のビット表現

• 2進数の各桁をそのままビット表現とする
  • 例: 2を8ビットの符号なし整数で表現すると， 2の2進数は10なので，00000010 になる． (余った上位ビットに0を入れることに注意)

符号なし整数の一覧表

• 前半

• 後半

符号なし整数の扱える範囲

• 固定長の整数の範囲は有限
  • 例: 8ビット符号なし整数が表現できる範囲は \(0\)から\(255\)まで
• 一般に\(n\)ビット符号なし整数の範囲は \(0\)から\(2^n-1\)まで
• (符号なしなので当然ですが)負の値は表現できない

符号なし整数の最大値と最小値のビットパターン

• 見やすさのため8ビットごとにスペースを入れてます
• 最小値は全てのビットが0，最大値は全てのビットが1
• 32ビット符号なし整数の最大値は約42.9億．現在の世界の人口(約80億人)を数えられない

符号なし整数のオーバーフロー

• 演算の結果，表現できる範囲を超えた場合をオーバーフロー (overflow)と言う．
• 8ビット符号なし整数が表現できる範囲は0から255まで(復習)
• 例: 8ビット符号なし整数の255に1を足すと，256は表現できる範囲外なので， オーバーフローして結果は0になる

// overflow1.c
#include <stdio.h>
#include <stdint.h>
int main ()
{
    uint8_t x = 255;    
    x++;
    printf ("%d\n", x);
}

$ gcc -g overflow1.c 
$ ./a.out
0

• 例: 8ビット符号なし整数の0から1を引くと，-1は表現できる範囲外なので， オーバーフローして結果は255になる

// overflow2.c
#include <stdio.h>
#include <stdint.h>
int main ()
{
    uint8_t x = 0;
    x--;
    printf ("%d\n", x);
}

$ gcc -g overflow2.c 
$ ./a.out
255

• 8ビット符号なし整数のオーバーフロー時の動作: 0から255までの範囲に収まるように，256で割った余りを計算結果とする (これはC言語規格の定義とも合致する)．
• 一般的には\(n\)ビット符号なし整数の場合， オーバーフローの結果は，\(0\)から\(2^n-1\)の範囲に収まるように， \(2^n\)で割った余りを計算結果とする．

キャリーとボロー

• キャリー (carry)は繰り上げ，ボロー(borrow)は繰り下げのこと

• 符号なし整数のオーバーフローはキャリーやボローの有無でチェックできる

• 例: 8ビット符号なし整数で255+1を計算すると，キャリーが発生する

  

• 例: 8ビット符号なし整数で0-1を計算すると，ボローが発生する

  

• x86-64では符号なし整数のオーバーフローは， キャリーフラグ(CF)で検出できる． キャリーやボローが発生するとキャリーフラグが立つから．

  • cf. x86-64では符号あり整数のオーバーフローは， オーバーフローフラグ(OF)で検出できる

符号あり整数，2の補数

符号あり整数のビット表現

• 非負(0か正数)の数は2進数の各桁をそのままビット表現， 負の数は2の補数 (two's complement)を使う

  • MSBは符号ビットになる．0なら非負，1なら負になる．
  • 2の補数以外にも負の数の表現方法はある． 2の補数を使う理由は，(1) 減算を加算処理で行えるから， (2) x86-64が2の補数を使っているからです．

• 例: 8ビットの符号あり整数の場合，

  • 前半の00000000〜01111111を0と正の数に， 後半の10000000〜11111111を負の数にする．
  • 例えば，126に対する(8ビットの場合の)2の補数は130(=256-126)なので， 130の2進表記 10000010 を -126 のビット表現とする．

一覧表

• 前半 (0と正の数)

• 後半 (負の数)

2の補数と1の補数

• 2の補数とは(キャリーを無視して)加算して全てのビットが0になる数です

  • 例: 8ビットの場合，126 (2進数で 01111110)の2の補数は10000010 (=130)です． 01111110+10000010=00000000になるからです(キャリーを無視すれば)． \(126+130=256=2^8\)

    

• 1の補数とは(キャリーを無視して)加算して全てのビットが1になる数です

  • 例: 8ビットの場合，126 (2進数で 01111110)の1の補数は 10000001 (=129)です． 01111110+10000001=11111111になるからです． \(126+129=255=2^8-1\)

    

• 2の補数の求め方: 各ビットを反転してから，LSBに1を加えれば良い

  

• 一般的に，\(n\)進数に対して，\(n\)の補数と，\((n-1)\)の補数が存在します

  • \(n\)の補数は「足すとちょうど桁が上がる数」です． 10進数で2桁の数を考える時，\(65\)に対する10の補数は\(35\)になります． 足すと\(100\)になるから．
  • \(n-1\)の補数は「足してもギリギリ桁が上がらない数」です． 10進数で2桁の数を考える時，\(65\)に対する9の補数は\(34\)になります． 足すと\(99\)になるから．

符号なし整数と符号あり整数の関係

• 8ビットの場合，符号なし整数の128〜255の範囲のビット表現を， 符号あり整数の-128〜-1の範囲にシフトしたことになる．

  

• シフトの幅がどれもちょうど256であることがポイント．

• 「130を足す」のと「126を引く」のは同じ

  • 8ビット整数の場合，256を足しても引いても値は変化しませんよね． キャリーやボローとしてはみ出るだけだからです．
  • 例えば，1 + 256 = 1 ですし，1 - 256 = 1 です． (数式ではこれを \(1 + 256 \equiv 1 \pmod {256}\) と書きます． 「256で割った余りで考えれば，同じ値である」という意味です． ここでは単に = を使います)．
  • ですので，4 - 126 = 4 + (-126) = 4 + 256 + (-126) = 4 + 130 となります．

• 時計で考えると分かりやすいかも．時計の上で，「7時間足す」のと「5時間引く」のは同じ．

  

扱える範囲

• 例: 8ビット符号あり整数が表現できる範囲は \(-128\)から\(127\)まで
  • \(128\)まででは無いのはプラス側にはゼロ (0)があるから
• 一般に\(n\)ビット符号なし整数の範囲は \(-2^n/2\)から\(2^n/2-1\)まで
  • \(n\)ビットの場合，\(2^n\)通りの数が扱える． 正と負で半分ずつ使ってる (\(2^n/2\))が， 正の方はゼロ (0)があるので \(-1\)となる．

最大値と最小値のビットパターン

• 見やすさのため8ビットごとにスペースを入れてます
• 最小値はMSBが1でそれ以外の全ビットが0，最大値はMSBが0でそれ以外の全ビットが1

x86-64は符号の有無を気にせず加算する→どちらの結果も正しい

• 2の補数の利点 = 足し算回路で引き算ができる

• 例: 31-126は，31と -126 のビット表現の加算で計算できる．

  • つまり 00011111 + 10000010 = 10100001 = -95
  • この結果が 31 + 130 = 10100001 = 161 の結果と，ビット表現が一致することに注意
  • これは当然で，8ビットの場合，31 + (-126) = 31 + 256 + (-126) = 31 + 130 だから
  

• 実際，x86-64は整数が符号ありか符号なしかを区別せずに加算している． 計算結果はどちらに対しても正しい．

  • プログラマ(あるいはコンパイラ)は符号ありか符号なしかを意識する必要がある． 符号あり・符号なしでビット表現が意味する値が変わるし (上の例では161か-95か)， オーバーフローの判定にキャリーフラグ(CF)とオーバーフローフラグ(OF)の どちらを使うべきかを判断する必要があるから．

符号あり整数のオーバーフロー

• 8ビット符号あり整数の64に64を足すと，オーバーフローして結果は-128になる (64 + 64 = 128 は８バイト符号あり整数が表現可能な-128〜127の範囲を超えている)．

  

• C言語の規格上，符号あり整数のオーバーフローは未定義動作(undefined behavior)． つまり，符号あり整数をオーバーフローさせてはいけない．

  • 未定義動作を含むプログラムに対して，コンパイラはどのように振る舞っても良い．
    • コンパイルエラーにしても良いし，実行するたびに異なる結果を出力するコードを出力しても良いし，それっぽい答え(ここではオーバーフローしたビット表現)を出力しても良い
  • ここでは-128の結果を得たが，C言語の規格上，他の結果がでる可能性がある

符号あり整数では，オーバーフローとキャリーの有無は関係ない

• 符号あり整数ではオーバーフローとキャリーの有無は関係ありません

  
  • 例: 8ビット符号あり整数で，64+64=128 は，表現可能な-128〜127を超えているのでオーバーフロー発生．しかしキャリーは0
  • 例: 8ビット符号あり整数で，(-1)+(-1)=-2は，表現可能な-128〜127の範囲内なので オーバーフローは発生していない．しかしキャリーは1

• このため，x86-64では符号あり整数のオーバーフローを(キャリーフラグ(CF)ではなく) オーバーフローフラグ(OF)で検出する

  • 一方，符号なし整数のオーバーフローは キャリーフラグ(CF)で検出する

• なお人間が判断する場合は以下で簡単に判定できる

  • 正と正の数同士(どちらもMSBは0)を足して，負になったら(MSBは1)オーバーフロー発生
  • 負と負の数同士(どちらもMSBは1)を足して，正になったら(MSBは0)オーバーフロー発生
  • 正と負の数同士の足し算では決してオーバーフローは発生しない

C言語で整数計算に注意が必要な場合

符号あり整数のオーバーフロー (未定義動作)

// overflow4.c
#include <stdio.h>
#include <stdint.h>
int main ()
{
    int32_t x1 = 10 * 10000 * 10000; // 10億
    int32_t x2 = 15 * 10000 * 10000; // 15億
    int32_t x3 = x1 + x2; // オーバーフロー
    printf ("%d\n", x3); // -1794967296
}

$ gcc -g overflow4.c
$ ./a.out
-1794967296

• 符号あり整数のオーバーフローはセキュリティ上の脆弱性になるため避けるべきです． -ftrapvオプションをつけると符号あり整数のオーバーフロー時に トラップが発生します． 試した所，シグナルSIGABRTが発生してプログラムは終了しました．

$ gcc -g -ftrapv overflow4.c
$ ./a.out
Aborted

絶対値を計算できない数がある

// overflow5.c
#include <stdio.h>
#include <stdint.h>
int main ()
{
    int8_t  x1 = -128;
    int16_t x2 = -32768;
    int32_t x3 = -2147483648;
    x1 = -x1;
    x2 = -x2;
    x3 = -x3;
    printf ("%d, %d, %d\n", x1, x2, x3);
}

$ gcc -g overflow5.c
$ ./a.out
-128, -32768, -2147483648

• 符号あり整数で表現可能な最小の数は絶対値を計算できません．
• 例えば8ビット符号あり整数-128の絶対値は計算できません． 絶対値の128が，表現可能な範囲-128〜127を超えてしまうからです．
• この場合もオーバーフローが起きているので未定義動作となります．

符号ありと符号なしを混ぜると直感に反する結果になる

// signed-unsigned.c
#include <stdio.h>
#include <stdint.h>
int main ()
{
    int32_t x1 = -1;
    uint32_t x2 = 0;
    printf ("%d\n", x1 < x2); // 0
}

$ gcc -g singed-unsigned.c
$ ./a.out
0

• これはオーバーフローではなくC言語の規格に関する話です．
• 上のsigned-unsigned.cを実行すると0が返りました． (-1 < 0は真なので1が返って欲しいのに)．
• これは違う型同士の演算ではC言語ではまず型を同じにするためです (通常の算術型変換といいます)． この場合は-1を符号なしに変換します． その結果，0xFFFFFFFFという大きな正の数になり， 0xFFFFFFFF < 0を比較して0が返るわけです．
• この問題があるため，C言語では符号ありと符号なしを混ぜて使うことを避けるべきです．
  • 通常は符号ありの整数を使う
  • ビット演算をしたい場合などに限定して符号なしの整数を使う (符号あり整数へのビット演算は(未定義動作ではないが) 処理系定義の動作を引き起こす場合があるため)．

機械語命令の符号化

覚える必要はありません

• 機械語命令の符号化方法はCPUごとに異なります
• x86-64の機械語命令の符号化方法はx86-64のマニュアル Intel 64 and IA-32 Architectures Software Developer Manualsに書いてありますし，アセンブラが自動変換してくれるので，私達は覚える必要は全くありません
• とはいえ，「機械語命令も2進数で符号化されている」ことを確認するために， 機械語命令の符号化をちょっとだけ見てみましょう

概要

• x86-64はCISC (complex instruction set computer)なので， 「1つの命令で複雑な処理をする」という設計哲学です． そのため命令は可変長(1バイト〜15バイト)で複雑です． 一方，RISC (reduced instruction set computer)では命令長は固定長で， 1命令が処理する内容は単純なことが多いです．

命令フォーマット

• 上図はx86-64の基本的な命令フォーマットです(この図と異なる例外的な命令もあります)．
• 命令プリフィクス (instruction prefix)には例えばLOCKプリフィクスがあります． LOCKプリフィクスはメモリアクセスをアトミックにする効果がありますが， LOCKプリフィクスをつけて良い命令は一部に限定されています． また，以下ではREXプリフィクスも登場します．
• ModR/MバイトとSIBバイトは， アドレッシングモード，レジスタやメモリオペランドを指定します．
• 変位(displacement)と即値(immediate)はどちらも定数です． pushq 4(%rsp)の4が変位，pushq $4の4が即値です．

処理方向ビット

• 2つのオペランドを持つ多くの命令で， 1バイトのオペコードの (LSBを0ビット目と数えて)1ビット目が処理方向ビット(operation direction bit)になります．
• 処理方向ビットが0の時，代入の方向はreg→r/mになります． 一方1の時，代入の方向はr/m→regになります．
• 例えば，上図で movq r64, r/m64のオペコードはREX.W 89， movq r/m64, r64のオペコードはREX.W 8Bです． 確かに，処理方向ビットがそれぞれ0と1になっています． (REX.Wは命令プリフィクスで，オペランドサイズを64ビットにします)．

REXプリフィクス

• REXプリフィクスはx86-64で追加された1バイト長の命令プリフィクスです．
• GNUアセンブラが自動挿入するので，アセンブリコードでプログラマが 明示的にREXプリフィクスを記述する必要は通常はありません．
• REX.Wはオペランドサイズを64ビットにします．
• REX.R，REX.X，REX.Bはレジスタを指定する際に使われます． これらの値が1の時，新しいレジスタ%r8〜%r15を指定したことになります．

ModR/MバイトとSIBバイト

• ModR/Mバイトは上図のように分割されてます．

• ModR/MのModフィールドの意味は上記のとおりです．

$ gcc -g movq-10.s
$ objdump -d ./a.out
0000000000001129 <main>:
  1129: 4c 89 c0             	mov %r8,%rax        # Mod=11，レジスタ
  112c: 4c 89 00             	mov %r8,(%rax)      # Mod=00, メモリ参照，変位無し
  112f: 4c 89 40 08          	mov %r8,0x8(%rax)   # Mod=01，メモリ参照，変位1バイト (0x08)
  1133: 4c 89 80 e8 03 00 00 	mov %r8,0x3e8(%rax) # Mod=10, メモリ参照，変位4バイト (0xE8, 0x03, 0x00, 0x00)

• ModR/MのRegフィールドはREX.Rの1ビットと合わせて，レジスタを指定します(以下の表参照)．

• オペランドが1つの時はRegフィールドはレジスタの指定ではなく， オペコードの一部として使われることがあります(なので図中でOpcodeと書いています)．

• ModR/MのR/MフィールドはREX.Bの1ビットと合わせて，レジスタやメモリ参照を指定します．
  • Mod=11の時はR/Mフィールドは下の表のレジスタを指定します．
  • Mod\(\neq\)11の時はR/Mフィールドは下の表のメモリ参照を指定します．
    • ただし，R/M=100の時はSIBバイトを使うことを意味します． また，R/M=101の時は%rip相対アドレッシングを使うことを意味します． R/M=101の時，(本来はMod=00は変位無しですが) Mod=00でもMod=10でも変位が4バイトになります．

• SIBの各フィールドは，Scale，Indexレジスタ, Baseレジスタを指定します． (例えば，メモリ参照 (%rax, %rbx, 2)で， %raxがBaseレジスタ，%rbxがIndexレジスタ，2がScaleです)．

$ gcc -g movq-11.s
$ objdump -d ./a.out
0000000000001129 <main>:
  1129: 4c 89 05 e8 03 00 00 	mov  %r8,0x3e8(%rip)
  1130: 4e 89 84 48 e8 03 00 	mov  %r8,0x3e8(%rax,%r9,2)
  1137: 00 

• mov %r8, 0x3e8(%rip)の機械語バイト列を見てみます

  • Mod=00で，メモリ参照，変位は4バイトを意味します(これはR/M=101の時の例外)．
  • REX.R=1とReg=000で，%r8レジスタを意味します．
  • R/M=101で，%rip相対アドレッシングを意味します．
  • 89はmovqのオペコードです． 処理方向ビットが0なのでRegをR/Mに代入を意味します．
  • 最後の4バイト (E8 03 00 00)は4バイトの変位です．

• movq %r8, 0x3e8(%rax,%r9,2)の機械語バイト列を見てみます

  • Mod=10で，メモリ参照，変位は4バイトを意味します．
  • REX.R=1とReg=000で，%r8レジスタを意味します．
  • R/M=100で，SIBバイトの使用を意味します．
  • Scale=01で，0x3e8(%rax,%r9,2)の2を意味します．
  • REX.B=0とBase=000で，Indexレジスタとして%raxを使用します．
  • REX.X=1とIndex=001で，Baseレジスタとして%r9を使用します．

• SIBバイトのBaseフィールドはREX.BとともにBaseレジスタを指定します． ただし，❶❷の部分が特別扱いです．

  • ❶❷の101かつMod=00の場合，(%rbp)というメモリアクセスではなく， 32ビットの変位のみでのメモリアクセスになります．
  • 例えば，movq %r8,0x1000の機械語バイト列は 4c 89 04 25 00 10 00 00になります． Mod=00, Base=101となっていますね．

• SIBバイトのIndexフィールドはREX.Xと合わせて，Indexレジスタを指定します．

  • ただし%rspは指定不可です

データの変換

ゼロ拡張

• ゼロ拡張 (zero extension)は上位ビットを0で埋めてビット列を大きくする変換．
• 符号なし整数をゼロ拡張すると，値は変化しない．
  • 例: 2バイトの符号なし整数65535をゼロ拡張で4バイトに変換しても，値は変化しない．

符号拡張

• 符号拡張 (sign extension)は
  • 上位ビットを元データのMSBで埋めてビット列を大きくする変換．
  • つまり，正の場合は0を，負の場合は1を上位ビットに埋める．
• 符号あり整数を符号拡張すると，値は変化しない．

• 符号あり整数をゼロ拡張すると，値が変化する．

movz␣␣，movs␣␣命令

• movz␣␣はゼロ拡張をしてデータをコピーする命令 (move with zero extension)
• movs␣␣は符号拡張をしてデータをコピーする命令 (move with sign extension)
• 通常，値を変化させたくないので，符号なし整数にはmovz␣␣を使い， 符号あり整数にはmovs␣␣命令を使う．

切り詰め (truncation)

• 切り詰め = 上位ビットを捨ててビット列を小さくする変換
• 符号あり整数を切り詰めると，正負が変わることがある

#include <stdio.h>
#include <stdint.h>
int main (void)
{
    int32_t i = 100000;
    int16_t s = i;
    printf ("%d\n", s);
}

$ gcc -g trunc.c
$ ./a.out
-31072

• 4バイトから2バイトへ切り詰めは， 例えば，%eaxに値を入れて，%axで値を取り出せば可能．

# asm/trunc2.s
    .text
    .globl main
    .type main, @function
main:
    movl $100000, %eax
    movw %ax, %bx
    ret
    .size main, .-main

$ gcc -g trunc2.s
$ gdb ./a.out -x trunc2.txt
Breakpoint 1 at 0x1131: file trunc2.s, line 8.
Breakpoint 1, main () at trunc2.s:8
8	    ret
$1 = -31072
# -31072 が出力されれば成功

メモリレイアウト

多バイト長データはメモリの連続領域に格納

• 通常，メモリはバイトアドレッシングです． つまり，1つの番地ごとに1バイトの情報を格納できます．
• 多バイト長データ(2バイト以上のデータ)をメモリに格納する時は， メモリの連続領域を使ってデータを格納します．
  • 上図では4バイトのデータ 0x11223344をメモリの1000〜1003番地を使って格納していることを示しています．
  • このデータを読み書きする場合は，先頭番地の1000番地を使います．

バイトオーダとエンディアン

• 多バイト長のデータをメモリに格納するには1バイトごとに分割して格納します． 多バイト長のデータをバイト単位で格納する順序をバイトオーダ(byte order)といいます．

• 多バイト長データで最下位のバイトをLeast Significant Byte (LSB)， 最上位のバイトをMost Significant Byte (MSB)と呼びます．

  • 例えば，0x11223344という4バイトのデータのLSBは0x44，MSBは0x11です．

• 多バイト長データをメモリに格納する時，

  • LSBから先にメモリに格納する方法を
    リトルエンディアン
    (little endian)
  • MSBから先にメモリに格納する方法をビッグエンディアン (big endian) と呼びます．

アラインメントとパディング

アラインメント

• アラインメント (境界調整，alignment)とは， 特定のアドレス(例: 16の倍数のアドレス)にデータを格納することです
  • 16の倍数のアドレスに格納することを， 16バイト境界 (16-byte boundary)に格納する，という言い方もします．
• ABIはアラインメントを守ることを プログラムに要求します．このお約束をアラインメント制約といいます． 上の表は System V ABI (AMD64) が定めるアラインメント制約です．
  • スタックフレームの16バイト境界への制約は call命令実行時に%rspの値が16の倍数であることを要求しています．

アラインメント制約に違反すると最悪，クラッシュする

• アラインメント制約に違反すると，実行速度が遅くなったり， Segmentation faultなどの実行時エラーが生じます(例: AVX命令のmovdqa)． このため，コンパイラはアラインメント制約を満たすコードを出力します． 人手でアセンブリコードを書く場合は， プログラマがアラインメント制約を守るよう注意する必要があります．

アラインメント調整 (.align)とパディング

• アラインメント制約はアセンブラ命令.alignを使って満たせます (他にも .skip, .space, .zeroなどのアセンブラ命令でも可能です)．

  char x1 = 10;
  int  x2 = 20;
  

      .globl  x1
      .data
      .type   x1, @object
      .size   x1, 1
  x1:
      .byte   10
      .globl  x2
    ❶.align 4
      .type   x2, @object
      .size   x2, 4
  x2:
      .long   20
  

  
  • 例えば，上のchar型のx1とint型のx2というグローバル変数の宣言があった場合，コンパイラは上のようなアセンブリコードを出力します．
  • 仮にx1を1000番地に配置したとすると，そのまま次の領域にx2を配置すると x2は1001番地に配置することになります． 1001番地は4バイト境界(4の倍数のアドレス) ではないのでアラインメント制約違反になってしまいます．
  • これを避けるため❶.align 4というアセンブラ命令を使用します． .align 4は「次に出力するアドレスを4の倍数になるよう(最小限増やして)調整しろ」という意味です．その結果，x2のアドレスは1004番地になります．
  • なお未使用の1001〜1003番地のメモリ領域のことをパディング(詰め物，padding)といいます．

構造体のパディング

// asm/struct3.c
struct foo {
    char x1;
    int x2;
};
struct foo f = {10, 20};

    .globl  f
    .data
    .align 8            # 構造体全体を8バイト境界に配置
    .type   f, @object
    .size   f, 8
f:
    .byte   10          # f.x1
    .zero   3           # 3バイトのゼロを出力(3バイトのパディング)
    .long   20          # f.x2

• アラインメント制約のために，構造体の中にもパディングが生じます
• 上の例ではchar型のx1とint型のx2の間に3バイトのパディングができています
• 構造体の先頭にパディングが入ることはありません． 一方，構造体の末尾にパディングが入ることはあります(次の節で説明)

配列のためのパディング

• (構造体にはパディングが生じますが)配列にはパディングは入りません． 配列のすべての要素は常にぴったりくっついて， メモリ上で連続したアドレスに格納されます． 例えば，int a1 [3]; のメモリレイアウトは以下の図になります． (配列の各要素(ここではint)もアラインメント制約を満たしています (ここではアドレスが4の倍数になっています))

  

• これは2次元配列になっても同じです． 例えば，int a2 [2][3];のメモリレイアウトは(C言語では)以下の図になります．

  

• 「じゃあ，サイズが5バイトの構造体を作って，その構造体の配列を定義したら， その配列の要素はアラインメント制約を満たせないのでは?」

  答えは「はい，満たせなくなります．ですので，(構造体中にint型など アラインメント制約を持つメンバーがある場合は)サイズが5バイトの構造体は作れません」「その場合は構造体のお尻にパディングが入ります」． (なお構造体のメンバーがcharやchar[]など，どの場所にも置けるデータのみの 場合は5バイトの構造体を作れます)．

// asm/struct4.c
#include <stdio.h>
struct foo2 {
    int x2;
    char x1;
};
struct foo2 f = {10, 20};
int main ()
{
    printf ("%ld\n", sizeof (struct foo2));
}

    .globl  f
    .data
    .align 8
    .type   f, @object
    .size   f, 8  # 構造体全体のサイズは8バイト
f:
    .long   10
    .byte   20
    .zero   3     # 構造体のお尻に3バイトのパディングが入っている

実際にやってみると，構造体のお尻に3バイトのパディングが入りました．

x86-64機械語命令

x86-64機械語命令の実行方法

概要：デバッガ上で実行します

機械語命令を実行しても，単にa.outを実行するだけでは 意図通りに実行できたかの確認が難しいです． (アセンブリコード内からprintfを呼び出せばいいのですが， そのコードもうざいので)． そこで本書ではデバッガを使って機械語命令の実行と確認を行います．

以下では例としてmovq $999, %raxという機械語命令を実行してみます． (これらのファイルはサンプルコードから入手できます)． movq $999, %raxは「定数999を%raxレジスタに格納する」という命令ですので， 実行後，%raxレジスタに999という値が入っていれば， うまく実行できたことを確認できます．

# asm/movq-4.s
    .text
    .globl main
    .type main, @function
main:
    movq $999, %rax
    ret
    .size main, .-main

実行確認のためのgdbのコマンド列を書いたファイルも用意しています．

# asm/movq-4.txt
b 7
r
list 6,6
p $rax
echo # %raxの値が999なら成功\n
quit

デバッガ上で実行：gdbコマンドを手入力

asm/movq-4.txt中のgdbコマンドを 以下のように1行ずつ入力してみて下さい． (この章でもgdbの使い方を説明していきますが， gdbの使い方の詳細はデバッガgdbの使い方にもまとめてあります)．

$ gcc -g movq-4.s
$ gdb ./a.out ❶
(gdb) b 7 ❷
Breakpoint 1 at 0x1130: file movq-4.s, line 6.
(gdb) r ❸
Breakpoint 1, main () at movq-4.s:6
6	    ret
(gdb) list 6,6 ❹
5	    movq $999, %rax
(gdb) p $rax ❺
$1 = 999
(gdb) quit

• ❶ コンパイルしたa.outをgdb上で実行
• ❷ ブレークポイントを7行目(movq $999, %raxの次の行)に設定 (bはbreakの略)
• ❸ 実行開始 (r は run の略)
• ❹ ソースコードの6行目だけを表示
• ❺ レジスタ%raxの値を(10進表記で)表示 (pはprintの略)
• movq-4.txt の最後の行 echo # %raxの値が999なら成功\nは， 「どうなると正しく実行できたか」を確認するメッセージを出力するコマンドですので， ここでは入力不要です． ❺の結果と一致したので「正しい実行」と確認できました．

デバッガ上で実行：gdbコマンドを自動入力 (-xオプションを使う)

gdbコマンドを手入力して，よく使うgdbコマンドを覚えることは良いことです． とはいえ，手入力は面倒なので，自動入力も使いましょう．

$ gcc -g movq-4.s
$ gdb ./a.out ❶ -x movq-4.txt
Breakpoint 1, main () at movq-4.s:7
7	    ret
6	 ❷ movq $999, %rax
❸ $1 = 999 
❹ # %raxの値が999なら成功
(gdb) 

• ❶ -x movq-4.txt というオプションをつけると，指定したファイル(ここではmovq-4.txt)の中に書かれているgdbコマンドを1行ずつ順番に実行してくれます
• list 6,6を実行した結果，❷6行目のmovq $999, %rax が表示されています
• p $raxを実行した結果，%raxレジスタの値が❸999であると表示されています． ($1はgdbが扱う変数です．ここでは無視して下さい)
• echo # %raxの値が999なら成功\n をgdbが実行した結果， ❹ # %raxの値が999なら成功というメッセージが表示されています． このメッセージと❸の実行結果を見比べれば「実行結果が正しい」ことを確認できます．

デバッガ上で実行：gdbコマンドを自動入力 (sourceコマンドを使う)

$ gcc -g movq-4.s
$ gdb ./a.out
(gdb) ❶ source movq-4.txt
Breakpoint 1, main () at movq-4.s:7
7	    ret
6	    movq $999, %rax
$1 = 999
# %raxの値が999なら成功

gdbは通常通りに実行開始して， ❶ sourceコマンドを使えば，movq-4.txt中のgdbコマンドを実行できます． -xオプションとsourceコマンドは好きな方を使って下さい．

アドレッシングモード (オペランドの表記方法)

アドレッシングモードの概要

機械語命令は命令(オペコード(opcode))と その引数のオペランド(operand)から構成されています． 例えば，movq $999, %raxという命令では， movqがオペコードで，$999と%raxがオペランドです．

アドレッシングモードとはオペランドの書き方のことです． (元々は「メモリのアドレスを指定する記法」という意味で「アドレッシングモード」という用語が使われています). x86-64では大きく，以下の4種類の書き方ができます．

• fooはラベル（その値はアドレス）であり，定数と同じ扱い．(定数を書ける場所にはラベルも書ける)．
• メモリ参照では例えば-8(%rbp, %rax, 8)など複雑なオペランドも指定可能． 参照するメモリのアドレスは-8+%rbp+%rax*8になる． (以下を参照)．

アドレッシングモード：即値（定数）

定数 $999

即値(immediate value，定数)には$をつけます． 例えば$999は定数999を意味します．

# asm/movq-4.s
    .text
    .globl main
    .type main, @function
main:
    movq $999, %rax
    ret
    .size main, .-main

movq-4.sの6行目の movq $999, %raxは「定数999をレジスタ%raxに格納する」という意味です． デバッガで動作を確認します (デバッガの操作手順はmovq-4.txtにもあります)．

$ gcc -g movq-4.s
$ gdb ./a.out
(gdb) b main
Breakpoint 1 at 0x1129: file movq-4.s, line 6.
(gdb) r
Breakpoint 1, main () at movq-4.s:6
6	    movq $999, %rax
(gdb) si
main () at movq-4.s:7
7	    ret
(gdb) p $rax
$1 = 999

確かに%raxレジスタ中に999が格納されていました．

なお，多くの場合，即値は32ビットまでで，オペランドのサイズが64ビットの場合， 32ビットの即値は，64ビットの演算前に 64ビットに符号拡張 されます (ゼロ拡張だと 負の値が大きな正の値になって困るからです)． 64ビットに符号拡張される例はこちら を見て下さい． 例外はmovq命令で，64ビットの即値を扱えます． 実行例はこちらを見て下さい．

ラベル $main

定数が書ける場所にはラベル(その値はアドレス)も書けます． ラベルは関数名やグローバル変数の実体があるメモリの先頭番地を 示すために使われます(それ以外にはジャンプのジャンプ先としても使われます)． ですので，main関数の先頭番地を示すmainというラベルが main関数をコンパイルしたアセンブリコード中に存在します．

# asm/movq-6.s
    .text
    .globl main
    .type main, @function
main:
    movq $main, %rax
    ret
    .size main, .-main

movq-6.sの6行目のmovq $main, %raxは 「ラベルmainが表すアドレスを%raxレジスタに格納する」という意味です． gdbで確かめます．

$ gcc ❶ -no-pie -g movq-6.s
$ gdb ./a.out
(gdb) b main
Breakpoint 1 at ❷ 0x40110a: file movq-6.s, line 7.
(gdb) r
Breakpoint 1, main () at movq-6.s:7
7   ❸  movq $main, %rax
(gdb) ❹ si
main () at movq-6.s:8
8	ret
(gdb) p/x $rax
$1 = ❺ 0x40110a 

• まず❶ -no-pieオプションをつけてコンパイルして下さい． (-staticオプションを使ってもうまくいくと思います)

なぜ -no-pieオプション

-no-pieオプションをつけないと以下のエラーが出てしまうからです．

$ gcc -g movq-6.s
/usr/bin/ld: /tmp/ccqHsPbg.o: relocation R_X86_64_32S against symbol `main' can not be used when making a PIE object; recompile with -fPIE
/usr/bin/ld: failed to set dynamic section sizes: bad value
collect2: error: ld returned 1 exit status

-no-pieは「位置独立実行可能ファイル (PIEの説明1，PIEの説明2)を生成しない」 というオプションです． 最近のLinuxのgccでは，PIEがデフォルトで有効になっている事が多いです． PIC(位置独立コード)やPIEは「再配置(アドレス調整)無しに どのメモリ番地に配置しても，そのまま実行可能」という機械語命令列です． そのため，PIEやPICのメモリ参照では絶対アドレス(absolute address)が使えません．

-no-pieオプションが無いと， アセンブラはmovq $main, %raxという命令中のmainというラベルを 「絶対アドレスだ」と解釈してエラーにするようです．

絶対アドレス，相対アドレスとは

絶対アドレスとは「メモリの先頭0番地から何バイト目か」で示すアドレスです． 上図で青色のメモリ位置の絶対アドレスは0x1000番地となります． 一方，相対アドレス(relative address)は(0番地ではなく)別の何かを起点とした差分のアドレスです． x86-64では%ripレジスタ(プログラムカウンタ)を起点とすることが多いです． 上図では青色のメモリ位置の相対アドレスは %ripを起点とすると，-0x500番地となります(0x1000 - 0x1500 = -0x500)．

また，相対アドレスに起点のアドレスを足すと絶対アドレスになります (-0x500 + 0x1500 = 0x1000)．

なぜ PICやPIEで絶対アドレスが使えないかと言うと， 機械語命令列を何番地に置くかで，絶対アドレスが変化してしまうからです．

もうちょっと具体的に

例えば，movq $main, %raxという命令は main関数のアドレスを%raxレジスタに格納するわけですが， このアドレスが絶対アドレスの場合，出力される機械語命令に 絶対アドレスが埋め込まれてしまいます．

$ gcc -no-pie -g movq-6.s
$ objdump -d ./a.out
(一部略)
000000000040110a <main>:
  40110a:  48 c7 c0 ❷ 0a 11 40 00    mov ❶$0x40110a,%rax
  401111:  c3                        ret    

上の逆アセンブル結果を見ると，確かにmain関数のアドレス❶ 0x40110aが 機械語命令列に❷埋め込まれています． (x86-64はリトルエンディアンなので，バイトの並びが逆順に見えることに注意)．

相対アドレスだと大丈夫なことも見てみます． leaq-1.s中の leaq main(%rip), %raxは， 「%ripを起点としたmainの相対アドレスと， %ripの値との和を%raxレジスタに格納する」という命令です． (lea は load effective address の略です．effective addressは日本語では実効アドレスです)．

# asm/leaq-1.s
    .text
    .globl main
    .type main, @function
main:
    leaq main(%rip), %rax
    ret
    .size main, .-main

$ gcc -g leaq-1.s
$ objdump -d ./a.out
(一部略)
0000000000001129 <main>:
 ❶ 1129:  48 8d 05 ❸ f9 ff ff ff    lea    ❷ -0x7(%rip),%rax  # 1129 <main>
 ❹ 1130:  c3                      ret    

上のように逆アセンブルすると以下が分かります．

• main関数の(ファイルa.out中での)アドレスは❶ 0x1129番地
• leaq main(%rip), %raxの %ripの値は❸ 0x1130番地 (プログラムカウンタ %ripは「次に実行する機械語命令のアドレス」を保持しています)．
• 機械語命令に埋め込まれているアドレスは相対アドレスで， ❶ 0x1129 - ❸ 0x1130 = ❷ -0x7 = ❸ 0xFFFFFFF9 です．

❶ 0x1129 や ❹ 0x1130 のアドレスは， main関数がどのアドレスに配置されるかで変化します． しかし，この相対アドレス❷ -0x7 は main関数がどのアドレスに配置されても変化しないので， この機械語命令はPICやPIEとして使えるわけです．

❷ -0x7 が ❸ 0xFFFFFFF9 として埋め込まれているのは， 2の補数表現だからですね

なお，相対アドレスが固定にならない場合(例えば，printf関数のアドレス)もあります． その場合はGOTやPLTを使います． printf関数のアドレスを機械語命令列(.textセクション)に埋め込むのではなく， 別の書込み可能なセクション(例：gotセクション)に格納し， そのアドレスを使って間接コール(indirect call)するのです．

• main関数の先頭にブレークポイントを設定します． main関数の先頭アドレスが❷ 0x40110aと分かります．

• ❸ movq $main, %raxの実行直前で止まっているので， ❹ siで1命令実行を進めます．

• ❺ %raxレジスタ中にmain関数のアドレス❷ 0x40110aが入っていました．

アドレッシングモード：レジスタ参照

# asm/movq-1.s
    .text
    .globl main
    .type main, @function
main:
    movq $999, %rax
    movq %rax, %rbx
    ret
    .size main, .-main

movq-1.s中のmovq %rax, %rbxは 「%raxレジスタ中の値を%rbxに格納する」という意味です．

$ gcc -g movq-1.s
$ gdb ./a.out
(gdb) b main
Breakpoint 1 at 0x1129: file movq-1.s, line 6.
(gdb) r
Breakpoint 1, main () at movq-1.s:6
6	    ❶ movq $999, %rax
(gdb) si
7	    ❷ movq %rax, %rbx
(gdb) si
main () at movq-1.s:8
8	    ret
(gdb) p $rax
$1 = ❸ 999
(gdb) p $rbx
$2 = ❹ 999

gdb上での実行で，❶ 定数999が%raxに格納され， ❷ %rax中の999がさらに%rbxに格納されたことを ❸❹確認できました．

アドレッシングモード：直接メモリ参照

直接メモリ参照はアクセスするメモリ番地が定数となるメモリ参照です． 以下の例ではラベルxを使ってメモリ参照していますが， これは直接メモリ参照になります． アセンブル時に(つまり実行する前に)アドレスが具体的に(以下では0x404028番地)と決まるからです．

# asm/movq-7.s
    .data
x:
    .quad 999 
    .text
    .globl main
    .type main, @function
main:
    movq x, %rax
    ret
    .size main, .-main

$ gcc -g -no-pie movq-7.s
$ gdb ./a.out -x movq-7.txt
Breakpoint 1, main () at movq-7.s:10
10	    ret
9	    movq x, %rax
$1 = ❶ 999
# %raxの値が999なら成功

以下の図で0x401106<main>は「ラベルmainが示すアドレスは0x401106番地」 「ラベルxが示すアドレスは0x404028番地」であることを示してます．

そしてmovq-7.s中の以下の3行で，以下は

    .data
x:
    .quad 999 

「.dataセクションにサイズが8バイトのデータとして値999を配置せよ」 「そのデータの先頭アドレスをラベルxとして定義せよ」を意味しています (quadが8バイトを意味しています)． ですので，実行時には上図のように 「.dataセクションのある場所(上図では0x404028番地)に値999が入っていて， ラベルxの値は0x404028」となっています．

ですので，movq-7.s中のmovq x, %raxは 「ラベルxが表すアドレス(上図では0x404028番地)のメモリの中身(上図では999) を%raxレジスタにコピーせよ」を意味します．

実行するとmovq x, %raxの実行で，x中の999が%raxレジスタに コピーされたことを確認できました❶．

ここで$マークの有無，つまりxと$xの違いに注意しましょう (上図も参照)．

movq x, %rax    # x はメモリの中身を表す
movq $x, %rax   # $x はアドレスを表す

以下のようにmovq $x, %raxを実行すると， %raxレジスタにはアドレス(ここでは0x404028番地)が 入っていることを確認できました❷．

# asm/movq-8.s
    .data
x:
    .quad 999 
    .text
    .globl main
    .type main, @function
main:
    movq $x, %rax
    ret
    .size main, .-main

$ gcc -g -no-pie movq-8.s
$ gdb ./a.out -x movq-8.txt
Breakpoint 1, main () at movq-8.s:10
10	    ret
9	    movq $x, %rax
$1 = 0x404028 ❷
nm ./a.out | egrep 'd x'
0000000000404028 d x
# %raxの値と nmコマンドによるxのアドレスが一致すれば成功

ちなみに，xのアドレスが0x404028になると分かっていれば，

movq x, %rax          # これと
movq 0x404028, %rax   # これは同じ意味

上の2行は全く同じ意味(0x404028番地のメモリの中身)になります． しかし，何番地になるか事前に分からないのが普通なので， 通常はラベル(ここではx)を使います．

アドレッシングモード：間接メモリ参照

間接メモリ参照はアクセスするメモリ番地が変数となるメモリ参照です． アセンブリ言語では変数という概念は無いので， 正確には「実行時に決まるレジスタの値を使って， 参照先のメモリアドレスを計算して決める」という参照方式です． 以下では3つの例が出てきます(以下でより複雑な間接メモリ参照を説明します)．

以下のmovq-9.sをpushq $777まで実行すると， メモリの状態は上図のようになっています． (%rspが指す777のひとつ下のアドレスが%rsp+8なのは， pushq $777命令が「サイズが8バイトの値777をスタックにプッシュしたから」です)．

# asm/movq-9.s
    .data
foo:
    .quad 999 
    .text
    .globl main
    .type main, @function
main:
    pushq $888
    pushq $777
    movq (%rsp), %rax
    movq 8(%rsp), %rbx
    movq foo(%rip), %rcx
    ret
    .size main, .-main

• (%rsp) は「アドレスが %rspの値のメモリ」なので値777が入っている部分を参照します
• 8(%rsp) は「アドレスが %rsp + 8の値のメモリ」なので値888が入っている部分を参照します
• foo(%rip) はちょっと特殊です．この形式は %rip相対アドレッシング といいます． この形式の時，ラベルfooの値はプログラムカウンタ%rip中のアドレスを起点とした 相対アドレス になります．ですので，%rip + fooはfooの 絶対アドレス になるので， foo(%rip)はラベルfooのメモリ部分，つまり999が入っている部分になります．

$ gcc -g movq-9.s
$ gdb ./a.out -x movq-9.txt
Breakpoint 1, main () at movq-9.s:14
14	    ret
11	    movq (%rsp), %rax
12	    movq 8(%rsp), %rbx
13	    movq foo(%rip), %rcx
$1 = 777
$2 = 888
$3 = 999
# 777, 888, 999なら成功

メモリ参照の一般形

前節では， (%rsp)，8(%rsp)，foo(%rip)という間接メモリ参照の例を説明しました． ここではメモリ参照の一般形を説明します． 以下がx86-64のメモリ参照の形式です．

disp (base, index, scale) でアクセスするメモリのアドレスは base + index * scale + disp で計算します． disp(%rip)でアクセスするメモリのアドレスは disp + %ripで計算します． disp，base，index，scaleとして指定可能なものは次の節で説明します．

メモリ参照で可能な組み合わせ(64ビットモードの場合)

通常のメモリ参照

通常のメモリ参照では，disp，base，index，scaleに以下を指定できます．

• disp には符号あり定数を指定する．ただし「64ビット定数」は無いことに注意． アドレス計算時に64ビット長に符号拡張される． dispは変位(displacement)を意味する．
• base には上記のいずれかのレジスタを指定可能．省略も可．
• index には上記のいずれかのレジスタを指定可能．省略も可． %rspを指定できないことに注意．
• scale を省略すると 1 と同じ

注: dispの例外． mov␣命令のみ，64ビットのdispを指定可能． この場合，movabs␣というニモニックを使用可能． (absはおそらく絶対アドレス absolute address から)． メモリ参照はdispのみで，base，index，scaleは指定不可． 他方のオペランドは%raxのみ指定可能．

movq     0x1122334455667788, %rax
movabsq  0x1122334455667788, %rax
movq     %rax, 0x1122334455667788
movabsq  %rax, 0x1122334455667788

%rip相対参照

%rip相対参照では32ビットのdispと%ripレジスタのみが指定可能です．

メモリ参照の例

以下がメモリ参照の例です．

// array.c
int foo (int array [], int i)
{
    return array [i];
}

	.text
	.p2align 4
	.globl	foo
	.type	foo, @function
foo:
	endbr64
	movslq	%esi, %rsi
	movl	(%rdi,%rsi,4), %eax
	ret
	.size	foo, .-foo

オペランドの表記方法

以下の機械語命令の説明で使う記法を説明します． この記法はその命令に許されるオペランドの形式を表します．

オペランド，即値(定数)

• 多くの場合，サイズを省略して単にimmと書きます． 特にサイズに注意が必要な時だけ，imm32などとサイズを明記します．
• 一部例外を除き， x86-64では64ビットの即値を書けません(32ビットまでです)．

汎用レジスタ

メモリ参照

x86-64機械語命令：転送など

nop命令: 何もしない

nopは転送命令ではありませんが，最も簡単な命令ですので最初に説明します．

• nopは何もしない命令です(ただしプログラムカウンタ%ripは増加します)． フラグも変化しません．
• 機械語命令列の間を(何もせずに)埋めるために使います．
• nopの機械語命令は1バイト長です． (なのでどんな長さの隙間にも埋められます)．
• nop r/m という形式の命令は2〜9バイト長のnop命令になります． 1バイト長のnopを9個並べるより， 9バイト長のnopを1個並べた方が，実行が早くなります．
• 「複数バイトのnop命令がある」という知識は， 逆アセンブル時にnopl (%rax)などを見て「なんじゃこりゃ」とビックリしないために必要です．

mov命令: データの転送（コピー）

• mov命令は第1オペランドの値を第2オペランドに転送(コピー)します． 例えば，movq %rax, %rbxは「%raxの値を%rbxにコピー」することを意味します．

$ gcc -g movq-1.s
$ gdb ./a.out -x movq-1.txt
Breakpoint 1, main () at movq-1.s:8
8	    ret
7	    movq %rax, %rbx
# p $rbx
$1 = 999
# %rbxの値が999なら成功

$ gcc -g movq-2.s
$ gdb ./a.out -x movq-2.txt
Breakpoint 1, main () at movq-2.s:8
8	    ret
7	    movq %rax, -8(%rsp)
# x/1gd $rsp-8
0x7fffffffde90:	999
# -8(%rsp)の値が999なら成功

• オペランドには，即値，レジスタ，メモリ参照を組み合わせて指定できますが， メモリからメモリへの直接データ転送はできません．

• ␣には命令サフィックス (q, l, w, b)を指定します． 命令サフィックスは転送するデータのサイズを明示します (順番に，8バイト，4バイト，2バイト，1バイトを示します)．

  • movq $0x11, (%rsp) は値0x11を8バイトのデータとして(%rsp)に書き込む
  • movl $0x11, (%rsp) は値0x11を4バイトのデータとして(%rsp)に書き込む
  • movw $0x11, (%rsp) は値0x11を2バイトのデータとして(%rsp)に書き込む
  • movb $0x11, (%rsp) は値0x11を1バイトのデータとして(%rsp)に書き込む

movq $0x11, (%rax)

movl $0x11, (%rax)

movw $0x11, (%rax)

movb $0x11, (%rax)

機械語命令のバイト列をアセンブリコードに直書きできる

movq %rax, %rbxをコンパイルして逆アセンブルすると， 機械語命令のバイト列は48 89 C3となります． .byteというアセンブラ命令を使うと， アセンブラに指定したバイト列を出力できます． 例えば，次のように.byte 0x48, 0x89, 0xC3と書くと， .textセクションに0x48, 0x89, 0xC3というバイト列を出力できます．

# asm/byte.s
    .text
    .globl main
    .type main, @function
main:
    movq %rax, %rbx          # これと
    .byte 0x48, 0x89, 0xC3   # これは同じ意味
    ret
    .size main, .-main

$ gcc -g byte.s
$ objdump -d ./a.out
(中略)
0000000000001129 <main>:
    1129:   ❶48 89 c3     ❸mov    %rax,%rbx
    112c:   ❷48 89 c3     ❹mov    %rax,%rbx
    112f:   c3               ret    

コンパイルして逆アセンブルしてみると， ❷0x48, 0x89, 0xC3を出力できています． 一方，❶0x48, 0x89, 0xC3にも同じバイト列が並んでいます． これは❸movq %rax, %rbx命令の機械語命令バイト列ですね． さらに❷0x48, 0x89, 0xC3の逆アセンブル結果として， ❹movq %rax, %rbxとも表示されています．

つまり，アセンブラにとっては，

• movq %rax, %rbx というニモニック
• .byte 0x48, 0x89, 0xC3 というバイト列

は全く同じ意味になるのでした． ですので，.textセクションにニモニックで機械語命令を書く代わりに， .byteを使って直接，機械語命令のバイト列を書くことができます．

異なる機械語のバイト列で，同じ動作のmov命令がある

• 質問： %raxの値を%rbxにコピーしたい時， movq r, r/m と movq r/m, r のどちらを使えばいいのでしょう?
• 答え： どちらを使ってもいいです．ただし，異なる機械語命令のバイト列に なることがあります．

実は0x48, 0x89, 0xC3というバイト列は， movq r, r/m を使った時のものです． 一方，movq r/m, r という形式を使った場合は， バイト列は 0x48, 0x8B, 0xD8になります．確かめてみましょう．

# asm/byte2.s
    .text
    .globl main
    .type main, @function
main:
    .byte 0x48, 0x89, 0xC3
    .byte 0x48, 0x8B, 0xD8
    ret
    .size main, .-main

$ gcc -g byte2.s
$ objdump -d ./a.out
(中略)
0000000000001129 <main>:
    1129:    ❶48 89 c3      ❸mov    %rax,%rbx
    112c:    ❷48 8b d8      ❹mov    %rax,%rbx
    112f:      c3             ret    

❶48 89 c3と❷48 8b d8は異なるバイト列ですが 逆アセンブル結果としては ❸mov %rax,%rbxと❹mov %rax,%rbxと，どちらも同じ結果になりました．

このように同じニモニック命令に対して，複数の機械語のバイト列が存在する時， アセンブラは「実行が速い方」あるいは「バイト列が短い方」を適当に選んでくれます． (そして，アセンブラが選ばない方をどうしても使いたい場合は， .byte等を使って機械語のバイト列を直書きするしかありません)．

xchg命令: オペランドの値を交換

• xchg命令はアトミックに2つのオペランドの値を交換します．(LOCKプリフィクスをつけなくてもアトミックになります)
• このアトミックな動作はロックなどの同期機構を作るために使えます．

$ gcc -g xchg.s
$ gdb ./a.out -x xchg.txt
Breakpoint 1, main () at xchg.s:9
9	    xchg %rax, (%rsp)
1: /x $rax = 0x99aabbccddeeff00
2: /x *(void **)($rsp) = 0x1122334455667788
10	    xchg (%rsp), %rax
1: /x $rax = 0x1122334455667788
2: /x *(void **)($rsp) = 0x99aabbccddeeff00
11	    popq %rax
1: /x $rax = 0x99aabbccddeeff00
2: /x *(void **)($rsp) = 0x1122334455667788
# 値が入れ替わっていれば成功

lea命令: 実効アドレスを計算

• lea命令は第1オペランド(常にメモリ参照)の実効アドレスを計算して， 第2オペランドに格納します．
• lea命令はアドレスを計算するだけで，メモリにはアクセスしません．

$ gcc -g lea.s
$ gdb ./a.out -x lea.txt
Breakpoint 1, main () at leaq-2.s:8
8	    ret
# p/x $rsp
$1 = 0x7fffffffde98
# p/x $rsi
$2 = 0x8
# p/x $rax
$3 = 0x7fffffffdeb0
# %rax == %rsp + %rsi * 4 なら成功

• 実効アドレスとは直接メモリ参照や 間接メモリ参照で計算したアドレスことです．

実効アドレスとリニアアドレスの違いは?→(ほぼ)同じ

• 実効アドレス(effective address)は メモリ参照で disp (base, index, scale) や disp (%rip)から計算したアドレスのことです．
• x86-64のアセンブリコード中のアドレスは論理アドレス (logical address)といい， セグメントと実効アドレスのペアとなっています． このペアをx86-64用語でfarポインタとも呼びます． (本書ではfarポインタは扱いません)．
• セグメントが示すベースアドレスと実効アドレスを加えたものが リニアアドレス(linear address)です． 例えば64ビットアドレス空間だと，リニアアドレスは0番地から2⁶⁴-1番地 まで一直線に並ぶのでリニアアドレスと呼ばれています． リニアアドレスは仮想アドレス(virtual address)と等しくなります．
• また，x86-64では%fsと%gsを除き， セグメントが示すベースアドレスが0番地なので， 実効アドレスとリニアアドレスは等しくなります．
• リニアアドレス(仮想アドレス)はCPUのページング機構により， 物理アドレスに変換されて，最終的なメモリアクセスが行われます．

• コンパイラは加算・乗算を高速に実行するためlea命令を使うことがあります．

例えば，

movq $4, %rax
addq %rbx, %rax
shlq $2, %rsi   # 左論理シフト．2ビット左シフトすることで%rsiを4倍にしている
addq %rsi, %rax

は，%rax = %rbx + %rsi * 4 + 4という計算を4命令でしていますが， lea命令なら以下の1命令で済みます

leaq 4(%rbx, %rsi, 4), %rax

注: 実行時間は命令ごとに異なりますので，命令数だけで 実行時間を比較することはできません．

pushとpop命令: スタックとデータ転送

pushq %rax前

pushq %rax後

popq %rbx後

• push命令はスタックポインタ%rspを減らしてから， スタックトップ(スタックの一番上)にオペランドの値を格納します．
• pop命令はスタックトップの値をオペランドに格納してから， スタックポインタを増やします．
• 64ビットモードでは，32ビットのpushとpopはできません．
• 抽象データ型のスタックは(スタックトップに対する)プッシュ操作とポップ操作しか できませんが，x86-64のスタック操作はスタックトップ以外の部分にも自由にアクセス可能です(例えば，-8(%rsp)や-8(%rbp)などへのメモリ参照で)．
• 一番右側の図(popq %rbx後)で，ポップ後も%rspよりも上に古い値が残っています (0x11〜0x88)．このように，ポップしてもスタック上に古い値がゴミとして残ります．

$ gcc -g push1.s
$ gdb ./a.out -x push1.txt
Breakpoint 1, main () at push1.s:6
6	    pushq $999
# p/x $rsp
$1 = 0x7fffffffde98
main () at push1.s:7
7	    ret
# p/x $rsp
$2 = 0x7fffffffde90
# x/1gd $rsp
0x7fffffffde90:	999
# %rsp が8減って，(%rsp)の値が999なら成功

$ gcc -g push2.s
$ gdb ./a.out -x push2.txt
Breakpoint 1, main () at push2.s:6
6	    pushw $999
# p/x $rsp
$1 = 0x7fffffffde98
main () at push2.s:7
7	    ret
# p/x $rsp
$2 = 0x7fffffffde96
# x/1hd $rsp
0x7fffffffde96:	999
# %rsp が2減って，(%rsp)の値が999なら成功

$ gcc -g pop2.s
$ gdb ./a.out -x pop2.txt
Breakpoint 1, main () at pop2.s:7
7	    popw %ax
# p/x $rsp
$1 = 0x7fffffffde96
main () at pop2.s:8
8	    ret
# p/x $rsp
$2 = 0x7fffffffde98
# p/d $ax
$3 = 999
# %rsp が2増えて，%axの値が999なら成功

$ gcc -g push-pop.s
$ gdb ./a.out -x push-pop.txt
Breakpoint 1, main () at push-pop.s:8
8	    pushq %rax
# p/x $rsp
$1 = 0x7fffffffde98
main () at push-pop.s:9
9	    popq  %rbx
# p/x $rsp
$2 = 0x7fffffffde90
# x/8bx $rsp
0x7fffffffde90:	0x88	0x77	0x66	0x55	0x44	0x33	0x22	0x11
# %rsp の値が8減って，スタックトップ8バイトが 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11なら成功

x86-64機械語命令: 算術・論理演算

概要とステータスフラグ

ここでは以下の算術・論理演算を説明します．

これらの命令のほとんどが演算の結果として， ステータスフラグ の値を変化させます． 本書ではステータスフラグの変化を以下の記法で表します．

記法の意味は以下の通りです．

add命令: 足し算

• addとadcはオペランドが符号あり整数か符号なし整数かを区別せず， 両方の結果を正しく計算します．
• adcは例えば，多倍長整数(任意の桁数の整数)を実装する時の 「繰り上がり」の計算に便利です．

$ gcc -g add-1.s
$ gdb ./a.out -x add-1.txt
Breakpoint 1, main () at add-1.s:8
8	    ret
# p $rax
$1 = 1000
# %raxが1000なら成功

$ gcc -g add-2.s
$ gdb ./a.out -x add-2.txt
Breakpoint 1, main () at add-2.s:10
10	    popq %rbx
# p $rax
$1 = 1001
# x/1gd $rsp
0x7fffffffde90:	1000
# %raxが1001，(%rsp)が1000なら成功

$ gcc -g adc-1.s
$ gdb ./a.out -x adc-1.txt
reakpoint 1, main () at adc-1.s:8
8	    adcq $2, %rax
# p $rax
$1 = 0
# p $eflags
$2 = [ CF PF AF ZF IF ]
main () at adc-1.s:9
9	    ret
# p $rax
$3 = 3
# %rflagsでCFが立っていて，%raxが3なら成功

$ gcc -g adc-2.s
$ gdb ./a.out -x adc-2.txt
Breakpoint 1, main () at adc-2.s:9
9	    adcq $2, (%rsp)
# p $rax
$1 = 0
# p $eflags
$2 = [ CF PF AF ZF IF ]
main () at adc-2.s:10
10	    ret
x/1gd $rsp
0x7fffffffde90:	1002
# %rflagsでCFが立っていて，(%rsp)が1002なら成功

$ gcc -g adc-3.s
$ gdb ./a.out -x adc-3.txt
Breakpoint 1, main () at adc-3.s:9
9	    adcq (%rsp), %rax
# p $rax
$1 = 0
# p $eflags
$2 = [ CF PF AF ZF IF ]
main () at adc-3.s:10
10	    ret
# p $rax
$3 = 1000
# %rflagsでCFが立っていて，%raxが1000なら成功

sub, sbb命令: 引き算

• addと同様に，subとsbbは オペランドが符号あり整数か符号なし整数かを区別せず， 両方の結果を正しく計算します．

$ gcc -g sub-1.s
$ gdb ./a.out -x sub-1.txt
Breakpoint 1, main () at sub-1.s:8
8	    ret
# p $rax
$1 = 1
# %raxが1なら成功

$ gcc -g sub-2.s
$ gdb ./a.out -x sub-2.txt
Breakpoint 1, main () at sub-2.s:10
10	    popq %rbx
# p $rax
$1 = -997
# x/1gd $rsp
0x7fffffffde90:	998
# %raxが-997，(%rsp)が998なら成功

$ gcc -g sbb-1.s
$ gdb ./a.out -x sbb-1.txt
Breakpoint 1, main () at sbb-1.s:8
8	    sbbq $2, %rax
# p $rax
$1 = 0
# p $eflags
$2 = [ CF PF AF ZF IF ]
main () at sbb-1.s:9
9	    ret
# p $rax
$3 = -3
# %rflagsでCFが立っていて，%raxが-3なら成功

$ gcc -g sbb-2.s
$ gdb ./a.out -x sbb-2.txt
Breakpoint 1, main () at sbb-2.s:9
9	    sbbq $2, (%rsp)
# p $rax
$1 = 0
# p $eflags
$2 = [ CF PF AF ZF IF ]
10	    sbbq (%rsp), %rax
main () at sbb-2.s:11
11	    ret
x/1gd $rsp
0x7fffffffde90:	996
# p $rax
$3 = -996
# %rflagsでCFが立っていて，(%rsp)が996，%raxが-996なら成功

mul, imul命令: かけ算

• オペランドが1つの形式では，%raxが隠しオペランドになります． このため，乗算の前に%raxに値をセットしておく必要があります． また，8バイト同士の乗算結果は最大で16バイトになるので， 乗算結果を%rdxと%raxに分割して格納します (16バイトの乗算結果の上位8バイトを%rdxに，下位8バイトを%raxに格納します)． これをここでは(%rdx:%rax)という記法で表現しています．
• imulだけ例外的に，オペランドが2つの形式と3つの形式があります． 2つか3つの形式では乗算結果が8バイトを超えた場合， 越えた分は破棄されます(乗算結果は8バイトのみ)．

$ gcc -g mul-1.s
$ gdb ./a.out -x mul-1.txt
Breakpoint 1, main () at mul-1.s:9
9	    ret
# p $rdx
$1 = 0
# p $rax
$2 = 6
# %rdxが0, %raxが6なら成功

$ gcc -g imul-1.s
$ gdb ./a.out -x imul-1.txt
Breakpoint 1, main () at imul-1.s:9
9	    ret
# p $rdx
$1 = 0xffffffffffffffff
# p $rax
$2 = -6
# %rdxが0xFFFFFFFFFFFFFFFF, %raxが-6なら成功