Next: YACASL2の概要 [Contents]

YACASL2 - CASL II 処理システム ¶

1 YACASL2の概要
2 YACASL2の使用例
3 casl2
- オプション
4 comet2
- オプション
5 casl2rev
- オプション
6 dumpword
- 注意
- オプション
7 comet2monitor

Next: YACASL2の使用例, Previous: YACASL2 - CASL II 処理システム, Up: YACASL2 - CASL II 処理システム [Contents]

1 YACASL2の概要 ¶

YACASL2は、UNIXやLinuxのコマンドラインインターフェイスで動作するオープンソースのCASL II処理システムです。 CASL IIは情報処理試験で用いられるアセンブラ言語で、次の資料により仕様が公開されています。

情報処理技術者試験情報処理安全確保支援士試験試験で使用する情報技術に関する用語・プログラム言語など Ver 4.3［PDFファイル］
別紙2 アセンブラ言語の仕様（5ページから12ページまで）

この資料の必要部分を抜粋し、HTMLとPDFに変換したもの

情報処理技術者試験アセンブラ言語の仕様（HTML版）

情報処理技術者試験アセンブラ言語の仕様（PDF版）

YACASL2は、CASL IIアセンブラ言語で記述されたファイルをアセンブルし、仮想マシンCOMET II上で実行します。アセンブルと実行は、連続で行うこともできますし、アセンブル結果をファイルに保存してあとから実行することもできます。 YACASL2の動作はCASL IIの仕様に準拠しているため、情報処理試験の問題をはじめ各種参考書やサイトに記載されたCASL IIのプログラムをそのままアセンブルして実行できます。また、本パッケージ中にCASL IIのサンプルプログラムが多数収録されています。

YACASL2は、「ふつうの処理系」として動作します。 YACASL2の操作は、端末上のコマンドラインインターフェイス（CLI）で操作します。 YACASL2は、次のような動作内容をすべてテキストで出力します。

ラベルとアドレスの対応
アセンブル結果
実行時のレジスタの内容
実行時のメモリの内容

YACASL2では、機械コードモニターを使い、動作中のCPUやメモリーを調べたりデバッグしたりすることもできます。

また、出力された動作内容は、GNU/Linuxのさまざまなコマンド、たとえば、cat、less、grep、wcなどを使って解析できます。

Next: casl2, Previous: YACASL2の概要, Up: YACASL2 - CASL II 処理システム [Contents]

2 YACASL2の使用例 ¶

YACASL2 は、テキストファイルに記述されたCASLプログラムを処理します。以下の例で用いられるCASLプログラムのファイルは、テキストエディタなどで作成するか、インストールしたディレクトリの中にあるasディレクトリからコピーしてください。

Next: アセンブル結果の確認, Previous: YACASL2の使用例, Up: YACASL2の使用例 [Contents]

2.1 実行結果の出力だけを表示 ¶

インストール時にコマンド実行の確認に使ったhello.caslは、次のような内容です。 CASL IIのマクロ命令OUTは、文字列を出力します。

$ cat hello.casl
MAIN     START
         OUT     OBUF,LEN
         RET
OBUF     DC      'Hello, World!'
LEN      DC      13
         END

次のコマンドを実行すると、CASL II のアセンブルと仮想マシン COMET II 上での実行が連続で行われ、文字列が出力されます。

$ casl2 hello.casl
Hello, World!

addl.caslは、3と1の和を求めます。

$ cat addl.casl
;;; ADDL r,adr
MAIN     START
         LD      GR1,A
         ADDL    GR1,B
         RET
A        DC      3
B        DC      1
         END

このプログラムには出力命令がないため、オプションなしで実行した場合には結果が出力されません。

$ casl2 addl.casl
$

実行内容を確認するには、後述のようにCPU 内にあるレジスタやメモリの内容を表示するか、結果を出力するための処理を追加する必要があります。

Next: モニターでステップ実行を確認する, Previous: 実行結果の出力だけを表示, Up: YACASL2の使用例 [Contents]

2.2 アセンブル結果の確認 ¶

casl2の処理途中で行われるアセンブルの結果を表示するには、オプション-aを指定します。また、ラベルとアドレスの対応表を表示するには、オプション-lを指定します。

次のコマンドではhello.caslの、ラベルとアドレスの対応表と、アセンブル結果と、実行結果が表示されます。 OUTはアセンブラ命令で複数の機械語命令で構成されているため、命令行1行に対して、複数行のコードが生成されます。

$ casl2 -a -l hello.casl

Assemble hello.casl (0)

Label::::
MAIN ---> #0000
MAIN.OBUF ---> #0013
MAIN.LEN ---> #0020

Assemble as/sample/hello.casl (1)
as/sample/hello.casl:    1:MAIN    START
as/sample/hello.casl:    2:        OUT     OBUF,LEN
	#0000	#7001
	#0001	#0000
	#0002	#7002
	#0003	#0000
	#0004	#1210
	#0005	#0013
	#0006	#1220
	#0007	#0020
	#0008	#F000
	#0009	#0002
	#0021	#000A
	#000A	#1210
	#000B	#0021
	#0022	#0001
	#000C	#1220
	#000D	#0022
	#000E	#F000
	#000F	#0002
	#0010	#7120
	#0011	#7110
as/sample/hello.casl:    3:        RET
	#0012	#8100
as/sample/hello.casl:    4:OBUF    DC      'Hello, World!'
	#0013	#0048
	#0014	#0065
	#0015	#006C
	#0016	#006C
	#0017	#006F
	#0018	#002C
	#0019	#0020
	#001A	#0057
	#001B	#006F
	#001C	#0072
	#001D	#006C
	#001E	#0064
	#001F	#0021
as/sample/hello.casl:    5:LEN     DC      13
	#0020	#000D
as/sample/hello.casl:    6:        END

Literal::::
=000A ---> #0021
=0001 ---> #0022

Hello, World!

addl.caslの、ラベルとアドレスの対応表と、アセンブル結果は、次のようになります。

$ casl2 -a -l addl.casl

Assemble addl.casl (0)

Label::::
MAIN ---> #0000
MAIN.A ---> #0007
MAIN.B ---> #0008
MAIN.C ---> #0009

Assemble addl.casl (1)
addl.casl:    1:;;; ADDL r,adr
addl.casl:    2:MAIN    START
addl.casl:    3:        LD      GR1,A
    #0000   #1010
    #0001   #0007
addl.casl:    4:        ADDL    GR1,B
    #0002   #2210
    #0003   #0008
addl.casl:    5:        ST      GR1,C
    #0004   #1110
    #0005   #0009
addl.casl:    6:        RET
    #0006   #8100
addl.casl:    7:A       DC      3
    #0007   #0003
addl.casl:    8:B       DC      2
    #0008   #0002
addl.casl:    9:C       DS      1
    #0009   #0000
addl.casl:   10:        END

なお、オプション-Aを指定すると、アセンブル結果が表示される時点で処理が終了します。仮想マシンCOMET IIでのプログラム実行はされません。

Next: 実行結果をまとめて確認する, Previous: アセンブル結果の確認, Up: YACASL2の使用例 [Contents]

2.3 モニターでステップ実行を確認する ¶

casl2に-mを指定すると、アセンブルに続けてそのまま、 1命令ずつ実行を止めながらレジスタやメモリの内容を確認できる、対話的なモニターを起動できます。 -Oでオブジェクトファイルをあらかじめ作成しておく必要はありません。オプションの詳細はcasl2を参照してください。

Next: ループを含むプログラムの実行, Previous: モニターでステップ実行を確認する, Up: モニターでステップ実行を確認する [Contents]

2.3.1 起動とステップ実行 ¶

まず、出力命令のないaddl.casl（3と1の和を求めるプログラム）を例に、基本的な使い方を確認します。 -mのあとに続けてT・dの文字を指定すると、モニターに入った時点で、レジスタ（論理値表示）・メモリダンプの自動表示が、それぞれ有効になります。逆アセンブル結果の自動表示は、これらのフラグの指定に関わらず常にONです（comet2monitorのデフォルト動作と同じです）。 -M16は、メモリサイズを16語に指定するオプションです。

$ casl2 -M16 -mTd addl.casl

Assemble addl.casl (0)

Assemble addl.casl (1)
addl.casl:    1:;;; ADDL r,adr
addl.casl:    2:MAIN    START
addl.casl:    3:        LD      GR1,A
    #0000   #1010
    #0001   #0007
addl.casl:    4:        ADDL    GR1,B
    #0002   #2210
    #0003   #0008
addl.casl:    5:        ST      GR1,C
    #0004   #1110
    #0005   #0009
addl.casl:    6:        RET
    #0006   #8100
addl.casl:    7:A       DC      3
    #0007   #0003
addl.casl:    8:B       DC      2
    #0008   #0002
addl.casl:    9:C       DS      1
    #0009   #0000
addl.casl:   10:        END

#0000: Register::::
#0000: GR0:      0 = #0000 = 0000000000000000
#0000: GR1:      0 = #0000 = 0000000000000000
#0000: GR2:      0 = #0000 = 0000000000000000
#0000: GR3:      0 = #0000 = 0000000000000000
#0000: GR4:      0 = #0000 = 0000000000000000
#0000: GR5:      0 = #0000 = 0000000000000000
#0000: GR6:      0 = #0000 = 0000000000000000
#0000: GR7:      0 = #0000 = 0000000000000000
#0000: SP:      16 = #0010 = 0000000000010000
#0000: PR:       0 = #0000 = 0000000000000000
#0000: FR (OF SF ZF): 000
#0000: Memory::::
#0000: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0000: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000
#0000: Disassemble::::        LD      GR1,#0007       ; #0000: #1010 #0007

COMET II machine code monitor. Type ? for help.
(comet2 monitor)

プロンプト(comet2 monitor)で、コマンドを受け付ける状態になります。 n（next）を入力すると、1命令だけ実行し、実行直後のレジスタ・メモリ・次に実行される命令の逆アセンブル結果を表示します。 addl.caslは4命令だけの単純なプログラムなので、nを繰り返すだけで最後まで確認できます。

(comet2 monitor) n
#0002: Register::::
#0002: GR0:      0 = #0000 = 0000000000000000
#0002: GR1:      3 = #0003 = 0000000000000011
#0002: GR2:      0 = #0000 = 0000000000000000
#0002: GR3:      0 = #0000 = 0000000000000000
#0002: GR4:      0 = #0000 = 0000000000000000
#0002: GR5:      0 = #0000 = 0000000000000000
#0002: GR6:      0 = #0000 = 0000000000000000
#0002: GR7:      0 = #0000 = 0000000000000000
#0002: SP:      16 = #0010 = 0000000000010000
#0002: PR:       2 = #0002 = 0000000000000010
#0002: FR (OF SF ZF): 000
#0002: Memory::::
#0002: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0002: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000
#0002: Disassemble::::        ADDL    GR1,#0008       ; #0002: #2210 #0008

(comet2 monitor) n
#0004: Register::::
#0004: GR0:      0 = #0000 = 0000000000000000
#0004: GR1:      5 = #0005 = 0000000000000101
#0004: GR2:      0 = #0000 = 0000000000000000
#0004: GR3:      0 = #0000 = 0000000000000000
#0004: GR4:      0 = #0000 = 0000000000000000
#0004: GR5:      0 = #0000 = 0000000000000000
#0004: GR6:      0 = #0000 = 0000000000000000
#0004: GR7:      0 = #0000 = 0000000000000000
#0004: SP:      16 = #0010 = 0000000000010000
#0004: PR:       4 = #0004 = 0000000000000100
#0004: FR (OF SF ZF): 000
#0004: Memory::::
#0004: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0004: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000
#0004: Disassemble::::        ST      GR1,#0009       ; #0004: #1110 #0009

(comet2 monitor) n
#0006: Register::::
#0006: GR0:      0 = #0000 = 0000000000000000
#0006: GR1:      5 = #0005 = 0000000000000101
#0006: GR2:      0 = #0000 = 0000000000000000
#0006: GR3:      0 = #0000 = 0000000000000000
#0006: GR4:      0 = #0000 = 0000000000000000
#0006: GR5:      0 = #0000 = 0000000000000000
#0006: GR6:      0 = #0000 = 0000000000000000
#0006: GR7:      0 = #0000 = 0000000000000000
#0006: SP:      16 = #0010 = 0000000000010000
#0006: PR:       6 = #0006 = 0000000000000110
#0006: FR (OF SF ZF): 000
#0006: Memory::::
#0006: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0006: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0005 0000 0000 0000 0000 0000 0000
#0006: Disassemble::::        RET                     ; #0006: #8100

(comet2 monitor) n
Return to top.
(comet2 monitor) q
Quit: COMET II monitor

GR1に5（3+2）が格納され、STによってメモリの#0009番地（Cのアドレス）に書き込まれていることが確認できます。これで、出力のないaddl.caslの実行内容も、ステップごとに確認できました。

Next: 継続実行とブレークポイント, Previous: 起動とステップ実行, Up: モニターでステップ実行を確認する [Contents]

2.3.2 ループを含むプログラムの実行 ¶

addl.caslのように命令数が少ないプログラムでは、nを繰り返すだけで最後まで確認できます。ループを含むプログラムではどうなるか、1から10までの整数の和を求める sum_10.caslを例に見てみましょう。 sum_10.caslは、1から10までの整数の和を求め、GR2に格納してからメモリにストア（書き込み）します。

$ cat sum_10.casl
;;; sum_10.casl
;;; 1から10までの整数をすべて加算した値をメモリーに格納する
MAIN    START
        XOR     GR2,GR2         ; GR2を初期化
        LD      GR1,FST         ; GR1に初項をメモリーから転送
LOOP    ADDL    GR2,GR1         ; ループ先頭。GR2 <- GR2 + GR1
        ADDL    GR1,STEP        ; GR1 <- GR1 + 公差
        CPL     GR1,LST         ; GR1が末項より大きい場合は終了
        JPL     FIN             ; ↓
        JUMP    LOOP            ; ループ終端
FIN     ST      GR2,RST         ; GR2の結果をメモリーに転送
        RET
FST     DC      1               ; 初項
LST     DC      10              ; 末項
STEP    DC      1               ; 公差
RST     DS      1               ; 結果
        END

-M32は、メモリサイズを32語に指定するオプションです。

$ casl2 -M32 -mTd sum_10.casl

Assemble sum_10.casl (0)

Assemble sum_10.casl (1)
sum_10.casl:    1:;;; sum_10.casl
sum_10.casl:    2:;;; 1から10までの整数をすべて加算した値をメモリーに格納する
sum_10.casl:    3:MAIN    START
sum_10.casl:    4:        XOR     GR2,GR2         ; GR2を初期化
    #0000   #3622
sum_10.casl:    5:        LD      GR1,FST         ; GR1に初項をメモリーから転送
    #0001   #1010
    #0002   #000F
sum_10.casl:    6:LOOP    ADDL    GR2,GR1         ; ループ先頭。GR2 <- GR2 + GR1
    #0003   #2621
sum_10.casl:    7:        ADDL    GR1,STEP        ; GR1 <- GR1 + 公差
    #0004   #2210
    #0005   #0011
sum_10.casl:    8:        CPL     GR1,LST         ; GR1が末項より大きい場合は終了
    #0006   #4110
    #0007   #0010
sum_10.casl:    9:        JPL     FIN             ; ↓
    #0008   #6500
    #0009   #000C
sum_10.casl:   10:        JUMP    LOOP            ; ループ終端
    #000A   #6400
    #000B   #0003
sum_10.casl:   11:FIN     ST      GR2,RST         ; GR2の結果をメモリーに転送
    #000C   #1120
    #000D   #0012
sum_10.casl:   12:        RET
    #000E   #8100
sum_10.casl:   13:FST     DC      1               ; 初項
    #000F   #0001
sum_10.casl:   14:LST     DC      10              ; 末項
    #0010   #000A
sum_10.casl:   15:STEP    DC      1               ; 公差
    #0011   #0001
sum_10.casl:   16:RST     DS      1               ; 結果
    #0012   #0000
sum_10.casl:   17:        END

#0000: Register::::
#0000: GR0:      0 = #0000 = 0000000000000000
#0000: GR1:      0 = #0000 = 0000000000000000
#0000: GR2:      0 = #0000 = 0000000000000000
#0000: GR3:      0 = #0000 = 0000000000000000
#0000: GR4:      0 = #0000 = 0000000000000000
#0000: GR5:      0 = #0000 = 0000000000000000
#0000: GR6:      0 = #0000 = 0000000000000000
#0000: GR7:      0 = #0000 = 0000000000000000
#0000: SP:      32 = #0020 = 0000000000100000
#0000: PR:       0 = #0000 = 0000000000000000
#0000: FR (OF SF ZF): 000
#0000: Memory::::
#0000: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0000: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#0000: 0010: 000A 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#0000: Disassemble::::        XOR     GR2,GR2         ; #0000: #3622

COMET II machine code monitor. Type ? for help.
(comet2 monitor)

addl.caslのときと同じように、nで1命令ずつ進められます。

(comet2 monitor) n
#0001: Register::::
#0001: GR0:      0 = #0000 = 0000000000000000
#0001: GR1:      0 = #0000 = 0000000000000000
#0001: GR2:      0 = #0000 = 0000000000000000
#0001: GR3:      0 = #0000 = 0000000000000000
#0001: GR4:      0 = #0000 = 0000000000000000
#0001: GR5:      0 = #0000 = 0000000000000000
#0001: GR6:      0 = #0000 = 0000000000000000
#0001: GR7:      0 = #0000 = 0000000000000000
#0001: SP:      32 = #0020 = 0000000000100000
#0001: PR:       1 = #0001 = 0000000000000001
#0001: FR (OF SF ZF): 001
#0001: Memory::::
#0001: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0001: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#0001: 0010: 000A 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#0001: Disassemble::::        LD      GR1,#000F       ; #0001: #1010 #000F

(comet2 monitor) n
#0003: Register::::
#0003: GR0:      0 = #0000 = 0000000000000000
#0003: GR1:      1 = #0001 = 0000000000000001
#0003: GR2:      0 = #0000 = 0000000000000000
#0003: GR3:      0 = #0000 = 0000000000000000
#0003: GR4:      0 = #0000 = 0000000000000000
#0003: GR5:      0 = #0000 = 0000000000000000
#0003: GR6:      0 = #0000 = 0000000000000000
#0003: GR7:      0 = #0000 = 0000000000000000
#0003: SP:      32 = #0020 = 0000000000100000
#0003: PR:       3 = #0003 = 0000000000000011
#0003: FR (OF SF ZF): 000
#0003: Memory::::
#0003: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0003: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#0003: 0010: 000A 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#0003: Disassemble::::        ADDL    GR2,GR1         ; #0003: #2621

nを繰り返すたびにPRが進み、GR1・GR2の値が変化していく様子を、 1命令ずつ確認できます。ここから先は、LOOPをループの回数だけnで繰り返すことになります。

Next: ブレークポイントでループを1周ずつ確認する, Previous: ループを含むプログラムの実行, Up: モニターでステップ実行を確認する [Contents]

2.3.3 継続実行とブレークポイント ¶

sum_10.caslはループを含むため、nをループの回数だけ繰り返す必要があります。ループの中身を1回ずつ確認したあとは、c（continue）でプログラムの終わりまで一気に実行できます。 cを実行すると、途中の各ステップの状態がnと同じ形式で連続して表示され、最後に、RETが実行されてプログラム先頭に戻ったところで停止します。

(comet2 monitor) c
（……ループの残りのステップが、nと同じ形式で連続して表示される……）
#000E: Register::::
#000E: GR0:      0 = #0000 = 0000000000000000
#000E: GR1:     11 = #000B = 0000000000001011
#000E: GR2:     55 = #0037 = 0000000000110111 = '7'
#000E: GR3:      0 = #0000 = 0000000000000000
#000E: GR4:      0 = #0000 = 0000000000000000
#000E: GR5:      0 = #0000 = 0000000000000000
#000E: GR6:      0 = #0000 = 0000000000000000
#000E: GR7:      0 = #0000 = 0000000000000000
#000E: SP:      32 = #0020 = 0000000000100000
#000E: PR:      14 = #000E = 0000000000001110
#000E: FR (OF SF ZF): 000
#000E: Memory::::
#000E: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#000E: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#000E: 0010: 000A 0001 0037 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#000E: Disassemble::::        RET                     ; #000E: #8100

Return to top.
(comet2 monitor) q
Quit: COMET II monitor

GR2に55（1から10までの和）が格納されていること、その値がメモリの#0012番地（RSTのアドレス）に書き込まれていることが確認できます。

Previous: 継続実行とブレークポイント, Up: モニターでステップ実行を確認する [Contents]

2.3.4 ブレークポイントでループを1周ずつ確認する ¶

ループの先頭、つまりLOOP（#0003番地）にブレークポイントを設定すると、 cを実行するたびにループを1周だけ進めて、そこで実行を止められます。 nをループの回数だけ繰り返さなくても、GR2に合計が積み上がっていく様子を 1周ごとに確認できます。 b（break）に続けてa または（add）とアドレスを指定すると、ブレークポイントが追加されます。

(comet2 monitor) b a #0003
#0003: breakpoint added
(comet2 monitor) n
#0004: Register::::
#0004: GR0:      0 = #0000 = 0000000000000000
#0004: GR1:      2 = #0002 = 0000000000000010
#0004: GR2:      3 = #0003 = 0000000000000011
#0004: GR3:      0 = #0000 = 0000000000000000
#0004: GR4:      0 = #0000 = 0000000000000000
#0004: GR5:      0 = #0000 = 0000000000000000
#0004: GR6:      0 = #0000 = 0000000000000000
#0004: GR7:      0 = #0000 = 0000000000000000
#0004: SP:      32 = #0020 = 0000000000100000
#0004: PR:       4 = #0004 = 0000000000000100
#0004: FR (OF SF ZF): 000
#0004: Memory::::
#0004: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0004: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#0004: 0010: 000A 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#0004: Disassemble::::        ADDL    GR1,#0011       ; #0004: #2210 #0011

(comet2 monitor) c
（……途中のステップが、nと同じ形式で連続して表示される……）
#0003: Register::::
#0003: GR0:      0 = #0000 = 0000000000000000
#0003: GR1:      3 = #0003 = 0000000000000011
#0003: GR2:      3 = #0003 = 0000000000000011
#0003: GR3:      0 = #0000 = 0000000000000000
#0003: GR4:      0 = #0000 = 0000000000000000
#0003: GR5:      0 = #0000 = 0000000000000000
#0003: GR6:      0 = #0000 = 0000000000000000
#0003: GR7:      0 = #0000 = 0000000000000000
#0003: SP:      32 = #0020 = 0000000000100000
#0003: PR:       3 = #0003 = 0000000000000011
#0003: FR (OF SF ZF): 010
#0003: Memory::::
#0003: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0003: 0000: 3622 1010 000F 2621 2210 0011 4110 0010 6500 000C 6400 0003 1120 0012 8100 0001
#0003: 0010: 000A 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
#0003: Disassemble::::        ADDL    GR2,GR1         ; #0003: #2621

cを実行するたびに、ブレークポイントを設定した#0003番地で実行が止まります。ブレークポイントに達したときも、特別なメッセージは表示されず、通常の実行結果と同じ形式でその時点の状態が表示されます。そのままcを繰り返すと、GR2に1から10までの合計が積み上がっていく様子が、 1周ごとに確認できます。

GR1	GR2	意味
3	3	1+2
4	6	1+2+3
5	10	1+2+3+4
6	15	1+2+3+4+5
7	21	1+2+3+4+5+6
8	28	1+2+3+4+5+6+7
9	36	1+2+3+4+5+6+7+8
10	45	1+2+3+4+5+6+7+8+9

GR1がLST（10）を超えると、CPLの結果によりループを抜けてFINに進むため、最後のcではブレークポイントに達せず、そのままプログラムの終わり（GR2=55）まで実行されてReturn to top.と表示されます。

Next: オブジェクトファイルの作成, Previous: モニターでステップ実行を確認する, Up: YACASL2の使用例 [Contents]

2.4 実行結果をまとめて確認する ¶

前節のモニターは、1命令ずつ実行を止めながら確認するのに向いています。一方で、テストスクリプトなどでプログラムの動作をまとめて自動的に確認したい場合や、実行結果全体を一度に見比べたい場合は、-t・-dオプションと、 GNU/Linuxのコマンド（grep・tail・wcなど）を組み合わせる方法が便利です。

YACASL2では実行中のCPUのレジスタとメモリの内容をそれぞれ、-tと-dを指定することで表示できます。

また、-Mで、仮想マシンCOMET II のメモリ容量を語(16ビット)単位で指定できます。小さいプログラムを実行するときは、メモリ容量を小さくすれば結果が見やすくなります。

addl.caslでは、次のようにCPUのレジスタとメモリの内容を表示できます。

$ casl2 -t -d -M16 addl.casl | less

Assemble addl.casl (0)

Assemble addl.casl (1)

Executing machine codes
#0000: Register::::
#0000: GR0:      0 = #0000 = 0000000000000000
#0000: GR1:      0 = #0000 = 0000000000000000
#0000: GR2:      0 = #0000 = 0000000000000000
#0000: GR3:      0 = #0000 = 0000000000000000
#0000: GR4:      0 = #0000 = 0000000000000000
#0000: GR5:      0 = #0000 = 0000000000000000
#0000: GR6:      0 = #0000 = 0000000000000000
#0000: GR7:      0 = #0000 = 0000000000000000
#0000: SP:      16 = #0010 = 0000000000010000
#0000: PR:       0 = #0000 = 0000000000000000
#0000: FR (OF SF ZF): 000
#0000: Memory::::
#0000: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0000: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000

#0002: Register::::
#0002: GR0:      0 = #0000 = 0000000000000000
#0002: GR1:      3 = #0003 = 0000000000000011
#0002: GR2:      0 = #0000 = 0000000000000000
#0002: GR3:      0 = #0000 = 0000000000000000
#0002: GR4:      0 = #0000 = 0000000000000000
#0002: GR5:      0 = #0000 = 0000000000000000
#0002: GR6:      0 = #0000 = 0000000000000000
#0002: GR7:      0 = #0000 = 0000000000000000
#0002: SP:      16 = #0010 = 0000000000010000
#0002: PR:       2 = #0002 = 0000000000000010
#0002: FR (OF SF ZF): 000
#0002: Memory::::
#0002: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0002: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000

#0004: Register::::
#0004: GR0:      0 = #0000 = 0000000000000000
#0004: GR1:      5 = #0005 = 0000000000000101
#0004: GR2:      0 = #0000 = 0000000000000000
#0004: GR3:      0 = #0000 = 0000000000000000
#0004: GR4:      0 = #0000 = 0000000000000000
#0004: GR5:      0 = #0000 = 0000000000000000
#0004: GR6:      0 = #0000 = 0000000000000000
#0004: GR7:      0 = #0000 = 0000000000000000
#0004: SP:      16 = #0010 = 0000000000010000
#0004: PR:       4 = #0004 = 0000000000000100
#0004: FR (OF SF ZF): 000
#0004: Memory::::
#0004: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0004: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0000 0000 0000 0000 0000 0000 0000

#0006: Register::::
#0006: GR0:      0 = #0000 = 0000000000000000
#0006: GR1:      5 = #0005 = 0000000000000101
#0006: GR2:      0 = #0000 = 0000000000000000
#0006: GR3:      0 = #0000 = 0000000000000000
#0006: GR4:      0 = #0000 = 0000000000000000
#0006: GR5:      0 = #0000 = 0000000000000000
#0006: GR6:      0 = #0000 = 0000000000000000
#0006: GR7:      0 = #0000 = 0000000000000000
#0006: SP:      16 = #0010 = 0000000000010000
#0006: PR:       6 = #0006 = 0000000000000110
#0006: FR (OF SF ZF): 000
#0006: Memory::::
#0006: adr : 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F
       -------------------------------------------------------------------------------------
#0006: 0000: 1010 0007 2210 0008 1110 0009 8100 0003 0002 0005 0000 0000 0000 0000 0000 0000

Next: プログラム終了時の値を表示, Previous: 実行結果をまとめて確認する, Up: 実行結果をまとめて確認する [Contents]

2.4.1 特定のレジスタを表示 ¶

addl.caslのレジスタやメモリの中で、実行中に値が変化しているのはGR1だけです。こうした場合は、grepを使って表示される内容を絞り込むことで動作を検証しやすくなります。

$ casl2 -t addl.casl | grep 'GR1:'
#0000: GR1:      0 = #0000 = 0000000000000000
#0002: GR1:      3 = #0003 = 0000000000000011
#0004: GR1:      5 = #0005 = 0000000000000101
#0006: GR1:      5 = #0005 = 0000000000000101

この内容を、先に出力したアセンブル結果と比較してください。次の表のように、PRとGR1、命令行が対応していることがわかります。

PR	GR1	命令行
#0000	#0000	（なし）
#0002	#0003	`LD GR1,A`
#0004	#0004	`ADDL GR1,B`
#0006	#0006	`ST GR1,C`

Next: プログラムのステップ数を表示, Previous: 特定のレジスタを表示, Up: 実行結果をまとめて確認する [Contents]

2.4.2 プログラム終了時の値を表示 ¶

grepとtailを組み合わせれば、プログラム終了時の値を表示できます。

addl.caslでプログラム終了時のGR1の値を確認するには、次のようにします。

$ casl2 -t addl.casl | grep 'GR1:' | tail -1
#0006: GR1:      5 = #0005 = 0000000000000101

sum_10.caslでプログラム終了時のGR2の値を確認するには、次のようにします。

$ casl2 -t sum_10.casl | grep 'GR2:' | tail -1
#000E: GR2:     55 = #0037 = 0000000000110111 = '7'

複数のテストケースをまとめて自動実行したい場合は、このようにコマンドラインツールを組み合わせる方法も便利です。同様の結果は、前節のモニターのブレークポイント機能でも確認できます。

Previous: プログラム終了時の値を表示, Up: 実行結果をまとめて確認する [Contents]

2.4.3 プログラムのステップ数を表示 ¶

grepとwcを組み合わせれば、プログラムのステップ数を表示できます。

$ casl2 -t hello.casl | grep 'GR1:' | wc -l
11

$ casl2 -t addl.casl | grep 'GR1:' | wc -l
3

sum_10.caslはプログラム内にループがあるため、ステップ数が大きくなります。

$ casl2 -t sum_10.casl | grep 'GR2:' | wc -l
53

Next: オブジェクトファイルの確認, Previous: 実行結果をまとめて確認する, Up: YACASL2の使用例 [Contents]

2.5 オブジェクトファイルの作成 ¶

casl2に-Oファイル名を指定すると、オブジェクトファイルを作成できます。オブジェクトファイルを作成すると、アセンブルと実行を別にできます。

$ casl2 -Ohello.o hello.casl

オブジェクトファイルの実行には、comet2を使います。

$ comet2 hello.o
Hello, World!

すでに作成済みのオブジェクトファイルに対して、casl2 -mと同じように 1命令ずつステップ実行を確認したい場合は、comet2 -m または comet2monitorを使います（see comet2monitor）。

Next: 1語の解析, Previous: オブジェクトファイルの作成, Up: YACASL2の使用例 [Contents]

2.6 オブジェクトファイルの確認 ¶

オブジェクトファイルは、テキストファイルではないためcatなどでは確認できません。 casl2revで逆アセンブルして内容を確認できます。

$ casl2rev hello.o
MAIN    START
        PUSH    #0000,GR1       ; #0000: #7001 #0000
        PUSH    #0000,GR2       ; #0002: #7002 #0000
        LAD     GR1,#0013       ; #0004: #1210 #0013
        LAD     GR2,#0020       ; #0006: #1220 #0020
        SVC     #0002           ; #0008: #F000 #0002
        LAD     GR1,#0021       ; #000A: #1210 #0021
        LAD     GR2,#0022       ; #000C: #1220 #0022
        SVC     #0002           ; #000E: #F000 #0002
        POP     GR2             ; #0010: #7120
        POP     GR1             ; #0011: #7110
        RET                     ; #0012: #8100
        DC      72              ; #0013: #0048 ::    72 = #0048 = 0000000001001000 = 'H'
        DC      101             ; #0014: #0065 ::   101 = #0065 = 0000000001100101 = 'e'
        DC      108             ; #0015: #006C ::   108 = #006C = 0000000001101100 = 'l'
        DC      108             ; #0016: #006C ::   108 = #006C = 0000000001101100 = 'l'
        DC      111             ; #0017: #006F ::   111 = #006F = 0000000001101111 = 'o'
        DC      44              ; #0018: #002C ::    44 = #002C = 0000000000101100 = ','
        DC      32              ; #0019: #0020 ::    32 = #0020 = 0000000000100000 = ' '
        DC      87              ; #001A: #0057 ::    87 = #0057 = 0000000001010111 = 'W'
        DC      111             ; #001B: #006F ::   111 = #006F = 0000000001101111 = 'o'
        DC      114             ; #001C: #0072 ::   114 = #0072 = 0000000001110010 = 'r'
        DC      108             ; #001D: #006C ::   108 = #006C = 0000000001101100 = 'l'
        DC      100             ; #001E: #0064 ::   100 = #0064 = 0000000001100100 = 'd'
        DC      33              ; #001F: #0021 ::    33 = #0021 = 0000000000100001 = '!'
        DC      13              ; #0020: #000D ::    13 = #000D = 0000000000001101
        DC      10              ; #0021: #000A ::    10 = #000A = 0000000000001010 = '\n'
        DC      1               ; #0022: #0001 ::     1 = #0001 = 0000000000000001
        END

また、LinuxやMacなどに標準インストールされていることが多いodを使っても確認できます。

$ od -t x2 hello.o
0000000 7001 0000 7002 0000 1210 0013 1220 0020
0000020 f000 0002 1210 0021 1220 0022 f000 0002
0000040 7120 7110 8100 0048 0065 006c 006c 006f
0000060 002c 0020 0057 006f 0072 006c 0064 0021
0000100 000d 000a 0001
0000106

Next: CASL IIライブラリの使用, Previous: オブジェクトファイルの確認, Up: YACASL2の使用例 [Contents]

2.7 1語の解析 ¶

CASL IIでは、1語（1 word、16ビット）を単位としてデータが処理されます。 dumpwordは、指定した1語を10進数、16進数、2進数で表示します。

$ dumpword 72
    72:     72 = #0048 = 0000000001001000 = 'H'

Previous: 1語の解析, Up: YACASL2の使用例 [Contents]

2.8 CASL IIライブラリの使用 ¶

YACASL2のas/casl2libディレクトリには、CASL IIで記述されたライブラリファイルが格納されています。

このフォルダには、たとえば次のようなプログラムが含まれています。

OUTL: outl.casl。 GR1に格納された値を、0以上65535以下の整数として出力します。
OUTA: outa.casl。 GR1に格納された値を、-32767以上32767以下の整数として出力します。
MULL: mull.casl。 GR1とGR2に格納された値を0以上65535以下の整数と見なし、積をGR3に格納します。
DIVL: divl.casl。 GR1とGR2に格納された値を0以上65535以下の整数と見なし、商をGR3、剰余をGR0に格納します。

2.8.1 数値を出力する ¶

3と1の和を求めるaddl.caslで演算結果を出力するには、まずaddl.caslを編集します。 CASL IIのCALL命令でOUTLを副プログラムとして呼び出します。

$ cat addl_outl.casl
MAIN    START
        LD      GR1,A
        ADDL    GR1,B
        CALL    OUTL
        RET
A       DC      3
B       DC      1
        END

変更したらcasl2を、複数のファイルを指定して実行します。

$ casl2 addl_outl.casl ~/yacasl2/as/casl2lib/outl.casl
4

Next: comet2, Previous: YACASL2の使用例, Up: YACASL2 - CASL II 処理システム [Contents]

3 `casl2` ¶

casl2は、引数として指定されたCASLファイルをアセンブルし、仮想マシンCOMET II上で実行します。 CASLファイルは、アセンブラ言語CASL IIで記述されたテキストファイルです。引数が指定されない場合は、エラーメッセージを表示して終了します。

$ casl2 hello.casl

複数のCASLファイルを指定することで、副プログラムを呼び出すこともできます。

$ casl2 addl_outl.casl ~/yacasl2/as/casl2lib/outl.casl

オプション ¶

casl2は、次のオプションを指定できます。

-s

--source

CASLファイルの内容を表示します。

-l

--label

ラベルの一覧を次の形式で表示します。表示後、ほかの作業を続行します。

<プログラム名>.<ラベル名> ---> <アドレスの16進数表現>

-L

--labelonly

-lと同じ形式でラベルの一覧を表示します。表示後、ほかの作業は続行せず、終了します。

-a

--assembledetail

アセンブル詳細結果を表示し、ほかの作業を続行します。

-A

--assembledetailonly

アセンブル詳細結果を表示して終了します。

-o<OBJECTFILE>

--assembleout<OBJECTFILE>

アセンブル結果をオブジェクトファイル<OBJECTFILE>に出力し、ほかの作業を続行します。出力されたオブジェクトファイルは、comet2で実行できます。オブジェクトファイルを指定しない場合、出力先はa.oです。オブジェクトファイルは1つだけ指定できます。

-O[<OBJECTFILE>]

--assembleoutonly[<OBJECTFILE>]

アセンブル結果をオブジェクトファイル<OBJECTFILE>に出力し、終了します。出力されたオブジェクトファイルは、comet2で実行できます。オブジェクトファイルを指定しない場合、出力先はa.oです。オブジェクトファイルは1つだけ指定できます。

-t

--trace

--tracearithmetic

プログラム実行中のレジスタの値を次の形式で表示します。

<PR値の16進数表現>: <レジスタ>: <値の10進数表現> =
<値の16進数表現> = <値の2進数表現>[ ='文字']

<PR値の16進数表現>と<レジスタ>、<値の16進数表現>は、4けたの16進数で表されます。 <PR値の16進数表現>と<値の16進数表現>には、先頭に#が付きます。範囲は#0000から#FFFFです
<値の10進数表現>は符号の付いた10進数です。範囲は-32768から32767です。
<値の2進数表現>は、16けたの2進数で表されます。範囲は、0000000000000000から1111111111111111です
[ ='文字']は、レジストリの値が「文字の組」の範囲に含まれる場合に表示されます。

表示されるレジスタには、次の種類があります。

GR0 GR1 GR2 GR3 GR4 GR5 GR6 GR7: 汎用レジスタ
SP: スタックポインタ
PR: プログラムレジスタ
FR: フラグレジスタ

例えば、次のように表示されます。

#0002: GR1:      3 = #0003 = 0000000000000011

-T

--tracelogical

-tと同じように、プログラム実行中のレジスタの値を表示します。ただし-tと異なり、<値の10進数表現>は符号の付かない10進数です。値の範囲は0から65535です。

-d

--dump

メモリの内容をすべて表示します。

-m

アセンブル後、実行を1命令ごとに止めながら確認できる、対話的なモニターを起動します。プロンプトは(comet2 monitor)で、コマンドの詳細はcomet2monitorの「モニターコマンド」を参照してください。 <フラグ>にはT・dを組み合わせて指定でき、それぞれレジスタ（論理値）・メモリダンプの自動表示を有効にします。逆アセンブル結果の自動表示は、フラグの指定に関わらず常にONです。

-M <MEMORYSIZE>

--memorysize <MEMORYSIZE>

アセンブルおよびCOMET II実行時のメモリサイズ<MEMORYSIZE>をWORD（16ビット）単位で1から65535の範囲で指定します。指定しない場合、512語です。小さいプログラムを実行するときは、メモリ容量を小さくすれば結果が見やすくなります。

-C <CLOCKS>

--clocks <CLOCKS>

COMET II実行時のクロック周波数<CLOCKS>を0より大きい整数で指定します。指定しない場合、クロック周波数は5000000です。

-v

--version

casl2のバージョンを表示して終了します。

-h

--help

casl2の使用方法を表示して終了します。

Next: casl2rev, Previous: casl2, Up: YACASL2 - CASL II 処理システム [Contents]

4 `comet2` ¶

comet2は、引数として指定されたオブジェクトファイルを仮想マシンCOMET II上で実行します。オブジェクトファイルは、caslに-oまたは-Oを指定して出力します。

$ comet2 hello.o

引数で指定できるオブジェクトファイルは1つだけです。引数が指定されない場合は、エラーメッセージを表示して終了します。複数の引数を指定した場合、2番目以降の引数は無視されます。

オプション ¶

comet2は、次のオプションを指定できます。

-t

--trace

--tracearithmetic

プログラム実行中のレジスタの値を次の形式で表示します。 <値の10進数表現>は符号の付いた10進数です。範囲は-32768から32767です。

<PR値の16進数表現>: <レジスタ>: <値の10進数表現> = <値の16進数表現> = <値の2進数表現>[ ='文字']

<PR値の16進数表現>と<値の16進数表現>は、先頭に#が付いた4けたの16進数で表されます。範囲は、#0000から#FFFFです
<値の2進数表現>は、16けたの2進数で表されます。範囲は、0000000000000000から1111111111111111です
[ ='文字']は、レジストリの値が「文字の組」の範囲に含まれる場合に表示されます。

例えば、次のように表示されます。

#0002: GR1:      3 = #0003 = 0000000000000011

表示されるレジスタには、次の種類があります。

GR0 GR1 GR2 GR3 GR4 GR5 GR6 GR7: 汎用レジスタ
SP: スタックポインタ
PR: プログラムレジスタ
FR: フラグレジスタ

-T

--tracelogical

-tと同じように、プログラム実行中のレジスタの値を表示します。ただし、-tと異なり、<値の10進数表現>は符号の付かない10進数です。値の範囲は0から65535です。

-d

--dump

メモリの内容をすべて表示します。

-m

-M <MEMORYSIZE>

--memorysize <MEMORYSIZE>

COMET II実行時のメモリサイズ<MEMORYSIZE>をWORD（16ビット）単位で1から65535の範囲で指定します。指定しない場合、512語です。小さいプログラムを実行するときは、メモリ容量を小さくすれば結果が見やすくなります。

-C <CLOCKS>

--clocks <CLOCKS>

実行時のクロック周波数<CLOCKS>を0より大きい整数で指定します。指定しない場合、5000000です。

-v

--version

comet2のバージョンを表示して終了します。

-h

--help

comet2の使用方法を表示して終了します。

Next: dumpword, Previous: comet2, Up: YACASL2 - CASL II 処理システム [Contents]

5 `casl2rev` ¶

casl2revは、引数として指定されたオブジェクトファイルを逆アセンブルして表示します。プログラムを実行せず、逆アセンブル結果だけを表示する点が、comet2や comet2monitorと異なります。オブジェクトファイルの内容を、実行せずにざっと確認したいときに使います。

casl2rev [-vh] FILE

引数で指定できるオブジェクトファイルは1つだけです。引数が指定されない場合は、エラーメッセージを表示して終了します。

addl.oを逆アセンブルすると、次のように表示されます。

$ casl2rev addl.o
MAIN    START
        LD      GR1,#0007       ; #0000: #1010 #0007
        ADDL    GR1,#0008       ; #0002: #2210 #0008
        ST      GR1,#0009       ; #0004: #1110 #0009
        RET                     ; #0006: #8100
        DC      3               ; #0007: #0003 ::     3 = #0003 = 0000000000000011
        DC      2               ; #0008: #0002 ::     2 = #0002 = 0000000000000010
        DS      1               ; #0009: #0000
        END

先頭にMAIN START、末尾にENDが表示され、 CASL IIのソースファイルに近い形式で逆アセンブル結果が確認できます。

オプション ¶

casl2revは、次のオプションを指定できます。

-v
--version: casl2revのバージョンを表示して終了します。
-h
--help: casl2revの使用方法を表示して終了します。

Next: comet2monitor, Previous: casl2rev, Up: YACASL2 - CASL II 処理システム [Contents]

6 `dumpword` ¶

dumpwordは引数として指定された数値を、整数、#0000から#FFFFまでの範囲の16進数、2進数で表示します。文字の組に該当する場合は、「 = 」のうしろに文字が表示されます。引数は、10進数または先頭に「#」の付いた16進数で指定します。表示される整数は、オプションにより符号付きか符号なしかを指定します。オプションなしの場合は符号付きです。整数の範囲は、符号付きの場合は-32768以上32767以下、符号なしの場合は0以上65535以下です。

$ dumpword 10
    10:     10 = #000A = 0000000000001010 = '\n'

引数が指定されない場合は、使い方を表示して終了します。複数の引数を指定した場合、1つ目の引数だけが表示され、2つ目以降の引数は無視されます。

注意 ¶

マイナスの数や16進数はシェルの仕様により、そのままでは指定できません。

マイナスの数を指定するときは、次のように--を付けます。

$ dumpword -- -72
   -72:    -72 = #FFB8 = 1111111110111000

先頭に「#」を付けて16進数を指定するときは、次のように「’」で囲みます。

$ dumpword '#0048'
 #0048:     72 = #0048 = 0000000001001000 = 'H'

オプション ¶

dumpwordは、次のオプションを指定できます。

-a
--arithmetic: 出力される整数の範囲を-32,768以上32,767以下にします。オプションなしの場合と同じです。
-l
--logical: 出力される整数の範囲を0以上65,535以下にします。
-v
--version: dumpwordのバージョンを表示して終了します。
-h
--help: dumpwordの使用方法を表示して終了します。

Previous: dumpword, Up: YACASL2 - CASL II 処理システム [Contents]

7 `comet2monitor` ¶

comet2monitorは、COMET II機械コードモニターです。オブジェクトファイルをロードし、対話的にステップ実行・逆アセンブル・レジスタやメモリの確認ができます。

comet2monitor [-tTdqvh] [-M <MEMORYSIZE>] [-C <CLOCKS>] FILE

Next: モニターコマンド, Previous: comet2monitor, Up: comet2monitor [Contents]

7.1 オプション ¶

-t
--trace
--tracearithmetic: 命令実行ごとにCPUレジスタの内容を表示します。値は算術（符号あり）表現で表示されます。
-T
--tracelogical: 命令実行ごとにCPUレジスタの内容を表示します。値は論理（符号なし）表現で表示されます。
-d
--dump: 命令実行ごとにメモリダンプを表示します。
-q: 逆アセンブルの自動表示をOFFにします。デフォルトでは逆アセンブル自動表示はONです。
-M MEMORYSIZE
--memorysize=MEMORYSIZE: COMET II実行時のメモリサイズ<MEMORYSIZE>をWORD（16ビット）単位で1から65535の範囲で指定します。指定しない場合、512語です。小さいプログラムを実行するときは、メモリ容量を小さくすれば結果が見やすくなります。
-C CLOCKS
--clocks=CLOCKS: COMET II実行時のクロック周波数<CLOCKS>を0より大きい整数で指定します。指定しない場合、5000000です。
-v
--version: バージョン情報を表示して終了します。
-h
--help: 使い方を表示して終了します。

Next: 使用例, Previous: オプション, Up: comet2monitor [Contents]

7.2 モニターコマンド ¶

comet2monitorは起動後、対話的にコマンドを受け付けます。コマンドは省略形でも指定できます。空行を入力すると、直前のコマンドをリピートします。 !で始まる入力はシェルコマンドとして実行されます。

7.2.1 実行コマンド ¶

n
next: 現在のPRアドレスの命令を1つ実行します。実行後、レジスタ・メモリ・逆アセンブルが自動表示設定に従い表示されます。
c
continue: プログラムが終了するか、ブレークポイントに達するまで実行します。実行中、各ステップで逆アセンブルが自動表示設定に従い表示されます。

7.2.2 表示コマンド ¶

r

reverse

メモリを逆アセンブルして表示します。引数なしではロードされたプログラム全体を表示します。

r start end

アドレスを指定した場合は、startからendの範囲を表示します。アドレスは10進数または16進数（#xxxx形式）で指定できます。

r auto
r noauto

autoまたはaを指定すると逆アセンブルの自動表示をONに、 noautoまたはnを指定するとOFFにします。

t

trace

CPUレジスタの内容を算術（符号あり）表現で表示します。

t auto
t noauto

autoまたはaを指定するとレジスタの自動表示をONに、 noautoまたはnを指定するとOFFにします。

T

Trace

CPUレジスタの内容を論理（符号なし）表現で表示します。 auto/noautoの指定はtと同様です。

d

dump

メモリダンプを表示します。引数なしでは#0000から#0040の範囲を表示します。メモリサイズが#0040より小さい場合はメモリ全体を表示します。

d start
d start end
d start +length

startのみ指定した場合はstartから#0040語分、 endも指定した場合はstartからendの範囲を表示します。 +を付けた場合はstartからlength語分を表示します。

d auto
d noauto

autoまたはaを指定するとメモリダンプの自動表示をONに、 noautoまたはnを指定するとOFFにします。

7.2.3 ブレークポイントコマンド ¶

b add address
break add address: addressにブレークポイントを追加します。
b del address
break del address: addressのブレークポイントを削除します。
b list
break list: 設定中のブレークポイント一覧を表示します。
b reset
break reset: すべてのブレークポイントを削除します。

7.2.4 その他のコマンド ¶

l filepath [address]
load filepath [address]: filepathのオブジェクトファイルをメモリにロードします。 addressを省略した場合は#0000番地にロードします。
reset: CPUをリセットします。メモリの内容は保持されます。
resetall: CPUとメモリをリセットします。
q
quit: モニターを終了します。
?
h
help: コマンドのヘルプを表示します。
!command: シェルコマンドcommandを実行します。

Previous: モニターコマンド, Up: comet2monitor [Contents]

7.3 使用例 ¶

ldlad.oをオプションなしで起動し、ステップ実行します。デフォルトで逆アセンブルの自動表示がONのため、起動時にプログラム全体の逆アセンブル結果と、最初に実行される命令が表示されます。

$ comet2monitor -M32 as/sample/ldlad.o
        LAD     GR1,#0001       ; #0000: #1210 #0001
        LAD     GR2,#000B       ; #0002: #1220 #000B
        LD      GR3,#000B       ; #0004: #1030 #000B
        ST      GR2,#000C       ; #0006: #1120 #000C
        ST      GR3,#000C,GR1   ; #0008: #1131 #000C
        RET                     ; #000A: #8100
        DC      3               ; #000B: #0003 ::     3 = #0003 = 0000000000000011
        DC      0               ; #000C: #0000 ::     0 = #0000 = 0000000000000000
        DC      0               ; #000D: #0000 ::     0 = #0000 = 0000000000000000
        DC      0               ; #000E: #0000 ::     0 = #0000 = 0000000000000000
#0000: Disassemble::::        LAD     GR1,#0001       ; #0000: #1210 #0001

COMET II machine code monitor. Type ? for help.
(comet2 monitor) n
> n
#0002: Disassemble::::        LAD     GR2,#000B       ; #0002: #1220 #000B

(comet2 monitor) n
> n
#0004: Disassemble::::        LD      GR3,#000B       ; #0004: #1030 #000B

(comet2 monitor) q
> q
Quit: COMET II monitor

レジスタトレースとメモリダンプを追加して起動する場合は-Tと-dを指定します。

$ comet2monitor -Td -M32 as/sample/ldlad.o

逆アセンブルの自動表示をOFFにして最後まで一気に実行する場合は、モニター起動後にr noautoを実行してからcを使います。

(comet2 monitor) r noauto
> r noauto
(comet2 monitor) c
> c
Return to top.

YACASL2 - CASL II 処理システム ¶

Table of Contents

1 YACASL2の概要 ¶

2 YACASL2の使用例 ¶

2.1 実行結果の出力だけを表示 ¶

2.2 アセンブル結果の確認 ¶

2.3 モニターでステップ実行を確認する ¶

2.3.1 起動とステップ実行 ¶

2.3.2 ループを含むプログラムの実行 ¶

2.3.3 継続実行とブレークポイント ¶

2.3.4 ブレークポイントでループを1周ずつ確認する ¶

2.4 実行結果をまとめて確認する ¶

2.4.1 特定のレジスタを表示 ¶

2.4.2 プログラム終了時の値を表示 ¶

2.4.3 プログラムのステップ数を表示 ¶

2.5 オブジェクトファイルの作成 ¶

2.6 オブジェクトファイルの確認 ¶

2.7 1語の解析 ¶

2.8 CASL IIライブラリの使用 ¶

2.8.1 数値を出力する ¶

3 casl2 ¶

オプション ¶

4 comet2 ¶

オプション ¶

5 casl2rev ¶

オプション ¶

6 dumpword ¶

注意 ¶

オプション ¶

7 comet2monitor ¶

7.1 オプション ¶

7.2 モニターコマンド ¶

7.2.1 実行コマンド ¶

7.2.2 表示コマンド ¶

7.2.3 ブレークポイントコマンド ¶

7.2.4 その他のコマンド ¶

7.3 使用例 ¶

3 `casl2` ¶

4 `comet2` ¶

5 `casl2rev` ¶

6 `dumpword` ¶

7 `comet2monitor` ¶