ラズパイでARM入門（8.配列と構造体、その他のインデクシングモード）

前回：[7.インデクシングモード](https://qiita.com/GoodOldLandLine/items/75d96355d19b76d8586f) 次回：[9.関数その１](https://qiita.com/GoodOldLandLine/items/2a63dafa7192ca45d0e2)
[目次（記事一覧）](https://qiita.com/GoodOldLandLine/items/bb17122fee602d1aedb9)

※この記事は[Roger Ferrer Ibáñez](https://rofi.roger-ferrer.org)さんのブログ[ARM assembler in Raspberry Pi – Chapter 8](https://thinkingeek.com/2013/01/27/arm-assembler-raspberry-pi-chapter-8/)の翻訳です。

前章では、ビットをシフトまたはローテートするシフト演算子がほとんどの算術命令の第2オペランドで利用できることがわかりました。本章では、引き続きARMの命令で利用できるインデクシングモードについて学習します。今回は、ロード命令とストア命令に焦点を当てます。

# 配列と構造体

前章までに、32ビットのデータをメモリからレジスタに移動し（ロード）、メモリに戻す（ストア）ことができるようになりました。しかし、32ビット（スカラー値）だけで作業するのは少々不便です。配列と構造体について学びましょう。

配列は、同じ種類の要素の列です。配列は基本的なデータ構造であり、ほぼすべての低水準言語にあります。配列には必ずベースアドレスがあり、普通は配列の名前が使われます。また、配列にはN個の要素があり、各要素には昇順に0～N-1、または1～Nのようにインデックスが関連付けられます。ベースアドレスとインデックスを使うことで配列の要素にアクセスできます。第3章でメモリはバイト配列とみなすことができると述べました。メモリの中に作る配列も同様ですが、1つの要素は1バイトより大きくなることもあります。

構造体（レコード、タプル）は異なる種類（同じでも良い）の要素の列です。構造体の各要素はフィールドと呼ばれます。フィールドにはインデックスは付いていませんが、構造体の先頭に対するオフセットが付いています。構造体は全てのフィールドが適切なメモリ配置になるようにします。構造体のベースアドレスは1つ目のフィールドのアドレスと同じです。構造体はベースアドレスがメモリ境界に位置する場合、同様に全フィールドが適切なメモリ境界に位置するように配置される必要があります（※訳注　メモリ境界については[Wikipedia](https://ja.wikipedia.org/wiki/%E3%83%87%E3%83%BC%E3%82%BF%E6%A7%8B%E9%80%A0%E3%82%A2%E3%83%A9%E3%82%A4%E3%83%A1%E3%83%B3%E3%83%88)も参照）。

配列と構造体はロードとストアのインデクシングモードとどんな関係があるのでしょうか？実は、ロードとストアのインデクシングモードは、配列や構造体へのアクセスがしやすいように設計されています。

# 配列と構造体を定義する

<!-- 参照ではなく構造体では？
配列と参照の使い方を説明するために
-->

配列と構造体の使い方を説明するために、以下のC言語での宣言をアセンブリ言語に実装してみます。

```C
int a[100];
struct my_struct
{
  char f0;
  int f1;
} b;
```

ではまず、配列「a」を定義しましょう。ちょうど100個の整数の配列です。ARMの整数は32ビット幅のため、アセンブリコードでは400（=4*100）バイトのスペースを確保する必要があります。

```armasm:array01.s（一部）
/* -- array01.s */
.data

.balign 4
a: .skip 400
```

最後の行で識別子`a`を定義し、400バイトのスペースを確保します。ディレクティブ`.skip`は、指定したバイト数だけ進めてから次のデータを発行するようにアセンブラに指示をします。今回は、整数配列が400バイト（1個当たり4バイトの整数が100個）を使用するため400バイトをスキップしています。構造体の宣言もほとんど違いはありません。

```armasm
// array01.sの続き
.balign 4
b: .skip 8
```

ここで、構造体の持つデータが5バイトであるにも関わらず8バイトをスキップしたことを不思議に思うかもしれません。確かに構造体に保存される有用な情報は5バイトまでです。最初のフィールド`f0`は`char`型で、1個の`char`は1バイトのストレージを使用します。次のフィールド`f1`は整数型で、1個の整数は4バイトを使用しますが、整数は4バイト境界に配置されなくてはなりません。したがって、フィールド`f0`、`f1`の間には3個の空きバイトを入れる必要があります。境界をあわせるために配置されるこの空きストレージのことをパディングバイトと呼びます。パディングバイトをプログラム中で取扱わないでください。

# インデクシングモードを使わない例

では、配列a[i]の全要素を初期化するコードを書いてみましょう。実行する処理は以下のC言語コードと同等です。

```C
for (i = 0; i < 100; i++)
  a[i] = i;
```

```armasm
// array01.sの続き
.text

.global main
main:
    ldr r1, addr_of_a       /* r1 ← &a */
    mov r2, #0              /* r2 ← 0 */
loop:
    cmp r2, #100            /* 100回目か？ */
    beq end                 /* もしそうならループを抜け、違うなら続行 */
    add r3, r1, r2, LSL #2  /* r3 ← r1 + (r2*4) */
    str r2, [r3]            /* *r3 ← r2 */
    add r2, r2, #1          /* r2 ← r2 + 1 */
    b loop                  /* loopの最初へ戻る */
end:
    bx lr
addr_of_a: .word a
```

以前の章で学んだことがたくさん入っていますね。`main:`の次の行で、配列のベースアドレスを`r1`にロードします。配列のアドレスは変わらないのでロードは一度だけで良いです。レジスタ`r2`の役割は0～99のインデックスを保持することです。`loop:`の次の行では、`r2`を100と比較しループの終わりに到達したかを確認します。

`loop:`から3行後の`add r3, r1, r2, LSL #2 `は重要です。ここでは配列の要素のアドレスを計算します。`r1`はベースアドレスで、配列の各要素は4バイト幅です。さらに、`r2`は配列の各要素へのアクセスに使うループのインデックスを保持しています。各要素間が4バイトのため、要素のインデックスが`i`ならその要素のアドレスは`&a + 4*i`となります。したがって、`r3`にはその時のループ回数に即した配列の要素のアドレスが入ります。次の行の`str r2, [r3]`では、`r2`の値（=i）を`r3`が指すメモリ（=i番目の配列の要素=a[i]）へとストアします。

その後、`r2`をインクリメントし、次のループへとジャンプします。

このように、配列にアクセスするにはアクセスする要素のアドレスを計算する必要があります。ARMの命令セットにはもっと簡潔な方法があるのでしょうか？はい、いくつかのインデクシングモードが提供されています。

# インデクシングモードを使う

前章までの使い方では、インデックスを付けるようなことはしなかったため「インデクシングモード」という名前は少々ずれていました。今回はインデックスから配列の要素のアドレスを計算するので、その名前も少しばかり意味を持つでしょう。ARMはそんなインデクシングモードを9つ提供します。それらのインデクシングモードは副作用の有無で更新なしモードと更新ありモードで区別できます。副作用については更新ありインデクシングモードで解説します。

## 更新なしインデクシングモード

| 番号 | 構文 |
|:-:|:-:|
| 1 | `[Rsource1, +#immediate]` または `[Rsource1, -#immediate]` |

アドレスを作るために単純に即値を加算または減算します。これはインデックスがコード内で固定値である配列の要素へのアクセスや、オフセットが常に固定値である構造体のフィールドへのアクセスに役に立ちます。`Resource1`にはベースアドレスを入れ、`immediate`にはオフセットをバイト単位で入れます。`immediate`は12ビット[0,4096)より大きくすることはできません。`immediate`が`#0`の場合は、これまでに使ってきた通常の`[Rsource1]`のようになります。

例えば、このようにして`a[3]`に3をセットします（`r1`はすでにベースアドレスを保持していると仮定します）。オフセットはバイト単位のためオフセットが12（4バイト*3要素をスキップ）となることに注意してください。

```armasm
mov r2, #3          /* r2 ← 3 */
str r2, [r1, #+12]  /* *(r1 + 12) ← r2 */
```

| 番号 | 構文 |
|:-:|:-:|
| 2 | `[Rsource1, +Rsource2]` または `[Rsource1, -Rsource2]` |

これは1番目の構文と似ていますが、レジスタの値で加算または減算するオフセットが決まります。これは、オフセットが即値に使用できないくらい大きいときに役に立ちます。`+Rsource2`の場合、2つのレジスタは場所を交換できます（アドレス計算の結果に影響を与えません）。

例です。1番目の構文と同じですが、レジスタを使用します。

```armasm
mov r2, #3         /* r2 ← 3 */
mov r3, #12        /* r3 ← 12 */
str r2, [r1,+r3]   /* *(r1 + r3) ← r2 */
```

| 番号 | 構文 |
|:-:|:-:|
| 3 | `[Rsource1, +Rsource2, shift_operation #immediate]` または<br> `[Rsource1, -Rsource2, shift_operation #immediate]` |

この構文は他の命令で利用できる通常のシフト演算に似ています。シフト演算（`LSL, LSR, ASR, ROR`など）が`Rsource2`に適用され、その後、`Rsource2`に適用されたシフト演算の結果が`Rsource1`に加算または減算されます。これは、オフセットの計算に一定量を掛ける必要がある場合に役に立ちます。整数配列`a`の要素にアクセスするときに、インデックスに4を掛けましたね。

要素のインデックスが`r2`の場合のアドレス計算を思い出してみましょう。

```armasm
// array01.sの一部
add r3, r1, r2, LSL #2  /* r3 ← r1 + r2*4 */
str r2, [r3]            /* *r3 ← r2 */
```

これをもっとコンパクトに表現できます（`r3`レジスタは不要です）。

```armasm
str r2, [r1, +r2, LSL #2]  /* *(r1 + r2*4) ← r2 */
```

## 更新ありインデクシングモード

このインデクシングモードでは、`Rsource1`レジスタがロード、またはストア命令によって合成されたアドレスで更新されます。なぜそうしたいのか疑問に思うかもしれません。少し遠回りになりますが、配列のロードを再確認しましょう。ベースアドレスから4バイトずつ離れていくのに、ベースアドレスを保持する必要はあるのでしょうか？現在使用しているアドレスを保持する方が良いのではないでしょうか？つまり、

```armasm
// array01.sの一部
add r3, r1, r2, LSL #2  /* r3 ← r1 + r2*4 */
str r2, [r3]            /* *r3 ← r2 */
```

の代わりに、

```armasm
str r2, [r1]        /* *r1 ← r2 */
add r1, r1, #4      /* r1 ← r1 + 4 */
```

とすると、次の要素に順番にアクセスしていくようになり、アドレスを毎回最初から計算する必要がなくなります。少し改善したように見えますが、まだもう少し改善できます。仮に`r1`を更新する命令があったらどうでしょうか。こんな感じに...（正しい構文ではありません）

```
/* 不正な構文 */
str r2, [r1] "そして" add r1, r1, #4
```

このようなことをするインデクシングモードが存在します。`Rsource1`の更新タイミングに応じて2種類に分類できます。ロードまたはストア後に`Rsource1`が更新される場合（この場合`Rsource1`の初期値がロードまたはストアされる）、これをポストインデクシングモードと呼びます。実際のロードまたはストアの前に`Rsource1`が更新される場合（この場合、更新後の`Rsource1`の値をアドレスとしてロードまたはストアが行われる）、これをプレインデクシングモードと呼びます。いずれの場合も、命令終了時までにインデクシングモードの計算した値が`Rsource1`に入ります。複雑に聞こえたかもしれませんが、先程の例を見てみましょう。始めに`r1`を使ってロードして、そして`r1 ← r1 + 4`をします。よってこれはポストインデクシングです。`r2`の値をストアする場所のアドレスとして`r1`の値を最初に用いて、そして`r1`を`r1 + 4`で更新します。次に、別の架空の構文を作って考えてみます。

```
/* 不正な構文 */
str r2, [add r1, r1, #4]
```

こちらはプレインデクシングです。最初に`r1 + 4`をして、それを`r2`のアドレスをストアする場所のアドレスとして使います。こちらも`r1`の最後の時点で`r1`の更新が完了していますが、更新された値はすでにロードまたはストアのアドレスとして使用されています。

### ポストインデクシングモード

| 番号 | 構文 |
|:-:|:-:|
| 4 | `[Rsource1], #+immediate` または `[Rsource1], #-immediate` |

`Rsource1`の値はロードまたはストアのアドレスとして使用されます。その後、`Rsource1`は`immediate`の値を加算したまたは減算した値で更新されます。このインデクシングモードを使って、最初の例を以下のように書き直すことができます。

```diff_arm_asm:
// array01.sの一部
loop:
    cmp r2, #100            /* 100回目か？ */
    beq end                 /* もしそうならループを抜け、違うなら続行 */
-   add r3, r1, r2, LSL #2  /* r3 ← r1 + (r2*4) */
-   str r2, [r3]            /* *r3 ← r2 */
+   str r2, [r1], #4        /* *r1 ← r2 then r1 ← r1 + 4 */
    add r2, r2, #1          /* r2 ← r2 + 1 */
    b loop                  /* loopの最初へ戻る */
end:
```

| 番号 | 構文 |
|:-:|:-:|
| 5 | `[Rsource1], +Rsource2` または `[Rsource1], -Rsource2` |

4番目の構文と同様ですが、即値の代わりに`Resource2`の値が使用されます。オフセットが即値で表現できる範囲を超えるときの回避策として利用できます。

| 番号 | 構文 |
|:-:|:-:|
| 6 | `[Rsource1], +Rsource2, shift_operation #immediate` または<br> `[Rsource1], -Rsource2, shift_operation #immediate` |

`Rsource1`の値はロードまたはストアのアドレスに使用されます。その後、`Rsource2`にはシフト演算（`LSL, LSR, ASR, ROL`）が適用されます。そのシフト演算の結果が`Rsource1`に加算または減算され、最終的にその値で更新されます。

### プレインデクシングモード

プレインデクシングモードは最初は少し奇妙に見えるかもしれませんが、計算したアドレスにがすぐに再利用される場合に役に立ちます。再計算する代わりに更新された`Rsource1`を再利用できます。プレインデクシングモードと更新なしインデクシングモードとの区別のため`!`を用いることに注意してください。

| 番号 | 構文 |
|:-:|:-:|
| 7 | `[Rsource1, #+immediate]!` または `[Rsource1, #-immediate]!` |

1番目の更新なしインデクシングモードと同じように動作しますが、`Rsource1`は計算したアドレスで更新されます。例えば`a[3] = a[3] + a[3]`を実行したいとすると、次のように書くことができます（`r1`にはすでに配列のベースアドレスが入っていると仮定します）。

```armasm
ldr r2, [r1, #+12]!  /* r1 ← r1 + 12 そして r2 ← *r1 */
add r2, r2, r2       /* r2 ← r2 + r2 */
str r2, [r1]         /* *r1 ← r2 */
```

| 番号 | 構文 |
|:-:|:-:|
| 8 | `[Rsource1, +Rsource2]!` または `[Rsource1, -Rsource2]!` |

7番目の構文と同様ですが、即値の代わりにレジスタを使用します。

| 番号 | 構文 |
|:-:|:-:|
| 9 | `[Rsource1, +Rsource2, shift_operation #immediate]!` または<br> `[Rsource1, -Rsource2, shift_operation #immediate]!` |

3番目の更新なしインデクシングモードと同様ですが、`Rsource1`はロードまたはストア命令で使用されたアドレスで更新されます。

# 構造体に戻る

この章の例ではすべて配列を使用してきました。構造体はもう少し単純です。フィールドへのオフセットは常に一定のため、構造体のベースアドレス（最初のフィールドのアドレス）を一度取得すれば、フィールドへのアクセスは（たいてい即値の）オフセットを伴う一度のインデクシングモードの使用で済みます。例に出した構造体は、あえて最初のフィールド`f0`を`char`型としています。現在、メモリ内の4バイト以外のスカラーを扱う方法は学んでいません。よって、最初のフィールドについては後ほどの章で扱います。

例えば、このようにフィールド`f1`を加算したいとします。

```C
b.f1 = b.f1 + 7;
```

構造体のベースアドレスが`r1`に入っているとします。今は利用可能なすべてのインデクシングモードを知っているので、フィールド`f1`にアクセスするコードを書くのは非常に簡単です。

```armasm
ldr r2, [r1, #+4]!  /* r1 ← r1 + 4 そして r2 ← *r1 */
add r2, r2, #7     /* r2 ← r2 + 7 */
str r2, [r1]       /* *r1 ← r2 */
```

プレインデクシングモードを使用してフィールド`f1`のアドレスを`r1`に保存していることに注意してください。このようにすることで、2番目のストアにおいてアドレスを再計算する必要はなくなります。

今日はここまで。

次回：[9.関数その１](https://qiita.com/GoodOldLandLine/items/2a63dafa7192ca45d0e2)