const char gIllegalChars[] = "&<>"; const char * Sanitise( const char * str ) { // // Quickly check to see if there are any illegal characters in the string // const char * b( str ); const char * e( str + strlen(str) ); // Point to nullptr char const char * s = std::find_first_of( b, e, gIllegalChars, gIllegalChars+ARRAYSIZE(gIllegalChars)); if( s == e ) { return str; } static std::string out; out.resize( 0 ); out.reserve( strlen( str ) ); // // Pretty lame. Could avoid doing a char-by-char copy // while( *str ) { switch( *str ) { case '&': out += "&"; break; case '<': out += "<"; break; case '>': out += ">"; break; default: out += *str; break; } str++; } return out.c_str(); } #if defined( DAEDALUS_W32 ) extern char *disasmx86(u8 *opcode1,int codeoff1,int *len); void DisassembleBuffer( const u8 * buf, int buf_size, FILE * fh ) { int pos = 0; /* current position in buffer */ char *strbuf; int len = 0; const u32 base_address( reinterpret_cast< u32 >( buf ) ); while ( pos < buf_size ) { strbuf = disasmx86((u8*)buf + pos, 0, &len); fprintf( fh, "%08x: %s\n", buf + pos, Sanitise( strbuf ) ); pos += len; } } #elif defined ( DAEDALUS_PSP ) void DisassembleBuffer( const u8 * buf, int buf_size, FILE * fh ) { const int STRBUF_LEN = 1024; char strbuf[STRBUF_LEN+1]; const OpCode * p_op( reinterpret_cast< const OpCode * >( buf ) ); const OpCode * p_op_end( reinterpret_cast< const OpCode * >( buf + buf_size ) ); while( p_op < p_op_end ) { u32 address( reinterpret_cast< u32 >( p_op ) ); OpCode op_code( *p_op ); SprintOpCodeInfo( strbuf, address, op_code ); fprintf( fh, "%08x: %08x %s\n", address, op_code._u32, Sanitise( strbuf ) ); p_op++; } } #endif #endif // defined( DAEDALUS_DEBUG_DYNAREC ) #ifdef DAEDALUS_DEBUG_DYNAREC //************************************************************************************* // //************************************************************************************* void CFragment::DumpFragmentInfoHtml( FILE * fh, u64 total_cycles ) const { float pc_total_cycles( 0.0f ); if( total_cycles > 0 ) { pc_total_cycles = 100.0f * float( GetCyclesExecuted() ) / float( total_cycles ); } fputs( "", fh ); fputs( "\n", fh ); fprintf( fh, "Fragment %08x\n", GetEntryAddress() ); fputs( "\n", fh ); fputs( "\n", fh ); fprintf( fh, "

Fragment %8x

\n", GetEntryAddress() ); fputs( "

\n", fh ); fprintf( fh, "\n", GetCyclesExecuted() ); fprintf( fh, "\n", pc_total_cycles ); fprintf( fh, "\n", mHitCount ); fprintf( fh, "\n", GetInputLength() ); fprintf( fh, "\n", GetOutputLength() ); fprintf( fh, "\n", f32( GetOutputLength() ) / f32( GetInputLength() ) ); #ifdef DAEDALUS_ENABLE_OS_HOOKS if (mTraceBuffer.empty()) fprintf( fh,"\n", Patch_GetJumpAddressName(mEntryAddress)); #endif fputs( "

Cycles	%d
Cycles %%	%.2f%%
Hit count	%d
Input Bytes	%d
Output Bytes	%d
Expansion ratio	%.2fx
function name	%s

\n", fh ); fputs( "

Register Usage

\n", fh ); fputs( "

\n", fh ); fputs( "\n", fh ); fputs( "\n", fh ); fputs( "\n", fh ); fputs( "

Read	", fh ); for(u32 i = 1; i < NUM_N64_REGS; ++i) { if(mRegisterUsage.RegistersRead&(1<
Written	", fh ); for(u32 i = 1; i < NUM_N64_REGS; ++i) { if(mRegisterUsage.RegistersWritten&(1<
Bases	", fh ); for(u32 i = 1; i < NUM_N64_REGS; ++i) { if(mRegisterUsage.RegistersAsBases&(1<

\n", fh ); fputs( "

Spans

\n", fh ); fputs( "

\n", fh );
	for(RegisterSpanList::const_iterator span_it = mRegisterUsage.SpanList.begin(); span_it < mRegisterUsage.SpanList.end(); ++span_it )
	{
		const SRegisterSpan &	span( *span_it );

		fprintf( fh, "%s: %3d -> %3d   [", RegNames[ span.Register ], span.SpanStart, span.SpanEnd );

		// Display the span as a line
		u32 count( 0 );
		while( count < span.SpanStart )
		{
			fprintf( fh, " " );
			count++;
		}
		while( count <= span.SpanEnd )		// <= (span end is inclusive)
		{
			fprintf( fh, "-" );
			count++;
		}
		while( count < mTraceBuffer.size() )
		{
			fprintf( fh, " " );
			count++;
		}

		fprintf( fh, "]\n" );
	}
	fprintf( fh, "\n" );
	fputs( "

\n", fh ); // // Input trace // { fputs( "

Input Disassembly

\n", fh ); fputs( "

\n", fh ); u32 last_address( mTraceBuffer.size() > 0 ? mTraceBuffer[ 0 ].Address-4 : 0 ); for( u32 i = 0; i < mTraceBuffer.size(); ++i ) { const STraceEntry & entry( mTraceBuffer[ i ] ); u32 address( entry.Address ); OpCode op_code( entry.OpCode ); u32 branch_index( entry.BranchIdx ); char buf[100]; SprintOpCodeInfo( buf, address, op_code ); bool is_jump( address != last_address + 4 ); fprintf( fh, "\n"); last_address = address; } fputs( "

Address	Instruction	Exit Target
%08x	%c%s	", address, is_jump ? '*' : ' ', Sanitise( buf ) ); if( branch_index != INVALID_IDX ) { DAEDALUS_ASSERT( branch_index < mBranchBuffer.size(), "The branch index is out of range" ); const SBranchDetails & details( mBranchBuffer[ branch_index ] ); fprintf( fh, "%08x", details.TargetAddress, details.TargetAddress ); } fprintf( fh, "

Address

Instruction

Exit Target

%08x

%c%s

", address, is_jump ? '*' : ' ', Sanitise( buf ) );

			if( branch_index != INVALID_IDX )
			{
				DAEDALUS_ASSERT( branch_index < mBranchBuffer.size(), "The branch index is out of range" );

				const SBranchDetails &	details( mBranchBuffer[ branch_index ] );

				fprintf( fh, "%08x", details.TargetAddress, details.TargetAddress );
			}
			fprintf( fh, "

\n", fh ); } if( mEntryPoint.IsSet() ) { fputs( "

Disassembly

\n", fh ); fputs( "

\n", fh ); const u8 * output_begin( mEntryPoint.GetTargetU8P() ); const u8 * buffer_end( output_begin + mFragmentFunctionLength ); // // Prologue // if( mInstructionStartLocations.size() > 0 ) { const u8 * output_end( mInstructionStartLocations[ 0 ] ); fputs( "\n", fh ); output_begin = output_end; } // // Trace // for( u32 i = 0; i < mTraceBuffer.size(); ++i ) { const STraceEntry & entry( mTraceBuffer[ i ] ); const u8 * output_end( i+1 < mInstructionStartLocations.size() ? mInstructionStartLocations[ i+1 ] : buffer_end ); u32 address( entry.Address ); OpCode op_code( entry.OpCode ); char buf[100]; SprintOpCodeInfo( buf, address, op_code ); fprintf( fh, "\n", fh ); output_begin = output_end; } // // Epilogue // const u8 * output_end( buffer_end ); fputs( "\n", fh ); output_begin = output_end; fputs( "

Input	Output
(Prologue)	", fh ); DisassembleBuffer( output_begin, output_end-output_begin, fh ); fputs( "
%08x	%s	", address, Sanitise( buf ) ); DisassembleBuffer( output_begin, output_end-output_begin, fh ); fputs( "
(Epilogue)	", fh ); DisassembleBuffer( output_begin, output_end-output_begin, fh ); fputs( "

Input

Output

(Prologue)

", fh );
			DisassembleBuffer( output_begin, output_end-output_begin, fh );
			fputs( "

%08x

%s

", address, Sanitise( buf ) );
			DisassembleBuffer( output_begin, output_end-output_begin, fh );
			fputs( "

(Epilogue)

", fh );
		DisassembleBuffer( output_begin, output_end-output_begin, fh );
		fputs( "

\n", fh ); } fputs( "\n", fh ); } #endif // DAEDALUS_DEBUG_DYNAREC