typedef unsigned int uint32_t;
typedef std::basic_string<uint32_t> u32stirng;

typedef boost::basic_regex<uint32_t> u32regex;
typedef boost::match_results<u32string::const_iterator> u32match;

namespace std {
template<>
bool ctype<uint32_t>::is(std::ctype_base::mask m, uint32_t c) const
{
    if (c & ~0xFFU) return false;
    return use_facet<ctype<char> >(std::locale()).is(m, static_cast<char>(c));
}
template<>
uint32_t ctype<uint32_t>::tolower(uint32_t c) const
{
    if ('A' <= c && c <= 'Z') return c - 'A' + 'a';
    return c;
}
template<>
uint32_t ctype<uint32_t>::widen(char c) const
{
    return c;
}
}

return use_facet<ctype<char> >(std::locale()).is(m, static_cast<char>(c));

static const std::ctype<char>& cache = use_facet<ctype<char> >(std::locale());
return cache.is(m, static_cast<char>(c));

static struct Custom : public std::ctype<char> {
    const mask * table() const { return std::ctype<char>::table(); }
} custom;
static const mask* maskTbl = custom.table();
return (maskTbl[(unsigned char)c] & m) != 0;

size_t strlenSSE2(const char *p)
{
    const char *const top = p;
    __m128i c16 = _mm_set1_epi8(0);
    /* 16 byte alignment */
    size_t ip = reinterpret_cast(p);
    size_t n = ip & 15;
    if (n > 0) {
        ip &= ~15;
        __m128i x = *(const __m128i*)ip;
        __m128i a = _mm_cmpeq_epi8(x, c16);
        unsigned long mask = _mm_movemask_epi8(a);
        mask &= 0xffffffffUL << n;
        if (mask) {
            return bsf(mask) - n;
        }
        p += 16 - n;
    }
    /*
        thanks to egtra-san
    */
    assert((reinterpret_cast(p) & 15) == 0);
    if (reinterpret_cast(p) & 31) {
        __m128i x = *(const __m128i*)&p[0];
        __m128i a = _mm_cmpeq_epi8(x, c16);
        unsigned long mask = _mm_movemask_epi8(a);
        if (mask) {
            return p + bsf(mask) - top;
        }
        p += 16;
    }
    assert((reinterpret_cast(p) & 31) == 0);
    for (;;) {
        __m128i x = *(const __m128i*)&p[0];
        __m128i y = *(const __m128i*)&p[16];
        __m128i a = _mm_cmpeq_epi8(x, c16);
        __m128i b = _mm_cmpeq_epi8(y, c16);
        unsigned long mask = (_mm_movemask_epi8(b) << 16) | _mm_movemask_epi8(a);
        if (mask) {
            return p + bsf(mask) - top;
        }
        p += 32;
    }
}

64ビットアプリケーションではx87命令・MMX命令及び3DNow!命令をサポートしない（x87レジスタをコンテキストスイッチの際にセーブしない）

test_mmx 1
test_mmx 3

The MMX and floating-point stack registers (MM0-MM7/ST0-ST7) are preserved across context switches

1. toyVMのスペック，命令セットと命令フォーマットを決める
2. toyVMのアセンブラを作る
3. toyVMの実行部分を作る
4. toyVM用のフィボナッチ数列プログラムを作って実行する
5. toyVMのマシン語をx86に変換するリコンパイラを作る
6. パフォーマンスを見る
7. リコンパイラを改良する

1. toyVMのスペックを決める

• 32bitレジスタA, Bの二つ．あとPC(program counter)
• メモリは4byte単位のみでのアクセス．4byte x 65536
• すべての命令は4byte固定
• 即値は全て16bit

void decode(uint32& code, uint32& r, uint32& imm, uint32 x)
{
    code = x >> 24;
    r = (x >> 16) & 0xff;
    imm = x & 0xffff;
}
void encode(Code code, Reg r, uint16 imm = 0)
{
    uint32 x = (code << 24) | (r << 16) | imm;
    code_.push_back(x);
}

2. toyVMのアセンブラを作る

void vldi(Reg r, uint16 imm) { encode(LDI, r, imm); }
void vld(Reg r, uint16 idx) { encode(LD, r, idx); }
void vst(Reg r, uint16 idx) { encode(ST, r, idx); }
void vadd(Reg r, uint16 idx) { encode(ADD, r, idx); }
void vaddi(Reg r, uint16 imm) { encode(ADDI, r, imm); }
void vsub(Reg r, uint16 idx) { encode(SUB, r, idx); }
void vsubi(Reg r, uint16 imm) { encode(SUBI, r, imm); }
void vjnz(Reg r, int offset) { encode(JNZ, r, static_cast(offset)); }
void vput(Reg r) { encode(PUT, r); }

3. toyVMの実行部分を作る

void run()
{
    uint32 reg[2] = { 0, 0 }; // A, B
    const uint32 end = code_.size();
    uint32 pc = 0;
    for (;;) {
        uint32 code, r, imm;
        decode(code, r, imm, code_[pc]);
        switch (code) {
           ...
        }
        pc++;
        if (pc >= end) break;
    } // for (;;)
}

switch (code) {
case LDI:
    reg[r] = imm;
    break;
case LD:
    reg[r] = mem_[imm];
    break;
case ST:
    mem_[imm] = reg[r];
    break;
case ADD:
    reg[r] += mem_[imm];
    break;
case ADDI:
    reg[r] += imm;
    break;
case SUB:
    reg[r] -= mem_[imm];
    break;
case SUBI:
    reg[r] -= imm;
    break;
case PUT:
    printf("%c %8d(0x%08x)\n", 'A' + r, reg[r], reg[r]);
    break;
case JNZ:
    if (reg[r] != 0) pc += static_cast<signed short>(imm);
    break;
default:
    assert(0);
    break;
}

void fibC(uint32 n)
{
    uint32 p, c, t;
    p = 1;
    c = 1;
lp:
    t = c;
    c += p;
    p = t;
    n--;
    if (n != 0) goto lp;
    printf("c=%d(0x%08x)\n", c, c);
}

Fib(int n)
{
    vldi(A, 1); // c = 1
    vst(A, 0); // p = 1
    vldi(B, n);
    vst(B, 2); // n
// lp
    vst(A, 1); // t = c
    vadd(A, 0); // c += p
    vld(B, 1); // mem[1]の値をBを経由してmem[2]に移動する
    vst(B, 0); // p = t
    vld(B, 2);
    vsubi(B, 1);
    vst(B, 2); // n--
    vjnz(B, -8); // PCを8減らせばlpのところにもどる．
    vput(A);
}

Fib fib(10);
fib.run();
>A      144(0x00000090)

void recompile()
{
    push(ebx);
    push(esi);
    push(edi);
 
    const Reg32 reg[2] = { esi, edi };
    const Reg32 mem(ebx);
 
    xor(reg[0], reg[0]);
    xor(reg[1], reg[1]);
    mov(mem, (int)mem_);
    const uint32 end = code_.size();
    uint32 pc = 0;
    uint32 labelNum = 0;
    for (;;) {
        uint32 code, r, imm;
        decode(code, r, imm, code_[pc]);
    L(toStr(labelNum++));
        switch (code) {
        ...
        pc++;
        if (pc >= end) break;
    } // for (;;)
 
    pop(edi);
    pop(esi);
    pop(ebx);
    ret();

    switch (code) {
    case LDI:
        mov(reg[r], imm);
        break;
    case LD:
        mov(reg[r], ptr[mem + imm * 4]);
        break;
    case ST:
        mov(ptr [mem + imm * 4], reg[r]);
        break;
    case ADD:
        add(reg[r], ptr [mem + imm * 4]);
        break;
    case ADDI:
        add(reg[r], imm);
        break;
    case SUB:
        sub(reg[r], ptr [mem + imm * 4]);
        break;
    case SUBI:
        sub(reg[r], imm);
        break;

    L(toStr(labelNum++));
        switch (code) {
        ...
        case JNZ:
            test(reg[r], reg[r]);
            jnz(toStr(labelNum + static_cast<signed short>(imm)));
            break;

.lp:
  mov   dword ptr [ebx+4],esi 
  add   esi,dword ptr [ebx] 
  mov   edi,dword ptr [ebx+4] 
  mov   dword ptr [ebx],edi 
  mov   edi,dword ptr [ebx+8] 
  sub   edi,1 
  mov   dword ptr [ebx+8],edi 
  test  edi,edi 
  jne   .lp

const Reg32 memTbl[] = { eax, ecx, edx };
const size_t memTblNum = NUM_OF_ARRAY(memTbl);
for (size_t i = 0; i < memTblNum; i++) xor(memTbl[i], memTbl[i]);

case ADD:
    if (imm < memTblNum) {        //
        add(reg[r], memTbl[imm]);    // 追加部分
    } else {                         //
        add(reg[r], ptr [mem + imm * 4]);
    }
    break;

.lp:
   mov         ecx,esi 
   add         esi,eax 
   mov         edi,ecx 
   mov         eax,edi 
   mov         edi,edx 
   sub         edi,1 
   mov         edx,edi 
   test        edi,edi 
   jne         .lp

typedef unsigned int uint32;
 
#ifdef WIN32
uint32 bsr(uint32 x)
{
    __asm {
        bsr eax, x
    }
}
#else
 
#define bsr(x) __builtin_clz(x)
 
#endif
 
void put(uint32 x)
{
    for (int i = 0; i < 32; i++) {
        putchar((x & (1 << (31 - i))) ? '1' : '0');
    }
    printf("\n");
}
 
int main()
{
    uint32 x = 0;
    int len = 31;
    for (int i = 0; i < 32; i++) {
        put(x);
        uint32 s = 31 - bsr(~x);
        x = ((x << s) + (1 << len)) >> s;
    }
}

Q1

lea    eax, [eax + eax*8]
lea    eax, [eax + eax*4]

Q2

cdq
xor    eax, edx
sub    eax, edx

-x = x ^ (-1) - (-1)
 x = x ^ 0 - 0

unsigned int m = (x < 0) ? -1 : 0

unsigned int m = x >> 31;
return x ^ m - m;

mov    edx, eax
sar    edx, 31

cdq ⇔ edx = eax < 0 ? -1 : 0

Q3

/* 3.1 */
.label:
...
shr    eax, 1
shr    eax, 1
jnz    .label

Q4

Q5

Q6

Q7

mov    edx, [esp+4]
bsr    eax, edx
cmovz  eax, edx
ret

    mov    eax, [esp+4]
    test   eax, eax
    jz     .skip
    bsr    eax, eax
    jmp    .exit
.skip:
    mov    eax, [0の時の特殊値]
.exit:

    mov    edx, [esp+4]
    bsr    eax, edx
    cmovz  eax, [0の時の特殊値]

Q8

sub    esp, 8192
mov   [esp+4096], eax ; dummy write
mov   [esp], eax
add    esp, 8192

Q9

FPUの場合

cwOrg dw ; デフォルトのFPU制御ワード
cwTrunc dw ; cwOrg |= (3 << 10) ; truncate to 0
 
; ループ前
fldcw    [cwTrunc] ; 丸めモードを0への切り捨てに変更する
; ループ内
fistp    dword [...]
; ループ後
fldcw    [cwOrg] ; デフォルトモードに復元

SSEの場合

mxcsrOrg dd ; デフォルトのMXCSRレジスタ
mxcsrTrunc dd msxcrOrg |= (3 << 11) ; truncate to 0
; ループ前
ldmscsr    [mxcsrTrunc] ; 丸めモードを0への切り捨てに変更する
; ループ内
cvtps2pi [...] ; float x 2 → int x 2
; ループ後
ldmxcsr    [mxcsrOrg] ; デフォルトモードに復元

SSE2の場合

cvttps2piを使えばMSCSRレジスタを変更することなく切り捨てを行える

SSE3搭載CPUでFPUを使う場合

fisttpを使えばFPU制御ワードを変更することなく切り捨てを行える

Q10

proc log2A
    mov   edx, [esp+4]
    mov   eax, [esp+8]
    mov   ecx, [esp+12]
    push  ebx
.lp:
    mov   ebx, [eax]
    add   eax, byte 4
    bsr   ebx, ebx
    mov   [edx], ebx
    add   edx, byte 4
    sub   ecx, byte 1
    jnz   .lp
    pop   ebx
    ret

_1023   dd 1023, 1023, 1023, 1023
 
proc log2B
    mov        edx, [esp+4]
    mov        eax, [esp+8]
    mov        ecx, [esp+12]
.lp:
    cvtpi2pd   xm0, [eax]      ; [D1_H:D1_L:D0_H:D0_L]
    cvtpi2pd   xm1, [eax+8]    ; [D3_H:D3_L:D2_H:D2_L]
    add        eax, 16
    shufps     xm0, xm1, (3 * 64 + 1 * 16 + 3 * 4 + 1)
                               ; [D3_H:D2_H:D1_H:D0_H]
                               ; 32bit右シフト相当
    psrld      xm0, 20         ; 20bit右シフト
    psubd      xm0, [_1023]
    movaps     [edx], xm0
    add        edx, 16
    sub        ecx, byte 4
    jnz        .lp
    ret

_127 dd 127, 127, 127, 127
 
proc    log2C
    mov        edx, [esp+4]
    mov        eax, [esp+8]
    mov        ecx, [esp+12]
.lp:
    cvtpi2ps   xm0, [eax]      ; [*:*:F1:F0]
    cvtpi2ps   xm1, [eax + 8]  ; [*:*:F3:F2]
    punpckldq  xm0, xm1        ; [F3:F2:F1:F0]
    add        eax, 16
    psrld      xm0, 23
    psubd      xm0, [_127]
    movaps     [edx], xm0
    add        edx, 16
    sub        ecx, byte 4
    jnz        .lp
    ret

• 環境は32bit OS上のPentium4以降のx86 CPU
• 関数の呼び出し規約は__cdecl
• 配列は16byte alignmentされていて複数の配列はオーバーラップしていない
• ループは4の倍数と仮定してよい

Q1(5点)

Q2(6点)

; input :  eax
; output:  eax
; destroy: edx
 
mov    edx, eax
sar    edx, 31
xor    eax, edx
sub    eax, edx

Q3(各4点)

/* 3.1 */
.label:
...
shr   eax, 2
jnz    .label

/* 3.2 */
.label:
...
sub   ecx, byte 1
jnz    .label

Q4(8点)

Q5(8点)

magic dd 0x01800000
x dd 1.5 ; float
 
movss    xm0, [x]
paddd    xm0, [magic]

Q6(12点)

Q7(10点)

int getBit(unsigned int x)
{
    for (int i = 31; i >= 0; i--) {
        if (x & (1 << i)) return i;
    }
    return 0;
}

Q8(8点)

sub    esp, 8192
mov    [esp], eax
add    esp, 8192

Q9(15点)

/*
    -1 <= in[i] <= 1とする．
*/
void func(int *out, const float *in, int n)
{
    for (int i = 0; i < n; i++) {
        out[i] = int(in[i] * 32767);
    }
}

Q10(20点)

void log2(int *dest, const int *src, int n)
{
    for (int i = 0; i < n; i++) {
#if 0
          /* わずかな誤差で意図しない値になることがあったので修正 */
//        dest[i] = (int)(log(src[i]) / log(2));
#else
        int j;
        int x = src[i];
        for (j = -1; x > 0; j++) {
            x >>= 1;
        }
        dest[i] = j;
#endif
    }
}

汎用性の高い規約

• C++での関数宣言にはextern "C"をつける．
• 引数の型はvoid, int(32bit)，またはポインタのみとする．構造体，浮動小数は扱わない．
• 返り値はvoid, int，またはポインタのみとする．

double func(double a, double b);

void func(double *out, const double *a, const double *b);

呼び出す側の規約

• funcの引数を右側からpushする．
• call funcする(Xbyakではcall(int(func));)．
• 引数の数 x 4だけespを大きくする．
• 関数の返り値はeaxに入っている．void型の場合はeaxの値は不定．

int func0(int a, char *b, double *c);

push(ポインタcの値);
push(ポインタbの値);
push(aの値);
call(int(func0));
add(esp, 3 * 4); /* 引数が3個なので3 * 4 */

void func();

call(int(func));

呼び出される側の規約

• 返り値はeaxに代入する(返り値がvoidならeaxの値は不定)．
• 汎用レジスタのうちebx, esi, edi, ebp, espの値は関数を抜けるときに呼び出されたときの状態に戻す．ecx, edxの値を保存する必要はない．
• ret();で関数から戻る．

esp + 8 : c
esp + 4 : b
esp + 0 : a

esp + 12: c
esp + 8 : b
esp + 4 : a
esp + 0 : 次の命令のアドレス

extern "C" void func(int a, int b, int c)
{
}
 
int main()
{
    func(1, 2, 3);
}

<asm>
00401B97   push        3
00401B99   push        2
00401B9B   push        1
00401B9D   call        @ILT+1400(func) (0040157d)
00401BA2   add         esp,0Ch
 
<レジスタ>
 EAX = CCCCCCCC EBX = 7FFDF000 ECX = 00000000 EDX = 00371538
 ESI = 00000000 EDI = 0012FF70
 EIP = 00401B9D ESP = 0012FADC EBP = 0012FF80 EFL = 00000212
 
<スタック>
0012FADC  01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00
0012FAEC  00 00 00 00 00 F0 FD 7F CC CC CC CC CC CC CC CC
0012FAFC  CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC

<レジスタ>
 EAX = CCCCCCCC EBX = 7FFDF000 ECX = 00000000 EDX = 00371538
 ESI = 00000000 EDI = 0012FF70
 EIP = 00401B30 ESP = 0012FAD8 EBP = 0012FF80 EFL = 00000212
 
<スタック>
0012FAD8  A2 1B 40 00 01 00 00 00 02 00 00 00 03 00 00 00
0012FAE8  00 00 00 00 00 00 00 00 00 F0 FD 7F CC CC CC CC
0012FAF8  CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC

• アドレス
• レジスタ
• インストラクションポインタ
• スタック

アドレス

レジスタ

インストラクションポインタ

    push((int)"Hello Xbyak!"); // (C1)
    call((int)puts); // (C2)
    add(esp, 4); // (C3)
    ret(); // (C4)

void hello()
{
    puts("Hello Xbyak!");
}

C1.

文字列"Hello Xbyak!"はメモリ上のstaticな領域に格納されています．これをputsの引数として与えるには，そのアドレスをスタック領域に保存します．なぜスタック領域に保存するのかについては今後説明します．とりあえずここでは関数の引数はスタックに格納する必要があることを覚えてください． そして，データをスタック領域に保存するにはpush命令を使います．intにキャストしているのはXbyakの文法のせいです．つまりこの行は"Hello Xbyak!"が格納されたアドレスをスタック領域に確保することを意味します．スタックで述べたようにスタック領域は0に向かいますので，pushするとespの値が4(byte)減ります．デバッガでpushの前後でespの値が4減っていることを確認してください．

C2.

引数がスタック領域に確保にされたのでCのputs関数を呼び出します．Xbyakの文法上，intにキャストしています．この行が実行されるとコンソールに文字列が表示されていることをデバッガで確認してください．

C3.

C1でスタック領域に引数を渡したので，このままではスタック領域は4byte減ったままになります．スタックは貴重です．この関数ではもうこの領域は使いませんから開放する必要があります．espに4を足してスタック領域を基に戻しましょう．add esp, 4はC表記のesp += 4;と同じです．

C4.

hello()関数を抜けて元のmain()関数に戻ります．そのためにはret命令を使います．デバッガでこの命令を実行するとmainに戻ることを確認してください． 以下にgdbで追いかけたときのログを表示します．実際に自分でも実行してみると理解しやすいでしょう．

(gdb) al
0x804b190:      push   0x804a756
0x804b195:      call   0x8048710 <puts@plt>
0x804b19a:      add    esp,0x4
0x804b19d:      ret
(gdb) p $esp
$1 = (void *) 0xbffff2ac      // (*)
(gdb) si
0x0804b195 in ?? ()           // (C1)を実行した
(gdb) p $esp
$2 = (void *) 0xbffff2a8      // (*)に比べてespの値が4減っている
(gdb) ni                      // (C2)callを実行する
Hello Xbyak!                  // 文字列が表示された
0x0804b19a in ?? ()
(gdb) si
0x0804b19d in ?? ()           // (C3)を実行
(gdb) p $esp
$3 = (void *) 0xbffff2ac      // espの値が(*)に戻った
(gdb) ni
main () at t.cpp:19
19              return 0;

今回はアドレス，レジスタとスタック，puts("Hello Xbyak!")の中身を説明しました．次回はサンプルプログラムの説明を続けます． ]]>

• レジスタやスタックを理解する
• 関数を作れる
• SIMD命令の基礎を知る
• JITのメリットを理解する

#include "xbyak/xbyak.h"
#include <stdio.h>
 
struct HelloGenerator : public Xbyak::CodeGenerator { // (A)
    HelloGenerator() // (B)
    {
        push((int)"Hello Xbyak!"); // (C1)
        call((int)puts); // (C2)
        add(esp, 4); // (C3)
        ret(); // (C4)
    }
};
 
int main()
{
    HelloGenerator hello; // (D)
    void (*code)() = (void (*)())hello.getCode(); // (E)
    code(); // (F)
    return 0;
}

> g++ t.cpp -g -fno-operator-names
> ./a.out
> Hello Xbyak!

#include <stdio.h>
int main(int argc, char *argv[])
{
    argc == 1 and puts("need option");
}

19:       code();
00401696 8B F4                mov         esi,esp
00401698 FF 95 F4 FE FF FF    call        dword ptr [ebp-10Ch]
0040169E 3B F4                cmp         esi,esp
004016A0 E8 2B 14 01 00       call        __chkesp (00412ad0)

003730A4 68 B0 01 44 00       push        offset string "Hello Xbyak!" (004401b0)
003730A9 E8 62 FA 09 00       call        puts (00412b10)
003730AE 83 C4 04             add         esp,4
003730B1 C3                   ret

>gdb ./a.out
>b HelloGenerator.getCode
Breakpoint 1 at 0x804b2b6: file xbyak/xbyak.h, line 1307.

(gdb) r
Starting program: /home/shigeo/Program/xbyak/a.out
Breakpoint 1, Xbyak::CodeGenerator::getCode (this=0xbffff2e0) at xbyak/xbyak.h:1307
1307                    assert(!hasUndefinedLabel());
(gdb) n
1309                    return top_;
(gdb)([Enter]を押す)
1310            } ([Enter]を押す)
(gdb) ([Enter]を押す)
main () at t.cpp:19
19              code();

(gdb) define al
Type commands for definition of "al".
End with a line saying just "end".
>x/11i $pc
>end

(gdb) al
0x8048904 <main+52>:    mov    eax,DWORD PTR [ebp-12]
0x8048907 <main+55>:    call   eax
0x8048909 <main+57>:    mov    ebx,0x0
0x804890e <main+62>:    lea    eax,[ebp-0x108]
0x8048914 <main+68>:    mov    DWORD PTR [esp],eax
0x8048917 <main+71>:    call   0x8049c2c <~HelloGenerator>
0x804891c <main+76>:    mov    DWORD PTR [ebp-0x10c],ebx
0x8048922 <main+82>:    jmp    0x8048952 <main+130>
0x8048924 <main+84>:    mov    DWORD PTR [ebp-0x110],eax
0x804892a <main+90>:    mov    ebx,DWORD PTR [ebp-0x110]
0x8048930 <main+96>:    lea    eax,[ebp-0x108]

(gdb) si
0x08048907      19              code();
(gdb) ([Enter]を押す)
0x0804c190 in ?? ()

(gdb) al
0x804c194:      push   0x804b44b
0x804c199:      call   0x8048734 <puts@plt>
0x804c19e:      add    esp,0x4
0x804c1a1:      ret

• 普通のgasやNASMによる解説はありふれていること
• Windows，Linux，Intel Macで同じソースが使え，C++だけで閉じているためアセンブラの設定に悩まなくてすむこと
• JITなどの特殊な最適化ができること

>./test0
xbyak version=1.06
0 + ... + 0 = 0
0 + ... + 1 = 1
0 + ... + 2 = 3
0 + ... + 3 = 6
0 + ... + 4 = 10
0 + ... + 5 = 15
0 + ... + 6 = 21
0 + ... + 7 = 28
0 + ... + 8 = 36
0 + ... + 9 = 45
0 + ... + 10 = 55
0 + 0 = 0
1 + 1 = 2
2 + 2 = 4
3 + 3 = 6
4 + 4 = 8
5 + 5 = 10
6 + 6 = 12
7 + 7 = 14
8 + 8 = 16
9 + 9 = 18
call atoi("123") = 123
jmp atoi("456") = 456
OK

make install

test0

1から10までの和や，足し算，atoi()の呼び出しテストです．

quantize

JPEGやMPEGで使われる量子化のサンプルです．起動して1～100の数値を入力してください．最初にC版，次にxbyakによる演算時間が表示されます．

calc

簡単な関数計算デモです．引数に"x*(x+1)"などを与えて実行してください．このデモのコンパイルにはboostのインストールが必要です．

bf

BrainfuckJIT環境です．./bf hello.bfとしてください．

add3 : function(y) {
    return y + 3;
}

addF : function(x) {
    var z = 2;
    for (var i = 0; i < 3; i++) {
        z += this.add3(i);
    }
    return z;
}

function(x) {
    var z = 2;
        z += this.add3(0);
        z += this.add3(1);
        z += this.add3(2);
    return z;
}

function(x) {
    var z = 2;
    {
        var _y = 0; z+=(_y + 3);
    }
    {
        var _y = 1; z+=(_y + 3);
    }
    {
        var _y = 2; z+=(_y + 3);
    }
    return z;
}