neg eax ; twos compliment negation    

cmp eax,ecx
jg label ;or ja, jb, jle, etc.    

sub esp,4 ;space for 4 bytes, 1 dword
mov [esp],eax ;store something there    

sub esp,4*4 ;space for 4 dwords, or 16 bytes    

add esp,4*4 ; restore esp to original value    

format PE
entry main
section '.code' code readable executable

main:
        int3
        mov eax, -8
        neg eax
        mov ecx, 9
        cmp eax, ecx
        jg myLabel

myLabel:
        push ebp
        mov ebp, esp

        sub esp, 4
        mov [esp], eax
        sub esp, 6*1 ; 6 bytes for 6 characters
        mov [esp+4], "hello",0
        cinvoke printf, [esp+4]

        mov esp, ebp
        pop ebp



section '.idata' import data readable
        library msvcrt,'msvcrt.dll'

        import msvcrt,\
               printf,'printf'     

mov dword[esp],'hell'
mov word[esp+4],'o' ;upper 8 bits are zero
cinvoke printf, esp    

You can't load a 6 byte constant with a single 32-bit instruction. You can split it into two parts.

Code:

mov dword[esp],'hell'
mov word[esp+4],'o' ;upper 8 bits are zero
cinvoke printf, esp    

void myFunc()
{
        const char* myString = "hello";
        printf("%s\n", myString);
}    

proc myFunc c
     cinvoke printf, .szFormat, .myString
     ret

.szFormat db '%s\n', 0
.myString db 'hello', 0
endp    

printf("hello\n");    

Suppose i have a function (label) where i want to store some strings localy to work with them within this function.
The aproach you showed seems to be a bit error prone.

If not, how would one usually do it?

How would this c-code look like in fasm?

Code:

void myFunc()
{
        const char* myString = "hello";
        printf("%s\n", myString);
}    

jmp @f
.my_string: db 'hello',0
@@: cinvoke printf, .my_string    

You might want to write something like

Code:

proc myFunc c
     cinvoke printf, .szFormat, .myString
     ret

.szFormat db '%s\n', 0
.myString db 'hello', 0
endp    

Note also that in your case it might be enough to use a single string:

Code:

printf("hello\n");    

It depends upon how you interpret "local"

The reason behind this is, i want to check if a condition is met (e.g. one is greater than the other) and not directly jump somewhere by using jg for example. I want to always use "jz" to jump, therefore i need to manually set the corresponding flags manually.
So i want to do it like this:
- cmp
- check if greater without jumping (not using jg)
- set zero flag accordingly
- use jz

Instead you might be able to use setg and setz to set two different registers, and then compare with cmp and make your final jz from there.

sle d0 ; set d0 register when less or equal -> in fasm ?
tst d0 ; test if d0 is set -> in fasm cmp eax, ???
beq myLabel ; jump when z-bit set (by tst) -> in fasm jz myLabel    

There are also cmovcc instructions.

Various combinations of the conditional instructions might make your code more efficient. It might also allow you to avoid using jcc completely.

There are also cmovcc instructions.

Various combinations of the conditional instructions might make your code more efficient. It might also allow you to avoid using jcc completely.

It's a pity there are no cmovcc instructions with the destination memory operand.

xor eax,eax ; null pointer. Z flag is now set
cmovnz eax,[eax] ; CRASH! Fails when eax==0 regardless of the Z flag value    

CandyMan wrote:

It's a pity there are no cmovcc instructions with the destination memory operand.

It is also a pity that you can't use cmovcc to avoid reading null pointers. The second operand is always read.

Code:

xor eax,eax ; null pointer. Z flag is now set
cmovnz eax,[eax] ; CRASH! Fails when eax==0 regardless of the Z flag value