precise debugging of inline asm
Hello!
The mentioning of gdb in this mailinglist gave me the idea to ask my unresolved question here as well:
Trying to port cpt2 to linux I have an inline assembly part of about 100 lines that causes a segmentation fault while juggling around with memory. When I use gdb for debugging it sadly only points me to the line where the inline asm starts. I haven't been able to figure out how to get a more precise info in what line the actual segmentation fault comes from.
Does anybody here know if that is at all possible and if so, how? Would labels to each line help?
Thanks for any help or hints.
Lynx
Quoted 14 lines · [email protected] wrote:
Hello!
The mentioning of gdb in this mailinglist gave me the idea to ask my unresolved question here as well:
Trying to port cpt2 to linux I have an inline assembly part of about 100 lines that causes a segmentation fault while juggling around with memory. When I use gdb for debugging it sadly only points me to the line where the inline asm starts. I haven't been able to figure out how to get a more precise info in what line the actual segmentation fault comes from.
Does anybody here know if that is at all possible and if so, how? Would labels to each line help?
Quoted 2 lines
Thanks for any help or hints.
Lynx
On x86, try for example
(gdb) disassemble $eip $eip+20
Also see
(gdb) info registers
Cld
Quoted 6 lines · Claudio Fontana
On x86, try for example
(gdb) disassemble $eip $eip+20
Also see
(gdb) info registers
Thanks Claudio Fontana. That did the trick. So the first line of output from disassemble $eip $eip+20 is then the line where the segfault occured? In this
example "mov %cx,(%esi,%edx,2)"?
(gdb) disassemble $eip $eip+20
Dump of assembler code from 0x87b29f8 to 0x87b2a0c:
0x087b29f8 <.lable1+3>: mov %cx,(%esi,%edx,2) 0x087b29fc <.lable1+7>: inc %edx 0x087b29fd <.lable1+8>: jne 0x87b29ca <.lable0> 0x087b29ff <.lable1+10>: mov %ebp,0xffffffd0(%ebp) 0x087b2a02 <.lable1+13>: pop %ebx 0x087b2a03 <.lable1+14>: mov %eax,0xffffffa8(%ebp) 0x087b2a06 <.lable1+17>: addl $0x1,0xffffffb0(%ebp) 0x087b2a0a <.lable1+21>: cmpl $0x2f,0xffffffb0(%ebp)
End of assembler dump.
Well investigating that I think I should be sure of what each line does so here I have some more questions:
As in the code below, will gcc not use registers in the clobber list as registers for %0 - %5 ?
Or asked differently: How would one code an asm swap?
1.
__asm__("movl %0,%4 \n\t"
"movl %1,%0 \n\t"
"movl %4,%1 \n\t"
: "=r" (a), "=r" (b) : "0" (a), "1" (b), "r" (c));or
2.
__asm__("movl %0,%%ebx \n\t"
"movl %1,%0 \n\t"
"movl %%ebx,%1 \n\t"
: "=r" (a), "=r" (b) : "0" (a), "1" (b) : %ebx);Well if some one likes the challange: Does anybody see the mistakes I mad translating the intel inline-asm MSC code to at&t inline-asm gcc code? Did I do something wrong with the register lowding or the constrains?
Thanks again
Lynx
_asm {
mov edx, endX mov edi, pDestPixel mov esi, dataPtr mov ecx, startX lea edi, [edi + 2*edx] sub ecx, edx mov ebx, transDataPtr
L0:
mov dx, [esi] add esi, 2
xor eax, eax mov ax, dx
cmp eax, 4
jge L1
mov edx, tileData[4*eax] test edx, edx jz L2
add edx, 2
mov tileData[4*eax], edx mov dx, [edx-2] jmp L1
L2:
mov dx, [ebx]
L1:
add ebx, 2
mov [edi + 2*ecx], dx inc ecx
jnz L0
mov transDataPtr, ebx mov dataPtr, esi
}
#else
printf("%s L%d: Using __asm__ tile blending!\n", __FILE__, __LINE__);
__asm__ (
// "movl $endX, %edx \n\t" //done by gcc! %3
// "movl $pDestPixel, %edi \n\t" //done by gcc! %2
// "movl $dataPtr, %esi \n\t" //done by gcc! %1
// "movl $startX, %ecx \n\t" //done by gcc! %4 "leal (%2,%3,2),%2 \n\t"//load value %2 + 2 * %3 is pointing to
"subl %3,%4 \n\t" //%3 is now reuseable
// "movl $transDataPtr, %ebx \n\t" //done by gcc!
".lable0: \n\t"
"movw (%1),%w3 \n\t" //reusing edx (%3)
"addl $2,%1 \n\t"// "movl %%eax, %4 \n\t"
"pushl %%ebx \n\t" // save reg for PIC!
// "pushl %%ebp \n\t" // save ebp, NEVER! use -fomit-frame-pointer
//even if ebp is in clobberlist gcc uses it here to reference memory!
"movl %0, %%ebp \n\t"
"xorl %%ebx,%%ebx \n\t" //make %ebx = 0, see below, we use ebx
"movw %w3,%%bx \n\t" //because of this ebx has to be static
"cmpl $4,%%ebx \n\t" //because of above line eax may be != 0
"jge .lable1 \n\t"
"movl (%5,%%ebx,4), %3 \n\t" // ** tileData can't be passed as "m"!
"testl %3,%3 \n\t" //check if %3 is zero, set Z-bit
"jz .lable2 \n\t"
"addl $2,%3 \n\t"
"movl %3, (%5,%%ebx,4) \n\t" // (%eax + %ebx * 4) = %3
"movw -2(%3),%w3 \n\t" // %w3 first (or last?) 2 bytes of %3
"jmp .lable1 \n\t"
".lable2: \n\t"
"movw (%%ebp),%w3 \n\t"//movw (%3),%%dx
".lable1: \n\t"
"addl $2,%%ebp \n\t"
"movw %w3,(%2,%4,2) \n\t"
"incl %4 \n\t"
"jnz .lable0 \n\t"
"movl %%ebp, %0 \n\t"// this wouldn't work without -fomit-frame-pointer
// "popl %%ebp \n\t"// restore ebp, NEVER use this!
"popl %%ebx \n\t"// restore reg for PIC!
// "movl %esi, $dataPtr \n\t" //does gcc
: "=g" (transDataPtr), "=r" (dataPtr) // "=D" (pDestPixel)
: "r" (pDestPixel), "r" (endX), "r" (startX), "r" (tileData), "0" (transDataPtr), "1" (dataPtr)
: "%ebp", "cc"
#if !defined(PIC) && !defined(__PIC__) //don't tell gcc about what was done to ebx!!!
, "%ebx" //but do, if PIC is not enabled! It might use it else wise!!!
#endif
);