00000000  E802000000        call dword 0x7
00000005  90                nop
00000006  90                nop
00000007  8B442408          mov eax,[esp+0x8]
0000000B  8B4C2404          mov ecx,[esp+0x4]
0000000F  01C8              add eax,ecx
00000011  C20800            ret 0x8
    

As i expected, code branching using call and jmp instruction wont work properly, because they use absolute addressing.

Code:

00000000  E802000000        call dword 0x7
00000005  90                nop
00000006  90                nop
00000007  8B442408          mov eax,[esp+0x8]
0000000B  8B4C2404          mov ecx,[esp+0x4]
0000000F  01C8              add eax,ecx
00000011  C20800            ret 0x8
    

call function
nop
nop
function:
mov eax,[esp+0x8]
mov ecx,[esp+0x4]
add eax,ecx
ret
    

Quote:

because they use absolute addressing

Better use absolute addressing. The problem to relative is that you have to recalculate it. It is better to have a fixed set of compiled code. Probably your making a JIT compiler like this:

http://pypy.org/

I think this is quite bad programming style.
Why don't you use labels ?

dst addr is the procedure
src addr is the current address

here from the same add op:

//

#include <stdio.h>
#include <windows.h>
...

There is no static executabel this code is running in. It will be loaded dynamicall at runtime and executed and thus if i use a label, it will use a static (or does use in my case) address to jump to that address, but in dynamically loaded code, the address will point to something wrong and will make the process crash. The point is that i have to calculate the target instructions absolute address from the relative address somehow and make a branch to the target address, but how?

1.2.5 Jumps and calls


The operand of any jump or call instruction can be preceded not only by the
size operator, but also by one of the operators specifying type of the jump:
short, near or far. For example, when assembler is in 16-bit mode,
instruction jmp dword [0] will become the far jump and when assembler is
in 32-bit mode, it will become the near jump. To force this instruction to be
treated differently, use the jmp near dword [0] or jmp far dword [0] form.


When operand of near jump is the immediate value, assembler will generate
the shortest variant of this jump instruction if possible (but will not create
32-bit instruction in 16-bit mode nor 16-bit instruction in 32-bit mode,
unless there is a size operator stating it). By specifying the jump type
you can force it to always generate long variant (for example jmp near 0)
or to always generate short variant and terminate with an error when it's
impossible (for example jmp short 0).

Labels are in general independent of static or dynamic.
Please read the section in flat assembler manual about jumps and calls.
So why ever calculate jumps and calls manually when you have an assembler engine doing it for you ???
Just use near jumps and calls.
1.2.5 Jumps and calls


The operand of any jump or call instruction can be preceded not only by the
size operator, but also by one of the operators specifying type of the jump:
short, near or far. For example, when assembler is in 16-bit mode,
instruction jmp dword [0] will become the far jump and when assembler is
in 32-bit mode, it will become the near jump. To force this instruction to be
treated differently, use the jmp near dword [0] or jmp far dword [0] form.


When operand of near jump is the immediate value, assembler will generate
the shortest variant of this jump instruction if possible (but will not create
32-bit instruction in 16-bit mode nor 16-bit instruction in 32-bit mode,
unless there is a size operator stating it). By specifying the jump type
you can force it to always generate long variant (for example jmp near 0)
or to always generate short variant and terminate with an error when it's
impossible (for example jmp short 0).

And I don't know for what you exactly use the NOP statements, please take a look at the ALIGN statement for further information.