christripledot

anyone ever tried to write an external in i386 assembly? i haven't much experience inlining asm in c functions. starting from a stripped-down "simplemsp~", i'm struggling to figure out how i'm supposed to "return the NEXT pointer in the array"... i'm assuming the return value should go in eax, but i get nothing but crashes whatever i try...

__inline __declspec(naked) t_int *simplemsp_perform(t_int *w) {

        mov    ebp,    esp

        sub    esp,    __LOCAL_SIZE

        mov    eax,    ebp    ; eax = address of w?

        add    eax,    5    ; w += 5, return?

        mov    esp,    ebp

__inline __declspec(naked) t_int *simplemsp_perform(t_int *w) {
	__asm {
		; set up stack frame
		push	ebp
		mov	ebp,	esp
		sub	esp,	__LOCAL_SIZE

		mov	eax,	ebp	; eax = address of w?
		add	eax,	5	; w += 5, return?

		; restore stack frame
		mov	esp,	ebp
		pop	ebp
		ret
	}
}

inline-assembly-in-vc

mov eax, [ebp] ;; ebp is a pointer to the bottom of the stack

add eax, 20 ;; each int is 4 bytes, so 5 ints is 20 bytes

My other tip is that you are setting yourself up for a life of misery if you continue to follow this path :) Fun as asm is, a quick google will turn up a bunch of articles on how C compilers can optimise better than people for modern architectures. In fact, I read some really old interview with John Carmack where he said that, and it was from about 1994 ..

mov eax, [ebp]  ;; ebp is a pointer to the bottom of the stack
add eax, 20     ;; each int is 4 bytes, so 5 ints is 20 bytes

My other tip is that you are setting yourself up for a life of misery if you continue to follow this path :) Fun as asm is, a quick google will turn up a bunch of articles on how C compilers can optimise better than people for modern architectures. In fact, I read some really old interview with John Carmack where he said that, and it was from about 1994 ..


i had a eureka moment when i woke up this morning, and realised that i should be adding 20, not 5. doh! plus i forgot that i need to look further back on the stack for *w. for anyone interested, here's the solution:

mov     eax, [ebp+8] ; ebp+4 = return address, ebp+8 = w

add eax,    20 ; return w + (# of args * 4 bytes)

i know what you mean about misery! haha! i'm not expecting fantastic results, i just enjoy 'thinking in assembly' and i find it helps you to devleop stronger algorithms. writing max externals in asm is great for me, because i get to learn about writing dsp code without having to worry about how to talk to the sound card - max provides a great framework for that.

i've been working on naive C implementations of some of my ideas for externals (step sequencer counters, a USABLE adsr, etc) and i always pay the penalties of conditional branching. i'm a total klutz with c subtleties, but i know my way around conditional MOVs, so i reckon i might get a little performance benefit in that respect at least.

thankyou so much for replying, i knew it was a long shot! i'll send you anything that i get working!

__inline __declspec(naked) t_int *simplemsp_perform(t_int *w) {
__asm {
push ebp
mov ebp, esp ; ebp = top of stack
mov	 eax, [ebp+8] ; ebp+4 = return address, ebp+8 = w
add eax,	20 ; return w + (# of args * 4 bytes)
pop	ebp
ret
}
}

inline assembly in vc++