SDL_systhread.c:47 crash? NULL dereference?

[superfury]

For some reason my program crashes here. Anyone knows what can cause this (I've already protected against NULL everywhere)? The debugger says that it tries to jump to address 0x00000000 (NULL dereference). Anyone knows how to fix this?

[Disch]

Sounds like you are creating a thread and are giving it a null function pointer.

After it crashes and it takes you to the debugger, go up in the call stack to see where (in your code) the crash is happening.

[superfury]

The strange thing is: I don't use the SDL thread functions (only the init and flip with some rendering (sdl_gfx) functions). The only thread creating I use is the functionality of the developement kit and a function I made myself (which is protected against NULL threads, returning once they're trying to be fired). Does the SDL create it's own threads (I do use SDL_Init(SDL_INIT_VIDEO) at the start of the software):

	if (SDL_Init(SDL_INIT_VIDEO)==-1) //Error?
	{
		raiseError("SDL Init error: %s",SDL_GetError()); //Raise an error!
		while (1) //Loop infinite!
		{
			delay(1);
		}
	}
	
	pspsurface = SDL_SetVideoMode(PSP_SCREEN_COLUMNS, PSP_SCREEN_ROWS, 32, SDL_DOUBLEBUF|SDL_HWSURFACE); //Start fullscreen, double buffering 32BPP pixel mode! 

Other calls are to the SDL_gfx functions for rendering and SDL_Flip when a frame is rendered.

[superfury]

My SDL functionality functions:

void matchColorKeys(const SDL_Surface* src, SDL_Surface* dest ){
	if (!(src && dest)) return; //Abort: invalid src/dest!
	if( src->flags & SDL_SRCCOLORKEY )
	{
		Uint32 colorkey = src->format->colorkey;
		SDL_SetColorKey( dest, SDL_SRCCOLORKEY, colorkey );
	}
}

SDL_Surface *resizeImage( SDL_Surface *img, const double newwidth, const double newheight, int keepaspectratio){
	if (!img) //No image to resize?
	{
		return NULL; //Nothin to resize is nothing back!
	}
	double do_newwidth = newwidth;
	double do_newheight = newheight; //New width/height!
	if (keepaspectratio) //Keeping the aspect ratio?
	{
		double aspectoriginal = SAFEDIV((float)img->w,(float)img->h); //Original aspect ratio!
		double aspectnew = SAFEDIV((float)newwidth,(float)newheight); //New aspect ratio!
		if (aspectoriginal!=aspectnew) //Different aspect ratio?
		{
			if (aspectoriginal>aspectnew) //Need to change height?
			{
				do_newheight = SAFEDIV(do_newwidth,img->w)*img->h; //New height!
			}
			else //Need to change width?
			{
				do_newwidth = SAFEDIV(do_newheight,img->h)*img->w; //New width?
			}
		}
	}
	
	if (!(do_newwidth && do_newheight) || !(img->w && img->h)) //No size in src or dest?
	{
		return NULL; //Nothing to render, so give nothing!
	}

	double zoomx = SAFEDIV(do_newwidth,(float)img->w); //Resize to new width!
	double zoomy = SAFEDIV(do_newheight,(float)img->h); //Resize to new height!
	
	SDL_Surface* sized = zoomSurface( img, zoomx, zoomy, SMOOTHING_ON );
	matchColorKeys( img, sized );
	return sized;
}

Uint32 get_pixel(const SDL_Surface* surface, const int x, const int y ){
	if (!surface) return 0; //Disable if no surface!
	Uint32 *pixels = (Uint32*)surface->pixels;
	return pixels[ ( y * surface->w ) + x ];
}


void put_pixel(SDL_Surface *surface, const int x, const int y, const Uint32 pixel ){
	if (!surface) return; //Disable if no surface!
	Uint32 *pixels = (Uint32 *)surface->pixels;
	pixels[ ( y * surface->w ) + x ] = pixel;
}

uint_32 get_pixelrow_pitch(SDL_Surface *surface) //Get the difference between two rows!
{
	if (!surface) return 0; //No surface = no pitch!
	if (surface->pitch) //Got pitch?
	{
		return (surface->pitch/4); //Pitch in pixels!
	}
	return surface->w; //Just use the width as a pitch to fall back to!
}

void *get_pixel_ptr(SDL_Surface *surface, const int y, const int x)
{
	if (!surface) return NULL; //Unknown!
	if ((y<surface->h) && (x<surface->w)) //Within range?
	{
		Uint32 *pixels = (Uint32 *)surface->pixels;
		//No pitch? Use width to fall back!
		return &pixels[ ( y * get_pixelrow_pitch(surface) ) + x ]; //The pixel ptr!		
	}
	return NULL; //Out of range!
}

//Row functions, by me!
uint_32 *get_pixel_row(SDL_Surface *surface, const int y, const int x)
{
	return (uint_32 *)get_pixel_ptr(surface,y,x); //Give the pointer!
}

void put_pixel_row(SDL_Surface *surface, const int y, uint_32 rowsize, uint_32 *pixels, int center) //Based upon above, but for whole rows at once!
{
	if (surface && pixels) //Got surface and pixels!
	{
		uint_32 use_rowsize = MIN(surface->w,rowsize); //Minimum is decisive!
		if (use_rowsize) //Got something to copy and valid row?
		{
			uint_32 *row = get_pixel_row(surface,y,0); //Row at the left!
			if (row) //Gotten the row (valid row?)
			{
				uint_32 restpixels = (surface->w)-use_rowsize; //Rest ammount of pixels!
				uint_32 start = (surface->w/2) - (use_rowsize/2); //Start of the drawn part!
				switch (center) //What centering method?
				{
				case 1: //Use horizontal centering?
					//Originally: no centering!
					if (surface->w>(use_rowsize+2)) //We have space left&right to plot? Also must have at least 2 pixels left&right to center!
					{
						memset(row,0,start*4); //Clear the left!
						memset(&row[start+use_rowsize],0,(surface->w-(start+use_rowsize))*4); //Clear the right!
						memcpy(&row[start],pixels,use_rowsize*4); //Copy the pixels to the center!
						return; //Done: we've written the pixels at the center!
					}
					//We don't need centering: just do left side plot!
				default: //We default to left side plot!
				case 0: //Left side plot?
					memcpy(row,pixels,use_rowsize*4); //Copy the row to the buffer as far as we can go!
					//Now just render the rest part of the line to black!
					if (restpixels) //Still a part of the row not rendered and valid rest location?
					{
						memset(&row[use_rowsize],0,restpixels*4); //Clear to the end of the row, so that only the part we specified gets something!
					}
					break;

				case 2: //Right side plot?
					//Just plain plot at the right, filling with black on the left when not centering!
					if (restpixels) //Still a part of the row not rendered and valid rest location?
					{
						memset(&row[0],0,restpixels*4); //Clear to the start of the row, so that only the part we specified gets something!
					}
					memcpy(&row[restpixels],pixels,use_rowsize*4); //Copy the row to the buffer as far as we can go!
					break;
				}
			}
		}
	}
	else if (surface) //Surface, but no pixels: clear the row?
	{
		uint_32 *row = get_pixel_row(surface,y,0); //Row at the left!
		if (row && surface->w) //Got row?
		{
			memset(row,0,surface->w*4); //Clear the row, because we have no pixels!
		}
	}
}

SDL_Surface *freeSurface(SDL_Surface *surface)
{
	if (surface) //Allocated?
	{
		SDL_FreeSurface(surface); //Release!
		return NULL;
	}
	return surface; //Still allocated!
}

void safeFlip(SDL_Surface *surface) //Safe flipping (non-null)
{
	if (surface) //Surface valid and allowed to show pixels?
	{
		//If the surface must be locked
		if( SDL_MUSTLOCK( surface ) )
		{
			//Lock the surface
			SDL_LockSurface( surface );
		}
		
		SDL_Flip(surface); //Flip!
		
		//Unlock surface
		if( SDL_MUSTLOCK( surface ) )
		{
			SDL_UnlockSurface( surface );
		}
	}
}

[superfury]

Btw SAFEDIV/SAFEMOD are just protection macros returning 0 when divided by 0.

[superfury]

Also: main rendering function (called once an entire VGA frame has been rendered (or 0 lines when the registers are set to do so)):

void renderScreenFrame() //Render the screen frame!
{
	if (SDL_WasInit(SDL_INIT_VIDEO)) //Rendering using SDL?
	{
		safeFlip(pspsurface); //Set the new resized screen to use, if possible!
		return; //Done!
	}
	//Already on-screen rendered: We're using direct mode!
}

int GPU_directRenderer() //Plot directly 1:1 on-screen!
{
	int pspy=0;
	if (SDL_WasInit(SDL_INIT_VIDEO)) //Rendering using SDL?
	{
		memset(pspsurface->pixels,0,4*(get_pixelrow_pitch(pspsurface)*pspsurface->h)); //Clear surface: we want all but our screen to be empty!
		for (pspy=0;pspy<MIN(PSP_SCREEN_ROWS,GPU.GPU_screenysize);)
		{
			put_pixel_row(pspsurface,pspy,GPU.GPU_screenxsize,&EMU_BUFFER(0,pspy),GPU.use_Letterbox); //Plot row to buffer!
			++pspy; //Next Y!
		}
		
		keyboard_renderer(); //Render the keyboard on-screen!
		renderScreenFrame(); //Set the new resized screen to use, if possible!
		return 0; //Don't render anymore!
	}
	
	//Old method, also fine&reasonably fast!
	for (;pspy<PSP_SCREEN_ROWS;) //Process row!
	{
		int pspx = 0;
		for (;pspx<PSP_SCREEN_COLUMNS;) //Process column!
		{
			if ((pspx>GPU.GPU_screenxsize) || (pspy>GPU.GPU_screenysize)) //Out of range?
			{
				PSP_BUFFER(pspx,pspy) = 0; //Clear color for out of range!
			}
			else //Exists in buffer?
			{
				PSP_BUFFER(pspx,pspy) = GPU_GETPIXEL(pspx,pspy); //Get pixel from buffer!
			}
			++pspx; //Next X!
		}
		//delay(1); //Hand a bit of time!
		++pspy; //Next Y!
	}
	keyboard_renderer(); //Render the keyboard on-screen!
	return 1; //OK: rendered to PSP buffer!
}

int GPU_fullRenderer()
{
	word y; //X&Y in the emulated screen!
	if (SDL_WasInit(SDL_INIT_VIDEO)) //Rendering using SDL?
	{
		return 0; //Disable our renderer!
		uint_32 rmask,gmask,bmask,amask; //Masks!
		#if SDL_BYTEORDER == SDL_BIG_ENDIAN
			rmask = 0xff000000;
			gmask = 0x00ff0000;
			bmask = 0x0000ff00;
			amask = 0x000000ff;
		#else
			rmask = 0x000000ff;
			gmask = 0x0000ff00;
			bmask = 0x00ff0000;
			amask = 0xff000000;
		#endif
		
		SDL_Surface *emu_screen = NULL; //The screen we're working with in rendering the emulator!
		
		//Next, allocate all buffers!
		if (((GPU.GPU_screenxsize*GPU.GPU_screenysize)>0) && pspsurface) //x&y present (both non-0)?
		{
			emu_screen = SDL_CreateRGBSurface(SDL_SWSURFACE,GPU.GPU_screenxsize, GPU.GPU_screenysize, 32, rmask,gmask,bmask,amask); //Start resoltution 32BPP pixel mode!
		}

		uint_32 row_empty[PSP_SCREEN_COLUMNS]; //A full row!
		memset(&row_empty,0,sizeof(row_empty)); //Clear the row to empty for vertical clearing usage!
		
		//Check if we can render?
		if (emu_screen && ((GPU.GPU_screenxsize*GPU.GPU_screenysize)>0)) //Got emu screen to render to the PSP and not testing?
		{
			//SDL rendering only!
			//Move entire emulator buffer to the rendering buffer!
			for (y=0;y<GPU.GPU_screenysize;)
			{
				put_pixel_row(emu_screen,y,GPU.GPU_screenxsize,&EMU_BUFFER(0,y),0); //Plot row to buffer to the left border!
				++y; //Next Y!
			}
			
			SDL_Surface *resized = resizeImage(emu_screen,PSP_SCREEN_COLUMNS,PSP_SCREEN_ROWS,GPU.use_Letterbox); //Render it to the PSP screen, keeping aspect ratio with letterboxing!
			if (resized) //Resized (anti-NULL protection)?
			{
				uint_32 start = 0; //Start row of the drawn part!
				y = 0; //Init Y to the beginning!
				if (GPU.use_Letterbox) //Using letterbox for aspect ratio?
				{
					start = (pspsurface->h/2) - (resized->h/2); //Calculate start row of contents!
					for (y=0;y<start;) //Process top!
					{
						put_pixel_row(pspsurface,y,PSP_SCREEN_COLUMNS,&row_empty[0],0); //Plot empty row, don't care about more black!
						++y; //Next row!
					}
				}
				
				uint_32 virtual = 0; //Virtual row to use! (From the source)
				for (;virtual<resized->h;) //Process row-by-row!
				{
					put_pixel_row(pspsurface,y,PSP_SCREEN_COLUMNS,get_pixel_row(resized,virtual,0),GPU.use_Letterbox); //Copy the row to the screen buffer, centered horizontally if needed, from virtual if needed!
					++y; //Next Y!
					++virtual; //Next virtual row!
				}
				
				if (GPU.use_Letterbox) //Using letterbox for aspect ratio?
				{
					for (;y<PSP_SCREEN_ROWS;) //Process bottom!
					{
						put_pixel_row(pspsurface,y,PSP_SCREEN_COLUMNS,&row_empty[0],0); //Plot empty row for the bottom, don't care about more black!
						++y; //Next row!
					}
				}
			}
			else //Nothing to render = clear screen!
			{
				for (y=0;y<pspsurface->h;y++)
				{
					put_pixel_row(pspsurface,y,PSP_SCREEN_COLUMNS,&row_empty[0],0); //Clear the screen!
				}
			}
			//emu_screen is deallocated now!
			resized = freeSurface(resized); //Done with the resizing!
			emu_screen = freeSurface(emu_screen); //Done with the emulator screen!
		}

		emu_screen = freeSurface(emu_screen); //Release the emulated screen we've allocated!
		
		keyboard_renderer(); //Render the keyboard on-screen!
		renderScreenFrame(); //Render the current frame!
		return 0; //OK: rendered, so don't render anymore!
	}
	return GPU_directRenderer(); //Render direct instead, since we don't support this!
}

/*

THE RENDERER!

*/



byte candraw = 0; //Can we draw (determined by max framerate)?
byte GPU_is_rendering = 0; //We're rendering currently: for preventing multirendering?

void renderGPU() //Render a frame!
{
	++frames; //We've processed a frame!
	if (!GPU.video_on) return; //Disable when Video is turned off!
	if (!ALLOW_RENDERING) return; //Disable when not allowed to render!
	if (!candraw) return; //Disable when not allowed to draw yet (determined by max framerate)!
	candraw = 0; //We're drawing, so don't draw until available again!

	if (GPU_is_rendering) return; //Don't render multiple frames at the same time!
	GPU_is_rendering = 1; //We're rendering!

	getmspassed(&ms_render_lastcheck); //Init last check to current time!
	
	int render_ready = 1; //Ready to be rendered?
	
	int do_render = 1; //Do render?

	if (GPU.frameskip) //Got frameskip?
	{
		do_render = !GPU.framenr; //To render the current frame each <frameskip> frames!
		GPU.framenr = (GPU.framenr+1)%(GPU.frameskip+1); //Next frame!
	}
	
	if (do_render) //To render this frame?
	{
		//Start the rendering!
		if (!VIDEO_DIRECT) //To do scaled mapping to the screen?
		{
			render_ready = GPU_fullRenderer(); //Use the full renderer!
		}
		else //Video direct?
		{
			render_ready = GPU_directRenderer(); //Video direct!
		}
		if (GPU.vram && GPU.psp_screenbuffer && render_ready) //We're allowed to render?
		{
			memcpy(GPU.vram,GPU.psp_screenbuffer,PSP_SCREENBUFFERSIZE*4); //Plot to the screen!
		}
	}
	else //No rendering (we have a frame skipped)?
	{
		renderScreenFrame(); //Render the same frame if possible!
	}
	GPU_is_rendering = 0; //We're done rendering!
	ms_render = getmspassed(&ms_render_lastcheck); //Update last check to current time processed!
	finish_screen(); //Finish stuff on-screen!
}

/*

FPS LIMITER!

*/

void refreshscreen() //Handler for a screen frame (60 fps) MAXIMUM.
{
//First, calculate the relative destination on the PSP screen!.
candraw = 1; //We can draw one frame now!
}

[Disch]

You'll need to find out where it's crashing.

When debuggers are snapped there are 2 things you can look for:

- Thread
- Call Stack

Look around in the IDE for these debugging options. Any IDE worth using has these in the debugger.

The thread window will list all threads that your program is running (so you can see if its crashing in your main thread, or if SDL is spawning another thread and that's where it's crashing).

Assuming it's crashing in the main thread, you can then look at the call stack (and go up it) to see all the functions that have been called (all the way back to main()) and that'll tell you where in your code the crash is actually happening.


Until you know where this is crashing, you're just grasping at straws. Figure out exactly which line the crash is occurring on. Then you should be able to see why it's crashing.


EDIT:

Which debugger/IDE are you using? If it's VS I might be able to guide you through it.

[superfury]

I'm just using the PSPSDK (minpspw) development kit for Windows with the JPCSP emulator (Java) to test it. It says the thread where it crashes is at SDL_systhread.c:47 when I take the error address into the devkit's psp-addr2line program (inside the cmd.exe)

[Disch]

yikes I didn't see all these replies. You must have done them while I was typing my response. Gimmie a sec to look this over.

EDIT:

Ah okay. So you're compiling for and running on a PSP emu for testing. That'll probably make debugging difficult.

Unfortunately I don't think I'll be able to help with this problem. =( Sorry. Hopefully someone else can step in and help out.

[superfury]

Debug register dump:

552682 [GUI] ERROR hle - Thread ID - 0x00000016
Th Name   - SDL thread
zr:0x00000000 at:0xDEADBEEF v0:0x00000000 v1:0x00000000
a0:0x0897E804 a1:0x00000001 a2:0x00000000 a3:0xDEADBEEF
t0:0xDEADBEEF t1:0xDEADBEEF t2:0xDEADBEEF t3:0xDEADBEEF
t4:0xDEADBEEF t5:0xDEADBEEF t6:0xDEADBEEF t7:0xDEADBEEF
s0:0x08990000 s1:0x08993CD0 s2:0x08990000 s3:0x00000000
s4:0x08959388 s5:0xDEADBEEF s6:0xDEADBEEF s7:0xDEADBEEF
t8:0xDEADBEEF t9:0xDEADBEEF k0:0x09FFED00 k1:0x00000000
gp:0x089956B0 sp:0x09FFEC80 fp:0xDEADBEEF ra:0x00000000
0x08945F08: 0x8CA40000 - lw         $a0, 0($a1)
552683 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552683 [GUI] ERROR hle - Thread Name: 'keyboard_psp_type' ID: 0x0022 Module ID: 0x0001
552684 [GUI] ERROR hle - Thread Status: 0x00000010 PSP_THREAD_STOPPED
552684 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552684 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6A00 - 0x09FF6C00 Stack Size: 0x00000200
552685 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x00000000
552685 [GUI] ERROR hle - Thread Wait Type: None Us: 0 Forever: false
552686 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552686 [GUI] ERROR hle - Thread Name: 'threaddebugger' ID: 0x0011 Module ID: 0x0001
552687 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552687 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x11 Initial Priority: 0x11
552688 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FFEE00 - 0x09FFF000 Stack Size: 0x00000200
552688 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552688 [GUI] ERROR hle - Thread Wait Type: Delay (delay 100000 us, rest 0 us) Us: 100000 Forever: false
552689 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552689 [GUI] ERROR hle - Thread Name: 'timer_thread' ID: 0x00EE Module ID: 0x0001
552689 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552690 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552690 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6200 - 0x09FF6400 Stack Size: 0x00000200
552690 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552691 [GUI] ERROR hle - Thread Wait Type: Delay (delay 200 us, rest 0 us) Us: 200 Forever: false
552691 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552691 [GUI] ERROR hle - Thread Name: 'idle0' ID: 0x0004 Module ID: 0x0000
552692 [GUI] ERROR hle - Thread Status: 0x00000002 PSP_THREAD_READY
552693 [GUI] ERROR hle - Thread Attr: 0x00001000 Current Priority: 0x7F Initial Priority: 0x7F
552693 [GUI] ERROR hle - Thread Entry: 0x88000000 Stack: 0x08800000 - 0x08802000 Stack Size: 0x00002000
552693 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552694 [GUI] ERROR hle - Thread Wait Type: None Us: 200 Forever: false
552694 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552694 [GUI] ERROR hle - Thread Name: 'keyboard_psp_swap' ID: 0x0024 Module ID: 0x0001
552694 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552695 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552695 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6800 - 0x09FF6A00 Stack Size: 0x00000200
552695 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552696 [GUI] ERROR hle - Thread Wait Type: Blocked (delay 100000 us, rest 0 us) Us: 100000 Forever: false
552696 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552696 [GUI] ERROR hle - Thread Name: 'idle1' ID: 0x0006 Module ID: 0x0000
552697 [GUI] ERROR hle - Thread Status: 0x00000002 PSP_THREAD_READY
552697 [GUI] ERROR hle - Thread Attr: 0x00001000 Current Priority: 0x7F Initial Priority: 0x7F
552698 [GUI] ERROR hle - Thread Entry: 0x88000000 Stack: 0x08802000 - 0x08804000 Stack Size: 0x00002000
552698 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552699 [GUI] ERROR hle - Thread Wait Type: None Us: 0 Forever: false
552699 [GUI] ERROR hle - 

[superfury]

Continuation of the dump:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552699 [GUI] ERROR hle - Thread Name: 'SDL thread' ID: 0x0016 Module ID: 0x0001
552699 [GUI] ERROR hle - Thread Status: 0x00000001 PSP_THREAD_RUNNING
552700 [GUI] ERROR hle - Thread Attr: 0x80004000 Current Priority: 0x20 Initial Priority: 0x20
552700 [GUI] ERROR hle - Thread Entry: 0x08945F08 Stack: 0x09FF6E00 - 0x09FFEE00 Stack Size: 0x00008000
552701 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552701 [GUI] ERROR hle - Thread Wait Type: None Us: 16666 Forever: false
552701 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552702 [GUI] ERROR hle - Thread Name: 'framerate_updater' ID: 0x002A Module ID: 0x0001
552702 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552702 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552703 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6400 - 0x09FF6600 Stack Size: 0x00000200
552703 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552703 [GUI] ERROR hle - Thread Wait Type: Delay (delay 1000000 us, rest 0 us) Us: 1000000 Forever: false
552704 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552704 [GUI] ERROR hle - Thread Name: 'framerate_thread' ID: 0x0028 Module ID: 0x0001
552704 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552705 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552705 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6600 - 0x09FF6800 Stack Size: 0x00000200
552705 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552706 [GUI] ERROR hle - Thread Wait Type: Delay (delay 1000000 us, rest 0 us) Us: 1000000 Forever: false
552706 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552706 [GUI] ERROR hle - Thread Name: 'user_main' ID: 0x000B Module ID: 0x0001
552707 [GUI] ERROR hle - Thread Status: 0x00000002 PSP_THREAD_READY
552707 [GUI] ERROR hle - Thread Attr: 0x80000000 Current Priority: 0x20 Initial Priority: 0x20
552707 [GUI] ERROR hle - Thread Entry: 0x08900180 Stack: 0x09F80000 - 0x09FC0000 Stack Size: 0x00040000
552708 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552708 [GUI] ERROR hle - Thread Wait Type: None Us: 200 Forever: false
552708 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552709 [GUI] ERROR hle - Thread Name: 'Emulator' ID: 0x001C Module ID: 0x0001
552709 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552709 [GUI] ERROR hle - Thread Attr: 0x80300000 Current Priority: 0x18 Initial Priority: 0x18
552710 [GUI] ERROR hle - Thread Entry: 0x0893338C Stack: 0x09FF6C00 - 0x09FF6E00 Stack Size: 0x00000200
552710 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552710 [GUI] ERROR hle - Thread Wait Type: Sleep (forever) Us: 0 Forever: true
552711 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552711 [GUI] ERROR hle - Thread Name: 'update_thread' ID: 0x000D Module ID: 0x0001
552711 [GUI] ERROR hle - Thread Status: 0x00000004 PSP_THREAD_WAITING
552712 [GUI] ERROR hle - Thread Attr: 0x80000000 Current Priority: 0x11 Initial Priority: 0x11
552713 [GUI] ERROR hle - Thread Entry: 0x08937A90 Stack: 0x09FFF000 - 0x0A000000 Stack Size: 0x00001000
552713 [GUI] ERROR hle - Thread Run Clocks: 0 Exit Code: 0x800201A4
552713 [GUI] ERROR hle - Thread Wait Type: Sleep (forever) Us: 0 Forever: true
552714 [GUI] ERROR hle - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
552714 [GUI] ERROR hle - Allocated memory:  016CD960 23910752 bytes
552714 [GUI] ERROR hle - [X XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX]
552715 [GUI] ERROR hle - Fragmented memory: 00132600 1254912 bytes
552715 [GUI] ERROR hle - [XXX                                                           XX]
552715 [GUI] ERROR hle - Free list: [addr=0x08804000-0x08900000, size=0xFC000], [addr=0x09F7FC00-0x09F80000, size=0x400], [addr=0x09FC0000-0x09FF6200, size=0x36200]
552717 [GUI] ERROR hle - Allocated blocks:
SysMemInfo[addr=0x08800000-0x08804000, uid=3, partition=1, name='ThreadMan-RootMem', type=PSP_SMEM_Addr, size=0x4000 (allocated=0x4000)]
SysMemInfo[addr=0x08900000-0x08C51800, uid=2, partition=2, name='x86EMU', type=PSP_SMEM_Addr, size=0x351760 (allocated=0x351800)]
SysMemInfo[addr=0x08C51800-0x09F7FC00, uid=10, partition=2, name='block', type=PSP_SMEM_Low, size=0x132E400 (allocated=0x132E400)]
SysMemInfo[addr=0x09F80000-0x09FC0000, uid=c, partition=2, name='ThreadMan-Stack-0xb-user_main', type=PSP_SMEM_High, size=0x40000 (allocated=0x40000)]
SysMemInfo[addr=0x09FF6200-0x09FF6400, uid=ef, partition=2, name='ThreadMan-Stack-0xee-timer_thread', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6400-0x09FF6600, uid=2b, partition=2, name='ThreadMan-Stack-0x2a-framerate_updater', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6600-0x09FF6800, uid=29, partition=2, name='ThreadMan-Stack-0x28-framerate_thread', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6800-0x09FF6A00, uid=25, partition=2, name='ThreadMan-Stack-0x24-keyboard_psp_swap', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6A00-0x09FF6C00, uid=23, partition=2, name='ThreadMan-Stack-0x22-keyboard_psp_type', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6C00-0x09FF6E00, uid=1d, partition=2, name='ThreadMan-Stack-0x1c-Emulator', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FF6E00-0x09FFEE00, uid=17, partition=2, name='ThreadMan-Stack-0x16-SDL thread', type=PSP_SMEM_High, size=0x8000 (allocated=0x8000)]
SysMemInfo[addr=0x09FFEE00-0x09FFF000, uid=12, partition=2, name='ThreadMan-Stack-0x11-threaddebugger', type=PSP_SMEM_High, size=0x200 (allocated=0x200)]
SysMemInfo[addr=0x09FFF000-0x0A000000, uid=e, partition=2, name='ThreadMan-Stack-0xd-update_thread', type=PSP_SMEM_High, size=0x1000 (allocated=0x1000)]

552717 [GUI] ERROR hle -

[superfury]

It does say something in the registers: 0xDEADBEEF. According to Urban Dictionary (wiki too):

The hexadecimal word-fill pattern for freshly allocated memory under a number of IBM environments, including the RS/6000. Some modern debugging tools deliberately fill freed memory with this value.

2. Geek-speak for dead/gone/erased/eliminated/removed
“Your program is 0xDEADBEEF”
(meaning gone, aborted, flushed from memory)

Anyone can help me with this?