edi | EDI is a notes application that integrates with the shell | Form library

This question is really too big for Stack Overflow.

But one way of answering it is to say that if you can mechanically translate some variant of λ-calculus into some other language, then you can reduce the question of how you might compile λ-calculus to asking how do you turn that substrate language into machine language for some physical machine: how do you compile that substrate language, in other words. That should give an initial hint as to why this question is too big.

Fortunately λ-calculus is pretty simple, so the translation into a substrate language is also pretty easy to do, especially if you pick a substrate language which has first-class functions and macros: you can simply compile λ-calculus into a tiny subset of that language. Chances are that the substrate language will have operations on numbers, strings, and all sorts of other types of thing, but your compiler won't target any of those: it will just turn functions in the λ-calculus into functions in the underlying language, and then rely on that language to compile them. If the substrate language doesn't have first-class functions you'll have to work harder, so I'll pick one that does.

So here is a specific example of doing that. I have a toy language called 'oa' (or in fact 'oa/normal' which is an untyped, normal-order λ-calculus. It represents functions in a slight variant of the traditional Lisp representation: (λ x y) is λx.y. Function application is (x y).

oa then get gets turned into Scheme (actually Racket) roughly as follows.

First of all there are two operations it uses to turn normal-order semantics into Scheme's applicative-order semantics:

• (hold x) delays the evaluation of x – it is just a version of Scheme's delay which exists so I could instrument it to find bugs. Like delay, hold is not a function: it's a macro. If there were no macros the translation process would have to produce into the expression into which hold expands.
• (release* x) will force the held object made by hold and will do so until the object it gets is not a held object. release* is equivalent to an iterated force which keeps forcing until the thing is no longer a promise. Unlike hold, release* is a function, but as with hold it could simply be expanded out into inline code if you wanted to make the output of the conversion larger and harder to read.

So then here is how a couple of λ-calculus expressions get turned into Scheme expressions. Here I'll use λ to mean 'this is a oa/λ-calculus-world thing' and lambda to mean 'this is a Scheme world thing'.

llvm-objdump -S should work in the same way that it does for native object files.

If you are looking for nice display of code that lacks debug info you might also want to take a look at wasm-decompile which is part of the wabt project. Its able to do a much better job of making something readable than normal/native decompilers.

Your code didn't work because Specifying Registers for Local Variables explicitly tells you not to do what you did:

The only supported use for this feature is to specify registers for input and output operands when calling Extended asm (see Extended Asm).

Other than when invoking the Extended asm, the contents of the specified register are not guaranteed. For this reason, the following uses are explicitly not supported. If they appear to work, it is only happenstance, and may stop working as intended due to (seemingly) unrelated changes in surrounding code, or even minor changes in the optimization of a future version of gcc:

• Passing parameters to or from Basic asm
• Passing parameters to or from Extended asm without using input or output operands.
• Passing parameters to or from routines written in assembler (or other languages) using non-standard calling conventions.

To put the value of registers in variables, you can use Extended asm, like this:

You can use these two empty templates:

There's a couple of issues. First of all ja is used for unsigned comparisons so it won't work for detecting values <0. Use jg (jump if greater) instead.

When you use Invoke MASM, does prepare a frame for you and passes parameters via stack, those are available inside the method, but if you see those ptrmessage in a debugger outside VS, those will be pointers to the addresses on the stack and not to the content of the message.

1. Your SIMD code wastes time mispredicting that test ebp, 1 / jnz branch. There’s no conditional move instruction in SSE, but you can still optimize away that test + branch with a few more instructions like this:

val % 2 may have negative value if val is negative. val & 1 will only have a positive value (or zero). So those operations are not identical - thus different compiled code.

This is actually compilable C code.

None of the variables have names because that information is not in the executable (unless it was compiled with debug settings). The types being used are typedefs for certain integer types which presumably the decompiler has available as a header file. So given that header you can recompile this source file.

Don't make it so complicated. joinArrayBuffers and padArrayBufferTo64 are very inefficient, notice that buffers and typed arrays have quite some overhead in JS - they are designed to hold large binary data, not individual values, and you should try to create them once and only read/write to them afterwards.

Instead of trying to use BigUint64Array for all your operands, and moving around buffers, I would recommend to use the appropriately sized typed arrays for your smaller registers, and just cast the number to a bigint after accessing the array (if you need bigints for all your ALU operations at all - a 32 bit ALU is probably much more efficient to implement).