/*---------------------------------------------------------------------
	Copyright (C) 1997, Nintendo.
	
	File		gs2main.s
	Coded    by	Yoshitaka Yasumoto.	Jan 23, 1997.
	Modified by	
	Comments	
	
	$Id: gs2main.s,v 1.1.1.1 2002/05/02 03:29:12 blythe Exp $
  ---------------------------------------------------------------------*/
#define		F3DEX_GBI
#define		OVERLAY_CODE
#include	<rsp.h>
#include	<rcp.h>
#include	<os.h>
#include	<sptask.h>
#include	<gbi.h>
#include	"gs2macros.h"

	#
	#  DMANOWAIT および DMANOWAIT2 で fifo へ転送する
	#
	.text	0x04001080
	.data	0x04000000

#include	"gs2regs.h"
#include	"gs2dmem.h"

	.text
	#
	# rspboot で 0x1080 にロードされ, ここから実行される
	#	

	# 初期化を行なう
doInit:
	# 定数の初期化
	_li	(vecptr, RSPOBJ_VPTR)
		vxor	vzero, vzero, vzero
	lqv	vconst[0],  oRSPOBJ_VCONST(vecptr)
	lqv	vconst1[0], oRSPOBJ_VCONST1(vecptr)
	lqv	vconst2[0], oRSPOBJ_VCONST2(vecptr)
	lqv	vconst3[0], oRSPOBJ_VCONST3(vecptr)
	
	# SP_STATUS レジスタの YIELDED フラグおよび TASKDONE フラグのクリア
	_set_sp_status( SP_CLR_YIELDED|SP_CLR_TASKDONE )
	
	# 定数の初期化 その 2
	vadd	vone, vzero, _0x0001

	# DMEM 内のコマンドバッファのポインタの初期化
	#	通常起動時および yield 復帰時共通
	#	yield 時にはバッファをフラッシュするので outp は初期値に戻る
	_li	(outp, RSP_OUTPUT_OFFSET)
	
	# GTASK_FLAGS を参照して Yield 復帰判定を行ない, 分岐する
	# その後 FLAGS をクリアする 
	_flag_z_goto( GTASK_FLAGS, OS_TASK_YIELDED, RSPstart)
	sw	zero, GTASK_FLAGS(zero)

	# ================================================================
	# Yield 復帰処理
	# ================================================================
	#
	# セーブしておいたレジスタを復帰し, 処理を再開する
	#   yield 時に outp は初期値に戻っているのでセーブしていない
	#
 #	lw	outp, (RSP_SCRATCH_OFFSET+0)(zero)
	lw	dinp, (RSP_SCRATCH_OFFSET+4)(zero)
#ifdef OVERLAY_CODE
	#
	# オーバーレイを実行して rspboot の部分を上書きする
	#   オーバーレイ終了後は GfxDone へ直接飛ぶ
	#
	lhu	return, RSP_JUMPTABLE_ORIG(zero)  # G_NOP の飛び先=GFXDONE
	j	loadOverlayPart0
#else
	j	GfxDone
#endif
	lw	inp,  (RSP_SCRATCH_OFFSET+8)(zero)
		
RSPstart:	
	# DP が現在 fifo のどこを処理しているかを判定する. 
	# Fast3D では xbus バージョンをサポートしていたが F3DEX,S2DEX
	# ではサポートしていないので XBUS かどうかの判定を省略する
Assign(rdpcur, 1)
Assign(rdpend, 2)
Assign(buftop, 3)
Assign(bufend, 4)
	
	# RDP のコマンド終了ポインタが fifo バッファの前にあるなら
	# fifo をリセットする
	lw	buftop, GTASK_OUTBUFF(zero)
	mfc0	rdpend, CMD_END
	_if_gotoR (buftop, gt, rdpend, restart_fifo)

	# CMD_CURRENT が 0 なら fifo のリセット
	mfc0	rdpcur, CMD_CURRENT
	_if_eq_gotoR(rdpcur, zero, restart_fifo)
	nop
	
	# CMD_CURRENT != CMD_END なら fifo を継続する
	_if_ne_gotoR(rdpcur, rdpend, set_fifo)

	# fifo のリセット処理
restart_fifo:

	# DP ステータスが DPC_STATUS_START_VALID になるまで待機
	_flag_c0_nz_goto(CMD_STATUS, DPC_STATUS_START_VALID, restart_fifo)

	# DP コマンドバッファを RDRAM を参照するように変更 (前半は Delay 内)
	_set_c0_regI(CMD_STATUS, DPC_CLR_XBUS_DMEM_DMA)

	# バッファの次に書き込む位置をリセットする
	lw	rdpend, GTASK_OUTBUFF_SZ(zero)

	# DP コマンドポインタを設定する
	_set_c0_regR(CMD_START, rdpend)
	_set_c0_regR(CMD_END,   rdpend)
	
set_fifo:
	# 次の DP コマンドの代入位置の設定
	sw	rdpend, RSP_STATEP_FIFO_OUTP(zero)

EndAssign(rdpcur, 1)
EndAssign(rdpend, 2)
EndAssign(buftop, 3)
EndAssign(bufend, 4)

#ifdef OVERLAY_CODE
	#
	# オーバーレイコードのポインタを作成する
	#     OVERLAY_OFFSET には各オーバーレイの ucode 先頭からの
	#     オフセット値が入っているので ucode の先頭番地を加算して
	#     実際のアドレスを得る
	#
Assign(base, 1)
Assign(ptr0, 2)
Assign(ptr1, 3)
Assign(ptr2, 4)
	lw	base, GTASK_UCODE(zero)
	lw	ptr0, OVERLAY_0_OFFSET+OVERLAY_OFFSET(zero)
	lw	ptr1, OVERLAY_1_OFFSET+OVERLAY_OFFSET(zero)
	lw	ptr2, OVERLAY_2_OFFSET+OVERLAY_OFFSET(zero)
	addu	ptr0, ptr0, base
	addu	ptr1, ptr1, base
	addu	ptr2, ptr2, base
	sw	ptr0, OVERLAY_0_OFFSET+OVERLAY_OFFSET(zero)
	sw	ptr1, OVERLAY_1_OFFSET+OVERLAY_OFFSET(zero)
	sw	ptr2, OVERLAY_2_OFFSET+OVERLAY_OFFSET(zero)
EndAssign(base, 1)
EndAssign(ptr0, 2)
EndAssign(ptr1, 3)
EndAssign(ptr2, 4)
	#
	# オーバーレイを実行して rspboot の部分を上書きする
	#
	jal	loadOverlayPart0
#endif
	#
	# DL の先頭番地を取得する
	#
	lw	inp, GTASK_DATA(zero)

	#------
	#  ここまでの IMEM はマイクロコード始動後, 使用しないので
	#  オーバーレイをかけて他のコードをロードできる.
	#------
	
	# ================================================================
	# DL 処理ループ
	# ================================================================
StartDLload:
	#
	# DL を DMEM に読み込む
	# dinp をロードカウンタ兼 DL ポインタとする.
	# この場合 dinp==0 で終了となる.
	# また現在処理中の DL は
	#   DRAM アドレス:	dinp+inp
	#   DMEM アドレス:	dinp+RSP_DLINPUT_BOTTOM
	# と表現できる.
	#
  AssignForDMAproc
	#
	# DMA 開始
	#
	_li	(dma_len,   GS_MAX_DL*8-1)
	_mov	(dram_adrs, inp)
	jal	DMAread
	_li	(dmem_adrs, RSP_DLINPUT_OFFSET)
	#
	# DL ポインタ加算
	#
	addiu	inp, inp, GS_MAX_DL*8
	#
	# DMA 終了待ち & ロードカウンタ初期化
	#
	jal	DMAwait
	_li	(dinp, -GS_MAX_DL*8)
  EndAssignForDMAproc
	#
	# LOAD ストールの間に DL の先頭の 1 byte/ 1 word を取得
        # 先頭の 1 byte を取り, テーブル参照で Jump する. 
	#
GfxDone:
	lb	gfx0, (RSP_DLINPUT_BOTTOM+0)(dinp)	# DL 1 byte 目取得
							# lb である必要あり
GfxDone1:	
	#
	# Yield 要求のチェック
	#
	mfc0	sys0, SP_STATUS				# YIELD 要求チェック
	lw	gfx1, (RSP_DLINPUT_BOTTOM+4)(dinp)	# DL 後半を gfx1 へ

#ifdef	ASSERT
	#
	# 現在処理中の DL の DRAM 上アドレスの出力
	#
	add	sys1, inp, dinp
	sw	sys1, ASSERT_SAVE_INP(zero)	
	#
	# 有効な DL であるかどうかを判定する (sys1 の bit31=1 なら OK)
	#
	srl	sys1, gfx0, 3
	andi	sys1, sys1, 0x001c
	lw	sys1, RSP_ASSERT_DL_TABLE(sys1)
	sllv	sys1, sys1, gfx0
#endif
	
	sll	gfx0, gfx0, 1				# INDEX 作成
		andi	sys0, sys0, SP_STATUS_YIELD	
		bne	sys0, zero, RSPYield		# YIELD 判定
	lhu	sys0, RSP_JUMPTABLE_ORIG(gfx0)		# テーブル参照
	beq	dinp, zero, StartDLload			# DL 終了なら新規ロード
	lw	gfx0, (RSP_DLINPUT_BOTTOM+0)(dinp)	# DL 前半を gfx0 へ

#ifdef	ASSERT
	#
	# 無効な DL コマンドなら停止する. 実行ログを記録する
	#
#  ifdef  LOGGING
  AssignForDMAproc
  Assign(save_sys0, 1)
	_mov	(save_sys0, sys0)
	sw	gfx0, ASSERT_SAVE_GFX0(zero)
	sh	sys0, ASSERT_SAVE_GFX0+2(zero)
	lw	dram_adrs, ASSERT_LOG_PTR(zero)
	_li	(dmem_adrs, ASSERT_SAVE_INP)
	_li	(dma_len, 7)
	jal	DMAproc
	_li	(iswrite, 1)
	addiu	dram_adrs, dram_adrs, 8
	bgezal	sys1, AssertHandler
	sw	dram_adrs, ASSERT_LOG_PTR(zero)
	_mov	(sys0, save_sys0)
  EndAssign(save_sys0, 1)
  EndAssignForDMAproc	
#  else
	bgezal	sys1, AssertHandler
	sw	gfx0, ASSERT_SAVE_GFX0(zero)
#  endif
#endif
	jr	sys0					# 各処理へ JUMP
	addiu	dinp, dinp, 8				# ポインタ加算 

	.symbol	adrs_GFXDONE,  GfxDone
	.symbol	adrs_GFXDONE1, GfxDone1

	# ================================================================
	# DMA 系処理
	# ================================================================
DMA_START:	.symbol	DUMMY_DMA_START, 0
#include	"gs2dma.s"
DMA_END:	.symbol	DUMMY_DMA_END, 0

	# ================================================================
	# RDP 系処理
	# ================================================================
RDP_START:	.symbol	DUMMY_RDP_START, 0
#include "gs2rdp.s"
RDP_END:	.symbol	DUMMY_RDP_END, 0

  #---------------------------------------------------------------------------
  # Overlay Part 1 コード
  #     gs2sprite.s, gs2rect.s と gs2bg1cyc.s をオーバーレイで入れ替える.
  #---------------------------------------------------------------------------
			.align	8
OVERLAY_P1_CODE:	.symbol	DUMMY_OVERLAY1,     0
			.align	8	# DMA の為の 8 byte alignment
	# ================================================================
	# 回転スプライト処理
	# ================================================================
SPRITE_START:		.symbol	DUMMY_SPRITE_START, 0
#include		"gs2sprite.s"
SPRITE_END:		.symbol	DUMMY_SPRITE_END, 0

	# ================================================================
	# 非回転スプライト処理
	# ================================================================
RECT_START:		.symbol	DUMMY_RECT_START, 0
#include		"gs2rect.s"
RECT_END:		.symbol	DUMMY_RECT_END, 0

			.align	8	# DMA の為の 8 byte alignment
OVERLAY_P1_CODE_END:	.symbol	DUMMY_OVERLAY1_END, 0
	.symbol	OVERLAY_P1_OFFSET, OVERLAY_P1_CODE-doInit
	.symbol	OVERLAY_P1_SIZE,   OVERLAY_P1_CODE_END-OVERLAY_P1_CODE-1
	.symbol	OVERLAY_AREA1,     OVERLAY_P1_CODE-0x04000000
	
	# ================================================================
	# BG 系処理
	# ================================================================
BGCOPY_START:	.symbol	DUMMY_BG_START, 0
#include "gs2bg.s"
BGCOPY_END:	.symbol	DUMMY_BG_END, 0

	# ================================================================
	# TMEM ロード処理
	# ================================================================
TMEM_START:	.symbol	DUMMY_TMEM_START, 0
#include "gs2tmem.s"
TMEM_END:	.symbol	DUMMY_TMEM_END, 0
		
#ifdef	OVERLAY_CODE
	# ================================================================
	# オーバーレイ処理
	# ================================================================
loadOverlayPart0:
  AssignForDMAproc
	_li	(sys0, 0)
loadOverlaySR:
	_mov	(sys1,return)
loadOverlaySR1:
	lw      dram_adrs, OVERLAY_0_OFFSET+OVERLAY_OFFSET(sys0)
	lhu     dmem_adrs, OVERLAY_0_OFFSET+OVERLAY_DEST(sys0)
	jal     DMAread
	lhu     dma_len, OVERLAY_0_OFFSET+OVERLAY_SIZE(sys0)
	j	DMAwait
	_mov	(return, sys1)
  EndAssignForDMAproc
#endif
	
	# ================================================================
	# セグメントアドレスを物理アドレスへ変換
	#   結局セグメントアドレスを使用するのは gfx1 の値のみなので
	#   処理対象を gfx1 -> (DMAproc の dram_adrs) 固定にする
	# ================================================================
AdrsFixup:
  Assign(dram_adrs, 19)
	srl	sys0, gfx1, 22			# セグメント index 取得
	andi	sys0, sys0, 0x3c
	lw	sys0, RSP_SEG_OFFSET(sys0)	# テーブル参照
	sll	gfx1, gfx1, 8			# 上位 8 bit をマスクする
	srl	gfx1, gfx1, 8
	jr	return
	add	dram_adrs, gfx1, sys0		# オフセットの加算
  EndAssign(dram_adrs, 19)
	
	# ================================================================
	# FIFO 出力処理
	# ================================================================ 
OutputCloseGfxDone:	
	#
	# OutputClose 後に GfxDone へジャンプする 
	#
#if	1	/* Faster */
	addi	sys0, outp, -RSP_OUTPUT_ENOUGH
	blez	sys0, GfxDone
#endif
	_li	(return, adrs_GFXDONE)
OutputClose:
  AssignForDMAproc
	#
	# DMEM 上のバッファにデータが貯まったかの判定
	# 3 角形コマンドを書き出すのに充分な空き容量がなければデータを
	# FIFO へ吐き出す
	#
	addi	sys0, outp, -RSP_OUTPUT_ENOUGH
	blez	sys0, ReturnToR31	# ただ単に return の位置に戻るのみ
OutputCloseFlush:
	#
	# FIFO パラメータ取得
	#
	lw	dram_adrs, RSP_STATEP_FIFO_OUTP(zero)	# FIFO 空き領域先頭
	lw	sys1,      GTASK_OUTBUFF_SZ(zero)	# FIFO 領域終端
	# 
	# DMEM バッファ内にデータがなければ Return
	#	
	addi	dma_len, outp, -RSP_OUTPUT_OFFSET	# 書き出すデータサイズ
	blez	dma_len, ReturnToR31
	#
	# FIFO の空き領域に収まるなら DMA 転送へ
	#
	sub	sys1, sys1, dram_adrs			# FIFO 空き領域サイズ
	sub	sys0, sys1, dma_len
	bgez	sys0, WaitFifoFree
	#
	# DP の STATUS が START_VALID でなくなるまで待つ
	#
WaitStartInvalid:	
	mfc0	sys0, CMD_STATUS
	andi	sys0, sys0, DPC_STATUS_START_VALID
	bne	sys0, zero, WaitStartInvalid
	#
	# FIFO 領域の先頭から書き込むデータ分だけの領域が空くまで待つ
	#
	lw	dram_adrs, GTASK_OUTBUFF(zero)		# FIFO 先頭
CheckTopBuffer:	
	mfc0	sys1, CMD_CURRENT
	beq	sys1, dram_adrs, CheckTopBuffer
	nop	
	mtc0	dram_adrs, CMD_START
WaitFifoFree:
	mfc0	sys1, CMD_CURRENT
	sub	sys1, sys1, dram_adrs			# FIFO 空き領域サイズ
	blez	sys1, CloseDMA
	sub	sys0, sys1, dma_len
	blez	sys0, WaitFifoFree
CloseDMA:
	#
	# FIFO 空き領域先頭ポインタ更新
	#
	add	sys1, dram_adrs, dma_len
	sw	sys1, RSP_STATEP_FIFO_OUTP(zero)
	#
	# DMA パラメータ設定 / DMA 開始
	#
	addi	dma_len, dma_len, -1
	ori	iswrite, return, 0x1000		# iswrite > 0 となる
	jal	DMAproc
	_li	(dmem_adrs, RSP_OUTPUT_OFFSET)
	#
	# DMA 終了待ち / DMEM バッファポインタ初期化
	#	iswrite の値を保持するため + 高速化のため展開する
	#
OutputCloseDMAwait:
	mfc0	sys0, DMA_BUSY
	bne	sys0, zero, OutputCloseDMAwait
	_li	(outp, RSP_OUTPUT_OFFSET)
	#
	# DP ポインタを更新する
	#
	jr	iswrite				# 呼び出し元に戻る
	mtc0	sys1, CMD_END			# DP ポインタ更新
  EndAssignForDMAproc
	
	# ================================================================
	# Yield 処理
	# ================================================================
RSPYield:	
  Assign(tmp, 1)
  AssignForDMAproc
	#
	# ucode の処理状態をセーブする
	#   outp は TaskDone でのバッファフラッシュにより RSP_OUTPUT_OFFSET 値
	#   に設定されるのでここでセーブする必要はない.
	#
	# バッファをフラッシュする
	#	
	lw	tmp,   GTASK_UCODE(zero)
 #	sw	outp, (RSP_SCRATCH_OFFSET+0)(zero)	# outp はフラッシュ
	sw	dinp, (RSP_SCRATCH_OFFSET+4)(zero)
	sw	inp,  (RSP_SCRATCH_OFFSET+8)(zero)
	jal	OutputCloseFlush
	sw	tmp,  (RSP_YIELD_SAVE_LEN-4)(zero)	# 現在の ucode を保存
	#
	# DMA 転送開始
	#
	lw	 dram_adrs, GTASK_YIELD(zero)
	_li	(dmem_adrs, 0)
	_li	(dma_len, RSP_YIELD_SAVE_LEN-1)
	_li	(iswrite, SP_SET_YIELDED|SP_SET_TASKDONE) # フラグとしても使用
	jal	DMAproc
	addiu	return, return, 8	# TaskDone2 へ飛ぶ
		
	# ================================================================
	# TaskDone 処理
	#   CPU に割り込み通知を送り, タスクを終了する
	# ================================================================
TaskDone:
	_li	(iswrite, SP_SET_TASKDONE)
	#	
	# バッファをフラッシュする
	#
TaskDone1:
	jal	OutputCloseFlush
	#
	# STATUS 更新
	#
TaskDone2:
	mtc0	iswrite, SP_STATUS
	#
	# CPU への割り込み通知
	#
	break
  EndAssign(tmp, 1)
		
	# ================================================================
	#   Assert 処理
	# ================================================================
#ifdef	ASSERT
AssertHandler:
	lui	iswrite, (SP_SET_SIG7 >> 16)
	sw	return, ASSERT_SAVE_PC(zero)
	j	TaskDone1
	ori	iswrite, iswrite, SP_SET_TASKDONE
#endif
  EndAssignForDMAproc
	
	# ================================================================
	#   LoadUcode の処理
	# ================================================================
		
	#
	# F3DEX シリーズとの融和のため, コードを共通化する.
	#
#define LOADUC_A_SIZE   6	/* DMANOWAIT2       */
#define LOADUC_B_SIZE   2	/* DMANOWAIT        */
#define LOADUC_C_SIZE   2	/* RDPHALF のコピー, dlcount のクリア */
#define LOADUC_START  0x04001f94-(LOADUC_A_SIZE+LOADUC_B_SIZE+LOADUC_C_SIZE)*4

#ifdef  NODATA
        .symbol case_G_SWITCH_UCODE,    LOADUC_START
        .symbol DMAwait,                0x04001fc4      /* gloaduc */
        .symbol DMAread,                0x04001fd4      /* gloaduc */
        .symbol DMAproc,                0x04001fd8      /* gloaduc */
#else
EndOfBody:

	#
	# IMEM のロード領域 0x1000-0x1fff の設定
	#
	.dmax   1025-(LOADUC_A_SIZE+LOADUC_B_SIZE+LOADUC_C_SIZE+27)
        .space  LOADUC_START
	.symbol	IMEM_PAD,	(LOADUC_START-EndOfBody)/4

	#
	# LoadUcode 命令の処理ルーチン
	#
	.unname	sys0
	.unname	UNUSE17
	.unname	UNUSE18
	.unname	UNUSE19
	.unname	UNUSE20
#include        "gs2loaduc.s"
	.name	sys0, $11
	.name	UNUSE17, $17
	.name	UNUSE18, $18
	.name	UNUSE19, $19
	.name	UNUSE20, $20
#endif
End_of_Main:	
        .dmax   1025	

  #---------------------------------------------------------------------------
  # Overlay Part 0 コード
  #---------------------------------------------------------------------------
OVERLAY_P0_CODE:	.symbol	DUMMY_OVERLAY0,     0
			.align	8	# DMA の為の 8 byte alignment	
	# ================================================================
	# IMM 系処理
	# ================================================================
IMM_START:		.symbol	DUMMY_IMM_START,    0
#include		 "gs2imm.s"
IMM_END:		.symbol	DUMMY_IMM_END,      0

			.align	8	# DMA の為の 8 byte alignment
OVERLAY_P0_CODE_END:	.symbol	DUMMY_OVERLAY0_END, 0
	.symbol	OVERLAY_P0_OFFSET, OVERLAY_P0_CODE-doInit
	.symbol	OVERLAY_P0_SIZE,   OVERLAY_P0_CODE_END-OVERLAY_P0_CODE-1

  #---------------------------------------------------------------------------
  # Overlay Part 2 コード
  #---------------------------------------------------------------------------
	#
	# アドレス指定
	#   SPRITE 処理部と入れ替える
	#
	.space		adrs_G_OBJ_SPRITE+0x1000

OVERLAY_P2_CODE:	.symbol	DUMMY_OVERLAY2,     0	
			.align	8	# DMA の為の 8 byte alignment
	# ================================================================
	# スケーリング可能な BG の処理
	# ================================================================
BG1CYC_START:		.symbol	DUMMY_BG1CYC_START,	0
#include		 "gs2bg1cyc.s"
BG1CYC_END:		.symbol	DUMMY_BG1CYC_END,	0

			.align	8	# DMA の為の 8 byte alignment
OVERLAY_P2_CODE_END:	.symbol	DUMMY_OVERLAY2_END,	0
	.symbol	OVERLAY_P2_OFFSET, OVERLAY_P0_CODE_END-doInit
	.symbol	OVERLAY_P2_SIZE,   OVERLAY_P2_CODE_END-OVERLAY_P2_CODE-1

  #---------------------------------------------------------------------------
  # Overlay に関するデータの計算
  #---------------------------------------------------------------------------
	.symbol	CODE_MAIN,	0
	.symbol	CODE_MAIN_SZ,	OVERLAY_P0_CODE_END-doInit
	.symbol	CODE_PART1,	OVERLAY_P2_CODE-doInit
	.symbol	CODE_PART1_SZ,	OVERLAY_P2_CODE_END-OVERLAY_P2_CODE

  #---------------------------------------------------------------------------
  # 各処理のコード量の計算
  #---------------------------------------------------------------------------
	.symbol	BOOT_INST,   (StartDLload-0x04001000)/4
	.symbol IMM_INST,    (IMM_END-IMM_START)/4
	.symbol IMM_PAD,     (IMM_PAD_END-IMM_PAD_START)/4
	.symbol DMA_INST,    (DMA_END-DMA_START)/4
	.symbol RDP_INST,    (RDP_END-RDP_START)/4
	.symbol SPRITE_INST, (SPRITE_END-SPRITE_START)/4
	.symbol RECT_INST,   (RECT_END-RECT_START)/4
	.symbol BGCOPY_INST, (BGCOPY_END-BGCOPY_START)/4
	.symbol BG1CYC_INST, (BG1CYC_END-BG1CYC_START)/4
	.symbol	BG1CYC_PAD_A,(BG1CYC_PAD_END_A-BG1CYC_PAD_START_A)/4
	.symbol	BG1CYC_PAD_B,(BG1CYC_PAD_END_B-BG1CYC_PAD_START_B)/4
	.symbol TMEM_INST,   (TMEM_END-TMEM_START)/4
	.symbol	OVL1_INST,   (OVERLAY_P1_SIZE+1)/4
	.symbol	OVL2_INST,   (OVERLAY_P2_SIZE+1)/4

	.print  "====================================================\n"
	.print	"  BOOT =%4d inst(s).\n", BOOT_INST
	.print	"   IMM =%4d inst(s).\n", IMM_INST
	.print	"   DMA =%4d inst(s).\n", DMA_INST
	.print	"   RDP =%4d inst(s).\n", RDP_INST
	.print	"SPRITE =%4d inst(s).\n", SPRITE_INST
	.print	"  RECT =%4d inst(s).\n", RECT_INST
	.print	"BGCOPY =%4d inst(s).\n", BGCOPY_INST
	.print	"BG1CYC =%4d inst(s).\n", BG1CYC_INST-BG1CYC_PAD_A-BG1CYC_PAD_B
	.print	"  TMEM =%4d inst(s).\n", TMEM_INST
	.print  "====================================================\n"
	.print  "Generic Free Area            残り =%4d inst(s).\n", IMEM_PAD
	.print	"Overlay Part 0 (gs2imm.s)    残り =%4d inst(s).\n", IMM_PAD
	.print	"Overlay Part 2a(gs2bg1cyc.s) 残り =%4d inst(s).\n", BG1CYC_PAD_A
	.print	"Overlay Part 2b(gs2bg1cyc.s) 残り =%4d inst(s).\n", BG1CYC_PAD_B
	.print  "====================================================\n"
	.print	"**** Check List **** ↓が 0 なら正常\n"
	.print	"Check End of Main = [%d] IMEM サイズ内におさまるか ?\n", End_of_Main-0x4002000
	.print	"Check Overlay P-0 = [%d] OVERLAY 0 のLoadSizeは一致?\n", (BOOT_INST&0xfffe)-IMM_INST
	.print	"Check Size8BX P-0 = [%d] OVERLAY 0 SIZE が 8 の倍数?\n", IMM_INST&1
	.print	"Check Align8B P-1 = [%d] OVERLAY 1 AREA の 8B Align?\n", OVERLAY_P1_CODE&7
	.print	"Check Size8BX P-1 = [%d] OVERLAY 1 SIZE が 8 の倍数?\n", OVL1_INST&1
	.print	"Check Align8B P-2 = [%d] OVERLAY 2 AREA が 8B Align?\n", OVERLAY_P2_CODE&7
	.print	"Check Size8BX P-2 = [%d] OVERLAY 2 SIZE が 8 の倍数?\n", OVL2_INST&1
	.print	"Check Overlay P-2 = [%d] OVERLAY 1,2 のサイズは一致?\n", OVL1_INST-OVL2_INST
	.print  "====================================================\n"
	
#define	ASSERT_UNNAME
#include	"gs2regs.h"

/*======== End of gs2main.s ========*/