I'm wondering whether it's possible to design a programming language where I can teach the compiler how to implement a named operation in assembly, then reuse it later. For example, I might define something like `teach get(x)` and provide the assembly code for reading input. After that, writing `get(age)` would cause the compiler to insert or call the assembly implementation I previously supplied. The goal is a simple language that can generate native assembly or machine code while letting the programmer extend it with low-level implementations. I'm new to compiler design and low-level programming, so I'd like to know whether this is a meaningful idea, how it differs from ordinary functions, macros, or inline assembly, and whether it would be worthwhile as a learning project.
4 Answers
Languages such as C can already do something similar with inline assembly or separate assembly functions. The main difficulty is portability: assembly written for one processor and operating system usually won’t work on another, so supporting multiple targets means maintaining different implementations. You also have to follow the platform’s ABI and calling convention correctly.
It’s worth experimenting with, especially as a compiler-learning project. Just don’t assume hand-written assembly will automatically be faster. Modern compilers are often better at optimization than beginners, and assembly can make optimization, debugging, register management, and maintenance much harder. A small language that lets users attach target-specific assembly to normal function declarations would be a reasonable and educational design.
You may also want to study Forth-like languages for inspiration. They give programmers a very direct relationship with low-level operations and can be simpler to implement than a full general-purpose compiler. A practical first version could support named functions, typed parameters, an assembly block, and one target architecture before attempting automatic machine-code generation.
What you’re describing is essentially a function definition: write the assembly implementation once, associate it with a name and calling convention, then call that name elsewhere. It could also resemble a macro if the compiler directly substitutes the assembly at each call site. The concept is absolutely possible, but it isn’t fundamentally new. It could still be a great project for learning how parsing, symbol tables, assemblers, linking, and code generation work.
The important distinction is whether the code is called like a normal function or pasted into the caller like a macro. Either way, the compiler needs to know things such as argument locations, return values, registers, and which registers the assembly is allowed to change.