C++/スクリプト のバックアップ差分(No.7)

• バックアップ一覧
• 現在との差分 を表示
• 現在との差分 - Visual を表示
• ソース を表示
• バックアップ を表示
• C++/スクリプト へ行く。
  • 1 (2009-01-24 (土) 00:52:53)
  • 2 (2009-01-24 (土) 02:07:54)
  • 3 (2009-01-24 (土) 03:04:58)
  • 4 (2009-01-24 (土) 03:04:58)
  • 5 (2009-01-24 (土) 18:25:26)
  • 6 (2009-01-24 (土) 23:22:30)
  • 7 (2009-01-25 (日) 00:33:08)
  • 8 (2009-01-25 (日) 00:33:08)
  • 9 (2009-01-25 (日) 16:18:55)
  • 10 (2009-01-25 (日) 18:45:20)
  • 11 (2009-01-25 (日) 19:05:21)
  • 12 (2009-01-25 (日) 20:50:20)
  • 13 (2009-02-01 (日) 22:16:54)
  • 14 (2009-02-01 (日) 22:16:54)
  • 15 (2009-03-30 (月) 01:18:05)
  • 16 (2009-04-02 (木) 00:05:53)
  • 17 (2009-04-04 (土) 19:02:38)

• 追加された行はこの色です。
• 削除された行はこの色です。

* スクリプト [#a5edfb45]
#contents
いつものように妄想という名の遊び。

* バイトコード [#k6da8bb7]
スクリプトを解析後，変換されるバイトコード。
命令長が多少長くなっても，１命令で処理される内容が多い方がよいだろう。

* アセンブラ言語 [#fba2a405]
** オペランド [#t4cad9d2]
*** num - 数値 [#ae8a2597]
頭に何も付けず数値，この場合は１０進数表記。
もしくは頭に表記接頭辞''f'',''b'',''d'',''h'',''x''，を付ける。
符号を付ける場合は，表記接頭辞より手前に書く。
#code(){{
// 10進数表記
copy4 &bp[-4] 12345
copy4 &bp[-4] d12345
// 2進数表記
copy4 &bp[-4] b0001
// ８進数表記
copy4 &bp[-4] h7543
// １６進数表記
copy4 &bp[-4] x0123ABCD
// 浮動点小数
copy4 &bp[-4] f1.23456
}}
*** pointer value [#dbd08b25]
:@ - シンボル|
シンボル名に使っていい文字列は[a-zA-Z0-9_]。ただし１文字目に数値は使えない。
宣言するときはシンボル名の後に'':''。
参照するときは頭に@を付け，その後シンボル名。
#code(){{
VALUE_ONE:
    s32 1

func:
    copy4 &bp[-4] @VALUE_ONE[0]
}}

:bp - ベースポインタレジスタ|
スタック上のベースとなる位置。
#code(){{
func:
    copy4 &bp[-4] 1
}}

:reg - 計算用レジスタ|
好きに使って良いテンポラリレジスタ。
reg[0]からreg[31]まで使える。
エイリアスもある。
r0 == &reg[0] , r1 == &reg[4] , ... r7 = &reg[28]

:& - アドレス値を受け取る|
先頭に''&''。
#code(){{
func:
    copy4 &bp[-4] &bp
}}

:* - アドレス先の値を受け取る|
先頭に''*''。
#code(){{
func:
    copy4 &bp[-4] *bp[-8]
}}

:相対アドレスの指定|
後ろに[数値]で指定。
省略したら[0]と等価。

:example|
#code(){{
# addr is 0x100
CONST_VALUE:
  s32 10
  s32 20
  u32 0x100
  u32 0x110

#addr is 0x110
MUTABLE_VALUE:
  s32 0
  s32 0

func:
  copy4 @MUTABLE_VALUE @CONST_VALUE     # 0x110 = 0x100
  copy4 @MUTABLE_VALUE @CONST_VALUE[0]  # 0x110 = 10
  copy4 @MUTABLE_VALUE &@CONST_VALUE[1] # 0x110 = 0x108
  copy4 @MUTABLE_VALUE *@CONST_VALUE[2] # 0x110 = 10

}}
** ニーモニック命令 [#uc3b37a5]
*** 表記 [#b934f54d]
|表記|説明|
|addr|読み書きするアドレス。|
|[name]:[type]|値の名前とその値の型。|
|name|名前。|
|type|型。最初１文字が種類。２文字目がバイト数|
#code(){{
 Operation:
   OperationCode Argument
   OperationCode Argument Argument
 
 OperactionCode:
   addi4
   copy4
   ...

 Argument:
   Name:Type

 Name:
   a-zA-Z

 Type:
   [aisuf][1248] # prefix is type kind. sufix is type size.
}}

:型の接頭辞|
-a - any なんでもよし
-i - integer 整数
-s - signed integer 符号付き整数
-u - unsigned integer 符号無し整数
-f - float 浮動小数
-p - address アドレス

*** add - addition [#qe926862]
:code|
addi1 addr val:i1
addi2 addr val:i2
addi4 addr val:i4
addi8 addr val:i8
addf4 addr val:f4
addf8 addr val:f8
addi1 addr:p val:i1
addi2 addr:p val:i2
addi4 addr:p val:i4
addi8 addr:p val:i8
addf4 addr:p val:f4
addf8 addr:p val:f8

:c summary|
 *addr = *addr + val;

*** band - bit and [#ke51ecc3]
:code|
and1 addr val:a1
and2 addr val:a2
and4 addr val:a4
and8 addr val:a8
and1 addr:p val:a1
and2 addr:p val:a2
and4 addr:p val:a4
and8 addr:p val:a8

:c summary|
 *addr = addr & val;

*** bnot - bit not [#t94f668f]
:code|
bnot1 addr
bnot2 addr
bnot4 addr
bnot8 addr
bnot1 addr:p
bnot2 addr:p
bnot4 addr:p
bnot8 addr:p

:c summary|
 *addr = ~*addr;

*** bor - bit or [#s44cc09f]
:code|
bor1 addr val
bor2 addr val
bor4 addr val
bor8 addr val
bor1 addr:p val:a1
bor2 addr:p val:a2
bor4 addr:p val:a4
bor8 addr:p val:a8

:c summary|
 *addr = *addr | val;

*** bxor - bit xor [#c38745c8]
:code|
bxor1 addr val
bxor2 addr val
bxor4 addr val
bxor8 addr val
bxor1 addr:p val:a1
bxor2 addr:p val:a2
bxor4 addr:p val:a4
bxor8 addr:p val:a8

:c summary|
 *addr = *addr ^ val;

*** cmp  - compare [#cc7b57c2]
:code|
cmps1 lhs rhs
cmps2 lhs rhs
cmps4 lhs rhs
cmps8 lhs rhs
cmpu1 lhs rhs
cmpu2 lhs rhs
cmpu4 lhs rhs
cmpu8 lhs rhs
cmpf4 lhs rhs
cmpf8 lhs rhs
(cmps is signed integer compare. cmpu is unsigned integer compare. cmpf is floating point compare.)
cmps1 lhs:s1 rhs:s1
cmps2 lhs:s2 rhs:s2
cmps4 lhs:s4 rhs:s4
cmps8 lhs:s8 rhs:s8
cmpu1 lhs:u1 rhs:u1
cmpu2 lhs:u2 rhs:u2
cmpu4 lhs:u4 rhs:u4
cmpu8 lhs:u8 rhs:u8
cmpf4 lhs:f4 rhs:f4
cmpf8 lhs:f8 rhs:f8

:c summary|
 cr[0] = lhs < rhs;
 cr[1] = lhs == rhs;
 cr[2] = lhs == NaN; (only cmpf)
 cr[3] = rhs == NaN; (only cmpf)

*** cnv - type convert [#we231cea]
:code|
cnvF4tF8 addr
cnvF4tS4 addr
cnvF4tU4 addr
cnvF8tF4 addr
cnvF8tS8 addr
cnvF8tU8 addr
cnvS1tS4 addr
cnvS2tS4 addr
cnvS4tF4 addr
cnvS4tS1 addr
cnvS4tS2 addr
cnvS4tS8 addr
cnvS4tU4 addr
cnvS8tF8 addr
cnvS8tS4 addr
cnvS8tU8 addr
cnvU1tU4 addr
cnvU2tU4 addr
cnvU4tF4 addr
cnvU4tS4 addr
cnvU4tU1 addr
cnvU4tU2 addr
cnvU4tU8 addr
cnvU8tF8 addr
cnvU8tS8 addr
cnvU8tU4 addr
cnvF4tF8 addr:p
cnvF4tS4 addr:p
cnvF4tU4 addr:p
cnvF8tF4 addr:p
cnvF8tS8 addr:p
cnvF8tU8 addr:p
cnvS1tS4 addr:p
cnvS2tS4 addr:p
cnvS4tF4 addr:p
cnvS4tS1 addr:p
cnvS4tS2 addr:p
cnvS4tS8 addr:p
cnvS4tU4 addr:p
cnvS8tF8 addr:p
cnvS8tS4 addr:p
cnvS8tU8 addr:p
cnvU1tU4 addr:p
cnvU2tU4 addr:p
cnvU4tF4 addr:p
cnvU4tS4 addr:p
cnvU4tU1 addr:p
cnvU4tU2 addr:p
cnvU4tU8 addr:p
cnvU8tF8 addr:p
cnvU8tS8 addr:p
cnvU8tU4 addr:p

:c summary|
 *addr = (type)*addr;

*** copy - single data copy [#e24d1a69]
:code|
copy1 addr val
copy2 addr val
copy4 addr val
copy8 addr val
copy1 addr:p val:a1
copy2 addr:p val:a2
copy4 addr:p val:a4
copy8 addr:p val:a8

:c summary|
 *addr = val

*** dec - decremental [#c3d22c67]
:code|
decf4 addr:p 
decf8 addr:p 
deci1 addr:p
deci2 addr:p
deci4 addr:p
deci8 addr:p

:c summary|
 --*addr;

*** div - division [#q8f62086]
:code|
divf4 addr:p val:f4
divf8 addr:p val:f8
divs1 addr:p val:s1
divs2 addr:p val:s2
divs4 addr:p val:s4
divs8 addr:p val:s8
divu1 addr:p val:u1
divu2 addr:p val:u2
divu4 addr:p val:u4
divu8 addr:p val:u8

:c summary|
 *addr = *addr / val;

*** enter - begin of function [#s4d19122]
:code|
enter push_stack_size
enter push_stack_size:u4

:summary|
push bp;  sp -= push_stack_size;
:asm summary|
 push bp;  sp -= push_stack_size;

*** inc - incremental [#c31d1776]
:code|
incf4 addr:p 
incf8 addr:p 
inci1 addr:p
inci2 addr:p
inci4 addr:p
inci8 addr:p

:c summary|
 ++*addr;

*** jump - jump program address [#y641cfb3]
:code|
jump   dist_or_symbol
jumpe  dist # if equal
jumpne dist # if not equal
jumpl  dist # if less
jumple dist # if less equal
jumpv  dist # if NaN exist
jumpnv dist # if not NaN exist
jump   dest_or_symbol:p
jumpe  dest:p # if equal
jumpne dest:p # if not equal
jumpl  dest:p # if less
jumple dest:p # if less equal
jumpu  dest:p # if NaN exist
jumpnu dest:p # if not NaN exist
*** leave - end of function [#j3a9666b]
:code|
leave

:summary|
:asm summary|
sp = bp; pop bp;

*** mcopy - multi data copy [#e24d1a69]
*** mcopy - multi data copy [#k4bc823b]
:code|
mcopy dest src length
mcopy4 dest:p src:p length:u4

:summary|
memcpy(dest,src,length);
:c summary|
 memcpy(dest,src,length);

*** mod - [#g5b972f0]
:code|
mods1 addr:p val:s1
mods2 addr:p val:s2
mods4 addr:p val:s4
mods8 addr:p val:s8
modu1 addr:p val:u1
modu2 addr:p val:u2
modu4 addr:p val:u4
modu8 addr:p val:u8

:c summary|
 *addr = *addr % val;

*** mul - multiply [#sbf078cf]
:code|
mulf4 addr:p val:f4
mulf8 addr:p val:f8
muls1 addr:p val:s1
muls2 addr:p val:s2
muls4 addr:p val:s4
muls8 addr:p val:s8
mulu1 addr:p val:u1
mulu2 addr:p val:u2
mulu4 addr:p val:u4
mulu8 addr:p val:u8

:c summary|
 *addr = *addr * val;

*** sll - shift left as logical [#e4fbcec7]
:code|
 sll1 addr num
 sll2 addr num
 sll4 addr num
 sll8 addr num
 sll1 addr:p num:u1
 sll2 addr:p num:u2
 sll4 addr:p num:u4
 sll8 addr:p num:u8

:c summary|
 *addr <<= num
 *addr = *addr << num;

*** srl - shift right as logical [#r4a47f80]
:code|
 slr1 addr num
 slr2 addr num
 slr4 addr num
 slr8 addr num
 slr1 addr:p num:u1
 slr2 addr:p num:u2
 slr4 addr:p num:u4
 slr8 addr:p num:u8

:c dummary|
 *addr >>= num
 *addr = *addr >> num;

*** sub - substitute [#cafb3924]
:code|
subf4 addr:p val:f4
subf8 addr:p val:f8
subs1 addr:p val:s1
subs2 addr:p val:s2
subs4 addr:p val:s4
subs8 addr:p val:s8
subu1 addr:p val:u1
subu2 addr:p val:u2
subu4 addr:p val:u4
subu8 addr:p val:u8

:c summary|
 *addr = *addr - val;

** メモ [#n35db29d]
#code(){{

main:
    enter 4 # push bp , bp = sp , sp = bp-4

    leave # sp = bp , pop bp
}}


#code(c,){{

const int CONST_VALUE = 1;
const int* CONST_VALUE_ADDR = &CONST_VALUE;

struct Pos
{
  int x;
  int y;
};
const Pos CONST_OBJ_VALUE = {0,0};
const Pos* CONST_OBJ_VALUE_ADDR = &CONST_OBJ_VALUE;

void func()
{
  int stack_value; // -4(bp)
  int* stack_value_ptr: // -8(bp)

  int i; // -12(bp)
  i = 1; // 値 load i 1

  // シンボルを参照 
  // load bp[-12] @CONST_VALUE_ADDR[0]
  i = *CONST_VALUE_ADDR; 

  // シンボルを参照 
  // load bp[-12] @CONST_OBJ_VALUE_ADDR[4]
  i = CONST_OBJ_VALUE.y; 

  // ベースポインタの相対指定
  // load bp[-12] bp[-4]
  i = stack_value; 

  // ベースポインタの相対アドレス
  // load bp[-8] &bp[-4]
  stack_value_addr = &stack_value;

  // ベースポインタの相対指定をアドレスとみなし参照
  // load bp[-12] *bp[-8]
  i = *stack_value_ptr; 
} 
}}

op[i1-i8f4-f8] val[p] val[i1-i8f4-f8]
op[a1-a8] val[p] val[a1-a8]
op[a1-a8] val[p]
op[f4-f8s1-s8u1-u8] val[f4-f8s1-s8u1-u8] val[f4-f8s1-s8u1-u8]
op[i1-i9f4-f8] val[p]
op[f4-f8s1-s8u1-u8] val[p] val[f4-f8s1-s8u1-u8]
op val:u4
op val:p
op val:p val:p val:u4
op[s1-s8u1-u8] val[p] val[s1-s8u1-u8]
op[a1-a8] val[p] val[u1-u8]

cnvは特殊


val[p]:
 &bp[n]
 &symbol[n]
 &reg[n]
 値は禁止。

val[afisu]:
 num
 bp[n]
 symbol[n]
 reg[n]
 *bp[n]
 *symbol[n]
 *reg[n]
 &bp[n]
 &symbol[n]
 &reg[n]