Converting Arithmetic Expressions to Assembly

[aw27]

It's not. My website sleeps from 22 to 23 PM UTC+1. If I want to make it accessible 24h/day, I'd have to pay for the hosting, and now it's free.

Extreme poverty, people that can't pay a couple of dollars per month to have something fully functional, deserve my sympathy an I pray for them every night.

[HSE]

Internet even exist when I have 18. And in that case, no money to expend in it.   

[aw27]

Internet even exist when I have 18. And in that case, no money to expend in it.   

No free lunches, though, except in Salvation Army.  :t

[markallyn]

Hello Universe----,

That is a very cool project, I have to tell you.  I am not familiar with these "S expressions?", so my question may be hopelessly naïve and even misguided.  Here it is:

How far can you extend this compiler?  For example, would it be feasible to write code (presumably S expressions) that would solve differential  equations, or even just plain vanilla linear algebra?

Regards,
Mark Allyn

[UniverseIsASimulation]

Yes, it's possible to solve the equations using the S-expressions. Emacs calculator does that. I am not planning to extend that web-app very far. I am planning to learn a language that's more suitable for those things than JavaScript is and, perhaps a few years from now, rewrite it in that language. The web-app was just a way to test whether the algorithm I've made for converting the arithmetic expressions to assembly was right.

[UniverseIsASimulation]

Does anyone here happen to know the algorithms Emacs calculator uses?

[felipe]

Does anyone here happen to know the algorithms Emacs calculator uses?

Aren't the sources of emacs calculator freely available?  :idea:

[aw27]

As you may know the only way to convert a High-Level language, whatever it is, already invented or not to machine executable code is through a compiler. A compiler is a sophisticated piece of code, as you will be guessing.
Assembly language (ASM) is machine code in easy readable form. It is not as difficult to take machine code and obtain ASM by using a disassembler because there is almost 1-to-1 correspondence.
What you are trying to achieve is the associated job of a compiler AND a disassembler. Think about it, there are no shortcuts. You have in hands a major project, which can definitly not be made in javascript or in any easy-go-round language for lazy kids to show off.

[UniverseIsASimulation]

Does anyone here happen to know the algorithms Emacs calculator uses?

Aren't the sources of emacs calculator freely available?  :idea:

As I've said, I am not a programmer. Can you break it down for me? Preferably in Croatian and using JavaScript to explain the code-related details. If you can't, then explain it in English and using some language similar to JavaScript (I think I would even be able to understand C++) to explain the code-related details.

So, if I understood you correctly, the assembly code my web-app produces can be compiled using not only FASM, but also using MASM? That's quite surprising. I've checked it and it doesn't compile in the GAS intel-syntax mode.

[jj2007]

So, if I understood you correctly, the assembly code my web-app produces can be compiled using not only FASM, but also using MASM? That's quite surprising.

Not that surprising, actually. FPU code is pretty standard, it's mnemonics like fld somevar or fxch that all assemblers should treat the same way. The differences in headers and directives are much more important.

[UniverseIsASimulation]

Well, not all assemblers let you to use the syntax such as "st0" to access the stack (some require you to use the longer "ST(0)" format), and not all assemblers let you use a syntax such as "2f" to create 32-bit floats and use them as the arguments for "mov".
It compiles them the same way FASM does? A bit complicated example, if you assemble the web-app's output for "(x<0)*(-x)+(x>0)*x", does the variable "result" contain the absolute value of the variable "x"?

So, nobody here uses EMACS? Well, to be honest, neither do I. I usually use "xed" on Mac and Notepad++ on PC.

[jj2007]

Well, not all assemblers let you to use the syntax such as "st0" to access the stack (some require you to use the longer "ST(0)" format), and not all assemblers let you use a syntax such as "2f" to create 32-bit floats and use them as the arguments for "mov".

You are right, the differences are bigger than I thought :icon_redface:

finit	finit
fld dword [alpha]	fld alpha
mov [result],57.2957795f	m2m result, FP4(57.2957795)
fld dword [result]	fld dword ptr result
fdivp st1, st0	fdivp st(1), st
fsin	fsin
mov [result],2f	m2m result, FP4(2.)
fld dword [result]	fld dword ptr result
fxch	fxch
fld1	fld1
fxch	fxch
fyl2x	fyl2x
fldl2e	fldl2e
fdivp st1, st0	fdivp st(1), st
fmulp st1, st0	fmulp st(1), st
fldl2e	fldl2e
fmulp st1, st0	fmulp st(1), st
fld1	fld1
fscale	fscale
fxch	fxch
fld1	fld1
fxch	fxch
fprem	fprem
f2xm1	f2xm1
faddp st1, st0	faddp st(1), st
fmulp st1, st0	fmulp st(1), st
fld dword [alpha]	fld alpha
mov [result],57.2957795f	m2m result, FP4(57.2957795)
fld dword [result]	fld result
fdivp st1, st0	fdivp st(1), st
fcos	fcos
mov [result],2f	m2m result, FP4(2.)
fld dword [result]	fld result
fxch	fxch
fld1	fld1
fxch	fxch
fyl2x	fyl2x
fldl2e	fldl2e
fdivp st1, st0	fdivp st(1), st
fmulp st1, st0	fmulp st(1), st
fldl2e	fldl2e
fmulp st1, st0	fmulp st(1), st
fld1	fld1
fscale	fscale
fxch	fxch
fld1	fld1
fxch	fxch
fprem	fprem
f2xm1	f2xm1
faddp st1, st0	faddp st(1), st
fmulp st1, st0	fmulp st(1), st
faddp st1, st0	faddp st(1), st
mov [result],0f	mov result, 0
fld dword [result]	fld result
fxch	fxch
fsubp st1, st0	fsubp st(1), st
mov [result],0f	mov result, 0
fld dword [result]	fld result
mov [result],1f	m2m result, FP4(1.)
fld dword [result]	fld result
fsubp st1, st0	fsubp st(1), st
fsubp st1, st0	fsubp st(1), st
fabs	fabs
mov [result],1f	m2m result, FP4(1.)
fld dword [result]	fld result
mov [result],1000f	m2m result, FP4(1000.)
fld dword [result]	fld result
fdivp st1, st0	fdivp st(1), st
fcomip st1	fcomip st, st(1)
fstp dword [result]	fstp result
jna l194549	jna l194549
fld1	fld1
jmp l876055	jmp l876055
l194549:	l194549:
fldz	fldz
l876055:	l876055:
mov [result],2f	m2m result, FP4(2.)
fld dword [result]	fld result
mov [result],2f	m2m result, FP4(2.)
fld dword [result]	fld result
faddp st1, st0	faddp st(1), st
mov [result],5f	m2m result, FP4(5.)
fld dword [result]	fld result
fcomip st1	fcomip st, st(1)
fstp dword [result]	fstp result
jne l436047	jne l436047
fld1	fld1
jmp l71133	jmp l71133
l436047:	l436047:
fldz	fldz
l71133:	l71133:
mov [result],3f	m2m result, FP4(3.)
fld dword [result]	fld result
mov [result],1f	m2m result, FP4(1.)
fld dword [result]	fld result
faddp st1, st0	faddp st(1), st
mov [result],3.5f	m2m result, FP4(3.5)
fld dword [result]	fld result
fcomip st1	fcomip st, st(1)
fstp dword [result]	fstp result
jnb l613334	jnb l613334
fld1	fld1
jmp l467593	jmp l467593
l613334:	l613334:
fldz	fldz
l467593:	l467593:
fistp dword [result]	fistp result
mov eax,[result]	mov eax, result
fistp dword [result]	fistp result
or [result],eax	or result,eax
fild dword [result]	fild result
fistp dword [result]	fistp result
mov eax,[result]	mov eax, result
fistp dword [result]	fistp result
and [result],eax	and result,eax
fild dword [result]	fild result
mov [result],45f	m2m result, FP4(45.)
fld dword [result]	fld result
fstp dword [result]	fstp result
fld dword [result]	fld result
fld1	fld1
fld dword [result]	fld result
fld dword [result]	fld result
fmulp st1, st0	fmulp st(1), st
fsubp st1, st0	fsubp st(1), st
fsqrt	fsqrt
fdivp st1, st0	fdivp st(1), st
fld1	fld1
fpatan	fpatan
mov [result],57.2957795f	m2m result, FP4(57.2957795)
fld dword [result]	fld result
fxch	fxch
fmulp st1, st0	fmulp st(1), st
mov [result],0.5f	m2m result, FP4(0.5)
fld dword [result]	fld result
fsubp st1, st0	fsubp st(1), st
fabs	fabs
mov [result],1f	m2m result, FP4(1.)
fld dword [result]	fld result
mov [result],1000f	m2m result, FP4(1000.)
fld dword [result]	fld result
fdivp st1, st0	fdivp st(1), st
fcomip st1	fcomip st, st(1)
fstp dword [result]	fstp result
jna l606217	jna l606217
fld1	fld1
jmp l520364	jmp l520364
l606217:	l606217:
fldz	fldz
l520364:	l520364:
fld1	fld1
fxch	fxch
fsubp st1, st0	fsubp st(1), st
fistp dword [result]	fistp result
mov eax,[result]	mov eax, result
fistp dword [result]	fistp result
and [result],eax	and result,eax
fild dword [result]	fild result
fstp dword [result]	fstp result

So, nobody here uses EMACS? Well, to be honest, neither do I. I usually use "xed" on Mac and Notepad++ on PC.

RichMasm, of course :P

[UniverseIsASimulation]

So, indeed, it doesn't compile in MASM? Well, I guess it's still easier to manually convert the FASM code into the MASM code than to manually convert arithmetic expressions to assembly. Or is there a way to automatically convert the FASM code into the MASM code? Perhaps by compiling the code with FASM and then using a disassembler?

[jj2007]

Compiling the code with FASM and then using a disassembler should work, but that's a workaround. If it was my project, I would consider two versions, but it seems you are normally working with FASM...

[UniverseIsASimulation]

Maybe you can modify mine (fork it) to produce MASM-compatible code?
Just download the latest source code, I've fixed some bugs and implemented some basic error-handling since the version you posted here.

BTW, I can't find out, what do "m2m" and "fp4" mean exactly in MASM?