a25_kharcs2 のバックアップ(No.5)

kharcs #2

(by K, 2025.06.09)

↑

(0) これはなに？

（kharcsページは、kharc開発でわかったことを整理して説明するためのページ群です。）

今回説明したいこと：～この順番でCコンパイラを作ったら早くできたよ！～
- [1]関数宣言、インラインアセンブラ（2日目）
- [2]変数宣言、インラインアセンブラ内でのラベル宣言（3日目）
- [3]四則演算、return、関数呼び出し（4日目）

↑

(1) 関数宣言、インラインアセンブラ（2日目：6/5）

とりあえず、以下の記述くらいならできるようになりました。
```
int func(int i)
{
    asm { LodRMd(R0,SP,$i); AddRI(R0,3); } // R0=i+3;
}
```

受け取った引数に3を足すだけのヘボ関数です。コンパイルすると以下のようになります。

LbI(1); // func()
 SubAI(SP,8);
 StoAMd(RP,SP,0); // RP値を保存している（とりあえず今は無条件でやっている）.
 LodRMd(R0,SP,8); AddRI(R0,3); // （ここはasmの中身）$iが8に置換されている.
 LodAMd(RP,SP,0); // RP値を復元している.
 AddAI(SP,8);
 Ret();

引数に名前を付けて参照できるので、どこに何があるのかを人間が管理しなくてもよくなりました（前に作っていたアセンブラではすべて番号でしか管理できませんでしたので、大きな進歩です）。

↑

(2) 変数宣言、インラインアセンブラ内でのラベル宣言（3日目：6/6）

ローカル変数の宣言を可能にして、スタック内がどうなっているか、コンパイラに管理してもらえるようにしました。

void main()
{
    params(1); // このmain内で行われる関数呼び出しは、引数が最大で1つだという意味（もしインラインアセンブラ内で関数呼び出ししないなら、この記述はいらない）.
    asm {
        MovRI(R0,46); StoRMd(R0,SP,0); CalII($fib,@lb0:); // R0 = fib(46);
        return R0;
    }
}

int fib(int i)
{
    int tmp;
    params(1);
    asm {
        LodRMd(R0,SP,$i); CmpJleRII(R0,1,@skip); // if (i <= 1) goto skip;
                          SubRI(R0,2); StoRMd(R0,SP,0); CalII($fib,@lb0:); StoRMd(R0,SP,$tmp); // tmp = fib(i-2);
        LodRMd(R0,SP,$i); SubRI(R0,1); StoRMd(R0,SP,0); CalII($fib,@lb1:); // R0 = fib(i-1);
        LodRMd(R1,SP,$tmp); AddRR(R0,R1); // R0 += tmp;
        LbI(@skip:);
    }
}

このfib()部分のコンパイル結果はこうなります。

LbI(4); // fib()
 SubAI(SP,16);
 StoAMd(RP,SP,12);
 LodRMd(R0,SP,16); CmpJleRII(R0,1,7); // if (i <= 1) goto skip;
                   SubRI(R0,2); StoRMd(R0,SP,0); CalII(4,5); StoRMd(R0,SP,8); // tmp = fib(i-2);
 LodRMd(R0,SP,16); SubRI(R0,1); StoRMd(R0,SP,0); CalII(4,6); // R0 = fib(i-1);
 LodRMd(R1,SP,8); AddRR(R0,R1); // R0 += tmp;
LbI(7); // skip:
 LodAMd(RP,SP,12);
 AddAI(SP,16);
 Ret();

変数オフセットやラベルなどがすべて無事に数値化できています。

スタックはこんな感じになっています。

{ [SP+0:引数用の領域8バイト] [SP+8:変数tmp] [SP+12:RP保存領域] } [SP+16:引数i]

↑

(3) 四則演算、return、関数呼び出し（4日目：6/9）

式の評価をできるようにしました。四則演算と、代入と、関数呼び出しと、returnができます。

void main()
{
    fib(46); asm { return R0; }
}

int fib(int i)
{
    asm { LodRMd(R0,SP,$i); CmpJleRII(R0,1,@skip); }

    i = fib(i - 2) + fib(i - 1); // ← ここがかっこいい！

    asm { LbI(@skip:); }
    return i;
}

インラインアセンブラじゃないところは、すごくC言語っぽいです！かっこいい！！

上記をコンパイルするとこうなります。fib()の部分を見てみましょう。

LbI(4); // fib()
 SubAI(SP,24);
 StoAMd(RP,SP,20);
 LodRMd(R0,SP,24); CmpJleRII(R0,1,7); // （ここはasmの中身）
 LodRMd(R0,SP,24); // ムダ
 SubRI(R0,2);
 StoRMd(R0,SP,8); // ムダ
 LodRMd(R0,SP,8); // ムダ
 FreI(8);
 StoRMd(R0,SP,0);
 CalII(4,5);
 StoRMd(R0,SP,8);
 LodRMd(R0,SP,24);
 SubRI(R0,1);
 StoRMd(R0,SP,12); // ムダ
 LodRMd(R0,SP,12); // ムダ
 FreI(12);
 StoRMd(R0,SP,0);
 CalII(4,6);
 StoRMd(R0,SP,12);
 LodRMd(R0,SP,8);
 LodRMd(R1,SP,12);
 AddRR(R0,R1);
 StoRMd(R0,SP,16);
 FreI(8);
 FreI(12);
 LodRMd(R0,SP,16);
 StoRMd(R0,SP,24);
 FreI(16);
LbI(7);  LodRMd(R0,SP,24); // （ここはasmの中身）
 JmpI(8); // ムダ
LbI(8); // fib().ret:
 LodAMd(RP,SP,20);
 AddAI(SP,24);
 Ret();

// { [SP+0:引数用の領域8バイト] [SP+8:内部生成した一時変数tmp0] [SP+12:tmp1] [SP+16:tmp2] [SP+20:RP保存領域] } [SP+24:引数i]

FreI()命令は、何もしないコメント命令ですので、ひとまず無視してください（内部生成した一時変数の解放タイミングを示しています）。
明らかなムダ命令が6命令も入っていますが、それを除けば、なかなか頑張っている感じはします。
ムダ命令は将来的に簡単なオプティマイザ（最適化処理）を入れてうまく消すことします。FreI()命令を入れているのは、将来オプティマイザを作りやすくするための工夫です。

最適化と言えば、定数式のコンパイル時の評価とかもやっています。
```
int func()
{
    int i, j, k;
    i = j = k = 1 + 2 * 3;
    i = (j = 4) + 5;
}
```

これをコンパイルするとこうなります。

LbI(1); // func()
 SubAI(SP,16);
 StoAMd(RP,SP,12);
 MovRI(R0,7); // 1+2*3 をコンパイル時に計算して 7 にしている.
 StoRMd(R0,SP,8); // k
 MovRI(R0,7);
 StoRMd(R0,SP,4); // j
 MovRI(R0,7);
 StoRMd(R0,SP,0); // i
 MovRI(R0,4);
 StoRMd(R0,SP,4); // j
 MovRI(R0,9); // 4+5 をコンパイル時に計算して 9 にしている.
 StoRMd(R0,SP,0); // i
LbI(2); // func().ret:
 LodAMd(RP,SP,12);
 AddAI(SP,16);
 Ret();

これはなかなかかしこいです。1日で作ったにしてはよくできてます。

↑

(4)

次は普通のラベル定義と比較演算子とif文を作って、インラインアセンブラを使わずに、fib()を書けるようにしたいです。