Crambly - NASM Wrapper Language

[Mixolydian]

Sorry for the wait, I had some paid programming work so obviously that took priority.

I finally found the time to rewrite Crambly from the ground up and I am pleased to announce its release!

See the first post for the download link and a sample Crambly program which shows off all of the features I've been working on.

[gammac]

Hi,

nice work, but ...

Code: [Select]

_main:
push ebp
mov ebp, esp
and esp, -16
mov dword [ebp], 5
mov dword [ebp-4], 2

what are you doing here?

local variables should look like this:

Code: [Select]

sub esp, 8    ; reserve enough bytes for my local vars
mov dword [ebp-4], 5
mov dword [ebp-8], 2

And if you intend to use resd as directive for local vars, I would say, that's not a good idea.

btw: I would prefere an output that preseves the original source formating. Only your generated source should start at the beginning of a line, everything else as founded in the original source file.

EDIT: and you have left the function arguments on the stack

[Mixolydian]

Thanks for the feedback, I will fix the local variables.

you have left the function arguments on the stack

Originally I was going to leave this for the user to clean up, but I haven't fully decided.

I would prefere an output that preseves the original source formating.

Yes, I will definitely implement this in the future.

EDIT: I've just made some changes based on your suggestions. Here's the new adding.asm file that is generated:

Code: [Select]

extern _printf
global addFunction
global _main
section .data
addingString: db "Adding %d and %d", 10, "", 0
resultString: db "Result is %d", 10, "", 0
section .bss
result: resd 1
section .text
addFunction:
push ebp
mov ebp, esp
and esp, -16
push dword [ebp+12]
push dword [ebp+8]
push addingString
call _printf
add esp, 3*4
mov eax, [ebp+8]
add eax, [ebp+12]
add esp, 8
mov esp, ebp
pop ebp
ret
_main:
push ebp
mov ebp, esp
and esp, -16
sub esp, 16
mov dword [ebp-4], 5
mov dword [ebp-8], 2
push dword [ebp-8]
push dword [ebp-4]
call addFunction
mov dword [result], eax
push dword [result]
push resultString
call _printf
add esp, 2*4
add esp, 16
mov esp, ebp
pop ebp
ret


And if you intend to use resd as directive for local vars, I would say, that's not a good idea.

I could change the the res to loc, so it would be:

Code: [Select]

locd test
mov dword [test], 5

[Mixolydian]

I've just uploaded Version 0.2 to GitHub.

Local variables are now accessed correctly, function parameters are now taken off the stack before returning, and local variables are declared with locb, locw, locd, and locq instead of resb, resw, resd, and resq.

EDIT: I forgot to mention that the reason I sub esp, 16 instead of just sub esp, 8 is because Crambly automatically aligns to multiples of 16 to support 64bit, this is the same thing that gcc does; for example:

locb variable

Reserves 16 bytes, even though we only use 1.

But:

locq variable1
locq variable2
locb variable3

Reserves 32 bytes, even though we only use 17.

[gammac]

Code: [Select]

extern _printf
global addFunction
global _main

section .data
addingString: db "Adding %d and %d", 10, "", 0
resultString: db "Result is %d", 10, "", 0

section .bss
result: resd 1

section .text
addFunction:
push ebp
mov ebp, esp
and esp, -16

push dword [ebp+12]
push dword [ebp+8]
push addingString
call _printf
add esp, 3*4
mov eax, [ebp+8]
add eax, [ebp+12]

add esp, 8            ; that isn't a cleanup
mov esp, ebp
pop ebp
ret   ; no callee cleanup
_main:
push ebp
mov ebp, esp
and esp, -16
sub esp, 16

mov dword [ebp-4], 5
mov dword [ebp-8], 2
push dword [ebp-8]
push dword [ebp-4]
call addFunction
; and no caller clean up
mov dword [result], eax
push dword [result]
push resultString
call _printf
add esp, 2*4

add esp, 16          ; that's not necessary
mov esp, ebp        ; stack ballancing is done here
pop ebp
ret
You still have'nt fixed the clean up, take a look at this:
http://en.wikipedia.org/wiki/X86_calling_conventions#Callee_clean-up

and take a look at your stack balancing

[Mixolydian]

Thanks for helping me so much; I think I've finally got everything working correctly now, please try the latest Version 0.4 and tell me if there are any bugs still present.

[gammac]

sorry, I haven't tried it. But I've two notes, not really bugs.

- because you tried to align the stack you should know that your local vars are unaligned. Was it intended?
- ret 0 is not necessary maybe it's slower then simply ret

I assume that your crappy tool is not written in assembly. Which language do you use for it?

Code: [Select]

_main:
push ebp
mov ebp, esp
and esp, -16
sub esp, 16

mov dword [ebp-4], 5         ; ebp is unaligned esp
mov dword [ebp-8], 2
push dword [ebp-8]
push dword [ebp-4]
call addFunction
;...
mov esp, ebp
pop ebp
ret 0          ; it's not necessary with 0, it could be slower
ret            ; then this.

[Mixolydian]

The tool is written in C - I will release the source, but not right now. It's not ready yet.

Regarding the incorrect alignment:

Code: [Select]

sub esp, 16

mov dword [ebp-4], 5         ; ebp is unaligned esp
mov dword [ebp-8], 2
Should it be this?

Code: [Select]

sub esp, 16

mov dword [ebp-12], 5
mov dword [ebp-8], 2

Code: [Select]

ret 0          ; it's not necessary with 0, it could be slower
ret            ; then this.
OK; that's a simple fix.

I'm really busy for the rest of the week and I'm away on the weekend but I'll try and get an update fixing these two "notes" when I can.

Once again, thanks for the feedback.

[gammac]

Should it be this?

Code: [Select]

sub esp, 16

mov dword [ebp-12], 5
mov dword [ebp-8], 2

No.

I'm really busy for the rest of the week and I'm away on the weekend but I'll try and get an update fixing these two "notes" when I can.

I understand you but If you want to understand the stack and what goes on with the stack frame you'll need a little bit time to go for it.

[Mixolydian]

What should it be?

[gammac]

Let the user do the work, if they need aligned local variables.