- 142comments
- 49comments
- 42comments
- 458comments
- 180comments
- —discuss
- 36comments
- 51comments
- 13comments
- 552comments
- 28comments
- 117comments
- 5comments
- 132comments
- 192comments
- 14comments
- 108comments
- 301comments
- 360comments
- 24comments
- 18comments
- 89comments
- 23comments
- 11comments
- 51comments
- 44comments
- 122comments
- 7comments
- 280comments
- 4comments
The demo website at https://hlorenzi.github.io/customasm/web/ makes this even more accessible. I can actually follow along as to how this works.
This is very cool! I'm always on the lookout for extensible assemblers. I especially want one that can handle a normalized subset of GNU assembly so that it can be used on the output of LLVM or GCC (using existing assembly languages, but assembling them in non-standard ways or with extensions).
flat assembler g (fasmg) does this. It has a powerful macro language, in which, among other architectures and formats, it implements x86 and ELF/PE/macho and is able to assemble itself.
I like to use it for scripting for turning binary formats to text and vice-versa.
https://github.com/tgrysztar/fasmg
It's also possible to use stock flat assembler (non-g) for this, to some extent. I've done it before here: https://github.com/Rohansi/FPCompo11/blob/master/Assembler/i...
This is very cool. On the topic of assembly, does anyone know of a language that is higher level than assembly, but retains the property that the output doesn't depend on the compiler or its flags?
I want it for low level CPU benchmarks and tests. Using C or assembly for those both suck.
I don't really know exactly how this would look (is the register allocator part of the spec?) but has anyone tried something like this?
That's not an inherent property of assemblers, and not the case in practice either.
Yes I know there are some minor caveats with pseudo-instructions and relocations but in general it is basically true. You can't wildly change the output without changing the source like you can with C.
Have you tried looking into something like NASM's macro functionality?
That sounds like a tall order. If you want it for CPU benchmarks, you presumably want to be able to use all real CPU machine instructions. Or a simpler language instruction set but with an optimizer, but it's hard to write an optimizer and then you could never change the optimizer.
There was a post on HN where someone implemented a new language compiler purely from Assembly, and shows you from nothing to the very end where it looked mostly like a LISP assembly language. It was really neat. Sadly I dont have the buzzwords for Google to find it anymore, used to be able to find the powerpoint slides for it.
I forgot about HLA (High Level Assembly) though I have not used it personally, there were also a few others like C-- as well:
https://en.wikipedia.org/wiki/High_Level_Assembly
something like this: http://web.archive.org/web/20061108010907/http://www.rano.or... ?
Naturally, it is time for some Forth. :)
My complements on this. Assembler is the ultimate understanding and control.
This is great! I did a project just like this one for my Master's thesis at University of Glasgow, although this project looks to be much more mature and advanced (plus it has users!):
https://github.com/markoglasgow/assembler_generator
Is there an ISA for WASM that's faster than RISC-V 64, which is currently 3x faster than x86_64 on x86_64 FWICS? https://github.com/ktock/container2wasm#emscripten-on-browse... demo: https://ktock.github.io/container2wasm-demo/
Interesting. If only it supported little-endian architectures!