Re: optimization/8049: SSE unaligned vector stores crash with -O0

[Jan Hubicka <jh at suse dot cz>]

> On Thu, 10 Oct 2002, Jan Hubicka wrote:
> 
> > > The original example is one.  The three buffers passed into MatrixMultiply
> > > happen to be aligned on my system. The actual crash happens when the stack
> > > copy of C1 is loaded, before the _mm_store_ps (uninlined) function is
> > > called.
> >
> > This looks strange.  All stores to C1 works properly and then you get
> > movaps crash when you load it to store into output?
> > I believe it is the output that is missaligned (destination of store)
> > because the destination array is missaligned from the caller.
> 
> Hmm, perhaps I got confused between the Intel and ATT argument ordering
> scheme. Perhaps this is actually a store to the stack from the earlier
> mm_add_ps and gdb misreported the line from the source? What do you think?
> 
> (gdb) run
> Program received signal SIGSEGV, Segmentation Fault
>  0x0804888b in MatrixMultiply()  (A = 0xbffff9d0, B=0xbffff990, C=0xbffff950)
>      at main.c:74
> 
>  74 	_mm_store_ps( C + 0, C1 ); //....
> 
> 
>  0x8048884 <MatrixMultiply+1132>:	movaps 0xffffff68 (%ebp),%xmm0
>  0x804888b <MatrixMultiply+1139>:	movaps %xmm0, 0x4 (%esp, 1)
>  0x8048890 <MatrixMultiply+1144>:	call   0x8048930 <_mm_store_ps>

This really is load, however it is stored previously as:
> 0x80484c9 <MatrixMultiply+177>:	movaps %xmm0,0xffffff68(%ebp)

And it didn't generated trap, so ebp is aligned that time I suppose,
so it is really strange to see that it is not in this case.
Perhaps it is _mm_store_ps that messed up the stack and restored ebp
incorrectly?

Honza
> 
> (gdb) info registers
> 
>  esp 	0xbffff800
>  ebp	0xbffff928
> 
> 
> 
> Dump of assembler code for function MatrixMultiply:
> 0x8048418 <MatrixMultiply>:	push   %ebp
> 0x8048419 <MatrixMultiply+1>:	mov    %esp,%ebp
> 0x804841b <MatrixMultiply+3>:	sub    $0x128,%esp
> 0x8048421 <MatrixMultiply+9>:	mov    0x8(%ebp),%eax
> 0x8048424 <MatrixMultiply+12>:	mov    %eax,(%esp,1)
> 0x8048427 <MatrixMultiply+15>:	call   0x8048925 <_mm_load_ps>
> 0x804842c <MatrixMultiply+20>:	movaps %xmm0,0xffffffe8(%ebp)
> 0x8048430 <MatrixMultiply+24>:	mov    0x8(%ebp),%eax
> 0x8048433 <MatrixMultiply+27>:	add    $0x10,%eax
> 0x8048436 <MatrixMultiply+30>:	mov    %eax,(%esp,1)
> 0x8048439 <MatrixMultiply+33>:	call   0x8048925 <_mm_load_ps>
> 0x804843e <MatrixMultiply+38>:	movaps %xmm0,0xffffffd8(%ebp)
> 0x8048442 <MatrixMultiply+42>:	mov    0x8(%ebp),%eax
> 0x8048445 <MatrixMultiply+45>:	add    $0x20,%eax
> 0x8048448 <MatrixMultiply+48>:	mov    %eax,(%esp,1)
> 0x804844b <MatrixMultiply+51>:	call   0x8048925 <_mm_load_ps>
> 0x8048450 <MatrixMultiply+56>:	movaps %xmm0,0xffffffc8(%ebp)
> 0x8048454 <MatrixMultiply+60>:	mov    0x8(%ebp),%eax
> 0x8048457 <MatrixMultiply+63>:	add    $0x30,%eax
> 0x804845a <MatrixMultiply+66>:	mov    %eax,(%esp,1)
> 0x804845d <MatrixMultiply+69>:	call   0x8048925 <_mm_load_ps>
> 0x8048462 <MatrixMultiply+74>:	movaps %xmm0,0xffffffb8(%ebp)
> 0x8048466 <MatrixMultiply+78>:	mov    0xc(%ebp),%eax
> 0x8048469 <MatrixMultiply+81>:	mov    %eax,(%esp,1)
> 0x804846c <MatrixMultiply+84>:	call   0x8048925 <_mm_load_ps>
> 0x8048471 <MatrixMultiply+89>:	movaps %xmm0,0xffffffa8(%ebp)
> 0x8048475 <MatrixMultiply+93>:	mov    0xc(%ebp),%eax
> 0x8048478 <MatrixMultiply+96>:	add    $0x10,%eax
> 0x804847b <MatrixMultiply+99>:	mov    %eax,(%esp,1)
> 0x804847e <MatrixMultiply+102>:	call   0x8048925 <_mm_load_ps>
> 0x8048483 <MatrixMultiply+107>:	movaps %xmm0,0xffffff98(%ebp)
> 0x8048487 <MatrixMultiply+111>:	mov    0xc(%ebp),%eax
> 0x804848a <MatrixMultiply+114>:	add    $0x20,%eax
> 0x804848d <MatrixMultiply+117>:	mov    %eax,(%esp,1)
> 0x8048490 <MatrixMultiply+120>:	call   0x8048925 <_mm_load_ps>
> 0x8048495 <MatrixMultiply+125>:	movaps %xmm0,0xffffff88(%ebp)
> 0x8048499 <MatrixMultiply+129>:	mov    0xc(%ebp),%eax
> 0x804849c <MatrixMultiply+132>:	add    $0x30,%eax
> 0x804849f <MatrixMultiply+135>:	mov    %eax,(%esp,1)
> 0x80484a2 <MatrixMultiply+138>:	call   0x8048925 <_mm_load_ps>
> 0x80484a7 <MatrixMultiply+143>:	movaps %xmm0,0xffffff78(%ebp)
> 0x80484ae <MatrixMultiply+150>:	movaps 0xffffffe8(%ebp),%xmm0
> 0x80484b2 <MatrixMultiply+154>:	shufps $0x0,0xffffffe8(%ebp),%xmm0
> 0x80484b7 <MatrixMultiply+159>:	movaps %xmm0,(%esp,1)
> 0x80484bb <MatrixMultiply+163>:	movaps 0xffffffa8(%ebp),%xmm0
> 0x80484bf <MatrixMultiply+167>:	movaps %xmm0,0x10(%esp,1)
> 0x80484c4 <MatrixMultiply+172>:	call   0x8048905 <_mm_mul_ps>
> 0x80484c9 <MatrixMultiply+177>:	movaps %xmm0,0xffffff68(%ebp)
> 0x80484d0 <MatrixMultiply+184>:	movaps 0xffffffd8(%ebp),%xmm0
> 0x80484d4 <MatrixMultiply+188>:	shufps $0x0,0xffffffd8(%ebp),%xmm0
> 0x80484d9 <MatrixMultiply+193>:	movaps %xmm0,(%esp,1)
> 0x80484dd <MatrixMultiply+197>:	movaps 0xffffff98(%ebp),%xmm0
> 0x80484e1 <MatrixMultiply+201>:	movaps %xmm0,0x10(%esp,1)
> 0x80484e6 <MatrixMultiply+206>:	call   0x8048905 <_mm_mul_ps>
> 0x80484eb <MatrixMultiply+211>:	movaps %xmm0,0xffffff58(%ebp)
> 0x80484f2 <MatrixMultiply+218>:	movaps 0xffffffc8(%ebp),%xmm0
> 0x80484f6 <MatrixMultiply+222>:	shufps $0x0,0xffffffc8(%ebp),%xmm0
> 0x80484fb <MatrixMultiply+227>:	movaps %xmm0,(%esp,1)
> 0x80484ff <MatrixMultiply+231>:	movaps 0xffffff88(%ebp),%xmm0
> 0x8048503 <MatrixMultiply+235>:	movaps %xmm0,0x10(%esp,1)
> 0x8048508 <MatrixMultiply+240>:	call   0x8048905 <_mm_mul_ps>
> 0x804850d <MatrixMultiply+245>:	movaps %xmm0,0xffffff48(%ebp)
> 0x8048514 <MatrixMultiply+252>:	movaps 0xffffffb8(%ebp),%xmm0
> 0x8048518 <MatrixMultiply+256>:	shufps $0x0,0xffffffb8(%ebp),%xmm0
> 0x804851d <MatrixMultiply+261>:	movaps %xmm0,(%esp,1)
> 0x8048521 <MatrixMultiply+265>:	movaps 0xffffff78(%ebp),%xmm0
> 0x8048528 <MatrixMultiply+272>:	movaps %xmm0,0x10(%esp,1)
> 0x804852d <MatrixMultiply+277>:	call   0x8048905 <_mm_mul_ps>
> 0x8048532 <MatrixMultiply+282>:	movaps %xmm0,0xffffff38(%ebp)
> 0x8048539 <MatrixMultiply+289>:	movaps 0xffffffe8(%ebp),%xmm0
> 0x804853d <MatrixMultiply+293>:	shufps $0x55,0xffffffe8(%ebp),%xmm0
> 0x8048542 <MatrixMultiply+298>:	movaps %xmm0,(%esp,1)
> 0x8048546 <MatrixMultiply+302>:	movaps 0xffffffa8(%ebp),%xmm0
> 0x804854a <MatrixMultiply+306>:	movaps %xmm0,0x10(%esp,1)
> 0x804854f <MatrixMultiply+311>:	call   0x8048905 <_mm_mul_ps>
> 0x8048554 <MatrixMultiply+316>:	movaps %xmm0,0xffffff28(%ebp)
> 0x804855b <MatrixMultiply+323>:	movaps 0xffffffd8(%ebp),%xmm0
> 0x804855f <MatrixMultiply+327>:	shufps $0x55,0xffffffd8(%ebp),%xmm0
> 0x8048564 <MatrixMultiply+332>:	movaps %xmm0,(%esp,1)
> 0x8048568 <MatrixMultiply+336>:	movaps 0xffffff98(%ebp),%xmm0
> 0x804856c <MatrixMultiply+340>:	movaps %xmm0,0x10(%esp,1)
> 0x8048571 <MatrixMultiply+345>:	call   0x8048905 <_mm_mul_ps>
> 0x8048576 <MatrixMultiply+350>:	movaps %xmm0,0xffffff18(%ebp)
> 0x804857d <MatrixMultiply+357>:	movaps 0xffffffc8(%ebp),%xmm0
> 0x8048581 <MatrixMultiply+361>:	shufps $0x55,0xffffffc8(%ebp),%xmm0
> 0x8048586 <MatrixMultiply+366>:	movaps %xmm0,(%esp,1)
> 0x804858a <MatrixMultiply+370>:	movaps 0xffffff88(%ebp),%xmm0
> 0x804858e <MatrixMultiply+374>:	movaps %xmm0,0x10(%esp,1)
> 0x8048593 <MatrixMultiply+379>:	call   0x8048905 <_mm_mul_ps>
> 0x8048598 <MatrixMultiply+384>:	movaps %xmm0,0xffffff08(%ebp)
> 0x804859f <MatrixMultiply+391>:	movaps 0xffffffb8(%ebp),%xmm0
> 0x80485a3 <MatrixMultiply+395>:	shufps $0x55,0xffffffb8(%ebp),%xmm0
> 0x80485a8 <MatrixMultiply+400>:	movaps %xmm0,(%esp,1)
> 0x80485ac <MatrixMultiply+404>:	movaps 0xffffff78(%ebp),%xmm0
> 0x80485b3 <MatrixMultiply+411>:	movaps %xmm0,0x10(%esp,1)
> 0x80485b8 <MatrixMultiply+416>:	call   0x8048905 <_mm_mul_ps>
> 0x80485bd <MatrixMultiply+421>:	movaps %xmm0,0xfffffef8(%ebp)
> 0x80485c4 <MatrixMultiply+428>:	movaps 0xffffff68(%ebp),%xmm0
> 0x80485cb <MatrixMultiply+435>:	movaps %xmm0,(%esp,1)
> 0x80485cf <MatrixMultiply+439>:	movaps 0xffffff28(%ebp),%xmm0
> 0x80485d6 <MatrixMultiply+446>:	movaps %xmm0,0x10(%esp,1)
> 0x80485db <MatrixMultiply+451>:	call   0x80488e5 <_mm_add_ps>
> 0x80485e0 <MatrixMultiply+456>:	movaps %xmm0,0xffffff68(%ebp)
> 0x80485e7 <MatrixMultiply+463>:	movaps 0xffffff58(%ebp),%xmm0
> 0x80485ee <MatrixMultiply+470>:	movaps %xmm0,(%esp,1)
> 0x80485f2 <MatrixMultiply+474>:	movaps 0xffffff18(%ebp),%xmm0
> 0x80485f9 <MatrixMultiply+481>:	movaps %xmm0,0x10(%esp,1)
> 0x80485fe <MatrixMultiply+486>:	call   0x80488e5 <_mm_add_ps>
> 0x8048603 <MatrixMultiply+491>:	movaps %xmm0,0xffffff58(%ebp)
> 0x804860a <MatrixMultiply+498>:	movaps 0xffffff48(%ebp),%xmm0
> 0x8048611 <MatrixMultiply+505>:	movaps %xmm0,(%esp,1)
> 0x8048615 <MatrixMultiply+509>:	movaps 0xffffff08(%ebp),%xmm0
> 0x804861c <MatrixMultiply+516>:	movaps %xmm0,0x10(%esp,1)
> 0x8048621 <MatrixMultiply+521>:	call   0x80488e5 <_mm_add_ps>
> 0x8048626 <MatrixMultiply+526>:	movaps %xmm0,0xffffff48(%ebp)
> 0x804862d <MatrixMultiply+533>:	movaps 0xffffff38(%ebp),%xmm0
> 0x8048634 <MatrixMultiply+540>:	movaps %xmm0,(%esp,1)
> 0x8048638 <MatrixMultiply+544>:	movaps 0xfffffef8(%ebp),%xmm0
> 0x804863f <MatrixMultiply+551>:	movaps %xmm0,0x10(%esp,1)
> 0x8048644 <MatrixMultiply+556>:	call   0x80488e5 <_mm_add_ps>
> 0x8048649 <MatrixMultiply+561>:	movaps %xmm0,0xffffff38(%ebp)
> 0x8048650 <MatrixMultiply+568>:	movaps 0xffffffe8(%ebp),%xmm0
> 0x8048654 <MatrixMultiply+572>:	shufps $0xaa,0xffffffe8(%ebp),%xmm0
> 0x8048659 <MatrixMultiply+577>:	movaps %xmm0,(%esp,1)
> 0x804865d <MatrixMultiply+581>:	movaps 0xffffffa8(%ebp),%xmm0
> 0x8048661 <MatrixMultiply+585>:	movaps %xmm0,0x10(%esp,1)
> 0x8048666 <MatrixMultiply+590>:	call   0x8048905 <_mm_mul_ps>
> 0x804866b <MatrixMultiply+595>:	movaps %xmm0,0xffffff28(%ebp)
> 0x8048672 <MatrixMultiply+602>:	movaps 0xffffffd8(%ebp),%xmm0
> 0x8048676 <MatrixMultiply+606>:	shufps $0xaa,0xffffffd8(%ebp),%xmm0
> 0x804867b <MatrixMultiply+611>:	movaps %xmm0,(%esp,1)
> 0x804867f <MatrixMultiply+615>:	movaps 0xffffff98(%ebp),%xmm0
> 0x8048683 <MatrixMultiply+619>:	movaps %xmm0,0x10(%esp,1)
> 0x8048688 <MatrixMultiply+624>:	call   0x8048905 <_mm_mul_ps>
> 0x804868d <MatrixMultiply+629>:	movaps %xmm0,0xffffff18(%ebp)
> 0x8048694 <MatrixMultiply+636>:	movaps 0xffffffc8(%ebp),%xmm0
> 0x8048698 <MatrixMultiply+640>:	shufps $0xaa,0xffffffc8(%ebp),%xmm0
> 0x804869d <MatrixMultiply+645>:	movaps %xmm0,(%esp,1)
> 0x80486a1 <MatrixMultiply+649>:	movaps 0xffffff88(%ebp),%xmm0
> 0x80486a5 <MatrixMultiply+653>:	movaps %xmm0,0x10(%esp,1)
> 0x80486aa <MatrixMultiply+658>:	call   0x8048905 <_mm_mul_ps>
> 0x80486af <MatrixMultiply+663>:	movaps %xmm0,0xffffff08(%ebp)
> 0x80486b6 <MatrixMultiply+670>:	movaps 0xffffffb8(%ebp),%xmm0
> 0x80486ba <MatrixMultiply+674>:	shufps $0xaa,0xffffffb8(%ebp),%xmm0
> 0x80486bf <MatrixMultiply+679>:	movaps %xmm0,(%esp,1)
> 0x80486c3 <MatrixMultiply+683>:	movaps 0xffffff78(%ebp),%xmm0
> 0x80486ca <MatrixMultiply+690>:	movaps %xmm0,0x10(%esp,1)
> 0x80486cf <MatrixMultiply+695>:	call   0x8048905 <_mm_mul_ps>
> 0x80486d4 <MatrixMultiply+700>:	movaps %xmm0,0xfffffef8(%ebp)
> 0x80486db <MatrixMultiply+707>:	movaps 0xffffff68(%ebp),%xmm0
> 0x80486e2 <MatrixMultiply+714>:	movaps %xmm0,(%esp,1)
> 0x80486e6 <MatrixMultiply+718>:	movaps 0xffffff28(%ebp),%xmm0
> 0x80486ed <MatrixMultiply+725>:	movaps %xmm0,0x10(%esp,1)
> 0x80486f2 <MatrixMultiply+730>:	call   0x80488e5 <_mm_add_ps>
> 0x80486f7 <MatrixMultiply+735>:	movaps %xmm0,0xffffff68(%ebp)
> 0x80486fe <MatrixMultiply+742>:	movaps 0xffffff58(%ebp),%xmm0
> 0x8048705 <MatrixMultiply+749>:	movaps %xmm0,(%esp,1)
> 0x8048709 <MatrixMultiply+753>:	movaps 0xffffff18(%ebp),%xmm0
> 0x8048710 <MatrixMultiply+760>:	movaps %xmm0,0x10(%esp,1)
> 0x8048715 <MatrixMultiply+765>:	call   0x80488e5 <_mm_add_ps>
> 0x804871a <MatrixMultiply+770>:	movaps %xmm0,0xffffff58(%ebp)
> 0x8048721 <MatrixMultiply+777>:	movaps 0xffffff48(%ebp),%xmm0
> 0x8048728 <MatrixMultiply+784>:	movaps %xmm0,(%esp,1)
> 0x804872c <MatrixMultiply+788>:	movaps 0xffffff08(%ebp),%xmm0
> 0x8048733 <MatrixMultiply+795>:	movaps %xmm0,0x10(%esp,1)
> 0x8048738 <MatrixMultiply+800>:	call   0x80488e5 <_mm_add_ps>
> 0x804873d <MatrixMultiply+805>:	movaps %xmm0,0xffffff48(%ebp)
> 0x8048744 <MatrixMultiply+812>:	movaps 0xffffff38(%ebp),%xmm0
> 0x804874b <MatrixMultiply+819>:	movaps %xmm0,(%esp,1)
> 0x804874f <MatrixMultiply+823>:	movaps 0xfffffef8(%ebp),%xmm0
> 0x8048756 <MatrixMultiply+830>:	movaps %xmm0,0x10(%esp,1)
> 0x804875b <MatrixMultiply+835>:	call   0x80488e5 <_mm_add_ps>
> 0x8048760 <MatrixMultiply+840>:	movaps %xmm0,0xffffff38(%ebp)
> 0x8048767 <MatrixMultiply+847>:	movaps 0xffffffe8(%ebp),%xmm0
> 0x804876b <MatrixMultiply+851>:	shufps $0xff,0xffffffe8(%ebp),%xmm0
> 0x8048770 <MatrixMultiply+856>:	movaps %xmm0,(%esp,1)
> 0x8048774 <MatrixMultiply+860>:	movaps 0xffffffa8(%ebp),%xmm0
> 0x8048778 <MatrixMultiply+864>:	movaps %xmm0,0x10(%esp,1)
> 0x804877d <MatrixMultiply+869>:	call   0x8048905 <_mm_mul_ps>
> 0x8048782 <MatrixMultiply+874>:	movaps %xmm0,0xffffff28(%ebp)
> 0x8048789 <MatrixMultiply+881>:	movaps 0xffffffd8(%ebp),%xmm0
> 0x804878d <MatrixMultiply+885>:	shufps $0xff,0xffffffd8(%ebp),%xmm0
> 0x8048792 <MatrixMultiply+890>:	movaps %xmm0,(%esp,1)
> 0x8048796 <MatrixMultiply+894>:	movaps 0xffffff98(%ebp),%xmm0
> 0x804879a <MatrixMultiply+898>:	movaps %xmm0,0x10(%esp,1)
> 0x804879f <MatrixMultiply+903>:	call   0x8048905 <_mm_mul_ps>
> 0x80487a4 <MatrixMultiply+908>:	movaps %xmm0,0xffffff18(%ebp)
> 0x80487ab <MatrixMultiply+915>:	movaps 0xffffffc8(%ebp),%xmm0
> 0x80487af <MatrixMultiply+919>:	shufps $0xff,0xffffffc8(%ebp),%xmm0
> 0x80487b4 <MatrixMultiply+924>:	movaps %xmm0,(%esp,1)
> 0x80487b8 <MatrixMultiply+928>:	movaps 0xffffff88(%ebp),%xmm0
> 0x80487bc <MatrixMultiply+932>:	movaps %xmm0,0x10(%esp,1)
> 0x80487c1 <MatrixMultiply+937>:	call   0x8048905 <_mm_mul_ps>
> 0x80487c6 <MatrixMultiply+942>:	movaps %xmm0,0xffffff08(%ebp)
> 0x80487cd <MatrixMultiply+949>:	movaps 0xffffffb8(%ebp),%xmm0
> 0x80487d1 <MatrixMultiply+953>:	shufps $0xff,0xffffffb8(%ebp),%xmm0
> 0x80487d6 <MatrixMultiply+958>:	movaps %xmm0,(%esp,1)
> 0x80487da <MatrixMultiply+962>:	movaps 0xffffff78(%ebp),%xmm0
> 0x80487e1 <MatrixMultiply+969>:	movaps %xmm0,0x10(%esp,1)
> 0x80487e6 <MatrixMultiply+974>:	call   0x8048905 <_mm_mul_ps>
> 0x80487eb <MatrixMultiply+979>:	movaps %xmm0,0xfffffef8(%ebp)
> 0x80487f2 <MatrixMultiply+986>:	movaps 0xffffff68(%ebp),%xmm0
> 0x80487f9 <MatrixMultiply+993>:	movaps %xmm0,(%esp,1)
> 0x80487fd <MatrixMultiply+997>:	movaps 0xffffff28(%ebp),%xmm0
> 0x8048804 <MatrixMultiply+1004>:	movaps %xmm0,0x10(%esp,1)
> 0x8048809 <MatrixMultiply+1009>:	call   0x80488e5 <_mm_add_ps>
> 0x804880e <MatrixMultiply+1014>:	movaps %xmm0,0xffffff68(%ebp)
> 0x8048815 <MatrixMultiply+1021>:	movaps 0xffffff58(%ebp),%xmm0
> 0x804881c <MatrixMultiply+1028>:	movaps %xmm0,(%esp,1)
> 0x8048820 <MatrixMultiply+1032>:	movaps 0xffffff18(%ebp),%xmm0
> 0x8048827 <MatrixMultiply+1039>:	movaps %xmm0,0x10(%esp,1)
> 0x804882c <MatrixMultiply+1044>:	call   0x80488e5 <_mm_add_ps>
> 0x8048831 <MatrixMultiply+1049>:	movaps %xmm0,0xffffff58(%ebp)
> 0x8048838 <MatrixMultiply+1056>:	movaps 0xffffff48(%ebp),%xmm0
> 0x804883f <MatrixMultiply+1063>:	movaps %xmm0,(%esp,1)
> 0x8048843 <MatrixMultiply+1067>:	movaps 0xffffff08(%ebp),%xmm0
> 0x804884a <MatrixMultiply+1074>:	movaps %xmm0,0x10(%esp,1)
> 0x804884f <MatrixMultiply+1079>:	call   0x80488e5 <_mm_add_ps>
> 0x8048854 <MatrixMultiply+1084>:	movaps %xmm0,0xffffff48(%ebp)
> 0x804885b <MatrixMultiply+1091>:	movaps 0xffffff38(%ebp),%xmm0
> 0x8048862 <MatrixMultiply+1098>:	movaps %xmm0,(%esp,1)
> 0x8048866 <MatrixMultiply+1102>:	movaps 0xfffffef8(%ebp),%xmm0
> 0x804886d <MatrixMultiply+1109>:	movaps %xmm0,0x10(%esp,1)
> 0x8048872 <MatrixMultiply+1114>:	call   0x80488e5 <_mm_add_ps>
> 0x8048877 <MatrixMultiply+1119>:	movaps %xmm0,0xffffff38(%ebp)
> 0x804887e <MatrixMultiply+1126>:	mov    0x10(%ebp),%eax
> 0x8048881 <MatrixMultiply+1129>:	mov    %eax,(%esp,1)
> 0x8048884 <MatrixMultiply+1132>:	movaps 0xffffff68(%ebp),%xmm0
> 0x804888b <MatrixMultiply+1139>:	movaps %xmm0,0x4(%esp,1)
> 0x8048890 <MatrixMultiply+1144>:	call   0x8048930 <_mm_store_ps>
> 0x8048895 <MatrixMultiply+1149>:	mov    0x10(%ebp),%eax
> 0x8048898 <MatrixMultiply+1152>:	add    $0x10,%eax
> 0x804889b <MatrixMultiply+1155>:	mov    %eax,(%esp,1)
> 0x804889e <MatrixMultiply+1158>:	movaps 0xffffff58(%ebp),%xmm0
> 0x80488a5 <MatrixMultiply+1165>:	movaps %xmm0,0x4(%esp,1)
> 0x80488aa <MatrixMultiply+1170>:	call   0x8048930 <_mm_store_ps>
> 0x80488af <MatrixMultiply+1175>:	mov    0x10(%ebp),%eax
> 0x80488b2 <MatrixMultiply+1178>:	add    $0x20,%eax
> 0x80488b5 <MatrixMultiply+1181>:	mov    %eax,(%esp,1)
> 0x80488b8 <MatrixMultiply+1184>:	movaps 0xffffff48(%ebp),%xmm0
> 0x80488bf <MatrixMultiply+1191>:	movaps %xmm0,0x4(%esp,1)
> 0x80488c4 <MatrixMultiply+1196>:	call   0x8048930 <_mm_store_ps>
> 0x80488c9 <MatrixMultiply+1201>:	mov    0x10(%ebp),%eax
> 0x80488cc <MatrixMultiply+1204>:	add    $0x30,%eax
> 0x80488cf <MatrixMultiply+1207>:	mov    %eax,(%esp,1)
> 0x80488d2 <MatrixMultiply+1210>:	movaps 0xffffff38(%ebp),%xmm0
> 0x80488d9 <MatrixMultiply+1217>:	movaps %xmm0,0x4(%esp,1)
> 0x80488de <MatrixMultiply+1222>:	call   0x8048930 <_mm_store_ps>
> 0x80488e3 <MatrixMultiply+1227>:	leave
> 0x80488e4 <MatrixMultiply+1228>:	ret
> End of assembler dump.
> 
> 
> ---------------------------------------------------
>    Ian Ollmann, Ph.D.       iano@cco.caltech.edu
> ---------------------------------------------------
>