Microsoft Word - QtSimulator-H28A.docx

Transcription

1 QtSpim とは? QtSpim MIPS Simulator 2016 年度計算機アーキテクチャ概論 ( 青野雅樹 ) ウィスコンシン大学で作られた MIPS シミュレータを Qt 1 で拡張したもの 本資料で扱う MIPS アセンブラは にあります 後の演習のために拡張子が.s のものを全部ダウンロード 上に示したサーバ上にも Windows 版の QtSpim(Qt という GUI を用いた MIPS のシミュレータプログラム ) がありますが 情報メディア基盤センターの端末室の Windows 内にも QtSpim という名前のプログラムがすでにインストールされていると思います QtSpim.exe からシミュレータを起動してください 起動すると以下のようなウィンドウが表示されます 1 フィンランドのノキア社が開発し 同じフィンランドにあるソフトウェア会社のディジア社がノキアから買収したツールで C++ 言語で書かれている 1

2 ファイルオープン 一方 このあから ここで実行するアセンブラプログラム例をまとめて適当なフォルダにダウンロードしておいてください その中で まず最初に add.s( 足し算 ) アセンブラをロードしてください add.s を選択 次に 以下のように ワンステップずつ実行するボタンをクリックしていってください 2

3 ワンステップ実行 subu 命令は addiu 命令に変換される move 命令は addu 命令 (R 形式 ) に変換される la 命令 (load address) は lui+ori 命令に変換され li 命令は ori 命令に変換される 以下の行がちょうど 本当に行いたい足し算命令の実行になります しばらく続けると Console( コンソール ) に 答えは 30 と表示されるはずです 3

4 最後は [ ] の (Exit) で終了するはずです MIPS アーキテクチャの概要データ型 / サイズ MIPS シミュレータでは 整数型 (int 型 ) float 型 文字型が用意されています データの保持単位はバイト 半語 ( ハーフワード ) 語( ワード ) サイズが用意されています 浮動小数点に関しては 1 語 ( ワード )32 ビットの IEEE 浮動小数点と2 語 ( ダブルワード )64 ビットの IEEE 浮動小数点が用意されています 文字データは1バイトで 文字列は連続するバイト文字で表現されます 以下が MIPS のメモリサイズをまとめたものです Name byte halfword word float double Size 8-bit 整数 16-bit 整数 32-bit 整数 32-bit 浮動小数点 64-bit 浮動小数点 MIPS でのメモリへのデータ保持は リトルエンディアンで表現されます つまり LSB(Least Significant Bit) は最小メモリ位置に保持されます 逆に MSB (Most Significant Bit) はメモリの最上位置に保持されます MSB LSB たとえば 以下のアセンブラコードがある場合 num1:.word 42 num2:.word 進数では 0x A となり 5,000,00010 は 0x004C4B40 で表現されます 4

5 MIPS のメモリ MIPS でのメモリは 以下のように論理的に分かれています high memory stack low memory heap uninitialized data data text (code) reserved CPU レジスタ MIPS での CPU レジスタは以下のように割り当てられます 参照する場合 先頭に $ がついていることに注意してください これらは汎用レジスタと呼ばれることがあります Register Name Register Number Register Usage $zero $0 ハードウェアでゼロ値 $at $1 ( 通常未使用 ) $v0 - $v1 $2 - $3 関数の結果保持 ( 低 / 高 ) $a0 - $a3 $4 - $7 関数の引数レジスタ群 $t0 - $t7 $8 - $15 テンポラリレジスタ $s0 - $s7 $16 - $23 テンポラリレジスタ $t8 - $t9 $24 - $25 テンポラリレジスタ $k0 - $k1 $26 - $27 OS で予約 ( ユーザ不可 ) $gp $28 グローバルポインタ $sp $29 スタックポインタ $fp $30 フレームポインタ $ra $31 戻りアドレス 5

6 その他の主なレジスタ Register Name $pc $status $cause $hi $lo Register Usage プログラムカウンタ状態レジスタ例外要因レジスタ乗算 / 除算レジスタ QtSpim のシステムサービス Service Name Call Code Input 整数 (32-bit) 1 $a0 integer to be printed Float 実数 (32-bit) 2 $f12 32-bit floating-point value to be printed Double 実数 (64-bit) 3 $f12 64-bit floating-point value to be printed 文字列 4 $a0 starting address of NULL terminated string to be printed Output 整数読込 (32-bit) 5 $v0 32-bit integer entered by user 実数読込 (32-bit) 6 $f0 32-bit floatingpoint value entered by user 実数読込 (64- bit) 7 $f0 64-bit floatingpoint value entered by user 文字列読込 8 $a0 starting address of buffer (of where to store character entered by user) $a1 length of buffer メモリ割当 9 $a0 number of bytes to allocate 終了 (exit) 10 $v0 starting address of allocated memory 6

7 MIPS の 2 つのメインプロセッサ ( 整数演算プロセッサと浮動小数点プロセッサ ) MIPS Chip Core Configuration CPU FPU 整数演算 $0 - $31 実数演算 $f0 - $f31 FPU ( 浮動小数点装置 ) は FPU コプロセッサと呼ばれることがあります ここにも $f0 から $f31 までの 32 個のレジスタがあります IEEE bit (float 型 ) 浮動小数点形式 s 指数部仮数部 IEEE bit (double 型 ) 浮動小数点は以下のように表現されます s 指数部仮数部 指数部には 11 ビットのバイアスがあり 32 ビットで 127 のゲタを加えたように 64 ビットでは 1023 のゲタを加えます 7

8 具体的なアセンブラ例 (1) 足し算 ( レジスタ + レジスタ メモリ ) # # add.s 足し算 #.text # テキスト領域開始.align 2.globl main main: subu $sp, $sp, 8 # スタックを確保 (8 バイト ) sw $ra, 0($sp) # $ra レジスタ退避 ( 戻り番地保持 ) sw $zero, 4($sp) # 結果保持用メモリ (4 バイト ) move $t1, $zero # $t1 レジスタを 0 で初期化 move $t2, $zero # $t2 レジスタを 0 で初期化 addiu $t1, $t1, 10 # $t1 レジスタを 10 増加 addiu $t2, $t2, 20 # $t1 レジスタを 20 増加 addu $t3, $t1, $t2 # $t3 = $t1 + $t2 sw $t3, 4($sp) # $t3 レジスタ結果をメモリ書込み la $a0, str # 文字列をセット li $v0, 4 # 文字列端末書き出しセット # システムコール li $v0, 1 # 整数書き出しセット lw $a0, 4($sp) # 整数値をロード # システムコール lw $ra, 0($sp) # 戻り番地復帰 addu $sp, $sp, 8 # スタックを戻す jr $ra # 戻り番地にジャンプ # データ領域.data.align 0 str:.asciiz " 答えは " このファイルを からダウンロードしてください (2) 引き算 (A( メモリ ) B( メモリ ) C( メモリ )) ( 課題 ) メモリ ( データ領域 )A 番地と B 番地に適当な数値があるとき メモリ領域のC 番地に A-B の引き算結果をセーブし その値をプリントする MIPS アセンブラを作成し 実行せよ 8

9 (3) 二乗和の計算 ( メモリに初期値を入れ二乗和を行うと仮定 ) # Array: A[i]=i (i=1,..,10) # File: array.s # Do: Result = Sum(A[i]*A[i])/10 for i = 1,...,10 # ========================================================.text.align 2.globl main main: sw $ra, 0($sp) # $ra レジスタを退避 ( 戻り番地保持 ) # レジスタ $s0 (A のアドレス ), $s1(a のインデックス ) la $s0, A # $s0 に A のアドレスをロード li $s1, 0 # $s1 に A のインデックスを初期化 # レジスタ $s2 (A のアドレス最後尾のオフセット ), $t2 に結果を保持 li $s2, 10 # $s2 にデータ数 40 をロードしておく li $t2, 0 # $t2 に値 0 をロードしておく Loop: # レジスタ $t0 は二乗和と条件分岐で使用 lw $t0, 0($s0) # $t0 に $s0 のアドレスにある A の配列中身をロード mul $t1, $t0, $t0 # $t1 = $t0 * $t0( 二乗和 ) addu $t2, $t1, $t2 # $t2 = $t1 + $t2( 積和 ) slt $t0, $s1, $s2 # if ($s1 < $s2) $t0 = 1 else $t0 = 0 addiu $s0, $s0, 4 # $s0 = $s0 + 4( アドレスを4バイト進める ) addiu $s1, $s1, 1 # $s1 = $s1 + 1( インデックスをインクリメント ) bne $t0, $zero, Loop # if ($t0!= $zero) goto Loop # $t0 == 0 の場合 印刷処理 la $a0, str # 文字列をセット li $v0, 4 # 文字列端末書き出しセット # システムコール li $v0, 1 # $t2 内の整数値の書き出しセット move $a0, $t2 # システムコール ( 実際に書き出す ) # 戻る準備 lw $ra, 0($sp) # $sp からのアドレスにあるデータをロード jr $ra # 戻り番地にジャンプ # データ領域.data.align 0 str:.asciiz "1*1+2* *10=".align 2 A: 9

10 .word 1,2,3,4,5,6,7,8,9,10 # 配列 A[10] の領域を確保なお このアセンブラを QtSpim シミュレータにロードすると 擬似アセンブラは実際に MIPS にあるアセンブラに変換されて以下のようなテキスト領域内の命令に変換されます User Text Segment [ ]..[ ] [ ] 8fa40000 lw $4, 0($29) ; 183: lw $a0 0($sp) # argc [ ] 27a50004 addiu $5, $29, 4 ; 184: addiu $a1 $sp 4 # argv [ ] 24a60004 addiu $6, $5, 4 ; 185: addiu $a2 $a1 4 # envp [ c] sll $2, $4, 2 ; 186: sll $v0 $a0 2 [ ] 00c23021 addu $6, $6, $2 ; 187: addu $a2 $a2 $v0 [ ] 0c jal 0x [main] ; 188: jal main [ ] nop ; 189: nop [ c] a ori $2, $0, 10 ; 191: li $v0 10 [ ] c ; 192: # 10 (exit) [ ] afbf0000 sw $31, 0($29) ; 11: sw $ra, 0($sp) # $ra レジスタを退避 ( 戻り番地保持 ) [ ] 3c lui $1, 4097 [A] ; 13: la $s0, A # $s0 に A のアドレスをロード [ c] ori $16, $1, 20 [A] [ ] ori $17, $0, 0 ; 14: li $s1, 0 # $s1 に A のインデックスを初期化 [ ] a ori $18, $0, 10 ; 16: li $s2, 10 # $s2 にデータ数 40 をロードしておく [ ] 340a0000 ori $10, $0, 0 ; 17: li $t2, 0 # $t2 に値 0 をロードしておく [ c] 8e lw $8, 0($16) ; 20: lw $t0, 0($s0) # $t0 に $s0 のアドレスにある A の配列中 をロード [ ] mul $9, $8, $8 ; 21: mul $t1, $t0, $t0 # $t1 = $t0 * $t0( 乗和 ) [ ] 012a5021 addu $10, $9, $10 ; 22: addu $t2, $t1, $t2 # $t2 = $t1 + $t2( 積和 ) [ ] a slt $8, $17, $18 ; 24: slt $t0, $s1, $s2 # if ($s1 [ c] addiu $16, $16, 4; 25: addiu $s0, $s0, 4 # $s0 = $s0 + 4( アドレス4バイト進める ) [ ] addiu $17, $17, 1 ; 26: addiu $s1, $s1, 1 # $s1 = $s1 + 1( インデックスをインクリメント ) [ ] 1500fffa bne $8, $0, -24 [Loop-0x ] [ ] 3c lui $1, 4097 [str] ; 29: la $a0, str # 字列をセット [ c] ori $4, $1, 0 [str] la 命令は lui 命令と ori 命令に分解される Loop ラベルはアセン ブラによりオフセッ ト値に変換される [ ] ori $2, $0, 4 ; 30: li $v0, 4 # 字列端末書き出しセット [ ] c ; 31: # システムコール [ ] ori $2, $0, 1 ; 33: li $v0, 1 # $t2 内の整数値の書き出しセット [ c] 000a2021 addu $4, $0, $10 ; 34: move $a0, $t2 [ ] c ; 35: # システムコール ( 実際に書き出す ) [ ] 8fbf0000 lw $31, 0($29) ; 37: lw $ra, 0($sp) # $sp からのアドレスにあるデータをロード 10

11 [ ] 03e00008 jr $31 ; 38: jr $ra # 戻り番地にジャンプ (4) メモリのデータ Swap 実現例 ( 課題 ) メモリ番地 A にあるデータと B にあるデータの中身と交換する MIPS アセンブラを作成せよ ただし 他のメモリは使わないとし できるだけ少ないレジスタで実現することとする また Swap が正しく実現できたことを示すコンソールへの出力も示すこと (5) スタックを使ったサブルーチン実現例 ( その 1) コンピュータで 関数 ( 手続き サブルーチン ) を実現するには どのようなアーキテクチ ャがあればいいでしょうか? その答えを知るには 関数を呼び出すとき # Factorial: f(n) = n! = n * f(n-1) # File: factorial.s # Author: Masaki Aono # ======================================================.text # this is program code.align 2 # instructions must be on word boundaries.globl main # main is a global label main: subu $sp, $sp, 8 # スタックに 8 バイト (2ワード) 確保する sw $ra, 4($sp) # 戻りアドレスをスタックの第二ワード部分に退避 li $a0, 10 # 引数 10 を $a0 に代入 ($a0 = 10) jal fact # 階乗関数を呼び出す la $a0, str1 # フォーマットの文字列のアドレスを $a0 に move $s1, $v0 # fact の結果を $s1 に収める li $v0, 4 # print_str のシステムコール li $v0, 1 # print_int のシステムコール move $a0, $s1 # fact の結果を書き出す la $a0, str2 # フォーマットの文字列のアドレスを $a0 に li $v0, 4 # print_str のシステムコール lw $ra, 4($sp) # 戻りアドレスを設定 addu $sp, $sp, 8 # スタック フレームをポップ jr $ra # サブルーチンから呼び出し側に戻る.data str1:.asciiz "10 の階乗は " str2:.asciiz " です n" 11

12 fact:.text # テキスト領域にサブルーチンをとる # 階乗関数のスタート subu $sp, $sp, 8 # スタック フレームは 32 バイト長 sw $ra, 4($sp) # 戻りアドレスを退避 sw $a0, 0($sp) # 第一引数 (n) を退避 lw $v0, 0($sp) # n をロードする bgtz $v0, Case2 # n>0 の場合に分岐 li $v0, 1 # 1 を返す ( 結果は $v0 に置く ) j Case1 # 戻り処理 Case1 にジャンプ Case2: lw $v1, 0($sp) # n をロードする subu $v0, $v1, 1 # n-1 を計算 move $a0, $v0 # 値を $a0 に収める jal fact # 階乗関数を呼び出す lw $v1, 0($sp) # n をロードする mul $v0, $v0, $v1 # fact(n-1)*n を計算 Case1: lw $ra, 4($sp) # 戻りアドレスを復元 addu $sp, $sp, 8 # スタックポインタをポップし戻す jr $ra # 呼び出し元へジャンプ C 言語で書くと 以下のようなコードとなる int fact(int n) { if (n > 0) return (n*fact(n-1)); else return(1); } ここでの一番の問題は 再帰的な関数 (fact(int n) の中で fact(n-1) を呼ぶ ) User Text Segment [ ]..[ ] [ ] 8fa40000 lw $4, 0($29) ; 183: lw $a0 0($sp) # argc [ ] 27a50004 addiu $5, $29, 4 ; 184: addiu $a1 $sp 4 # argv [ ] 24a60004 addiu $6, $5, 4 ; 185: addiu $a2 $a1 4 # envp [ c] sll $2, $4, 2 ; 186: sll $v0 $a0 2 [ ] 00c23021 addu $6, $6, $2 ; 187: addu $a2 $a2 $v0 12

13 [ ] 0c jal 0x [main] ; 188: jal main [ ] nop ; 189: nop [ c] a ori $2, $0, 10 ; 191: li $v0 10 [ ] c ; 192: # 10 (exit) [ ] 27bdfff8 addiu $29, $29, -8 ; 11: subu $sp, $sp, 8 # スタックに 8 バイト (2ワード) 確保する [ ] afbf0004 sw $31, 4($29) ; 12: sw $ra, 4($sp) # 戻りアドレスを退避 [ c] a ori $4, $0, 10 ; 14: li $a0, 10 # 引数 10 を $a0 に代 ($a0 = 10) [ ] 0c10001c jal 0x [fact] ; 15: jal fact # 階乗関数を呼び出す [ ] 3c lui $1, 4097 [str1] ; 17: la $a0, str1 # フォーマットの 字列のアドレスを $a0 に [ ] ori $4, $1, 0 [str1] [ c] addu $17, $0, $2 ; 18: move $s1, $v0 # fact の結果を $s1 に収める [ ] ori $2, $0, 4 ; 19: li $v0, 4 # print_str のシステムコール [ ] c ; 20: [ ] ori $2, $0, 1 ; 22: li $v0, 1 # print_int のシステムコール [ c] addu $4, $0, $17 ; 23: move $a0, $s1 # fact の結果を書き出す [ ] c ; 24: [ ] 3c lui $1, 4097 [str2] ; 26: la $a0, str2 # フォーマットの 字列のアドレスを $a0 に [ ] f ori $4, $1, 15 [str2] [ c] ori $2, $0, 4 ; 27: li $v0, 4 # print_str のシステムコール [ ] c ; 28: [ ] 8fbf0004 lw $31, 4($29) ; 30: lw $ra, 4($sp) # 戻りアドレスを設定 [ ] 27bd0008 addiu $29, $29, 8 ; 31: addu $sp, $sp, 8 # スタック フレームをポップ [ c] 03e00008 jr $31 ; 32: jr $ra # サブルーチンから呼び出し側に戻る [ ] 27bdfff8 addiu $29, $29, -8 ; 40: subu $sp, $sp, 8 # スタック フレームは 32 バイト [ ] afbf0004 sw $31, 4($29) ; 41: sw $ra, 4($sp) # 戻りアドレスを退避 [ ] afa40000 sw $4, 0($29) ; 42: sw $a0, 0($sp) # 引数 (n) を退避 [ c] 8fa20000 lw $2, 0($29) ; 44: lw $v0, 0($sp) # n をロードする [ ] 1c bgtz $2 12 [Case2-0x ]; 45: bgtz $v0, Case2 # n>0 の場合に分岐 [ ] ori $2, $0, 1 ; 46: li $v0, 1 # 1 を返す [ ] j 0x004000a4 [Case1] ; 47: j Case1 # 戻り処理にジャンプ [ c] 8fa30000 lw $3, 0($29) ; 50: lw $v1, 0($sp) # n をロードする [ ] 2462ffff addiu $2, $3, -1 ; 51: subu $v0, $v1, 1 # n-1 を計算 [ ] addu $4, $0, $2 ; 52: move $a0, $v0 # 値を $a0 に収める [ ] 0c10001c jal 0x [fact] ; 53: jal fact # 階乗関数を呼び出す [ c] 8fa30000 lw $3, 0($29) [004000a0] mul $2, $2, $3 ; 55: lw $v1, 0($sp) # n をロードする ; 56: mul $v0, $v0, $v1 # fact(n-1)*n を計算 13

14 [004000a4] 8fbf0004 lw $31, 4($29) [004000a8] 27bd0008 addiu $29, $29, 8 [004000ac] 03e00008 jr $31 ; 59: lw $ra, 4($sp) # 戻りアドレスを復元 ; 60: addu $sp, $sp, 8 # スタック フレームをポップ ; 61: jr $ra # 呼び出し元へジャンプ レジスタ群は QtSpim の Int Regs [16] タブから 以下のようである なお これは 実 が [ ] の jal 命令の直前まで進 した時点でのレジスタを表す (PC の値が より わかる PC = ( プログラム カウンタ ) EPC = 0 Cause = 0 BadVAddr = 0 Status = 3000ff10 HI = 0 LO = 0 R0 [r0] = 0 R1 [at] = 0 R2 [v0] = 4 ( 関数の戻り値を れるレジスタ ) R3 [v1] = 0 R4 [a0] = a ( 関数の第 1 引数を れるレジスタ :16 進数で a で 10 進数で 10 が ってる ) R5 [a1] = 7ffff134 R6 [a2] = 7ffff13c R7 [a3] = 0 R8 [t0] = 0 R9 [t1] = 0 R10 [t2] = 0 R11 [t3] = 0 R12 [t4] = 0 R13 [t5] = 0 R14 [t6] = 0 R15 [t7] = 0 R16 [s0] = 0 R17 [s1] = 0 R18 [s2] = 0 R19 [s3] = 0 R20 [s4] = 0 R21 [s5] = 0 R22 [s6] = 0 R23 [s7] = 0 R24 [t8] = 0 10の階乗計算の結果はコンソールに表 される R25 [t9] = 0 14

15 R26 [k0] = 0 R27 [k1] = 0 R28 [gp] = R29 [sp] = 7ffff128 ($sp でスタックポインタ : つまり関数などにジャンプする際にレジスタ値をセーブするメモリのスタック領域のアドレスを保持している ) R30 [s8] = 0 R31 [ra] = ( テキスト領域での関数の戻りアドレスを保持 ) (6) スタックを使ったサブルーチン実現例 ( その 2) つぎに 最大公約数の計算を スタック (Jump And Link) を使って実現する例を見てみます #################################################### # gcd.s --- ユークリッドの互除法を用いた2つの整数の最大公約数 # (greatest common divisor) を再帰的に求める #################################################### # データ領域.data pr1:.asciiz" 終了するときは 0 を入力してください n" pr2:.asciiz"iを入力してください: " pr3:.asciiz"jを入力してください: " rs1:.asciiz " 最大公約数 " rs2:.asciiz " と " rs3:.asciiz " は " rs4:.asciiz " です n" #################################################### # main ####################################################.text.globl main main: sub $sp, $sp, 12 # 3ワード分 スタックに確保 sw $ra, 8($sp) # return address レジスタ sw $s0, 4($sp) # i は $s0 レジスタ. sw $s1, 0($sp) # j は $s1 レジスタ. li $v0, 4 # コンソールにプログラム終了条件表示 la $a0, pr1 while: # i と j(2つの整数入力 ) li $v0, 4 # iの入力を促す la $a0, pr2 15

16 li $v0, 5 # iをコンソールから読み込む move $s0, $v0 # 読み込んだ整数 i を $s0 レジスタにコピー if: beqz $s0, ewhile # branch to "ewhile" if $s0==0 li $v0, 4 # jの入力を促す la $a0, pr3 li $v0, 5 # jをコンソールから読み込む move $s1, $v0 # 読み込んだ整数 j を $s1 レジスタにコピー # Compute GCD of i and j move $a0, $s0 # $s0を引数レジスタ $a0 にコピー move $a1, $s1 # $s1 を引数レジスタ $a1 にコピー jal gcd # GCD を呼び出す move $t0, $v0 # GCDの結果を $t0 レジスタにコピー li $v0, 4 # Begin printing result string. la $a0, rs1 # 最大公約数をプリント li $v0, 1 # iをプリント. move $a0, $s0 li $v0, 4 la $a0, rs2 # と をプリント li $v0, 1 # jをプリント move $a0, $s1 li $v0, 4 la $a0, rs3 # は をプリント li $v0, 1 # gcd(i, j) の結果をプリント move $a0, $t0 li $v0, 4 # です をプリント la $a0, rs4 16

17 b while # 無条件ジャンプ ewhile: li $v0, 0 # 戻り値をセット lw $s1, 0($sp) # レジスタの値を回復 lw $s0, 4($sp) lw $ra, 8($sp) add $sp, $sp, 12 jr $ra # Return. ################################################## # gcd --- Implement the gcd() function from gcd.c below. ## Use the following memory map for this function: # # $ra # # $s0 Store $s0's value here, then use $s0 for i. In what # register is i initially? # $s1 Store $s1's value here, then use $s1 for j. In what # register is j initially? # # int gcd(int i, int j) # { # if (j == 0) return i; # else # return gcd(j, i % j); /* % is the remainder operator */ # } # ##################################################.text gcd: # a0 and a1 are the two integer parameters # return value is in v0 move $t0, $a0 move $t1, $a1 loop: beq $t1, $0, done div $t0, $t1 move $t0, $t1 mfhi $t1 # 除算の余りを $t1 レジスタに取り出す j loop # ユークリッドの互除法 : 反復法 done: move $v0, $t0 # 最大公約数が $v0 に 17

18 jr $ra このプログラムを QtSpim シミュレータにアップすると 以下のように翻訳されます ( 実行前 ) User Text Segment [ ]..[ ] [ ] 8fa40000 lw $4, 0($29) ; 183: lw $a0 0($sp) # argc [ ] 27a50004 addiu $5, $29, 4 ; 184: addiu $a1 $sp 4 # argv [ ] 24a60004 addiu $6, $5, 4 ; 185: addiu $a2 $a1 4 # envp [ c] sll $2, $4, 2 ; 186: sll $v0 $a0 2 [ ] 00c23021 addu $6, $6, $2 ; 187: addu $a2 $a2 $v0 [ ] 0c jal 0x [main] ; 188: jal main [ ] nop ; 189: nop [ c] a ori $2, $0, 10 ; 191: li $v0 10 [ ] c ; 192: # 10 (exit) [ ] 23bdfff4 addi $29, $29, -12 ; 20: sub $sp, $sp, 12 # 3 ワード分 スタックに確保 [ ] afbf0008 sw $31, 8($29) ; 21: sw $ra, 8($sp) # 戻りアドレスレジスタを退避 [ c] afb00004 sw $16, 4($29) ; 22: sw $s0, 4($sp) # $s0 レジスタを退避 [ ] afb10000 sw $17, 0($29) ; 23: sw $s1, 0($sp) # $s1 レジスタを退避 [ ] ori $2, $0, 4 ; 25: li $v0, 4 # コンソールにプログラム終了条件表 [ ] 3c lui $4, 4097 [pr1] ; 26: la $a0, pr1 [ c] c ; 27: [ ] ori $2, $0, 4 ; 29: li $v0, 4 # i の を促す [ ] 3c lui $1, 4097 [pr2] ; 30: la $a0, pr2 [ ] ori $4, $1, 54 [pr2] [ c] c ; 31: [ ] ori $2, $0, 5 ; 33: li $v0, 5 # i をコンソールから読み込む [ ] c ; 34: [ ] addu $16, $0, $2 ; 35: move $s0, $v0 # 読み込んだ整数 i を $s0 レジスタにコピー [ c] beq $16, $0, 152 [ewhile-0x c] [ ] ori $2, $0, 4 ; 40: li $v0, 4 # j の を促す [ ] 3c lui $1, 4097 [pr3] ; 41: la $a0, pr3 [ ] ori $4, $1, 85 [pr3] [ c] c ; 42: [ ] ori $2, $0, 5 ; 44: li $v0, 5 # j をコンソールから読み込む [ ] c ; 45: [ ] addu $17, $0, $2 ; 46: move $s1, $v0 # 読み込んだ整数 j を $s1 レジスタにコピ ー [ c] addu $4, $0, $16 ; 48: move $a0, $s0 # $s0 を引数レジスタ $a0 にコピー [ ] addu $5, $0, $17 ; 49: move $a1, $s1 # $s1 を引数レジスタ $a1 にコピー [ ] 0c jal 0x c [gcd] ; 50: jal gcd # GCD を呼び出す [ ] addu $8, $0, $2 ; 51: move $t0, $v0 # GCD の結果を $t0 レジスタにコピー [ c] ori $2, $0, 4 ; 53: li $v0, 4 # Begin printing result string. [ ] 3c lui $1, 4097 [rs1] ; 54: la $a0, rs1 # 最 公約数をプリント [ ] ori $4, $1, 116 [rs1] [ ] c ; 55: [ c] ori $2, $0, 1 ; 57: li $v0, 1 # i をプリント. [004000a0] addu $4, $0, $16 ; 58: move $a0, $s0 [004000a4] c ; 59: [004000a8] ori $2, $0, 4 ; 61: li $v0, 4 [004000ac] 3c lui $1, 4097 [rs2] [004000b0] ori $4, $1, 134 [rs2] [004000b4] c [004000b8] ori $2, $0, 1 ; 62: la $a0, rs2 # と をプリント ; 63: ; 65: li $v0, 1 # j をプリント [004000bc] addu $4, $0, $17 ; 66: move $a0, $s1 18

19 [004000c0] c ; 67: [004000c4] ori $2, $0, 4 ; 69: li $v0, 4 [004000c8] 3c lui $1, 4097 [rs3] ; 70: la $a0, rs3 # は をプリント [004000cc] c ori $4, $1, 140 [rs3] [004000d0] c ; 71: [004000d4] ori $2, $0, 1 ; 73: li $v0, 1 # gcd(i, j) の結果をプリント [004000d8] addu $4, $0, $8 ; 74: move $a0, $t0 [004000dc] c ; 75: [004000e0] ori $2, $0, 4 ; 77: li $v0, 4 # です をプリント [004000e4] 3c lui $1, 4097 [rs4] ; 78: la $a0, rs4 [004000e8] ori $4, $1, 146 [rs4] [004000ec] c ; 79: [004000f0] 0401ffd4 bgez $0-176 [while-0x004000f0]; 81: b while # 無条件ジャンプ [004000f4] ori $2, $0, 0 ; 84: li $v0, 0 # 戻り値をセット [004000f8] 8fb10000 lw $17, 0($29) ; 86: lw $s1, 0($sp) # レジスタの値を回復 [004000fc] 8fb00004 lw $16, 4($29) ; 87: lw $s0, 4($sp) [ ] 8fbf0008 lw $31, 8($29) ; 88: lw $ra, 8($sp) [ ] 23bd000c addi $29, $29, 12 ; 89: add $sp, $sp, 12 [ ] 03e00008 jr $31 ; 90: jr $ra # Return. [ c] addu $8, $0, $4 ; 115: move $t0, $a0 [ ] addu $9, $0, $5 ; 116: move $t1, $a1 [ ] beq $9, $0, 20 [done-0x ] [ ] a div $8, $9 ; 119: div $t0, $t1 [ c] addu $8, $0, $9 ; 120: move $t0, $t1 [ ] mfhi $9 ; 121: mfhi $t1 # 除算の余りを $t1 レジスタに取り出す [ ] j 0x [loop] ; 122: j loop # ユークリッドの互除法 : 反復法 [ ] addu $2, $0, $8 ; 124: move $v0, $t0 # 最 公約数が $v0 に [ c] 03e00008 jr $31 ; 125: jr $ra User data segment [ ]..[ ] [ ]..[1000ffff] [ ] e482b5e7 81e386ba 8b82e399 e3a881e [ ] 81e38d e3af 9282e330 e5a585e [ ] 81e39b8a a681e397 e38f81e3 81e3a [ ] 8481e395 e369000a 85e b8ae5a i [ ] e39781e3 81e3a681 a081e38f e39581e [ ] 203a e36a00 a585e592 e39b8ae5.. :. j [ ] 81e f81e3a6 e3a081e3 81e [ ] 00203a84 e5809ce6 85e5a7a4 84b4e7ac. : [ ] 3ab095e6 e a881 af81e : [ ] e e3a e a [100100a0]..[1003ffff] User Stack [7ffff6f8]..[ ] [7ffff6f8] ffff7b [7ffff700] fffffe1 7fffffbb 7fffffa [7ffff710] 7fffff6b 7fffff2f 7ffffefe 7ffffee4 k... / [7ffff720] 7ffffec0 7ffffeac 7ffffe9f 7ffffe8a [7ffff730] 7ffffe74 7ffffe4b 7ffffe30 7ffffe19 t... K [7ffff740] 7ffffe0b 7ffffb1a 7ffffadc 7ffffac [7ffff750] 7ffffaa4 7ffffa5c 7ffffa4a 7ffffa \... J [7ffff760] 7ffffa17 7ffff9f3 7ffff9ca 7ffff9ac

20 [7ffff770] 7ffff96b 7ffff954 7ffff940 7ffff931 k [7ffff780] 7ffff91b 7ffff8f5 7ffff8d0 7ffff8b [7ffff790] 7ffff8aa 7ffff890 7ffff83e 7ffff7ec > [7ffff7a0] 7ffff7da 7ffff7cd このプログラムを実行すると コンソールには以下のように初期表示されます ここで たとえば i に 306, j に 204 を代入すると 以下のように解答されます (7) 球の表面積と体積の計算 ( 実数演算例 ) つぎに 最大公約数の計算を スタック (Jump And Link) を使って実現する例を見てみます S 4 r 2 4 V r 3 を計算することになります 今 半径 と仮定した場合の浮動小数点演算 (float 型 ) で計算する事例を紹介します 3 #################################################### # floatpi.s --- 球の表面積と体積の計算例 #################################################### ## Example program to calculate the surface area # and volume of a sphere given the radius. # # Data Declarations 20

21 .data pi:.float fourptzero:.float 4.0 threeptzero:.float 3.0 radius:.float surfacearea:.float 0.0 volume:.float 0.0 str1:.asciiz " 球の面積は " str2:.asciiz " 球の体積は " strn:.asciiz " です n" # # text/code section.text.globl main main: # 命令で.s が末尾につくものは 実数の single precision( 単精度 ) という意味です # ここでは出ませんが 末尾に.d がつくと倍精度 (double 型 ) の意味になります # # Compute: (4.0 * pi) which is used for both equations. l.s $f2, fourptzero # 浮動小数点のロード l.s $f4, pi mul.s $f4, f2, $f4 # 4.0 * pi ( 単精度の乗算 ) l.s $f6, radius # radius # # Calculate surface area of a sphere. # surfacearea = 4.0 * pi * radius^2 mul.s $f8, $f6, $f6 # radius^2 mul.s $f8, $f4, $f8 # 4.0 * pi * radius^2 s.s $f8, surfacearea # 浮動小数点のストア la $a0, str1 # 文字列をセット li $v0, 4 # 文字列端末書き出しセット # システムコール mov.s $f12, $f8 li $v0, 2 la $a0, strn # 文字列をセット 21

22 li $v0, 4 # 文字列端末書き出しセット # システムコール # # Calculate volume of a sphere. # volume = (4.0 * pi / 3.0) * radius^3 l.s $f8, threeptzero div.s $f7, $f4, $f8 # (4.0 * pi / 3.0) 単精度の除算 mul.s $f10, $f6, $f6 mul.s $f10, $f10, $f6 mul.s $f12, $f7, $f10 s.s $f12, volume # radius^3 #4.0*pi/3.0*radius^3 store final answer la $a0, str2 # 文字列をセット li $v0, 4 # 文字列端末書き出しセット # システムコール # mov.s $f12, $f8 li $v0, 2 la $a0, strn # 文字列をセット li $v0, 4 # 文字列端末書き出しセット # システムコール #exit li $v0, 10 # terminate program 22