f(x,y)=x+sin(y)    

f(x,y):
while x^2 + y^2 < R,
{x, y} = {x^2 - y^2 + X, 2 x y + Y}
end while
return x + y
    

f:      fld  tword[2]
        fld  tword[Y]
        fld  tword[X]
        fld  tword[R]
        fld  tword[esp+4+16*1]  ; 2nd argument
        fld  tword[esp+4+16*0]  ; 1st argument
       fxch  st4
       fstp  tword[esp-16*1]    ; spill location
.1:     fld  st3
       fmul  st0,st0
        fld  st1
       fmul  st0,st0
        fld  st0
       fadd  st0,st2
     fcomip  st0,st4
        jnb  .2
      fsubp  st1,st0
       fxch  st1
       fmul  st0,st5
      fmulp  st4,st0
        fld  tword[esp-16*1]
      faddp  st4,st0
       fadd  st0,st2
       fstp  st5
       fxch  st2
       fxch  st3
        jmp  .1
.2:    fstp  st0
       fstp  st0
       fstp  st1
       fstp  st1
       fstp  st2
      faddp  st1,st0
        ret                     ; return value on fpu stack    

hmmm..
That doesn't always work:
What if I don't have a HLL compiler? (Or I can't get it to work)
What if the compiler places transcendental functions in some other place?
What if the program could use some simplifying assumptions about the function to produce better code than the compiler.

I was thinking it to be more of a fun exercise in basic HLL -> quality asm transformation. I admit it is probably not that useful.

__declspec(naked) type convention func_name(parameters...)
{
__asm push ebp
__asm mov ebp, esp

// your C code here

__asm mov esp, ebp
__asm pop ebp
ret                               // return that complies with appropriate convention used.
}