Re: [Drlvm][Opt]How to avoid instrumentation's effect on Reg-Allocation?

[zouqiong]

In fact, performance is not my problem.
I just want my instrumentation won't affect the code.
It means that if I remove the instrumentation, the code can still work
correctly.

     mov    %ebp, eax
     add    0xc, eax

//start of my instrumentation
     mov    $0xe1f0f4,%ebx
     mov    (%ebx),%edx
     mov    $0xe1f0f4,%ebx
     subl   $0x10,(%ebx)
     mov    %eax,(%edx)
     mov    0x8(%esp),%eax
     mov    %eax,0x4(%edx)
     movl   $0x9a0000,0x8(%edx)
//end of my instrumentation

     mov    0xc(%ebp,%eax,4),%ebp


if the instrumentation is removed, the code becomes:
     mov    %ebp, eax
     add    0xc, eax
     mov    0xc(%ebp,%eax,4),%ebp

because the eax is updated in my instrumentation, so without my
instrumentation, the code can't work.

This is the first thing. I still have another problem. It's odd.

Opnd* addrOpnd = irManager.newImmOpnd(typeManager.getUnmanagedPtrType(
typeManager.getUIntPtrType()),

(POINTER_SIZE_INT)&current_obj_acc_record_pointer);
Opnd* memOpnd =
irManager.newMemOpnd(typeManager.getUIntPtrType(),MemOpndKind_Heap,
addrOpnd, NULL, NULL, NULL);
Opnd* AddrOpnd = irManager.newRegOpnd(typeManager.getUnmanagedPtrType(
typeManager.getUIntPtrType()), RegName_EDX);
appendInsts(irManager.newInst(Mnemonic_SUB,memOpnd, irManager.newImmOpnd(
typeManager.getUInt32Type(), 16)));
appendInsts(irManager.newCopyPseudoInst(Mnemonic_MOV,AddrOpnd,
irManager.newMemOpnd(typeManager.getUIntPtrType(),
                                       MemOpndKind_Heap, addrOpnd, NULL,
NULL, NULL)));

The code generated is:
     mov    $0xe1f0f4,%ebx
     mov    (%ebx),%edx
      mov    $0xe1f0f4,%ebx
     subl   $0x10,(%ebx)

I don't know why the ebx is assigned with $0xe1f0f4 twice ? It's redundant.

Thanks,
Qiong







2007/2/8, Mikhail Fursov <[EMAIL PROTECTED]>:

Zouqiong,
If you do instrumentation in HIR you can't predict which registers will be
used in CG.
If you do instrumentation in LIR you can only assign predefined registers
or
constraints to your operands, but you can't affect register allocation for
unassigned operands.
So if you think that RegAlloc does a bad job for you, this is RegAlloc
issue
and must be fixed in RegAlloc.

+ Reg-allocator does change side-effects of your code. Loading EAX from a
stack in your example can have only 1 drawback: performance problem. Is
performance your problem here?

On 2/8/07, zouqiong <[EMAIL PROTECTED]> wrote:
>
> Hi, guys,
>   I instrument during code selector pass, however, I find that my
> instrmentation affects the register allocation. For example as follows:
>
>       mov    %ebp, eax
>       add    0xc, eax
>
>       mov    $0xe1f0f4,%ebx
>       mov    (%ebx),%edx
>       mov    $0xe1f0f4,%ebx
>       subl   $0x10,(%ebx)
>       mov    %eax,(%edx)
>       mov    0x8(%esp),%eax
>       mov    %eax,0x4(%edx)
>       movl   $0x9a0000,0x8(%edx)
>
>       mov    0xc(%ebp,%eax,4),%ebp
>
>       The code in yellow backgroud is my instrumentation. And we can see
> that EAX is loaded from the stack in the instrumentation. It's bad.
> I don't want my instrumentation doing it.
>       Can someone tell me how can i avoid it?
>
> Thanks,
> Qiong
>
>
> --
> Best Regards,
> Qiong,Zou
>



--
Mikhail Fursov

--
Best Regards,
Qiong,Zou